@open-mercato/cli 0.8.1-develop.7241.1.fad7b2ce2a → 0.8.1-develop.7254.1.ab24f26208

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-mercato/cli",
-  "version": "0.8.1-develop.7241.1.fad7b2ce2a",
+  "version": "0.8.1-develop.7254.1.ab24f26208",
   "license": "MIT",
   "type": "module",
   "main": "./dist/index.js",
@@ -60,9 +60,9 @@
     "@mikro-orm/decorators": "^7.1.14",
     "@mikro-orm/migrations": "^7.1.14",
     "@mikro-orm/postgresql": "^7.1.14",
-    "@open-mercato/queue": "0.8.1-develop.7241.1.fad7b2ce2a",
-    "@open-mercato/shared": "0.8.1-develop.7241.1.fad7b2ce2a",
-    "@open-mercato/telemetry": "0.8.1-develop.7241.1.fad7b2ce2a",
+    "@open-mercato/queue": "0.8.1-develop.7254.1.ab24f26208",
+    "@open-mercato/shared": "0.8.1-develop.7254.1.ab24f26208",
+    "@open-mercato/telemetry": "0.8.1-develop.7254.1.ab24f26208",
     "cross-spawn": "^7.0.6",
     "pg": "8.23.0",
     "semver": "^7.8.5",
@@ -73,10 +73,10 @@
     "typescript-js": "npm:typescript@6.0.3"
   },
   "peerDependencies": {
-    "@open-mercato/shared": "0.8.1-develop.7241.1.fad7b2ce2a"
+    "@open-mercato/shared": "0.8.1-develop.7254.1.ab24f26208"
   },
   "devDependencies": {
-    "@open-mercato/shared": "0.8.1-develop.7241.1.fad7b2ce2a",
+    "@open-mercato/shared": "0.8.1-develop.7254.1.ab24f26208",
     "@types/jest": "^30.0.0",
     "jest": "^30.4.2",
     "ts-jest": "^29.4.12"

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

@@ -3,6 +3,7 @@ import os from 'node:os'
 import path from 'node:path'
 import {
   createGenerateWatchChangeSignal,
+  resolveGenerateWatchTargets,
   type GenerateWatchTarget,
 } from '../generate-watch-events'
 
@@ -40,6 +41,142 @@ function createWatchHarness(initialTargets: GenerateWatchTarget[]) {
 }
 
 describe('createGenerateWatchChangeSignal', () => {
+  it('keeps app-module watches idle without inventing a node_modules/@app target', async () => {
+    const projectRoot = path.resolve('/virtual/standalone-app')
+    const modulesFile = path.join(projectRoot, 'src', 'modules.ts')
+    const appBase = path.join(projectRoot, 'src', 'modules', 'custom_module')
+    const impossiblePackageBase = path.join(
+      projectRoot,
+      'node_modules',
+      '@app',
+      'src',
+      'modules',
+      'custom_module',
+    )
+    const resolveSourceMirrorBase = jest.fn(() => null)
+    const targets = resolveGenerateWatchTargets({
+      modulesFile,
+      moduleRoots: [{
+        appBase,
+        pkgBase: impossiblePackageBase,
+        watchPackageBase: false,
+      }],
+      resolveSourceMirrorBase,
+    })
+
+    expect(targets).toEqual([
+      {
+        directory: path.dirname(modulesFile),
+        recursive: false,
+        fileName: path.basename(modulesFile),
+      },
+      {
+        directory: path.dirname(appBase),
+        recursive: true,
+      },
+    ])
+    expect(resolveSourceMirrorBase).not.toHaveBeenCalled()
+
+    const signal = createGenerateWatchChangeSignal({
+      getWatchTargets: () => targets,
+      directoryExists: () => true,
+      watchDirectory: () => ({ close: jest.fn() }),
+    })
+    await signal.refresh()
+    expect(signal.hasSkippedTargets?.()).toBe(false)
+    await signal.close()
+  })
+
+  it('retains the real package fallback target for app modules in monorepo mode', () => {
+    const projectRoot = path.resolve('/virtual/monorepo')
+    const modulesFile = path.join(projectRoot, 'apps', 'mercato', 'src', 'modules.ts')
+    const appBase = path.join(
+      projectRoot,
+      'apps',
+      'mercato',
+      'src',
+      'modules',
+      'custom_module',
+    )
+    const packageBase = path.join(
+      projectRoot,
+      'packages',
+      'core',
+      'src',
+      'modules',
+      'custom_module',
+    )
+    const resolveSourceMirrorBase = jest.fn(() => null)
+
+    const targets = resolveGenerateWatchTargets({
+      modulesFile,
+      moduleRoots: [{
+        appBase,
+        pkgBase: packageBase,
+        watchPackageBase: true,
+      }],
+      resolveSourceMirrorBase,
+    })
+
+    expect(targets).toContainEqual({
+      directory: path.dirname(appBase),
+      recursive: true,
+    })
+    expect(targets).toContainEqual({
+      directory: path.dirname(packageBase),
+      recursive: true,
+    })
+    expect(resolveSourceMirrorBase).toHaveBeenCalledWith(packageBase)
+  })
+
+  it('retains missing package-module targets so idle refresh discovers them later', async () => {
+    const projectRoot = path.resolve('/virtual/standalone-app')
+    const modulesFile = path.join(projectRoot, 'src', 'modules.ts')
+    const appBase = path.join(projectRoot, 'src', 'modules', 'official_module')
+    const packageBase = path.join(
+      projectRoot,
+      'node_modules',
+      '@open-mercato',
+      'official-package',
+      'dist',
+      'modules',
+      'official_module',
+    )
+    const packageModulesDir = path.dirname(packageBase)
+    const targets = resolveGenerateWatchTargets({
+      modulesFile,
+      moduleRoots: [{
+        appBase,
+        pkgBase: packageBase,
+        watchPackageBase: true,
+      }],
+      resolveSourceMirrorBase: () => null,
+    })
+    const existing = new Set([
+      path.dirname(modulesFile),
+      path.dirname(appBase),
+    ])
+    const registered: string[] = []
+    const signal = createGenerateWatchChangeSignal({
+      getWatchTargets: () => targets,
+      directoryExists: (directory) => existing.has(directory),
+      watchDirectory: (target) => {
+        registered.push(target.directory)
+        return { close: jest.fn() }
+      },
+    })
+
+    await signal.refresh()
+    expect(signal.hasSkippedTargets?.()).toBe(true)
+    expect(registered).not.toContain(packageModulesDir)
+
+    existing.add(packageModulesDir)
+    await signal.refresh()
+    expect(signal.hasSkippedTargets?.()).toBe(false)
+    expect(registered).toContain(packageModulesDir)
+    await signal.close()
+  })
+
   it('skips missing directories without falling back and retries them on refresh', async () => {
     const present = path.resolve('./modules-present')
     const delayed = path.resolve('./modules-delayed')

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

@@ -25,6 +25,37 @@ export type GenerateWatchChangeSignalOptions = {
   onSkippedDirectory?: (directory: string) => void
 }
 
+export type GenerateWatchModuleTarget = {
+  appBase: string
+  pkgBase: string
+  watchPackageBase: boolean
+}
+
+export function resolveGenerateWatchTargets(options: {
+  modulesFile: string
+  moduleRoots: GenerateWatchModuleTarget[]
+  resolveSourceMirrorBase: (packageBase: string) => string | null
+}): GenerateWatchTarget[] {
+  const targets: GenerateWatchTarget[] = [{
+    directory: path.dirname(options.modulesFile),
+    recursive: false,
+    fileName: path.basename(options.modulesFile),
+  }]
+
+  for (const roots of options.moduleRoots) {
+    targets.push({ directory: path.dirname(roots.appBase), recursive: true })
+    if (!roots.watchPackageBase) continue
+
+    targets.push({ directory: path.dirname(roots.pkgBase), recursive: true })
+    const sourceMirror = options.resolveSourceMirrorBase(roots.pkgBase)
+    if (sourceMirror) {
+      targets.push({ directory: path.dirname(sourceMirror), recursive: true })
+    }
+  }
+
+  return targets
+}
+
 function targetKey(target: GenerateWatchTarget): string {
   return JSON.stringify([
     path.resolve(target.directory),

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

@@ -3,6 +3,7 @@ import os from 'node:os'
 import path from 'node:path'
 import { generateModulePackageSources } from '../module-package-sources'
 import type { PackageResolver } from '../../resolver'
+import { readChecksumRecord } from '../../utils'
 
 const fixturePackageRoot = path.resolve(
   __dirname,
@@ -25,7 +26,7 @@ function copyDir(src: string, dest: string): void {
   }
 }
 
-function createResolver(tmpDir: string, packageRoot: string, from: string): PackageResolver {
+function createResolver(tmpDir: string, packageRoot: string, from: string, moduleId = 'test_package'): PackageResolver {
   const appDir = path.join(tmpDir, 'app')
   const outputDir = path.join(appDir, '.mercato', 'generated')
   fs.mkdirSync(outputDir, { recursive: true })
@@ -37,14 +38,14 @@ function createResolver(tmpDir: string, packageRoot: string, from: string): Pack
     getOutputDir: () => outputDir,
     getModulesConfigPath: () => path.join(appDir, 'src', 'modules.ts'),
     discoverPackages: () => [],
-    loadEnabledModules: () => [{ id: 'test_package', from }],
+    loadEnabledModules: () => [{ id: moduleId, from }],
     getModulePaths: () => ({
-      appBase: path.join(appDir, 'src', 'modules', 'test_package'),
-      pkgBase: path.join(packageRoot, 'src', 'modules', 'test_package'),
+      appBase: path.join(appDir, 'src', 'modules', moduleId),
+      pkgBase: path.join(packageRoot, 'src', 'modules', moduleId),
     }),
     getModuleImportBase: () => ({
-      appBase: '@/modules/test_package',
-      pkgBase: `${from}/modules/test_package`,
+      appBase: `@/modules/${moduleId}`,
+      pkgBase: `${from}/modules/${moduleId}`,
     }),
     getPackageOutputDir: () => outputDir,
     getPackageRoot: () => packageRoot,
@@ -75,6 +76,88 @@ describe('generateModulePackageSources', () => {
     expect(output).toContain('node_modules/@open-mercato/test-package/src/**/*.{ts,tsx}')
   })
 
+  it('does not checksum unrelated files below the installed package root', async () => {
+    const packageRoot = path.join(tmpDir, 'node_modules', '@open-mercato', 'test-package')
+    copyDir(fixturePackageRoot, packageRoot)
+    const resolver = createResolver(tmpDir, packageRoot, '@open-mercato/test-package')
+    const outFile = path.join(resolver.getOutputDir(), 'module-package-sources.css')
+    const checksumFile = path.join(resolver.getOutputDir(), 'module-package-sources.checksum')
+
+    await generateModulePackageSources({ resolver, quiet: true })
+    const outputBefore = fs.readFileSync(outFile, 'utf8')
+    const checksumBefore = readChecksumRecord(checksumFile)
+    const pinnedTime = new Date(Date.now() - 60_000)
+    fs.utimesSync(outFile, pinnedTime, pinnedTime)
+    fs.utimesSync(checksumFile, pinnedTime, pinnedTime)
+
+    fs.writeFileSync(path.join(packageRoot, 'src', 'unrelated-runtime.ts'), 'export const unrelated = true\n')
+    const result = await generateModulePackageSources({ resolver, quiet: true })
+
+    expect(result.filesWritten).toEqual([])
+    expect(result.filesUnchanged).toEqual([outFile])
+    expect(fs.readFileSync(outFile, 'utf8')).toBe(outputBefore)
+    expect(fs.statSync(outFile).mtimeMs).toBe(pinnedTime.getTime())
+    expect(fs.statSync(checksumFile).mtimeMs).toBe(pinnedTime.getTime())
+    expect(readChecksumRecord(checksumFile)).toEqual(checksumBefore)
+  })
+
+  it('tracks enabled module and package manifest inputs without touching byte-identical output', async () => {
+    const packageRoot = path.join(tmpDir, 'node_modules', '@open-mercato', 'test-package')
+    copyDir(fixturePackageRoot, packageRoot)
+    copyDir(
+      path.join(packageRoot, 'src', 'modules', 'test_package'),
+      path.join(packageRoot, 'src', 'modules', 'alternate_module'),
+    )
+    copyDir(
+      path.join(packageRoot, 'dist', 'modules', 'test_package'),
+      path.join(packageRoot, 'dist', 'modules', 'alternate_module'),
+    )
+    const packageName = '@open-mercato/test-package'
+    const initialResolver = createResolver(tmpDir, packageRoot, packageName)
+    const alternateResolver = createResolver(tmpDir, packageRoot, packageName, 'alternate_module')
+    const outFile = path.join(initialResolver.getOutputDir(), 'module-package-sources.css')
+    const checksumFile = path.join(initialResolver.getOutputDir(), 'module-package-sources.checksum')
+
+    await generateModulePackageSources({ resolver: initialResolver, quiet: true })
+    const outputBefore = fs.readFileSync(outFile, 'utf8')
+    const initialStructure = readChecksumRecord(checksumFile)?.structure
+    const pinnedTime = new Date(Date.now() - 60_000)
+    fs.utimesSync(outFile, pinnedTime, pinnedTime)
+
+    await generateModulePackageSources({ resolver: alternateResolver, quiet: true })
+    const alternateStructure = readChecksumRecord(checksumFile)?.structure
+    expect(alternateStructure).not.toBe(initialStructure)
+    expect(fs.readFileSync(outFile, 'utf8')).toBe(outputBefore)
+    expect(fs.statSync(outFile).mtimeMs).toBe(pinnedTime.getTime())
+
+    const packageJsonPath = path.join(packageRoot, 'package.json')
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8')) as Record<string, unknown>
+    packageJson.version = '0.2.0'
+    fs.writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`)
+    const result = await generateModulePackageSources({ resolver: alternateResolver, quiet: true })
+
+    expect(readChecksumRecord(checksumFile)?.structure).not.toBe(alternateStructure)
+    expect(result.filesWritten).toEqual([])
+    expect(result.filesUnchanged).toEqual([outFile])
+    expect(fs.readFileSync(outFile, 'utf8')).toBe(outputBefore)
+    expect(fs.statSync(outFile).mtimeMs).toBe(pinnedTime.getTime())
+  })
+
+  it('keeps official package validation as the source inclusion gate', async () => {
+    const packageRoot = path.join(tmpDir, 'node_modules', '@open-mercato', 'test-package')
+    copyDir(fixturePackageRoot, packageRoot)
+    const packageJsonPath = path.join(packageRoot, 'package.json')
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8')) as Record<string, unknown>
+    packageJson.name = '@open-mercato/different-package'
+    fs.writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`)
+    const resolver = createResolver(tmpDir, packageRoot, '@open-mercato/test-package')
+
+    await generateModulePackageSources({ resolver, quiet: true })
+
+    const output = fs.readFileSync(path.join(resolver.getOutputDir(), 'module-package-sources.css'), 'utf8')
+    expect(output).toBe('')
+  })
+
   it('skips app-backed modules', async () => {
     const packageRoot = path.join(tmpDir, 'node_modules', '@open-mercato', 'test-package')
     copyDir(fixturePackageRoot, packageRoot)

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

@@ -1,8 +1,7 @@
-import fs from 'node:fs'
 import path from 'node:path'
 import { readOfficialModulePackageFromRoot, resolveInstalledPackageRoot } from '../module-package'
 import type { PackageResolver } from '../resolver'
-import { calculateStructureChecksum, createGeneratorResult, type GeneratorResult, writeGeneratedFile } from '../utils'
+import { calculateChecksum, createGeneratorResult, type GeneratorResult, writeGeneratedFile } from '../utils'
 
 export interface ModulePackageSourcesOptions {
   resolver: PackageResolver
@@ -23,13 +22,12 @@ export async function generateModulePackageSources(
   const outFile = path.join(outputDir, 'module-package-sources.css')
   const checksumFile = path.join(outputDir, 'module-package-sources.checksum')
   const sourcePaths = new Set<string>()
-  const checksumTargets: string[] = []
+  const checksumInputs = new Set<string>()
 
   for (const entry of resolver.loadEnabledModules()) {
     if (!entry.from || entry.from === '@app' || entry.from === '@open-mercato/core') continue
 
     const packageRoot = resolveInstalledPackageRoot(resolver, entry.from)
-    checksumTargets.push(packageRoot)
 
     let modulePackage
     try {
@@ -39,12 +37,26 @@ export async function generateModulePackageSources(
     }
 
     const packageSourceRoot = path.join(modulePackage.packageRoot, 'src')
+    checksumInputs.add(JSON.stringify({
+      entry: {
+        from: entry.from,
+        id: entry.id,
+      },
+      packageName: modulePackage.packageName,
+      packageRoot: path.resolve(modulePackage.packageRoot),
+      packageJson: modulePackage.packageJson,
+      packageSourceRoot,
+      sourceModuleDir: path.resolve(modulePackage.sourceModuleDir),
+      distModuleDir: path.resolve(modulePackage.distModuleDir),
+    }))
     const relativeSourcePath = normalizeCssSourcePath(path.relative(path.dirname(outFile), packageSourceRoot))
     sourcePaths.add(`@source "${relativeSourcePath}/**/*.{ts,tsx}";`)
   }
 
   const content = `${Array.from(sourcePaths).sort((left, right) => left.localeCompare(right)).join('\n')}${sourcePaths.size > 0 ? '\n' : ''}`
-  const structureChecksum = calculateStructureChecksum(checksumTargets)
+  const structureChecksum = calculateChecksum(
+    Array.from(checksumInputs).sort((left, right) => left.localeCompare(right)).join('\n'),
+  )
 
   writeGeneratedFile({
     outFile,

package/src/mercato.ts

@@ -825,7 +825,7 @@ async function createGenerateWatchRuntime(quiet = false) {
   const [
     { createResolver },
     { calculateGenerateWatchStructureChecksum },
-    { createGenerateWatchChangeSignal },
+    { createGenerateWatchChangeSignal, resolveGenerateWatchTargets },
     { resolveStandaloneSourceMirrorBase },
   ] = await Promise.all([
     import('./lib/resolver'),
@@ -836,10 +836,18 @@ async function createGenerateWatchRuntime(quiet = false) {
 
   const collectWatchState = () => {
     const resolver = createResolver()
-    const moduleRoots = []
+    const moduleRoots: Array<{
+      appBase: string
+      pkgBase: string
+      watchPackageBase: boolean
+    }> = []
+    const watchAppPackageFallbacks = resolver.isMonorepo()
     for (const entry of resolver.loadEnabledModules()) {
       const roots = resolver.getModulePaths(entry)
-      moduleRoots.push({ appBase: roots.appBase, pkgBase: roots.pkgBase })
+      moduleRoots.push({
+        ...roots,
+        watchPackageBase: entry.from !== '@app' || watchAppPackageFallbacks,
+      })
     }
     return {
       modulesFile: resolver.getModulesConfigPath(),
@@ -857,20 +865,11 @@ async function createGenerateWatchRuntime(quiet = false) {
         : (directory) => console.log(`[generate:watch] Skipping missing watch directory: ${directory}`),
       getWatchTargets: () => {
         const state = collectWatchState()
-        const targets: Array<{ directory: string; recursive: boolean; fileName?: string }> = [{
-          directory: path.dirname(state.modulesFile),
-          recursive: false,
-          fileName: path.basename(state.modulesFile),
-        }]
-        for (const roots of state.moduleRoots) {
-          targets.push({ directory: path.dirname(roots.appBase), recursive: true })
-          targets.push({ directory: path.dirname(roots.pkgBase), recursive: true })
-          const sourceMirror = resolveStandaloneSourceMirrorBase(roots.pkgBase)
-          if (sourceMirror) {
-            targets.push({ directory: path.dirname(sourceMirror), recursive: true })
-          }
-        }
-        return targets
+        return resolveGenerateWatchTargets({
+          modulesFile: state.modulesFile,
+          moduleRoots: state.moduleRoots,
+          resolveSourceMirrorBase: resolveStandaloneSourceMirrorBase,
+        })
       },
     }),
   }