@open-mercato/cli 0.6.7-develop.6685.1.77c0a5591b → 0.6.7-develop.6687.1.46a258e592

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

@@ -35,6 +35,12 @@ describe('module-facts BC resolve guard (T2)', () => {
     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,6 +52,7 @@ 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,11 +4,13 @@ import path from 'node:path'
 import type { PackageResolver } from '../../resolver'
 import { discoverPackageModuleSources, hasReadableModuleSource } from '../module-facts-discovery'
 
-type FakePackage = { name: string; path: string; modulesPath: string }
+type FakePackage = { name: string; version?: string | null; path: string; modulesPath: string }
+type FakeModuleEntry = { id: string; from?: string }
 
-function makeResolver(packages: FakePackage[]): PackageResolver {
+function makeResolver(packages: FakePackage[], enabledModules: FakeModuleEntry[] = []): PackageResolver {
   return {
     discoverPackages: () => packages,
+    loadEnabledModules: () => enabledModules,
   } as unknown as PackageResolver
 }
 
@@ -62,27 +64,69 @@ describe('module-facts discovery (T1)', () => {
     writeModule(path.join(pkgSrc, 'src', 'modules'), 'gamma', 'events.ts')
 
     const resolver = makeResolver([
-      { name: '@open-mercato/tagged', path: pkgSrc, modulesPath: path.join(pkgSrc, 'src', 'modules') },
+      { name: '@open-mercato/tagged', version: '0.6.6', path: pkgSrc, modulesPath: path.join(pkgSrc, 'src', 'modules') },
     ])
 
     const [source] = discoverPackageModuleSources(resolver)
-    expect(source).toMatchObject({ moduleId: 'gamma', from: '@open-mercato/tagged' })
+    expect(source).toMatchObject({
+      moduleId: 'gamma',
+      from: '@open-mercato/tagged',
+      packageVersion: '0.6.6',
+    })
     expect(source.moduleRoot).toBe(path.join(pkgSrc, 'src', 'modules', 'gamma'))
   })
 
-  it('dedupes duplicate module ids first-wins', () => {
+  it('fails closed on duplicate module ids and reports every provider independent of discovery order', () => {
     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 resolver = makeResolver([
+    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 = [
+      { 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 sources = discoverPackageModuleSources(resolver)
-    expect(sources).toHaveLength(1)
-    expect(sources[0].moduleRoot).toBe(path.join(pkgA, 'src', 'modules', 'shared'))
+    expect(() => discoverPackageModuleSources(makeResolver(packages, [{ id: 'shared' }]))).toThrow(
+      'src/modules.ts omits "from", which defaults to @open-mercato/core',
+    )
   })
 })

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

@@ -0,0 +1,108 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { extractModuleFacts } from '../module-facts'
+
+function findCoreSrcRoot(): string {
+  let dir = __dirname
+  for (let depth = 0; depth < 10; depth += 1) {
+    const candidate = path.join(dir, 'packages', 'core', 'src', 'modules')
+    if (fs.existsSync(candidate)) return candidate
+    dir = path.dirname(dir)
+  }
+  throw new Error('[internal] could not locate packages/core/src/modules from the test directory')
+}
+
+function write(filePath: string, source: string): void {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true })
+  fs.writeFileSync(filePath, source)
+}
+
+describe('module-facts extension host extraction', () => {
+  const coreSrcRoot = findCoreSrcRoot()
+
+  it('resolves generated E.<module>.<entity> custom-field declarations from shipped modules', () => {
+    const expectedByModule: Record<string, string[]> = {
+      attachments: ['attachments:attachment'],
+      catalog: [
+        'catalog:catalog_product',
+        'catalog:catalog_product_variant',
+        'catalog:catalog_product_price',
+      ],
+      sales: [
+        'sales:sales_order',
+        'sales:sales_order_line',
+        'sales:sales_order_adjustment',
+        'sales:sales_quote',
+        'sales:sales_quote_line',
+        'sales:sales_quote_adjustment',
+        'sales:sales_invoice',
+        'sales:sales_invoice_line',
+        'sales:sales_payment',
+        'sales:sales_payment_allocation',
+        'sales:sales_credit_memo',
+        'sales:sales_credit_memo_line',
+        'sales:sales_shipment',
+        'sales:sales_shipment_item',
+        'sales:sales_note',
+      ],
+      staff: ['staff:staff_team_member'],
+    }
+
+    for (const [moduleId, expected] of Object.entries(expectedByModule)) {
+      const facts = extractModuleFacts({ moduleId, coreSrcRoot })
+      expect(facts.entities.filter((entity) => entity.customFields).map((entity) => entity.id).sort()).toEqual(
+        [...expected].sort(),
+      )
+    }
+  })
+
+  it('discovers literal and conditional DataTable IDs outside backend while excluding test sources', () => {
+    const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'module-facts-extension-hosts-'))
+    const moduleRoot = path.join(tmpRoot, 'alpha')
+    try {
+      write(
+        path.join(moduleRoot, 'data', 'entities.ts'),
+        `@Entity({ tableName: 'alpha_records' })\nexport class AlphaRecord { updatedAt?: Date }\n`,
+      )
+      write(
+        path.join(moduleRoot, 'ce.ts'),
+        `export const entities = [{ id: E.alpha.alpha_record, fields: [] }]\n`,
+      )
+      write(
+        path.join(moduleRoot, 'components', 'AlphaTable.tsx'),
+        `export const props = {
+  perspective: { tableId: kind === 'one' ? 'alpha.one' : 'alpha.two' },
+  extensionTableId: 'alpha.extension',
+}\n`,
+      )
+      write(
+        path.join(moduleRoot, 'components', 'Noise.test.tsx'),
+        `export const noise = { tableId: 'alpha.test-noise' }\n`,
+      )
+      write(
+        path.join(moduleRoot, 'backend', '__tests__', 'noise.tsx'),
+        `export const noise = { extensionTableId: 'alpha.test-directory-noise' }\n`,
+      )
+
+      const facts = extractModuleFacts({ moduleId: 'alpha', moduleRoot })
+      expect(facts.entities).toEqual([
+        expect.objectContaining({ id: 'alpha:alpha_record', customFields: true }),
+      ])
+      expect(facts.hostTokens.tableIds).toEqual(['alpha.extension', 'alpha.one', 'alpha.two'])
+    } finally {
+      fs.rmSync(tmpRoot, { recursive: true, force: true })
+    }
+  })
+
+  it('captures shipped component-level table hosts used by catalog and sales', () => {
+    const catalog = extractModuleFacts({ moduleId: 'catalog', coreSrcRoot })
+    expect(catalog.hostTokens.tableIds).toEqual([
+      'catalog.categories.list',
+      'catalog.products.list',
+    ])
+
+    const sales = extractModuleFacts({ moduleId: 'sales', coreSrcRoot })
+    expect(sales.hostTokens.tableIds).toEqual(['sales.orders', 'sales.quotes'])
+  })
+})

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

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

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-facts-discovery.ts

@@ -29,13 +29,59 @@ export function hasReadableModuleSource(moduleRoot: string): boolean {
   return false
 }
 
-function dedupeById(sources: ModuleFactSource[]): ModuleFactSource[] {
-  const seen = new Set<string>()
+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>()
   const result: ModuleFactSource[] = []
   for (const source of sources) {
-    if (seen.has(source.moduleId)) continue
-    seen.add(source.moduleId)
-    result.push(source)
+    if (emitted.has(source.moduleId)) continue
+    emitted.add(source.moduleId)
+    result.push(selectedSources.get(source.moduleId) ?? source)
   }
   return result
 }
@@ -51,8 +97,13 @@ 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 })
+      sources.push({
+        moduleId: discovered.moduleId,
+        moduleRoot,
+        from: pkg.name,
+        packageVersion: pkg.version ?? null,
+      })
     }
   }
-  return dedupeById(sources)
+  return resolveDuplicateModuleIds(sources, resolver)
 }

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

@@ -40,6 +40,8 @@ export interface ModuleFacts {
   title: string | null
   description: string | null
   coreVersion: string | null
+  sourcePackage: string | null
+  sourceVersion: string | null
   entities: ModuleEntityFact[]
   events: ModuleEventFact[]
   aclFeatures: string[]
@@ -64,6 +66,8 @@ export interface ExtractModuleFactsOptions {
   /** Explicit module source directory. When set it overrides `coreSrcRoot + moduleId`. */
   moduleRoot?: string
   coreVersion?: string | null
+  sourcePackage?: string | null
+  sourceVersion?: string | null
   registryPath?: string | null
   registrySource?: string | null
 }
@@ -73,6 +77,7 @@ export interface ModuleFactSource {
   moduleId: string
   moduleRoot: string
   from?: string
+  packageVersion?: string | null
 }
 
 function readSourceFile(filePath: string): ts.SourceFile | null {
@@ -159,10 +164,41 @@ function collectCustomFieldEntityIds(ceFilePath: string | null): Set<string> {
   const sourceFile = readSourceFile(ceFilePath)
   if (!sourceFile) return result
 
+  const readEntityId = (expression: ts.Expression): string | undefined => {
+    const current = unwrapExpression(expression)
+    if (ts.isStringLiteralLike(current)) {
+      return current.text.includes(':') ? current.text : undefined
+    }
+
+    const readAccessPath = (candidate: ts.Expression): string[] | null => {
+      const access = unwrapExpression(candidate)
+      if (ts.isIdentifier(access)) return [access.text]
+      if (ts.isPropertyAccessExpression(access)) {
+        const parent = readAccessPath(access.expression)
+        return parent ? [...parent, access.name.text] : null
+      }
+      if (ts.isElementAccessExpression(access) && access.argumentExpression) {
+        const parent = readAccessPath(access.expression)
+        const key = unwrapExpression(access.argumentExpression)
+        return parent && ts.isStringLiteralLike(key) ? [...parent, key.text] : null
+      }
+      return null
+    }
+
+    const accessPath = readAccessPath(current)
+    if (accessPath?.length === 3 && accessPath[0] === 'E') {
+      return `${accessPath[1]}:${accessPath[2]}`
+    }
+    return undefined
+  }
+
   const visit = (node: ts.Node): void => {
     if (ts.isObjectLiteralExpression(node)) {
-      const id = readStringPropertyInitializer(node, 'id')
-      if (id && id.includes(':')) result.add(id)
+      const initializer = getObjectPropertyInitializer(node, 'id')
+      if (initializer) {
+        const id = readEntityId(initializer)
+        if (id) result.add(id)
+      }
     }
     node.forEachChild(visit)
   }
@@ -666,36 +702,50 @@ function extractCli(cliFilePath: string | null, warnings: string[]): string[] {
 function listSourceFilesRecursive(directory: string): string[] {
   const files: string[] = []
   for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
-    if (entry.name === '__tests__' || entry.name === 'node_modules') continue
+    if (entry.name === '__tests__' || entry.name === '__mocks__' || entry.name === 'node_modules') continue
     const fullPath = path.join(directory, entry.name)
     if (entry.isDirectory()) {
       files.push(...listSourceFilesRecursive(fullPath))
-    } else if (/\.tsx?$/.test(entry.name) && !entry.name.endsWith('.d.ts')) {
+    } else if (
+      /\.tsx?$/.test(entry.name)
+      && !entry.name.endsWith('.d.ts')
+      && !/\.(?:test|spec)\.tsx?$/.test(entry.name)
+    ) {
       files.push(fullPath)
     }
   }
   return files
 }
 
-function extractTableIds(backendDir: string): string[] {
-  if (!fs.existsSync(backendDir)) return []
+function extractTableIds(moduleRoot: string): string[] {
+  if (!fs.existsSync(moduleRoot)) return []
 
   const tableIds: string[] = []
   const seen = new Set<string>()
-  for (const filePath of listSourceFilesRecursive(backendDir)) {
+  const collectLiteralValues = (expression: ts.Expression): string[] => {
+    const current = unwrapExpression(expression)
+    if (ts.isStringLiteralLike(current)) return [current.text]
+    if (ts.isConditionalExpression(current)) {
+      return [
+        ...collectLiteralValues(current.whenTrue),
+        ...collectLiteralValues(current.whenFalse),
+      ]
+    }
+    return []
+  }
+
+  for (const filePath of listSourceFilesRecursive(moduleRoot)) {
     const sourceFile = readSourceFile(filePath)
     if (!sourceFile) continue
     const visit = (node: ts.Node): void => {
       if (ts.isPropertyAssignment(node)) {
         const propertyName = getPropertyName(node)
-        if (
-          (propertyName === 'tableId' || propertyName === 'extensionTableId') &&
-          ts.isStringLiteralLike(node.initializer)
-        ) {
-          const value = node.initializer.text
-          if (value && !seen.has(value)) {
-            seen.add(value)
-            tableIds.push(value)
+        if (propertyName === 'tableId' || propertyName === 'extensionTableId') {
+          for (const value of collectLiteralValues(node.initializer)) {
+            if (value && !seen.has(value)) {
+              seen.add(value)
+              tableIds.push(value)
+            }
           }
         }
       }
@@ -724,7 +774,7 @@ function extractModuleMeta(indexFilePath: string | null): { title: string | null
 }
 
 export function extractModuleFacts(options: ExtractModuleFactsOptions): ModuleFacts {
-  const { moduleId, coreVersion = null } = options
+  const { moduleId, coreVersion = null, sourcePackage = null, sourceVersion = null } = options
   const moduleRoot = options.moduleRoot
     ?? (options.coreSrcRoot ? path.join(options.coreSrcRoot, moduleId) : null)
   if (!moduleRoot) {
@@ -743,7 +793,6 @@ export function extractModuleFacts(options: ExtractModuleFactsOptions): ModuleFa
   const notificationsFilePath = resolveConventionFile(moduleRoot, 'notifications')
   const cliFilePath = resolveConventionFile(moduleRoot, 'cli')
   const indexFilePath = resolveConventionFile(moduleRoot, 'index')
-  const backendDir = path.join(moduleRoot, 'backend')
 
   const warnings: string[] = []
   const { title, description } = extractModuleMeta(indexFilePath)
@@ -760,7 +809,7 @@ export function extractModuleFacts(options: ExtractModuleFactsOptions): ModuleFa
   const cli = extractCli(cliFilePath, warnings)
   const hostTokens: ModuleHostTokens = {
     entityIds: extractHostEntityIds(entities),
-    tableIds: extractTableIds(backendDir),
+    tableIds: extractTableIds(moduleRoot),
   }
 
   return {
@@ -768,6 +817,8 @@ export function extractModuleFacts(options: ExtractModuleFactsOptions): ModuleFa
     title,
     description,
     coreVersion,
+    sourcePackage,
+    sourceVersion,
     entities,
     events,
     aclFeatures,
@@ -791,6 +842,8 @@ export interface ModuleFactsJsonEntry {
   title: string | null
   description: string | null
   coreVersion: string | null
+  sourcePackage: string | null
+  sourceVersion: string | null
   entities: ModuleEntityFact[]
   events: ModuleFactsJsonEvent[]
   aclFeatures: string[]
@@ -804,7 +857,14 @@ export interface ModuleFactsJsonEntry {
 
 const EMPTY_SECTION_MARKER = '_none_'
 
-function renderVersionStamp(coreVersion: string | null): string {
+function renderVersionStamp(
+  coreVersion: string | null,
+  sourcePackage: string | null,
+  sourceVersion: string | null,
+): string {
+  if (sourcePackage) {
+    return `<!-- generated from ${sourcePackage} ${sourceVersion || '<unknown>'}; core ${coreVersion || '<unknown>'} — R1 staleness stamp -->`
+  }
   const version = coreVersion && coreVersion.length > 0 ? coreVersion : '<unknown>'
   return `<!-- generated from @open-mercato/core ${version} — R1 staleness stamp -->`
 }
@@ -873,7 +933,7 @@ function renderHostTokensSection(hostTokens: ModuleHostTokens): string {
 export function renderModuleFactsMarkdown(facts: ModuleFacts): string {
   const sections = [
     `# ${facts.module} — module facts (generated, do not edit)`,
-    renderVersionStamp(facts.coreVersion),
+    renderVersionStamp(facts.coreVersion, facts.sourcePackage, facts.sourceVersion),
     '',
     renderEntitiesSection(facts.entities),
     '',
@@ -902,6 +962,8 @@ export function toModuleFactsJsonEntry(facts: ModuleFacts): ModuleFactsJsonEntry
     title: facts.title,
     description: facts.description,
     coreVersion: facts.coreVersion,
+    sourcePackage: facts.sourcePackage,
+    sourceVersion: facts.sourceVersion,
     entities: facts.entities,
     events: facts.events.map((event) => ({ id: event.id, category: event.category, entity: event.entity })),
     aclFeatures: facts.aclFeatures,
@@ -967,6 +1029,8 @@ export function extractAllModuleFacts(options: ExtractAllModuleFactsOptions): Ex
       moduleId: source.moduleId,
       moduleRoot: source.moduleRoot,
       coreVersion: options.coreVersion ?? null,
+      sourcePackage: source.from ?? null,
+      sourceVersion: source.packageVersion ?? null,
       registryPath: options.registryPath ?? null,
       registrySource: options.registrySource ?? null,
     })

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

@@ -3059,6 +3059,10 @@ async function generateModuleRegistryFromDiscovery(options: ModuleRegistryRender
       if (fields) fieldsImportName = fields.importName
     }
 
+    const integrationExports = integrationImportName
+      ? `(${integrationImportName} as unknown as { integrations?: import('@open-mercato/shared/modules/integrations/types').IntegrationDefinition[]; integration?: import('@open-mercato/shared/modules/integrations/types').IntegrationDefinition; bundles?: import('@open-mercato/shared/modules/integrations/types').IntegrationBundle[]; bundle?: import('@open-mercato/shared/modules/integrations/types').IntegrationBundle })`
+      : null
+
     // 13. Pages: backend
     {
       const beApp = path.join(roots.appBase, 'backend')
@@ -3167,8 +3171,8 @@ async function generateModuleRegistryFromDiscovery(options: ModuleRegistryRender
       ${dashboardWidgets.length ? `dashboardWidgets: [${dashboardWidgets.join(', ')}],` : ''}
       ${setupImportName ? `setup: (${setupImportName}.default ?? ${setupImportName}.setup) || undefined,` : ''}
       ${encryptionImportName ? `defaultEncryptionMaps: ((${encryptionImportName}.default ?? ${encryptionImportName}.defaultEncryptionMaps) as import('@open-mercato/shared/modules/encryption').ModuleEncryptionMap[]) || [],` : ''}
-      ${integrationImportName ? `integrations: (( ${integrationImportName}.integrations ?? (${integrationImportName}.integration ? [${integrationImportName}.integration] : []) ) as import('@open-mercato/shared/modules/integrations/types').IntegrationDefinition[]),` : ''}
-      ${integrationImportName ? `bundles: (( ${integrationImportName}.bundles ?? (${integrationImportName}.bundle ? [${integrationImportName}.bundle] : []) ) as import('@open-mercato/shared/modules/integrations/types').IntegrationBundle[]),` : ''}
+      ${integrationExports ? `integrations: ((${integrationExports}.integrations ?? (${integrationExports}.integration ? [${integrationExports}.integration] : [])) as import('@open-mercato/shared/modules/integrations/types').IntegrationDefinition[]),` : ''}
+      ${integrationExports ? `bundles: ((${integrationExports}.bundles ?? (${integrationExports}.bundle ? [${integrationExports}.bundle] : [])) as import('@open-mercato/shared/modules/integrations/types').IntegrationBundle[]),` : ''}
     }`)
     runtimeModuleDecls.push(`{
       id: ${toLiteral(modId)},
@@ -3185,8 +3189,8 @@ async function generateModuleRegistryFromDiscovery(options: ModuleRegistryRender
       ${customEntitiesImportName ? `customEntities: ((${customEntitiesImportName}.default ?? ${customEntitiesImportName}.entities) as any) || [],` : ''}
       ${setupImportName ? `setup: (${setupImportName}.default ?? ${setupImportName}.setup) || undefined,` : ''}
       ${encryptionImportName ? `defaultEncryptionMaps: ((${encryptionImportName}.default ?? ${encryptionImportName}.defaultEncryptionMaps) as import('@open-mercato/shared/modules/encryption').ModuleEncryptionMap[]) || [],` : ''}
-      ${integrationImportName ? `integrations: (( ${integrationImportName}.integrations ?? (${integrationImportName}.integration ? [${integrationImportName}.integration] : []) ) as import('@open-mercato/shared/modules/integrations/types').IntegrationDefinition[]),` : ''}
-      ${integrationImportName ? `bundles: (( ${integrationImportName}.bundles ?? (${integrationImportName}.bundle ? [${integrationImportName}.bundle] : []) ) as import('@open-mercato/shared/modules/integrations/types').IntegrationBundle[]),` : ''}
+      ${integrationExports ? `integrations: ((${integrationExports}.integrations ?? (${integrationExports}.integration ? [${integrationExports}.integration] : [])) as import('@open-mercato/shared/modules/integrations/types').IntegrationDefinition[]),` : ''}
+      ${integrationExports ? `bundles: ((${integrationExports}.bundles ?? (${integrationExports}.bundle ? [${integrationExports}.bundle] : [])) as import('@open-mercato/shared/modules/integrations/types').IntegrationBundle[]),` : ''}
     }`)
   }