@lowdefy/server-dev 6.1.0 → 7.0.0

package/lib/configTree/runConfigTreeBuild.mjs

@@ -0,0 +1,88 @@
+/*
+  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 build from '@lowdefy/build';
+import defaultMessagesMap from '@lowdefy/build/defaultMessagesMap';
+import { serializeBuildException } from '@lowdefy/build/dev';
+import { mergeObjects } from '@lowdefy/helpers';
+
+import collectConfigText from './collectConfigText.mjs';
+import createCustomPluginMessagesMap from '../../manager/utils/createCustomPluginMessagesMap.mjs';
+import createCustomPluginTypesMap from '../../manager/utils/createCustomPluginTypesMap.mjs';
+import prepareScratchServer from './prepareScratchServer.mjs';
+
+// A full config build of one tree for the journeys scope diff: the pipeline
+// `lowdefy build` runs, without the Vite client build, at stage dev so a
+// prodError warning stays a warning as it does in the dev server. The plugin
+// types come from the installed dev server, so base and head are built by
+// one builder and a Lowdefy version bump does not show as a config change.
+// Writes <out>/build/, <out>/server/ and <out>/result.json, which the CLI
+// reads for the build's errors and warnings. A build that succeeds also
+// writes <out>/configText.json, the app's config text set, which the journey
+// readers resolve production text tokens against.
+async function runConfigTreeBuild({
+  configDirectory,
+  outDirectory,
+  devDirectory,
+  logger,
+  refResolver,
+  skipPluginChecks,
+}) {
+  const directories = {
+    config: configDirectory,
+    build: path.join(outDirectory, 'build'),
+    server: path.join(outDirectory, 'server'),
+  };
+  const resultPath = path.join(outDirectory, 'result.json');
+  const configTextPath = path.join(outDirectory, 'configText.json');
+  await fs.promises.rm(resultPath, { force: true });
+  await fs.promises.rm(configTextPath, { force: true });
+  await prepareScratchServer({ devDirectory, serverDirectory: directories.server });
+  let result;
+  try {
+    const [customTypesMap, customMessagesMap] = await Promise.all([
+      createCustomPluginTypesMap({ directories, logger }),
+      createCustomPluginMessagesMap({ directories, logger }),
+    ]);
+    await build({
+      customMessagesMap,
+      customTypesMap,
+      directories,
+      logger,
+      refResolver,
+      skipPluginChecks,
+      stage: 'dev',
+    });
+    const configText = await collectConfigText({
+      buildDirectory: directories.build,
+      messagesMap: mergeObjects([defaultMessagesMap, customMessagesMap]),
+    });
+    await fs.promises.writeFile(configTextPath, JSON.stringify(configText, null, 2));
+    result = { status: 'ok', errors: [], warnings: [] };
+  } catch (error) {
+    result = {
+      status: 'error',
+      errors: error.errors ?? [serializeBuildException(error)],
+      warnings: error.warnings ?? [],
+    };
+  }
+  await fs.promises.writeFile(resultPath, JSON.stringify(result, null, 2));
+  return result;
+}
+
+export default runConfigTreeBuild;

package/lib/configTree/runConfigTreeBuild.skipPluginChecks.test.mjs

@@ -0,0 +1,74 @@
+/*
+  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 { jest } from '@jest/globals';
+
+const mockBuild = jest.fn();
+
+jest.unstable_mockModule('@lowdefy/build', () => ({ default: mockBuild }));
+jest.unstable_mockModule('./collectConfigText.mjs', () => ({
+  default: jest.fn().mockResolvedValue({}),
+}));
+jest.unstable_mockModule('./prepareScratchServer.mjs', () => ({
+  default: jest.fn().mockResolvedValue(),
+}));
+jest.unstable_mockModule('../../manager/utils/createCustomPluginTypesMap.mjs', () => ({
+  default: jest.fn().mockResolvedValue({}),
+}));
+jest.unstable_mockModule('../../manager/utils/createCustomPluginMessagesMap.mjs', () => ({
+  default: jest.fn().mockResolvedValue({}),
+}));
+
+const { default: runConfigTreeBuild } = await import('./runConfigTreeBuild.mjs');
+
+const logger = { debug: () => {}, info: () => {}, warn: () => {}, error: () => {} };
+let root;
+
+beforeEach(() => {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'lowdefy-config-tree-skip-'));
+  mockBuild.mockResolvedValue();
+});
+
+afterEach(() => {
+  fs.rmSync(root, { recursive: true, force: true });
+});
+
+test('runConfigTreeBuild passes skipPluginChecks true to build', async () => {
+  const result = await runConfigTreeBuild({
+    configDirectory: path.join(root, 'app'),
+    outDirectory: root,
+    devDirectory: path.join(root, 'dev'),
+    logger,
+    skipPluginChecks: true,
+  });
+  expect(result).toEqual({ status: 'ok', errors: [], warnings: [] });
+  const [args] = mockBuild.mock.calls[0];
+  expect(args.skipPluginChecks).toBe(true);
+  expect(args.stage).toEqual('dev');
+});
+
+test('runConfigTreeBuild passes skipPluginChecks undefined to build when not given', async () => {
+  await runConfigTreeBuild({
+    configDirectory: path.join(root, 'app'),
+    outDirectory: root,
+    devDirectory: path.join(root, 'dev'),
+    logger,
+  });
+  expect(mockBuild.mock.calls[0][0].skipPluginChecks).toBeUndefined();
+});

package/lib/configTree/runConfigTreeBuild.test.mjs

@@ -0,0 +1,202 @@
+/*
+  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 crypto from 'node:crypto';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { jest } from '@jest/globals';
+
+import runConfigTreeBuild from './runConfigTreeBuild.mjs';
+
+jest.setTimeout(120000);
+
+const serverDevDirectory = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
+
+const logger = {
+  debug: () => {},
+  info: () => {},
+  warn: () => {},
+  error: () => {},
+};
+
+function writeApp({ directory, title }) {
+  fs.mkdirSync(directory, { recursive: true });
+  fs.writeFileSync(
+    path.join(directory, 'lowdefy.yaml'),
+    [
+      'lowdefy: 6.0.0',
+      'pages:',
+      '  - id: home',
+      '    type: Box',
+      '    blocks:',
+      '      - id: title',
+      '        type: Html',
+      '        properties:',
+      `          html: ${title}`,
+      '',
+    ].join('\n')
+  );
+}
+
+// A stand-in for the app's .lowdefy/dev: the real server-dev package.json,
+// public_default and node_modules, plus a public/ and a tailwind/ the running
+// dev server would hold.
+function writeDevDirectory({ directory }) {
+  fs.mkdirSync(path.join(directory, 'public'), { recursive: true });
+  fs.mkdirSync(path.join(directory, 'lowdefy-build', 'tailwind'), { recursive: true });
+  fs.copyFileSync(
+    path.join(serverDevDirectory, 'package.json'),
+    path.join(directory, 'package.json')
+  );
+  fs.cpSync(
+    path.join(serverDevDirectory, 'public_default'),
+    path.join(directory, 'public_default'),
+    {
+      recursive: true,
+    }
+  );
+  fs.writeFileSync(path.join(directory, 'public', 'logo.svg'), '<svg>live</svg>');
+  fs.writeFileSync(
+    path.join(directory, 'lowdefy-build', 'tailwind', 'pages.css'),
+    '@source "live";'
+  );
+  fs.symlinkSync(
+    path.join(serverDevDirectory, 'node_modules'),
+    path.join(directory, 'node_modules')
+  );
+}
+
+function hashTree(directory) {
+  const hash = crypto.createHash('sha1');
+  function walk(current) {
+    fs.readdirSync(current, { withFileTypes: true })
+      .filter((entry) => entry.name !== 'node_modules')
+      .sort((a, b) => a.name.localeCompare(b.name))
+      .forEach((entry) => {
+        const full = path.join(current, entry.name);
+        hash.update(path.relative(directory, full));
+        if (entry.isDirectory()) {
+          walk(full);
+        } else {
+          hash.update(fs.readFileSync(full));
+        }
+      });
+  }
+  walk(directory);
+  return hash.digest('hex');
+}
+
+let root;
+beforeEach(() => {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'lowdefy-config-tree-build-'));
+});
+afterEach(() => {
+  fs.rmSync(root, { recursive: true, force: true });
+});
+
+test('runConfigTreeBuild builds base and head into scratch directories and writes nothing under the dev directory', async () => {
+  const devDirectory = path.join(root, 'app', '.lowdefy', 'dev');
+  writeApp({ directory: path.join(root, 'app'), title: 'Head' });
+  writeApp({ directory: path.join(root, 'base-tree', 'app'), title: 'Base' });
+  writeDevDirectory({ directory: devDirectory });
+  const before = hashTree(devDirectory);
+
+  const [base, head] = await Promise.all([
+    runConfigTreeBuild({
+      configDirectory: path.join(root, 'base-tree', 'app'),
+      outDirectory: path.join(root, 'builds', 'base'),
+      devDirectory,
+      logger,
+    }),
+    runConfigTreeBuild({
+      configDirectory: path.join(root, 'app'),
+      outDirectory: path.join(root, 'builds', 'head'),
+      devDirectory,
+      logger,
+    }),
+  ]);
+
+  expect(base).toEqual({ status: 'ok', errors: [], warnings: [] });
+  expect(head).toEqual({ status: 'ok', errors: [], warnings: [] });
+  expect(hashTree(devDirectory)).toEqual(before);
+  expect(fs.readFileSync(path.join(devDirectory, 'public', 'logo.svg'), 'utf8')).toEqual(
+    '<svg>live</svg>'
+  );
+  const headPage = fs.readFileSync(
+    path.join(root, 'builds', 'head', 'build', 'pages', 'home.json'),
+    'utf8'
+  );
+  const basePage = fs.readFileSync(
+    path.join(root, 'builds', 'base', 'build', 'pages', 'home.json'),
+    'utf8'
+  );
+  expect(headPage).toContain('Head');
+  expect(basePage).toContain('Base');
+  expect(
+    JSON.parse(fs.readFileSync(path.join(root, 'builds', 'head', 'result.json'), 'utf8')).status
+  ).toEqual('ok');
+  expect(
+    fs.lstatSync(path.join(root, 'builds', 'head', 'server', 'node_modules')).isSymbolicLink()
+  ).toBe(true);
+  const configText = JSON.parse(
+    fs.readFileSync(path.join(root, 'builds', 'head', 'configText.json'), 'utf8')
+  );
+  expect(configText).toEqual(expect.arrayContaining(['Head', 'OK', 'Cancel']));
+  expect(configText).not.toContain('Base');
+});
+
+test('runConfigTreeBuild reports a plugin the dev directory does not install as a build error', async () => {
+  const devDirectory = path.join(root, 'app', '.lowdefy', 'dev');
+  writeApp({ directory: path.join(root, 'app'), title: 'Head' });
+  fs.appendFileSync(
+    path.join(root, 'app', 'lowdefy.yaml'),
+    'plugins:\n  - name: "@acme/blocks-not-installed"\n    version: 1.2.0\n'
+  );
+  writeDevDirectory({ directory: devDirectory });
+
+  const result = await runConfigTreeBuild({
+    configDirectory: path.join(root, 'app'),
+    outDirectory: path.join(root, 'builds', 'head'),
+    devDirectory,
+    logger,
+  });
+
+  expect(result.status).toEqual('error');
+  expect(result.errors[0].message).toContain('@acme/blocks-not-installed');
+});
+
+test('runConfigTreeBuild reports the config errors of a tree that does not build', async () => {
+  const devDirectory = path.join(root, 'app', '.lowdefy', 'dev');
+  writeApp({ directory: path.join(root, 'app'), title: 'Head' });
+  fs.writeFileSync(
+    path.join(root, 'app', 'lowdefy.yaml'),
+    'lowdefy: 6.0.0\npages:\n  - id: home\n    type: Buton\n'
+  );
+  writeDevDirectory({ directory: devDirectory });
+
+  const result = await runConfigTreeBuild({
+    configDirectory: path.join(root, 'app'),
+    outDirectory: path.join(root, 'builds', 'head'),
+    devDirectory,
+    logger,
+  });
+
+  expect(result.status).toEqual('error');
+  expect(result.errors.map((error) => error.message).join('\n')).toContain('Buton');
+  expect(fs.existsSync(path.join(root, 'builds', 'head', 'configText.json'))).toBe(false);
+});

package/lib/docs/JourneyStepError.js

@@ -0,0 +1,30 @@
+/*
+  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.
+*/
+
+// Carries what a failed step expected and what it found, so the journey's
+// failure report can show both. Executors throw it for a failed `expect` and
+// for an interaction Playwright refused; the run loop turns it into
+// `failure` and stops.
+class JourneyStepError extends Error {
+  constructor(message, { expected, actual }) {
+    super(message);
+    this.name = 'JourneyStepError';
+    this.expected = expected;
+    this.actual = actual;
+  }
+}
+
+export default JourneyStepError;

package/lib/docs/acquireBrowserSlot.js

@@ -0,0 +1,30 @@
+/*
+  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 { acquireMachineSlot } from '@lowdefy/node-utils';
+
+const BROWSER_SLOTS = 3;
+const BROWSER_SLOT_WAIT_MS = 5 * 60 * 1000;
+
+// Takes one of the machine's browser slots, so at most three browser
+// operations run at once across every dev server on the machine. The caller
+// releases it (slot.release()) when its operation ends. Throws when the wait
+// outlasts BROWSER_SLOT_WAIT_MS.
+function acquireBrowserSlot({ acquire = acquireMachineSlot } = {}) {
+  return acquire({ name: 'browser', limit: BROWSER_SLOTS, waitMs: BROWSER_SLOT_WAIT_MS });
+}
+
+export default acquireBrowserSlot;

package/lib/docs/addNestedEndpoints.js

@@ -0,0 +1,54 @@
+/*
+  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';
+
+import readRoutineSteps from './readRoutineSteps.js';
+
+// The browser never sees a routine's CallApi, in-process or detached, so the
+// endpoints a journey reached through one are added from config: every
+// endpoint a called endpoint's routine names with a literal endpointId,
+// transitively, as { endpointId, via, calls: null }. A computed endpointId
+// cannot be followed; such steps are counted as `unfollowed`.
+async function addNestedEndpoints({ endpoints, readConfigFile }) {
+  const result = endpoints.map((endpoint) => ({ ...endpoint }));
+  const visited = new Set(endpoints.map(({ endpointId }) => endpointId));
+  const queue = [...visited];
+  let unfollowed = 0;
+  while (queue.length > 0) {
+    const caller = queue.shift();
+    const artifact = await readConfigFile(`api/${caller}.json`);
+    const callApiSteps = readRoutineSteps({ routine: artifact.routine }).filter(
+      (step) => step.type === 'CallApi'
+    );
+    callApiSteps.forEach((step) => {
+      const endpointId = step.properties?.endpointId;
+      if (!type.isString(endpointId)) {
+        unfollowed += 1;
+        return;
+      }
+      if (visited.has(endpointId)) {
+        return;
+      }
+      visited.add(endpointId);
+      queue.push(endpointId);
+      result.push({ endpointId, via: caller, calls: null });
+    });
+  }
+  return { endpoints: result, unfollowed };
+}
+
+export default addNestedEndpoints;

package/lib/docs/addNestedEndpoints.test.mjs

@@ -0,0 +1,185 @@
+/*
+  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 addNestedEndpoints from './addNestedEndpoints.js';
+import addWriteFlags from './addWriteFlags.js';
+import collectExercised from './collectExercised.js';
+import readRoutineSteps from './readRoutineSteps.js';
+
+function callApi({ id, endpointId, detached }) {
+  return {
+    id: `endpoint:x:${id}`,
+    stepId: id,
+    type: 'CallApi',
+    properties: { endpointId, ...(detached ? { detached: true } : {}) },
+  };
+}
+
+const artifacts = {
+  'routes.json': [
+    { pageId: 'tickets', path: 'tickets' },
+    { pageId: 'ticket', path: 'tickets/{ticket_id}' },
+  ],
+  'plugins/requestSchemas.json': {
+    MongoDBFind: { meta: { checkRead: true, checkWrite: false } },
+    MongoDBInsertOne: { meta: { checkRead: false, checkWrite: true } },
+  },
+  'pages/tickets/requests/list.json': { type: 'MongoDBFind' },
+  'pages/tickets/requests/save.json': { type: 'MongoDBInsertOne' },
+  // Writes only through the endpoints it calls.
+  'api/notify.json': {
+    routine: [
+      callApi({ id: 'inline', endpointId: 'log' }),
+      { ':if': true, ':then': [callApi({ id: 'later', endpointId: 'archive', detached: true })] },
+      callApi({ id: 'computed', endpointId: { _payload: 'target' } }),
+    ],
+  },
+  'api/log.json': {
+    routine: [
+      { id: 'endpoint:log:insert', stepId: 'insert', type: 'MongoDBInsertOne' },
+      // A cycle back to the caller.
+      callApi({ id: 'back', endpointId: 'notify' }),
+    ],
+  },
+  'api/archive.json': {
+    routine: [{ id: 'endpoint:archive:find', stepId: 'find', type: 'MongoDBFind' }],
+  },
+  'api/read.json': {
+    routine: [
+      { ':try': [{ id: 'endpoint:read:find', stepId: 'find', type: 'MongoDBFind' }], ':catch': [] },
+      callApi({ id: 'archive', endpointId: 'archive' }),
+    ],
+  },
+};
+
+async function readConfigFile(name) {
+  return artifacts[name] ?? null;
+}
+
+test('readRoutineSteps finds steps inside control objects and not inside step properties', () => {
+  const steps = readRoutineSteps({
+    routine: [
+      { ':if': true, ':then': [{ stepId: 'a', type: 'A' }], ':else': [{ stepId: 'b', type: 'B' }] },
+      { stepId: 'c', type: 'C', properties: { nested: [{ stepId: 'd', type: 'D' }] } },
+    ],
+  });
+  expect(steps.map((step) => step.stepId)).toEqual(['a', 'b', 'c']);
+});
+
+test('addNestedEndpoints follows in-process and detached CallApi with literal ids, transitively, once each', async () => {
+  const result = await addNestedEndpoints({
+    endpoints: [{ endpointId: 'notify', calls: 1 }],
+    readConfigFile,
+  });
+  expect(result).toEqual({
+    endpoints: [
+      { endpointId: 'notify', calls: 1 },
+      { endpointId: 'log', via: 'notify', calls: null },
+      { endpointId: 'archive', via: 'notify', calls: null },
+    ],
+    unfollowed: 1,
+  });
+});
+
+test('addNestedEndpoints keeps an endpoint the browser called itself as called, not nested', async () => {
+  const result = await addNestedEndpoints({
+    endpoints: [
+      { endpointId: 'notify', calls: 1 },
+      { endpointId: 'archive', calls: 2 },
+    ],
+    readConfigFile,
+  });
+  expect(result.endpoints).toContainEqual({ endpointId: 'archive', calls: 2 });
+  expect(result.endpoints.filter((entry) => entry.endpointId === 'archive')).toHaveLength(1);
+});
+
+test('addWriteFlags follows checkWrite for a read and a write request type', async () => {
+  const { requests } = await addWriteFlags({
+    requests: [
+      { pageId: 'tickets', requestId: 'list', calls: 1 },
+      { pageId: 'tickets', requestId: 'save', calls: 1 },
+    ],
+    endpoints: [],
+    readConfigFile,
+    requestSchemas: artifacts['plugins/requestSchemas.json'],
+  });
+  expect(requests).toEqual([
+    { pageId: 'tickets', requestId: 'list', calls: 1, write: false },
+    { pageId: 'tickets', requestId: 'save', calls: 1, write: true },
+  ]);
+});
+
+test('addWriteFlags marks a caller that writes only through a nested endpoint as a write', async () => {
+  const { endpoints } = await addWriteFlags({
+    requests: [],
+    endpoints: [
+      { endpointId: 'notify', calls: 1 },
+      { endpointId: 'log', via: 'notify', calls: null },
+      { endpointId: 'archive', via: 'notify', calls: null },
+      { endpointId: 'read', calls: 1 },
+    ],
+    readConfigFile,
+    requestSchemas: artifacts['plugins/requestSchemas.json'],
+  });
+  expect(endpoints.map(({ endpointId, write }) => [endpointId, write])).toEqual([
+    ['notify', true],
+    ['log', true],
+    ['archive', false],
+    ['read', false],
+  ]);
+});
+
+test('collectExercised merges actors, adds nested endpoints and writes, and passes the observed events and blocks through', async () => {
+  const exercised = await collectExercised({
+    snapshots: [
+      {
+        pagePaths: ['tickets', 'tickets/7'],
+        appEvents: true,
+        requests: [{ pageId: 'tickets', requestId: 'save', calls: 1 }],
+        endpoints: [{ endpointId: 'notify', calls: 1 }],
+      },
+    ],
+    observed: {
+      events: [
+        {
+          scope: 'page',
+          pageId: 'tickets',
+          blockId: 'save',
+          eventName: 'onClick',
+          actionIds: ['a'],
+        },
+      ],
+      rendered: { tickets: ['save'] },
+    },
+    readConfigFile,
+    requestSchemas: artifacts['plugins/requestSchemas.json'],
+  });
+  expect(exercised).toEqual({
+    pages: ['ticket', 'tickets'],
+    appEvents: true,
+    requests: [{ pageId: 'tickets', requestId: 'save', calls: 1, write: true }],
+    endpoints: [
+      { endpointId: 'notify', calls: 1, write: true },
+      { endpointId: 'log', via: 'notify', calls: null, write: true },
+      { endpointId: 'archive', via: 'notify', calls: null, write: false },
+    ],
+    unfollowed: 1,
+    events: [
+      { scope: 'page', pageId: 'tickets', blockId: 'save', eventName: 'onClick', actionIds: ['a'] },
+    ],
+    rendered: { tickets: ['save'] },
+  });
+});