@open-mercato/shared 0.6.7 → 0.6.8-develop.6874.1.982d6097d8

package/src/lib/bootstrap/__tests__/clientOnlyModules.test.ts

@@ -0,0 +1,189 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+
+import {
+  createClientOnlyStubPlugin,
+  encodeJsStringLiteral,
+  isClientOnlyModulePath,
+  renderClientOnlyModuleStub,
+} from '../clientOnlyModules'
+import { createCliBundlePlugins } from '../dynamicLoader'
+
+const CHART_IMPORT = '@open-mercato/ui/backend/charts'
+
+function createServerHelperFixture(tempDir: string): string {
+  const moduleDir = path.join(tempDir, 'src', 'modules', 'demo')
+  fs.mkdirSync(moduleDir, { recursive: true })
+
+  fs.writeFileSync(
+    path.join(moduleDir, 'http.client.ts'),
+    ['export const httpClient = { fetchOrders: async () => [] }', ''].join('\n'),
+  )
+
+  const entry = path.join(tempDir, 'modules.cli.generated.ts')
+  fs.writeFileSync(
+    entry,
+    [
+      "import { httpClient } from './src/modules/demo/http.client'",
+      'export const modules = [{',
+      "  id: 'demo',",
+      '  workers: [{ handler: () => httpClient.fetchOrders() }],',
+      '}]',
+      '',
+    ].join('\n'),
+  )
+
+  return entry
+}
+
+function createAppModuleFixture(tempDir: string): string {
+  const widgetDir = path.join(tempDir, 'src', 'modules', 'demo', 'widgets', 'dashboard', 'sales')
+  fs.mkdirSync(widgetDir, { recursive: true })
+
+  fs.writeFileSync(
+    path.join(widgetDir, 'widget.client.tsx'),
+    [
+      '"use client"',
+      `import { BarChart } from '${CHART_IMPORT}'`,
+      'export default function DemoWidget() { return BarChart }',
+      '',
+    ].join('\n'),
+  )
+
+  const entry = path.join(tempDir, 'modules.cli.generated.ts')
+  fs.writeFileSync(
+    entry,
+    [
+      'export const modules = [{',
+      "  id: 'demo',",
+      '  dashboardWidgets: [{',
+      "    moduleId: 'demo',",
+      "    key: 'demo:sales:widget',",
+      "    loader: () => import('./src/modules/demo/widgets/dashboard/sales/widget.client').then((mod) => mod.default ?? mod),",
+      '  }],',
+      '}]',
+      '',
+    ].join('\n'),
+  )
+
+  return entry
+}
+
+async function bundle(entry: string, outfile: string, withStubPlugin: boolean): Promise<string> {
+  const esbuild = await import('esbuild')
+  await esbuild.build({
+    entryPoints: [entry],
+    outfile,
+    bundle: true,
+    format: 'esm',
+    platform: 'node',
+    target: 'node18',
+    external: ['@open-mercato/*'],
+    plugins: withStubPlugin ? [createClientOnlyStubPlugin()] : [],
+  })
+  return fs.readFileSync(outfile, 'utf8')
+}
+
+describe('isClientOnlyModulePath', () => {
+  it('matches local client modules with and without an extension', () => {
+    expect(isClientOnlyModulePath('./widget.client')).toBe(true)
+    expect(isClientOnlyModulePath('./widget.client.tsx')).toBe(true)
+    expect(isClientOnlyModulePath('../dashboard/sales/widget.client.ts')).toBe(true)
+    expect(isClientOnlyModulePath('@/modules/demo/widgets/dashboard/sales/widget.client')).toBe(true)
+    expect(isClientOnlyModulePath('./notifications.client.ts')).toBe(true)
+  })
+
+  it('leaves bare package specifiers to the external-import plugin', () => {
+    expect(isClientOnlyModulePath('@open-mercato/ui/backend/charts')).toBe(false)
+    expect(isClientOnlyModulePath('@open-mercato/core/modules/demo/widget.client')).toBe(false)
+    expect(isClientOnlyModulePath('react')).toBe(false)
+  })
+
+  it('does not match server modules that merely mention client', () => {
+    expect(isClientOnlyModulePath('./widget.ts')).toBe(false)
+    expect(isClientOnlyModulePath('./clientFactory.ts')).toBe(false)
+    expect(isClientOnlyModulePath('./client/index.ts')).toBe(false)
+  })
+
+  it('does not match the generated notification-renderer registry', () => {
+    expect(isClientOnlyModulePath('@/.mercato/generated/notifications.client.generated')).toBe(false)
+    expect(isClientOnlyModulePath('@/.mercato/generated/notifications.client.generated.ts')).toBe(false)
+  })
+})
+
+describe('encodeJsStringLiteral', () => {
+  it('escapes quotes and backslashes so the literal cannot be terminated early', () => {
+    expect(encodeJsStringLiteral('say "hi"')).toBe('"say \\"hi\\""')
+    expect(encodeJsStringLiteral('a\\b')).toBe('"a\\\\b"')
+  })
+
+  it('escapes every character outside printable ASCII, including the separators JSON leaves raw', () => {
+    expect(encodeJsStringLiteral('a\u2028b')).toBe('"a\\u2028b"')
+    expect(encodeJsStringLiteral('a\u2029b')).toBe('"a\\u2029b"')
+    expect(encodeJsStringLiteral('a\nb')).toBe('"a\\u000ab"')
+  })
+
+  it('leaves no unescaped delimiter that could break out of the literal', () => {
+    const hostile = './widget.client"); globalThis.pwned = true; ("'
+    const encoded = encodeJsStringLiteral(hostile)
+
+    expect(encoded.startsWith('"')).toBe(true)
+    expect(encoded.endsWith('"')).toBe(true)
+    expect(encoded.slice(1, -1)).not.toMatch(/(^|[^\\])"/)
+    expect(JSON.parse(encoded)).toBe(hostile)
+  })
+})
+
+describe('renderClientOnlyModuleStub', () => {
+  it('exports a default that throws when the browser component is actually used', () => {
+    const stub = renderClientOnlyModuleStub('./widget.client')
+    expect(stub).toContain('export default clientOnlyModuleUnavailable')
+    expect(stub).toContain('./widget.client')
+  })
+})
+
+describe('createCliBundlePlugins', () => {
+  it('registers the client-only stub ahead of the alias and external plugins', () => {
+    expect(createCliBundlePlugins('/tmp/app-root').map((plugin) => plugin.name)).toEqual([
+      'client-only-stub',
+      'alias-resolver',
+      'external-non-json',
+    ])
+  })
+})
+
+describe('CLI bundle graph', () => {
+  let tempDir: string
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'open-mercato-client-only-'))
+  })
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true })
+  })
+
+  it('keeps browser-only widget imports out of the CLI bundle', async () => {
+    const entry = createAppModuleFixture(tempDir)
+    const output = await bundle(entry, path.join(tempDir, 'stubbed.mjs'), true)
+
+    expect(output).not.toContain(CHART_IMPORT)
+    expect(output).toContain('clientOnlyModuleUnavailable')
+  })
+
+  it('without the plugin the same fixture hoists the browser-only import (regression guard)', async () => {
+    const entry = createAppModuleFixture(tempDir)
+    const output = await bundle(entry, path.join(tempDir, 'plain.mjs'), false)
+
+    expect(output).toContain(CHART_IMPORT)
+  })
+
+  it('leaves statically imported server helpers alone even when they are named *.client', async () => {
+    const entry = createServerHelperFixture(tempDir)
+    const output = await bundle(entry, path.join(tempDir, 'server-helper.mjs'), true)
+
+    expect(output).toContain('fetchOrders')
+    expect(output).not.toContain('clientOnlyModuleUnavailable')
+  })
+})

package/src/lib/bootstrap/__tests__/dynamicLoader.aliasResolver.test.ts

@@ -0,0 +1,98 @@
+/**
+ * @jest-environment node
+ *
+ * The CLI bundle's `@/` alias must mirror what the app tsconfig maps, because the dynamic
+ * bootstrap path compiles app sources (`src/di.ts`) and generated registries that import app
+ * modules through the alias. The tsconfig maps `@/.mercato/*` to the app root and every other
+ * `@/*` to the app's `src/` directory; resolving everything against the app root silently sends
+ * `@/lib/x` to a path that does not exist.
+ */
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+
+import { createCliBundlePlugins } from '../dynamicLoader'
+
+async function bundleWithCliPlugins(appRoot: string, entry: string): Promise<string> {
+  const esbuild = await import('esbuild')
+  const outfile = path.join(appRoot, 'bundle.mjs')
+  await esbuild.build({
+    entryPoints: [entry],
+    outfile,
+    absWorkingDir: appRoot,
+    bundle: true,
+    format: 'esm',
+    platform: 'node',
+    target: 'node18',
+    plugins: createCliBundlePlugins(appRoot),
+  })
+  return fs.readFileSync(outfile, 'utf8')
+}
+
+describe('createCliBundlePlugins — @/ alias resolution', () => {
+  let appRoot: string
+
+  beforeEach(() => {
+    appRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'om-alias-resolver-'))
+    fs.mkdirSync(path.join(appRoot, 'src', 'lib'), { recursive: true })
+    fs.mkdirSync(path.join(appRoot, 'src', 'modules', 'demo'), { recursive: true })
+    fs.mkdirSync(path.join(appRoot, '.mercato', 'generated'), { recursive: true })
+
+    fs.writeFileSync(
+      path.join(appRoot, 'src', 'lib', 'marker.ts'),
+      "export const srcLibMarker = 'resolved-from-src-lib'\n",
+    )
+    fs.writeFileSync(
+      path.join(appRoot, 'src', 'modules', 'demo', 'index.ts'),
+      "export const srcModuleMarker = 'resolved-from-src-module-index'\n",
+    )
+    fs.writeFileSync(
+      path.join(appRoot, '.mercato', 'generated', 'registry.generated.ts'),
+      "export const generatedMarker = 'resolved-from-generated'\n",
+    )
+  })
+
+  afterEach(() => {
+    fs.rmSync(appRoot, { recursive: true, force: true })
+  })
+
+  it('resolves @/* against the app src directory and @/.mercato/* against the app root', async () => {
+    const entry = path.join(appRoot, '.mercato', 'generated', 'entry.ts')
+    fs.writeFileSync(
+      entry,
+      [
+        "import { srcLibMarker } from '@/lib/marker'",
+        "import { srcModuleMarker } from '@/modules/demo'",
+        "import { generatedMarker } from '@/.mercato/generated/registry.generated'",
+        'export const markers = [srcLibMarker, srcModuleMarker, generatedMarker]',
+        '',
+      ].join('\n'),
+    )
+
+    const output = await bundleWithCliPlugins(appRoot, entry)
+
+    expect(output).toContain('resolved-from-src-lib')
+    expect(output).toContain('resolved-from-src-module-index')
+    expect(output).toContain('resolved-from-generated')
+  })
+
+  it('prefers an app-root match when the specifier has no src counterpart', async () => {
+    fs.writeFileSync(
+      path.join(appRoot, 'root-only.ts'),
+      "export const rootOnlyMarker = 'resolved-from-app-root'\n",
+    )
+    const entry = path.join(appRoot, '.mercato', 'generated', 'entry.ts')
+    fs.writeFileSync(
+      entry,
+      [
+        "import { rootOnlyMarker } from '@/root-only'",
+        'export const markers = [rootOnlyMarker]',
+        '',
+      ].join('\n'),
+    )
+
+    const output = await bundleWithCliPlugins(appRoot, entry)
+
+    expect(output).toContain('resolved-from-app-root')
+  })
+})

package/src/lib/bootstrap/__tests__/dynamicLoader.appDi.test.ts

@@ -0,0 +1,211 @@
+/**
+ * @jest-environment node
+ *
+ * Regression guard: the worker/CLI/scheduler bootstrap path (bootstrapFromAppRoot) must register
+ * the app-level DI hook (`src/di.ts`) the same way the Next.js runtime does through its own
+ * `src/bootstrap.ts`. Without it, `getAppDiRegistrar()` stays null in those processes, so the app's
+ * registrations silently never run there and every request container falls back to a doomed
+ * `import('@/di')` — the `@/` alias does not exist in a plain Node ESM process, so it throws
+ * ERR_MODULE_NOT_FOUND once per created container (once per queued job).
+ *
+ * Like the #4327 guard next to it, this test authors both the `.ts` sources and fresh compiled
+ * `.mjs` siblings so compileAndImport takes its cache path and never invokes esbuild. The `.mjs`
+ * stubs use module.exports because Jest's CJS runtime handles the dynamic import().
+ *
+ * `bootstrapFromAppRoot` reaches the factory through `import('./factory.js')`, a specifier with no
+ * on-disk counterpart under Jest's CJS resolver, so it is mocked virtually.
+ */
+jest.mock('../../logger', () => {
+  const logger = {
+    debug: jest.fn(),
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    child: () => logger,
+  }
+  return { createLogger: () => logger }
+})
+
+const createBootstrapMock = jest.fn(() => () => {})
+
+jest.mock(
+  '../factory.js',
+  () => ({
+    createBootstrap: (...args: unknown[]) => createBootstrapMock(...(args as [])),
+    waitForAsyncRegistration: async () => {},
+  }),
+  { virtual: true },
+)
+
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import crypto from 'node:crypto'
+import { createLogger } from '../../logger'
+import { bootstrapFromAppRoot } from '../dynamicLoader'
+
+const mockedLogger = createLogger('shared') as unknown as {
+  debug: jest.Mock
+  error: jest.Mock
+}
+
+const APP_DI_CALL_COUNTER_KEY = '__omTestAppDiRegisterCalls__'
+
+const GENERATED_MODULES: Record<string, { ts: string; compiled: string }> = {
+  'entities.ids.generated': { ts: 'export const E = {}', compiled: 'module.exports = { E: {} }' },
+  'modules.cli.generated': { ts: 'export const modules = []', compiled: 'module.exports = { modules: [] }' },
+  'entities.generated': { ts: 'export const entities = []', compiled: 'module.exports = { entities: [] }' },
+  'di.generated': { ts: 'export const diRegistrars = []', compiled: 'module.exports = { diRegistrars: [] }' },
+}
+
+const APP_TSCONFIG = JSON.stringify({
+  compilerOptions: {
+    experimentalDecorators: true,
+    emitDecoratorMetadata: true,
+    useDefineForClassFields: false,
+    target: 'ES2022',
+  },
+})
+
+const APP_DI_TS = 'export function register() {}'
+
+const APP_DI_COMPILED = [
+  'module.exports = {',
+  '  register: () => {',
+  `    globalThis['${APP_DI_CALL_COUNTER_KEY}'] = (globalThis['${APP_DI_CALL_COUNTER_KEY}'] ?? 0) + 1`,
+  '  },',
+  '}',
+].join('\n')
+
+function hash(content: string): string {
+  return crypto.createHash('sha256').update(content).digest('hex')
+}
+
+function writeCompiledPair(
+  appRoot: string,
+  sourcePath: string,
+  compiledPath: string,
+  source: { ts: string; compiled: string },
+) {
+  fs.writeFileSync(sourcePath, source.ts)
+  fs.writeFileSync(compiledPath, source.compiled)
+  const sourceRelativePath = path.relative(appRoot, sourcePath).split(path.sep).join('/')
+  fs.writeFileSync(`${compiledPath}.cache.json`, JSON.stringify({
+    version: 4,
+    inputHash: hash(JSON.stringify({
+      version: 4,
+      sourceHash: hash(source.ts),
+      tsconfigHashes: {
+        'tsconfig.json': hash(APP_TSCONFIG),
+      },
+    })),
+    outputHash: hash(source.compiled),
+    dependencies: {
+      [sourceRelativePath]: hash(source.ts),
+    },
+  }))
+}
+
+const createdAppRoots: string[] = []
+
+function createAppRoot(appDi: { ts: string; compiled: string } | null): string {
+  const appRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'om-bootstrap-app-di-'))
+  const generatedDir = path.join(appRoot, '.mercato', 'generated')
+  fs.mkdirSync(generatedDir, { recursive: true })
+  fs.writeFileSync(path.join(appRoot, 'tsconfig.json'), APP_TSCONFIG)
+
+  for (const [baseName, source] of Object.entries(GENERATED_MODULES)) {
+    writeCompiledPair(
+      appRoot,
+      path.join(generatedDir, `${baseName}.ts`),
+      path.join(generatedDir, `${baseName}.mjs`),
+      source,
+    )
+  }
+
+  if (appDi) {
+    fs.mkdirSync(path.join(appRoot, 'src'), { recursive: true })
+    writeCompiledPair(
+      appRoot,
+      path.join(appRoot, 'src', 'di.ts'),
+      path.join(generatedDir, 'app-di.compiled.mjs'),
+      appDi,
+    )
+  }
+
+  createdAppRoots.push(appRoot)
+  return appRoot
+}
+
+function appDiRegistrarArgument(): unknown {
+  const [, options] = createBootstrapMock.mock.calls[0] as unknown as [unknown, Record<string, unknown>]
+  return options?.appDiRegistrar
+}
+
+describe('bootstrapFromAppRoot — app-level DI reaches worker/CLI processes', () => {
+  afterAll(() => {
+    for (const root of createdAppRoots) {
+      fs.rmSync(root, { recursive: true, force: true })
+    }
+  })
+
+  beforeEach(() => {
+    createBootstrapMock.mockClear()
+    mockedLogger.debug.mockClear()
+    mockedLogger.error.mockClear()
+    delete (globalThis as Record<string, unknown>)[APP_DI_CALL_COUNTER_KEY]
+  })
+
+  it('passes the app DI register() from src/di.ts to createBootstrap', async () => {
+    const appRoot = createAppRoot({ ts: APP_DI_TS, compiled: APP_DI_COMPILED })
+
+    await bootstrapFromAppRoot(appRoot)
+
+    const registrar = appDiRegistrarArgument()
+    expect(typeof registrar).toBe('function')
+
+    await (registrar as (container: unknown) => unknown)({})
+    expect((globalThis as Record<string, unknown>)[APP_DI_CALL_COUNTER_KEY]).toBe(1)
+    expect(mockedLogger.error).not.toHaveBeenCalled()
+  })
+
+  it('bootstraps without an app DI registrar when src/di.ts is absent', async () => {
+    const appRoot = createAppRoot(null)
+
+    await bootstrapFromAppRoot(appRoot)
+
+    expect(createBootstrapMock).toHaveBeenCalledTimes(1)
+    expect(appDiRegistrarArgument()).toBeUndefined()
+    expect(mockedLogger.error).not.toHaveBeenCalled()
+  })
+
+  it('reports an error and keeps bootstrapping when src/di.ts fails to load', async () => {
+    const appRoot = createAppRoot({
+      ts: APP_DI_TS,
+      compiled: "throw new Error('src/di.ts is broken')",
+    })
+
+    await bootstrapFromAppRoot(appRoot)
+
+    expect(createBootstrapMock).toHaveBeenCalledTimes(1)
+    expect(appDiRegistrarArgument()).toBeUndefined()
+    expect(mockedLogger.error).toHaveBeenCalledTimes(1)
+    const [message, fields] = mockedLogger.error.mock.calls[0] as [string, Record<string, unknown>]
+    expect(message).toContain('Failed to load the app-level DI module')
+    expect((fields.err as Error).message).toContain('src/di.ts is broken')
+  })
+
+  it('reports an error and keeps bootstrapping when src/di.ts exports no register()', async () => {
+    const appRoot = createAppRoot({
+      ts: APP_DI_TS,
+      compiled: 'module.exports = {}',
+    })
+
+    await bootstrapFromAppRoot(appRoot)
+
+    expect(createBootstrapMock).toHaveBeenCalledTimes(1)
+    expect(appDiRegistrarArgument()).toBeUndefined()
+    expect(mockedLogger.error).toHaveBeenCalledTimes(1)
+    expect(mockedLogger.error.mock.calls[0][0]).toContain('exports no register()')
+  })
+})

package/src/lib/bootstrap/__tests__/dynamicLoader.commandInterceptors.test.ts

@@ -13,13 +13,34 @@
  * The .mjs stubs use module.exports because Jest's CJS runtime handles the
  * dynamic import() and does not transform .mjs files; the loader consumes the
  * named exports identically either way.
+ *
+ * The third case guards #4491: the compatibility fallback to an empty list must
+ * stay silent for an absent registry, but must report a registry that exists and
+ * fails to load — otherwise the #4327 condition can recur with no diagnostics.
  */
+jest.mock('../../logger', () => {
+  const logger = {
+    debug: jest.fn(),
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    child: () => logger,
+  }
+  return { createLogger: () => logger }
+})
+
 import fs from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
+import { createLogger } from '../../logger'
 import crypto from 'node:crypto'
 import { loadBootstrapData } from '../dynamicLoader'
 
+const mockedLogger = createLogger('shared') as unknown as {
+  debug: jest.Mock
+  error: jest.Mock
+}
+
 const GENERATED_MODULES: Record<string, { ts: string; compiled: string }> = {
   'entities.ids.generated': { ts: 'export const E = {}', compiled: 'module.exports = { E: {} }' },
   'modules.cli.generated': { ts: 'export const modules = []', compiled: 'module.exports = { modules: [] }' },
@@ -71,21 +92,36 @@ function writeGeneratedModule(generatedDir: string, baseName: string, source: {
   }))
 }
 
+const createdAppRoots: string[] = []
+
+function createAppRoot(overrides: Record<string, { ts: string; compiled: string }> = {}): string {
+  const appRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'om-bootstrap-4327-'))
+  const generatedDir = path.join(appRoot, '.mercato', 'generated')
+  fs.mkdirSync(generatedDir, { recursive: true })
+  fs.writeFileSync(path.join(appRoot, 'tsconfig.json'), APP_TSCONFIG)
+  for (const [baseName, source] of Object.entries({ ...GENERATED_MODULES, ...overrides })) {
+    writeGeneratedModule(generatedDir, baseName, source)
+  }
+  createdAppRoots.push(appRoot)
+  return appRoot
+}
+
 describe('loadBootstrapData — command interceptors reach worker/CLI bootstrap (#4327)', () => {
   let appRoot: string
 
   beforeAll(() => {
-    appRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'om-bootstrap-4327-'))
-    const generatedDir = path.join(appRoot, '.mercato', 'generated')
-    fs.mkdirSync(generatedDir, { recursive: true })
-    fs.writeFileSync(path.join(appRoot, 'tsconfig.json'), APP_TSCONFIG)
-    for (const [baseName, source] of Object.entries(GENERATED_MODULES)) {
-      writeGeneratedModule(generatedDir, baseName, source)
-    }
+    appRoot = createAppRoot()
   })
 
   afterAll(() => {
-    fs.rmSync(appRoot, { recursive: true, force: true })
+    for (const root of createdAppRoots) {
+      fs.rmSync(root, { recursive: true, force: true })
+    }
+  })
+
+  beforeEach(() => {
+    mockedLogger.debug.mockClear()
+    mockedLogger.error.mockClear()
   })
 
   it('returns commandInterceptorEntries from command-interceptors.generated', async () => {
@@ -105,5 +141,24 @@ describe('loadBootstrapData — command interceptors reach worker/CLI bootstrap
 
     expect(data.commandInterceptorEntries).toEqual([])
     expect(data.commandLoaderEntries).toEqual([])
+    expect(mockedLogger.error).not.toHaveBeenCalled()
+  })
+
+  it('logs an error when the generated file exists but fails to import (#4491)', async () => {
+    const brokenAppRoot = createAppRoot({
+      'command-interceptors.generated': {
+        ts: 'export const commandInterceptorEntries = []',
+        compiled: "throw new Error('command-interceptors.generated is broken')",
+      },
+    })
+
+    const data = await loadBootstrapData(brokenAppRoot)
+
+    expect(data.commandInterceptorEntries).toEqual([])
+    expect(mockedLogger.error).toHaveBeenCalledTimes(1)
+    const [message, fields] = mockedLogger.error.mock.calls[0] as [string, Record<string, unknown>]
+    expect(message).toContain('Failed to load generated registry')
+    expect(fields.file).toBe('command-interceptors.generated.ts')
+    expect((fields.err as Error).message).toContain('command-interceptors.generated is broken')
   })
 })