@lowdefy/server-dev 7.0.0 → 7.1.0

package/lib/docs/dataSets/readDataSet.test.mjs

@@ -84,9 +84,11 @@ test('readDataSet reads module connections, which the build writes under their m
   writeConnection('contacts/contacts', mongo({ collection: 'contacts' }));
   writeConnection('crm-contacts', mongo({ collection: 'contacts', databaseName: 'crm' }));
   writeDataSet('alpha', 'fixtures:\n  contacts/contacts: [{ _id: c1 }]\n');
-  await expect(readDataSet({ configDirectory, buildDirectory, name: 'alpha' })).rejects.toThrow(
-    'Data set "alpha": Connections "contacts/contacts" and "crm-contacts" both name collection "contacts" in different databases'
-  );
+  const dataSet = await readDataSet({ configDirectory, buildDirectory, name: 'alpha' });
+  expect(dataSet.databaseTargets).toEqual([
+    JSON.stringify(['secret:MONGODB_URI', null]),
+    JSON.stringify(['secret:MONGODB_URI', 'crm']),
+  ]);
 });
 
 test('readDataSet maps a module connection to its collection', async () => {
@@ -127,37 +129,66 @@ test('readDataSet refuses an indexed connection whose databaseName is an operato
   );
 });
 
-test('readDataSet refuses a keyed connection naming one collection under a different databaseName from another connection', async () => {
-  writeConnection('tickets', mongo({ collection: 'tickets', databaseName: 'app' }));
-  writeConnection('legacy-tickets', mongo({ collection: 'tickets', databaseName: 'legacy' }));
-  writeDataSet('alpha', 'fixtures:\n  tickets: [{ _id: a }]\n');
-  await expect(readDataSet({ configDirectory, buildDirectory, name: 'alpha' })).rejects.toThrow(
-    'Data set "alpha": Connections "legacy-tickets" and "tickets" both name collection "tickets" in different databases'
-  );
-});
-
-test('readDataSet refuses a keyed connection naming one collection under a different databaseUri secret from another connection', async () => {
+test('readDataSet maps each keyed connection to its database target', async () => {
   writeConnection('tickets', mongo({ collection: 'tickets' }));
+  writeConnection('legacy-tickets', mongo({ collection: 'tickets', databaseName: 'legacy' }));
   writeConnection('reporting', {
     type: 'MongoDBCollection',
     properties: { databaseUri: { _secret: 'REPORTING_URI' }, collection: 'tickets' },
   });
-  writeDataSet('alpha', 'fixtures:\n  tickets: [{ _id: a }]\n');
-  await expect(readDataSet({ configDirectory, buildDirectory, name: 'alpha' })).rejects.toThrow(
-    'Connections "reporting" and "tickets" both name collection "tickets" in different databases'
+  writeConnection('computed', {
+    type: 'MongoDBCollection',
+    properties: { databaseUri: { _env: 'URI' }, collection: 'tickets' },
+  });
+  writeConnection('api', { type: 'AxiosHttp', properties: { baseURL: 'https://example.com' } });
+  writeDataSet(
+    'alpha',
+    'fixtures:\n  tickets: [{ _id: a }]\n  legacy-tickets: [{ _id: a }]\n  reporting: [{ _id: a }]\n  computed: [{ _id: b }]\n'
   );
+  const dataSet = await readDataSet({ configDirectory, buildDirectory, name: 'alpha' });
+  expect(dataSet.targets).toEqual({
+    tickets: JSON.stringify(['secret:MONGODB_URI', null]),
+    'legacy-tickets': JSON.stringify(['secret:MONGODB_URI', 'legacy']),
+    reporting: JSON.stringify(['secret:REPORTING_URI', null]),
+    // Computed per request: the first target's, the database it reads.
+    computed: JSON.stringify(['secret:MONGODB_URI', null]),
+  });
+  // Every target in the build, sorted, whether or not the data set names it.
+  expect(dataSet.databaseTargets).toEqual([
+    JSON.stringify(['secret:MONGODB_URI', null]),
+    JSON.stringify(['secret:MONGODB_URI', 'legacy']),
+    JSON.stringify(['secret:REPORTING_URI', null]),
+  ]);
+  expect(dataSet.warnings).toEqual([]);
 });
 
-test('readDataSet warns on the same collision between two unkeyed connections', async () => {
-  writeConnection('tickets', mongo({ collection: 'tickets' }));
-  writeConnection('a', mongo({ collection: 'events', databaseName: 'one' }));
-  writeConnection('b', mongo({ collection: 'events', databaseName: 'two' }));
-  writeConnection('computed', mongo({ collection: { _state: 'c' }, databaseName: 'three' }));
-  writeDataSet('alpha', 'fixtures:\n  tickets: [{ _id: a }]\n');
+test('readDataSet accepts one _id generated on one collection in two database targets', async () => {
+  writeConnection('users', mongo({ collection: 'users' }));
+  writeConnection('auth-users', {
+    type: 'MongoDBCollection',
+    properties: { databaseUri: { _secret: 'AUTH_URI' }, collection: 'users' },
+  });
+  writeDataSet(
+    'alpha',
+    'fixtures:\n  auth-users: [{ _id: users-1 }]\ngenerate:\n  seed: 1\n  users:\n    count: 1\n'
+  );
   const dataSet = await readDataSet({ configDirectory, buildDirectory, name: 'alpha' });
-  expect(dataSet.warnings).toEqual([
-    'Connections "a" and "b" both name collection "events" in different databases; under a data set they read one database, so they share one collection.',
-  ]);
+  expect(dataSet.collections).toEqual({ users: 'users', 'auth-users': 'users' });
+});
+
+test('readDataSet refuses a generated _id a computed-target connection also holds on the first target', async () => {
+  writeConnection('users', mongo({ collection: 'users' }));
+  writeConnection('computed-users', {
+    type: 'MongoDBCollection',
+    properties: { databaseUri: { _env: 'URI' }, collection: 'users' },
+  });
+  writeDataSet(
+    'alpha',
+    'fixtures:\n  computed-users: [{ _id: users-1 }]\ngenerate:\n  seed: 1\n  users:\n    count: 1\n'
+  );
+  await expect(readDataSet({ configDirectory, buildDirectory, name: 'alpha' })).rejects.toThrow(
+    'connections "users" and "computed-users" both load collection "users".'
+  );
 });
 
 test('readDataSet resolves generated connections and refuses one the app does not have', async () => {

package/lib/docs/dataSets/sessionDatabaseName.js

@@ -0,0 +1,32 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import { type } from '@lowdefy/helpers';
+
+// The session database a database target (describeTargetKey) reads. Each target the build names has
+// its own, numbered when the session opens; a target the build did not name (a config mutant's, say)
+// gets the next number when first met, so it never merges with another. A target computed per
+// request (null) reads the session's first database.
+function sessionDatabaseName({ session, target }) {
+  if (type.isNone(target)) return session.databaseName;
+  if (!session.databases.has(target)) {
+    session.databases.set(target, `${session.prefix}_${session.databaseCount}`);
+    session.databaseCount += 1;
+  }
+  return session.databases.get(target);
+}
+
+export default sessionDatabaseName;

package/lib/docs/dataSets/sweepOrphanDatabases.js

@@ -17,15 +17,18 @@
 import dataSessionRegistry from './dataSessionRegistry.js';
 
 // Drops every session database on the store that no registered session owns: one left behind by a
-// write that was still in flight when its session dropped the database, or by a dev server that
-// stopped mid-run.
+// write that was still in flight when its session dropped its databases, or by a dev server that
+// stopped mid-run. A session owns every database under its prefix (<prefix>_<n>), including one it
+// numbers after this sweep lists them.
 async function sweepOrphanDatabases({ client }) {
-  const owned = new Set([...dataSessionRegistry.values()].map((session) => session.databaseName));
+  const prefixes = [...dataSessionRegistry.values()].map((session) => `${session.prefix}_`);
   const { databases } = await client.db('admin').admin().listDatabases({ nameOnly: true });
   await Promise.all(
     databases
       .map((database) => database.name)
-      .filter((name) => name.startsWith('ld_') && !owned.has(name))
+      .filter(
+        (name) => name.startsWith('ld_') && !prefixes.some((prefix) => name.startsWith(prefix))
+      )
       .map((name) => client.db(name).dropDatabase())
   );
 }

package/lib/docs/dataSets/test/app/lowdefy.yaml

@@ -30,6 +30,15 @@ connections:
         _secret: MONGODB_URI
       collection: tickets
       write: true
+  # A second database that also has a tickets collection: under a data set it reads a session
+  # database of its own, so its fixtures never merge with the app's tickets.
+  - id: crm_tickets
+    type: MongoDBCollection
+    properties:
+      databaseUri:
+        _secret: CRM_MONGODB_URI
+      collection: tickets
+      write: true
 
 # A module connection is written under its module's folder (connections/archive/archive_db.json),
 # which the data set redirect must reach too.
@@ -81,6 +90,19 @@ api:
               _id: 1
       - :return:
           _step: find
+  - id: list_crm_tickets
+    type: Api
+    routine:
+      - id: find
+        type: MongoDBFind
+        connectionId: crm_tickets
+        properties:
+          query: {}
+          options:
+            sort:
+              _id: 1
+      - :return:
+          _step: find
   - id: create_ticket_later
     type: Api
     routine:

package/lib/docs/dataSets/test/app/tests/data/shop.yaml

@@ -3,6 +3,10 @@ fixtures:
     - { _id: t-a1, organization_id: org_a, title: First }
     - { _id: t-a2, organization_id: org_a, title: Second }
     - { _id: t-b1, organization_id: org_b, title: Other org }
+  # The same collection name in another database: it loads into a session database of its own.
+  crm_tickets:
+    - { _id: t-a1, organization_id: org_a, title: CRM copy }
+    - { _id: crm-a2, organization_id: org_a, title: CRM only }
 users:
   owner: { id: u_1, roles: [admin], organizationId: org_a }
   outsider: { id: u_9, roles: [admin], organizationId: org_b }

package/lib/docs/devToolDefinitions.js

@@ -30,9 +30,9 @@ const INSTRUCTIONS = `Lowdefy documentation and feedback server for this project
 
 Discovery workflow: start with lowdefy_overview. Use lowdefy_list_types with a kind to discover ALL installed blocks/operators/actions/connections/requests — never guess type names. Then lowdefy_get_schema and lowdefy_get_examples for the exact contract of a type, and lowdefy_get_doc / lowdefy_search_docs for concept documentation. Icons: use a semantic name (icon: edit); otherwise use a Lucide name in PascalCase (icon: Receipt) found with lowdefy_search_icons; never invent an icon name, never emoji; in any HTML string use <i data-icon="edit"></i>, data-tooltip="…" and data-popover="…", ClickableHtml with data-event for clicks (list each event in its dataEvents property; escape request and user data in the HTML), <a data-page-id="page" data-url-query="k=v"> for in-app links (never a hard-coded href; data-new-tab, not target), and data-tag="success" / data-status="success" for statuses (never inline-styled pills), <time datetime="…" data-time="relative">, data-format="currency" data-currency="USD" on raw numbers, data-avatar="Name" (never an avatar image service), data-copy, data-truncate="2", data-tone="secondary" (never inline grey colours) and, in ClickableHtml, confirm on destructive events in dataEvents ({ name: onDelete, confirm: "…" }); lowdefy_get_doc concepts/html-attributes lists them all. lowdefy_search_docs and lowdefy_get_doc also cover the docs this app's own plugins and modules ship (READMEs, docs/*.md, and modules/<id>/manifest for a module's components, exports and vars), so read those before reading plugin or module source.
 
-Push events: build results, server restarts and browser/server errors arrive as notifications/message from logger "lowdefy" (data.type is one of build, restart, client_error, server_error; a build event carries status, errors, warnings and stale). Act on them without polling — lowdefy_build_status remains the full picture.
+Push events: build results, server restarts and browser/server errors arrive as notifications/message from logger "lowdefy" (data.type is one of build, restart, client_error, server_error; a build event carries status, errors, warnings and stale, for the config build only: pages build on request and send no event). Act on them without polling — lowdefy_build_status remains the full picture, and the only one that reports pages that fail to build.
 
-Feedback loop: after EVERY config edit, call lowdefy_build_status with wait: true — the dev server rebuilds on file change, wait: true answers once your edit has been processed and the pages it touched have been built, and this returns the current build errors/warnings (with source file locations), the pages that fail to build (pages.failed), recent browser runtime errors, and recent server errors (request, endpoint, MCP and agent failures with their config source). Errors reported before your latest edit are listed apart under earlierErrors, since they may already be fixed. Fix what it reports, then confirm the page builds with lowdefy_get_page_config, and visually verify with lowdefy_screenshot_page. Use lowdefy_find_config to locate where any id (page, block, request) is defined. lowdefy_scaffold_page creates a canonical new page file. Use lowdefy_app_map first to understand an existing app. If a tool result begins with "STALE:", the last build FAILED and the answer comes from the previous successful build, not from your latest edits — call lowdefy_build_status and fix the reported errors before trusting anything else.
+Feedback loop: after EVERY config edit, call lowdefy_build_status with wait: true — the dev server rebuilds on file change, wait: true answers once your edit has been processed and the pages it touched have been built, and this returns build.status (ok when the config builds and no page failed its latest build; pages_failed, with failedPages naming them, when a page failed its latest build and has not changed since; error when the config build fails), the build errors/warnings and each failed page's errors (with source file locations), recent browser runtime errors, and recent server errors (request, endpoint, MCP and agent failures with their config source). Errors reported before your latest edit are listed apart under earlierErrors, since they may already be fixed. Fix what it reports, then confirm the page builds with lowdefy_get_page_config, and visually verify with lowdefy_screenshot_page. Use lowdefy_find_config to locate where any id (page, block, request) is defined. lowdefy_scaffold_page creates a canonical new page file. Use lowdefy_app_map first to understand an existing app. If a tool result begins with "STALE:", the last build FAILED and the answer comes from the previous successful build, not from your latest edits — call lowdefy_build_status and fix the reported errors before trusting anything else.
 
 Live state: lowdefy_inspect_state reads the ACTUAL state, request results, and event log of a running page — when the developer has the page open in their browser it reads THEIR live tab (ask them to interact, then inspect), otherwise it runs the page headless. lowdefy_eval_operator evaluates any operator expression against that live state — use it to debug _state/_request bindings. lowdefy_run_request executes a request with a test payload to verify data shape (read-only unless the app opts into writes). A request or endpoint response too large to return inline is written in full to a file under .lowdefy/responses/ and the result gives its path as responseFile; pass saveResponse: true to always write it there. lowdefy_run_endpoint runs an Api endpoint routine headlessly with a test payload (always needs cli.agentTools.allowWriteRequests, since routines are not classified read-only); a :reject comes back as status "reject" with the routine's own error, not as a tool failure. Pass system: true to run a scheduled or detached-only InternalApi routine as a system context (no _user, auth not checked), exactly as cron would.
 
@@ -231,7 +231,7 @@ const devToolDefinitions = {
 
   lowdefy_build_status: {
     description:
-      'Call after every config edit. Returns the current build status: errors and warnings from the last config build (with source file locations), the page builds (pages: failed lists the pages whose last build failed with their errors, changedSinceBuild the pages changed since they were built, unbuilt how many pages nothing has built since the dev server started), recent browser runtime errors, and recent server errors — request, endpoint, MCP and agent tool failures with their config source. Errors reported under an earlier build come apart under earlierErrors. The dev server rebuilds automatically on file change — edit, then call this with wait: true to see what broke.',
+      'Call after every config edit. Returns the current build status: build.status is ok when the config build succeeds and no page failed its latest build, pages_failed (with build.failedPages naming the pages) when the config builds but a page failed its latest build and has not changed since, and error when the config build fails; build.configStatus is the status of the config build alone. A failed page changed since its last build is not counted until it is rebuilt: it is listed under pages.changedSinceBuild, and wait: true rebuilds it. Then the errors and warnings from the last config build (with source file locations), the page builds (pages: failed holds the errors of each failed page, changedSinceBuild the pages changed since they were built, unbuilt how many pages nothing has built since the dev server started), recent browser runtime errors, and recent server errors — request, endpoint, MCP and agent tool failures with their config source. Errors reported under an earlier build come apart under earlierErrors. The dev server rebuilds automatically on file change — edit, then call this with wait: true to see what broke.',
     inputSchema: {
       wait: z
         .boolean()

package/lib/docs/getBrowser.js

@@ -127,7 +127,7 @@ async function openPage({
       ]);
     }
     // A journey on a data set: every request from this context reads the data
-    // session's database (see lib/server/applyDataSetRedirect.js), while the
+    // session's databases (see lib/server/applyDataSetRedirect.js), while the
     // developer's own tabs keep the app's real one. Set before the first
     // navigation, so no request from this context ever goes without it.
     if (!type.isUndefined(dataCookie)) {

package/lib/docs/getBuildStatus.js

@@ -32,6 +32,30 @@ function splitByBuild({ entries, buildId }) {
   };
 }
 
+// buildStatus.json covers the config build only; pages build later, on first
+// request. So that build.status alone answers "does the app build", an ok
+// config build with a failed page reads pages_failed, and failedPages names
+// those pages. A failed page changed since that build is left out: its failure
+// may already be fixed, and pages.changedSinceBuild lists it until it is
+// rebuilt. A config build that is not ok keeps its status and names no pages,
+// since the config is what to fix first. The page errors stay under
+// pages.failed either way. configStatus keeps the config build's own status for
+// callers that wait on a published config build, whatever the pages do.
+function withFailedPages({ build, pages }) {
+  const configBuild = { ...build, configStatus: build.status };
+  if (build.status !== 'ok') {
+    return configBuild;
+  }
+  const changedSinceBuild = new Set(pages.changedSinceBuild ?? []);
+  const failedPages = (pages.failed ?? [])
+    .map(({ pageId }) => pageId)
+    .filter((pageId) => !changedSinceBuild.has(pageId));
+  if (failedPages.length === 0) {
+    return configBuild;
+  }
+  return { ...configBuild, status: 'pages_failed', failedPages };
+}
+
 // Notices about Lowdefy's agent block (see checkAgentFiles), checked on every
 // read: the root files are not watched, so a stored result would outlive a fix.
 async function getAgentFiles() {
@@ -43,7 +67,8 @@ async function getAgentFiles() {
 }
 
 // Feedback loop for agents: build status (written by the build manager to
-// build/buildStatus.json), the page builds (see getPageBuildStatus), plus
+// build/buildStatus.json, with page failures folded in by withFailedPages),
+// the page builds (see getPageBuildStatus), plus
 // recent browser errors reported via POST /api/client-error, plus recent server
 // errors (request, endpoint, MCP and agent tool failures) collected by
 // createHandleError. Lets an agent check "did my last edit work?" without
@@ -61,10 +86,11 @@ async function getBuildStatus({ checked } = {}) {
   const buildId = getBuildId();
   const clientErrors = splitByBuild({ entries: clientErrorStore.list(), buildId });
   const serverErrors = splitByBuild({ entries: serverErrorStore.list(), buildId });
+  const pages = await getPageBuildStatus({ checked });
   const status = {
     buildId,
-    build,
-    pages: await getPageBuildStatus({ checked }),
+    build: withFailedPages({ build, pages }),
+    pages,
     clientErrors: clientErrors.current,
     serverErrors: serverErrors.current,
   };

package/lib/docs/getBuildStatus.test.mjs

@@ -26,12 +26,108 @@ jest.unstable_mockModule('./serverErrorStore.js', () => ({ default: { list: mock
 jest.unstable_mockModule('./getBuildId.js', () => ({ default: () => 'build-2' }));
 const mockGetPageBuildStatus = jest.fn(() => ({ unbuilt: 0 }));
 jest.unstable_mockModule('./getPageBuildStatus.js', () => ({ default: mockGetPageBuildStatus }));
-jest.unstable_mockModule('./readBuildArtifact.js', () => ({
-  default: () => ({ status: 'ok', errors: [], warnings: ['a build warning'] }),
-}));
+const okBuild = () => ({ status: 'ok', errors: [], warnings: ['a build warning'] });
+const mockReadBuildArtifact = jest.fn(okBuild);
+jest.unstable_mockModule('./readBuildArtifact.js', () => ({ default: mockReadBuildArtifact }));
 
 const { default: getBuildStatus } = await import('./getBuildStatus.js');
 
+describe('page failures in build.status', () => {
+  const failed = [
+    { pageId: 'orders', errors: [{ type: 'ConfigError', message: 'Bad.', source: null }] },
+    { pageId: 'invoices', errors: [{ type: 'ConfigError', message: 'Worse.', source: null }] },
+  ];
+
+  beforeEach(() => {
+    mockClientErrors.mockReturnValue([]);
+    mockServerErrors.mockReturnValue([]);
+  });
+
+  afterEach(() => {
+    mockReadBuildArtifact.mockImplementation(okBuild);
+    mockGetPageBuildStatus.mockImplementation(() => ({ unbuilt: 0 }));
+  });
+
+  test('reads pages_failed and names the pages when the config builds but a page fails', async () => {
+    mockGetPageBuildStatus.mockResolvedValue({ failed, unbuilt: 0 });
+
+    const status = await getBuildStatus();
+
+    expect(status.build).toEqual({
+      status: 'pages_failed',
+      configStatus: 'ok',
+      errors: [],
+      warnings: ['a build warning'],
+      failedPages: ['orders', 'invoices'],
+    });
+    expect(status.pages.failed).toEqual(failed);
+  });
+
+  test('keeps error and names no pages when the config build failed too', async () => {
+    mockReadBuildArtifact.mockReturnValue({
+      status: 'error',
+      errors: ['Bad config.'],
+      warnings: [],
+    });
+    mockGetPageBuildStatus.mockResolvedValue({ failed: failed.slice(0, 1), unbuilt: 0 });
+
+    const status = await getBuildStatus();
+
+    expect(status.build.status).toBe('error');
+    expect(status.build.configStatus).toBe('error');
+    expect(status.build).not.toHaveProperty('failedPages');
+    expect(status.pages.failed).toEqual(failed.slice(0, 1));
+  });
+
+  test('keeps unknown and names no pages before the first config build is written', async () => {
+    mockReadBuildArtifact.mockReturnValue(null);
+    mockGetPageBuildStatus.mockResolvedValue({ failed, unbuilt: 0 });
+
+    const { build } = await getBuildStatus();
+
+    expect(build.status).toBe('unknown');
+    expect(build.configStatus).toBe('unknown');
+    expect(build).not.toHaveProperty('failedPages');
+  });
+
+  test('leaves out a failed page changed since its last build, since its failure may be fixed', async () => {
+    mockGetPageBuildStatus.mockResolvedValue({
+      failed,
+      changedSinceBuild: ['orders'],
+      unbuilt: 0,
+    });
+
+    const { build } = await getBuildStatus();
+
+    expect(build.status).toBe('pages_failed');
+    expect(build.failedPages).toEqual(['invoices']);
+  });
+
+  test('stays ok when every failed page has changed since its last build', async () => {
+    mockGetPageBuildStatus.mockResolvedValue({
+      failed: failed.slice(0, 1),
+      changedSinceBuild: ['orders', 'home'],
+      unbuilt: 0,
+    });
+
+    const status = await getBuildStatus();
+
+    expect(status.build.status).toBe('ok');
+    expect(status.build).not.toHaveProperty('failedPages');
+    expect(status.pages.failed).toEqual(failed.slice(0, 1));
+  });
+
+  test('stays ok with no failedPages when every built page builds', async () => {
+    mockGetPageBuildStatus.mockResolvedValue({ checked: ['orders'], unbuilt: 2 });
+
+    const { build } = await getBuildStatus({ checked: ['orders'] });
+
+    expect(build.status).toBe('ok');
+    expect(build.configStatus).toBe('ok');
+    expect(build).not.toHaveProperty('failedPages');
+  });
+});
+
 test('getBuildStatus lists errors from earlier builds apart from the current ones', async () => {
   mockClientErrors.mockReturnValue([
     { message: 'old render error', buildId: 'build-1' },

package/lib/docs/getOverview.js

@@ -121,8 +121,8 @@ function getOverview() {
     '',
     'The dev server rebuilds automatically when config files change. After EVERY edit:',
     '',
-    '1. **Check what broke**: `GET /lowdefy-docs/build-status?wait=true` — or `lowdefy_build_status` with `wait: true`, which answers once your latest edit has been processed and the pages it touched have been built. Current build errors and warnings with source file locations, the pages that fail to build (`pages.failed`), plus recent browser runtime errors. Errors from before the latest edit come apart under `earlierErrors`.',
-    '   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`).',
+    '1. **Check what broke**: `GET /lowdefy-docs/build-status?wait=true` — or `lowdefy_build_status` with `wait: true`, which answers once your latest edit has been processed and the pages it touched have been built. `build.status` is `ok` when the config builds and no page failed its latest build: `pages_failed` (with `build.failedPages` naming the pages) when a page failed its latest build and has not changed since, `error` when the config build fails. Then the build errors and warnings and the errors of each failed page, with source file locations, plus recent browser runtime errors. Errors from before the latest edit come apart under `earlierErrors`.',
+    '   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`). A `build` event covers the config build only, so check build status for pages that fail to build.',
     '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; `?viewportWidth=390&colorScheme=dark` (the tool's `width` and `colorScheme`) checks a phone layout in dark mode.",
     '4. **Verify behaviour**: `POST /lowdefy-docs/journey` `{pageId, steps, user, urlQuery, state}` — or `lowdefy_run_journey`. Drive the page headless with declarative steps (`click`, `fill`, `select`, `press`, `back`, `goto`, `email`, `as`, `wait`, `screenshot`, `expect: { state | visible | text | url | title }`) and assert what happens. `user: "none"` injects no caller, so sign-up, sign-in and invitations run through the app\'s own auth. 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. A final state over 10000 characters comes back as `stateOmitted` (its size and top-level keys); pass `state: [paths]` for the paths you need, `true` for all of it or `false` for none.',

package/lib/docs/rails/findExternalBlocks.js

@@ -20,9 +20,9 @@ import pageBlocks from '../pageBlocks.js';
 import readBuiltArtifact from './readBuiltArtifact.js';
 import readRoutineSteps from '../readRoutineSteps.js';
 
-// The meta.dataSet declarations a data session runs against the session's database (see
-// lib/server/applyDataSetRedirect.js): 'redirect' takes the session database, 'walled' reaches it
-// only through walled connections. Every other declaration, or none, would reach a real service or
+// The meta.dataSet declarations a data session runs against the session's databases (see
+// lib/server/applyDataSetRedirect.js): 'redirect' takes its target's session database, 'walled'
+// reaches them only through walled connections. Every other declaration, or none, would reach a real service or
 // is refused by the gate.
 const CLICKABLE_DATA_SET_MODES = new Set(['redirect', 'walled']);
 

package/lib/docs/runJourneyDataSet.test.mjs

@@ -59,7 +59,7 @@ const dataSet = {
   fixtures: { tickets: [{ _id: 't1' }, { _id: 't2' }], companies: [{ _id: 'c1' }] },
   generated: { invoices: [{ _id: 'i1' }] },
   users: { outsider: { id: 'u_9', roles: ['admin'], organizationId: 'org_b' } },
-  warnings: ['Connections "a" and "b" both name collection "events" in different databases.'],
+  warnings: ['Data set "sample" loads 1,200 documents for connection "tickets".'],
 };
 
 let order;

package/lib/docs/withDataSession.js

@@ -19,8 +19,8 @@ import { type } from '@lowdefy/helpers';
 import getDataStore from './dataSets/getDataStore.js';
 import openDataSession from './dataSets/openDataSession.js';
 
-// Runs `task` on a data set's own database when the call named one: a fresh
-// database on the dev server's memory store, loaded with the data set and
+// Runs `task` on a data set's own databases when the call named one: fresh
+// databases on the dev server's memory store, loaded with the data set and
 // dropped once the task settles, exactly as a journey's. The task gets
 // `dataCookie` (for a headless browser context, see openPage) and
 // `dataSession` (for a context the dev server builds itself, see

package/lib/server/applyDataSetRedirect.js

@@ -17,6 +17,8 @@
 import { mergeObjects, type } from '@lowdefy/helpers';
 
 import createDataSetRefusal from './createDataSetRefusal.js';
+import describeTargetKey from '../docs/dataSets/describeTargetKey.js';
+import sessionDatabaseName from '../docs/dataSets/sessionDatabaseName.js';
 
 // Module connections are written under their module's folder (connections/<module>/<id>.json), so
 // the pattern matches every depth.
@@ -29,13 +31,16 @@ function hasLiteralKeys(properties) {
 }
 
 // The one gate for connections under a data session, for this request only. It fails closed: a
-// connection is either verifiably pointed at the session's database or the read throws. A type
+// connection is either verifiably pointed at a session database or the read throws. A type
 // declares how it behaves through meta.dataSet on its plugin, in one of three modes:
-// - 'redirect' takes its database from databaseUri and databaseName, so the session's are merged
-//   over its properties whether or not the data set lists it.
+// - 'redirect' takes its database from databaseUri and databaseName, so the session's URI and the
+//   session database of its own target (its databaseUri secret or literal and databaseName) are
+//   merged over its properties whether or not the data set lists it. Connections on different
+//   targets read different databases, as they do outside the session; one whose target is computed
+//   per request reads the session's first database.
 // - 'walled' holds no database address and reaches MongoDB only through the walled client (the
 //   resolver's walled(connectionId) argument), so it passes unchanged: the walled connections it
-//   names are read through this same gate and take the session database as redirect connections.
+//   names are read through this same gate and take their session databases as redirect connections.
 // - 'external' reaches an outside service and keeps its target.
 // Anything else, including no declaration, refuses. The gate cannot verify a walled or external
 // declaration, since properties are evaluated later and may read secrets: it is the plugin
@@ -70,11 +75,15 @@ function applyDataSetRedirect({ context, session, connections }) {
         reason: 'its properties are an operator, so the redirect cannot be checked',
       });
     }
+    const target = describeTargetKey({ properties: artifact.properties });
     return {
       ...artifact,
       properties: mergeObjects([
         artifact.properties,
-        { databaseUri: session.databaseUri, databaseName: session.databaseName },
+        {
+          databaseUri: session.databaseUri,
+          databaseName: sessionDatabaseName({ session, target }),
+        },
       ]),
     };
   };