create-mercato-app 0.6.3-develop.3876.1.d40fe4ec2d → 0.6.3-develop.3894.1.352abf4240

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-mercato-app",
-  "version": "0.6.3-develop.3876.1.d40fe4ec2d",
+  "version": "0.6.3-develop.3894.1.352abf4240",
   "type": "module",
   "description": "Create a new Open Mercato application",
   "main": "./dist/index.js",

package/template/scripts/dev-orchestration-log-policy.mjs

@@ -66,6 +66,17 @@ export function isIgnorableTurboShutdownLine(line) {
     || /^command (interrupted|cancelled|canceled)/i.test(plain)
 }
 
+export function isIgnorableConsolidatedWatchLine(line) {
+  if (typeof line !== 'string') return false
+  const plain = normalize(line)
+  if (!plain.startsWith('[watch]')) return false
+  return /^\[watch\] consolidated watcher: /.test(plain)
+    || /^\[watch\] [^:]+: rebuilding\.\.\.$/.test(plain)
+    || /^\[watch\] [^:]+: rebuild complete$/.test(plain)
+    || /^\[watch\] [^:]+: no source files found, skipping rebuild$/.test(plain)
+    || /^\[watch\] no workspace packages with a `watch` script /.test(plain)
+}
+
 const FAILURE_NOISE_PREDICATES = [
   isIgnorableBoxDrawingLine,
   isIgnorableEnvInjectionLine,
@@ -89,6 +100,7 @@ const TURBO_NOISE_PREDICATES = [
   isIgnorableTurboCacheCancellationLine,
   isIgnorableTurboShutdownLine,
   isIgnorableBoxDrawingLine,
+  isIgnorableConsolidatedWatchLine,
 ]
 
 export function isIgnorableTurboLine(line) {

package/template/scripts/dev-runtime.mjs

@@ -1434,6 +1434,28 @@ function classifyWatchLine(line) {
       progressLabel: 'Watching structural module files',
     }
   }
+  if (line.startsWith('[generate:watch] Regenerating')) {
+    return {
+      type: 'status',
+      message: '♻️ Structural change detected; regenerating generated files',
+      splashPhase: startupSplashPhase,
+      splashDetail: 'Regenerating generated files',
+      activity: 'Regenerating generated files',
+      progressCurrent: 2,
+      progressLabel: 'Watching structural module files',
+    }
+  }
+  if (line === '[generate:watch] Generators completed.') {
+    return {
+      type: 'status',
+      message: '♻️ Generated files refreshed',
+      splashPhase: startupSplashPhase,
+      splashDetail: 'Generated files refreshed',
+      activity: 'Generated files refreshed',
+      progressCurrent: 2,
+      progressLabel: 'Watching structural module files',
+    }
+  }
   if (line.startsWith('[generate:watch]')) {
     return {
       type: 'status',
@@ -1473,6 +1495,9 @@ function classifyWatchLine(line) {
 }
 
 function classifyServerLine(line) {
+  if (line.startsWith('[generate:watch]')) {
+    return classifyWatchLine(line)
+  }
   if (line.startsWith('🚀 Running server:dev')) {
     return {
       type: 'status',
@@ -1672,6 +1697,18 @@ function startFilteredChild(args, label, classifyLine) {
   return child
 }
 
+function resolveGenerateWatchMode(env) {
+  const raw = env.OM_DEV_GENERATE_WATCH_MODE
+  if (typeof raw !== 'string') return 'in-process'
+  const normalized = raw.trim().toLowerCase()
+  if (normalized === 'legacy' || normalized === 'sidecar' || normalized === 'out-of-process') {
+    return 'legacy'
+  }
+  return 'in-process'
+}
+
+const generateWatchMode = resolveGenerateWatchMode(process.env)
+
 async function runClassicRuntime() {
   const initialGenerate = spawnMercato(['generate'])
   const initialGenerateResult = await waitForExit(initialGenerate)
@@ -1684,12 +1721,19 @@ async function runClassicRuntime() {
     shutdown(initialGenerateExitCode)
   }
 
-  const watch = spawnMercato(['generate', 'watch', '--skip-initial'])
+  // Default ('in-process'): `mercato server dev` runs the structural
+  // regeneration watcher in-process. Set OM_DEV_GENERATE_WATCH_MODE=legacy
+  // to fall back to spawning the dedicated sidecar Node process.
+  const watchers = []
+  if (generateWatchMode === 'legacy') {
+    watchers.push(['Generator watch (legacy sidecar)', spawnMercato(['generate', 'watch', '--skip-initial'])])
+  }
   const server = spawnMercato(['server', 'dev'])
-  const result = await Promise.race([
-    waitForExit(watch, 'Generator watch'),
+  const waiters = [
     waitForExit(server, 'App runtime'),
-  ])
+    ...watchers.map(([label, child]) => waitForExit(child, label)),
+  ]
+  const result = await Promise.race(waiters)
   if (isGracefulShutdownResult(result)) {
     return
   }
@@ -1707,13 +1751,16 @@ installLogToggle()
 initializeRuntimeSummary()
 printRuntimePackagesSummary()
 
-const watch = startFilteredChild(['generate', 'watch', '--skip-initial'], 'Generator watch', classifyWatchLine)
+const sidecarWatch = generateWatchMode === 'legacy'
+  ? startFilteredChild(['generate', 'watch', '--skip-initial'], 'Generator watch (legacy sidecar)', classifyWatchLine)
+  : null
 const server = startFilteredChild(['server', 'dev'], 'App runtime', classifyServerLine)
 
-const result = await Promise.race([
-  waitForExit(watch, 'Generator watch'),
-  waitForExit(server, 'App runtime'),
-])
+const waiters = [waitForExit(server, 'App runtime')]
+if (sidecarWatch) {
+  waiters.push(waitForExit(sidecarWatch, 'Generator watch (legacy sidecar)'))
+}
+const result = await Promise.race(waiters)
 if (!isGracefulShutdownResult(result)) {
   reportUnexpectedChildExit(result)
   shutdown(resolveUnexpectedExitCode(result))

package/template/scripts/dev-shutdown-utils.mjs

@@ -0,0 +1,41 @@
+import spawn from 'cross-spawn'
+
+// Windows does not propagate signals from a parent process down to grandchildren
+// the way POSIX does: child.kill('SIGTERM'/'SIGKILL') only terminates the direct
+// child, leaving any further descendants (next dev, mercato generate watch, etc.)
+// alive and still holding ports. taskkill with /T (tree) /F (force) is the
+// platform-blessed way to terminate the whole descendant tree. On POSIX we keep
+// child.kill so the existing graceful-then-forced two-phase shutdown is preserved.
+export function killProcessTree(child, signal, options = {}) {
+  if (!child) return false
+
+  const platform = options.platform ?? process.platform
+  const spawnImpl = options.spawn ?? spawn
+
+  if (platform === 'win32') {
+    const pid = child.pid
+    if (typeof pid !== 'number' || Number.isNaN(pid) || pid <= 0) {
+      return false
+    }
+    try {
+      const killer = spawnImpl('taskkill', ['/pid', String(pid), '/T', '/F'], {
+        stdio: 'ignore',
+        windowsHide: true,
+      })
+      if (killer && typeof killer.on === 'function') {
+        killer.on('error', () => { /* best-effort: taskkill may not exist on stripped images */ })
+      }
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  if (child.killed) return false
+  try {
+    child.kill(signal)
+    return true
+  } catch {
+    return false
+  }
+}

package/template/scripts/dev.mjs

@@ -23,6 +23,7 @@ import {
   stripAnsi,
 } from './dev-splash-helpers.mjs'
 import { purgeAppBuildCaches } from './dev-cache-purge.mjs'
+import { killProcessTree } from './dev-shutdown-utils.mjs'
 import { resolveSpawnCommand } from './dev-spawn-utils.mjs'
 import { createDevSplashCodingFlow } from './dev-splash-coding-flow.mjs'
 import { createDevSplashGitRepoFlow } from './dev-splash-git-repo-flow.mjs'
@@ -1023,13 +1024,13 @@ function shutdown(exitCode = 0) {
   }
 
   for (const child of alive) {
-    child.kill('SIGTERM')
+    killProcessTree(child, 'SIGTERM')
   }
 
   setTimeout(() => {
     for (const child of children) {
       if (!child.killed) {
-        child.kill('SIGKILL')
+        killProcessTree(child, 'SIGKILL')
       }
     }
     closeDevLogSession()
@@ -1492,10 +1493,21 @@ async function runPassthroughStage(label, commandArgs, options = {}) {
   console.log(`✅ ${formatProgressLine(label, stageCurrent, stageTotal, resolveProgressPercent(stageCurrent, stageTotal))} in ${formatDuration(Date.now() - startedAt)}`)
 }
 
+function resolveWatchPackagesScript() {
+  // `OM_WATCH_PACKAGES_MODE=legacy` falls back to the Turbo per-package
+  // fan-out for developers who need the old behavior (debugging, or pairing
+  // with `OM_PACKAGE_WATCH_MODE=persistent` for hot rebuilds at the cost of
+  // ~1 GB more idle RSS). Default is the consolidated single-process watcher.
+  const raw = String(process.env.OM_WATCH_PACKAGES_MODE ?? '').trim().toLowerCase()
+  return raw === 'legacy' ? 'watch:packages:legacy' : 'watch:packages'
+}
+
 function startPackageWatch() {
+  const watchScript = resolveWatchPackagesScript()
+
   if (classic) {
-    const child = spawnCommand(yarnCommand, ['watch:packages'], {
-      label: 'watch:packages',
+    const child = spawnCommand(yarnCommand, [watchScript], {
+      label: watchScript,
       logFile: getDevRunnerLog(),
       mirrorOutput: true,
     })
@@ -1529,16 +1541,7 @@ function startPackageWatch() {
     activity: 'Workspace package watch started',
   })
 
-  const child = spawnCommand(yarnCommand, [
-    'turbo',
-    'run',
-    'watch',
-    '--filter=./packages/*',
-    '--concurrency=32',
-    '--output-logs=errors-only',
-    '--log-order=grouped',
-    '--log-prefix=none',
-  ], {
+  const child = spawnCommand(yarnCommand, [watchScript], {
     label: 'Watching workspace packages',
     logFile: getDevRunnerLog(),
     mirrorOutput: verbose,