@open-mercato/cli 0.6.6-develop.6457.1.41b39a465a → 0.6.6-develop.6460.1.f94c74174c

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-mercato/cli",
-  "version": "0.6.6-develop.6457.1.41b39a465a",
+  "version": "0.6.6-develop.6460.1.f94c74174c",
   "license": "MIT",
   "type": "module",
   "main": "./dist/index.js",
@@ -60,8 +60,8 @@
     "@mikro-orm/decorators": "^7.1.5",
     "@mikro-orm/migrations": "^7.1.5",
     "@mikro-orm/postgresql": "^7.1.5",
-    "@open-mercato/queue": "0.6.6-develop.6457.1.41b39a465a",
-    "@open-mercato/shared": "0.6.6-develop.6457.1.41b39a465a",
+    "@open-mercato/queue": "0.6.6-develop.6460.1.f94c74174c",
+    "@open-mercato/shared": "0.6.6-develop.6460.1.f94c74174c",
     "cross-spawn": "^7.0.6",
     "pg": "8.22.0",
     "semver": "^7.8.5",
@@ -71,10 +71,10 @@
     "typescript": "^6.0.3"
   },
   "peerDependencies": {
-    "@open-mercato/shared": "0.6.6-develop.6457.1.41b39a465a"
+    "@open-mercato/shared": "0.6.6-develop.6460.1.f94c74174c"
   },
   "devDependencies": {
-    "@open-mercato/shared": "0.6.6-develop.6457.1.41b39a465a",
+    "@open-mercato/shared": "0.6.6-develop.6460.1.f94c74174c",
     "@types/jest": "^30.0.0",
     "jest": "^30.4.2",
     "ts-jest": "^29.4.11"

package/src/__tests__/mercato.test.ts

@@ -359,7 +359,6 @@ describe('init command failure output', () => {
       generateModuleDi: jest.fn().mockResolvedValue(undefined),
       generateModulePackageSources: jest.fn().mockResolvedValue(undefined),
       generateOpenApi: jest.fn().mockResolvedValue(undefined),
-      generateModuleFacts: jest.fn().mockResolvedValue(undefined),
     }))
     jest.doMock('../lib/resolver', () => ({
       createResolver: () => ({
@@ -408,7 +407,6 @@ describe('init command failure output', () => {
       generateModuleDi: jest.fn().mockResolvedValue(undefined),
       generateModulePackageSources: jest.fn().mockResolvedValue(undefined),
       generateOpenApi: jest.fn().mockResolvedValue(undefined),
-      generateModuleFacts: jest.fn().mockResolvedValue(undefined),
     }))
     jest.doMock('../lib/resolver', () => ({
       createResolver: () => ({
@@ -460,7 +458,6 @@ describe('init command failure output', () => {
       generateModuleDi: jest.fn().mockResolvedValue(undefined),
       generateModulePackageSources: jest.fn().mockResolvedValue(undefined),
       generateOpenApi: jest.fn().mockResolvedValue(undefined),
-      generateModuleFacts: jest.fn().mockResolvedValue(undefined),
     }))
     jest.doMock('../lib/db', () => ({
       dbMigrate: jest.fn().mockResolvedValue(undefined),
@@ -569,7 +566,6 @@ describe('generate post-step structural cache purge', () => {
       generateModuleDi,
       generateModulePackageSources,
       generateOpenApi,
-      generateModuleFacts: jest.fn().mockResolvedValue(undefined),
     }))
     jest.doMock('../lib/resolver', () => ({
       createResolver: () => ({
@@ -619,7 +615,6 @@ describe('generate post-step structural cache purge', () => {
       generateModuleDi,
       generateModulePackageSources,
       generateOpenApi,
-      generateModuleFacts: jest.fn().mockResolvedValue(undefined),
     }))
     jest.doMock('../lib/resolver', () => ({
       createResolver: () => ({

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

@@ -1,51 +1,64 @@
 import fs from 'node:fs'
 import path from 'node:path'
-import { extractAllModuleFacts, MODULE_FACTS_ALLOWLIST } from '../module-facts'
+import { extractAllModuleFacts } from '../module-facts'
+import { discoverPackageModuleSources } from '../module-facts-discovery'
+import { createResolver } from '../../resolver'
 
-function findCoreSrcRoot(): string {
+function findRepoRoot(): 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
+    if (fs.existsSync(path.join(dir, 'packages', 'core', 'src', 'modules'))) return dir
     dir = path.dirname(dir)
   }
-  throw new Error('[internal] could not locate packages/core/src/modules from the test directory')
+  throw new Error('[internal] could not locate repo root from the test directory')
 }
 
 function isUnique(values: string[]): boolean {
   return values.length === new Set(values).size
 }
 
-describe('module-facts BC resolve guard (T3)', () => {
-  const coreSrcRoot = findCoreSrcRoot()
-  const { factsByModule } = extractAllModuleFacts({ coreSrcRoot })
+describe('module-facts BC resolve guard (T2)', () => {
+  const repoRoot = findRepoRoot()
+  const sources = discoverPackageModuleSources(createResolver(repoRoot))
+  const { factsByModule } = extractAllModuleFacts({ sources })
 
-  it('emits facts for every allowlisted module', () => {
-    expect(Object.keys(factsByModule).sort()).toEqual([...MODULE_FACTS_ALLOWLIST].sort())
+  it('discovers a superset of the historical core modules', () => {
+    const discovered = new Set(Object.keys(factsByModule))
+    for (const moduleId of ['auth', 'catalog', 'customers', 'sales', 'workflows']) {
+      expect(discovered.has(moduleId)).toBe(true)
+    }
+    expect(discovered.size).toBeGreaterThan(9)
   })
 
-  for (const moduleId of MODULE_FACTS_ALLOWLIST) {
+  for (const source of sources) {
+    const moduleId = source.moduleId
     describe(`${moduleId}`, () => {
-      it('namespaces entity / event / acl / notification ids under the module and keeps them unique', () => {
-        const facts = factsByModule[moduleId]
-        const entityIds = facts.entities.map((entity) => entity.id)
+      const facts = factsByModule[moduleId]
 
+      // 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', () => {
+        const entityIds = facts.entities.map((entity) => entity.id)
         expect(entityIds.every((id) => id.startsWith(`${moduleId}:`))).toBe(true)
         expect(isUnique(entityIds)).toBe(true)
-        expect(facts.events.every((event) => event.id.startsWith(`${moduleId}.`))).toBe(true)
+        expect(facts.searchEntities.every((id) => id.startsWith(`${moduleId}:`))).toBe(true)
+        expect(isUnique(facts.searchEntities)).toBe(true)
+        expect(facts.hostTokens.entityIds.every((id) => id.startsWith(`${moduleId}:`))).toBe(true)
+      })
+
+      // Event / ACL / notification ids must be unique, but are NOT asserted to be
+      // dot-prefixed by the module id: some modules intentionally use a different
+      // namespace (e.g. ai_assistant -> `ai.*`, dashboards -> `analytics.*`,
+      // storage_s3 -> `storage_providers.*`). The meaningful invariant is uniqueness,
+      // not folder-name prefixing (spec 2026-07-06 R1).
+      it('keeps event / acl / notification ids unique', () => {
         expect(isUnique(facts.events.map((event) => event.id))).toBe(true)
-        expect(facts.aclFeatures.every((feature) => feature.startsWith(`${moduleId}.`))).toBe(true)
         expect(isUnique(facts.aclFeatures)).toBe(true)
-        expect(facts.notifications.every((notification) => notification.startsWith(`${moduleId}.`))).toBe(true)
+        expect(isUnique(facts.notifications)).toBe(true)
       })
 
-      it('resolves search and host-token references against the module entity set', () => {
-        const facts = factsByModule[moduleId]
+      it('resolves host-token entity ids against the module entity set', () => {
         const entityIds = new Set(facts.entities.map((entity) => entity.id))
-
-        for (const searchEntity of facts.searchEntities) {
-          expect(entityIds.has(searchEntity)).toBe(true)
-        }
         for (const hostEntityId of facts.hostTokens.entityIds) {
           expect(entityIds.has(hostEntityId)).toBe(true)
           expect(hostEntityId.endsWith('_entity')).toBe(true)

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

@@ -0,0 +1,88 @@
+import fs from 'node:fs'
+import os from 'node:os'
+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 }
+
+function makeResolver(packages: FakePackage[]): PackageResolver {
+  return {
+    discoverPackages: () => packages,
+  } as unknown as PackageResolver
+}
+
+function writeModule(modulesDir: string, moduleId: string, file: string): void {
+  const moduleRoot = path.join(modulesDir, moduleId)
+  fs.mkdirSync(moduleRoot, { recursive: true })
+  fs.writeFileSync(path.join(moduleRoot, file), '// fixture\n')
+}
+
+describe('module-facts discovery (T1)', () => {
+  let tmp: string
+
+  beforeAll(() => {
+    tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'module-facts-discovery-'))
+  })
+
+  afterAll(() => {
+    fs.rmSync(tmp, { recursive: true, force: true })
+  })
+
+  it('hasReadableModuleSource is true for a .ts module and false for a .js-only module', () => {
+    const srcModules = path.join(tmp, 'readable', 'src', 'modules')
+    writeModule(srcModules, 'alpha', 'index.ts')
+    const distModules = path.join(tmp, 'readable', 'dist', 'modules')
+    writeModule(distModules, 'compiled', 'index.js')
+
+    expect(hasReadableModuleSource(path.join(srcModules, 'alpha'))).toBe(true)
+    expect(hasReadableModuleSource(path.join(distModules, 'compiled'))).toBe(false)
+    expect(hasReadableModuleSource(path.join(srcModules, 'missing'))).toBe(false)
+  })
+
+  it('returns package-provided .ts modules and skips .js-only installs (A1 + A3)', () => {
+    const pkgSrc = path.join(tmp, 'pkg-a')
+    writeModule(path.join(pkgSrc, 'src', 'modules'), 'alpha', 'index.ts')
+    writeModule(path.join(pkgSrc, 'src', 'modules'), 'beta', 'acl.ts')
+
+    const pkgDist = path.join(tmp, 'pkg-compiled')
+    writeModule(path.join(pkgDist, 'dist', 'modules'), 'compiled', 'index.js')
+
+    const resolver = makeResolver([
+      { name: '@open-mercato/core', path: pkgSrc, modulesPath: path.join(pkgSrc, 'src', 'modules') },
+      { name: '@open-mercato/compiled', path: pkgDist, modulesPath: path.join(pkgDist, 'dist', 'modules') },
+    ])
+
+    const ids = discoverPackageModuleSources(resolver).map((source) => source.moduleId)
+    expect(ids.sort()).toEqual(['alpha', 'beta'])
+  })
+
+  it('tags each source with its providing package name', () => {
+    const pkgSrc = path.join(tmp, 'pkg-tagged')
+    writeModule(path.join(pkgSrc, 'src', 'modules'), 'gamma', 'events.ts')
+
+    const resolver = makeResolver([
+      { 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' })
+    expect(source.moduleRoot).toBe(path.join(pkgSrc, 'src', 'modules', 'gamma'))
+  })
+
+  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 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') },
+    ])
+
+    const sources = discoverPackageModuleSources(resolver)
+    expect(sources).toHaveLength(1)
+    expect(sources[0].moduleRoot).toBe(path.join(pkgA, 'src', 'modules', 'shared'))
+  })
+})

package/src/lib/generators/index.ts

@@ -4,4 +4,3 @@ export { generateModuleEntities, type ModuleEntitiesOptions } from './module-ent
 export { generateModuleDi, type ModuleDiOptions } from './module-di'
 export { generateModulePackageSources, type ModulePackageSourcesOptions } from './module-package-sources'
 export { generateOpenApi, type GenerateOpenApiOptions } from './openapi'
-export { generateModuleFacts, type ModuleFactsOptions } from './module-facts-generate'

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

@@ -0,0 +1,58 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import type { PackageResolver } from '../resolver'
+import { discoverModulesInPackage } from '../module-package'
+import type { ModuleFactSource } from './module-facts'
+
+const READABLE_CONVENTION_FILES = [
+  'index',
+  'acl',
+  'events',
+  'di',
+  path.join('data', 'entities'),
+  path.join('db', 'entities'),
+]
+
+/**
+ * True when the module directory exposes at least one recognised convention file as
+ * TypeScript source. This is the auto-discovery boundary that skips `.js`-only
+ * installs (standalone `node_modules/@open-mercato/<pkg>/dist/modules`) — the extractor's
+ * ts-morph reader only parses `.ts`/`.tsx`, so a `.js`-only root would yield empty facts.
+ */
+export function hasReadableModuleSource(moduleRoot: string): boolean {
+  if (!fs.existsSync(moduleRoot)) return false
+  for (const basename of READABLE_CONVENTION_FILES) {
+    for (const extension of ['.ts', '.tsx']) {
+      if (fs.existsSync(path.join(moduleRoot, `${basename}${extension}`))) return true
+    }
+  }
+  return false
+}
+
+function dedupeById(sources: ModuleFactSource[]): ModuleFactSource[] {
+  const seen = new Set<string>()
+  const result: ModuleFactSource[] = []
+  for (const source of sources) {
+    if (seen.has(source.moduleId)) continue
+    seen.add(source.moduleId)
+    result.push(source)
+  }
+  return result
+}
+
+/**
+ * Package-scan discovery for the create-app build: every package-provided module
+ * across `@open-mercato/*` workspace packages (core plus others), never `apps/*`
+ * demo modules. Routes through the resolver rather than hardcoded paths.
+ */
+export function discoverPackageModuleSources(resolver: PackageResolver): ModuleFactSource[] {
+  const sources: ModuleFactSource[] = []
+  for (const pkg of resolver.discoverPackages()) {
+    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 })
+    }
+  }
+  return dedupeById(sources)
+}

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

@@ -54,12 +54,32 @@ export interface ModuleFacts {
 
 export interface ExtractModuleFactsOptions {
   moduleId: string
-  coreSrcRoot: string
+  /**
+   * Parent modules directory joined with `moduleId` to locate the module source.
+   * Legacy input; prefer the explicit per-module `moduleRoot` for modules that do
+   * not live under a single shared root (auto-discovery). One of `moduleRoot` /
+   * `coreSrcRoot` must be provided.
+   */
+  coreSrcRoot?: string
+  /** Explicit module source directory. When set it overrides `coreSrcRoot + moduleId`. */
+  moduleRoot?: string
   coreVersion?: string | null
   registryPath?: string | null
   registrySource?: string | null
 }
 
+/** A discovered module and the source directory its facts are extracted from. */
+export interface ModuleFactSource {
+  moduleId: string
+  moduleRoot: string
+  from?: string
+}
+
+/**
+ * @deprecated Superseded by auto-discovery (`discoverPackageModuleSources` in
+ * `module-facts-discovery.ts`). Retained as a stable export for one minor; no
+ * longer gates which modules receive fact-sheets.
+ */
 export const MODULE_FACTS_ALLOWLIST = [
   'auth',
   'catalog',
@@ -72,6 +92,7 @@ export const MODULE_FACTS_ALLOWLIST = [
   'workflows',
 ] as const
 
+/** @deprecated See {@link MODULE_FACTS_ALLOWLIST}. */
 export type ModuleFactsModuleId = (typeof MODULE_FACTS_ALLOWLIST)[number]
 
 function readSourceFile(filePath: string): ts.SourceFile | null {
@@ -723,8 +744,12 @@ function extractModuleMeta(indexFilePath: string | null): { title: string | null
 }
 
 export function extractModuleFacts(options: ExtractModuleFactsOptions): ModuleFacts {
-  const { moduleId, coreSrcRoot, coreVersion = null } = options
-  const moduleRoot = path.join(coreSrcRoot, moduleId)
+  const { moduleId, coreVersion = null } = options
+  const moduleRoot = options.moduleRoot
+    ?? (options.coreSrcRoot ? path.join(options.coreSrcRoot, moduleId) : null)
+  if (!moduleRoot) {
+    throw new Error(`[internal] extractModuleFacts requires moduleRoot or coreSrcRoot for module "${moduleId}"`)
+  }
 
   const entitiesFilePath =
     resolveConventionFile(path.join(moduleRoot, 'data'), 'entities') ??
@@ -924,10 +949,17 @@ export function renderModuleFactsJson(factsByModule: Record<string, ModuleFacts>
 }
 
 export interface ExtractAllModuleFactsOptions {
-  coreSrcRoot: string
+  /**
+   * Discovered module sources (auto-discovery path). When provided, each entry's
+   * explicit `moduleRoot` is used and `coreSrcRoot`/`moduleIds` are ignored.
+   */
+  sources?: readonly ModuleFactSource[]
+  /** Legacy shared-root path. Used only when `sources` is not provided. */
+  coreSrcRoot?: string
   registryPath?: string | null
   registrySource?: string | null
   coreVersion?: string | null
+  /** @deprecated Legacy allowlist iteration; only consulted when `sources` is absent. */
   moduleIds?: readonly string[]
 }
 
@@ -938,20 +970,28 @@ export interface ExtractAllModuleFactsResult {
 }
 
 export function extractAllModuleFacts(options: ExtractAllModuleFactsOptions): ExtractAllModuleFactsResult {
-  const moduleIds = options.moduleIds ?? MODULE_FACTS_ALLOWLIST
+  const sources: ModuleFactSource[] = options.sources
+    ? [...options.sources]
+    : (options.coreSrcRoot
+        ? (options.moduleIds ?? MODULE_FACTS_ALLOWLIST).map((moduleId) => ({
+            moduleId,
+            moduleRoot: path.join(options.coreSrcRoot as string, moduleId),
+          }))
+        : [])
+
   const factsByModule: Record<string, ModuleFacts> = {}
   const markdownByModule: Record<string, string> = {}
   const warnings: string[] = []
-  for (const moduleId of moduleIds) {
+  for (const source of sources) {
     const facts = extractModuleFacts({
-      moduleId,
-      coreSrcRoot: options.coreSrcRoot,
+      moduleId: source.moduleId,
+      moduleRoot: source.moduleRoot,
       coreVersion: options.coreVersion ?? null,
       registryPath: options.registryPath ?? null,
       registrySource: options.registrySource ?? null,
     })
-    factsByModule[moduleId] = facts
-    markdownByModule[moduleId] = renderModuleFactsMarkdown(facts)
+    factsByModule[source.moduleId] = facts
+    markdownByModule[source.moduleId] = renderModuleFactsMarkdown(facts)
     warnings.push(...facts.warnings)
   }
   return { factsByModule, markdownByModule, warnings }

package/src/mercato.ts

@@ -756,7 +756,6 @@ async function runGeneratorSuite(quiet: boolean): Promise<void> {
     generateModuleDi,
     generateModulePackageSources,
     generateOpenApi,
-    generateModuleFacts,
   } = await import('./lib/generators')
   const resolver = createResolver()
   await generateEntityIds({ resolver, quiet })
@@ -767,7 +766,6 @@ async function runGeneratorSuite(quiet: boolean): Promise<void> {
   await generateModuleDi({ resolver, quiet })
   await generateModulePackageSources({ resolver, quiet })
   await generateOpenApi({ resolver, quiet })
-  await generateModuleFacts({ resolver, quiet })
 }
 
 /**

package/dist/lib/generators/module-facts-generate.js

@@ -1,52 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import {
-  createGeneratorResult,
-  ensureDir,
-  logGenerationResult
-} from "../utils.js";
-import { extractAllModuleFacts, renderModuleFactsJson } from "./module-facts.js";
-function readCoreVersion(coreSrcRoot) {
-  const corePackageJsonPath = path.resolve(coreSrcRoot, "..", "..", "package.json");
-  if (!fs.existsSync(corePackageJsonPath)) return null;
-  try {
-    const parsed = JSON.parse(fs.readFileSync(corePackageJsonPath, "utf8"));
-    return typeof parsed.version === "string" ? parsed.version : null;
-  } catch {
-    return null;
-  }
-}
-async function generateModuleFacts(options) {
-  const { resolver, quiet } = options;
-  const result = createGeneratorResult();
-  const rootDir = resolver.getRootDir();
-  const coreSrcRoot = path.join(rootDir, "packages", "core", "src", "modules");
-  if (!fs.existsSync(coreSrcRoot)) {
-    if (!quiet) {
-      console.warn(`[module-facts] core module sources not found at ${coreSrcRoot}; skipping module-facts generation`);
-    }
-    return result;
-  }
-  const registryPath = path.join(resolver.getOutputDir(), "modules.runtime.generated.ts");
-  const coreVersion = readCoreVersion(coreSrcRoot);
-  const { factsByModule, warnings } = extractAllModuleFacts({ coreSrcRoot, registryPath, coreVersion });
-  for (const warning of warnings) {
-    console.warn(warning);
-  }
-  const content = renderModuleFactsJson(factsByModule);
-  const outFile = path.join(resolver.getAppDir(), "src", "module-facts.generated.json");
-  const existing = fs.existsSync(outFile) ? fs.readFileSync(outFile, "utf8") : null;
-  if (existing === content) {
-    result.filesUnchanged.push(outFile);
-    return result;
-  }
-  ensureDir(outFile);
-  fs.writeFileSync(outFile, content);
-  result.filesWritten.push(outFile);
-  logGenerationResult(path.relative(process.cwd(), outFile), true);
-  return result;
-}
-export {
-  generateModuleFacts
-};
-//# sourceMappingURL=module-facts-generate.js.map

package/dist/lib/generators/module-facts-generate.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/lib/generators/module-facts-generate.ts"],
-  "sourcesContent": ["import fs from 'node:fs'\nimport path from 'node:path'\nimport type { PackageResolver } from '../resolver'\nimport {\n  createGeneratorResult,\n  ensureDir,\n  logGenerationResult,\n  type GeneratorResult,\n} from '../utils'\nimport { extractAllModuleFacts, renderModuleFactsJson } from './module-facts'\n\nexport interface ModuleFactsOptions {\n  resolver: PackageResolver\n  quiet?: boolean\n}\n\nfunction readCoreVersion(coreSrcRoot: string): string | null {\n  const corePackageJsonPath = path.resolve(coreSrcRoot, '..', '..', 'package.json')\n  if (!fs.existsSync(corePackageJsonPath)) return null\n  try {\n    const parsed = JSON.parse(fs.readFileSync(corePackageJsonPath, 'utf8')) as { version?: unknown }\n    return typeof parsed.version === 'string' ? parsed.version : null\n  } catch {\n    return null\n  }\n}\n\n/**\n * Emits the versioned `apps/mercato/src/module-facts.generated.json` artifact from\n * monorepo core module sources. Must run AFTER `generateModuleRegistry` because\n * per-route API auth is read from the generated `modules.runtime.generated.ts`\n * registry (`apis[].metadata`). Registry-derived warnings are non-fatal.\n */\nexport async function generateModuleFacts(options: ModuleFactsOptions): Promise<GeneratorResult> {\n  const { resolver, quiet } = options\n  const result = createGeneratorResult()\n\n  const rootDir = resolver.getRootDir()\n  const coreSrcRoot = path.join(rootDir, 'packages', 'core', 'src', 'modules')\n  if (!fs.existsSync(coreSrcRoot)) {\n    if (!quiet) {\n      console.warn(`[module-facts] core module sources not found at ${coreSrcRoot}; skipping module-facts generation`)\n    }\n    return result\n  }\n\n  const registryPath = path.join(resolver.getOutputDir(), 'modules.runtime.generated.ts')\n  const coreVersion = readCoreVersion(coreSrcRoot)\n\n  const { factsByModule, warnings } = extractAllModuleFacts({ coreSrcRoot, registryPath, coreVersion })\n  for (const warning of warnings) {\n    console.warn(warning)\n  }\n\n  const content = renderModuleFactsJson(factsByModule)\n  const outFile = path.join(resolver.getAppDir(), 'src', 'module-facts.generated.json')\n  const existing = fs.existsSync(outFile) ? fs.readFileSync(outFile, 'utf8') : null\n  if (existing === content) {\n    result.filesUnchanged.push(outFile)\n    return result\n  }\n\n  ensureDir(outFile)\n  fs.writeFileSync(outFile, content)\n  result.filesWritten.push(outFile)\n  logGenerationResult(path.relative(process.cwd(), outFile), true)\n  return result\n}\n"],
-  "mappings": "AAAA,OAAO,QAAQ;AACf,OAAO,UAAU;AAEjB;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OAEK;AACP,SAAS,uBAAuB,6BAA6B;AAO7D,SAAS,gBAAgB,aAAoC;AAC3D,QAAM,sBAAsB,KAAK,QAAQ,aAAa,MAAM,MAAM,cAAc;AAChF,MAAI,CAAC,GAAG,WAAW,mBAAmB,EAAG,QAAO;AAChD,MAAI;AACF,UAAM,SAAS,KAAK,MAAM,GAAG,aAAa,qBAAqB,MAAM,CAAC;AACtE,WAAO,OAAO,OAAO,YAAY,WAAW,OAAO,UAAU;AAAA,EAC/D,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAQA,eAAsB,oBAAoB,SAAuD;AAC/F,QAAM,EAAE,UAAU,MAAM,IAAI;AAC5B,QAAM,SAAS,sBAAsB;AAErC,QAAM,UAAU,SAAS,WAAW;AACpC,QAAM,cAAc,KAAK,KAAK,SAAS,YAAY,QAAQ,OAAO,SAAS;AAC3E,MAAI,CAAC,GAAG,WAAW,WAAW,GAAG;AAC/B,QAAI,CAAC,OAAO;AACV,cAAQ,KAAK,mDAAmD,WAAW,oCAAoC;AAAA,IACjH;AACA,WAAO;AAAA,EACT;AAEA,QAAM,eAAe,KAAK,KAAK,SAAS,aAAa,GAAG,8BAA8B;AACtF,QAAM,cAAc,gBAAgB,WAAW;AAE/C,QAAM,EAAE,eAAe,SAAS,IAAI,sBAAsB,EAAE,aAAa,cAAc,YAAY,CAAC;AACpG,aAAW,WAAW,UAAU;AAC9B,YAAQ,KAAK,OAAO;AAAA,EACtB;AAEA,QAAM,UAAU,sBAAsB,aAAa;AACnD,QAAM,UAAU,KAAK,KAAK,SAAS,UAAU,GAAG,OAAO,6BAA6B;AACpF,QAAM,WAAW,GAAG,WAAW,OAAO,IAAI,GAAG,aAAa,SAAS,MAAM,IAAI;AAC7E,MAAI,aAAa,SAAS;AACxB,WAAO,eAAe,KAAK,OAAO;AAClC,WAAO;AAAA,EACT;AAEA,YAAU,OAAO;AACjB,KAAG,cAAc,SAAS,OAAO;AACjC,SAAO,aAAa,KAAK,OAAO;AAChC,sBAAoB,KAAK,SAAS,QAAQ,IAAI,GAAG,OAAO,GAAG,IAAI;AAC/D,SAAO;AACT;",
-  "names": []
-}

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

@@ -1,68 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-import type { PackageResolver } from '../resolver'
-import {
-  createGeneratorResult,
-  ensureDir,
-  logGenerationResult,
-  type GeneratorResult,
-} from '../utils'
-import { extractAllModuleFacts, renderModuleFactsJson } from './module-facts'
-
-export interface ModuleFactsOptions {
-  resolver: PackageResolver
-  quiet?: boolean
-}
-
-function readCoreVersion(coreSrcRoot: string): string | null {
-  const corePackageJsonPath = path.resolve(coreSrcRoot, '..', '..', 'package.json')
-  if (!fs.existsSync(corePackageJsonPath)) return null
-  try {
-    const parsed = JSON.parse(fs.readFileSync(corePackageJsonPath, 'utf8')) as { version?: unknown }
-    return typeof parsed.version === 'string' ? parsed.version : null
-  } catch {
-    return null
-  }
-}
-
-/**
- * Emits the versioned `apps/mercato/src/module-facts.generated.json` artifact from
- * monorepo core module sources. Must run AFTER `generateModuleRegistry` because
- * per-route API auth is read from the generated `modules.runtime.generated.ts`
- * registry (`apis[].metadata`). Registry-derived warnings are non-fatal.
- */
-export async function generateModuleFacts(options: ModuleFactsOptions): Promise<GeneratorResult> {
-  const { resolver, quiet } = options
-  const result = createGeneratorResult()
-
-  const rootDir = resolver.getRootDir()
-  const coreSrcRoot = path.join(rootDir, 'packages', 'core', 'src', 'modules')
-  if (!fs.existsSync(coreSrcRoot)) {
-    if (!quiet) {
-      console.warn(`[module-facts] core module sources not found at ${coreSrcRoot}; skipping module-facts generation`)
-    }
-    return result
-  }
-
-  const registryPath = path.join(resolver.getOutputDir(), 'modules.runtime.generated.ts')
-  const coreVersion = readCoreVersion(coreSrcRoot)
-
-  const { factsByModule, warnings } = extractAllModuleFacts({ coreSrcRoot, registryPath, coreVersion })
-  for (const warning of warnings) {
-    console.warn(warning)
-  }
-
-  const content = renderModuleFactsJson(factsByModule)
-  const outFile = path.join(resolver.getAppDir(), 'src', 'module-facts.generated.json')
-  const existing = fs.existsSync(outFile) ? fs.readFileSync(outFile, 'utf8') : null
-  if (existing === content) {
-    result.filesUnchanged.push(outFile)
-    return result
-  }
-
-  ensureDir(outFile)
-  fs.writeFileSync(outFile, content)
-  result.filesWritten.push(outFile)
-  logGenerationResult(path.relative(process.cwd(), outFile), true)
-  return result
-}