@lowdefy/server-dev 6.1.0 → 7.1.0

package/lib/client/utils/usePageConfig.test.mjs

@@ -15,6 +15,7 @@
 */
 
 import { jest } from '@jest/globals';
+import { callerStamp } from '@lowdefy/helpers';
 
 // usePageConfig imports swr and useMutateCache only for the hook; the fetcher
 // under test needs neither. Mock them so the module loads in the node test env.
@@ -24,39 +25,223 @@ jest.unstable_mockModule('./useMutateCache.js', () => ({
   getReloadVersion: jest.fn(),
 }));
 
-const { fetchPageConfig } = await import('./usePageConfig.js');
+const { getNavVersion, getReloadVersion } = await import('./useMutateCache.js');
+const { fetchPageConfig, getPageConfigKey, recordDynamicPage } = await import('./usePageConfig.js');
 
-function mockJsonResponse(body) {
-  return { status: 200, ok: true, json: async () => body };
+beforeEach(() => {
+  getNavVersion.mockReturnValue(0);
+  getReloadVersion.mockReturnValue(0);
+});
+
+function mockJsonResponse(body, { headers = {} } = {}) {
+  return { status: 200, ok: true, headers: new Headers(headers), json: async () => body };
 }
 
+beforeEach(() => {
+  const stored = {};
+  global.window = {
+    location: { reload: jest.fn() },
+    sessionStorage: {
+      getItem: (key) => stored[key] ?? null,
+      setItem: (key, value) => {
+        stored[key] = value;
+      },
+    },
+  };
+});
+
 afterEach(() => {
   delete global.fetch;
+  delete global.window;
 });
 
 test('fetchPageConfig compiles inlined _jsEntries module text into a { hash: fn } object', async () => {
   global.fetch = jest.fn(async () =>
     mockJsonResponse({
-      id: 'p',
-      _jsEntries: "export default { 'h1': ({ args }) => { return args.x + 1; } };",
-      _dynamicIcons: { FiZap: { tag: 'svg' } },
+      pageId: 'p',
+      pathParams: {},
+      matchedPath: 'p',
+      pageConfig: {
+        id: 'page:p',
+        _jsEntries: "export default { 'h1': ({ args }) => { return args.x + 1; } };",
+        _dynamicIcons: { Zap: { node: [['path', { d: 'M0 0' }]] } },
+      },
     })
   );
 
-  const data = await fetchPageConfig('http://localhost/api/page/p');
+  const { pageConfig } = await fetchPageConfig('http://localhost/api/page/p', {
+    lowdefy: {},
+    user: null,
+  });
 
-  expect(typeof data._jsEntries.h1).toBe('function');
-  expect(data._jsEntries.h1({ args: { x: 1 } })).toBe(2);
+  expect(typeof pageConfig._jsEntries.h1).toBe('function');
+  expect(pageConfig._jsEntries.h1({ args: { x: 1 } })).toBe(2);
   // _dynamicIcons passes through untouched.
-  expect(data._dynamicIcons).toEqual({ FiZap: { tag: 'svg' } });
+  expect(pageConfig._dynamicIcons).toEqual({ Zap: { node: [['path', { d: 'M0 0' }]] } });
 });
 
 test('fetchPageConfig issues only the page-config request — no /api/js or /api/icons fetch', async () => {
-  global.fetch = jest.fn(async () => mockJsonResponse({ id: 'p' }));
+  global.fetch = jest.fn(async () =>
+    mockJsonResponse({
+      pageId: 'p',
+      pathParams: {},
+      matchedPath: 'p',
+      pageConfig: { id: 'page:p' },
+    })
+  );
 
-  const data = await fetchPageConfig('http://localhost/api/page/p');
+  const data = await fetchPageConfig('http://localhost/api/page/p', { lowdefy: {}, user: null });
 
-  expect(data._jsEntries).toBeUndefined();
+  expect(data.pageConfig._jsEntries).toBeUndefined();
   expect(global.fetch).toHaveBeenCalledTimes(1);
   expect(global.fetch.mock.calls[0][0]).toBe('http://localhost/api/page/p');
 });
+
+test('getPageConfigKey leaves the query string out of a page not known to be dynamic', () => {
+  const pageUrl = '/api/page/static-page';
+  getNavVersion.mockReturnValue(1);
+  const first = getPageConfigKey({ pageUrl, search: '?file=a' });
+  getNavVersion.mockReturnValue(2);
+  const second = getPageConfigKey({ pageUrl, search: '?file=b' });
+
+  expect(first).toEqual([pageUrl, 0]);
+  expect(second).toEqual(first);
+});
+
+test('getPageConfigKey keeps a static page keyed without the query after its fetch', () => {
+  const pageUrl = '/api/page/static-fetched';
+  recordDynamicPage({ data: { pageConfig: { id: 'page:static-fetched' } }, pageUrl });
+  getNavVersion.mockReturnValue(3);
+
+  expect(getPageConfigKey({ pageUrl, search: '?q=1' })).toEqual([pageUrl, 0]);
+});
+
+test('getPageConfigKey keeps the static key for the navigation that found a page dynamic', () => {
+  const pageUrl = '/api/page/dynamic-first';
+  getNavVersion.mockReturnValue(4);
+  const beforeFetch = getPageConfigKey({ pageUrl, search: '?q=1' });
+  recordDynamicPage({ data: { pageConfig: { dynamic: true } }, pageUrl });
+  const afterFetch = getPageConfigKey({ pageUrl, search: '?q=1' });
+
+  expect(afterFetch).toEqual(beforeFetch);
+});
+
+test('getPageConfigKey keys a known dynamic page on the query and navigation version', () => {
+  const pageUrl = '/api/page/dynamic-later';
+  getNavVersion.mockReturnValue(5);
+  recordDynamicPage({ data: { pageConfig: { dynamic: true } }, pageUrl });
+  getNavVersion.mockReturnValue(6);
+  const sixth = getPageConfigKey({ pageUrl, search: '?q=1' });
+  // A later fetch of the known dynamic page must not move it back to the static key.
+  recordDynamicPage({ data: { pageConfig: { dynamic: true } }, pageUrl });
+  const sixthAfterFetch = getPageConfigKey({ pageUrl, search: '?q=1' });
+  getNavVersion.mockReturnValue(7);
+  const seventh = getPageConfigKey({ pageUrl, search: '?q=1' });
+
+  expect(sixth).toEqual([pageUrl, 0, '?q=1', 6]);
+  expect(sixthAfterFetch).toEqual(sixth);
+  expect(seventh).toEqual([pageUrl, 0, '?q=1', 7]);
+});
+
+test('getPageConfigKey returns to the static key when a dynamic page is no longer dynamic', () => {
+  const pageUrl = '/api/page/dynamic-removed';
+  getNavVersion.mockReturnValue(8);
+  recordDynamicPage({ data: { pageConfig: { dynamic: true } }, pageUrl });
+  getReloadVersion.mockReturnValue(1);
+  getNavVersion.mockReturnValue(9);
+  recordDynamicPage({ data: { pageConfig: { id: 'page:dynamic-removed' } }, pageUrl });
+
+  expect(getPageConfigKey({ pageUrl, search: '?q=1' })).toEqual([pageUrl, 1]);
+});
+
+test('fetchPageConfig returns the page a patterned path matched with its values', async () => {
+  global.fetch = jest.fn(async () =>
+    mockJsonResponse({
+      pageId: 'ticket',
+      pathParams: { space: 'a+b', ticket_id: '1' },
+      matchedPath: 'tickets/a%2Bb/1',
+      pageConfig: { id: 'page:ticket', path: 'tickets/{space}/{ticket_id}' },
+    })
+  );
+
+  const data = await fetchPageConfig('http://localhost/api/page/tickets/a%2Bb/1', {
+    lowdefy: {},
+    user: null,
+  });
+
+  expect(global.fetch.mock.calls[0][0]).toBe('http://localhost/api/page/tickets/a%2Bb/1');
+  expect(data).toEqual({
+    pageId: 'ticket',
+    pathParams: { space: 'a+b', ticket_id: '1' },
+    matchedPath: 'tickets/a%2Bb/1',
+    pageConfig: { id: 'page:ticket', path: 'tickets/{space}/{ticket_id}' },
+  });
+});
+
+test('fetchPageConfig reloads instead of settling when the server answered as another caller', async () => {
+  global.fetch = jest.fn(async () =>
+    mockJsonResponse(
+      { pageId: 'p', pathParams: {}, matchedPath: 'p', pageConfig: { id: 'page:p' } },
+      { headers: { 'x-lowdefy-caller': 'aaaaaaaaaaaaaaaa' } }
+    )
+  );
+  const settled = jest.fn();
+  fetchPageConfig('http://localhost/api/page/p', {
+    lowdefy: {},
+    user: { id: 'user_1', organization_id: 'org_1' },
+  }).then(settled);
+  await new Promise((resolve) => setTimeout(resolve, 20));
+  expect(global.window.location.reload).toHaveBeenCalledTimes(1);
+  expect(settled).not.toHaveBeenCalled();
+});
+
+test('fetchPageConfig returns the page when the server answered as the rendered caller', async () => {
+  global.fetch = jest.fn(async () =>
+    mockJsonResponse(
+      { pageId: 'p', pathParams: {}, matchedPath: 'p', pageConfig: { id: 'page:p' } },
+      { headers: { 'x-lowdefy-caller': '' } }
+    )
+  );
+  const data = await fetchPageConfig('http://localhost/api/page/p', { lowdefy: {}, user: null });
+  expect(data.pageId).toBe('p');
+  expect(global.window.location.reload).not.toHaveBeenCalled();
+});
+
+test('fetchPageConfig reloads when the server answered the rendered caller with other roles', async () => {
+  const user = { id: 'user_1', organization_id: 'org_1', roles: ['editor', 'admin'] };
+  global.fetch = jest.fn(async () =>
+    mockJsonResponse(
+      { pageId: 'p', pathParams: {}, matchedPath: 'p', pageConfig: { id: 'page:p' } },
+      { headers: { 'x-lowdefy-caller': callerStamp({ user: { ...user, roles: ['editor'] } }) } }
+    )
+  );
+  const settled = jest.fn();
+  fetchPageConfig('http://localhost/api/page/p', { lowdefy: {}, user }).then(settled);
+  await new Promise((resolve) => setTimeout(resolve, 20));
+  expect(global.window.location.reload).toHaveBeenCalledTimes(1);
+  expect(settled).not.toHaveBeenCalled();
+});
+
+test('fetchPageConfig keeps the caller stamp of a page answered as the rendered caller', async () => {
+  const user = { id: 'user_1', organization_id: 'org_1', roles: ['editor', 'admin'] };
+  // The fixed vector callerStamp's own tests pin, so server and client agree.
+  const header =
+    '82e92667feb5824d; session=3a1d7b6848ba4816; roles=228d50a09b1b1e2b; memberships=476954726056d64d';
+  global.fetch = jest.fn(async () =>
+    mockJsonResponse(
+      { pageId: 'p', pathParams: {}, matchedPath: 'p', pageConfig: { id: 'page:p' } },
+      { headers: { 'x-lowdefy-caller': header } }
+    )
+  );
+  // The first page config arrives before the page context exists.
+  const lowdefy = {};
+  const data = await fetchPageConfig('http://localhost/api/page/p', { lowdefy, user });
+  expect(data.pageId).toBe('p');
+  expect(global.window.location.reload).not.toHaveBeenCalled();
+  expect(lowdefy._internal.callerStamp).toEqual({
+    caller: '82e92667feb5824d',
+    session: '3a1d7b6848ba4816',
+    roles: '228d50a09b1b1e2b',
+    memberships: '476954726056d64d',
+  });
+});

package/lib/configTree/buildConfigTree.mjs

@@ -0,0 +1,58 @@
+/*
+  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 path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { parseArgs } from 'node:util';
+import pino from 'pino';
+import { createNodeLogger } from '@lowdefy/logger/node';
+
+import runConfigTreeBuild from './runConfigTreeBuild.mjs';
+
+// Entry for `lowdefy journeys scope`'s base and head builds and the journey
+// readers' config text set: the CLI spawns
+// `node <dev>/lib/configTree/buildConfigTree.mjs --config <dir> --out <dir>`
+// from the installed dev server, which holds @lowdefy/build and the app's
+// plugins. Exits 1 when the build fails; <out>/result.json says why.
+async function buildConfigTree() {
+  const { values } = parseArgs({
+    options: { config: { type: 'string' }, out: { type: 'string' } },
+  });
+  const logger = createNodeLogger({
+    name: 'lowdefy config tree build',
+    level: process.env.LOWDEFY_LOG_LEVEL ?? 'info',
+    base: { pid: undefined, hostname: undefined },
+    destination: pino.destination({ dest: 1, sync: true }),
+  });
+  if (!values.config || !values.out) {
+    logger.error('buildConfigTree needs --config <dir> and --out <dir>.');
+    process.exitCode = 1;
+    return;
+  }
+  const result = await runConfigTreeBuild({
+    configDirectory: path.resolve(values.config),
+    outDirectory: path.resolve(values.out),
+    devDirectory: path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..'),
+    logger,
+    refResolver: process.env.LOWDEFY_BUILD_REF_RESOLVER,
+    skipPluginChecks: process.env.LOWDEFY_BUILD_SKIP_PLUGIN_CHECKS === 'true',
+  });
+  if (result.status !== 'ok') {
+    process.exitCode = 1;
+  }
+}
+
+await buildConfigTree();

package/lib/configTree/buildConfigTree.test.mjs

@@ -0,0 +1,77 @@
+/*
+  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 path from 'node:path';
+import { jest } from '@jest/globals';
+
+const mockRunConfigTreeBuild = jest.fn();
+let mockArgs = [];
+
+// parseArgs reads the real process.argv, which the test cannot set: jest gives
+// it a copy. The real parseArgs runs on the test's arguments instead.
+const actualUtil = await import('node:util');
+jest.unstable_mockModule('node:util', () => ({
+  ...actualUtil,
+  default: actualUtil.default,
+  parseArgs: (config) => actualUtil.parseArgs({ ...config, args: mockArgs }),
+}));
+
+jest.unstable_mockModule('./runConfigTreeBuild.mjs', () => ({
+  default: mockRunConfigTreeBuild,
+}));
+
+const savedSkip = process.env.LOWDEFY_BUILD_SKIP_PLUGIN_CHECKS;
+const savedExitCode = process.exitCode;
+let loadCount = 0;
+
+// buildConfigTree.mjs runs its build when imported, so each import is a fresh
+// module instance.
+async function runScript() {
+  loadCount += 1;
+  await import(`./buildConfigTree.mjs?case=${loadCount}`);
+}
+
+beforeEach(() => {
+  mockArgs = ['--config', '/app', '--out', '/out'];
+  delete process.env.LOWDEFY_BUILD_SKIP_PLUGIN_CHECKS;
+  mockRunConfigTreeBuild.mockReset();
+  mockRunConfigTreeBuild.mockResolvedValue({ status: 'ok', errors: [], warnings: [] });
+});
+
+afterAll(() => {
+  process.exitCode = savedExitCode;
+  if (savedSkip === undefined) {
+    delete process.env.LOWDEFY_BUILD_SKIP_PLUGIN_CHECKS;
+  } else {
+    process.env.LOWDEFY_BUILD_SKIP_PLUGIN_CHECKS = savedSkip;
+  }
+});
+
+test('buildConfigTree passes skipPluginChecks true when LOWDEFY_BUILD_SKIP_PLUGIN_CHECKS is true', async () => {
+  process.env.LOWDEFY_BUILD_SKIP_PLUGIN_CHECKS = 'true';
+  await runScript();
+  expect(mockRunConfigTreeBuild).toHaveBeenCalledTimes(1);
+  const [args] = mockRunConfigTreeBuild.mock.calls[0];
+  expect(args.configDirectory).toEqual(path.resolve('/app'));
+  expect(args.outDirectory).toEqual(path.resolve('/out'));
+  expect(args.skipPluginChecks).toBe(true);
+});
+
+test('buildConfigTree passes skipPluginChecks false when LOWDEFY_BUILD_SKIP_PLUGIN_CHECKS is unset', async () => {
+  await runScript();
+  expect(mockRunConfigTreeBuild).toHaveBeenCalledTimes(1);
+  expect(mockRunConfigTreeBuild.mock.calls[0][0].skipPluginChecks).toBe(false);
+});

package/lib/configTree/collectConfigText.mjs

@@ -0,0 +1,101 @@
+/*
+  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 fs from 'node:fs';
+import path from 'node:path';
+import { type } from '@lowdefy/helpers';
+import { normaliseClickText } from '@lowdefy/node-utils';
+
+// Build markers: their values are key and reference ids, not text the app
+// shows.
+const MARKER_KEYS = new Set(['~k', '~r', '~l', '~ignoreBuildChecks']);
+const ANTD_LOCALE_NAME = /^[A-Za-z]{2,3}(_[A-Za-z0-9]+)*$/;
+
+// Strings only: a number leaf is not config text, so a page size of 42 never
+// resolves a grid cell showing "42".
+function addStringLeaves({ value, texts }) {
+  if (type.isString(value)) {
+    const text = normaliseClickText(value);
+    if (!type.isNone(text)) texts.add(text);
+    return;
+  }
+  if (type.isArray(value)) {
+    value.forEach((item) => addStringLeaves({ value: item, texts }));
+    return;
+  }
+  if (type.isObject(value)) {
+    Object.entries(value).forEach(([key, item]) => {
+      if (MARKER_KEYS.has(key)) return;
+      addStringLeaves({ value: item, texts });
+    });
+  }
+}
+
+function readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+function listPageArtifacts({ buildDirectory }) {
+  const pagesDirectory = path.join(buildDirectory, 'pages');
+  if (!fs.existsSync(pagesDirectory)) return [];
+  return fs
+    .readdirSync(pagesDirectory, { withFileTypes: true })
+    .filter((entry) => entry.isFile() && entry.name.endsWith('.json'))
+    .map((entry) => path.join(pagesDirectory, entry.name))
+    .sort();
+}
+
+// antd shows its own strings (OK, Cancel, pagination) in the locale the app
+// declares for it; an app with no i18n, or a locale with no antd name, gets
+// antd's default, en_US.
+function listAntdLocales({ i18n }) {
+  const locales = i18n.locales ?? [];
+  if (locales.length === 0) return ['en_US'];
+  const names = locales.map((locale) =>
+    type.isString(locale.antd) && ANTD_LOCALE_NAME.test(locale.antd) ? locale.antd : 'en_US'
+  );
+  return [...new Set(names)].sort();
+}
+
+async function importAntdLocale(name) {
+  const module = await import(`antd/locale/${name}.js`);
+  return module.default?.default ?? module.default ?? module;
+}
+
+// The app's config text set: every string an element of this app can show
+// that comes from the repository, never from data. Read after a full build
+// from its artifacts: every page's string leaves (operator arguments
+// included, so both branches of an _if count), menus.json, every locale's
+// messages in i18n.json, every plugin's default messages for every locale it
+// ships (i18n.json keeps only declared locales), and antd's locale strings.
+// Returns a sorted array of distinct strings, normalised as clicked text is.
+async function collectConfigText({ buildDirectory, messagesMap }) {
+  const texts = new Set();
+  listPageArtifacts({ buildDirectory }).forEach((filePath) => {
+    addStringLeaves({ value: readJson(filePath), texts });
+  });
+  addStringLeaves({ value: readJson(path.join(buildDirectory, 'menus.json')), texts });
+  const i18n = readJson(path.join(buildDirectory, 'i18n.json'));
+  addStringLeaves({ value: i18n.messages ?? {}, texts });
+  (i18n.locales ?? []).forEach((locale) => addStringLeaves({ value: locale.label, texts }));
+  addStringLeaves({ value: messagesMap, texts });
+  for (const name of listAntdLocales({ i18n })) {
+    addStringLeaves({ value: await importAntdLocale(name), texts });
+  }
+  return [...texts].sort();
+}
+
+export default collectConfigText;

package/lib/configTree/collectConfigText.test.mjs

@@ -0,0 +1,116 @@
+/*
+  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 fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import collectConfigText from './collectConfigText.mjs';
+
+let buildDirectory;
+beforeEach(() => {
+  buildDirectory = fs.mkdtempSync(path.join(os.tmpdir(), 'lowdefy-config-text-'));
+  fs.mkdirSync(path.join(buildDirectory, 'pages'));
+});
+afterEach(() => {
+  fs.rmSync(buildDirectory, { recursive: true, force: true });
+});
+
+function writeArtifact(name, value) {
+  fs.writeFileSync(path.join(buildDirectory, name), JSON.stringify(value));
+}
+
+const homePage = {
+  id: 'home',
+  type: 'Box',
+  '~k': 'k:1',
+  blocks: [
+    {
+      id: 'assign_button',
+      type: 'Button',
+      properties: { title: '  Assign\n  to me ', size: 42 },
+      '~r': 'r:1',
+    },
+    {
+      id: 'status_title',
+      type: 'Title',
+      properties: {
+        content: { _if: { test: { _state: 'open' }, then: 'Open items', else: 'Closed items' } },
+      },
+    },
+  ],
+};
+
+test('collectConfigText collects page strings, both _if branches, menus and every locale', async () => {
+  writeArtifact('pages/home.json', homePage);
+  writeArtifact('menus.json', [
+    {
+      id: 'default',
+      links: [{ id: 'home', type: 'MenuLink', properties: { title: 'Home page' } }],
+    },
+  ]);
+  writeArtifact('i18n.json', {
+    defaultLocale: 'en-US',
+    locales: [
+      { code: 'en-US', label: 'English', antd: 'en_US' },
+      { code: 'de-DE', label: 'Deutsch', antd: 'de_DE' },
+    ],
+    messages: { 'en-US': { save: 'Save' }, 'de-DE': { save: 'Speichern' } },
+  });
+  const texts = await collectConfigText({
+    buildDirectory,
+    messagesMap: {
+      '@acme/blocks': { 'en-US': { clear: 'Clear all' }, 'fr-FR': { clear: 'Tout effacer' } },
+    },
+  });
+  expect(texts).toEqual(expect.arrayContaining(['Assign to me', 'Open items', 'Closed items']));
+  expect(texts).toEqual(expect.arrayContaining(['Home page', 'Save', 'Speichern', 'Deutsch']));
+  expect(texts).toEqual(expect.arrayContaining(['Clear all', 'Tout effacer']));
+  expect(texts).toEqual([...texts].sort());
+  expect(new Set(texts).size).toEqual(texts.length);
+});
+
+test('collectConfigText leaves out numbers, build markers and empty strings', async () => {
+  writeArtifact('pages/home.json', { ...homePage, empty: '   ' });
+  writeArtifact('menus.json', []);
+  writeArtifact('i18n.json', {});
+  const texts = await collectConfigText({ buildDirectory, messagesMap: {} });
+  expect(texts).not.toContain('42');
+  expect(texts).not.toContain('k:1');
+  expect(texts).not.toContain('r:1');
+  expect(texts).not.toContain('');
+});
+
+test("collectConfigText adds antd's en_US strings for an app with no i18n", async () => {
+  writeArtifact('pages/home.json', homePage);
+  writeArtifact('menus.json', []);
+  writeArtifact('i18n.json', {});
+  const texts = await collectConfigText({ buildDirectory, messagesMap: {} });
+  expect(texts).toEqual(expect.arrayContaining(['OK', 'Cancel', 'Next Page']));
+});
+
+test("collectConfigText adds antd's strings for each declared locale's antd name", async () => {
+  writeArtifact('pages/home.json', homePage);
+  writeArtifact('menus.json', []);
+  writeArtifact('i18n.json', {
+    defaultLocale: 'de-DE',
+    locales: [{ code: 'de-DE', antd: 'de_DE' }],
+    messages: { 'de-DE': { save: 'Speichern' } },
+  });
+  const texts = await collectConfigText({ buildDirectory, messagesMap: {} });
+  expect(texts).toContain('Abbrechen');
+  expect(texts).not.toContain('Next Page');
+});

package/lib/configTree/prepareScratchServer.mjs

@@ -0,0 +1,46 @@
+/*
+  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 fs from 'node:fs';
+import path from 'node:path';
+
+// A build writes into its server directory as well as its build directory:
+// it rewrites package.json, cleans and refills public/ from public_default/,
+// rewrites lowdefy-build/tailwind/ and copies agent files in. A base or head
+// build for the journeys scope gets a scratch server directory of its own, so the
+// running dev server's directory (devDirectory) is only ever read: a copy of
+// its package.json and public_default/, and a symlink to its node_modules,
+// where block source collection resolves plugin packages.
+async function prepareScratchServer({ devDirectory, serverDirectory }) {
+  await fs.promises.rm(serverDirectory, { recursive: true, force: true });
+  await fs.promises.mkdir(serverDirectory, { recursive: true });
+  await fs.promises.copyFile(
+    path.join(devDirectory, 'package.json'),
+    path.join(serverDirectory, 'package.json')
+  );
+  await fs.promises.cp(
+    path.join(devDirectory, 'public_default'),
+    path.join(serverDirectory, 'public_default'),
+    { recursive: true }
+  );
+  await fs.promises.symlink(
+    path.join(devDirectory, 'node_modules'),
+    path.join(serverDirectory, 'node_modules'),
+    'dir'
+  );
+}
+
+export default prepareScratchServer;