@lowdefy/server-dev 0.0.0-experimental-20260906143808 → 0.0.0-experimental-20260908103554

package/lib/client/auth/AuthConfigured.jsx

@@ -18,6 +18,7 @@ import React, { useEffect, useRef, useState } from 'react';
 import { createAuthClient } from 'better-auth/react';
 import {
   adminClient,
+  emailOTPClient,
   magicLinkClient,
   organizationClient,
   phoneNumberClient,
@@ -44,6 +45,7 @@ const authClient = createAuthClient({
   baseURL: `${window.location.origin}${lowdefyConfig.basePath ?? ''}/api/auth`,
   plugins: [
     adminClient(),
+    emailOTPClient(),
     magicLinkClient(),
     oauthProviderClient(),
     organizationClient(),
@@ -57,8 +59,8 @@ const authClient = createAuthClient({
 // signal-driven refetch on the calls that would otherwise fire one, so
 // nothing competes with (and aborts) the refetch UpdateSession awaits.
 // Only calls that mutate an existing session are suppressed - calls that
-// can establish one (the sign-ins, and the two-factor, phone-number and
-// passkey verifies) keep their signal: its refetch is what makes the store
+// can establish one (the sign-ins, and the two-factor, phone-number,
+// email-otp and passkey verifies) keep their signal: its refetch is what makes the store
 // notice a login when no navigation follows.
 // disableSignal silences all atomListeners for the call, including the
 // organization plugin's org atoms - none are exposed to app config, so a
@@ -193,6 +195,9 @@ function AuthConfigured({ authConfig, children, serverUser }) {
     // oauth_query contract as oauth2Consent: the signed query rides from
     // window.location.search, so the call must run before any navigation.
     oauth2Continue: (params) => authClient.oauth2.continue(params),
+    // The one-time email code: send, then sign in with it.
+    emailOtpSend: (params) => authClient.emailOtp.sendVerificationOtp(params),
+    emailOtpVerify: (params) => authClient.signIn.emailOtp(params),
     phoneNumberRequestPasswordReset: (params) =>
       authClient.phoneNumber.requestPasswordReset(params),
     phoneNumberResetPassword: (params) => authClient.phoneNumber.resetPassword(params),

package/lib/client/auth/AuthNotConfigured.js

@@ -39,6 +39,8 @@ function AuthNotConfigured({ authConfig, children, user = null }) {
     listOrganizations: authNotConfigured,
     oauth2Consent: authNotConfigured,
     oauth2Continue: authNotConfigured,
+    emailOtpSend: authNotConfigured,
+    emailOtpVerify: authNotConfigured,
     phoneNumberRequestPasswordReset: authNotConfigured,
     phoneNumberResetPassword: authNotConfigured,
     phoneNumberSendOtp: authNotConfigured,

package/lib/docs/createDocsMcpServer.js

@@ -445,13 +445,13 @@ function createDocsMcpServer({ origin, honoContext } = {}) {
     'lowdefy_run_journey',
     {
       description:
-        'Drive a page of the running dev server headless through declarative steps and assert what happens — the way to verify behaviour (a form submits, a modal opens, a filter works), not just layout. Blocks are addressed by blockId. A step that fails stops the journey and is returned as data (passed: false, failure with index/step/expected/actual/message, later steps "skipped") — never as a tool error. Always returns the final page state and any screenshots taken (as images after the JSON text).',
+        'Drive a page of the running dev server headless through declarative steps and assert what happens — the way to verify behaviour (a form submits, a modal opens, a filter works), not just layout. Blocks are addressed by blockId; a target object narrows to a grid row/cell ({"blockId": "grid", "row": 1, "column": "actions"}), to the control with exactly some text ({"blockId": "grid", "row": 1, "text": "Edit"}), or reaches portal-rendered controls page-wide by text alone ({"text": "OK"} for a confirm dialog or modal footer button, a menu item). A step that fails stops the journey and is returned as data (passed: false, failure with index/step/expected/actual/message, later steps "skipped") — never as a tool error. Always returns the final page state and any screenshots taken (as images after the JSON text).',
       inputSchema: {
         pageId: z.string().describe('The page id to open.'),
         steps: z
           .array(z.record(z.any()))
           .describe(
-            'Ordered steps, one key each: {"click": blockId} | {"fill": {"blockId", "value"}} | {"select": {"blockId", "value"}} (option by exact text) | {"press": "Enter" | "Mod+k"} (Mod is Meta/Control per platform) | {"wait": {"ms": n} | {"request": requestId} | {"state": path}} | {"screenshot": name?} | {"expect": {"state": {"path", "equals"}} | {"visible": blockId} | {"text": {"blockId", "contains"}} | {"url": {"contains"}}}. Each step gets 5s; after an interaction the runner waits for the page\'s pending events and requests to settle.'
+            'Ordered steps, one key each: {"click": target} | {"fill": {...target, "value"}} | {"select": {...target, "value"}} (option by exact text) | {"press": "Enter" | "Mod+k"} (Mod is Meta/Control per platform) | {"wait": {"ms": n} | {"request": requestId} | {"state": path}} | {"screenshot": name?} | {"expect": {"state": {"path", "equals"}} | {"visible": target} | {"text": {...target, "contains"}} | {"url": {"contains"}}}. A target is a blockId string, or an object of {"blockId", "row" (zero-based grid row as displayed), "column" (grid col-id), "text" (exact text of the interactive control to use), "nth" (zero-based pick among several matches)}; "text" without "blockId" searches the whole page, which is how confirm dialog / modal footer buttons and dropdown menu items are reached. fill, select and expect.text need a blockId. Each step gets 5s; after an interaction the runner waits for the page\'s pending events and requests to settle.'
           ),
         user: userSchema,
         urlQuery: z

package/lib/docs/getOverview.js

@@ -71,7 +71,7 @@ function getOverview() {
     '   Or subscribe instead of polling: `GET /lowdefy-docs/events` streams `build`, `client_error`, `server_error` and `restart` events over SSE (MCP clients receive the same as `notifications/message` from logger `lowdefy`).',
     '2. **Verify the page**: `GET /lowdefy-docs/page-config/{pageId}` — or `lowdefy_get_page_config`. The fully built page config, or its structured build errors.',
     '3. **See it rendered**: `GET /lowdefy-docs/screenshot/{pageId}` — or `lowdefy_screenshot_page`. PNG of the page in headless Chromium.',
-    '4. **Verify behaviour**: `POST /lowdefy-docs/journey` `{pageId, steps, user, urlQuery}` — or `lowdefy_run_journey`. Drive the page headless with declarative steps (`click`, `fill`, `select`, `press`, `wait`, `screenshot`, `expect: { state | visible | text | url }`, blocks addressed by blockId) and assert what happens. A failing step stops the journey and returns `passed: false` with `failure: { index, step, expected, actual, message }` and the final page `state` — data, not an error.',
+    '4. **Verify behaviour**: `POST /lowdefy-docs/journey` `{pageId, steps, user, urlQuery}` — or `lowdefy_run_journey`. Drive the page headless with declarative steps (`click`, `fill`, `select`, `press`, `wait`, `screenshot`, `expect: { state | visible | text | url }`) and assert what happens. Targets are a blockId, or `{ blockId, row, column, text, nth }` to reach the button in a grid cell, a control by its exact text, or — with `text` alone — a confirm dialog / modal footer button rendered outside every block. A failing step stops the journey and returns `passed: false` with `failure: { index, step, expected, actual, message }` and the final page `state` — data, not an error.',
     '5. **Locate config**: `GET /lowdefy-docs/find/{id}?pageId=...` — or `lowdefy_find_config`. Which yaml file defines a page/block/request id.',
     '6. **Scaffold**: `lowdefy_scaffold_page` creates a canonical new page file (then register it in lowdefy.yaml).',
     '',

package/lib/docs/runJourney.js

@@ -68,18 +68,23 @@ function cleanMessage(error) {
 // Wraps a Playwright interaction so a locator that never became actionable
 // (missing block, hidden, disabled, detached) reads as "expected the block
 // to be actionable, actual: <Playwright's message>" instead of a bare error.
-async function actOnBlock({ blockId, action }) {
+async function actOnTarget({ target, action }) {
   try {
     await action();
   } catch (error) {
     const actual = cleanMessage(error);
-    throw new JourneyStepError(`Block "${blockId}" was not actionable: ${actual}`, {
-      expected: `block "${blockId}" to be actionable`,
+    const description = describeTarget(target);
+    throw new JourneyStepError(`${capitalise(description)} was not actionable: ${actual}`, {
+      expected: `${description} to be actionable`,
       actual,
     });
   }
 }
 
+function capitalise(text) {
+  return text.charAt(0).toUpperCase() + text.slice(1);
+}
+
 // The #bl-<id> wrapper spans the full row while the control inside it (an
 // antd button, a link, a checkbox) is usually narrower, so a click at the
 // wrapper's centre can land beside the control. The block's own e2e helpers
@@ -99,40 +104,156 @@ const INTERACTIVE_CONTROL = [
   '[role="menuitem"]',
 ].join(', ');
 
-async function resolveClickTarget(block) {
-  const control = block.locator(INTERACTIVE_CONTROL).first();
+async function resolveClickTarget(scope) {
+  const control = scope.locator(INTERACTIVE_CONTROL).first();
   if ((await control.count()) > 0) {
     return control;
   }
-  return block;
+  return scope;
+}
+
+// Exact match on a control's or option's text: a regex anchored at both ends,
+// so "Cat" does not pick "Category".
+function exactText(value) {
+  return new RegExp(`^\\s*${value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*$`);
+}
+
+// A step's target is a blockId string or an object narrowing the search (see
+// validateJourneySteps). The string form is the object form with only blockId.
+function normaliseTarget(target) {
+  if (type.isString(target)) {
+    return { blockId: target };
+  }
+  return target;
+}
+
+// Reads back the way an author thinks of it — `block "grid" row 1 control
+// "Edit"` — for the expected/actual pair of a failed step.
+function describeTarget(target) {
+  const parts = [];
+  if (!type.isUndefined(target.blockId)) {
+    parts.push(`block "${target.blockId}"`);
+  }
+  if (!type.isUndefined(target.row)) {
+    parts.push(`row ${target.row}`);
+  }
+  if (!type.isUndefined(target.column)) {
+    parts.push(`column "${target.column}"`);
+  }
+  if (!type.isUndefined(target.text)) {
+    parts.push(`control "${target.text}"`);
+  }
+  if (!type.isUndefined(target.nth)) {
+    parts.push(`nth ${target.nth}`);
+  }
+  return parts.join(' ');
+}
+
+function attributeValue(value) {
+  return `"${String(value).replace(/["\\]/g, '\\$&')}"`;
+}
+
+// The element the target's scope keys name: the block wrapper, narrowed to a
+// grid row (`.ag-row[row-index]`, the row as displayed, which ag-grid renders
+// once per pinned/centre column container) and to a cell (`.ag-cell[col-id]`,
+// the column's field or colId). Undefined for a page-wide `text` target,
+// which has no scope narrower than the page.
+function resolveScope({ page, target }) {
+  if (type.isUndefined(target.blockId)) {
+    return undefined;
+  }
+  let scope = getBlock(page, target.blockId);
+  if (!type.isUndefined(target.row)) {
+    scope = scope.locator(`.ag-row[row-index=${attributeValue(target.row)}]`);
+  }
+  if (!type.isUndefined(target.column)) {
+    scope = scope.locator(`.ag-cell[col-id=${attributeValue(target.column)}]`);
+  }
+  return scope;
+}
+
+// Portal layers, front-most first. A control found by text alone is looked
+// for in the front-most open layer before the page, the way a person reads a
+// screen: an open dropdown menu covers a dialog, a dialog covers the page. A
+// confirm dialog's "Delete" is then found over the grid's "Delete" cell
+// buttons behind its mask, without the author counting buttons.
+const LAYERS = ['[role="menu"]', '[role="dialog"]'];
+
+function controlsWithText({ root, text, nth }) {
+  return root
+    .locator(INTERACTIVE_CONTROL)
+    .filter({ hasText: exactText(text) })
+    .filter({ visible: true })
+    .nth(nth ?? 0);
+}
+
+async function resolvePageWideText({ page, target }) {
+  for (const layer of LAYERS) {
+    const open = page.locator(layer).filter({ visible: true });
+    if ((await open.count()) > 0) {
+      const inLayer = controlsWithText({ root: open.last(), text: target.text });
+      if ((await inLayer.count()) > 0) {
+        return controlsWithText({ root: open.last(), text: target.text, nth: target.nth });
+      }
+    }
+  }
+  return controlsWithText({ root: page, text: target.text, nth: target.nth });
+}
+
+// The element a step acts on or asserts about. With `text` it is the visible
+// interactive control with exactly that text (a cell button, a confirm
+// dialog's OK, a menu item) inside the scope, or in the front-most open layer
+// of the page when there is no blockId — portal-rendered controls live
+// outside every block. With `nth` alone it is the nth interactive control in
+// the scope. Otherwise it is the scope itself, and a click resolves its inner
+// control the way a plain blockId click does.
+async function resolveTarget({ page, target }) {
+  const scope = resolveScope({ page, target });
+  if (!type.isUndefined(target.text)) {
+    if (type.isUndefined(scope)) {
+      return resolvePageWideText({ page, target });
+    }
+    return controlsWithText({ root: scope, text: target.text, nth: target.nth });
+  }
+  if (!type.isUndefined(target.nth)) {
+    return scope.locator(INTERACTIVE_CONTROL).nth(target.nth);
+  }
+  return scope;
+}
+
+// A target that names a control (`text`, `nth`) is clicked as is; a target that
+// names a container (block, row, cell) is clicked on the first control inside
+// it, or on itself when it has none.
+async function resolveClickLocator({ page, target }) {
+  const located = await resolveTarget({ page, target });
+  if (!type.isUndefined(target.text) || !type.isUndefined(target.nth)) {
+    return located;
+  }
+  return resolveClickTarget(located);
 }
 
 async function runClick({ page, step, timeout }) {
-  const blockId = step.click;
-  await actOnBlock({
-    blockId,
+  const target = normaliseTarget(step.click);
+  await actOnTarget({
+    target,
     action: async () => {
-      const target = await resolveClickTarget(getBlock(page, blockId));
-      await target.click({ timeout });
+      const locator = await resolveClickLocator({ page, target });
+      await locator.click({ timeout });
     },
   });
 }
 
 async function runFill({ page, step, timeout }) {
-  const { blockId, value } = step.fill;
-  await actOnBlock({
-    blockId,
-    action: () =>
-      getBlock(page, blockId).locator('input, textarea').first().fill(String(value), { timeout }),
+  const { value, ...target } = step.fill;
+  await actOnTarget({
+    target,
+    action: async () => {
+      const scope = await resolveTarget({ page, target });
+      await scope.locator('input, textarea').first().fill(String(value), { timeout });
+    },
   });
 }
 
-// Exact match on the option's text: a regex anchored at both ends, so "Cat"
-// does not pick "Category".
-function exactText(value) {
-  return new RegExp(`^\\s*${value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*$`);
-}
-
 // A native <select> inside the block is preferred when present (Playwright's
 // selectOption is exact and needs no open dropdown). Otherwise the block is
 // clicked to open its dropdown and the option with exactly `value` as text is
@@ -140,22 +261,22 @@ function exactText(value) {
 // page-wide, restricted to visible ones so the hidden accessibility list is
 // never matched.
 async function runSelect({ page, step, timeout }) {
-  const { blockId, value } = step.select;
+  const { value, ...target } = step.select;
   const text = String(value);
-  const block = getBlock(page, blockId);
-  const native = block.locator('select');
+  const scope = await resolveTarget({ page, target });
+  const native = scope.locator('select');
   if ((await native.count()) > 0) {
-    await actOnBlock({
-      blockId,
+    await actOnTarget({
+      target,
       action: () => native.first().selectOption({ label: text }, { timeout }),
     });
     return;
   }
-  await actOnBlock({
-    blockId,
+  await actOnTarget({
+    target,
     action: async () => {
-      const target = await resolveClickTarget(block);
-      await target.click({ timeout });
+      const locator = await resolveClickLocator({ page, target });
+      await locator.click({ timeout });
     },
   });
   const option = page
@@ -166,10 +287,11 @@ async function runSelect({ page, step, timeout }) {
   try {
     await option.click({ timeout });
   } catch (error) {
+    const description = describeTarget(target);
     throw new JourneyStepError(
-      `No option with text "${text}" appeared in the dropdown of block "${blockId}".`,
+      `No option with text "${text}" appeared in the dropdown of ${description}.`,
       {
-        expected: `option "${text}" in the dropdown of block "${blockId}"`,
+        expected: `option "${text}" in the dropdown of ${description}`,
         actual: cleanMessage(error),
       }
     );
@@ -269,34 +391,46 @@ async function expectState({ page, params }) {
 }
 
 async function expectVisible({ page, params, timeout }) {
-  const blockId = params;
+  const target = normaliseTarget(params);
+  const description = describeTarget(target);
   try {
-    await getBlock(page, blockId).waitFor({ state: 'visible', timeout });
+    const located = await resolveTarget({ page, target });
+    await located.waitFor({ state: 'visible', timeout });
   } catch (error) {
-    throw new JourneyStepError(`Expected block "${blockId}" to be visible.`, {
-      expected: `block "${blockId}" to be visible`,
+    throw new JourneyStepError(`Expected ${description} to be visible.`, {
+      expected: `${description} to be visible`,
       actual: cleanMessage(error),
     });
   }
 }
 
+// Waits for the target to be in the page, then reads the text of every element
+// it matches. A grid row is rendered once per column container (pinned left,
+// centre, pinned right), so a row target legitimately matches more than one
+// element; joining them reads the whole row.
+async function readTargetText({ page, target, timeout }) {
+  const located = await resolveTarget({ page, target });
+  await located.first().waitFor({ state: 'attached', timeout });
+  const texts = await located.allInnerTexts();
+  return texts.join('\n');
+}
+
 async function expectText({ page, params, timeout }) {
-  const { blockId, contains } = params;
+  const { contains, ...target } = params;
+  const description = describeTarget(target);
   let text;
   try {
-    text = await getBlock(page, blockId).innerText({ timeout });
+    text = await readTargetText({ page, target, timeout });
   } catch (error) {
-    throw new JourneyStepError(`Expected block "${blockId}" to contain text "${contains}".`, {
-      expected: `block "${blockId}" text to contain "${contains}"`,
+    throw new JourneyStepError(`Expected ${description} to contain text "${contains}".`, {
+      expected: `${description} text to contain "${contains}"`,
       actual: cleanMessage(error),
     });
   }
   if (!text.includes(contains)) {
     throw new JourneyStepError(
-      `Expected block "${blockId}" text to contain "${contains}" but found ${JSON.stringify(
-        text
-      )}.`,
-      { expected: `block "${blockId}" text to contain "${contains}"`, actual: text }
+      `Expected ${description} text to contain "${contains}" but found ${JSON.stringify(text)}.`,
+      { expected: `${description} text to contain "${contains}"`, actual: text }
     );
   }
 }

package/lib/docs/runJourney.test.mjs

@@ -69,6 +69,8 @@ function createLocator({ selector, page }) {
     }),
     locator: jest.fn((child) => createLocator({ selector: `${selector} ${child}`, page })),
     first: jest.fn(() => locator),
+    last: jest.fn(() => locator),
+    nth: jest.fn(() => locator),
     filter: jest.fn(() => locator),
     count: jest.fn(async () => 0),
     selectOption: jest.fn(),
@@ -77,7 +79,7 @@ function createLocator({ selector, page }) {
         throw new Error(`locator.waitFor: Timeout 5000ms exceeded.`);
       }
     }),
-    innerText: jest.fn(async () => page.texts[selector] ?? ''),
+    allInnerTexts: jest.fn(async () => [page.texts[selector] ?? '']),
   };
   return locator;
 }
@@ -254,6 +256,370 @@ test('runJourney clicks the interactive control inside a block when there is one
   ]);
 });
 
+const CONTROLS = `button, [role="button"], a[href], input:not([type="hidden"]), textarea, select, [role="switch"], [role="checkbox"], [role="radio"], [role="tab"], [role="menuitem"]`;
+
+// Records every filter and nth applied to any locator, however deeply chained,
+// so a test can assert on the text and visibility filters a target resolves to.
+function trackFilters(page) {
+  const filters = [];
+  function instrument(locator) {
+    locator.filter.mockImplementation((filter) => {
+      filters.push({ selector: locator.selector, filter });
+      return locator;
+    });
+    locator.nth.mockImplementation((index) => {
+      page.nths.push({ selector: locator.selector, index });
+      return locator;
+    });
+    locator.locator.mockImplementation((child) =>
+      instrument(createLocator({ selector: `${locator.selector} ${child}`, page }))
+    );
+    return locator;
+  }
+  page.locator.mockImplementation((selector) => instrument(createLocator({ selector, page })));
+  return filters;
+}
+
+test('runJourney clicks a cell button by row and exact text inside a grid block', async () => {
+  const page = createPage();
+  page.nths = [];
+  openWith(page);
+  const filters = trackFilters(page);
+
+  const result = await runJourney({
+    origin,
+    pageId: 'controls',
+    steps: [{ click: { blockId: 'grid', row: 1, text: 'Edit' } }],
+  });
+
+  expect(result.passed).toBe(true);
+  expect(page.clicks).toEqual([`#bl-grid .ag-row[row-index="1"] ${CONTROLS}`]);
+  expect(filters).toHaveLength(2);
+  expect(filters[0].filter.hasText.test('Edit')).toBe(true);
+  expect(filters[0].filter.hasText.test(' Edit ')).toBe(true);
+  expect(filters[0].filter.hasText.test('Edit row')).toBe(false);
+  expect(filters[1].filter).toEqual({ visible: true });
+  expect(page.nths).toEqual([
+    { selector: `#bl-grid .ag-row[row-index="1"] ${CONTROLS}`, index: 0 },
+  ]);
+});
+
+test('runJourney clicks the control inside a grid cell addressed by row and column', async () => {
+  const page = createPage();
+  openWith(page);
+  page.locator.mockImplementation((selector) => {
+    const locator = createLocator({ selector, page });
+    locator.locator.mockImplementation((child) => {
+      const inner = createLocator({ selector: `${selector} ${child}`, page });
+      inner.locator.mockImplementation((grandchild) => {
+        const cell = createLocator({ selector: `${inner.selector} ${grandchild}`, page });
+        cell.locator.mockImplementation((control) => {
+          const found = createLocator({ selector: `${cell.selector} ${control}`, page });
+          found.count.mockResolvedValue(1);
+          return found;
+        });
+        return cell;
+      });
+      return inner;
+    });
+    return locator;
+  });
+
+  const result = await runJourney({
+    origin,
+    pageId: 'controls',
+    steps: [{ click: { blockId: 'grid', row: 0, column: 'actions' } }],
+  });
+
+  expect(result.passed).toBe(true);
+  expect(page.clicks).toEqual([
+    `#bl-grid .ag-row[row-index="0"] .ag-cell[col-id="actions"] ${CONTROLS}`,
+  ]);
+});
+
+test('runJourney clicks the nth control in a grid cell when several have no text', async () => {
+  const page = createPage();
+  page.nths = [];
+  openWith(page);
+  trackFilters(page);
+
+  const result = await runJourney({
+    origin,
+    pageId: 'controls',
+    steps: [{ click: { blockId: 'grid', row: 0, column: 'actions', nth: 1 } }],
+  });
+
+  expect(result.passed).toBe(true);
+  const selector = `#bl-grid .ag-row[row-index="0"] .ag-cell[col-id="actions"] ${CONTROLS}`;
+  expect(page.clicks).toEqual([selector]);
+  expect(page.nths).toEqual([{ selector, index: 1 }]);
+});
+
+test('runJourney clicks a page-wide control by text when the target has no blockId', async () => {
+  const page = createPage();
+  page.nths = [];
+  openWith(page);
+  const filters = trackFilters(page);
+
+  const result = await runJourney({
+    origin,
+    pageId: 'controls',
+    steps: [{ click: { text: 'OK' } }, { click: { text: 'Delete', nth: 1 } }],
+  });
+
+  expect(result.passed).toBe(true);
+  expect(page.clicks).toEqual([CONTROLS, CONTROLS]);
+  // No menu or dialog is open (every count is 0), so only the page-wide
+  // search filters apply, once per step.
+  const pageWide = filters.filter((f) => f.selector === CONTROLS);
+  expect(pageWide.map((f) => f.filter)).toEqual([
+    { hasText: expect.any(RegExp) },
+    { visible: true },
+    { hasText: expect.any(RegExp) },
+    { visible: true },
+  ]);
+  expect(pageWide[0].filter.hasText.test('OK')).toBe(true);
+  expect(pageWide[0].filter.hasText.test('OKAY')).toBe(false);
+  expect(page.nths).toEqual([
+    { selector: CONTROLS, index: 0 },
+    { selector: CONTROLS, index: 1 },
+  ]);
+});
+
+test('runJourney finds a page-wide text target in the open dialog before the page', async () => {
+  const page = createPage();
+  page.nths = [];
+  openWith(page);
+  trackFilters(page);
+  // A dialog is open and it holds a control with the text; the grid behind it
+  // holds one too, but the dialog wins.
+  page.locator.mockImplementation((selector) => {
+    const locator = createLocator({ selector, page });
+    if (selector === '[role="dialog"]') {
+      locator.count.mockResolvedValue(1);
+      locator.last.mockImplementation(() => locator);
+      locator.locator.mockImplementation((child) => {
+        const inner = createLocator({ selector: `${selector} ${child}`, page });
+        inner.count.mockResolvedValue(1);
+        inner.nth.mockImplementation((index) => {
+          page.nths.push({ selector: inner.selector, index });
+          return inner;
+        });
+        return inner;
+      });
+    }
+    return locator;
+  });
+
+  const result = await runJourney({
+    origin,
+    pageId: 'controls',
+    steps: [{ click: { text: 'Delete' } }],
+  });
+
+  expect(result.passed).toBe(true);
+  expect(page.clicks).toEqual([`[role="dialog"] ${CONTROLS}`]);
+  expect(page.nths).toEqual([
+    { selector: `[role="dialog"] ${CONTROLS}`, index: 0 },
+    { selector: `[role="dialog"] ${CONTROLS}`, index: 0 },
+  ]);
+});
+
+test('runJourney prefers an open menu over an open dialog for a page-wide text target', async () => {
+  const page = createPage();
+  openWith(page);
+  page.locator.mockImplementation((selector) => {
+    const locator = createLocator({ selector, page });
+    if (selector === '[role="menu"]' || selector === '[role="dialog"]') {
+      locator.count.mockResolvedValue(1);
+      locator.last.mockImplementation(() => locator);
+      locator.locator.mockImplementation((child) => {
+        const inner = createLocator({ selector: `${selector} ${child}`, page });
+        inner.count.mockResolvedValue(1);
+        return inner;
+      });
+    }
+    return locator;
+  });
+
+  const result = await runJourney({
+    origin,
+    pageId: 'controls',
+    steps: [{ click: { text: 'Archive' } }],
+  });
+
+  expect(result.passed).toBe(true);
+  expect(page.clicks).toEqual([`[role="menu"] ${CONTROLS}`]);
+});
+
+test('runJourney falls through to the page when the open dialog has no control with the text', async () => {
+  const page = createPage();
+  openWith(page);
+  page.locator.mockImplementation((selector) => {
+    const locator = createLocator({ selector, page });
+    if (selector === '[role="dialog"]') {
+      locator.count.mockResolvedValue(1);
+      locator.last.mockImplementation(() => locator);
+    }
+    return locator;
+  });
+
+  const result = await runJourney({
+    origin,
+    pageId: 'controls',
+    steps: [{ click: { text: 'Refresh' } }],
+  });
+
+  expect(result.passed).toBe(true);
+  expect(page.clicks).toEqual([CONTROLS]);
+});
+
+test('runJourney escapes quotes in a column id', async () => {
+  const page = createPage();
+  openWith(page);
+
+  await runJourney({
+    origin,
+    pageId: 'controls',
+    steps: [{ click: { blockId: 'grid', row: 0, column: 'a"b' } }],
+  });
+
+  expect(page.clicks).toEqual(['#bl-grid .ag-row[row-index="0"] .ag-cell[col-id="a\\"b"]']);
+});
+
+test('runJourney describes a failed target by block, row, column and text', async () => {
+  const page = createPage();
+  openWith(page);
+  page.locator.mockImplementation((selector) => {
+    const locator = createLocator({ selector, page });
+    const fail = async () => {
+      throw new Error('locator.click: Timeout 5000ms exceeded.');
+    };
+    locator.click.mockImplementation(fail);
+    locator.locator.mockImplementation((child) => {
+      const inner = createLocator({ selector: `${selector} ${child}`, page });
+      inner.click.mockImplementation(fail);
+      inner.locator.mockImplementation((grandchild) => {
+        const deep = createLocator({ selector: `${inner.selector} ${grandchild}`, page });
+        deep.click.mockImplementation(fail);
+        deep.locator.mockImplementation(() => deep);
+        return deep;
+      });
+      return inner;
+    });
+    return locator;
+  });
+
+  const result = await runJourney({
+    origin,
+    pageId: 'controls',
+    steps: [{ click: { blockId: 'grid', row: 2, column: 'actions', text: 'Edit', nth: 1 } }],
+  });
+
+  expect(result.passed).toBe(false);
+  expect(result.failure.expected).toEqual(
+    'block "grid" row 2 column "actions" control "Edit" nth 1 to be actionable'
+  );
+  expect(result.failure.message).toMatch(
+    /^Block "grid" row 2 column "actions" control "Edit" nth 1 was not actionable: locator.click/
+  );
+});
+
+test('runJourney reports a page-wide control that never appears', async () => {
+  const page = createPage();
+  openWith(page);
+  page.locator.mockImplementation((selector) => {
+    const locator = createLocator({ selector, page });
+    locator.click.mockImplementation(async () => {
+      throw new Error('locator.click: Timeout 5000ms exceeded.');
+    });
+    return locator;
+  });
+
+  const result = await runJourney({
+    origin,
+    pageId: 'controls',
+    steps: [{ click: { text: 'Confirm' } }],
+  });
+
+  expect(result.passed).toBe(false);
+  expect(result.failure.expected).toEqual('control "Confirm" to be actionable');
+  expect(result.failure.message).toMatch(/^Control "Confirm" was not actionable/);
+});
+
+test('runJourney fills and selects inside a grid cell addressed by row and column', async () => {
+  const page = createPage();
+  openWith(page);
+
+  const result = await runJourney({
+    origin,
+    pageId: 'controls',
+    steps: [
+      { fill: { blockId: 'grid', row: 1, column: 'name', value: 'Ada' } },
+      { select: { blockId: 'grid', row: 1, column: 'status', value: 'Open' } },
+    ],
+  });
+
+  expect(result.passed).toBe(true);
+  expect(page.fills).toEqual([
+    {
+      selector: '#bl-grid .ag-row[row-index="1"] .ag-cell[col-id="name"] input, textarea',
+      value: 'Ada',
+    },
+  ]);
+  expect(page.clicks).toEqual([
+    '#bl-grid .ag-row[row-index="1"] .ag-cell[col-id="status"]',
+    '.ant-select-item-option, [role="option"]',
+  ]);
+});
+
+test('runJourney checks visibility and text of a grid row and cell', async () => {
+  const page = createPage();
+  page.texts['#bl-grid .ag-row[row-index="0"] .ag-cell[col-id="title"]'] = 'Access reviews';
+  page.texts['#bl-grid .ag-row[row-index="0"]'] = 'Access reviews open Edit';
+  openWith(page);
+
+  const result = await runJourney({
+    origin,
+    pageId: 'controls',
+    steps: [
+      { expect: { visible: { blockId: 'grid', row: 0 } } },
+      { expect: { text: { blockId: 'grid', row: 0, column: 'title', contains: 'Access' } } },
+      { expect: { text: { blockId: 'grid', row: 0, contains: 'open' } } },
+      { expect: { text: { blockId: 'grid', row: 0, column: 'title', contains: 'Closed' } } },
+    ],
+  });
+
+  expect(result.steps.map((step) => step.status)).toEqual(['ok', 'ok', 'ok', 'failed']);
+  expect(result.failure.expected).toEqual(
+    'block "grid" row 0 column "title" text to contain "Closed"'
+  );
+  expect(result.failure.actual).toEqual('Access reviews');
+});
+
+test('runJourney joins the text of every element a row target matches', async () => {
+  const page = createPage();
+  openWith(page);
+  page.locator.mockImplementation((selector) => {
+    const locator = createLocator({ selector, page });
+    locator.locator.mockImplementation((child) => {
+      const inner = createLocator({ selector: `${selector} ${child}`, page });
+      // ag-grid renders the row once per column container.
+      inner.allInnerTexts.mockResolvedValue(['Access reviews', 'Edit Delete']);
+      return inner;
+    });
+    return locator;
+  });
+
+  const result = await runJourney({
+    origin,
+    pageId: 'controls',
+    steps: [{ expect: { text: { blockId: 'grid', row: 0, contains: 'Delete' } } }],
+  });
+
+  expect(result.passed).toBe(true);
+});
+
 test('runJourney reports a missing expect.state value as actual null', async () => {
   const page = createPage({ window: createLowdefyWindow({ state: {} }) });
   openWith(page);

package/lib/docs/validateJourneySteps.js

@@ -34,17 +34,93 @@ function getStepKey(step) {
   return keys[0];
 }
 
+// A step's target is a blockId string or an object that narrows the search:
+// `blockId` scopes to the block's #bl- wrapper, `row` and `column` to a grid
+// row (zero-based, as displayed) and cell (by col-id) inside it, `text` to the
+// interactive control with exactly that text, `nth` picks among several
+// matches. `text` alone, with no blockId, searches the whole page — that is
+// how portal-rendered controls (confirm dialog buttons, modal footers,
+// dropdown menu items) are reached, since they render outside every block.
+const TARGET_KEYS = ['blockId', 'text', 'row', 'column', 'nth'];
+
+function isIndex(value) {
+  return type.isInt(value) && value >= 0;
+}
+
+// Validates the target keys of a step object; `extraKeys` are the step's own
+// keys (`value`, `contains`) that may sit beside them. Returns an error
+// message, or undefined when the target is well-formed.
+function validateTargetObject({ key, params, extraKeys = [], requireBlockId = false }) {
+  const allowed = [...TARGET_KEYS, ...extraKeys];
+  const unknown = Object.keys(params).filter((k) => !allowed.includes(k));
+  if (unknown.length > 0) {
+    return `Step "${key}" has unknown key${unknown.length > 1 ? 's' : ''} ${unknown
+      .map((k) => `"${k}"`)
+      .join(', ')}. Keys are: ${allowed.join(', ')}.`;
+  }
+  if (!type.isUndefined(params.blockId) && !type.isString(params.blockId)) {
+    return `Step "${key}" requires "blockId" to be a string. Received ${describe(params.blockId)}.`;
+  }
+  if (!type.isUndefined(params.text) && !type.isString(params.text)) {
+    return `Step "${key}" requires "text" to be a string. Received ${describe(params.text)}.`;
+  }
+  if (requireBlockId && type.isUndefined(params.blockId)) {
+    return `Step "${key}" requires a "blockId" string. Received ${describe(params)}.`;
+  }
+  if (type.isUndefined(params.blockId) && type.isUndefined(params.text)) {
+    return `Step "${key}" requires a "blockId" or a "text" to target. Received ${describe(
+      params
+    )}.`;
+  }
+  if (!type.isUndefined(params.row) && !isIndex(params.row)) {
+    return `Step "${key}" requires "row" to be a zero-based row index. Received ${describe(
+      params.row
+    )}.`;
+  }
+  if (!type.isUndefined(params.column) && !type.isString(params.column)) {
+    return `Step "${key}" requires "column" to be a column id string. Received ${describe(
+      params.column
+    )}.`;
+  }
+  if (
+    (!type.isUndefined(params.row) || !type.isUndefined(params.column)) &&
+    type.isUndefined(params.blockId)
+  ) {
+    return `Step "${key}" requires a "blockId" (the grid block) when "row" or "column" is given. Received ${describe(
+      params
+    )}.`;
+  }
+  if (!type.isUndefined(params.nth) && !isIndex(params.nth)) {
+    return `Step "${key}" requires "nth" to be a zero-based index. Received ${describe(
+      params.nth
+    )}.`;
+  }
+  return undefined;
+}
+
+// click and expect.visible take a blockId string or a target object.
+function validateTarget({ key, params }) {
+  if (type.isString(params)) {
+    return undefined;
+  }
+  if (!type.isObject(params)) {
+    return `Step "${key}" requires a blockId string or a target object { blockId, text, row, column, nth }. Received ${describe(
+      params
+    )}.`;
+  }
+  return validateTargetObject({ key, params });
+}
+
+// fill and select take the target keys beside `value`; the block is required
+// because a value is typed into a block's input, never a page-wide control.
 function validateBlockValue({ key, params }) {
   if (!type.isObject(params)) {
     return `Step "${key}" requires { blockId, value }. Received ${describe(params)}.`;
   }
-  if (!type.isString(params.blockId)) {
-    return `Step "${key}" requires a "blockId" string. Received ${describe(params.blockId)}.`;
-  }
   if (type.isUndefined(params.value)) {
     return `Step "${key}" requires a "value". Received ${describe(params)}.`;
   }
-  return undefined;
+  return validateTargetObject({ key, params, extraKeys: ['value'], requireBlockId: true });
 }
 
 function validateWait(params) {
@@ -88,19 +164,17 @@ function validateExpect(params) {
       }
       return undefined;
     case 'visible':
-      if (!type.isString(value)) {
-        return `Step "expect.visible" requires a blockId string. Received ${describe(value)}.`;
-      }
-      return undefined;
+      return validateTarget({ key: 'expect.visible', params: value });
     case 'text':
-      if (
-        !type.isObject(value) ||
-        !type.isString(value.blockId) ||
-        !type.isString(value.contains)
-      ) {
+      if (!type.isObject(value) || !type.isString(value.contains)) {
         return `Step "expect.text" requires { blockId, contains }. Received ${describe(value)}.`;
       }
-      return undefined;
+      return validateTargetObject({
+        key: 'expect.text',
+        params: value,
+        extraKeys: ['contains'],
+        requireBlockId: true,
+      });
     case 'url':
       if (!type.isObject(value) || !type.isString(value.contains)) {
         return `Step "expect.url" requires { contains }. Received ${describe(value)}.`;
@@ -125,10 +199,7 @@ function validateStep(step) {
   const params = step[key];
   switch (key) {
     case 'click':
-      if (!type.isString(params)) {
-        return `Step "click" requires a blockId string. Received ${describe(params)}.`;
-      }
-      return undefined;
+      return validateTarget({ key: 'click', params });
     case 'fill':
     case 'select':
       return validateBlockValue({ key, params });
@@ -169,5 +240,5 @@ function validateJourneySteps({ steps }) {
   return {};
 }
 
-export { STEP_KEYS, getStepKey };
+export { STEP_KEYS, TARGET_KEYS, getStepKey };
 export default validateJourneySteps;

package/lib/docs/validateJourneySteps.test.mjs

@@ -40,6 +40,27 @@ test('validateJourneySteps accepts every step of the grammar', () => {
   expect(result).toEqual({});
 });
 
+test('validateJourneySteps accepts target objects on click, fill, select, expect.visible and expect.text', () => {
+  const result = validateJourneySteps({
+    steps: [
+      { click: { blockId: 'submit' } },
+      { click: { blockId: 'grid', row: 1, text: 'Edit' } },
+      { click: { blockId: 'grid', row: 0, column: 'actions' } },
+      { click: { blockId: 'grid', row: 0, column: 'actions', nth: 1 } },
+      { click: { blockId: 'tabs', text: 'Settings' } },
+      { click: { text: 'OK' } },
+      { click: { text: 'Delete', nth: 0 } },
+      { fill: { blockId: 'grid', row: 2, column: 'name', value: 'Ada' } },
+      { select: { blockId: 'grid', row: 2, column: 'status', value: 'Open' } },
+      { expect: { visible: { blockId: 'grid', row: 3 } } },
+      { expect: { visible: { text: 'Are you sure?' } } },
+      { expect: { text: { blockId: 'grid', row: 0, column: 'title', contains: 'Access' } } },
+      { expect: { text: { blockId: 'grid', row: 0, contains: 'Access' } } },
+    ],
+  });
+  expect(result).toEqual({});
+});
+
 test('validateJourneySteps rejects steps that are not an array', () => {
   expect(validateJourneySteps({ steps: undefined }).error).toMatch(
     /requires "steps" to be an array. Received undefined/
@@ -68,9 +89,53 @@ test('validateJourneySteps rejects a step that is not an object', () => {
 });
 
 test.each([
-  [{ click: 7 }, /Step "click" requires a blockId string. Received 7/],
+  [{ click: 7 }, /Step "click" requires a blockId string or a target object .*Received 7/],
+  [{ click: {} }, /Step "click" requires a "blockId" or a "text" to target/],
+  [{ click: { blockId: 7 } }, /Step "click" requires "blockId" to be a string. Received 7/],
+  [{ click: { text: 7 } }, /Step "click" requires "text" to be a string. Received 7/],
+  [
+    { click: { blockId: 'grid', row: -1 } },
+    /Step "click" requires "row" to be a zero-based row index. Received -1/,
+  ],
+  [
+    { click: { blockId: 'grid', row: '0' } },
+    /Step "click" requires "row" to be a zero-based row index. Received "0"/,
+  ],
+  [
+    { click: { blockId: 'grid', column: 0 } },
+    /Step "click" requires "column" to be a column id string. Received 0/,
+  ],
+  [
+    { click: { text: 'Edit', row: 0 } },
+    /Step "click" requires a "blockId" \(the grid block\) when "row" or "column" is given/,
+  ],
+  [
+    { click: { text: 'Edit', column: 'actions' } },
+    /Step "click" requires a "blockId" \(the grid block\) when "row" or "column" is given/,
+  ],
+  [
+    { click: { text: 'Edit', nth: 1.5 } },
+    /Step "click" requires "nth" to be a zero-based index. Received 1.5/,
+  ],
+  [
+    { click: { blockId: 'grid', colum: 'actions' } },
+    /Step "click" has unknown key "colum". Keys are: blockId, text, row, column, nth/,
+  ],
+  [
+    { click: { blockId: 'grid', colum: 'a', rows: 1 } },
+    /Step "click" has unknown keys "colum", "rows"/,
+  ],
   [{ fill: 'name' }, /Step "fill" requires \{ blockId, value \}/],
-  [{ fill: { blockId: 1, value: 'x' } }, /Step "fill" requires a "blockId" string. Received 1/],
+  [
+    { fill: { blockId: 1, value: 'x' } },
+    /Step "fill" requires "blockId" to be a string. Received 1/,
+  ],
+  [{ fill: { value: 'x' } }, /Step "fill" requires a "blockId" string/],
+  [{ fill: { text: 'Name', value: 'x' } }, /Step "fill" requires a "blockId" string/],
+  [
+    { fill: { blockId: 'grid', row: 0, column: 'name', value: 'x', selector: 'input' } },
+    /Step "fill" has unknown key "selector". Keys are: blockId, text, row, column, nth, value/,
+  ],
   [{ fill: { blockId: 'name' } }, /Step "fill" requires a "value"/],
   [{ select: { value: 'x' } }, /Step "select" requires a "blockId" string/],
   [{ press: ['Enter'] }, /Step "press" requires a key string/],
@@ -93,8 +158,23 @@ test.each([
   ],
   [{ expect: { state: { path: 'a' } } }, /Step "expect.state" requires \{ path, equals \}/],
   [{ expect: { state: 'a' } }, /Step "expect.state" requires \{ path, equals \}/],
-  [{ expect: { visible: { blockId: 'a' } } }, /Step "expect.visible" requires a blockId string/],
+  [
+    { expect: { visible: 7 } },
+    /Step "expect.visible" requires a blockId string or a target object/,
+  ],
+  [
+    { expect: { visible: { row: 0 } } },
+    /Step "expect.visible" requires a "blockId" or a "text" to target/,
+  ],
   [{ expect: { text: { blockId: 'a' } } }, /Step "expect.text" requires \{ blockId, contains \}/],
+  [
+    { expect: { text: { text: 'OK', contains: 'OK' } } },
+    /Step "expect.text" requires a "blockId" string/,
+  ],
+  [
+    { expect: { text: { blockId: 'grid', row: 0, contains: 'a', equals: 'a' } } },
+    /Step "expect.text" has unknown key "equals". Keys are: blockId, text, row, column, nth, contains/,
+  ],
   [{ expect: { url: '/detail' } }, /Step "expect.url" requires \{ contains \}/],
 ])('validateJourneySteps rejects malformed step %j', (step, expected) => {
   const result = validateJourneySteps({ steps: [step] });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lowdefy/server-dev",
-  "version": "0.0.0-experimental-20260906143808",
+  "version": "0.0.0-experimental-20260908103554",
   "license": "Apache-2.0",
   "description": "",
   "homepage": "https://lowdefy.com",
@@ -45,40 +45,40 @@
     "@hono/mcp": "0.3.0",
     "@hono/node-server": "2.0.4",
     "@hono/vite-dev-server": "0.26.0",
-    "@lowdefy/actions-core": "0.0.0-experimental-20260906143808",
-    "@lowdefy/api": "0.0.0-experimental-20260906143808",
-    "@lowdefy/block-utils": "0.0.0-experimental-20260906143808",
-    "@lowdefy/blocks-aggrid": "0.0.0-experimental-20260906143808",
-    "@lowdefy/blocks-antd": "0.0.0-experimental-20260906143808",
-    "@lowdefy/blocks-antd-x": "0.0.0-experimental-20260906143808",
-    "@lowdefy/blocks-basic": "0.0.0-experimental-20260906143808",
-    "@lowdefy/blocks-captcha": "0.0.0-experimental-20260906143808",
-    "@lowdefy/blocks-echarts": "0.0.0-experimental-20260906143808",
-    "@lowdefy/blocks-loaders": "0.0.0-experimental-20260906143808",
-    "@lowdefy/blocks-markdown": "0.0.0-experimental-20260906143808",
-    "@lowdefy/blocks-tiptap": "0.0.0-experimental-20260906143808",
-    "@lowdefy/build": "0.0.0-experimental-20260906143808",
-    "@lowdefy/client": "0.0.0-experimental-20260906143808",
-    "@lowdefy/connection-axios-http": "0.0.0-experimental-20260906143808",
-    "@lowdefy/connection-mongodb": "0.0.0-experimental-20260906143808",
-    "@lowdefy/docs-content": "0.0.0-experimental-20260906143808",
-    "@lowdefy/e2e-utils": "0.0.0-experimental-20260906143808",
-    "@lowdefy/engine": "0.0.0-experimental-20260906143808",
-    "@lowdefy/errors": "0.0.0-experimental-20260906143808",
-    "@lowdefy/helpers": "0.0.0-experimental-20260906143808",
-    "@lowdefy/layout": "0.0.0-experimental-20260906143808",
-    "@lowdefy/logger": "0.0.0-experimental-20260906143808",
-    "@lowdefy/node-utils": "0.0.0-experimental-20260906143808",
-    "@lowdefy/operators-change-case": "0.0.0-experimental-20260906143808",
-    "@lowdefy/operators-dayjs": "0.0.0-experimental-20260906143808",
-    "@lowdefy/operators-diff": "0.0.0-experimental-20260906143808",
-    "@lowdefy/operators-js": "0.0.0-experimental-20260906143808",
-    "@lowdefy/operators-mql": "0.0.0-experimental-20260906143808",
-    "@lowdefy/operators-nunjucks": "0.0.0-experimental-20260906143808",
-    "@lowdefy/operators-uuid": "0.0.0-experimental-20260906143808",
-    "@lowdefy/operators-yaml": "0.0.0-experimental-20260906143808",
-    "@lowdefy/plugin-better-auth": "0.0.0-experimental-20260906143808",
-    "@lowdefy/websockets-core": "0.0.0-experimental-20260906143808",
+    "@lowdefy/actions-core": "0.0.0-experimental-20260908103554",
+    "@lowdefy/api": "0.0.0-experimental-20260908103554",
+    "@lowdefy/block-utils": "0.0.0-experimental-20260908103554",
+    "@lowdefy/blocks-aggrid": "0.0.0-experimental-20260908103554",
+    "@lowdefy/blocks-antd": "0.0.0-experimental-20260908103554",
+    "@lowdefy/blocks-antd-x": "0.0.0-experimental-20260908103554",
+    "@lowdefy/blocks-basic": "0.0.0-experimental-20260908103554",
+    "@lowdefy/blocks-captcha": "0.0.0-experimental-20260908103554",
+    "@lowdefy/blocks-echarts": "0.0.0-experimental-20260908103554",
+    "@lowdefy/blocks-loaders": "0.0.0-experimental-20260908103554",
+    "@lowdefy/blocks-markdown": "0.0.0-experimental-20260908103554",
+    "@lowdefy/blocks-tiptap": "0.0.0-experimental-20260908103554",
+    "@lowdefy/build": "0.0.0-experimental-20260908103554",
+    "@lowdefy/client": "0.0.0-experimental-20260908103554",
+    "@lowdefy/connection-axios-http": "0.0.0-experimental-20260908103554",
+    "@lowdefy/connection-mongodb": "0.0.0-experimental-20260908103554",
+    "@lowdefy/docs-content": "0.0.0-experimental-20260908103554",
+    "@lowdefy/e2e-utils": "0.0.0-experimental-20260908103554",
+    "@lowdefy/engine": "0.0.0-experimental-20260908103554",
+    "@lowdefy/errors": "0.0.0-experimental-20260908103554",
+    "@lowdefy/helpers": "0.0.0-experimental-20260908103554",
+    "@lowdefy/layout": "0.0.0-experimental-20260908103554",
+    "@lowdefy/logger": "0.0.0-experimental-20260908103554",
+    "@lowdefy/node-utils": "0.0.0-experimental-20260908103554",
+    "@lowdefy/operators-change-case": "0.0.0-experimental-20260908103554",
+    "@lowdefy/operators-dayjs": "0.0.0-experimental-20260908103554",
+    "@lowdefy/operators-diff": "0.0.0-experimental-20260908103554",
+    "@lowdefy/operators-js": "0.0.0-experimental-20260908103554",
+    "@lowdefy/operators-mql": "0.0.0-experimental-20260908103554",
+    "@lowdefy/operators-nunjucks": "0.0.0-experimental-20260908103554",
+    "@lowdefy/operators-uuid": "0.0.0-experimental-20260908103554",
+    "@lowdefy/operators-yaml": "0.0.0-experimental-20260908103554",
+    "@lowdefy/plugin-better-auth": "0.0.0-experimental-20260908103554",
+    "@lowdefy/websockets-core": "0.0.0-experimental-20260908103554",
     "@modelcontextprotocol/sdk": "1.29.0",
     "@tailwindcss/postcss": "4.3.1",
     "@vitejs/plugin-react": "6.0.2",

package/package.original.json

@@ -1,6 +1,6 @@
 {
   "name": "@lowdefy/server-dev",
-  "version": "0.0.0-experimental-20260906143808",
+  "version": "0.0.0-experimental-20260908103554",
   "license": "Apache-2.0",
   "description": "",
   "homepage": "https://lowdefy.com",
@@ -51,40 +51,40 @@
     "@hono/mcp": "0.3.0",
     "@hono/node-server": "2.0.4",
     "@hono/vite-dev-server": "0.26.0",
-    "@lowdefy/actions-core": "0.0.0-experimental-20260906143808",
-    "@lowdefy/api": "0.0.0-experimental-20260906143808",
-    "@lowdefy/block-utils": "0.0.0-experimental-20260906143808",
-    "@lowdefy/blocks-aggrid": "0.0.0-experimental-20260906143808",
-    "@lowdefy/blocks-antd": "0.0.0-experimental-20260906143808",
-    "@lowdefy/blocks-antd-x": "0.0.0-experimental-20260906143808",
-    "@lowdefy/blocks-basic": "0.0.0-experimental-20260906143808",
-    "@lowdefy/blocks-captcha": "0.0.0-experimental-20260906143808",
-    "@lowdefy/blocks-echarts": "0.0.0-experimental-20260906143808",
-    "@lowdefy/blocks-loaders": "0.0.0-experimental-20260906143808",
-    "@lowdefy/blocks-markdown": "0.0.0-experimental-20260906143808",
-    "@lowdefy/blocks-tiptap": "0.0.0-experimental-20260906143808",
-    "@lowdefy/build": "0.0.0-experimental-20260906143808",
-    "@lowdefy/client": "0.0.0-experimental-20260906143808",
-    "@lowdefy/connection-axios-http": "0.0.0-experimental-20260906143808",
-    "@lowdefy/connection-mongodb": "0.0.0-experimental-20260906143808",
-    "@lowdefy/docs-content": "0.0.0-experimental-20260906143808",
-    "@lowdefy/e2e-utils": "0.0.0-experimental-20260906143808",
-    "@lowdefy/engine": "0.0.0-experimental-20260906143808",
-    "@lowdefy/errors": "0.0.0-experimental-20260906143808",
-    "@lowdefy/helpers": "0.0.0-experimental-20260906143808",
-    "@lowdefy/layout": "0.0.0-experimental-20260906143808",
-    "@lowdefy/logger": "0.0.0-experimental-20260906143808",
-    "@lowdefy/node-utils": "0.0.0-experimental-20260906143808",
-    "@lowdefy/operators-change-case": "0.0.0-experimental-20260906143808",
-    "@lowdefy/operators-dayjs": "0.0.0-experimental-20260906143808",
-    "@lowdefy/operators-diff": "0.0.0-experimental-20260906143808",
-    "@lowdefy/operators-js": "0.0.0-experimental-20260906143808",
-    "@lowdefy/operators-mql": "0.0.0-experimental-20260906143808",
-    "@lowdefy/operators-nunjucks": "0.0.0-experimental-20260906143808",
-    "@lowdefy/operators-uuid": "0.0.0-experimental-20260906143808",
-    "@lowdefy/operators-yaml": "0.0.0-experimental-20260906143808",
-    "@lowdefy/plugin-better-auth": "0.0.0-experimental-20260906143808",
-    "@lowdefy/websockets-core": "0.0.0-experimental-20260906143808",
+    "@lowdefy/actions-core": "0.0.0-experimental-20260908103554",
+    "@lowdefy/api": "0.0.0-experimental-20260908103554",
+    "@lowdefy/block-utils": "0.0.0-experimental-20260908103554",
+    "@lowdefy/blocks-aggrid": "0.0.0-experimental-20260908103554",
+    "@lowdefy/blocks-antd": "0.0.0-experimental-20260908103554",
+    "@lowdefy/blocks-antd-x": "0.0.0-experimental-20260908103554",
+    "@lowdefy/blocks-basic": "0.0.0-experimental-20260908103554",
+    "@lowdefy/blocks-captcha": "0.0.0-experimental-20260908103554",
+    "@lowdefy/blocks-echarts": "0.0.0-experimental-20260908103554",
+    "@lowdefy/blocks-loaders": "0.0.0-experimental-20260908103554",
+    "@lowdefy/blocks-markdown": "0.0.0-experimental-20260908103554",
+    "@lowdefy/blocks-tiptap": "0.0.0-experimental-20260908103554",
+    "@lowdefy/build": "0.0.0-experimental-20260908103554",
+    "@lowdefy/client": "0.0.0-experimental-20260908103554",
+    "@lowdefy/connection-axios-http": "0.0.0-experimental-20260908103554",
+    "@lowdefy/connection-mongodb": "0.0.0-experimental-20260908103554",
+    "@lowdefy/docs-content": "0.0.0-experimental-20260908103554",
+    "@lowdefy/e2e-utils": "0.0.0-experimental-20260908103554",
+    "@lowdefy/engine": "0.0.0-experimental-20260908103554",
+    "@lowdefy/errors": "0.0.0-experimental-20260908103554",
+    "@lowdefy/helpers": "0.0.0-experimental-20260908103554",
+    "@lowdefy/layout": "0.0.0-experimental-20260908103554",
+    "@lowdefy/logger": "0.0.0-experimental-20260908103554",
+    "@lowdefy/node-utils": "0.0.0-experimental-20260908103554",
+    "@lowdefy/operators-change-case": "0.0.0-experimental-20260908103554",
+    "@lowdefy/operators-dayjs": "0.0.0-experimental-20260908103554",
+    "@lowdefy/operators-diff": "0.0.0-experimental-20260908103554",
+    "@lowdefy/operators-js": "0.0.0-experimental-20260908103554",
+    "@lowdefy/operators-mql": "0.0.0-experimental-20260908103554",
+    "@lowdefy/operators-nunjucks": "0.0.0-experimental-20260908103554",
+    "@lowdefy/operators-uuid": "0.0.0-experimental-20260908103554",
+    "@lowdefy/operators-yaml": "0.0.0-experimental-20260908103554",
+    "@lowdefy/plugin-better-auth": "0.0.0-experimental-20260908103554",
+    "@lowdefy/websockets-core": "0.0.0-experimental-20260908103554",
     "@modelcontextprotocol/sdk": "1.29.0",
     "@tailwindcss/postcss": "4.3.1",
     "@vitejs/plugin-react": "6.0.2",