@open-mercato/cli 0.6.7 → 0.6.8-canary.320.1.bf889f49e4

package/src/lib/generators/__tests__/module-subset.test.ts

@@ -578,6 +578,66 @@ export { POST, PUT, DELETE }
     expect(apiRoutes).toContain('methods: ["GET", "POST", "PUT", "DELETE"]')
   })
 
+  it('partitions API and backend loader graphs while preserving legacy manifests', async () => {
+    scaffoldModule(tmpDir, 'customers', 'pkg', ['api/people/route.ts', 'backend/people/page.tsx'])
+    scaffoldModule(tmpDir, 'sales', 'pkg', ['api/orders/route.ts', 'backend/orders/page.tsx'])
+    touchFile(
+      path.join(tmpDir, 'packages', 'core', 'src', 'modules', 'customers', 'api', 'people', 'route.ts'),
+      `export const metadata = { path: '/customers/people' }\nexport function GET() { return null }\n`,
+    )
+    touchFile(
+      path.join(tmpDir, 'packages', 'core', 'src', 'modules', 'customers', 'backend', 'people', 'page.tsx'),
+      `export const metadata = { pageTitle: 'People' }\nexport default function Page() { return null }\n`,
+    )
+    touchFile(
+      path.join(tmpDir, 'packages', 'core', 'src', 'modules', 'sales', 'api', 'orders', 'route.ts'),
+      `export const metadata = { path: '/sales/orders' }\nexport function POST() { return null }\n`,
+    )
+    touchFile(
+      path.join(tmpDir, 'packages', 'core', 'src', 'modules', 'sales', 'backend', 'orders', 'page.tsx'),
+      `export const metadata = { pageTitle: 'Orders' }\nexport default function Page() { return null }\n`,
+    )
+
+    const resolver = createMockResolver(tmpDir, [
+      { id: 'customers', from: '@open-mercato/core' },
+      { id: 'sales', from: '@open-mercato/core' },
+    ])
+    await generateModuleRegistry({ resolver, quiet: true })
+
+    const outputDir = path.join(tmpDir, 'output', 'generated')
+    const generatedNames = fs.readdirSync(outputDir)
+    const apiShardNames = generatedNames.filter((name) => /^api-route-shard\..+\.generated\.ts$/.test(name))
+    const backendShardNames = generatedNames.filter((name) => /^backend-route-shard\..+\.generated\.ts$/.test(name))
+    const apiShards = apiShardNames.map((name) => fs.readFileSync(path.join(outputDir, name), 'utf8'))
+    const backendShards = backendShardNames.map((name) => fs.readFileSync(path.join(outputDir, name), 'utf8'))
+
+    expect(apiShardNames).toHaveLength(2)
+    expect(backendShardNames).toHaveLength(2)
+    expect(apiShards.filter((source) => source.includes('/customers/people'))).toHaveLength(1)
+    expect(apiShards.filter((source) => source.includes('/sales/orders'))).toHaveLength(1)
+    expect(backendShards.filter((source) => source.includes('/backend/people'))).toHaveLength(1)
+    expect(backendShards.filter((source) => source.includes('/backend/orders'))).toHaveLength(1)
+
+    const apiLoader = readGenerated(tmpDir, 'api-route-shards.generated.ts')!
+    const backendLoader = readGenerated(tmpDir, 'backend-route-shards.generated.ts')!
+    expect(apiLoader).not.toContain('@open-mercato/core/modules/customers/api')
+    expect(backendLoader).not.toContain('@open-mercato/core/modules/customers/backend')
+
+    const apiMetadata = readGenerated(tmpDir, 'api-route-metadata.generated.ts')!
+    const backendMetadata = readGenerated(tmpDir, 'backend-route-metadata.generated.ts')!
+    expect(apiMetadata).not.toContain('load: async')
+    expect(backendMetadata).not.toContain('load: async')
+    expect(readGenerated(tmpDir, 'api-routes.generated.ts')).toContain('/customers/people')
+    expect(readGenerated(tmpDir, 'backend-routes.generated.ts')).toContain('/backend/orders')
+
+    const customersOnlyResolver = createMockResolver(tmpDir, [
+      { id: 'customers', from: '@open-mercato/core' },
+    ])
+    await generateModuleRegistry({ resolver: customersOnlyResolver, quiet: true })
+    const remainingApiShards = fs.readdirSync(outputDir).filter((name) => /^api-route-shard\..+\.generated\.ts$/.test(name))
+    expect(remainingApiShards).toHaveLength(1)
+  })
+
   it('keeps all HTTP methods for route.ts files that destructure-export crud handlers', async () => {
     scaffoldModule(tmpDir, 'example', 'pkg', ['api/todos/route.ts'])
     touchFile(
@@ -702,6 +762,24 @@ export function GET() {
     expect(output).toContain('features:')
   })
 
+  it('normalizes singular app-owned integration exports without requiring plural properties', async () => {
+    touchFile(
+      path.join(tmpDir, 'app', 'src', 'modules', 'mailbox', 'integration.ts'),
+      "export const integration = { id: 'mailbox' }\nexport default integration\n",
+    )
+    const resolver = createMockResolver(tmpDir, [{ id: 'mailbox', from: '@app' }])
+    const result = await generateModuleRegistry({ resolver, quiet: true })
+
+    expect(result.errors).toEqual([])
+    for (const file of ['modules.generated.ts', 'modules.runtime.generated.ts']) {
+      const output = readGenerated(tmpDir, file)!
+      expect(output).toContain('as unknown as { integrations?:')
+      expect(output).toContain('.integration ? [')
+      expect(output).not.toMatch(/INTEGRATION_[A-Za-z0-9_]+\.integrations/)
+      expect(output).not.toMatch(/INTEGRATION_[A-Za-z0-9_]+\.bundles/)
+    }
+  })
+
   it('escapes generated module specifiers for lazy imports', async () => {
     touchFile(
       path.join(tmpDir, 'packages', 'core', 'src', 'modules', 'safe_mod', 'subscribers', `o'hare.ts`),
@@ -1044,6 +1122,85 @@ export default async function handle(): Promise<void> {}
     expect(output).toContain("workers:")
   })
 
+  it('writes a content-stable primitive dev supervisor manifest', async () => {
+    scaffoldModule(tmpDir, 'events', 'pkg', ['workers/dispatch.ts'])
+    scaffoldModule(tmpDir, 'scheduler', 'pkg', ['cli.ts'])
+    touchFile(
+      path.join(tmpDir, 'packages', 'core', 'src', 'modules', 'events', 'workers', 'dispatch.ts'),
+      `export const metadata = { id: 'events:dispatch', queue: 'events', concurrency: 3 }\nexport default async function dispatch() {}\n`,
+    )
+    touchFile(
+      path.join(tmpDir, 'packages', 'core', 'src', 'modules', 'scheduler', 'cli.ts'),
+      `export default [{ command: 'start', run() {} }]\n`,
+    )
+    const resolver = createMockResolver(tmpDir, [
+      { id: 'events', from: '@open-mercato/core' },
+      { id: 'scheduler', from: '@open-mercato/core' },
+    ])
+
+    const first = await generateModuleRegistryCli({ resolver, quiet: true })
+    const manifestPath = path.join(tmpDir, 'output', 'generated', 'dev-supervisor.generated.json')
+    expect(JSON.parse(fs.readFileSync(manifestPath, 'utf8'))).toEqual({
+      version: 1,
+      workers: [{
+        id: 'events:dispatch',
+        moduleId: 'events',
+        queue: 'events',
+        concurrency: 3,
+      }],
+      schedulerStartStatus: 'ok',
+      requiresFullBootstrap: false,
+    })
+    expect(first.filesWritten).toContain(manifestPath)
+
+    const second = await generateModuleRegistryCli({ resolver, quiet: true })
+    expect(second.filesUnchanged).toContain(manifestPath)
+    expect(second.filesWritten).not.toContain(manifestPath)
+  })
+
+  it('falls back to full bootstrap for worker overrides and computed scheduler commands', async () => {
+    scaffoldModule(tmpDir, 'events', 'pkg', ['workers/dispatch.ts'])
+    scaffoldModule(tmpDir, 'scheduler', 'pkg', ['cli.ts'])
+    touchFile(
+      path.join(tmpDir, 'packages', 'core', 'src', 'modules', 'events', 'workers', 'dispatch.ts'),
+      `export const metadata = { id: 'events:dispatch', queue: 'events', concurrency: 3 }\nexport default async function dispatch() {}\n`,
+    )
+    touchFile(
+      path.join(tmpDir, 'packages', 'core', 'src', 'modules', 'scheduler', 'cli.ts'),
+      `const command = 'start'\nexport default [{ command, run() {} }]\n`,
+    )
+    const resolver = createMockResolver(tmpDir, [
+      { id: 'events', from: '@open-mercato/core', devSupervisorRequiresFullBootstrap: true },
+      { id: 'scheduler', from: '@open-mercato/core' },
+    ])
+
+    await generateModuleRegistryCli({ resolver, quiet: true })
+    const manifestPath = path.join(tmpDir, 'output', 'generated', 'dev-supervisor.generated.json')
+    expect(JSON.parse(fs.readFileSync(manifestPath, 'utf8'))).toMatchObject({
+      schedulerStartStatus: 'missing-command',
+      requiresFullBootstrap: true,
+    })
+  })
+
+  it('falls back to full bootstrap when app code registers programmatic worker overrides', async () => {
+    scaffoldModule(tmpDir, 'events', 'pkg', ['workers/dispatch.ts'])
+    touchFile(
+      path.join(tmpDir, 'packages', 'core', 'src', 'modules', 'events', 'workers', 'dispatch.ts'),
+      `export const metadata = { id: 'events:dispatch', queue: 'events', concurrency: 3 }\nexport default async function dispatch() {}\n`,
+    )
+    touchFile(
+      path.join(tmpDir, 'app', 'src', 'bootstrap-overrides.ts'),
+      `import { applyWorkerOverrides as overrideWorkers } from '@open-mercato/shared/modules/overrides'\noverrideWorkers({ 'events:dispatch': null })\n`,
+    )
+    const resolver = createMockResolver(tmpDir, [
+      { id: 'events', from: '@open-mercato/core' },
+    ])
+
+    await generateModuleRegistryCli({ resolver, quiet: true })
+    const manifestPath = path.join(tmpDir, 'output', 'generated', 'dev-supervisor.generated.json')
+    expect(JSON.parse(fs.readFileSync(manifestPath, 'utf8')).requiresFullBootstrap).toBe(true)
+  })
+
   it('handles disabling a module that was previously enabled', async () => {
     scaffoldModule(tmpDir, 'keep_mod', 'pkg', [
       'subscribers/handler.ts',
@@ -1462,6 +1619,115 @@ describe('generateModuleRegistryApp with module subsets', () => {
     const bootstrapOutput = readGenerated(tmpDir, 'modules.bootstrap.generated.ts')
     expect(bootstrapOutput).not.toBeNull()
     expect(bootstrapOutput).toContain('export const modules: Module[] = [')
+
+    const i18nLoadersOutput = readGenerated(tmpDir, 'modules.i18n.loaders.generated.ts')
+    expect(i18nLoadersOutput).toContain('export async function loadI18nModules')
+    expect(i18nLoadersOutput).toContain('default:')
+    expect(i18nLoadersOutput).toContain('return []')
+  })
+
+  it('keeps the legacy i18n registry while emitting deterministic locale-specific shards', async () => {
+    touchFile(
+      path.join(tmpDir, 'packages', 'core', 'src', 'modules', 'localized', 'i18n', 'en.json'),
+      JSON.stringify({ localized: { title: 'Core title' } }),
+    )
+    touchFile(
+      path.join(tmpDir, 'packages', 'core', 'src', 'modules', 'localized', 'i18n', 'pl.json'),
+      JSON.stringify({ localized: { title: 'Tytuł' } }),
+    )
+    touchFile(
+      path.join(tmpDir, 'app', 'src', 'modules', 'localized', 'i18n', 'en.json'),
+      JSON.stringify({ localized: { title: 'App title' } }),
+    )
+    touchFile(
+      path.join(tmpDir, 'packages', 'core', 'src', 'modules', 'localized', 'i18n', '.hardcoded-allowlist.json'),
+      JSON.stringify({ allow: ['framework chrome'] }),
+    )
+
+    const resolver = createMockResolver(tmpDir, [
+      { id: 'localized', from: '@open-mercato/core' },
+    ])
+    const result = await generateModuleRegistryApp({ resolver, quiet: true })
+
+    expect(result.errors).toEqual([])
+
+    const legacyI18nOutput = readGenerated(tmpDir, 'modules.i18n.generated.ts')!
+    expect(legacyI18nOutput).toContain('@open-mercato/core/modules/localized/i18n/en.json')
+    expect(legacyI18nOutput).toContain('@/modules/localized/i18n/en.json')
+    expect(legacyI18nOutput).toContain('@open-mercato/core/modules/localized/i18n/pl.json')
+    expect(legacyI18nOutput).toContain('export const modules: Module[] = [')
+
+    const bootstrapOutput = readGenerated(tmpDir, 'modules.bootstrap.generated.ts')!
+    expect(bootstrapOutput).not.toContain('/i18n/')
+    expect(bootstrapOutput).not.toContain('translations:')
+
+    const loadersOutput = readGenerated(tmpDir, 'modules.i18n.loaders.generated.ts')!
+    expect(loadersOutput).not.toContain('.json')
+    expect(loadersOutput).toContain('case "en":')
+    expect(loadersOutput).toContain('import("./modules.i18n.en.generated")')
+    expect(loadersOutput).toContain('case "pl":')
+    expect(loadersOutput).not.toContain('hardcoded-allowlist')
+    expect(loadersOutput.indexOf('case "en":')).toBeLessThan(loadersOutput.indexOf('case "pl":'))
+
+    const enShard = readGenerated(tmpDir, 'modules.i18n.en.generated.ts')!
+    expect(enShard).toContain('@open-mercato/core/modules/localized/i18n/en.json')
+    expect(enShard).toContain('@/modules/localized/i18n/en.json')
+    expect(enShard).not.toContain('/i18n/pl.json')
+    expect(enShard).toContain('id: "localized"')
+    expect(enShard).toContain('translations:')
+
+    const plShard = readGenerated(tmpDir, 'modules.i18n.pl.generated.ts')!
+    expect(plShard).toContain('@open-mercato/core/modules/localized/i18n/pl.json')
+    expect(plShard).not.toContain('/i18n/en.json')
+    expect(plShard).not.toContain('@/modules/localized/i18n/pl.json')
+    expect(readGenerated(tmpDir, 'modules.i18n._hardcoded-allowlist.generated.ts')).toBeNull()
+
+    const secondResult = await generateModuleRegistryApp({ resolver, quiet: true })
+    expect(secondResult.filesWritten).toEqual([])
+
+    fs.rmSync(path.join(
+      tmpDir,
+      'packages',
+      'core',
+      'src',
+      'modules',
+      'localized',
+      'i18n',
+      'pl.json',
+    ))
+    await generateModuleRegistryApp({ resolver, quiet: true })
+    expect(readGenerated(tmpDir, 'modules.i18n.pl.generated.ts')).toBeNull()
+    expect(fs.existsSync(path.join(
+      tmpDir,
+      'output',
+      'generated',
+      'modules.i18n.pl.generated.checksum',
+    ))).toBe(false)
+    expect(readGenerated(tmpDir, 'modules.i18n.loaders.generated.ts')).not.toContain('case "pl":')
+  })
+
+  it('uses standalone source-mirror translations in locale-specific shards', async () => {
+    touchFile(
+      path.join(tmpDir, 'node_modules', 'pkg', 'src', 'modules', 'customers', 'i18n', 'en.json'),
+      JSON.stringify({ customers: { people: { title: 'People' } } }),
+    )
+    touchFile(
+      path.join(tmpDir, 'node_modules', 'pkg', 'dist', 'modules', 'customers', 'index.js'),
+      'export const metadata = { id: "customers" }\n',
+    )
+
+    const resolver = createStandaloneMockResolver(tmpDir, [
+      { id: 'customers', from: '@open-mercato/core' },
+    ])
+    const result = await generateModuleRegistryApp({ resolver, quiet: true })
+
+    expect(result.errors).toEqual([])
+    const shard = fs.readFileSync(
+      path.join(tmpDir, '.mercato', 'generated', 'modules.i18n.en.generated.ts'),
+      'utf8',
+    )
+    expect(shard).toContain('@open-mercato/core/modules/customers/i18n/en.json')
+    expect(shard).toContain('id: "customers"')
   })
 
   it('app output excludes CLI commands and keeps lazy workers/subscribers', async () => {

package/src/lib/generators/__tests__/output-snapshots.test.ts

@@ -829,12 +829,12 @@ describe('generator output compatibility', () => {
 
     const content = readGenerated('bootstrap-registrations.generated.ts')
     expect(content).not.toBeNull()
-    expect(content).toContain(`import { backendRoutes } from "./backend-routes.generated"`)
+    expect(content).toContain(`import { backendRouteFacades } from "./backend-route-shards.generated"`)
     expect(content).toContain(`import { frontendRoutes } from "./frontend-routes.generated"`)
     expect(content).toContain(
       `import { registerBackendRouteManifests, registerFrontendRouteManifests } from '@open-mercato/shared/modules/registry'`,
     )
-    expect(content).toMatch(/export function runBootstrapRegistrations\(\): void \{[\s\S]*registerBackendRouteManifests\(backendRoutes\)[\s\S]*\}/)
+    expect(content).toMatch(/export function runBootstrapRegistrations\(\): void \{[\s\S]*registerBackendRouteManifests\(backendRouteFacades\)[\s\S]*\}/)
     expect(content).toMatch(/export function runBootstrapRegistrations\(\): void \{[\s\S]*registerFrontendRouteManifests\(frontendRoutes\)[\s\S]*\}/)
   })
 
@@ -846,6 +846,6 @@ describe('generator output compatibility', () => {
 
     const content = readGenerated('bootstrap-registrations.generated.ts')
     expect(content).not.toBeNull()
-    expect(content).toContain(`registerBackendRouteManifests(backendRoutes)`)
+    expect(content).toContain(`registerBackendRouteManifests(backendRouteFacades)`)
   })
 })

package/src/lib/generators/__tests__/route-manifest-shards.test.ts

@@ -0,0 +1,62 @@
+import {
+  getRouteManifestShardKey,
+  renderRouteManifestShardOutputs,
+  renderRouteMetadataOutput,
+} from '../route-manifest-shards'
+
+describe('route manifest shards', () => {
+  it('groups static request prefixes and preserves dynamic-prefix fallbacks', () => {
+    expect(getRouteManifestShardKey('api', '/customers/[id]')).toBe('customers')
+    expect(getRouteManifestShardKey('backend', '/backend/sales/orders')).toBe('sales')
+    expect(getRouteManifestShardKey('backend', '/backend/[tenant]/settings')).toBe('__dynamic')
+    expect(getRouteManifestShardKey('api', '/')).toBe('__root')
+  })
+
+  it('renders a small loader graph with exact and dynamic shards', () => {
+    const outputs = renderRouteManifestShardOutputs('api', [
+      { path: '/customers', declaration: `{ moduleId: 'customers' } as any` },
+      { path: '/sales/orders', declaration: `{ moduleId: 'sales' } as any` },
+      { path: '/[module]/health', declaration: `{ moduleId: 'dynamic' } as any` },
+    ])
+    const loader = outputs.find((entry) => entry.fileName === 'api-route-shards.generated.ts')?.content ?? ''
+
+    expect(outputs.filter((entry) => entry.fileName.includes('route-shard.'))).toHaveLength(3)
+    expect(loader).toContain(`case "customers":`)
+    expect(loader).toContain(`case "sales":`)
+    expect(loader).toContain(`const dynamicShard = await loadShard("__dynamic")`)
+    expect(loader).toContain(`export const apiRouteFacades`)
+    expect(loader).toContain(`loadApiRouteManifestByOrdinal(ordinal)`)
+    expect(loader).not.toContain("moduleId: 'customers'")
+  })
+
+  it('retains global route order when exact and dynamic entries interleave', () => {
+    const outputs = renderRouteManifestShardOutputs('api', [
+      { path: '/customers/new', declaration: `{ path: '/customers/new' } as any` },
+      { path: '/[module]/health', declaration: `{ path: '/[module]/health' } as any` },
+      { path: '/customers/[id]', declaration: `{ path: '/customers/[id]' } as any` },
+      { path: '/', declaration: `{ path: '/' } as any` },
+    ])
+    const customerShard = outputs.find((entry) => entry.content.includes(`/customers/new`))?.content ?? ''
+    const dynamicShard = outputs.find((entry) => entry.content.includes(`/[module]/health`))?.content ?? ''
+    const loader = outputs.find((entry) => entry.fileName === 'api-route-shards.generated.ts')?.content ?? ''
+
+    expect(customerShard).toContain('export const routeOrders = [0, 2]')
+    expect(dynamicShard).toContain('export const routeOrders = [1]')
+    expect(loader).toContain(`case "__root":`)
+    expect(loader).toContain(`.sort((a, b) => a.order - b.order)`)
+    expect(loader).toContain(`const ROUTE_SHARD_KEYS = ["customers","__dynamic","customers","__root"]`)
+  })
+
+  it('renders metadata without load functions while retaining metadata imports', () => {
+    const output = renderRouteMetadataOutput('backend', [{
+      path: '/backend/settings',
+      declaration: `{ moduleId: 'settings', ...resolvePageRouteMetadata('/backend/settings', META.metadata) }`,
+      imports: [`import * as META from '@app/settings/meta'`],
+    }])
+
+    expect(output.fileName).toBe('backend-route-metadata.generated.ts')
+    expect(output.content).toContain(`import * as META from '@app/settings/meta'`)
+    expect(output.content).toContain(`Omit<BackendRouteManifestEntry, 'load'>`)
+    expect(output.content).not.toContain('load: async')
+  })
+})

package/src/lib/generators/entity-ids.ts

@@ -5,17 +5,13 @@ import { VariableDeclarationKind } from 'ts-morph'
 import type { PackageResolver, ModuleEntry } from '../resolver'
 import { MODULE_CODE_EXTENSIONS } from './scanner'
 import {
-  calculateChecksum,
-  readChecksumRecord,
-  writeChecksumRecord,
-  ensureDir,
   toVar,
   toSnake,
   rimrafDir,
-  logGenerationResult,
-  writeIfChanged,
   type GeneratorResult,
   createGeneratorResult,
+  writeGeneratedFile,
+  writeIfChanged,
 } from '../utils'
 import { addAutoGeneratedComment, createGeneratedSourceFile, elementAccess, getSourceText, identifier, returnStatement } from './ast'
 
@@ -438,26 +434,14 @@ export async function generateEntityIds(options: EntityIdsOptions): Promise<Gene
   })
   const consolidatedSrc = getSourceText(consolidatedSourceFile)
 
-  // Check if content has changed
-  const newChecksum = calculateChecksum(consolidatedSrc)
-  let shouldWrite = true
-
-  const existingRecord = readChecksumRecord(checksumFile)
-  if (existingRecord && existingRecord.content === newChecksum) {
-    shouldWrite = false
-  }
-
-  if (shouldWrite) {
-    ensureDir(outFile)
-    fs.writeFileSync(outFile, consolidatedSrc)
-    writeChecksumRecord(checksumFile, { content: newChecksum, structure: '' })
-    result.filesWritten.push(outFile)
-    if (!quiet) {
-      logGenerationResult(path.relative(process.cwd(), outFile), true)
-    }
-  } else {
-    result.filesUnchanged.push(outFile)
-  }
+  writeGeneratedFile({
+    outFile,
+    checksumFile,
+    content: consolidatedSrc,
+    structureChecksum: '',
+    result,
+    quiet,
+  })
 
   // Write per-group outputs
   const groups = Object.keys(grouped) as GroupKey[]

package/src/lib/generators/extensions/injection-widgets.ts

@@ -183,9 +183,52 @@ function resolveScannedWidgetPath(roots: ModuleRoots, fromApp: boolean, relPath:
   return path.join(base, 'widgets', 'injection', ...relPath.split('/'))
 }
 
+/**
+ * A widget's `metadata.id` and the injection-table entry that mounts it are two hand-typed string
+ * literals in two different files, and nothing links them. A typo in either fails silently: the spot
+ * resolves to no widget and nothing is logged, so it only surfaces as "why isn't my widget
+ * rendering" during manual QA.
+ *
+ * Reports table entries whose `widgetId` no scanned widget declares. Diagnostics only — generated
+ * output is unchanged and the build is not failed, since a table entry may legitimately point at a
+ * widget supplied by a module that is not enabled in this app.
+ *
+ * Deliberately one-directional. The mirror check ("a widget nothing references is never mounted")
+ * cannot be done reliably yet: `extractInjectionTableWidgetIds` only reads statically-analyzable
+ * object literals, so a table assembled by composition or computation contributes **no** visible
+ * ids — `example` exports `cond ? { ...a, ...b } : a` and `translations` exports
+ * `buildInjectionTable()`, and both would have every one of their widgets reported as unreferenced.
+ * Under-reporting is harmless in the direction implemented here (a reference the extractor never saw
+ * cannot produce a warning) but fatal in the other. Teaching the extractor to resolve spreads,
+ * conditionals and call expressions is the prerequisite for adding it.
+ */
+function reportUnresolvableWidgetReferences(
+  widgetEntries: Map<string, InjectionWidgetEntry>,
+  tableWidgetRefs: Map<string, Set<string>>,
+): void {
+  const declaredIds = new Set<string>()
+  for (const entry of widgetEntries.values()) {
+    if (entry.widgetId) declaredIds.add(entry.widgetId)
+  }
+
+  for (const [widgetId, modules] of Array.from(tableWidgetRefs.entries()).sort(([a], [b]) => a.localeCompare(b))) {
+    if (declaredIds.has(widgetId)) continue
+    const owners = Array.from(modules).sort((left, right) => left.localeCompare(right)).join(', ')
+    console.warn(
+      `[generate] ⚠ Injection table in "${owners}" references widget id "${widgetId}", but no scanned ` +
+        'widget declares it — that spot will render nothing. Check the id against the widget\'s ' +
+        'metadata.id, and that the widget lives in a file the scanner reads ' +
+        '(widgets/injection/**/widget.ts|tsx — note that widget.client.tsx alone is not scanned).',
+    )
+  }
+}
+
 export function createInjectionWidgetsExtension(): GeneratorExtension {
   const widgetEntries = new Map<string, InjectionWidgetEntry>()
   const tableEntries: InjectionTableEntry[] = []
+  // widgetId -> module ids whose injection table references it. Collected across every module so a
+  // table may legitimately reference a widget another module owns.
+  const tableWidgetRefs = new Map<string, Set<string>>()
 
   return {
     id: 'registry.injection-widgets',
@@ -217,6 +260,12 @@ export function createInjectionWidgetsExtension(): GeneratorExtension {
         moduleWidgetEntries[0].widgetId = tableWidgetIds[0]
       }
 
+      for (const widgetId of tableWidgetIds) {
+        const modules = tableWidgetRefs.get(widgetId) ?? new Set<string>()
+        modules.add(ctx.moduleId)
+        tableWidgetRefs.set(widgetId, modules)
+      }
+
       for (const entry of moduleWidgetEntries) {
         const existing = widgetEntries.get(entry.key)
         if (!existing || (existing.source !== 'app' && entry.source === 'app')) {
@@ -233,6 +282,8 @@ export function createInjectionWidgetsExtension(): GeneratorExtension {
       }
     },
     generateOutput() {
+      reportUnresolvableWidgetReferences(widgetEntries, tableWidgetRefs)
+
       const widgetDecls = Array.from(widgetEntries.entries())
         .sort(([left], [right]) => left.localeCompare(right))
         .map(([, entry]) =>

package/src/lib/generators/module-di.ts

@@ -4,14 +4,10 @@ import { StructureKind, VariableDeclarationKind } from 'ts-morph'
 import type { PackageResolver } from '../resolver'
 import { MODULE_CODE_EXTENSIONS } from './scanner'
 import {
-  calculateChecksum,
-  readChecksumRecord,
-  writeChecksumRecord,
-  ensureDir,
   toVar,
-  logGenerationResult,
   type GeneratorResult,
   createGeneratorResult,
+  writeGeneratedFile,
 } from '../utils'
 import {
   addAutoGeneratedComment,
@@ -96,26 +92,14 @@ export async function generateModuleDi(options: ModuleDiOptions): Promise<Genera
   })
   const output = getSourceText(sourceFile)
 
-  // Check if content has changed
-  const newChecksum = calculateChecksum(output)
-  let shouldWrite = true
-
-  const existingRecord = readChecksumRecord(checksumFile)
-  if (existingRecord && existingRecord.content === newChecksum) {
-    shouldWrite = false
-  }
-
-  if (shouldWrite) {
-    ensureDir(outFile)
-    fs.writeFileSync(outFile, output)
-    writeChecksumRecord(checksumFile, { content: newChecksum, structure: '' })
-    result.filesWritten.push(outFile)
-    if (!quiet) {
-      logGenerationResult(path.relative(process.cwd(), outFile), true)
-    }
-  } else {
-    result.filesUnchanged.push(outFile)
-  }
+  writeGeneratedFile({
+    outFile,
+    checksumFile,
+    content: output,
+    structureChecksum: '',
+    result,
+    quiet,
+  })
 
   return result
 }

package/src/lib/generators/module-entities.ts

@@ -4,14 +4,10 @@ import { StructureKind, VariableDeclarationKind } from 'ts-morph'
 import type { PackageResolver } from '../resolver'
 import { MODULE_CODE_EXTENSIONS, stripModuleCodeExtension } from './scanner'
 import {
-  calculateChecksum,
-  readChecksumRecord,
-  writeChecksumRecord,
-  ensureDir,
   toVar,
-  logGenerationResult,
   type GeneratorResult,
   createGeneratorResult,
+  writeGeneratedFile,
 } from '../utils'
 import {
   addAutoGeneratedComment,
@@ -206,26 +202,14 @@ export async function generateModuleEntities(options: ModuleEntitiesOptions): Pr
   })
   const output = getSourceText(sourceFile)
 
-  // Check if content has changed
-  const newChecksum = calculateChecksum(output)
-  let shouldWrite = true
-
-  const existingRecord = readChecksumRecord(checksumFile)
-  if (existingRecord && existingRecord.content === newChecksum) {
-    shouldWrite = false
-  }
-
-  if (shouldWrite) {
-    ensureDir(outFile)
-    fs.writeFileSync(outFile, output)
-    writeChecksumRecord(checksumFile, { content: newChecksum, structure: '' })
-    result.filesWritten.push(outFile)
-    if (!quiet) {
-      logGenerationResult(path.relative(process.cwd(), outFile), true)
-    }
-  } else {
-    result.filesUnchanged.push(outFile)
-  }
+  writeGeneratedFile({
+    outFile,
+    checksumFile,
+    content: output,
+    structureChecksum: '',
+    result,
+    quiet,
+  })
 
   return result
 }