@lowdefy/docs-content 7.1.0 → 7.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (51) hide show
  1. package/content/actions/login.md +1 -1
  2. package/content/actions/posthoginit.md +1 -1
  3. package/content/adapter-reference/mongodbauthadapter.md +2 -2
  4. package/content/agents/agents-introduction.md +41 -1
  5. package/content/callback-reference/auth0logoutcallback.md +1 -1
  6. package/content/concepts/ai-agent-docs.md +116 -108
  7. package/content/concepts/blocks.md +1 -1
  8. package/content/concepts/connections-and-requests.md +8 -8
  9. package/content/concepts/custom-html.md +1 -1
  10. package/content/concepts/dynamic-page-content.md +26 -15
  11. package/content/concepts/events-and-actions.md +24 -0
  12. package/content/concepts/logger.md +1 -1
  13. package/content/concepts/lowdefy-api.md +81 -14
  14. package/content/concepts/lowdefy-schema.md +11 -0
  15. package/content/concepts/mobile-apps.md +110 -0
  16. package/content/concepts/page-and-app-state.md +2 -2
  17. package/content/concepts/theming.md +1 -1
  18. package/content/connections/axioshttp.md +1 -1
  19. package/content/connections/mongodb.md +22 -6
  20. package/content/controls/reject.md +2 -2
  21. package/content/deployment/vercel.md +1 -1
  22. package/content/display-blocks/aggrid.md +1 -1
  23. package/content/display-blocks/search.md +86 -2
  24. package/content/display-blocks/table.md +154 -9
  25. package/content/input-blocks/tableinput.md +12 -4
  26. package/content/input-blocks/tiptapinput.md +3 -2
  27. package/content/input-blocks/tiptapmentioninput.md +3 -2
  28. package/content/migration/v3-to-v4.md +2 -2
  29. package/content/operators/_base64.md +2 -2
  30. package/content/operators/_log.md +1 -1
  31. package/content/operators/_ref.md +6 -6
  32. package/content/plugins/plugins-introduction.md +13 -0
  33. package/content/plugins/posthog.md +1 -1
  34. package/content/provider-reference/auth-js-providers.md +2 -2
  35. package/content/provider-reference/openidconnectprovider.md +1 -1
  36. package/content/reference/cli.md +164 -0
  37. package/content/testing/config-tests.md +2 -2
  38. package/content/tutorial/tutorial-create-page.md +1 -1
  39. package/content/tutorial/tutorial-requests-api.md +1 -1
  40. package/content/tutorial/tutorial-requests-sql.md +1 -1
  41. package/content/tutorial/tutorial-start.md +1 -1
  42. package/content/user-authentication/auth-configuration.md +9 -9
  43. package/content/user-authentication/auth-steps.md +4 -2
  44. package/content/user-authentication/organizations.md +57 -0
  45. package/content/user-authentication/protected-pages-apis.md +4 -4
  46. package/content/user-authentication/roles.md +2 -2
  47. package/content/user-authentication/user-object.md +1 -1
  48. package/content/websockets/websocket-publish.md +1 -1
  49. package/content/websockets/websockets-introduction.md +1 -1
  50. package/index.json +72 -57
  51. package/package.json +2 -2
@@ -28,7 +28,7 @@ The `callbackUrl` parameter of the Login action specifies where the user lands a
28
28
 
29
29
  If none of the three resolves - an app with no `homePageId` whose menu offers the signed-out user no page to fall back on - the action throws rather than staying silently on the sign-in page.
30
30
 
31
- To sign in without navigating at all, set `callbackUrl: false`. This is for a login form in a modal or an embedded panel, where the session store re-renders the page with the new user in place. It is not valid for magic-link or social/OAuth sign-in, which redirect through a hop Lowdefy does not control.
31
+ To sign in without navigating at all, set `callbackUrl: false`. This is for a login form in a modal or an embedded panel: the page renders the new user in place, as the server resolves them, before the next action in the chain runs. It is not valid for magic-link or social/OAuth sign-in, which redirect through a hop Lowdefy does not control.
32
32
 
33
33
  A sign-in the auth server rejects - a wrong password, an expired or already-used link, an invalid code - is an expected outcome, not an app error. The action throws a `UserError`: `catch` actions on the event still run and the error message still displays, but it is logged to the browser console only and is never reported to the server. The auth server's response is available to `catch` actions as `_actions.<actionId>.error.metaData`, with a `code` (for example `INVALID_EMAIL_OR_PASSWORD`) and the HTTP `status`. A network failure or a server fault is still thrown as an action error and reported.
34
34
 
@@ -20,7 +20,7 @@ Every event carries the deployment environment: when the app declares [`config.e
20
20
 
21
21
  Events carry Lowdefy semantics. Autocaptured clicks, rage clicks and dead clicks get `lowdefy_page_id`, `lowdefy_block_id`, `lowdefy_block_type`, `lowdefy_block_ids` (every enclosing block, innermost first), `lowdefy_option: true` on a dropdown option, `lowdefy_text` (the text of the control the click reached, such as a button or menu item, even when the click landed on its icon or a wrapper) and, inside a grid, `lowdefy_row` and `lowdefy_column`. Every other event gets `lowdefy_page_id`. This adds properties only, never events, and has no switch. A block with the `ph-no-capture` class is not autocaptured, so it is never enriched.
22
22
 
23
- Click text that shows the app's data never leaves the browser. On every event, a clicked text (`$el_text`, `lowdefy_text`, the `text` entries of `$elements_chain` and `$elements`, `$selected_content` and link targets) is kept only when the config of the page, the menus, the i18n messages or the antd locale spell it out, so grid and table cell values, options and menu items a request fills, labels built from records and `Dynamic` block output are removed, while button titles, menu and tab labels, column headers, literal options and modal __OK__ and __Cancel__ stay. Element attributes other than the tag, classes, `class`, `role`, `type`, `row-index`, `col-id`, `nth-child` and `nth-of-type` are removed, including `title`, `aria-label`, `value`, `placeholder`, `alt` and `data-*`, and `id` is kept only as a block wrapper id (`bl-<blockId>`). Classes and `data-ph-capture-attribute-<name>` values (sent as property `<name>`) are not masked, so never build them from data. The other `lowdefy_*` properties stay, so a click on data still records its block, row and column. URLs are not masked: `$current_url`, `$pathname`, query values and `lowdefy_path_params` are sent unchanged. Set `maskDataText: false` to send full click text, or `options.mask_all_text: true` to send none. A block `class` of `ph-sensitive` masks that block's config text too, but only within the block's own DOM: popups it renders into the page body (`Dropdown` and `DropdownButton` items, table and grid `MenuCell` menus, `Modal`, `Drawer`) are outside it. Session replay is not covered: set `options.session_recording.maskTextSelector: '*'` to mask all text in recordings, or give a block a `class` of `ph-mask`. See [Click text masking](/PostHog#click-text-masking).
23
+ Click text that shows the app's data never leaves the browser. On every event, a clicked text (`$el_text`, `lowdefy_text`, the `text` entries of `$elements_chain` and `$elements`, `$selected_content` and link targets) is kept only when the config of the page, the menus, the i18n messages or the antd locale spell it out, so grid and table cell values, options and menu items a request fills, labels built from records and `Dynamic` block output are removed, while button titles, menu and tab labels, column headers, literal options and modal __OK__ and __Cancel__ stay. Element attributes other than the tag, classes, `class`, `role`, `type`, `row-index`, `col-id`, `data-row-index`, `data-col-key`, `nth-child` and `nth-of-type` are removed, including `title`, `aria-label`, `value`, `placeholder`, `alt` and other `data-*`, and `id` is kept only as a block wrapper id (`bl-<blockId>`). Classes and `data-ph-capture-attribute-<name>` values (sent as property `<name>`) are not masked, so never build them from data. The other `lowdefy_*` properties stay, so a click on data still records its block, row and column. URLs are not masked: `$current_url`, `$pathname`, query values and `lowdefy_path_params` are sent unchanged. Set `maskDataText: false` to send full click text, or `options.mask_all_text: true` to send none. A block `class` of `ph-sensitive` masks that block's config text too, but only within the block's own DOM: popups it renders into the page body (`Dropdown` and `DropdownButton` items, table and grid `MenuCell` menus, `Modal`, `Drawer`) are outside it. Session replay is not covered: set `options.session_recording.maskTextSelector: '*'` to mask all text in recordings, or give a block a `class` of `ph-mask`. See [Click text masking](/PostHog#click-text-masking).
24
24
 
25
25
  When a block or app event fails, `PostHogInit` captures a `lowdefy_event_failed` event with `lowdefy_event_scope` (`page` or `app`), `lowdefy_page_id`, `lowdefy_block_id`, `lowdefy_block_type`, `lowdefy_event_name`, `lowdefy_debounce_ms`, `lowdefy_action_id`, `lowdefy_action_type`, `lowdefy_error_name`, `lowdefy_config_key` and `lowdefy_invalid_blocks` (the blocks a `Validate` found invalid). It carries ids only, never error messages or values, and is timestamped when the event's actions started. Failures in the app's `onInit` and in the first page's `onInit` are captured too, although `PostHogInit` runs later in `onInitAsync`: Lowdefy holds up to 20 failures until PostHog starts. At most 50 are captured per app load, held failures included. Set `captureEventFailures: false` to turn it off.
26
26
 
@@ -18,7 +18,7 @@ If you are upgrading from the old `MongoDBAdapter`: the type is renamed, `databa
18
18
  ###### Minimum configuration.
19
19
 
20
20
  ```yaml
21
- lowdefy: 7.0.0
21
+ lowdefy: 7.1.0
22
22
  auth:
23
23
  database:
24
24
  id: auth_db
@@ -31,7 +31,7 @@ auth:
31
31
  ###### Full configuration.
32
32
 
33
33
  ```yaml
34
- lowdefy: 7.0.0
34
+ lowdefy: 7.1.0
35
35
  auth:
36
36
  database:
37
37
  id: auth_db
@@ -9,7 +9,7 @@ Agents are defined at the root of your Lowdefy configuration, alongside `connect
9
9
  A connection, an agent, and a chat block — that's all you need:
10
10
 
11
11
  ```yaml
12
- lowdefy: 7.0.0
12
+ lowdefy: 7.1.0
13
13
 
14
14
  connections:
15
15
  - id: anthropic
@@ -65,6 +65,7 @@ Agents are defined in the top-level `agents` array in your Lowdefy configuration
65
65
  - `mcp: array`: MCP server tools. See [MCP Tools](/agent-mcp-tools).
66
66
  - `agents: array`: Sub-agent tools. See [Multi-Agent](/agent-multi-agent).
67
67
  - `hooks: object`: Server-side lifecycle hooks. See [Server Hooks](/agent-server-hooks).
68
+ - `redact: object`: Patterns the server masks in the user's messages. See Redacting User Messages below. __Operators are evaluated__.
68
69
 
69
70
  ###### Agent with tools, sub-agents, and hooks:
70
71
  ```yaml
@@ -92,6 +93,45 @@ agents:
92
93
  - save-conversation
93
94
  ```
94
95
 
96
+ ## Redacting User Messages
97
+
98
+ `redact` masks text in the user's messages on the server before anything else sees it: the model, title generation, tools and the [server hooks](/agent-server-hooks) that save the conversation. Use it to keep personal information, like ID numbers or email addresses a user pastes into the chat, away from the AI provider and out of chat history, as data protection laws such as POPIA or GDPR require.
99
+
100
+ - `redact: object`:
101
+ - `patterns: array`: __Required__ - The patterns to mask, at least one. Each is a regular expression string, or an object:
102
+ - `pattern: string`: __Required__ - The regular expression.
103
+ - `name: string`: A name for the pattern. The server's debug log counts replacements by name, never logging the matched text.
104
+ - `flags: string`: Regular expression flags, such as `i`. `g` is always added, so every match is masked. The sticky flag `y` is refused.
105
+ - `replacement: string`: Default: `'[removed]'` - The text each match is replaced with.
106
+
107
+ The server masks the text of every user message, not only the newest: the browser sends the whole conversation with each turn. The model's replies, tool calls and results, and attached files are left as they are. `redact` applies to chat turns: a sub-agent's `redact` is not applied when another agent calls it, and the `CallAgent` routine step does not use it. The chat in the browser still shows what the user typed. A conversation the browser saves through its own endpoints is not masked by `redact`, so mask it in those endpoints too, for example with [`_string.replace`](/_string).
108
+
109
+ The patterns can come from a module var, resolved at build, or from a runtime operator such as `_secret`, evaluated with each request. The build checks a pattern written in the config; a pattern an operator returns is checked when the request runs, and an invalid one fails the turn with a config error. A pattern that matches empty text, such as `\d*`, is refused, since it would put the replacement between every character.
110
+
111
+ Patterns run in the order they are listed, each on the text the ones before it left. Put the longer patterns first: listed before an ID number pattern, a short pattern such as `\d{4}` would split the number into blocks and leave its last digits. Avoid patterns that can match the replacement text itself, like `\w+`.
112
+
113
+ ###### Mask ID numbers, phone numbers and email addresses (POPIA):
114
+ ```yaml
115
+ agents:
116
+ - id: support_agent
117
+ type: ClaudeAgent
118
+ connectionId: anthropic
119
+ properties:
120
+ model: claude-sonnet-4-20250514
121
+ redact:
122
+ replacement: '[removed]'
123
+ patterns:
124
+ - name: email
125
+ pattern: '[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}'
126
+ - name: id_number
127
+ pattern: '\d(?:[ -]?\d){8,}'
128
+ hooks:
129
+ onFinish:
130
+ - save-conversation
131
+ ```
132
+
133
+ A user who types `My ID is 8001015009087, email me at jo@example.com` reaches the model, and the `save-conversation` hook, as `My ID is [removed], email me at [removed]`.
134
+
95
135
  ## Beyond Chat
96
136
 
97
137
  Agents can also run headlessly from [API endpoint routines](/api) using the `CallAgent` step — the agent loops through its tools to completion and the result lands in the routine's `_step` results, no chat UI involved. The step can pass images and documents beside its prompt with `files`. See [Running Agents As A Routine Step](/api) for details.
@@ -16,7 +16,7 @@ To trigger the Auth0 logout, the `Logout` action `callbackUrl.url` param should
16
16
  ###### Configuring Auth0LogoutCallback.
17
17
 
18
18
  ```yaml
19
- lowdefy: 7.0.0
19
+ lowdefy: 7.1.0
20
20
  providers:
21
21
  - id: auth0
22
22
  type: Auth0Provider
@@ -72,6 +72,10 @@ The dev server itself also serves the MCP endpoint over streamable HTTP at `/low
72
72
 
73
73
  The `/lowdefy-docs` tools accept requests from agents and tools on your machine and from the dev app's own pages; a request a browser makes on behalf of another website is refused.
74
74
 
75
+ ## Tool usage log
76
+
77
+ `lowdefy mcp` appends one line per tool call to `~/.lowdefy/tool-calls.jsonl` (under `LOWDEFY_HOME` when that is set): `{ "tool", "app", "ts", "ms", "ok" }`. It records the lifecycle tools and every forwarded dev tool, across all your projects and worktrees, in one file. It holds no arguments and no results, never leaves your machine, and rolls over at 1 MB, keeping one old file as `tool-calls.jsonl.1`. Count calls per tool from it to see which tools your agents use.
78
+
75
79
  ## Working across projects
76
80
 
77
81
  A session can start and query the dev servers of several projects side by side — say, an app and the shared plugin repository it uses. Pass each call the `directory` of the app it is for. Without anything set up, `lowdefy mcp` allows apps in the session's own checkout and its git worktrees; for any other app it asks you first.
@@ -87,37 +91,27 @@ This is a consent check on the tools, not a sandbox: an agent that can run shell
87
91
 
88
92
  The dev server provides these tools:
89
93
 
90
- | Tool | Purpose |
91
- | -------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
92
- | `lowdefy_overview` | Start here — what is installed, counts per kind, and how to use the rest |
93
- | `lowdefy_list_types` | List ALL available types of a kind (blocks, operators, actions, connections, requests) |
94
- | `lowdefy_list_plugins` | Installed plugin packages, including local plugins, and the types each provides |
95
- | `lowdefy_get_schema` | JSON Schema for a specific type — all properties and events |
96
- | `lowdefy_get_examples` | Real YAML usage examples for a block type |
97
- | `lowdefy_get_doc` | A docs page as markdown, by slug or by type name: a Lowdefy docs page, or a page this app's own plugins and modules ship |
98
- | `lowdefy_search_docs` | Search the Lowdefy docs and this app's plugin and module docs. Pages are ranked by how many query words match, title matches first; each hit names its source (`core`, `plugin`, `local-plugin` or `module`), package and version, and `source` narrows the search |
99
- | `lowdefy_search_icons` | Search icon names: semantic names first, then Lucide names, then the names of installed icon sets (qualified). Never invent an icon name |
100
- | `lowdefy_get_plugin_doc` | All the markdown (README, `docs/*.md`) an installed plugin package ships, as one page |
101
- | `lowdefy_build_status` | Current build errors and warnings (with source file locations) plus recent browser runtime errors — call after every edit |
102
- | `lowdefy_check` | Validate the whole app as `lowdefy build` would, without building — every page, and the prod-only checks dev shows as warnings come back as errors. Call before calling a change done |
103
- | `lowdefy_get_page_config` | The fully built config for a page, or its structured build errors |
104
- | `lowdefy_screenshot_page` | PNG screenshot of a rendered page (headless Chromium) for visual verification; `width`, `height` and `colorScheme: "dark"` check a phone layout or dark mode; `urlQuery` opens it at a query string; `pathParams` opens an instance of a page whose [`path`](/page-paths) has placeholders; `steps` (`{"open": "blockId"}`, `click`, `fill`, `select`, `wait`, …) run first so the capture shows an open dropdown, calendar or modal |
105
- | `lowdefy_run_journey` | Drive a page headless through declarative steps (`click`, `fill`, `goto`, `email`, `as`, `expect`, …) and assert state, visibility, text, url, title or email — verify behaviour, not just layout |
106
- | `lowdefy_journey_session` | The recorded dev sessions, or one as a log (one line per interaction with what the app did, e.g. `click save → Validate failed [priority]`), to write journeys from |
107
- | `lowdefy_find_config` | Which yaml file (and line) defines a given page, block, or request id |
108
- | `lowdefy_scaffold_page` | Create a new page yaml file with a canonical minimal structure |
109
- | `lowdefy_app_map` | The whole-app graph: every page, menu, connection, endpoint, and agent in one call |
110
- | `lowdefy_inspect_state` | The LIVE state, request results, and event log of a running page — reads your open browser tab, or runs the page headless |
111
- | `lowdefy_eval_operator` | Evaluate any operator expression against live page state — a REPL for config |
112
- | `lowdefy_run_request` | Execute a request with a test payload, as a given `user`, to verify data shape (read-only unless opted in) |
113
- | `lowdefy_run_endpoint` | Execute an Api endpoint routine with a test payload, as a given `user` or as a system context (`system: true`), to see what it returns, rejects or throws (needs `allowWriteRequests`; a `:reject` comes back as data) |
114
- | `lowdefy_snapshot_state` | Capture live page state + request responses into a committable checkpoint folder |
115
- | `lowdefy_load_state` | Restore a state checkpoint — headless, or a `?_checkpoint=` URL for manual testing |
116
- | `lowdefy_list_state_checkpoints` | List saved state checkpoints |
117
- | `lowdefy_checkpoint_to_mocks` | Convert a state checkpoint into e2e `mocks.yaml` fixtures |
118
- | `lowdefy_restart` | Restart the dev server process — after editing a local plugin's server-side code, or when `build_status` looks stale. Then call `lowdefy_build_status` with `wait: true`, which answers once the server is back |
119
- | `lowdefy_checkpoint` | Snapshot all config files before risky changes |
120
- | `lowdefy_revert_checkpoint` | Restore config files from a checkpoint |
94
+ | Tool | Purpose |
95
+ | ------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
96
+ | `lowdefy_list_types` | List ALL available types of a kind (blocks, operators, actions, connections, requests); `target: "mobile"` lists the blocks, actions and client operators a native shell carries, for mobile pages |
97
+ | `lowdefy_get_schema` | JSON Schema for a specific type — all properties and events |
98
+ | `lowdefy_get_examples` | Real YAML usage examples for a block type |
99
+ | `lowdefy_get_doc` | A docs page as markdown, by slug or by type name: a Lowdefy docs page, or a page this app's own plugins and modules ship |
100
+ | `lowdefy_search_docs` | Search the Lowdefy docs and this app's plugin and module docs. Pages are ranked by how many query words match, title matches first; each hit names its source (`core`, `plugin`, `local-plugin` or `module`), package and version, and `source` narrows the search |
101
+ | `lowdefy_search_icons` | Search icon names: semantic names first, then Lucide names, then the names of installed icon sets (qualified). Never invent an icon name |
102
+ | `lowdefy_build_status` | Current build errors and warnings (with source file locations) plus recent runtime errors from browsers and phones (`surface: "web"` or `"mobile"`) — call after every edit |
103
+ | `lowdefy_check` | Validate the whole app as `lowdefy build` would, without building — every page, and the prod-only checks dev shows as warnings come back as errors. Call before calling a change done |
104
+ | `lowdefy_get_page_config` | The fully built config for a page, or its structured build errors |
105
+ | `lowdefy_screenshot_page` | PNG screenshot of a rendered page (headless Chromium) for visual verification; `width`, `height` and `colorScheme: "dark"` check a phone layout or dark mode; `urlQuery` opens it at a query string; `pathParams` opens an instance of a page whose [`path`](/page-paths) has placeholders; `steps` (`{"open": "blockId"}`, `click`, `fill`, `select`, `wait`, …) run first so the capture shows an open dropdown, calendar or modal; `device` captures a phone in Lowdefy Dev instead |
106
+ | `lowdefy_run_journey` | Drive a page headless through declarative steps (`click`, `fill`, `goto`, `email`, `as`, `expect`, …) and assert state, visibility, text, url, title or email — verify behaviour, not just layout; `device` runs it on a phone |
107
+ | `lowdefy_journey_session` | The recorded dev sessions, or one as a log (one line per interaction with what the app did, e.g. `click save → Validate failed [priority]`), to write journeys from |
108
+ | `lowdefy_find_config` | Which yaml file (and line) defines a given page, block, or request id |
109
+ | `lowdefy_app_map` | The whole-app graph: every page, menu, connection, endpoint, and agent in one call |
110
+ | `lowdefy_inspect_state` | The LIVE state, request results, and event log of a running page — reads your open browser tab, or runs the page headless; `device` reads a phone (`expression` evaluates an operator expression against that state instead) |
111
+ | `lowdefy_run_request` | Execute a request with a test payload, as a given `user`, to verify data shape (read-only unless opted in) |
112
+ | `lowdefy_run_endpoint` | Execute an Api endpoint routine with a test payload, as a given `user` or as a system context (`system: true`), to see what it returns, rejects or throws (needs `allowWriteRequests`; a `:reject` comes back as data) |
113
+ | `lowdefy_device` | Phones in Lowdefy Dev: `list` the connected phones (each tab id is the `device` the other tools take) and the booted simulators and Android devices, `start` Lowdefy Dev on a simulator or emulator, `inject` a phone's next scan, photo, NFC read, dictated transcript, location, permission answer, push or network state |
114
+ | `lowdefy_restart` | Restart the dev server process — after editing a local plugin's server-side code, or when `build_status` looks stale. Then call `lowdefy_build_status` with `wait: true`, which answers once the server is back |
121
115
 
122
116
  ## Hazards — what the schema cannot tell you
123
117
 
@@ -127,26 +121,9 @@ A hazard is a behaviour of a type that its schema does not show, but that an age
127
121
 
128
122
  Hazards come from two places. Framework-level hazards ship with `@lowdefy/docs-content` (`hazards.json`). Type-attached hazards are declared by the plugin: a block sets `meta.hazards`, a request sets `meta.hazards` on the request function, and an operator package exports a `./metas` module with `{ hazards }` per operator — see [Plugins](/plugins-introduction). Local plugins in your project use the same channel, so your own blocks can warn an agent about their own surprises.
129
123
 
130
- ## Annotate your app — point, draw, copy, paste
131
-
132
- Press **Cmd+/** (macOS) or **Ctrl+/** (Windows/Linux) on any page of your running dev app. An overlay appears: hover to highlight blocks, click to select one, draw rectangles/arrows/freehand, type a comment, and batch several annotations. Hitting **Copy** (or just pressing Enter) puts an agent-readable feedback block on your clipboard — each annotation enriched with the **blockId and the exact yaml file and line** that defines it, plus **an annotated PNG screenshot of the page with your drawings on it** (saved under `.lowdefy/annotations/`, its path included in the block so the agent can view it; untick "Include annotated screenshot" to skip).
133
-
134
- Paste it into whichever agent session you want — that explicit paste is also what keeps feedback unambiguous when you run several Claude Code sessions against one dev server. A pasted block looks like:
135
-
136
- ```
137
- Feedback: 1 annotation(s) on page "orders" (/orders) — viewport 1280x800 @2x, scrollY 340
138
-
139
- 1. Element "submit_button" (pages/orders.yaml:42)
140
- Ancestors: submit_button > order_form
141
- Comment: Disable this while the form is submitting
142
- Shapes: 1 rect around the element
143
- ```
144
-
145
- Esc cancels; the overlay never ships to production servers. The `/lowdefy-feedback` route prefix is reserved in dev.
146
-
147
124
  ## Open code — Option/Alt+click jumps to the yaml
148
125
 
149
- Hold **Option** (macOS) or **Alt** (Windows/Linux) and click any element in your running dev app to open the yaml that defines its block in VS Code, at the exact line. While the modifier is held, the block under the cursor shows a blue highlight with its blockId — the same picking affordance as the annotation overlay — and the cursor becomes a pointer, so you see exactly what a click will open. The dev server resolves the clicked element to its block and looks up the config source the same way annotations do — blocks inside lists resolve to the item block that defines them (runtime array indices fold back to the config's `$` placeholder), other runtime-generated blocks resolve to their nearest configured ancestor, and blocks defined in modules open the module file that defines them. Plain clicks, Option/Alt+clicks outside any block, and Cmd/Ctrl+clicks (the browser's open-in-new-tab) keep their normal behaviour. Dev server only.
126
+ Hold **Option** (macOS) or **Alt** (Windows/Linux) and click any element in your running dev app to open the yaml that defines its block in VS Code, at the exact line. While the modifier is held, the block under the cursor shows a blue highlight with its blockId — and the cursor becomes a pointer, so you see exactly what a click will open. The dev server resolves the clicked element to its block and looks up the config source of its block — blocks inside lists resolve to the item block that defines them (runtime array indices fold back to the config's `$` placeholder), other runtime-generated blocks resolve to their nearest configured ancestor, and blocks defined in modules open the module file that defines them. Plain clicks, Option/Alt+clicks outside any block, and Cmd/Ctrl+clicks (the browser's open-in-new-tab) keep their normal behaviour. Dev server only.
150
127
 
151
128
  ## The feedback loop
152
129
 
@@ -209,21 +186,18 @@ The check reads the nearest `AGENTS.md` or `CLAUDE.md` holding the block, from t
209
186
 
210
187
  ## Live state — the agent sees what you see
211
188
 
212
- When you have a page open in your browser, the agent can read its **actual live state** — page state, request results, and the event log of recent actions — via `lowdefy_inspect_state`. Reproduce a problem by clicking through the app, then ask the agent to look: it inspects your exact tab, not a guess. `lowdefy_eval_operator` then evaluates any operator expression (like `{"_state": "customer.name"}`) against that same live context, so `_state`/`_request` binding bugs get debugged against real data. With no tab open, both tools run the page headless instead.
189
+ When you have a page open in your browser, the agent can read its **actual live state** — page state, request results, and the event log of recent actions — via `lowdefy_inspect_state`. Reproduce a problem by clicking through the app, then ask the agent to look: it inspects your exact tab, not a guess. Pass `expression` (like `{"_state": "customer.name"}`) and the same tool evaluates that operator expression against the live context instead, returning `{ value, errors, source, reads }`, where `reads` names the state, request and other paths the expression read — so `_state`/`_request` binding bugs get debugged against real data. With no tab open, it runs the page headless instead.
213
190
 
214
191
  ## Pages with path parameters
215
192
 
216
- A page whose [`path`](/page-paths) has placeholders, such as `tickets/{space}/{ticket_id}`, has one instance per set of values, each with its own state and requests. `lowdefy_app_map` shows each page's `path`, and `lowdefy_overview` lists the pages that have placeholders. The tools that open or read a page take `pathParams`, an object with one value per placeholder, next to `pageId` and `urlQuery`:
193
+ A page whose [`path`](/page-paths) has placeholders, such as `tickets/{space}/{ticket_id}`, has one instance per set of values, each with its own state and requests. `lowdefy_app_map` shows each page's `path`. The tools that open or read a page take `pathParams`, an object with one value per placeholder, next to `pageId` and `urlQuery`:
217
194
 
218
195
  ```json
219
196
  { "pageId": "ticket", "pathParams": { "space": "support", "ticket_id": "1234" } }
220
197
  ```
221
198
 
222
- - **Headless** (`lowdefy_screenshot_page`, `lowdefy_inspect_state`, `lowdefy_eval_operator`, `lowdefy_snapshot_state`, `lowdefy_run_journey`): `pathParams` is required to open a page that has placeholders. A missing placeholder is an error that names it, returned before a browser opens.
223
- - **Your open tab** (`lowdefy_inspect_state`, `lowdefy_eval_operator`, `lowdefy_snapshot_state`): with `pathParams`, the tool reads that instance. With only a `pageId`, it reads the instance your tab shows for that page, or the instance of that page most recently shown when no tab is on it.
224
- - **Checkpoints**: `lowdefy_snapshot_state` keeps the instance's `pathParams` next to `urlQuery`, and `lowdefy_load_state` opens that instance.
225
- - **Plain HTTP routes**: the screenshot, page-config and inspect-state routes take a page id with several segments, the GET routes take `pathParams` as JSON in the query (`?pathParams={"ticket_id":"1"}`), and the POST routes as an object in the body.
226
- - **Annotations** from the in-page feedback overlay carry the `pathParams` of the instance they were made on.
199
+ - **Headless** (`lowdefy_screenshot_page`, `lowdefy_inspect_state`, `lowdefy_run_journey`): `pathParams` is required to open a page that has placeholders. A missing placeholder is an error that names it, returned before a browser opens.
200
+ - **Your open tab** (`lowdefy_inspect_state`): with `pathParams`, the tool reads that instance. With only a `pageId`, it reads the instance your tab shows for that page, or the instance of that page most recently shown when no tab is on it.
227
201
 
228
202
  A headless capture waits for the page's full async lifecycle before it reads anything: `onInit`, `onInitAsync`, `onMount` and `onMountAsync`, every in-flight request, and the first message on each websocket subscription. A page whose data arrives through an `onMountAsync` `Request` action is therefore captured with its data, not empty. If a page has not settled within 15 seconds the result is still returned, carrying `ready: false` and a note — read that result as a snapshot of a page that was still loading, not as the page's settled state. One case escapes the wait: an event with a `debounce` is not yet marked loading during its delay, so a debounced `onMountAsync` can be captured before it runs.
229
203
 
@@ -231,7 +205,7 @@ A headless capture waits for the page's full async lifecycle before it reads any
231
205
 
232
206
  The headless renderer behind `lowdefy_screenshot_page` and `lowdefy_inspect_state` authenticates as a signed-in user, so pages with `auth.public: false` render for the agent instead of bouncing to the sign-in page. That default user carries **no roles**, so a page or request gated on a role still comes back refused or empty.
233
207
 
234
- To act as a specific caller, pass `user` — every tool that renders a page headless accepts it (`lowdefy_screenshot_page`, `lowdefy_run_journey`, `lowdefy_inspect_state`, `lowdefy_eval_operator`, `lowdefy_load_state`), as do `lowdefy_run_request` and `lowdefy_run_endpoint`:
208
+ To act as a specific caller, pass `user` — every tool that renders a page headless accepts it (`lowdefy_screenshot_page`, `lowdefy_run_journey`, `lowdefy_inspect_state`), as do `lowdefy_run_request` and `lowdefy_run_endpoint`:
235
209
 
236
210
  ```json
237
211
  { "pageId": "users", "user": { "roles": ["admin"] } }
@@ -251,30 +225,10 @@ Every one of these tools takes `user` in the same three forms:
251
225
 
252
226
  A data set user name without `data` is refused, as are a data set while a dev mock user is active and `"none"` on a data set while auth is configured. `lowdefy_run_endpoint` also takes `system: true`, which cannot be combined with `user`.
253
227
 
254
- `user` applies to the headless renderer only — it is never applied to a page you open in your own browser, which carries your real session and cannot be re-identified. `lowdefy_inspect_state` and `lowdefy_eval_operator` normally prefer your open tab, so passing `user` selects the headless source instead; combining it with `source: "tab"` is an error rather than a silently ignored role, as is combining it with `lowdefy_load_state`'s `mode: "registry-only"` (that mode hands you a URL to open yourself). The plain HTTP routes take the same params: `?user={"roles":["admin"]}` (or `?user=member&data=crm`, or `?user=none`) on the GET routes, a `user` key in the body of `POST /lowdefy-docs/journey`, `POST /lowdefy-docs/eval-operator`, `POST /lowdefy-docs/state-checkpoints/load`, `POST /lowdefy-docs/run-request` and `POST /lowdefy-docs/run-endpoint`. They answer a malformed or contradictory `user` with a `400`, distinct from the `502` a failed render returns.
228
+ `user` applies to the headless renderer only — it is never applied to a page you open in your own browser, which carries your real session and cannot be re-identified. `lowdefy_inspect_state` normally prefers your open tab, so passing `user` selects the headless source instead; combining it with `source: "tab"` is an error rather than a silently ignored role.
255
229
 
256
230
  To bypass login for the whole dev server — your own browser included — start it with a mock user instead: `lowdefy dev --mock-user '{"id":"dev","roles":["admin"]}'` (or configure `auth.dev.mockUser`). See [Auth Configuration](/auth-configuration#mock-user-for-testing-dev-server-only).
257
231
 
258
- ## State checkpoints — put the app in a known state
259
-
260
- `lowdefy_snapshot_state` captures a moment — page state plus every request's recorded response — into a folder you can commit:
261
-
262
- ```
263
- checkpoints/broken-refund-flow/
264
- checkpoint.json # manifest
265
- state.json
266
- urlQuery.json
267
- pathParams.json # the instance's path values, {} for a page without placeholders
268
- requests/
269
- get_order.json # one file per request — easy to review and edit
270
- ```
271
-
272
- Loading it back (`lowdefy_load_state`) opens the instance the checkpoint was taken on, serves the recorded request data from the dev server and re-injects the page state. Three ways to use it:
273
-
274
- - **Agent verification**: the agent restores a scenario headless and confirms its fix works against the exact data that caused the bug.
275
- - **Manual testing**: `mode: registry-only` returns a URL like `http://localhost:3000/orders?_checkpoint=broken-refund-flow` — open it and the app is in that state, no clicking required.
276
- - **e2e fixtures**: `lowdefy_checkpoint_to_mocks` converts a checkpoint into `mocks.yaml` entries for [e2e tests](/e2e-introduction), so "write an e2e test for this flow" starts from captured reality.
277
-
278
232
  ## Running requests safely
279
233
 
280
234
  `lowdefy_run_request` executes a request with a test payload so the agent can verify the data shape a page will receive. Read-only request types (like `MongoDBFind`) always run. The page is built first when it changed since its last build, so the request that runs is the one in the config now; a page that fails to build answers `refused: true` with its `buildErrors`.
@@ -291,7 +245,7 @@ cli:
291
245
 
292
246
  ## Running endpoints
293
247
 
294
- `lowdefy_run_endpoint` (or `POST /lowdefy-docs/run-endpoint`) executes an `Api` endpoint routine headlessly with a test payload, so the agent can verify what a routine returns, rejects or throws without clicking through the page that calls it:
248
+ `lowdefy_run_endpoint` executes an `Api` endpoint routine headlessly with a test payload, so the agent can verify what a routine returns, rejects or throws without clicking through the page that calls it:
295
249
 
296
250
  ```json
297
251
  { "endpointId": "create_order", "payload": { "sku": "A1" }, "user": { "roles": ["admin"] } }
@@ -367,8 +321,8 @@ A **target** is a `blockId` string, or an object that narrows the search to a co
367
321
  | Target key | Meaning |
368
322
  | ---------- | ------------------------------------------------------------------------------------------------------------------------------------ |
369
323
  | `blockId` | The block to search inside |
370
- | `row` | A grid row, zero-based as displayed (`AgGrid*` blocks, `.ag-row[row-index]`); needs `blockId` |
371
- | `column` | A grid cell in that row, by the column's `field` or `colId` (`.ag-cell[col-id]`); needs `blockId` |
324
+ | `row` | A grid row, zero-based as displayed (`AgGrid*`, `Table`, `TableInput`); needs `blockId` |
325
+ | `column` | A grid cell in that row, by the column's `field`, `colId` or `key`; needs `blockId` |
372
326
  | `text` | The visible interactive control whose text is exactly this — a button label, a tab, a menu item (`"Cat"` never matches `"Category"`) |
373
327
  | `nth` | When several elements match, the zero-based one to use |
374
328
 
@@ -476,6 +430,75 @@ To test auth itself — sign-up, email verification, sign-in, invitations, organ
476
430
 
477
431
  Journeys are also the file format of `tests/journeys/`, which `lowdefy test` runs through this same route — write the journey the agent used to verify a change, and it becomes the regression test for it.
478
432
 
433
+ ## Phones — the same tools on Lowdefy Dev
434
+
435
+ An app's mobile pages run in Lowdefy Dev, on an iPhone simulator, an Android emulator or a real phone (`lowdefy dev --ios`, `--android` or `--lan`). Lowdefy Dev joins the dev server as a tab, as a browser tab does, so the agent reaches it with the tools it already uses: pass a phone's tab id as `device`. The phone is used as it is — on the page it shows, signed in as whoever signed in on it, against the app's real database — so `user`, `data` and the headless browser's options (`width`, `urlQuery`, …) do not apply, and a tool given a page the phone does not show says which page it does show. Steps run on the phone by block id through the engine, the way the block's own view runs them: `click`, `fill`, `select` (an option by its text), `press` (`Enter`, on the input filled last), `wait`, `screenshot` and `expect` with `state`. Any other step is refused before the first one runs.
436
+
437
+ `lowdefy_device` with `action: "list"` names the phones connected now, and the simulators and Android devices on this computer:
438
+
439
+ ```json
440
+ {
441
+ "phones": [
442
+ {
443
+ "device": "6f1c…",
444
+ "platform": "ios",
445
+ "app": "com.lowdefy.dev",
446
+ "shell": "7.1.0",
447
+ "paired": false,
448
+ "pageId": "ticket",
449
+ "pathParams": {}
450
+ }
451
+ ],
452
+ "simulators": [{ "udid": "A1B2…", "name": "iPhone 16", "runtime": "iOS-18-2" }],
453
+ "android": [],
454
+ "unavailable": []
455
+ }
456
+ ```
457
+
458
+ `lowdefy_device` with `action: "start"` and `platform: "ios"` or `"android"` opens Lowdefy Dev on this dev server, as `lowdefy dev --ios` or `--android` does: it boots a simulator (or uses the booted one), or finds an Android phone on USB or starts the first emulator, installs the build `LOWDEFY_DEV_APP_IOS` or `LOWDEFY_DEV_APP_ANDROID` names, opens it, and returns the new phone's `device` once it joins:
459
+
460
+ ```json
461
+ { "action": "start", "platform": "ios" }
462
+ ```
463
+
464
+ `lowdefy_screenshot_page` with `device` runs its `steps` on the phone, then captures the whole screen — system dialogs and alerts included — with `xcrun simctl io` on a simulator or `adb exec-out screencap` on an Android device. A phone paired over the network, or one the tools cannot reach (several simulators booted, a tool missing), is captured by Lowdefy Dev from the app's own view instead. The result's `capture` says which (`simctl`, `adb` or `view`), with a `note` why for `view`:
465
+
466
+ ```json
467
+ { "pageId": "ticket", "device": "6f1c…", "steps": [{ "click": "assign" }] }
468
+ ```
469
+
470
+ `lowdefy_run_journey` with `device` runs a journey on the phone and returns the browser journey's result — `passed`, the step log, a `failure` with expected and actual, the phone's final state and the screenshots:
471
+
472
+ ```json
473
+ {
474
+ "pageId": "ticket",
475
+ "device": "6f1c…",
476
+ "steps": [
477
+ { "fill": { "blockId": "note", "value": "Called the customer" } },
478
+ { "click": "save" },
479
+ { "expect": { "state": { "path": "note", "equals": "Called the customer" } } }
480
+ ]
481
+ }
482
+ ```
483
+
484
+ `lowdefy_inspect_state` with `device` reads that phone's live state, as it reads a browser tab (`source: "tab"`), and never falls back to headless. With `expression`, the phone evaluates it against the page it shows:
485
+
486
+ ```json
487
+ { "pageId": "ticket", "device": "6f1c…", "expression": { "_state": "status" } }
488
+ ```
489
+
490
+ `lowdefy_device` with `action: "inject"` fakes the phone's next device result through Lowdefy Dev, which the app's device actions read, so it works on real phones too: `scan` `{ "data" }`, `photo` `{ "base64" }`, `nfc` (the tag read), `location` `{ "latitude", "longitude" }` or a list of them as a route, `permission` with `name` and `"granted"` or `"denied"`, `network` `"online"` or `"offline"`, `push`, and `clear`. On an iOS simulator a location and a permission are also set on the simulator itself (`xcrun simctl location`, `simctl privacy`; iOS may restart the app when a permission changes), and a push — an APNs payload with `aps` — is delivered by `xcrun simctl push`, which Lowdefy Dev cannot yet do itself on other phones:
491
+
492
+ ```json
493
+ {
494
+ "action": "inject",
495
+ "device": "6f1c…",
496
+ "inject": { "kind": "scan", "value": { "data": "JOB-42" } }
497
+ }
498
+ ```
499
+
500
+ `lowdefy_list_types` with `target: "mobile"` lists the blocks, actions and client operators a mobile page can use — the ones the native shell carries, not the app's web plugins — and `lowdefy_build_status` lists a phone's runtime errors beside the browser's, marked `surface: "mobile"` with the shell version.
501
+
479
502
  ## Setting up a project — one command
480
503
 
481
504
  ```bash
@@ -525,38 +548,23 @@ Or register it for every project with `claude mcp add --scope user lowdefy -- np
525
548
 
526
549
  ## Plain HTTP routes
527
550
 
528
- Everything the MCP tools serve is also available as plain GET routes — useful for `curl`, scripts, or agents without MCP support:
529
-
530
- | Route | Purpose |
531
- | ----------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- |
532
- | `GET /lowdefy-docs` | Overview and route index |
533
- | `GET /lowdefy-docs/{kind}` | List all available types of a kind, e.g. `/lowdefy-docs/blocks` |
534
- | `GET /lowdefy-docs/plugins` | Installed plugin packages and the types each provides |
535
- | `GET /lowdefy-docs/schema/{kind}/{type}` | JSON schema for a type, e.g. `/lowdefy-docs/schema/blocks/Button` |
536
- | `GET /lowdefy-docs/examples/{type}` | Example YAML for a block type |
537
- | `GET /lowdefy-docs/content/{slug}` | A docs page as markdown, e.g. `/lowdefy-docs/content/operators/_get` |
538
- | `GET /lowdefy-docs/search?q={query}` | Search the docs |
539
- | `GET /lowdefy-docs/plugin-doc/{package}` | Markdown shipped inside a plugin package |
540
- | `GET /lowdefy-docs/build-status` | Current build errors/warnings + recent browser runtime errors |
541
- | `GET /lowdefy-docs/events` | SSE stream of `restart`, `build`, `client_error` and `server_error` events |
542
- | `GET /lowdefy-docs/page-config/{pageId}` | Fully built page config, or its build errors |
543
- | `GET /lowdefy-docs/screenshot/{pageId}` | PNG screenshot of the rendered page; `?viewportWidth=390&viewportHeight=844&colorScheme=dark` sets the viewport and colour scheme |
544
- | `POST /lowdefy-docs/journey` | Drive a page headless through declarative steps and assert what happens; screenshots returned as base64 |
545
- | `GET /lowdefy-docs/find/{id}?pageId=` | Locate where a page/block/request id is defined |
546
- | `GET /lowdefy-docs/app-map` | Whole-app graph: pages, menus, connections, endpoints, agents |
547
- | `GET /lowdefy-docs/inspect-state/{pageId}` | Live state/requests/eventLog of a running page (tab or headless) |
548
- | `POST /lowdefy-docs/eval-operator` | Evaluate an operator expression against live page state |
549
- | `POST /lowdefy-docs/run-request` | Execute a request with a test payload (read-only unless opted in) |
550
- | `POST /lowdefy-docs/run-endpoint` | Execute an Api endpoint routine with a test payload and caller (needs `allowWriteRequests`; rejects return as data) |
551
- | `GET/POST /lowdefy-docs/checkpoints` + `/revert` | Config-file checkpoints |
552
- | `GET/POST /lowdefy-docs/state-checkpoints` + `/snapshot`, `/load` | State & data checkpoints |
553
- | `POST /lowdefy-docs/restart` | Restart the dev server process (`{reason}` optional; then `build-status?wait=true` answers once it is back) |
551
+ MCP is the agent interface. A few plain routes remain for the CLI, the dev app and scripts; the rest of the tools have no HTTP route:
552
+
553
+ | Route | Purpose |
554
+ | ---------------------------------------- | ----------------------------------------------------------------------------------------------------------- |
555
+ | `GET /lowdefy-docs` | Overview and route index |
556
+ | `GET /lowdefy-docs/build-status` | Current build errors/warnings + recent browser runtime errors |
557
+ | `GET /lowdefy-docs/events` | SSE stream of `restart`, `build`, `client_error` and `server_error` events |
558
+ | `GET /lowdefy-docs/page-config/{pageId}` | Fully built page config, or its build errors |
559
+ | `POST /lowdefy-docs/journey` | Drive a page headless through declarative steps and assert what happens; screenshots returned as base64 |
560
+ | `GET /lowdefy-docs/find/{id}?pageId=` | Locate where a page/block/request id is defined |
561
+ | `POST /lowdefy-docs/restart` | Restart the dev server process (`{reason}` optional; then `build-status?wait=true` answers once it is back) |
554
562
 
555
563
  ## Local plugins
556
564
 
557
565
  Your project's own plugins (declared under `plugins:` in `lowdefy.yaml`) are included automatically:
558
566
 
559
- - Types appear in `lowdefy_list_types` and `/lowdefy-docs/{kind}` listings.
567
+ - Types appear in `lowdefy_list_types` listings.
560
568
  - Block schemas are derived from each block's `meta`, and connection/request schemas from the `schema` property on your connection and request definitions.
561
569
  - Ship a `gallery.yaml` or `examples.yaml` next to a block in your plugin's `dist/blocks/{BlockName}/` and it is served by `lowdefy_get_examples`.
562
570
  - A `README.md` and `docs/*.md` files in your plugin package are searched by `lowdefy_search_docs` and read with `lowdefy_get_doc` (`plugins/<package>` for the README, `plugins/<package>/<file>` for a docs file). A docs file named after a type, such as `docs/MyBlock.md`, is the doc `lowdefy_get_doc` returns for that type. `lowdefy_get_plugin_doc` returns them all as one page.
@@ -35,7 +35,7 @@ Lowdefy has a set of default block types as defined in the Lowdefy docs. Most of
35
35
 
36
36
  ###### Default block type config example:
37
37
  ```yaml
38
- lowdefy: 7.0.0
38
+ lowdefy: 7.1.0
39
39
  pages:
40
40
  - id: example_dashboard
41
41
  type: PageHeaderMenu
@@ -22,7 +22,7 @@ The schema for a Lowdefy connection is:
22
22
 
23
23
  ###### Connections definition example:
24
24
  ```yaml
25
- lowdefy: 7.0.0
25
+ lowdefy: 7.1.0
26
26
  connections:
27
27
  - id: connection1
28
28
  type: ConnectionType1
@@ -100,7 +100,7 @@ _request: my_request
100
100
 
101
101
  ###### lowdefy.yaml
102
102
  ```yaml
103
- lowdefy: 7.0.0
103
+ lowdefy: 7.1.0
104
104
 
105
105
  connections:
106
106
  - id: connection1
@@ -142,7 +142,7 @@ To create this `connection`, define the connection as follows in the `lowdefy.ya
142
142
 
143
143
  ###### lowdefy.yaml
144
144
  ```yaml
145
- lowdefy: 7.0.0
145
+ lowdefy: 7.1.0
146
146
 
147
147
  connections:
148
148
  - id: my_api
@@ -159,7 +159,7 @@ To use this connection, a `request` must be defined, which references the corres
159
159
 
160
160
  ###### lowdefy.yaml
161
161
  ```yaml
162
- lowdefy: 7.0.0
162
+ lowdefy: 7.1.0
163
163
 
164
164
  connections:
165
165
  - id: my_api
@@ -183,7 +183,7 @@ This request should be called when the page is mounted. To do this, the [`Reques
183
183
 
184
184
  ###### lowdefy.yaml
185
185
  ```yaml
186
- lowdefy: 7.0.0
186
+ lowdefy: 7.1.0
187
187
 
188
188
  connections:
189
189
  - id: my_api
@@ -214,7 +214,7 @@ In this example, a [`Selector`](/Selector) block will be added. The [`_array.map
214
214
 
215
215
  ###### lowdefy.yaml
216
216
  ```yaml
217
- lowdefy: 7.0.0
217
+ lowdefy: 7.1.0
218
218
 
219
219
  connections:
220
220
  - id: my_api
@@ -259,7 +259,7 @@ To do this, create a new request that will make use of a `payload` to get the po
259
259
 
260
260
  ###### lowdefy.yaml
261
261
  ```yaml
262
- lowdefy: 7.0.0
262
+ lowdefy: 7.1.0
263
263
 
264
264
  connections:
265
265
  - id: my_api
@@ -321,7 +321,7 @@ This is done as follows:
321
321
 
322
322
  ###### lowdefy.yaml
323
323
  ```yaml
324
- lowdefy: 7.0.0
324
+ lowdefy: 7.1.0
325
325
 
326
326
  connections:
327
327
  - id: my_api
@@ -25,7 +25,7 @@ To add [Google Analytics](/https://developers.google.com/analytics/devguides/col
25
25
 
26
26
  ```yaml
27
27
  name: google-analytics-example
28
- lowdefy: 7.0.0
28
+ lowdefy: 7.1.0
29
29
  # ...
30
30
  app:
31
31
  html: