@simplysm/sd-cli 13.0.93 → 13.0.95

package/src/utils/esbuild-config.ts

@@ -5,6 +5,9 @@ import { createRequire } from "module";
 import type esbuild from "esbuild";
 import { solidPlugin } from "esbuild-plugin-solid";
 import type { TypecheckEnv } from "./tsconfig";
+import { consola } from "consola";
+
+const logger = consola.withTag("sd:cli:esbuild-config");
 
 /**
  * Write only changed files from esbuild outputFiles to disk
@@ -65,6 +68,8 @@ export interface ServerEsbuildOptions {
   env?: Record<string, string>;
   /** External modules to exclude from bundle */
   external?: string[];
+  /** Dev mode: skip minification for faster builds */
+  dev?: boolean;
 }
 
 /**
@@ -102,7 +107,7 @@ export function createLibraryEsbuildOptions(options: LibraryEsbuildOptions): esb
     bundle: false,
     write: false,
     tsconfigRaw: {
-      compilerOptions: options.compilerOptions as esbuild.TsconfigRaw["compilerOptions"],
+      compilerOptions: toEsbuildTsconfigRaw(options.compilerOptions),
     },
     logLevel: "silent",
     plugins,
@@ -130,7 +135,7 @@ export function createServerEsbuildOptions(options: ServerEsbuildOptions): esbui
     entryPoints: options.entryPoints,
     outdir: path.join(options.pkgDir, "dist"),
     format: "esm",
-    minify: true,
+    minify: options.dev !== true,
     platform: "node",
     target: "node20",
     bundle: true,
@@ -140,12 +145,64 @@ export function createServerEsbuildOptions(options: ServerEsbuildOptions): esbui
     external: options.external,
     define,
     tsconfigRaw: {
-      compilerOptions: options.compilerOptions as esbuild.TsconfigRaw["compilerOptions"],
+      compilerOptions: toEsbuildTsconfigRaw(options.compilerOptions),
     },
     logLevel: "silent",
   };
 }
 
+// TypeScript ScriptTarget enum → esbuild target string
+const TARGET_MAP: Record<number, string> = {
+  0: "es3", 1: "es5", 2: "es2015", 3: "es2016", 4: "es2017",
+  5: "es2018", 6: "es2019", 7: "es2020", 8: "es2021", 9: "es2022",
+  10: "es2023", 11: "es2024", 99: "esnext",
+};
+
+// TypeScript JsxEmit enum → esbuild jsx string
+const JSX_MAP: Record<number, string> = {
+  1: "preserve", 2: "react", 3: "react-native", 4: "react-jsx", 5: "react-jsxdev",
+};
+
+// TypeScript ModuleKind enum → string
+const MODULE_MAP: Record<number, string> = {
+  0: "none", 1: "commonjs", 2: "amd", 3: "umd", 4: "system",
+  5: "es2015", 6: "es2020", 7: "es2022", 99: "esnext",
+  100: "node16", 199: "nodenext",
+};
+
+// TypeScript ModuleResolutionKind enum → string
+const MODULE_RESOLUTION_MAP: Record<number, string> = {
+  1: "node10", 2: "node16", 3: "nodenext", 100: "bundler",
+};
+
+/**
+ * Convert TypeScript's ts.CompilerOptions to esbuild-compatible tsconfigRaw compilerOptions.
+ *
+ * TypeScript uses numeric enum values (e.g., target: 99) while esbuild expects
+ * string values (e.g., "esnext"). This converts known enum fields and passes
+ * everything else through as-is.
+ */
+function toEsbuildTsconfigRaw(
+  compilerOptions: Record<string, unknown>,
+): esbuild.TsconfigRaw["compilerOptions"] {
+  const result = { ...compilerOptions };
+
+  if (typeof result["target"] === "number") {
+    result["target"] = TARGET_MAP[result["target"]] ?? "esnext";
+  }
+  if (typeof result["jsx"] === "number") {
+    result["jsx"] = JSX_MAP[result["jsx"]];
+  }
+  if (typeof result["module"] === "number") {
+    result["module"] = MODULE_MAP[result["module"]];
+  }
+  if (typeof result["moduleResolution"] === "number") {
+    result["moduleResolution"] = MODULE_RESOLUTION_MAP[result["moduleResolution"]];
+  }
+
+  return result as esbuild.TsconfigRaw["compilerOptions"];
+}
+
 /**
  * Extract TypecheckEnv from build target
  *
@@ -183,6 +240,7 @@ function scanDependencyTree(
   try {
     pkgJsonPath = req.resolve(`${pkgName}/package.json`);
   } catch {
+    logger.debug(`[scanDependencyTree] Could not resolve: ${pkgName}`);
     return;
   }
 
@@ -196,7 +254,13 @@ function scanDependencyTree(
   }
 
   // Recursively traverse sub-dependencies
-  for (const dep of Object.keys(pkgJson.dependencies ?? {})) {
+  const subDeps = Object.keys(pkgJson.dependencies ?? {});
+  if (subDeps.length > 0) {
+    logger.debug(
+      `[scanDependencyTree] ${pkgName}: traversing ${String(subDeps.length)} sub-dependencies`,
+    );
+  }
+  for (const dep of subDeps) {
     scanDependencyTree(dep, depDir, external, visited, collector);
   }
 }
@@ -212,7 +276,12 @@ export function collectUninstalledOptionalPeerDeps(pkgDir: string): string[] {
   const visited = new Set<string>();
 
   const pkgJson = JSON.parse(readFileSync(path.join(pkgDir, "package.json"), "utf-8")) as PkgJson;
-  for (const dep of Object.keys(pkgJson.dependencies ?? {})) {
+  const deps = Object.keys(pkgJson.dependencies ?? {});
+  logger.debug(
+    `[optionalPeerDeps] Scanning ${String(deps.length)} top-level dependencies...`,
+  );
+
+  for (const dep of deps) {
     scanDependencyTree(dep, pkgDir, external, visited, (_pkgName, depDir, depPkgJson) => {
       const found: string[] = [];
       if (depPkgJson.peerDependenciesMeta != null) {
@@ -232,6 +301,9 @@ export function collectUninstalledOptionalPeerDeps(pkgDir: string): string[] {
     });
   }
 
+  logger.debug(
+    `[optionalPeerDeps] Done: visited ${String(visited.size)} packages, found ${String(external.size)} externals`,
+  );
   return [...external];
 }
 
@@ -250,7 +322,12 @@ export function collectNativeModuleExternals(pkgDir: string): string[] {
   const visited = new Set<string>();
 
   const pkgJson = JSON.parse(readFileSync(path.join(pkgDir, "package.json"), "utf-8")) as PkgJson;
-  for (const dep of Object.keys(pkgJson.dependencies ?? {})) {
+  const deps = Object.keys(pkgJson.dependencies ?? {});
+  logger.debug(
+    `[nativeModules] Scanning ${String(deps.length)} top-level dependencies...`,
+  );
+
+  for (const dep of deps) {
     scanDependencyTree(dep, pkgDir, external, visited, (pkgName, depDir, _pkgJson) => {
       const found: string[] = [];
       // Detect native modules by checking for binding.gyp
@@ -261,6 +338,9 @@ export function collectNativeModuleExternals(pkgDir: string): string[] {
     });
   }
 
+  logger.debug(
+    `[nativeModules] Done: visited ${String(visited.size)} packages, found ${String(external.size)} externals`,
+  );
   return [...external];
 }
 

package/src/utils/package-utils.ts

@@ -1,7 +1,10 @@
 import path from "path";
 import fs from "fs";
+import { consola } from "consola";
 import type { SdPackageConfig } from "../sd-config.types";
 
+const logger = consola.withTag("sd:cli:package-utils");
+
 /**
  * Walk up from import.meta.dirname to find package.json and return package root
  */
@@ -25,6 +28,8 @@ export function collectDeps(
   cwd: string,
   replaceDepsConfig?: Record<string, string>,
 ): DepsResult {
+  const startTime = performance.now();
+  logger.debug("[collectDeps] Starting dependency collection...");
   const rootPkgJsonPath = path.join(cwd, "package.json");
   const rootPkgJson = JSON.parse(fs.readFileSync(rootPkgJsonPath, "utf-8")) as { name: string };
   const scopeMatch = rootPkgJson.name.match(/^(@[^/]+)\//);
@@ -80,6 +85,9 @@ export function collectDeps(
   }
 
   traverse(pkgDir);
+  logger.debug(
+    `[collectDeps] Done: workspace=${String(workspaceDeps.length)}, replace=${String(replaceDeps.length)} (${Math.round(performance.now() - startTime)}ms)`,
+  );
   return { workspaceDeps, replaceDeps };
 }
 

package/src/utils/replace-deps.ts

@@ -3,6 +3,8 @@ import path from "path";
 import { glob } from "glob";
 import { consola } from "consola";
 import { fsx, pathx, FsWatcher } from "@simplysm/core-node";
+import { exec } from "child_process";
+import { promisify } from "util";
 
 /**
  * Match glob patterns from replaceDeps config with target package list
@@ -258,6 +260,24 @@ export async function setupReplaceDeps(
   }
 
   logger.success(`Replaced ${setupCount} dependencies`);
+
+  // Run postinstall scripts from replaced packages
+  for (const { targetName, resolvedSourcePath, actualTargetPath } of entries) {
+    const sourcePkgJsonPath = path.join(resolvedSourcePath, "package.json");
+    try {
+      const pkgJson = JSON.parse(await fs.promises.readFile(sourcePkgJsonPath, "utf-8"));
+      const postinstall = pkgJson.scripts?.postinstall as string | undefined;
+      if (postinstall == null) continue;
+
+      logger.start(`Running postinstall for ${targetName}`);
+      await promisify(exec)(postinstall, { cwd: actualTargetPath });
+      logger.success(`postinstall done: ${targetName}`);
+    } catch (err) {
+      logger.error(
+        `postinstall failed (${targetName}): ${err instanceof Error ? err.message : err}`,
+      );
+    }
+  }
 }
 
 /**

package/src/utils/worker-utils.ts

@@ -1,4 +1,17 @@
-import type { ConsolaInstance } from "consola";
+import consola, { type ConsolaInstance, LogLevels } from "consola";
+
+/**
+ * Apply debug log level in worker threads
+ *
+ * Checks the SD_DEBUG environment variable (set by --debug flag in main process)
+ * and applies debug log level to consola in the current worker thread.
+ * Must be called at worker module top level.
+ */
+export function applyDebugLevel(): void {
+  if (process.env["SD_DEBUG"] === "true") {
+    consola.level = LogLevels.debug;
+  }
+}
 
 /**
  * Register cleanup handlers for worker process shutdown signals

package/src/workers/client.worker.ts

@@ -8,7 +8,9 @@ import type { SdClientPackageConfig } from "../sd-config.types";
 import { parseRootTsconfig, getCompilerOptionsForPackage } from "../utils/tsconfig";
 import { createViteConfig } from "../utils/vite-config";
 import { collectDeps } from "../utils/package-utils";
-import { registerCleanupHandlers, createOnceGuard } from "../utils/worker-utils";
+import { registerCleanupHandlers, createOnceGuard, applyDebugLevel } from "../utils/worker-utils";
+
+applyDebugLevel();
 
 //#region Types
 

package/src/workers/dts.worker.ts

@@ -11,7 +11,9 @@ import {
   type TypecheckEnv,
 } from "../utils/tsconfig";
 import { serializeDiagnostic, type SerializedDiagnostic } from "../utils/typecheck-serialization";
-import { createOnceGuard, registerCleanupHandlers } from "../utils/worker-utils";
+import { createOnceGuard, registerCleanupHandlers, applyDebugLevel } from "../utils/worker-utils";
+
+applyDebugLevel();
 
 //#region Types
 

package/src/workers/library.worker.ts

@@ -14,7 +14,9 @@ import {
   getTypecheckEnvFromTarget,
   writeChangedOutputFiles,
 } from "../utils/esbuild-config";
-import { registerCleanupHandlers, createOnceGuard } from "../utils/worker-utils";
+import { registerCleanupHandlers, createOnceGuard, applyDebugLevel } from "../utils/worker-utils";
+
+applyDebugLevel();
 
 //#region Types
 

package/src/workers/server-runtime.worker.ts

@@ -4,7 +4,7 @@ import { err as errNs } from "@simplysm/core-common";
 import { consola } from "consola";
 import net from "net";
 import { pathToFileURL } from "url";
-import { registerCleanupHandlers } from "../utils/worker-utils";
+import { registerCleanupHandlers, applyDebugLevel } from "../utils/worker-utils";
 
 //#region Types
 
@@ -40,6 +40,8 @@ export interface ServerRuntimeWorkerEvents extends Record<string, unknown> {
 
 //#endregion
 
+applyDebugLevel();
+
 const logger = consola.withTag("sd:cli:server-runtime:worker");
 
 /** Server instance (to be cleaned up) */
@@ -109,8 +111,13 @@ async function findAvailablePort(startPort: number, maxRetries = 20): Promise<nu
  */
 async function start(info: ServerRuntimeStartInfo): Promise<void> {
   try {
+    const startTime = performance.now();
+
     // Import main.js (must export a server instance)
+    logger.debug("[start] Importing main.js...");
+    let stepStart = performance.now();
     const module = await import(pathToFileURL(info.mainJsPath).href);
+    logger.debug(`[start] main.js imported (${Math.round(performance.now() - stepStart)}ms)`);
     const server = module.server;
 
     if (server == null) {
@@ -121,15 +128,28 @@ async function start(info: ServerRuntimeStartInfo): Promise<void> {
     serverInstance = server;
 
     // Find available port (auto-increment on port conflict)
+    logger.debug("[start] Finding available port...");
+    stepStart = performance.now();
     const originalPort = server.options.port;
     const availablePort = await findAvailablePort(originalPort);
     if (availablePort !== originalPort) {
       logger.info(`Port ${originalPort} in use, changing to ${availablePort}`);
       server.options.port = availablePort;
     }
+    logger.debug(
+      `[start] Port ${String(availablePort)} available (${Math.round(performance.now() - stepStart)}ms)`,
+    );
 
     // Configure Vite proxy (only if clientPorts exists)
-    for (const [name, port] of Object.entries(info.clientPorts)) {
+    const clientEntries = Object.entries(info.clientPorts);
+    if (clientEntries.length > 0) {
+      logger.debug(
+        `[start] Configuring ${String(clientEntries.length)} Vite proxy(s)...`,
+      );
+      stepStart = performance.now();
+    }
+    for (const [name, port] of clientEntries) {
+      logger.debug(`[start] Registering proxy: /${name} -> http://127.0.0.1:${String(port)}`);
       await server.fastify.register(proxy, {
         prefix: `/${name}`,
         upstream: `http://127.0.0.1:${port}`,
@@ -137,9 +157,21 @@ async function start(info: ServerRuntimeStartInfo): Promise<void> {
         websocket: true,
       });
     }
+    if (clientEntries.length > 0) {
+      logger.debug(
+        `[start] Proxies configured (${Math.round(performance.now() - stepStart)}ms)`,
+      );
+    }
 
     // Start server
+    logger.debug("[start] Starting server listen...");
+    stepStart = performance.now();
     await server.listen();
+    logger.debug(`[start] Server listening (${Math.round(performance.now() - stepStart)}ms)`);
+
+    logger.debug(
+      `[start] Total runtime startup: ${Math.round(performance.now() - startTime)}ms`,
+    );
 
     sender.send("serverReady", { port: server.options.port });
   } catch (err) {

package/src/workers/server.worker.ts

@@ -16,7 +16,7 @@ import {
   collectNativeModuleExternals,
   writeChangedOutputFiles,
 } from "../utils/esbuild-config";
-import { registerCleanupHandlers, createOnceGuard } from "../utils/worker-utils";
+import { registerCleanupHandlers, createOnceGuard, applyDebugLevel } from "../utils/worker-utils";
 import { collectDeps } from "../utils/package-utils";
 import { copyPublicFiles, watchPublicFiles } from "../utils/copy-public";
 
@@ -101,6 +101,8 @@ export interface ServerWorkerEvents extends Record<string, unknown> {
 
 //#region Resource Management
 
+applyDebugLevel();
+
 const logger = consola.withTag("sd:cli:server:worker");
 
 /** esbuild build context (to be cleaned up) */
@@ -151,8 +153,20 @@ async function cleanup(): Promise<void> {
  * 3. Manually specified in sd.config.ts
  */
 function collectAllExternals(pkgDir: string, manualExternals?: string[]): string[] {
+  logger.debug("[externals] Scanning optional peer deps...");
+  let stepStart = performance.now();
   const optionalPeerDeps = collectUninstalledOptionalPeerDeps(pkgDir);
+  logger.debug(
+    `[externals] Optional peer deps done: ${String(optionalPeerDeps.length)} found (${Math.round(performance.now() - stepStart)}ms)`,
+  );
+
+  logger.debug("[externals] Scanning native modules...");
+  stepStart = performance.now();
   const nativeModules = collectNativeModuleExternals(pkgDir);
+  logger.debug(
+    `[externals] Native modules done: ${String(nativeModules.length)} found (${Math.round(performance.now() - stepStart)}ms)`,
+  );
+
   const manual = manualExternals ?? [];
 
   const merged = [...new Set([...optionalPeerDeps, ...nativeModules, ...manual])];
@@ -307,20 +321,39 @@ async function build(info: ServerBuildInfo): Promise<ServerBuildResult> {
 
   try {
     // Parse tsconfig
+    logger.debug("[build] Parsing tsconfig...");
+    let stepStart = performance.now();
     const parsedConfig = parseRootTsconfig(info.cwd);
+    logger.debug(`[build] tsconfig parsed (${Math.round(performance.now() - stepStart)}ms)`);
+
+    stepStart = performance.now();
     const entryPoints = getPackageSourceFiles(info.pkgDir, parsedConfig);
+    logger.debug(
+      `[build] Found ${String(entryPoints.length)} source files (${Math.round(performance.now() - stepStart)}ms)`,
+    );
 
     // Server target is node environment
+    logger.debug("[build] Getting compiler options...");
+    stepStart = performance.now();
     const compilerOptions = await getCompilerOptionsForPackage(
       parsedConfig.options,
       "node",
       info.pkgDir,
     );
+    logger.debug(
+      `[build] Compiler options ready (${Math.round(performance.now() - stepStart)}ms)`,
+    );
 
     // Collect all externals (optional peer deps + native modules + manual)
+    logger.debug("[build] Collecting externals...");
+    stepStart = performance.now();
     const external = collectAllExternals(info.pkgDir, info.externals);
+    logger.debug(
+      `[build] Collected ${String(external.length)} externals (${Math.round(performance.now() - stepStart)}ms)`,
+    );
 
     // One-time esbuild
+    logger.debug("[build] Creating esbuild options...");
     const esbuildOptions = createServerEsbuildOptions({
       pkgDir: info.pkgDir,
       entryPoints,
@@ -329,17 +362,30 @@ async function build(info: ServerBuildInfo): Promise<ServerBuildResult> {
       external,
     });
 
+    logger.debug("[build] Running esbuild...");
+    stepStart = performance.now();
     const result = await esbuild.build(esbuildOptions);
+    logger.debug(`[build] esbuild done (${Math.round(performance.now() - stepStart)}ms)`);
 
     // Generate .config.json
     const confDistPath = path.join(info.pkgDir, "dist", ".config.json");
     fs.writeFileSync(confDistPath, JSON.stringify(info.configs ?? {}, undefined, 2));
 
     // Copy public/ to dist/ (production build: no public-dev)
+    logger.debug("[build] Copying public files...");
+    stepStart = performance.now();
     await copyPublicFiles(info.pkgDir, false);
+    logger.debug(
+      `[build] Public files copied (${Math.round(performance.now() - stepStart)}ms)`,
+    );
 
     // Generate production files (package.json, mise.toml, openssl.cnf, pm2.config.cjs)
+    logger.debug("[build] Generating production files...");
+    stepStart = performance.now();
     generateProductionFiles(info, external);
+    logger.debug(
+      `[build] Production files generated (${Math.round(performance.now() - stepStart)}ms)`,
+    );
 
     const errors = result.errors.map((e) => e.text);
     const warnings = result.warnings.map((w) => w.text);
@@ -368,26 +414,53 @@ async function createAndBuildContext(
   isFirstBuild: boolean,
   resolveFirstBuild?: () => void,
 ): Promise<esbuild.BuildContext> {
+  const contextStart = performance.now();
+
+  logger.debug("[context] Parsing tsconfig...");
+  let stepStart = performance.now();
   const parsedConfig = parseRootTsconfig(info.cwd);
+  logger.debug(`[context] tsconfig parsed (${Math.round(performance.now() - stepStart)}ms)`);
+
+  stepStart = performance.now();
   const entryPoints = getPackageSourceFiles(info.pkgDir, parsedConfig);
+  logger.debug(
+    `[context] Found ${String(entryPoints.length)} source files (${Math.round(performance.now() - stepStart)}ms)`,
+  );
+
+  logger.debug("[context] Getting compiler options...");
+  stepStart = performance.now();
   const compilerOptions = await getCompilerOptionsForPackage(
     parsedConfig.options,
     "node",
     info.pkgDir,
   );
+  logger.debug(
+    `[context] Compiler options ready (${Math.round(performance.now() - stepStart)}ms)`,
+  );
 
   const mainJsPath = path.join(info.pkgDir, "dist", "main.js");
+
+  logger.debug("[context] Collecting externals...");
+  stepStart = performance.now();
   const external = collectAllExternals(info.pkgDir, info.externals);
+  logger.debug(
+    `[context] Collected ${String(external.length)} externals (${Math.round(performance.now() - stepStart)}ms)`,
+  );
+
+  logger.debug("[context] Creating esbuild options (dev mode, minify disabled)...");
   const baseOptions = createServerEsbuildOptions({
     pkgDir: info.pkgDir,
     entryPoints,
     compilerOptions,
     env: info.env,
     external,
+    dev: true,
   });
 
   let isBuildFirstTime = isFirstBuild;
 
+  logger.debug("[context] Creating esbuild context...");
+  stepStart = performance.now();
   const context = await esbuild.context({
     ...baseOptions,
     metafile: true,
@@ -396,14 +469,43 @@ async function createAndBuildContext(
       {
         name: "watch-notify",
         setup(pluginBuild) {
+          let consecutiveStarts = 0;
+
           pluginBuild.onStart(() => {
-            sender.send("buildStart", {});
+            consecutiveStarts++;
+            logger.debug(`[esbuild] onStart (#${String(consecutiveStarts)})`);
+
+            if (consecutiveStarts > 3) {
+              // esbuild context.rebuild() silently retries on build errors (esbuild bug).
+              // Stop the retry loop and diagnose via esbuild.build().
+              void context.dispose().catch(() => {});
+
+              void esbuild
+                .build(baseOptions)
+                .catch((err: unknown) => {
+                  sender.send("build", {
+                    success: false,
+                    mainJsPath,
+                    errors: [errNs.message(err)],
+                  });
+                })
+                .finally(() => {
+                  resolveFirstBuild?.();
+                });
+            } else {
+              sender.send("buildStart", {});
+            }
           });
 
           pluginBuild.onEnd(async (result) => {
+            consecutiveStarts = 0;
+
             // Save metafile
             if (result.metafile != null) {
               lastMetafile = result.metafile;
+              logger.debug(
+                `[esbuild] Metafile: ${String(Object.keys(result.metafile.inputs).length)} inputs, ${String(Object.keys(result.metafile.outputs).length)} outputs`,
+              );
             }
 
             const errors = result.errors.map((e) => e.text);
@@ -413,7 +515,11 @@ async function createAndBuildContext(
             // Write output files and check for changes
             let hasOutputChange = false;
             if (success && result.outputFiles != null) {
+              const writeStart = performance.now();
               hasOutputChange = await writeChangedOutputFiles(result.outputFiles);
+              logger.debug(
+                `[esbuild] Output files written: changed=${String(hasOutputChange)}, count=${String(result.outputFiles.length)} (${Math.round(performance.now() - writeStart)}ms)`,
+              );
             }
 
             if (isBuildFirstTime && success) {
@@ -442,8 +548,33 @@ async function createAndBuildContext(
       },
     ],
   });
+  logger.debug(
+    `[context] esbuild context created (${Math.round(performance.now() - stepStart)}ms)`,
+  );
+
+  logger.debug("[context] Running initial rebuild...");
+  stepStart = performance.now();
+  const progressTimer = setInterval(() => {
+    logger.debug(
+      `[esbuild] Still building... (${Math.round((performance.now() - stepStart) / 1000)}s elapsed)`,
+    );
+  }, 5000);
+  try {
+    await context.rebuild();
+  } catch {
+    // context.rebuild() may reject with "Cannot rebuild" when disposed
+    // from onStart guard. The real error is reported via esbuild.build()
+    // fallback in onStart, so we suppress this rejection.
+  } finally {
+    clearInterval(progressTimer);
+  }
+  logger.debug(
+    `[context] Initial rebuild done (${Math.round(performance.now() - stepStart)}ms)`,
+  );
 
-  await context.rebuild();
+  logger.debug(
+    `[context] Total context setup: ${Math.round(performance.now() - contextStart)}ms`,
+  );
 
   return context;
 }
@@ -457,6 +588,9 @@ async function startWatch(info: ServerWatchInfo): Promise<void> {
   guardStartWatch();
 
   try {
+    const watchStart = performance.now();
+    logger.debug("[startWatch] Starting watch setup...");
+
     // Promise to wait for first build completion
     let resolveFirstBuild!: () => void;
     const firstBuildPromise = new Promise<void>((resolve) => {
@@ -464,16 +598,36 @@ async function startWatch(info: ServerWatchInfo): Promise<void> {
     });
 
     // Create initial esbuild context and build
+    logger.debug("[startWatch] Creating initial esbuild context...");
+    let stepStart = performance.now();
     esbuildContext = await createAndBuildContext(info, true, resolveFirstBuild);
+    logger.debug(
+      `[startWatch] Initial context created (${Math.round(performance.now() - stepStart)}ms)`,
+    );
 
     // Wait for first build completion
+    logger.debug("[startWatch] Waiting for first build completion...");
+    stepStart = performance.now();
     await firstBuildPromise;
+    logger.debug(
+      `[startWatch] First build completed (${Math.round(performance.now() - stepStart)}ms)`,
+    );
 
     // Watch public/ and public-dev/ (dev mode includes public-dev)
+    logger.debug("[startWatch] Setting up public file watcher...");
+    stepStart = performance.now();
     publicWatcher = await watchPublicFiles(info.pkgDir, true);
+    logger.debug(
+      `[startWatch] Public watcher ready (${Math.round(performance.now() - stepStart)}ms)`,
+    );
 
     // Collect watch paths based on dependencies
+    logger.debug("[startWatch] Collecting dependencies for watch paths...");
+    stepStart = performance.now();
     const { workspaceDeps, replaceDeps } = collectDeps(info.pkgDir, info.cwd, info.replaceDeps);
+    logger.debug(
+      `[startWatch] Deps collected: workspace=${String(workspaceDeps.length)}, replace=${String(replaceDeps.length)} (${Math.round(performance.now() - stepStart)}ms)`,
+    );
 
     const watchPaths: string[] = [];
 
@@ -496,7 +650,15 @@ async function startWatch(info: ServerWatchInfo): Promise<void> {
     }
 
     // Start FsWatcher
+    logger.debug(`[startWatch] Starting FsWatcher with ${String(watchPaths.length)} paths...`);
+    stepStart = performance.now();
     srcWatcher = await FsWatcher.watch(watchPaths);
+    logger.debug(
+      `[startWatch] FsWatcher ready (${Math.round(performance.now() - stepStart)}ms)`,
+    );
+    logger.debug(
+      `[startWatch] Total watch setup: ${Math.round(performance.now() - watchStart)}ms`,
+    );
 
     // Handle file changes
     srcWatcher.onChange({ delay: 300 }, async (changes) => {