@lowdefy/server-dev 6.1.0 → 7.0.0

package/lib/docs/resolveSource.test.mjs

@@ -73,7 +73,7 @@ test('resolveSource marks a user combined with source "tab" as invalid input', (
 
   expect(result.invalidInput).toBe(true);
   expect(result.error).toBe(
-    'inspectState cannot apply "user" to the developer\'s live tab — it carries their real session. Omit "source", or use "headless".'
+    'inspectState cannot apply "user" to the developer\'s live tab — it carries their real session and database. Omit "source", or use "headless".'
   );
   expect(result.tryTab).toBeUndefined();
 });

package/lib/docs/resolveToolCaller.js

@@ -0,0 +1,62 @@
+/*
+  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 { type } from '@lowdefy/helpers';
+
+import readDevAuthMode from './readDevAuthMode.js';
+import resolveJourneyDataSet from './dataSets/resolveJourneyDataSet.js';
+
+const SHAPE =
+  '"user" should be a user object, e.g. {"roles":["admin"]}, "none" to act signed out, or the name of a user in the data set named by "data".';
+
+// Who a dev tool call acts as, in the forms a journey takes: a user object
+// (merged over the roleless headless default), "none" (no injected caller,
+// so the app's own auth decides), or the name of a user in the data set
+// `data` names. A data set also runs the call on a fresh database of its own,
+// loaded with it (see withDataSession). Returns { user, dataSet } - user is
+// the object, "none" or undefined; dataSet is undefined without `data` - or
+// { error, invalidInput: true } for a caller the call cannot act as.
+async function resolveToolCaller({ user, data }) {
+  if (!type.isNone(data) && !type.isString(data)) {
+    return {
+      error: `"data" should be the name of a data set in tests/data/<name>.yaml. Received ${JSON.stringify(
+        data
+      )}.`,
+      invalidInput: true,
+    };
+  }
+  if (!type.isNone(user) && !type.isObject(user) && !type.isString(user)) {
+    return { error: `${SHAPE} Received ${JSON.stringify(user)}.`, invalidInput: true };
+  }
+  if (user === '') {
+    return { error: `${SHAPE} Received "".`, invalidInput: true };
+  }
+  const resolved = await resolveJourneyDataSet({
+    data,
+    user: user ?? undefined,
+    subject: 'call',
+    configDirectory: process.env.LOWDEFY_DIRECTORY_CONFIG ?? process.cwd(),
+    buildDirectory: path.join(process.cwd(), 'build'),
+    ...readDevAuthMode(),
+  });
+  if (!type.isUndefined(resolved.error)) {
+    return { error: resolved.error, invalidInput: true };
+  }
+  return { user: resolved.user, dataSet: resolved.dataSet };
+}
+
+export default resolveToolCaller;

package/lib/docs/reviewPage.js

@@ -0,0 +1,51 @@
+/*
+  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 pageBuildRecords from '../server/pageBuildRecords.js';
+import { reviewBuiltPage } from '../server/jitPageBuilder.js';
+
+async function readModifiedAt(filePath) {
+  try {
+    return (await fs.promises.stat(filePath)).mtimeMs;
+  } catch {
+    return null;
+  }
+}
+
+// A page built since the server started is edited when its next request would
+// rebuild it (see reviewBuiltPage): it was built on an earlier build context
+// (a config build was published since), or a change event since its build
+// touched it, which for a page whose build ran app code is any change event.
+// A page not built since the server started is edited when its own page file
+// changed after the start. signals is what syncBuildSignals returned.
+// Returns 'edited', 'unbuilt' (never built and not edited) or 'current'.
+async function reviewPage({ pageId, entry, configDirectory, signals }) {
+  if (pageBuildRecords.get(pageId)) {
+    return reviewBuiltPage({ pageId, ...signals });
+  }
+  const pageFileModifiedAt = entry?.refPath
+    ? await readModifiedAt(path.resolve(configDirectory, entry.refPath))
+    : null;
+  if (pageFileModifiedAt !== null && pageFileModifiedAt > performance.timeOrigin) {
+    return 'edited';
+  }
+  return 'unbuilt';
+}
+
+export default reviewPage;

package/lib/docs/reviewPageBuilds.js

@@ -0,0 +1,56 @@
+/*
+  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 pageBuildRecords from '../server/pageBuildRecords.js';
+import { syncBuildSignals } from '../server/jitPageBuilder.js';
+import reviewPage from './reviewPage.js';
+
+// Sorts the registered pages by what the dev server knows about them (see
+// reviewPage): edited, unbuilt, and failed, the pages whose last build failed,
+// with its errors. The build signals are read first, so an edit no page
+// request has seen yet is reviewed too; pages that share a file read it once,
+// through the build context's read cache.
+async function reviewPageBuilds() {
+  const buildDirectory = path.join(process.cwd(), 'build');
+  const configDirectory = process.env.LOWDEFY_DIRECTORY_CONFIG || process.cwd();
+  const signals = syncBuildSignals({ buildDirectory, configDirectory });
+  const registry = signals.registry ?? {};
+  const pageIds = Object.keys(registry);
+  const reviews = await Promise.all(
+    pageIds.map((pageId) =>
+      reviewPage({ pageId, entry: registry[pageId], configDirectory, signals })
+    )
+  );
+  const edited = [];
+  const unbuilt = [];
+  const failed = [];
+  pageIds.forEach((pageId, index) => {
+    const errors = pageBuildRecords.get(pageId)?.errors;
+    if (errors) {
+      failed.push({ pageId, errors });
+    }
+    if (reviews[index] === 'edited') {
+      edited.push(pageId);
+    } else if (reviews[index] === 'unbuilt') {
+      unbuilt.push(pageId);
+    }
+  });
+  return { edited, unbuilt, failed };
+}
+
+export default reviewPageBuilds;

package/lib/docs/reviewPageBuilds.test.mjs

@@ -0,0 +1,207 @@
+/*
+  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 { jest } from '@jest/globals';
+import os from 'node:os';
+import path from 'node:path';
+
+// reviewPageBuilds reads the build from process.cwd()/build and page files
+// from LOWDEFY_DIRECTORY_CONFIG: point both at a throwaway app, and build its
+// pages with the dev server's real page builder.
+const serverDirectory = fs.mkdtempSync(path.join(os.tmpdir(), 'lowdefy-review-pages-'));
+const buildDirectory = path.join(serverDirectory, 'build');
+const configDirectory = path.join(serverDirectory, 'config');
+process.chdir(serverDirectory);
+process.env.LOWDEFY_DIRECTORY_CONFIG = configDirectory;
+
+const { default: buildPageIfNeeded } = await import('../server/jitPageBuilder.js');
+const { default: buildEditedPages } = await import('./buildEditedPages.js');
+const { default: reviewPageBuilds } = await import('./reviewPageBuilds.js');
+
+// A JIT page build loads the build package's plugins on first use.
+jest.setTimeout(30000);
+
+const longAgo = new Date('2000-01-01T00:00:00.000Z');
+let lastSignal = 0;
+
+function writeFile(filePath, content) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, content);
+}
+
+function writeConfigFile(relativePath, content, { modified } = {}) {
+  const filePath = path.join(configDirectory, relativePath);
+  writeFile(filePath, content);
+  if (modified) {
+    fs.utimesSync(filePath, modified, modified);
+  }
+  return filePath;
+}
+
+// A config build's output, as far as a JIT page build reads it. Each call
+// publishes a new page registry, as a config build does.
+function publishBuild(pageIds) {
+  writeFile(path.join(buildDirectory, 'idCounter.json'), '{"prefix":"cfg1_","counter":10}');
+  writeFile(path.join(buildDirectory, 'installedPluginPackages.json'), '["@lowdefy/blocks-basic"]');
+  writeFile(path.join(buildDirectory, 'theme.json'), '{}');
+  const registry = Object.fromEntries(
+    pageIds.map((pageId) => [
+      pageId,
+      { pageId, auth: { public: true }, refId: `ref-${pageId}`, refPath: `pages/${pageId}.yaml` },
+    ])
+  );
+  const registryPath = path.join(buildDirectory, 'pageRegistry.json');
+  writeFile(`${registryPath}.staged`, JSON.stringify(registry));
+  fs.renameSync(`${registryPath}.staged`, registryPath);
+}
+
+// What the manager writes after a batch of watched changes.
+function signalChange() {
+  lastSignal += 1;
+  writeFile(path.join(buildDirectory, 'invalidatePages'), String(lastSignal));
+}
+
+function request(pageId) {
+  return buildPageIfNeeded({ pageId, buildDirectory, configDirectory }).then(
+    (result) => (result === true ? 'served' : 'built'),
+    () => 'failed'
+  );
+}
+
+beforeEach(() => {
+  fs.rmSync(configDirectory, { recursive: true, force: true });
+  writeConfigFile('package.json', '{"type":"module"}');
+});
+
+test('a built page whose files are unchanged is neither edited nor unbuilt', async () => {
+  writeConfigFile(
+    'pages/current.yaml',
+    'id: current\ntype: Box\nblocks:\n  - _ref: shared.yaml\n',
+    {
+      modified: longAgo,
+    }
+  );
+  writeConfigFile('shared.yaml', 'id: shared\ntype: Box\n', { modified: longAgo });
+  publishBuild(['current']);
+  await request('current');
+  signalChange();
+
+  expect(await reviewPageBuilds()).toEqual({ edited: [], unbuilt: [], failed: [] });
+});
+
+test('right after an edit, with no page request since, the edited pages are listed', async () => {
+  writeConfigFile('pages/a.yaml', 'id: a\ntype: Box\nblocks:\n  - _ref: shared.yaml\n');
+  writeConfigFile('pages/b.yaml', 'id: b\ntype: Box\n');
+  writeConfigFile('shared.yaml', 'id: shared\ntype: Box\n');
+  publishBuild(['a', 'b']);
+  await request('a');
+  await request('b');
+
+  writeConfigFile('shared.yaml', 'id: shared\ntype: Box\nproperties:\n  title: New\n');
+  signalChange();
+
+  expect((await reviewPageBuilds()).edited).toEqual(['a']);
+});
+
+test('a built page is edited when a file its build read is gone', async () => {
+  writeConfigFile('pages/removed.yaml', 'id: removed\ntype: Box\n');
+  publishBuild(['removed']);
+  await request('removed');
+  fs.rmSync(path.join(configDirectory, 'pages/removed.yaml'));
+  signalChange();
+
+  expect((await reviewPageBuilds()).edited).toEqual(['removed']);
+});
+
+test('after an unrelated edit, a page whose build ran app code is edited and a YAML-only page is not', async () => {
+  writeConfigFile('pages/coded.yaml', 'id: coded\ntype: Box\nblocks:\n  - _ref: banner.js\n');
+  writeConfigFile('banner.js', "export default { id: 'banner', type: 'Box' };\n");
+  writeConfigFile('pages/plain.yaml', 'id: plain\ntype: Box\n');
+  writeConfigFile('pages/other.yaml', 'id: other\ntype: Box\n');
+  publishBuild(['coded', 'plain', 'other']);
+  await request('coded');
+  await request('plain');
+
+  writeConfigFile('pages/other.yaml', 'id: other\ntype: Box\nproperties:\n  title: Edited\n');
+  signalChange();
+
+  const { edited } = await reviewPageBuilds();
+  expect(edited).toContain('coded');
+  expect(edited).not.toContain('plain');
+  expect(await buildEditedPages()).toContain('coded');
+  expect(await request('plain')).toBe('served');
+});
+
+test('after a config publish every built page is edited, also one whose build failed', async () => {
+  writeConfigFile('pages/before.yaml', 'id: before\ntype: Box\n');
+  writeConfigFile(
+    'pages/failed_before.yaml',
+    'id: failed_before\ntype: Box\nblocks:\n  - id: x\n    type: Buton\n'
+  );
+  publishBuild(['before', 'failed_before']);
+  await request('before');
+  expect(await request('failed_before')).toBe('failed');
+
+  publishBuild(['before', 'failed_before']);
+
+  expect((await reviewPageBuilds()).edited).toEqual(['before', 'failed_before']);
+});
+
+test('a page whose last build failed is listed with its errors', async () => {
+  writeConfigFile(
+    'pages/broken.yaml',
+    'id: broken\ntype: Box\nblocks:\n  - id: x\n    type: Buton\n'
+  );
+  publishBuild(['broken']);
+  await request('broken');
+
+  const { failed } = await reviewPageBuilds();
+  expect(failed.map((page) => page.pageId)).toEqual(['broken']);
+  expect(failed[0].errors[0].message).toContain('Buton');
+});
+
+test('a page never built is edited when its page file changed after the server started, and unbuilt otherwise', async () => {
+  writeConfigFile('pages/new.yaml', 'id: new\ntype: Box\n');
+  writeConfigFile('pages/old.yaml', 'id: old\ntype: Box\n', { modified: longAgo });
+  publishBuild(['new', 'old', 'missing']);
+
+  expect(await reviewPageBuilds()).toEqual({
+    edited: ['new'],
+    unbuilt: ['old', 'missing'],
+    failed: [],
+  });
+});
+
+test('a wait builds exactly the pages the next requests would rebuild', async () => {
+  writeConfigFile('pages/one.yaml', 'id: one\ntype: Box\nblocks:\n  - _ref: common.yaml\n');
+  writeConfigFile('pages/two.yaml', 'id: two\ntype: Box\nblocks:\n  - _ref: common.yaml\n');
+  writeConfigFile('pages/three.yaml', 'id: three\ntype: Box\n');
+  writeConfigFile('pages/coded.yaml', 'id: coded\ntype: Box\nblocks:\n  - _ref: banner.js\n');
+  writeConfigFile('banner.js', "export default { id: 'banner', type: 'Box' };\n");
+  writeConfigFile('common.yaml', 'id: common\ntype: Box\n');
+  const pageIds = ['one', 'two', 'three', 'coded'];
+  publishBuild(pageIds);
+  for (const pageId of pageIds) await request(pageId);
+
+  writeConfigFile('common.yaml', 'id: common\ntype: Box\nproperties:\n  title: New\n');
+  signalChange();
+
+  expect((await buildEditedPages()).sort()).toEqual(['coded', 'one', 'two']);
+  for (const pageId of pageIds) {
+    expect(await request(pageId)).toBe('served');
+  }
+});

package/lib/docs/runCheck.js

@@ -0,0 +1,75 @@
+/*
+  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 { fileURLToPath } from 'url';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+
+const execFileAsync = promisify(execFile);
+
+const childPath = fileURLToPath(new URL('./runCheckChild.js', import.meta.url));
+
+// Reports must be readable by an agent even when the check itself broke, so
+// the report shape always comes back; a broken run is one unlocated error.
+function brokenReport(message) {
+  return {
+    ok: false,
+    errors: [
+      {
+        message,
+        name: 'LowdefyInternalError',
+        source: null,
+        config: null,
+        configKey: null,
+        checkSlug: null,
+        prodError: false,
+      },
+    ],
+    warnings: [],
+  };
+}
+
+// Runs `check` from @lowdefy/build against this dev server's config in a child
+// node process. The dev server directory is already installed, so no install
+// is needed — but @lowdefy/build keeps module-level state (the makeId counter
+// the JIT page builder relies on for stable ~k keys), and a full check resets
+// it, so the check cannot share this process with the running server.
+async function runCheck() {
+  const serverDirectory = process.cwd();
+  const configDirectory = process.env.LOWDEFY_DIRECTORY_CONFIG || serverDirectory;
+  let stdout;
+  try {
+    ({ stdout } = await execFileAsync(process.execPath, [childPath], {
+      cwd: serverDirectory,
+      env: {
+        ...process.env,
+        LOWDEFY_DIRECTORY_CONFIG: configDirectory,
+        LOWDEFY_DIRECTORY_SERVER: serverDirectory,
+      },
+      maxBuffer: 64 * 1024 * 1024,
+    }));
+  } catch (error) {
+    return brokenReport(
+      `lowdefy check failed to run: ${error.message}${
+        error.stderr ? `\n${String(error.stderr).trim()}` : ''
+      }`
+    );
+  }
+  const lastLine = stdout.trim().split('\n').pop();
+  const report = JSON.parse(lastLine);
+  return { ok: report.errors.length === 0, ...report };
+}
+
+export default runCheck;

package/lib/docs/runCheck.test.mjs

@@ -0,0 +1,91 @@
+/*
+  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 { jest } from '@jest/globals';
+
+jest.unstable_mockModule('child_process', () => ({
+  execFile: jest.fn(),
+}));
+
+const { execFile } = await import('child_process');
+const { default: runCheck } = await import('./runCheck.js');
+
+const locatedError = {
+  message: 'Page "nope" referenced in menu link "x" not found.',
+  name: 'ConfigWarning',
+  source: '/app/lowdefy.yaml:5',
+  config: 'root.menus[0:default].links[0:x:MenuLink]',
+  configKey: 'a',
+  checkSlug: 'link-refs',
+  prodError: true,
+};
+
+function mockChild({ stdout, error }) {
+  execFile.mockImplementation((file, args, options, callback) => {
+    if (error) {
+      callback(error, { stdout: '', stderr: error.stderr ?? '' });
+      return;
+    }
+    callback(null, { stdout, stderr: '' });
+  });
+}
+
+const originalConfigDirectory = process.env.LOWDEFY_DIRECTORY_CONFIG;
+
+beforeEach(() => {
+  process.env.LOWDEFY_DIRECTORY_CONFIG = '/app';
+});
+
+afterEach(() => {
+  if (originalConfigDirectory === undefined) {
+    delete process.env.LOWDEFY_DIRECTORY_CONFIG;
+  } else {
+    process.env.LOWDEFY_DIRECTORY_CONFIG = originalConfigDirectory;
+  }
+});
+
+test('runCheck runs the child in the server directory against the config directory', async () => {
+  mockChild({ stdout: `${JSON.stringify({ errors: [], warnings: [] })}\n` });
+  const result = await runCheck();
+  expect(result).toEqual({ ok: true, errors: [], warnings: [] });
+  const [file, args, options] = execFile.mock.calls[0];
+  expect(file).toBe(process.execPath);
+  expect(args[0]).toMatch(/runCheckChild\.js$/);
+  expect(options.cwd).toBe(process.cwd());
+  expect(options.env.LOWDEFY_DIRECTORY_CONFIG).toBe('/app');
+  expect(options.env.LOWDEFY_DIRECTORY_SERVER).toBe(process.cwd());
+});
+
+test('runCheck returns the located errors and warnings with ok false when there are errors', async () => {
+  const report = { errors: [locatedError], warnings: [{ ...locatedError, prodError: false }] };
+  mockChild({ stdout: `some stray log line\n${JSON.stringify(report)}\n` });
+  const result = await runCheck();
+  expect(result).toEqual({ ok: false, ...report });
+});
+
+test('runCheck reports a broken check run as one unlocated internal error', async () => {
+  const error = new Error('Command failed: node runCheckChild.js');
+  error.stderr = 'TypeError: boom\n';
+  mockChild({ error });
+  const result = await runCheck();
+  expect(result.ok).toBe(false);
+  expect(result.warnings).toEqual([]);
+  expect(result.errors).toHaveLength(1);
+  expect(result.errors[0].name).toBe('LowdefyInternalError');
+  expect(result.errors[0].source).toBeNull();
+  expect(result.errors[0].message).toBe(
+    'lowdefy check failed to run: Command failed: node runCheckChild.js\nTypeError: boom'
+  );
+});

package/lib/docs/runCheckChild.js

@@ -0,0 +1,49 @@
+/*
+  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 'path';
+
+import { check } from '@lowdefy/build/dev';
+import { createNodeLogger } from '@lowdefy/logger/node';
+
+import createCustomPluginMessagesMap from '../../manager/utils/createCustomPluginMessagesMap.mjs';
+import createCustomPluginTypesMap from '../../manager/utils/createCustomPluginTypesMap.mjs';
+
+// Child process for runCheck.js: prints the { errors, warnings } report as the
+// last line of stdout and exits 0 whenever the check ran. The logger is silent
+// because every error and warning is in the report already.
+async function run() {
+  const serverDirectory = path.resolve(process.env.LOWDEFY_DIRECTORY_SERVER ?? process.cwd());
+  const directories = {
+    build: path.join(serverDirectory, 'build'),
+    config: path.resolve(process.env.LOWDEFY_DIRECTORY_CONFIG ?? process.cwd()),
+    server: serverDirectory,
+  };
+  const logger = createNodeLogger({ name: 'lowdefy_check', level: 'silent' });
+  const [customTypesMap, customMessagesMap] = await Promise.all([
+    createCustomPluginTypesMap({ directories, logger }),
+    createCustomPluginMessagesMap({ directories, logger }),
+  ]);
+  const report = await check({
+    customMessagesMap,
+    customTypesMap,
+    directories,
+    logger,
+    refResolver: process.env.LOWDEFY_BUILD_REF_RESOLVER,
+  });
+  process.stdout.write(`${JSON.stringify(report)}\n`);
+}
+
+run();