@open-mercato/cli 0.6.7-develop.6862.1.c11a64ce0a → 0.6.7

package/src/lib/generators/__tests__/module-facts.bc-guard.test.ts

@@ -1,6 +1,6 @@
 import fs from 'node:fs'
 import path from 'node:path'
-import { extractAllModuleFacts, renderModuleFactsJson } from '../module-facts'
+import { extractAllModuleFacts } from '../module-facts'
 import { discoverPackageModuleSources } from '../module-facts-discovery'
 import { createResolver } from '../../resolver'
 
@@ -20,77 +20,7 @@ function isUnique(values: string[]): boolean {
 describe('module-facts BC resolve guard (T2)', () => {
   const repoRoot = findRepoRoot()
   const sources = discoverPackageModuleSources(createResolver(repoRoot))
-  const extractionStartedAt = process.cpuUsage()
-  const { factsByModule, markdownByModule, frameworkMarkdown } = extractAllModuleFacts({ sources })
-  const extractionCpuUsage = process.cpuUsage(extractionStartedAt)
-  const extractionCpuDurationMs = (extractionCpuUsage.user + extractionCpuUsage.system) / 1_000
-
-  it('emits complete, deterministic extension catalogs for every resolved module', () => {
-    const repeated = extractAllModuleFacts({ sources })
-    expect(renderModuleFactsJson(repeated.factsByModule)).toBe(renderModuleFactsJson(factsByModule))
-    expect(repeated.markdownByModule).toEqual(markdownByModule)
-    expect(repeated.frameworkMarkdown).toBe(frameworkMarkdown)
-    for (const facts of Object.values(factsByModule)) {
-      expect(facts.extensionSurfaces).toBeDefined()
-      expect(facts.extensionSurfaces?.unresolved).toEqual([])
-    }
-  })
-
-  it('keeps generated extension facts within bounded build-time and context budgets', () => {
-    const completeJson = renderModuleFactsJson(factsByModule)
-    const legacyJson = renderModuleFactsJson(Object.fromEntries(
-      Object.entries(factsByModule).map(([moduleId, facts]) => [moduleId, { ...facts, extensionSurfaces: undefined }]),
-    ))
-    const markdownBytes = Object.values(markdownByModule)
-      .reduce((total, markdown) => total + Buffer.byteLength(markdown), Buffer.byteLength(frameworkMarkdown))
-
-    // Budget raised by the bidirectional-topology spec
-    // (2026-08-02-module-facts-extension-activation-and-incoming-index): the
-    // additive `activations`, cross-module `incoming`, and per-contribution
-    // `contributionResolutions` layers add ~210KB of compact references (no
-    // contribution payloads are duplicated). Incoming rows are cross-module only;
-    // resolution rows are required one-per-contribution by the spec's acceptance
-    // criteria and are the dominant term.
-    //
-    // JSON cap raised again by the exact-override-targets spec
-    // (2026-08-02-module-facts-exact-override-targets): the additive per-module
-    // `overrideTargets` project one exact key per real override entry (acl
-    // features, di tokens, subscribers, pages, workers, encryption, widgets,
-    // notifications, cli, setup, ai, interceptors/enrichers, page guards). These
-    // are required exhaustively by the spec's acceptance criteria; targets carry
-    // only compact structured path/key/factRef/source refs (no runtime values or
-    // contribution payloads). The delta cap is unchanged because `overrideTargets`
-    // live in both the complete and legacy renders (only `extensionSurfaces` is
-    // stripped for the legacy comparison).
-    //
-    // JSON cap raised a third time by the uniform provenance index
-    // (2026-08-02-module-facts-source-provenance-and-contract-inventory): every
-    // proven `(kind, id)` now reaches `factSources` (~630KB across the repo), so a
-    // consumer resolves any fact's origin through one lookup. Entries whose
-    // declaration site is already serialized inline (routes, pages, CLI commands,
-    // AI tools/agents, owned contracts, hosts, contributions) emit a typed
-    // `factRef` pointer instead of a duplicated source ref, and `factKey` is
-    // omitted when it equals the entry `id` — so the index costs references, never
-    // copied provenance payloads. The cap also covers the newly reachable
-    // framework-host activations (dashboard/menu/notification contributions now
-    // resolve as bound instead of silently falling back to capability-only).
-    // This is a blow-up detector, not a performance target. It measures CPU time
-    // for a whole-repo extraction, and CPU time for fixed work varies with the
-    // machine: the same extraction measures ~7.3s on a developer workstation and
-    // ~30.0s on a CI runner. At the previous 30s cap CI sat exactly on the line
-    // (an observed failure at 30,052.8ms), so the guard could not tell a genuine
-    // pathological regression from ordinary hardware variance and failed
-    // unrelated PRs at random. 90s keeps it meaningful — a real blow-up here is
-    // multiplicative, not a few percent — while leaving CI roughly 3x headroom.
-    expect(extractionCpuDurationMs).toBeLessThan(90_000)
-    expect(Buffer.byteLength(completeJson)).toBeLessThan(3_500_000)
-    expect(Buffer.byteLength(completeJson) - Buffer.byteLength(legacyJson)).toBeLessThan(1_800_000)
-    // Markdown cap raised with the source-link contract: entities, events, ACL
-    // features, DI tokens, search entities, notifications, UMES hosts and UMES
-    // contributions all render a resolved Source cell, and contribution
-    // resolutions render as their own source-linked section.
-    expect(markdownBytes).toBeLessThan(1_550_000)
-  })
+  const { factsByModule } = extractAllModuleFacts({ sources })
 
   it('discovers a superset of the historical core modules', () => {
     const discovered = new Set(Object.keys(factsByModule))
@@ -100,27 +30,11 @@ describe('module-facts BC resolve guard (T2)', () => {
     expect(discovered.size).toBeGreaterThan(9)
   })
 
-  it('keeps factory-built and generated-registry enricher contributions visible', () => {
-    expect(factsByModule.sales.extensionSurfaces?.contributions).toEqual(expect.arrayContaining([
-      expect.objectContaining({ id: 'sales.catalog-image:sales:sales_quote_line', kind: 'response-enricher' }),
-      expect.objectContaining({ id: 'sales.catalog-image:sales:sales_order_line', kind: 'response-enricher' }),
-    ]))
-    expect(factsByModule.wms.extensionSurfaces?.contributions).toEqual(expect.arrayContaining([
-      expect.objectContaining({ id: 'wms.sales-order-inventory', kind: 'response-enricher' }),
-    ]))
-  })
-
   for (const source of sources) {
     const moduleId = source.moduleId
     describe(`${moduleId}`, () => {
       const facts = factsByModule[moduleId]
 
-      it('stamps the exact providing package and version without removing coreVersion', () => {
-        expect(facts.sourcePackage).toBe(source.from ?? null)
-        expect(facts.sourceVersion).toBe(source.packageVersion ?? null)
-        expect(facts).toHaveProperty('coreVersion')
-      })
-
       // Entity / search / host ids are colon-namespaced under the module by construction
       // and convention; drift here means the builder or a module's data model broke.
       it('colon-namespaces entity / search / host ids under the module and keeps ids unique', () => {

package/src/lib/generators/__tests__/module-facts.customers.fixture.test.ts

@@ -52,7 +52,6 @@ describe('module-facts customers fixture (T1 anti-drift guard)', () => {
       'customers.companies.list',
       'customers.deals.list',
       'customers.people.list',
-      'customers.todos.list',
     ])
     expect(facts.hostTokens.entityIds).toEqual(['customers:customer_entity'])
     expect(facts.diTokens).toEqual([])

package/src/lib/generators/__tests__/module-facts.discovery.test.ts

@@ -4,13 +4,11 @@ import path from 'node:path'
 import type { PackageResolver } from '../../resolver'
 import { discoverPackageModuleSources, hasReadableModuleSource } from '../module-facts-discovery'
 
-type FakePackage = { name: string; version?: string | null; path: string; modulesPath: string }
-type FakeModuleEntry = { id: string; from?: string }
+type FakePackage = { name: string; path: string; modulesPath: string }
 
-function makeResolver(packages: FakePackage[], enabledModules: FakeModuleEntry[] = []): PackageResolver {
+function makeResolver(packages: FakePackage[]): PackageResolver {
   return {
     discoverPackages: () => packages,
-    loadEnabledModules: () => enabledModules,
   } as unknown as PackageResolver
 }
 
@@ -64,69 +62,27 @@ describe('module-facts discovery (T1)', () => {
     writeModule(path.join(pkgSrc, 'src', 'modules'), 'gamma', 'events.ts')
 
     const resolver = makeResolver([
-      { name: '@open-mercato/tagged', version: '0.6.6', path: pkgSrc, modulesPath: path.join(pkgSrc, 'src', 'modules') },
+      { name: '@open-mercato/tagged', path: pkgSrc, modulesPath: path.join(pkgSrc, 'src', 'modules') },
     ])
 
     const [source] = discoverPackageModuleSources(resolver)
-    expect(source).toMatchObject({
-      moduleId: 'gamma',
-      from: '@open-mercato/tagged',
-      packageVersion: '0.6.6',
-    })
+    expect(source).toMatchObject({ moduleId: 'gamma', from: '@open-mercato/tagged' })
     expect(source.moduleRoot).toBe(path.join(pkgSrc, 'src', 'modules', 'gamma'))
   })
 
-  it('fails closed on duplicate module ids and reports every provider independent of discovery order', () => {
+  it('dedupes duplicate module ids first-wins', () => {
     const pkgA = path.join(tmp, 'dup-a')
     writeModule(path.join(pkgA, 'src', 'modules'), 'shared', 'index.ts')
     const pkgB = path.join(tmp, 'dup-b')
     writeModule(path.join(pkgB, 'src', 'modules'), 'shared', 'index.ts')
 
-    const packages = [
-      { name: '@open-mercato/dup-a', path: pkgA, modulesPath: path.join(pkgA, 'src', 'modules') },
-      { name: '@open-mercato/dup-b', path: pkgB, modulesPath: path.join(pkgB, 'src', 'modules') },
-    ]
-    const expected = '[module-facts] duplicate module id "shared" is provided by '
-      + '@open-mercato/dup-a, @open-mercato/dup-b; src/modules.ts does not select a provider. '
-      + 'Select exactly one matching provider in src/modules.ts.'
-
-    expect(() => discoverPackageModuleSources(makeResolver(packages))).toThrow(expected)
-    expect(() => discoverPackageModuleSources(makeResolver([...packages].reverse()))).toThrow(expected)
-  })
-
-  it('uses the exact src/modules.ts provider even when package discovery order is reversed', () => {
-    const pkgA = path.join(tmp, 'selected-a')
-    writeModule(path.join(pkgA, 'src', 'modules'), 'shared', 'index.ts')
-    const pkgB = path.join(tmp, 'selected-b')
-    writeModule(path.join(pkgB, 'src', 'modules'), 'shared', 'index.ts')
-
-    const packages = [
-      { name: '@open-mercato/selected-a', path: pkgA, modulesPath: path.join(pkgA, 'src', 'modules') },
-      { name: '@open-mercato/selected-b', path: pkgB, modulesPath: path.join(pkgB, 'src', 'modules') },
-    ]
-    const enabled = [{ id: 'shared', from: '@open-mercato/selected-b' }]
-
-    for (const discoveredPackages of [packages, [...packages].reverse()]) {
-      const sources = discoverPackageModuleSources(makeResolver(discoveredPackages, enabled))
-      expect(sources).toHaveLength(1)
-      expect(sources[0]).toMatchObject({ moduleId: 'shared', from: '@open-mercato/selected-b' })
-      expect(sources[0].moduleRoot).toBe(path.join(pkgB, 'src', 'modules', 'shared'))
-    }
-  })
-
-  it('explains that an omitted provider implicitly selects core', () => {
-    const pkgA = path.join(tmp, 'implicit-a')
-    writeModule(path.join(pkgA, 'src', 'modules'), 'shared', 'index.ts')
-    const pkgB = path.join(tmp, 'implicit-b')
-    writeModule(path.join(pkgB, 'src', 'modules'), 'shared', 'index.ts')
-
-    const packages = [
+    const resolver = makeResolver([
       { name: '@open-mercato/dup-a', path: pkgA, modulesPath: path.join(pkgA, 'src', 'modules') },
       { name: '@open-mercato/dup-b', path: pkgB, modulesPath: path.join(pkgB, 'src', 'modules') },
-    ]
+    ])
 
-    expect(() => discoverPackageModuleSources(makeResolver(packages, [{ id: 'shared' }]))).toThrow(
-      'src/modules.ts omits "from", which defaults to @open-mercato/core',
-    )
+    const sources = discoverPackageModuleSources(resolver)
+    expect(sources).toHaveLength(1)
+    expect(sources[0].moduleRoot).toBe(path.join(pkgA, 'src', 'modules', 'shared'))
   })
 })

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

@@ -702,24 +702,6 @@ 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`),

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

@@ -183,52 +183,9 @@ 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',
@@ -260,12 +217,6 @@ 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')) {
@@ -282,8 +233,6 @@ 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-facts-discovery.ts

@@ -29,59 +29,13 @@ export function hasReadableModuleSource(moduleRoot: string): boolean {
   return false
 }
 
-function resolveDuplicateModuleIds(
-  sources: ModuleFactSource[],
-  resolver: PackageResolver,
-): ModuleFactSource[] {
-  const sourcesByModule = new Map<string, ModuleFactSource[]>()
-  for (const source of sources) {
-    const matches = sourcesByModule.get(source.moduleId) ?? []
-    matches.push(source)
-    sourcesByModule.set(source.moduleId, matches)
-  }
-
-  const duplicates = [...sourcesByModule.entries()].filter(([, matches]) => matches.length > 1)
-  if (duplicates.length === 0) return sources
-
-  const selectedProviders = new Map<string, Set<string>>()
-  const implicitCoreSelections = new Set<string>()
-  for (const entry of resolver.loadEnabledModules()) {
-    const providers = selectedProviders.get(entry.id) ?? new Set<string>()
-    providers.add(entry.from ?? '@open-mercato/core')
-    selectedProviders.set(entry.id, providers)
-    if (entry.from === undefined) implicitCoreSelections.add(entry.id)
-  }
-
-  const selectedSources = new Map<string, ModuleFactSource>()
-  for (const [moduleId, matches] of duplicates) {
-    const providers = [...new Set(matches.map((source) => source.from ?? '<unknown>'))]
-      .sort((left, right) => left.localeCompare(right))
-    const configuredProviders = [...(selectedProviders.get(moduleId) ?? [])]
-      .sort((left, right) => left.localeCompare(right))
-    const selected = configuredProviders.length === 1
-      ? matches.filter((source) => source.from === configuredProviders[0])
-      : []
-
-    if (selected.length !== 1) {
-      const configured = configuredProviders.length > 0
-        ? implicitCoreSelections.has(moduleId)
-          ? '; src/modules.ts omits "from", which defaults to @open-mercato/core'
-          : `; src/modules.ts selects ${configuredProviders.join(', ')}`
-        : '; src/modules.ts does not select a provider'
-      throw new Error(
-        `[module-facts] duplicate module id "${moduleId}" is provided by ${providers.join(', ')}${configured}. `
-        + 'Select exactly one matching provider in src/modules.ts.',
-      )
-    }
-    selectedSources.set(moduleId, selected[0])
-  }
-
-  const emitted = new Set<string>()
+function dedupeById(sources: ModuleFactSource[]): ModuleFactSource[] {
+  const seen = new Set<string>()
   const result: ModuleFactSource[] = []
   for (const source of sources) {
-    if (emitted.has(source.moduleId)) continue
-    emitted.add(source.moduleId)
-    result.push(selectedSources.get(source.moduleId) ?? source)
+    if (seen.has(source.moduleId)) continue
+    seen.add(source.moduleId)
+    result.push(source)
   }
   return result
 }
@@ -97,13 +51,8 @@ export function discoverPackageModuleSources(resolver: PackageResolver): ModuleF
     for (const discovered of discoverModulesInPackage(pkg.path)) {
       const moduleRoot = path.join(pkg.modulesPath, discovered.moduleId)
       if (!hasReadableModuleSource(moduleRoot)) continue
-      sources.push({
-        moduleId: discovered.moduleId,
-        moduleRoot,
-        from: pkg.name,
-        packageVersion: pkg.version ?? null,
-      })
+      sources.push({ moduleId: discovered.moduleId, moduleRoot, from: pkg.name })
     }
   }
-  return resolveDuplicateModuleIds(sources, resolver)
+  return dedupeById(sources)
 }