@open-mercato/cli 0.6.7-develop.6553.1.2ec7246e04 → 0.6.7-develop.6566.1.15385fa179

package/src/lib/generate-watch-events.ts

@@ -0,0 +1,125 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import type { GenerateWatcherChangeSignal } from './in-process-generate-watcher'
+
+export type GenerateWatchTarget = {
+  directory: string
+  recursive: boolean
+  fileName?: string
+}
+
+type WatchHandle = {
+  close(): void
+}
+
+type WatchDirectory = (
+  target: GenerateWatchTarget,
+  onChange: (fileName?: string) => void,
+  onError: () => void,
+) => WatchHandle
+
+export type GenerateWatchChangeSignalOptions = {
+  getWatchTargets: () => Promise<GenerateWatchTarget[]> | GenerateWatchTarget[]
+  watchDirectory?: WatchDirectory
+}
+
+function targetKey(target: GenerateWatchTarget): string {
+  return JSON.stringify([
+    path.resolve(target.directory),
+    target.recursive,
+    target.fileName ?? '',
+  ])
+}
+
+const defaultWatchDirectory: WatchDirectory = (target, onChange, onError) => {
+  const watcher = fs.watch(
+    target.directory,
+    { recursive: target.recursive },
+    (_eventType, fileName) => {
+      const normalizedName = String(fileName ?? '')
+      if (target.fileName && normalizedName && normalizedName !== target.fileName) return
+      onChange(normalizedName || undefined)
+    },
+  )
+  watcher.on('error', onError)
+  return watcher
+}
+
+export function createGenerateWatchChangeSignal(
+  options: GenerateWatchChangeSignalOptions,
+): GenerateWatcherChangeSignal {
+  const watchDirectory = options.watchDirectory ?? defaultWatchDirectory
+  const watchers = new Map<string, WatchHandle>()
+  let version = 0
+  let pollingFallback = false
+  let closed = false
+
+  const closeWatchers = () => {
+    for (const watcher of watchers.values()) {
+      try { watcher.close() } catch {}
+    }
+    watchers.clear()
+  }
+
+  const enterPollingFallback = () => {
+    if (pollingFallback) return
+    pollingFallback = true
+    version += 1
+    closeWatchers()
+  }
+
+  return {
+    currentVersion: () => version,
+    usesPollingFallback: () => pollingFallback,
+    refresh: async () => {
+      if (closed || pollingFallback) return
+
+      let targets: GenerateWatchTarget[]
+      try {
+        targets = await options.getWatchTargets()
+      } catch {
+        enterPollingFallback()
+        return
+      }
+
+      const normalizedTargets = new Map<string, GenerateWatchTarget>()
+      for (const target of targets) {
+        const normalized: GenerateWatchTarget = {
+          ...target,
+          directory: path.resolve(target.directory),
+        }
+        normalizedTargets.set(targetKey(normalized), normalized)
+      }
+
+      for (const [key, watcher] of watchers) {
+        if (normalizedTargets.has(key)) continue
+        try { watcher.close() } catch {}
+        watchers.delete(key)
+      }
+
+      for (const [key, target] of normalizedTargets) {
+        if (watchers.has(key)) continue
+        try {
+          const watcher = watchDirectory(
+            target,
+            () => { version += 1 },
+            enterPollingFallback,
+          )
+          if (closed || pollingFallback) {
+            try { watcher.close() } catch {}
+            continue
+          }
+          watchers.set(key, watcher)
+        } catch {
+          enterPollingFallback()
+          return
+        }
+      }
+    },
+    close: () => {
+      if (closed) return
+      closed = true
+      closeWatchers()
+    },
+  }
+}

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

@@ -30,7 +30,10 @@ function createMockResolver(tmpRoot: string, enabled: ModuleEntry[]): PackageRes
       appBase: `@/modules/${entry.id}`,
       pkgBase: `@open-mercato/core/modules/${entry.id}`,
     }),
-    getPackageOutputDir: () => outputDir,
+    getPackageOutputDir: (packageName: string) =>
+      packageName === '@app'
+        ? outputDir
+        : path.join(tmpRoot, 'packages', 'core', 'generated'),
     getPackageRoot: () => path.join(tmpRoot, 'packages', 'core'),
   }
 }
@@ -75,6 +78,100 @@ afterEach(() => {
 })
 
 describe('generateEntityIds', () => {
+  it('does not rewrite generated entity outputs when inputs are unchanged', async () => {
+    const moduleEntry: ModuleEntry = { id: 'orders', from: '@open-mercato/core' }
+    const entitiesFile = path.join(tmpDir, 'packages', 'core', 'src', 'modules', 'orders', 'data', 'entities.ts')
+    fs.mkdirSync(path.dirname(entitiesFile), { recursive: true })
+    fs.writeFileSync(entitiesFile, 'export class SalesOrder { id!: string\n totalGross!: number\n}\n')
+    const resolver = createMockResolver(tmpDir, [moduleEntry])
+
+    const first = await generateEntityIds({ resolver, quiet: true })
+    expect(first.filesWritten.length).toBeGreaterThan(0)
+
+    const appOutput = resolver.getOutputDir()
+    const packageOutput = resolver.getPackageOutputDir('@open-mercato/core')
+    const generatedFiles = [
+      path.join(appOutput, 'entities.ids.generated.ts'),
+      path.join(appOutput, 'entity-fields-registry.ts'),
+      path.join(appOutput, 'entities', 'sales_order', 'index.ts'),
+      path.join(packageOutput, 'entities.ids.generated.ts'),
+      path.join(packageOutput, 'entity-fields-registry.ts'),
+      path.join(packageOutput, 'entities', 'sales_order', 'index.ts'),
+    ]
+    const pinnedTime = new Date('2026-01-01T00:00:00.000Z')
+    for (const filePath of generatedFiles) {
+      fs.utimesSync(filePath, pinnedTime, pinnedTime)
+    }
+
+    const second = await generateEntityIds({ resolver, quiet: true })
+
+    expect(second.filesWritten).toEqual([])
+    for (const filePath of generatedFiles) {
+      expect(fs.statSync(filePath).mtimeMs).toBe(pinnedTime.getTime())
+    }
+  })
+
+  it('reports field-only generated changes without rewriting the entity id map', async () => {
+    const moduleEntry: ModuleEntry = { id: 'orders', from: '@open-mercato/core' }
+    const entitiesFile = path.join(tmpDir, 'packages', 'core', 'src', 'modules', 'orders', 'data', 'entities.ts')
+    fs.mkdirSync(path.dirname(entitiesFile), { recursive: true })
+    fs.writeFileSync(entitiesFile, 'export class SalesOrder { id!: string\n}\n')
+    const resolver = createMockResolver(tmpDir, [moduleEntry])
+    await generateEntityIds({ resolver, quiet: true })
+    const rootIds = path.join(resolver.getOutputDir(), 'entities.ids.generated.ts')
+    const pinnedTime = new Date('2026-01-01T00:00:00.000Z')
+    fs.utimesSync(rootIds, pinnedTime, pinnedTime)
+
+    fs.writeFileSync(entitiesFile, 'export class SalesOrder { id!: string\n status!: string\n}\n')
+    const result = await generateEntityIds({ resolver, quiet: true })
+
+    expect(result.filesWritten).not.toContain(rootIds)
+    expect(fs.statSync(rootIds).mtimeMs).toBe(pinnedTime.getTime())
+    expect(result.filesWritten).toContain(
+      path.join(resolver.getOutputDir(), 'entities', 'sales_order', 'index.ts'),
+    )
+    expect(result.filesWritten).toContain(
+      path.join(resolver.getOutputDir(), 'entity-fields-registry.ts'),
+    )
+  })
+
+  it('keeps deletion changes visible while removing stale entity field output', async () => {
+    const moduleEntry: ModuleEntry = { id: 'orders', from: '@open-mercato/core' }
+    const entitiesFile = path.join(tmpDir, 'packages', 'core', 'src', 'modules', 'orders', 'data', 'entities.ts')
+    fs.mkdirSync(path.dirname(entitiesFile), { recursive: true })
+    fs.writeFileSync(entitiesFile, 'export class SalesOrder { id!: string }\nexport class SalesLine { id!: string }\n')
+    const resolver = createMockResolver(tmpDir, [moduleEntry])
+    await generateEntityIds({ resolver, quiet: true })
+    const staleDirectory = path.join(resolver.getOutputDir(), 'entities', 'sales_line')
+    expect(fs.existsSync(staleDirectory)).toBe(true)
+
+    fs.writeFileSync(entitiesFile, 'export class SalesOrder { id!: string }\n')
+    const result = await generateEntityIds({ resolver, quiet: true })
+
+    expect(fs.existsSync(staleDirectory)).toBe(false)
+    expect(result.filesWritten).toContain(
+      path.join(resolver.getOutputDir(), 'entities.ids.generated.ts'),
+    )
+  })
+
+  it('reports stale entity directory cleanup when every generated file is unchanged', async () => {
+    const moduleEntry: ModuleEntry = { id: 'orders', from: '@open-mercato/core' }
+    const entitiesFile = path.join(tmpDir, 'packages', 'core', 'src', 'modules', 'orders', 'data', 'entities.ts')
+    fs.mkdirSync(path.dirname(entitiesFile), { recursive: true })
+    fs.writeFileSync(entitiesFile, 'export class SalesOrder { id!: string }\n')
+    const resolver = createMockResolver(tmpDir, [moduleEntry])
+    await generateEntityIds({ resolver, quiet: true })
+
+    const staleDirectory = path.join(resolver.getOutputDir(), 'entities', 'sales_line')
+    fs.mkdirSync(staleDirectory, { recursive: true })
+    fs.writeFileSync(path.join(staleDirectory, 'index.ts'), 'export const id = "id"\n')
+
+    const result = await generateEntityIds({ resolver, quiet: true })
+
+    expect(fs.existsSync(staleDirectory)).toBe(false)
+    expect(result.filesWritten).toEqual([staleDirectory])
+  })
+
   it('writes an inline entity fields registry without generated entity imports', async () => {
     const moduleEntry: ModuleEntry = { id: 'orders', from: '@open-mercato/core' }
     const entitiesFile = path.join(tmpDir, 'packages', 'core', 'src', 'modules', 'orders', 'data', 'entities.ts')

package/src/lib/generators/__tests__/openapi.test.ts

@@ -42,6 +42,27 @@ describe('resolveOpenApiGeneratorProjectRoot', () => {
 describe('generateOpenApi', () => {
   let tmpDir: string
 
+  const sharedGeneratorSource = `
+export function buildOpenApiDocument(modules: any[], options: any) {
+  const paths: Record<string, any> = {}
+  for (const module of modules) {
+    for (const api of module.apis ?? []) {
+      const methods: Record<string, any> = {}
+      for (const [method, spec] of Object.entries(api.handlers.openApi ?? {})) {
+        methods[method.toLowerCase()] = spec
+      }
+      paths[api.path.replace(/\\[([^\\]]+)\\]/g, '{$1}')] = methods
+    }
+  }
+  return {
+    openapi: '3.1.0',
+    info: { title: options.title, version: options.version, description: options.description },
+    servers: options.servers,
+    paths,
+  }
+}
+`
+
   function touchFile(filePath: string, content: string): void {
     fs.mkdirSync(path.dirname(filePath), { recursive: true })
     fs.writeFileSync(filePath, content)
@@ -79,6 +100,14 @@ describe('generateOpenApi', () => {
 
   beforeEach(() => {
     tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'openapi-generator-test-'))
+    touchFile(
+      path.join(tmpDir, 'packages', 'shared', 'src', 'lib', 'openapi', 'generator.ts'),
+      sharedGeneratorSource,
+    )
+    touchFile(path.join(tmpDir, 'package.json'), '{"private":true}\n')
+    touchFile(path.join(tmpDir, 'yarn.lock'), '# test lockfile\n')
+    touchFile(path.join(tmpDir, 'app', 'package.json'), '{"private":true}\n')
+    touchFile(path.join(tmpDir, 'app', 'tsconfig.json'), '{"compilerOptions":{}}\n')
   })
 
   afterEach(() => {
@@ -130,4 +159,149 @@ describe('generateOpenApi', () => {
     expect(openApiDoc.paths['/api/demo/health']?.get?.summary).toBe('app health')
     expect(openApiDoc.paths['/api/demo/details']?.get?.summary).toBe('package details')
   })
+
+  it('skips route discovery and bundling when all tracked inputs are unchanged', async () => {
+    touchFile(
+      path.join(tmpDir, 'packages', 'core', 'src', 'modules', 'demo', 'api', 'health', 'route.ts'),
+      [
+        'export async function GET() { return new Response("ok") }',
+        "export const openApi = { GET: { summary: 'health' } }",
+        '',
+      ].join('\n'),
+    )
+    const resolver = createMockResolver([{ id: 'demo', from: '@open-mercato/core' }])
+
+    await generateOpenApi({ resolver, quiet: true })
+    const consoleSpy = jest.spyOn(console, 'log').mockImplementation()
+    const result = await generateOpenApi({ resolver, quiet: false })
+
+    const generatedPath = path.join(tmpDir, 'output', 'generated', 'openapi.generated.json')
+    expect(result.filesWritten).toEqual([])
+    expect(result.filesUnchanged).toEqual([generatedPath])
+    expect(consoleSpy).toHaveBeenCalledWith(`[OpenAPI] Skipped (inputs unchanged): ${generatedPath}`)
+    expect(consoleSpy).not.toHaveBeenCalledWith(expect.stringContaining('[OpenAPI] Found'))
+    consoleSpy.mockRestore()
+  })
+
+  it('invalidates the early cache when a transitive route dependency changes', async () => {
+    const moduleRoot = path.join(tmpDir, 'packages', 'core', 'src', 'modules', 'demo')
+    const schemaPath = path.join(moduleRoot, 'schema.ts')
+    touchFile(schemaPath, "export const summary = 'first schema'\n")
+    touchFile(
+      path.join(moduleRoot, 'api', 'health', 'route.ts'),
+      [
+        "import { summary } from '../../schema'",
+        'export async function GET() { return new Response("ok") }',
+        'export const openApi = { GET: { summary } }',
+        '',
+      ].join('\n'),
+    )
+    const resolver = createMockResolver([{ id: 'demo', from: '@open-mercato/core' }])
+    await generateOpenApi({ resolver, quiet: true })
+
+    touchFile(schemaPath, "export const summary = 'second schema'\n")
+    const result = await generateOpenApi({ resolver, quiet: true })
+    const generatedPath = path.join(tmpDir, 'output', 'generated', 'openapi.generated.json')
+    const openApiDoc = JSON.parse(fs.readFileSync(generatedPath, 'utf8')) as {
+      paths: Record<string, { get?: { summary?: string } }>
+    }
+
+    expect(result.filesWritten).toEqual([generatedPath])
+    expect(openApiDoc.paths['/api/demo/health']?.get?.summary).toBe('second schema')
+  })
+
+  it('invalidates the early cache when enabled modules change', async () => {
+    touchFile(
+      path.join(tmpDir, 'packages', 'core', 'src', 'modules', 'first', 'api', 'route.ts'),
+      "export async function GET() {}\nexport const openApi = { GET: { summary: 'first' } }\n",
+    )
+    touchFile(
+      path.join(tmpDir, 'packages', 'core', 'src', 'modules', 'second', 'api', 'route.ts'),
+      "export async function GET() {}\nexport const openApi = { GET: { summary: 'second' } }\n",
+    )
+    let enabled: ModuleEntry[] = [{ id: 'first', from: '@open-mercato/core' }]
+    const delegate = createMockResolver(enabled)
+    const resolver: PackageResolver = {
+      ...delegate,
+      loadEnabledModules: () => enabled,
+    }
+    await generateOpenApi({ resolver, quiet: true })
+
+    enabled = [{ id: 'second', from: '@open-mercato/core' }]
+    await generateOpenApi({ resolver, quiet: true })
+    const generatedPath = path.join(tmpDir, 'output', 'generated', 'openapi.generated.json')
+    const openApiDoc = JSON.parse(fs.readFileSync(generatedPath, 'utf8')) as {
+      paths: Record<string, unknown>
+    }
+
+    expect(openApiDoc.paths['/api/first']).toBeUndefined()
+    expect(openApiDoc.paths['/api/second']).toBeDefined()
+  })
+
+  it('rebuilds when the generated document is missing or tampered with', async () => {
+    touchFile(
+      path.join(tmpDir, 'packages', 'core', 'src', 'modules', 'demo', 'api', 'health', 'route.ts'),
+      "export async function GET() {}\nexport const openApi = { GET: { summary: 'health' } }\n",
+    )
+    const resolver = createMockResolver([{ id: 'demo', from: '@open-mercato/core' }])
+    const generatedPath = path.join(tmpDir, 'output', 'generated', 'openapi.generated.json')
+    await generateOpenApi({ resolver, quiet: true })
+
+    fs.unlinkSync(generatedPath)
+    const restored = await generateOpenApi({ resolver, quiet: true })
+    expect(restored.filesWritten).toEqual([generatedPath])
+
+    fs.writeFileSync(generatedPath, '{"tampered":true}')
+    const repaired = await generateOpenApi({ resolver, quiet: true })
+    expect(repaired.filesWritten).toEqual([generatedPath])
+    expect(JSON.parse(fs.readFileSync(generatedPath, 'utf8'))).toHaveProperty('openapi', '3.1.0')
+  })
+
+  it('invalidates the early cache when the generated server URL changes', async () => {
+    const originalAppUrl = process.env.NEXT_PUBLIC_APP_URL
+    touchFile(
+      path.join(tmpDir, 'packages', 'core', 'src', 'modules', 'demo', 'api', 'route.ts'),
+      "export async function GET() {}\nexport const openApi = { GET: { summary: 'demo' } }\n",
+    )
+    const resolver = createMockResolver([{ id: 'demo', from: '@open-mercato/core' }])
+    const generatedPath = path.join(tmpDir, 'output', 'generated', 'openapi.generated.json')
+
+    try {
+      process.env.NEXT_PUBLIC_APP_URL = 'https://first.example.test'
+      await generateOpenApi({ resolver, quiet: true })
+      process.env.NEXT_PUBLIC_APP_URL = 'https://second.example.test'
+      const result = await generateOpenApi({ resolver, quiet: true })
+      const openApiDoc = JSON.parse(fs.readFileSync(generatedPath, 'utf8')) as {
+        servers: Array<{ url: string }>
+      }
+
+      expect(result.filesWritten).toEqual([generatedPath])
+      expect(openApiDoc.servers[0]?.url).toBe('https://second.example.test')
+    } finally {
+      if (originalAppUrl === undefined) delete process.env.NEXT_PUBLIC_APP_URL
+      else process.env.NEXT_PUBLIC_APP_URL = originalAppUrl
+    }
+  })
+
+  it('does not cache a static fallback after a bundle failure', async () => {
+    touchFile(
+      path.join(tmpDir, 'packages', 'core', 'src', 'modules', 'demo', 'api', 'route.ts'),
+      "export async function GET() {}\nexport const openApi = { GET: { summary: 'demo' } }\n",
+    )
+    const resolver = createMockResolver([{ id: 'demo', from: '@open-mercato/core' }])
+    const generatorPath = path.join(tmpDir, 'packages', 'shared', 'src', 'lib', 'openapi', 'generator.ts')
+    const manifestPath = path.join(tmpDir, 'output', 'generated', 'openapi.generated.inputs.json')
+    await generateOpenApi({ resolver, quiet: true })
+
+    fs.unlinkSync(generatorPath)
+    const consoleSpy = jest.spyOn(console, 'log').mockImplementation()
+    await generateOpenApi({ resolver, quiet: false })
+    await generateOpenApi({ resolver, quiet: false })
+
+    expect(consoleSpy.mock.calls.filter(([message]) =>
+      typeof message === 'string' && message.startsWith('[OpenAPI] Found'),
+    )).toHaveLength(2)
+    expect(fs.existsSync(manifestPath)).toBe(false)
+    consoleSpy.mockRestore()
+  })
 })

package/src/lib/generators/__tests__/structural-contracts.test.ts

@@ -14,7 +14,7 @@
 import fs from 'node:fs'
 import path from 'node:path'
 import os from 'node:os'
-import ts from 'typescript'
+import ts from 'typescript-js'
 import type { PackageResolver, ModuleEntry } from '../../resolver'
 import { generateModuleRegistry, generateModuleRegistryApp, generateModuleRegistryCli } from '../module-registry'
 import { generateModuleDi } from '../module-di'

package/src/lib/generators/ast/imports.ts

@@ -1,4 +1,4 @@
-import ts from 'typescript'
+import ts from 'typescript-js'
 import {
   StructureKind,
   type ImportDeclarationStructure,

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

@@ -1,6 +1,6 @@
 import fs from 'node:fs'
 import path from 'node:path'
-import ts from 'typescript'
+import ts from 'typescript-js'
 import { VariableDeclarationKind } from 'ts-morph'
 import type { PackageResolver, ModuleEntry } from '../resolver'
 import { MODULE_CODE_EXTENSIONS } from './scanner'
@@ -13,6 +13,7 @@ import {
   toSnake,
   rimrafDir,
   logGenerationResult,
+  writeIfChanged,
   type GeneratorResult,
   createGeneratorResult,
 } from '../utils'
@@ -240,7 +241,23 @@ function parseEntityFieldsFromFile(filePath: string, exportedClassNames: string[
   return result
 }
 
-function writePerEntityFieldFiles(outRoot: string, fieldsByEntity: EntityFieldMap): void {
+function writeTrackedFile(
+  filePath: string,
+  content: string,
+  result: GeneratorResult,
+): void {
+  if (writeIfChanged(filePath, content)) {
+    result.filesWritten.push(filePath)
+  } else {
+    result.filesUnchanged.push(filePath)
+  }
+}
+
+function writePerEntityFieldFiles(
+  outRoot: string,
+  fieldsByEntity: EntityFieldMap,
+  result: GeneratorResult,
+): void {
   fs.mkdirSync(outRoot, { recursive: true })
   const desiredEntities = new Set(Object.keys(fieldsByEntity))
   for (const [entity, fields] of Object.entries(fieldsByEntity)) {
@@ -259,18 +276,24 @@ function writePerEntityFieldFiles(outRoot: string, fieldsByEntity: EntityFieldMa
         ],
       })
     }
-    fs.writeFileSync(path.join(entDir, 'index.ts'), getSourceText(sourceFile))
+    writeTrackedFile(path.join(entDir, 'index.ts'), getSourceText(sourceFile), result)
   }
 
   const existingEntries = fs.existsSync(outRoot) ? fs.readdirSync(outRoot, { withFileTypes: true }) : []
   for (const entry of existingEntries) {
     if (!entry.isDirectory()) continue
     if (desiredEntities.has(entry.name)) continue
-    rimrafDir(path.join(outRoot, entry.name))
+    const staleDirectory = path.join(outRoot, entry.name)
+    rimrafDir(staleDirectory)
+    result.filesWritten.push(staleDirectory)
   }
 }
 
-function writeEntityFieldsRegistry(generatedRoot: string, fieldsByEntity: EntityFieldMap): void {
+function writeEntityFieldsRegistry(
+  generatedRoot: string,
+  fieldsByEntity: EntityFieldMap,
+  result: GeneratorResult,
+): void {
   const entities = Object.keys(fieldsByEntity).sort((a, b) => a.localeCompare(b))
   const registry: Record<string, Record<string, string>> = {}
   for (const entity of entities) {
@@ -302,8 +325,7 @@ function writeEntityFieldsRegistry(generatedRoot: string, fieldsByEntity: Entity
     statements: [returnStatement(elementAccess(identifier('entityFieldsRegistry'), identifier('slug')))],
   })
   const outPath = path.join(generatedRoot, 'entity-fields-registry.ts')
-  ensureDir(outPath)
-  fs.writeFileSync(outPath, getSourceText(sourceFile))
+  writeTrackedFile(outPath, getSourceText(sourceFile), result)
 }
 
 export async function generateEntityIds(options: EntityIdsOptions): Promise<GeneratorResult> {
@@ -472,9 +494,7 @@ export async function generateEntityIds(options: EntityIdsOptions): Promise<Gene
       type: 'typeof E',
     })
     const src = getSourceText(groupSourceFile)
-    ensureDir(out)
-    fs.writeFileSync(out, src)
-    result.filesWritten.push(out)
+    writeTrackedFile(out, src, result)
 
     const fieldsRoot = path.join(pkgOutputDir, 'entities')
     const fieldsByModule = fieldsByGroup[g] || {}
@@ -485,10 +505,10 @@ export async function generateEntityIds(options: EntityIdsOptions): Promise<Gene
         combined[entity] = Array.from(new Set([...(combined[entity] || []), ...fields]))
       }
     }
-    writePerEntityFieldFiles(fieldsRoot, combined)
+    writePerEntityFieldFiles(fieldsRoot, combined, result)
 
     // Generate static entity fields registry for Turbopack compatibility
-    writeEntityFieldsRegistry(pkgOutputDir, combined)
+    writeEntityFieldsRegistry(pkgOutputDir, combined, result)
   }
 
   // Write combined entity fields to root generated/ folder
@@ -500,8 +520,8 @@ export async function generateEntityIds(options: EntityIdsOptions): Promise<Gene
       }
     }
   }
-  writePerEntityFieldFiles(path.join(outputDir, 'entities'), combinedAll)
-  writeEntityFieldsRegistry(outputDir, combinedAll)
+  writePerEntityFieldFiles(path.join(outputDir, 'entities'), combinedAll, result)
+  writeEntityFieldsRegistry(outputDir, combinedAll, result)
 
   return result
 }

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

@@ -1,7 +1,7 @@
 import fs from 'node:fs'
 import path from 'node:path'
 import { VariableDeclarationKind } from 'ts-morph'
-import ts from 'typescript'
+import ts from 'typescript-js'
 import type { GeneratorExtension } from '../extension'
 import { resolveStandaloneSourceMirrorBase, scanModuleDir, SCAN_CONFIGS, type ModuleRoots } from '../scanner'
 import {

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

@@ -1,6 +1,6 @@
 import fs from 'node:fs'
 import path from 'node:path'
-import ts from 'typescript'
+import ts from 'typescript-js'
 import { toSnake } from '../utils'
 
 export interface ModuleEntityFact {

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

@@ -2,7 +2,7 @@ import fs from 'node:fs'
 import path from 'node:path'
 import { pathToFileURL } from 'node:url'
 import { VariableDeclarationKind, type WriterFunction } from 'ts-morph'
-import ts from 'typescript'
+import ts from 'typescript-js'
 import type { PackageResolver } from '../resolver'
 import {
   calculateStructureChecksum,