@open-mercato/cli 0.6.3-develop.3881.1.0b590ac4eb → 0.6.3-develop.3901.1.ddad60693a

package/.turbo/turbo-build.log

@@ -1,4 +1,4 @@
-[build:cli] found 71 entry points
+[build:cli] found 73 entry points
 Copied create-app/agentic/ → dist/agentic/
 Discovered 16 standalone guides → dist/agentic/guides/
 [build:cli] built successfully

package/dist/lib/in-process-generate-watcher-mode.js

@@ -0,0 +1,13 @@
+function resolveGenerateWatcherMode(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";
+}
+export {
+  resolveGenerateWatcherMode
+};
+//# sourceMappingURL=in-process-generate-watcher-mode.js.map

package/dist/lib/in-process-generate-watcher-mode.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/lib/in-process-generate-watcher-mode.ts"],
+  "sourcesContent": ["/**\n * Resolves the watcher-mode env flag that governs whether the dev runtime\n * runs the generate watcher in-process (default) or as a legacy out-of-process\n * `mercato generate watch --skip-initial` sidecar.\n *\n * `OM_DEV_GENERATE_WATCH_MODE=legacy` opts back into the pre-consolidation\n * behavior (one extra long-running Node process). Any other value, missing\n * value, or unparseable value resolves to `in-process`.\n */\n\nexport type GenerateWatcherMode = 'in-process' | 'legacy'\n\nexport function resolveGenerateWatcherMode(env: NodeJS.ProcessEnv): GenerateWatcherMode {\n  const raw = env.OM_DEV_GENERATE_WATCH_MODE\n  if (typeof raw !== 'string') return 'in-process'\n  const normalized = raw.trim().toLowerCase()\n  if (normalized === 'legacy' || normalized === 'sidecar' || normalized === 'out-of-process') {\n    return 'legacy'\n  }\n  return 'in-process'\n}\n"],
+  "mappings": "AAYO,SAAS,2BAA2B,KAA6C;AACtF,QAAM,MAAM,IAAI;AAChB,MAAI,OAAO,QAAQ,SAAU,QAAO;AACpC,QAAM,aAAa,IAAI,KAAK,EAAE,YAAY;AAC1C,MAAI,eAAe,YAAY,eAAe,aAAa,eAAe,kBAAkB;AAC1F,WAAO;AAAA,EACT;AACA,SAAO;AACT;",
+  "names": []
+}

package/dist/lib/in-process-generate-watcher.js

@@ -0,0 +1,112 @@
+const MIN_POLL_MS = 250;
+const DEFAULT_POLL_MS = 1e3;
+function resolvePollMs(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return DEFAULT_POLL_MS;
+  const numeric = Math.floor(value);
+  return numeric >= MIN_POLL_MS ? numeric : DEFAULT_POLL_MS;
+}
+function startInProcessGenerateWatcher(options) {
+  const logger = options.logger ?? console;
+  const quiet = options.quiet === true;
+  const pollMs = resolvePollMs(options.pollMs);
+  const skipInitial = options.skipInitial === true;
+  const { computeStructureChecksum, runGenerators } = options;
+  let stopping = false;
+  let pollTimer = null;
+  let running = false;
+  let pendingReason = null;
+  let previousChecksum = "";
+  let doneResolve = null;
+  const done = new Promise((resolve) => {
+    doneResolve = resolve;
+  });
+  async function runOnce(reason) {
+    if (running) {
+      pendingReason = reason;
+      return;
+    }
+    running = true;
+    try {
+      if (!quiet) {
+        logger.log(`[generate:watch] Regenerating (${reason})...`);
+      }
+      await runGenerators(reason);
+      if (!quiet) {
+        logger.log("[generate:watch] Generators completed.");
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      logger.error(`[generate:watch] Generation failed: ${message}`);
+    } finally {
+      running = false;
+      if (pendingReason && !stopping) {
+        const queued = pendingReason;
+        pendingReason = null;
+        await runOnce(queued);
+      }
+    }
+  }
+  function scheduleNext() {
+    if (stopping) return;
+    pollTimer = setTimeout(() => {
+      void (async () => {
+        if (stopping) return;
+        try {
+          const nextChecksum = await computeStructureChecksum();
+          if (nextChecksum !== previousChecksum) {
+            previousChecksum = nextChecksum;
+            await runOnce("structure change");
+          }
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          logger.error(`[generate:watch] Poll cycle failed: ${message}`);
+        } finally {
+          if (!stopping) scheduleNext();
+        }
+      })();
+    }, pollMs);
+    pollTimer.unref?.();
+  }
+  void (async () => {
+    try {
+      if (!skipInitial) {
+        await runOnce("initial");
+      }
+      previousChecksum = await computeStructureChecksum();
+      if (!quiet) {
+        if (skipInitial) {
+          logger.log("[generate:watch] Skipping initial regeneration and watching the current generated state.");
+        }
+        logger.log(`[generate:watch] Watching structural module files every ${pollMs}ms (in-process).`);
+      }
+      scheduleNext();
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      logger.error(`[generate:watch] Initial setup failed: ${message}`);
+      scheduleNext();
+    }
+  })();
+  async function close() {
+    if (stopping) {
+      await done;
+      return;
+    }
+    stopping = true;
+    if (pollTimer) {
+      clearTimeout(pollTimer);
+      pollTimer = null;
+    }
+    if (doneResolve) {
+      doneResolve();
+      doneResolve = null;
+    }
+  }
+  return {
+    done,
+    close
+  };
+}
+export {
+  startInProcessGenerateWatcher
+};
+//# sourceMappingURL=in-process-generate-watcher.js.map

package/dist/lib/in-process-generate-watcher.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/lib/in-process-generate-watcher.ts"],
+  "sourcesContent": ["/**\n * In-process generate watcher.\n *\n * Polls a structural-fingerprint function on a configurable interval and\n * invokes the supplied generator callback whenever the fingerprint changes.\n * The polling loop is identical to the legacy standalone watcher; the only\n * difference is that it now runs inside whatever process calls it\n * (typically `mercato server dev`), so the dev runtime no longer needs a\n * sidecar `mercato generate watch` Node process.\n *\n * Contract preserved 1:1 with the prior standalone watcher:\n *   - Default poll interval 1000 ms (minimum 250 ms).\n *   - One initial generator run unless `skipInitial` is true.\n *   - Concurrent regeneration requests are coalesced (running + pending).\n *   - Generator errors are logged but never crash the watcher.\n *   - The polling timer uses `.unref()` so it never blocks process exit.\n */\n\nexport type GenerateWatcherLogger = Pick<Console, 'log' | 'error'>\n\nexport type GenerateWatcherOptions = {\n  /**\n   * Function that returns the current structural fingerprint of the module\n   * tree. The watcher re-runs `runGenerators` whenever this value changes.\n   */\n  computeStructureChecksum: () => Promise<string> | string\n  /**\n   * Function that performs the actual regeneration work. Called once on\n   * startup (unless `skipInitial`) and again whenever the checksum changes.\n   * The `reason` argument is suitable for logging (`'initial'`,\n   * `'structure change'`, `'queued change'`).\n   */\n  runGenerators: (reason: string) => Promise<void>\n  /** Poll interval in milliseconds. Defaults to 1000. Clamped to >= 250. */\n  pollMs?: number\n  /** Skip the initial regeneration on startup. Defaults to false. */\n  skipInitial?: boolean\n  /** Suppress informational logs. Errors are always logged. */\n  quiet?: boolean\n  /** Logger override. Defaults to `console`. */\n  logger?: GenerateWatcherLogger\n}\n\nexport type GenerateWatcherHandle = {\n  /** Resolves when the watcher loop has stopped (after `close()`). */\n  readonly done: Promise<void>\n  /** Stop the polling loop and resolve `done`. Idempotent. */\n  close(): Promise<void>\n}\n\nconst MIN_POLL_MS = 250\nconst DEFAULT_POLL_MS = 1000\n\nfunction resolvePollMs(value: number | undefined): number {\n  if (typeof value !== 'number' || !Number.isFinite(value)) return DEFAULT_POLL_MS\n  const numeric = Math.floor(value)\n  return numeric >= MIN_POLL_MS ? numeric : DEFAULT_POLL_MS\n}\n\n/**\n * Start an in-process generate watcher. The returned handle exposes a\n * `close()` to stop polling and a `done` promise that resolves once the\n * watcher loop has finished.\n */\nexport function startInProcessGenerateWatcher(\n  options: GenerateWatcherOptions,\n): GenerateWatcherHandle {\n  const logger = options.logger ?? console\n  const quiet = options.quiet === true\n  const pollMs = resolvePollMs(options.pollMs)\n  const skipInitial = options.skipInitial === true\n  const { computeStructureChecksum, runGenerators } = options\n\n  let stopping = false\n  let pollTimer: ReturnType<typeof setTimeout> | null = null\n  let running = false\n  let pendingReason: string | null = null\n  let previousChecksum = ''\n  let doneResolve: (() => void) | null = null\n  const done = new Promise<void>((resolve) => {\n    doneResolve = resolve\n  })\n\n  async function runOnce(reason: string): Promise<void> {\n    if (running) {\n      pendingReason = reason\n      return\n    }\n    running = true\n    try {\n      if (!quiet) {\n        logger.log(`[generate:watch] Regenerating (${reason})...`)\n      }\n      await runGenerators(reason)\n      if (!quiet) {\n        logger.log('[generate:watch] Generators completed.')\n      }\n    } catch (error) {\n      const message = error instanceof Error ? error.message : String(error)\n      logger.error(`[generate:watch] Generation failed: ${message}`)\n    } finally {\n      running = false\n      if (pendingReason && !stopping) {\n        const queued = pendingReason\n        pendingReason = null\n        await runOnce(queued)\n      }\n    }\n  }\n\n  function scheduleNext(): void {\n    if (stopping) return\n    pollTimer = setTimeout(() => {\n      void (async () => {\n        if (stopping) return\n        try {\n          const nextChecksum = await computeStructureChecksum()\n          if (nextChecksum !== previousChecksum) {\n            previousChecksum = nextChecksum\n            await runOnce('structure change')\n          }\n        } catch (error) {\n          const message = error instanceof Error ? error.message : String(error)\n          logger.error(`[generate:watch] Poll cycle failed: ${message}`)\n        } finally {\n          if (!stopping) scheduleNext()\n        }\n      })()\n    }, pollMs)\n    pollTimer.unref?.()\n  }\n\n  void (async () => {\n    try {\n      if (!skipInitial) {\n        await runOnce('initial')\n      }\n      previousChecksum = await computeStructureChecksum()\n      if (!quiet) {\n        if (skipInitial) {\n          logger.log('[generate:watch] Skipping initial regeneration and watching the current generated state.')\n        }\n        logger.log(`[generate:watch] Watching structural module files every ${pollMs}ms (in-process).`)\n      }\n      scheduleNext()\n    } catch (error) {\n      const message = error instanceof Error ? error.message : String(error)\n      logger.error(`[generate:watch] Initial setup failed: ${message}`)\n      // Even if the initial bootstrap fails, schedule polling so a later\n      // checksum recovery still picks up the next change on disk.\n      scheduleNext()\n    }\n  })()\n\n  async function close(): Promise<void> {\n    if (stopping) {\n      await done\n      return\n    }\n    stopping = true\n    if (pollTimer) {\n      clearTimeout(pollTimer)\n      pollTimer = null\n    }\n    if (doneResolve) {\n      doneResolve()\n      doneResolve = null\n    }\n  }\n\n  return {\n    done,\n    close,\n  }\n}\n"],
+  "mappings": "AAkDA,MAAM,cAAc;AACpB,MAAM,kBAAkB;AAExB,SAAS,cAAc,OAAmC;AACxD,MAAI,OAAO,UAAU,YAAY,CAAC,OAAO,SAAS,KAAK,EAAG,QAAO;AACjE,QAAM,UAAU,KAAK,MAAM,KAAK;AAChC,SAAO,WAAW,cAAc,UAAU;AAC5C;AAOO,SAAS,8BACd,SACuB;AACvB,QAAM,SAAS,QAAQ,UAAU;AACjC,QAAM,QAAQ,QAAQ,UAAU;AAChC,QAAM,SAAS,cAAc,QAAQ,MAAM;AAC3C,QAAM,cAAc,QAAQ,gBAAgB;AAC5C,QAAM,EAAE,0BAA0B,cAAc,IAAI;AAEpD,MAAI,WAAW;AACf,MAAI,YAAkD;AACtD,MAAI,UAAU;AACd,MAAI,gBAA+B;AACnC,MAAI,mBAAmB;AACvB,MAAI,cAAmC;AACvC,QAAM,OAAO,IAAI,QAAc,CAAC,YAAY;AAC1C,kBAAc;AAAA,EAChB,CAAC;AAED,iBAAe,QAAQ,QAA+B;AACpD,QAAI,SAAS;AACX,sBAAgB;AAChB;AAAA,IACF;AACA,cAAU;AACV,QAAI;AACF,UAAI,CAAC,OAAO;AACV,eAAO,IAAI,kCAAkC,MAAM,MAAM;AAAA,MAC3D;AACA,YAAM,cAAc,MAAM;AAC1B,UAAI,CAAC,OAAO;AACV,eAAO,IAAI,wCAAwC;AAAA,MACrD;AAAA,IACF,SAAS,OAAO;AACd,YAAM,UAAU,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;AACrE,aAAO,MAAM,uCAAuC,OAAO,EAAE;AAAA,IAC/D,UAAE;AACA,gBAAU;AACV,UAAI,iBAAiB,CAAC,UAAU;AAC9B,cAAM,SAAS;AACf,wBAAgB;AAChB,cAAM,QAAQ,MAAM;AAAA,MACtB;AAAA,IACF;AAAA,EACF;AAEA,WAAS,eAAqB;AAC5B,QAAI,SAAU;AACd,gBAAY,WAAW,MAAM;AAC3B,YAAM,YAAY;AAChB,YAAI,SAAU;AACd,YAAI;AACF,gBAAM,eAAe,MAAM,yBAAyB;AACpD,cAAI,iBAAiB,kBAAkB;AACrC,+BAAmB;AACnB,kBAAM,QAAQ,kBAAkB;AAAA,UAClC;AAAA,QACF,SAAS,OAAO;AACd,gBAAM,UAAU,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;AACrE,iBAAO,MAAM,uCAAuC,OAAO,EAAE;AAAA,QAC/D,UAAE;AACA,cAAI,CAAC,SAAU,cAAa;AAAA,QAC9B;AAAA,MACF,GAAG;AAAA,IACL,GAAG,MAAM;AACT,cAAU,QAAQ;AAAA,EACpB;AAEA,QAAM,YAAY;AAChB,QAAI;AACF,UAAI,CAAC,aAAa;AAChB,cAAM,QAAQ,SAAS;AAAA,MACzB;AACA,yBAAmB,MAAM,yBAAyB;AAClD,UAAI,CAAC,OAAO;AACV,YAAI,aAAa;AACf,iBAAO,IAAI,0FAA0F;AAAA,QACvG;AACA,eAAO,IAAI,2DAA2D,MAAM,kBAAkB;AAAA,MAChG;AACA,mBAAa;AAAA,IACf,SAAS,OAAO;AACd,YAAM,UAAU,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;AACrE,aAAO,MAAM,0CAA0C,OAAO,EAAE;AAGhE,mBAAa;AAAA,IACf;AAAA,EACF,GAAG;AAEH,iBAAe,QAAuB;AACpC,QAAI,UAAU;AACZ,YAAM;AACN;AAAA,IACF;AACA,eAAW;AACX,QAAI,WAAW;AACb,mBAAa,SAAS;AACtB,kBAAY;AAAA,IACd;AACA,QAAI,aAAa;AACf,kBAAY;AACZ,oBAAc;AAAA,IAChB;AAAA,EACF;AAEA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,EACF;AACF;",
+  "names": []
+}

package/dist/mercato.js

@@ -16,6 +16,12 @@ import {
   resolveLazySchedulerRestart
 } from "./lib/auto-spawn-scheduler.js";
 import { startLazySchedulerSupervisor } from "./lib/scheduler-supervisor.js";
+import {
+  startInProcessGenerateWatcher
+} from "./lib/in-process-generate-watcher.js";
+import {
+  resolveGenerateWatcherMode
+} from "./lib/in-process-generate-watcher-mode.js";
 import { parseModuleInstallArgs } from "./lib/module-install-args.js";
 import { resolveNextBuildIdCandidate } from "./lib/next-build-id.js";
 import { acquireServerStartLock } from "./lib/server-start-lock.js";
@@ -414,6 +420,45 @@ async function runPostGenerateStructuralCachePurge(quiet) {
     }
   }
 }
+async function runGeneratorSuite(quiet) {
+  const { createResolver } = await import("./lib/resolver.js");
+  const {
+    generateEntityIds,
+    generateModuleRegistry,
+    generateModuleRegistryApp,
+    generateModuleRegistryCli,
+    generateModuleEntities,
+    generateModuleDi,
+    generateModulePackageSources,
+    generateOpenApi
+  } = await import("./lib/generators/index.js");
+  const resolver = createResolver();
+  await generateEntityIds({ resolver, quiet });
+  await generateModuleRegistry({ resolver, quiet });
+  await generateModuleRegistryApp({ resolver, quiet });
+  await generateModuleRegistryCli({ resolver, quiet });
+  await generateModuleEntities({ resolver, quiet });
+  await generateModuleDi({ resolver, quiet });
+  await generateModulePackageSources({ resolver, quiet });
+  await generateOpenApi({ resolver, quiet });
+}
+function createGenerateWatchChecksumFn() {
+  return async () => {
+    const { createResolver } = await import("./lib/resolver.js");
+    const { calculateStructureChecksum } = await import("./lib/utils.js");
+    const resolver = createResolver();
+    const tracked = /* @__PURE__ */ new Set([
+      path.join(resolver.getAppDir(), "src", "modules.ts"),
+      path.join(resolver.getAppDir(), "src", "modules")
+    ]);
+    for (const entry of resolver.loadEnabledModules()) {
+      const roots = resolver.getModulePaths(entry);
+      tracked.add(roots.appBase);
+      tracked.add(roots.pkgBase);
+    }
+    return calculateStructureChecksum(Array.from(tracked));
+  };
+}
 async function buildAllModules() {
   const modules = getCliModules();
   let appCli = [];
@@ -1204,28 +1249,6 @@ async function run(argv = process.argv) {
       }
     ]
   });
-  const runGeneratorSuite = async (quiet) => {
-    const { createResolver } = await import("./lib/resolver.js");
-    const {
-      generateEntityIds,
-      generateModuleRegistry,
-      generateModuleRegistryApp,
-      generateModuleRegistryCli,
-      generateModuleEntities,
-      generateModuleDi,
-      generateModulePackageSources,
-      generateOpenApi
-    } = await import("./lib/generators/index.js");
-    const resolver = createResolver();
-    await generateEntityIds({ resolver, quiet });
-    await generateModuleRegistry({ resolver, quiet });
-    await generateModuleRegistryApp({ resolver, quiet });
-    await generateModuleRegistryCli({ resolver, quiet });
-    await generateModuleEntities({ resolver, quiet });
-    await generateModuleDi({ resolver, quiet });
-    await generateModulePackageSources({ resolver, quiet });
-    await generateOpenApi({ resolver, quiet });
-  };
   all.push({
     id: "generate",
     cli: [
@@ -1242,70 +1265,40 @@ async function run(argv = process.argv) {
       {
         command: "watch",
         run: async (args) => {
-          const { createResolver } = await import("./lib/resolver.js");
-          const { calculateStructureChecksum } = await import("./lib/utils.js");
           const quiet = args.includes("--quiet") || args.includes("-q");
           const skipInitial = args.includes("--skip-initial");
           const intervalArg = args.find((arg) => arg.startsWith("--interval="));
           const parsedInterval = intervalArg ? Number.parseInt(intervalArg.split("=")[1] ?? "", 10) : NaN;
           const intervalMs = Number.isFinite(parsedInterval) && parsedInterval >= 250 ? parsedInterval : 1e3;
-          let previousChecksum = "";
-          let running = false;
-          let pending = false;
-          const getTrackedPaths = () => {
-            const resolver = createResolver();
-            const tracked = /* @__PURE__ */ new Set([
-              path.join(resolver.getAppDir(), "src", "modules.ts"),
-              path.join(resolver.getAppDir(), "src", "modules")
-            ]);
-            for (const entry of resolver.loadEnabledModules()) {
-              const roots = resolver.getModulePaths(entry);
-              tracked.add(roots.appBase);
-              tracked.add(roots.pkgBase);
-            }
-            return Array.from(tracked);
-          };
-          const runWatchGeneration = async (reason) => {
-            if (running) {
-              pending = true;
-              return;
-            }
-            running = true;
-            try {
-              if (!quiet) {
-                console.log(`[generate:watch] Regenerating (${reason})...`);
-              }
+          const watcher = startInProcessGenerateWatcher({
+            pollMs: intervalMs,
+            skipInitial,
+            quiet,
+            computeStructureChecksum: createGenerateWatchChecksumFn(),
+            runGenerators: async () => {
               await runGeneratorSuite(true);
               await runPostGenerateStructuralCachePurge(true);
-              if (!quiet) {
-                console.log("[generate:watch] Generators completed.");
-              }
-            } catch (error) {
-              console.error("[generate:watch] Generation failed:", error instanceof Error ? error.message : error);
-            } finally {
-              running = false;
-              if (pending) {
-                pending = false;
-                await runWatchGeneration("queued change");
-              }
             }
+          });
+          const shutdownSignals = ["SIGINT", "SIGTERM"];
+          let shuttingDown = false;
+          const handleSignal = () => {
+            if (shuttingDown) return;
+            shuttingDown = true;
+            void watcher.close();
           };
-          if (!skipInitial) {
-            await runWatchGeneration("initial");
+          for (const signal of shutdownSignals) {
+            process.once(signal, handleSignal);
           }
-          previousChecksum = calculateStructureChecksum(getTrackedPaths());
-          if (!quiet) {
-            if (skipInitial) {
-              console.log("[generate:watch] Skipping initial regeneration and watching the current generated state.");
+          const keepAlive = setInterval(() => {
+          }, 1 << 30);
+          try {
+            await watcher.done;
+          } finally {
+            clearInterval(keepAlive);
+            for (const signal of shutdownSignals) {
+              process.removeListener(signal, handleSignal);
             }
-            console.log(`[generate:watch] Watching structural module files every ${intervalMs}ms`);
-          }
-          while (true) {
-            await new Promise((resolve) => setTimeout(resolve, intervalMs));
-            const nextChecksum = calculateStructureChecksum(getTrackedPaths());
-            if (nextChecksum === previousChecksum) continue;
-            previousChecksum = nextChecksum;
-            await runWatchGeneration("structure change");
           }
         }
       },
@@ -1400,6 +1393,8 @@ async function run(argv = process.argv) {
           let envChangePromiseResolve = null;
           let activeLazySupervisor = null;
           let activeLazySchedulerSupervisor = null;
+          let activeGenerateWatcher = null;
+          const generateWatcherMode = resolveGenerateWatcherMode(process.env);
           const envReloader = createDevEnvReloader(appDir, process.env, initialProcessEnvironmentEntries);
           function cleanup() {
             console.log("[server] Shutting down...");
@@ -1414,6 +1409,9 @@ async function run(argv = process.argv) {
             if (activeLazySchedulerSupervisor) {
               void activeLazySchedulerSupervisor.close().catch(() => void 0);
             }
+            if (activeGenerateWatcher) {
+              void activeGenerateWatcher.close().catch(() => void 0);
+            }
           }
           async function cleanupAndWait() {
             cleanup();
@@ -1439,6 +1437,13 @@ async function run(argv = process.argv) {
               }
               activeLazySchedulerSupervisor = null;
             }
+            if (activeGenerateWatcher) {
+              try {
+                await activeGenerateWatcher.close();
+              } catch {
+              }
+              activeGenerateWatcher = null;
+            }
             const lockFile = path.join(appDir, ".mercato", "next", "dev", "lock");
             try {
               fs.unlinkSync(lockFile);
@@ -1569,6 +1574,25 @@ async function run(argv = process.argv) {
                   managedExitPromises.push(waitForManagedProcessExit(schedulerProcess, "Scheduler polling engine"));
                 }
               }
+              if (generateWatcherMode === "in-process") {
+                console.log("[server] In-process generate watcher enabled \u2014 structural changes will regenerate without a sidecar process.");
+                activeGenerateWatcher = startInProcessGenerateWatcher({
+                  // `--skip-initial` equivalent: `yarn dev` always runs an
+                  // initial `mercato generate` before reaching the server
+                  // command, so the watcher must not re-run generators at
+                  // boot time. Otherwise dev startup pays a generator pass
+                  // twice in a row.
+                  skipInitial: true,
+                  quiet: false,
+                  computeStructureChecksum: createGenerateWatchChecksumFn(),
+                  runGenerators: async () => {
+                    await runGeneratorSuite(true);
+                    await runPostGenerateStructuralCachePurge(true);
+                  }
+                });
+              } else {
+                console.log("[server] Legacy out-of-process generate watcher selected via OM_DEV_GENERATE_WATCH_MODE=legacy \u2014 expect the dev orchestrator to spawn `mercato generate watch --skip-initial`.");
+              }
               const firstExit = await Promise.race(managedExitPromises);
               await cleanupAndWait();
               envChangePromiseResolve = null;