@simplysm/sd-cli 14.0.29 → 14.0.32

package/src/electron/electron.ts

@@ -4,7 +4,7 @@ import module from "module";
 import { cpx, fsx, pathx } from "@simplysm/core-node";
 import { consola, LogLevels } from "consola";
 import type { NpmConfig, SdElectronConfig } from "../sd-config.types.js";
-import { createEnvBanner } from "../utils/esbuild-config.js";
+import { createEnvBanner } from "../esbuild/esbuild-config.js";
 
 export class Electron {
   private static readonly _logger = consola.withTag("sd:cli:electron");
@@ -93,14 +93,7 @@ export class Electron {
     await this._copyPublicAssets();
 
     const esbuild = await import("esbuild");
-    const entryPoint = pathx.posixResolve(this._pkgPath, "src/electron-main.ts");
-
-    if (!(await fsx.exists(entryPoint))) {
-      throw new Error(`electron-main.ts 파일을 찾을 수 없습니다: ${entryPoint}`);
-    }
-
-    const builtinModules = module.builtinModules.flatMap((m) => [m, `node:${m}`]);
-    const reinstallDeps = this._config.reinstallDependencies ?? [];
+    const baseOptions = await this._createBaseEsbuildOptions({ ELECTRON_DEV_URL: url });
 
     let currentElectron: cpx.SpawnProcess | null = null;
     let isRestarting = false;
@@ -124,21 +117,9 @@ export class Electron {
       });
     };
 
-    const envBanner = createEnvBanner({ ELECTRON_DEV_URL: url, ...this._config.env });
-    const bannerJs =
-      "import { createRequire } from 'module'; const require = createRequire(import.meta.url);" +
-      envBanner;
-
     Electron._logger.debug("esbuild context 생성 시작");
     const ctx = await esbuild.context({
-      entryPoints: [entryPoint],
-      outfile: pathx.posixResolve(this._srcPath, "electron-main.js"),
-      platform: "node",
-      target: "node20",
-      format: "esm",
-      bundle: true,
-      external: ["electron", ...builtinModules, ...reinstallDeps, ...this._exclude],
-      banner: { js: bannerJs },
+      ...baseOptions,
       plugins: [
         {
           name: "electron-restart",
@@ -284,8 +265,13 @@ export class Electron {
 
   //#region Private - Bundling
 
-  private async _bundleMainProcess(): Promise<void> {
-    const esbuild = await import("esbuild");
+  /**
+   * run()과 _bundleMainProcess()가 공유하는 esbuild 옵션을 생성한다.
+   * extraEnv가 주어지면 config.env에 병합한다 (run 모드의 ELECTRON_DEV_URL 등).
+   */
+  private async _createBaseEsbuildOptions(
+    extraEnv?: Record<string, string>,
+  ): Promise<import("esbuild").BuildOptions> {
     const entryPoint = pathx.posixResolve(this._pkgPath, "src/electron-main.ts");
 
     if (!(await fsx.exists(entryPoint))) {
@@ -295,13 +281,12 @@ export class Electron {
     const builtinModules = module.builtinModules.flatMap((m) => [m, `node:${m}`]);
     const reinstallDeps = this._config.reinstallDependencies ?? [];
 
-    const envBanner = createEnvBanner(this._config.env);
+    const envBanner = createEnvBanner({ ...this._config.env, ...extraEnv });
     const bannerJs =
       "import { createRequire } from 'module'; const require = createRequire(import.meta.url);" +
       envBanner;
 
-    Electron._logger.debug(`esbuild 번들링: ${entryPoint}`);
-    await esbuild.build({
+    return {
       entryPoints: [entryPoint],
       outfile: pathx.posixResolve(this._srcPath, "electron-main.js"),
       platform: "node",
@@ -310,7 +295,15 @@ export class Electron {
       bundle: true,
       external: ["electron", ...builtinModules, ...reinstallDeps, ...this._exclude],
       banner: { js: bannerJs },
-    });
+    };
+  }
+
+  private async _bundleMainProcess(): Promise<void> {
+    const esbuild = await import("esbuild");
+    const options = await this._createBaseEsbuildOptions();
+
+    Electron._logger.debug(`esbuild 번들링: ${(options.entryPoints as string[])[0]}`);
+    await esbuild.build(options);
   }
 
   //#endregion

package/src/engines/BaseEngine.ts

@@ -1,9 +1,11 @@
 import { Worker, type WorkerProxy } from "@simplysm/core-node";
 import { consola } from "consola";
-import type { BuildResult, ResultCollector } from "../infra/ResultCollector";
-import { stopEngineWorker } from "../utils/engine-stop";
-import type { LintWithProgramResult } from "../utils/lint-with-program";
-import type { RebuildManager } from "../utils/rebuild-manager";
+import type { BuildResult, ResultCollector } from "../runtime/ResultCollector";
+import { stopEngineWorker } from "../runtime/engine-stop";
+import { setupWatchEvents } from "../runtime/engine-watch-events";
+import type { LintWithProgramResult } from "../lint/lint-with-program";
+import type { RebuildManager } from "../runtime/rebuild-manager";
+import type { SerializedDiagnostic } from "../typecheck/typecheck-serialization";
 import type { BuildEngine, BuildOutput, EngineResult, PackageInfo } from "./types";
 
 const logger = consola.withTag("sd:cli:engine");
@@ -53,7 +55,7 @@ export interface BaseEngineOptions<TPkg extends PackageInfo> {
  * 이벤트 처리)이 여기에 위치하며, 서브클래스는 추상 메서드를 통해
  * 워커 경로, 빌드/워치 호출 파라미터, 타겟 결정을 제공한다.
  *
- * ViteEngine은 이 계층에 포함되지 않음 — serverReady 이벤트, port 관리 등 생명주기가 다름.
+ * EsbuildClientEngine은 이 계층에 포함되지 않음 — serverReady 이벤트, port 관리 등 생명주기가 다름.
  */
 export abstract class BaseEngine<
   TPkg extends PackageInfo,
@@ -97,12 +99,38 @@ export abstract class BaseEngine<
    */
   protected abstract _callStartWatch(output: BuildOutput): Promise<void>;
 
+  /**
+   * Worker 빌드 결과를 EngineResult로 정규화한다.
+   * errors/warnings가 undefined이면 빈 배열로 변환한다.
+   */
+  protected _normalizeResult(result: {
+    build: {
+      success: boolean;
+      errors?: string[];
+      warnings?: string[];
+      diagnostics: SerializedDiagnostic[];
+    };
+    lint?: LintWithProgramResult;
+  }): EngineResult {
+    return {
+      build: {
+        success: result.build.success,
+        errors: result.build.errors ?? [],
+        warnings: result.build.warnings ?? [],
+        diagnostics: result.build.diagnostics,
+      },
+      lint: result.lint,
+    };
+  }
+
   /**
    * 서브클래스가 제공하는 워커 경로로 워커 인스턴스를 생성한다.
    */
   protected _createWorker(): void {
     const workerPath = this._getWorkerPath();
-    this._worker = Worker.create<TWorkerModule>(workerPath);
+    this._worker = Worker.create<TWorkerModule>(workerPath, {
+      resourceLimits: { maxOldGenerationSizeMb: 8192 },
+    });
   }
 
   /**
@@ -125,87 +153,40 @@ export abstract class BaseEngine<
     this._isWatchMode = true;
     this._createWorker();
 
-    return new Promise<void>((resolve) => {
-      let isInitialBuild = true;
-      let resolver: (() => void) | undefined;
-      const workerKey = `${this._pkg.name}:build`;
-
-      this._worker!.on("buildStart", () => {
-        if (this._rebuildManager != null) {
-          resolver = this._rebuildManager.registerBuild(
-            workerKey,
-            `${this._pkg.name} (${this._getTarget()})`,
-          );
-        }
-      });
-
-      this._worker!.on("build", (data) => {
-        const event = data;
-
-        if (event.build.warnings != null && event.build.warnings.length > 0) {
-          logger.warn(`${this._pkg.name}: ${event.build.warnings.join(", ")}`);
-        }
-
-        // 빌드 결과 보고
-        const buildResult: BuildResult = {
-          name: this._pkg.name,
-          target: this._getTarget(),
-          type: "build",
-          status: event.build.success ? "success" : "error",
-          message: event.build.errors?.join("\n"),
-        };
-        this._resultCollector?.add(buildResult);
-
-        // 린트 결과 보고 (있는 경우)
-        if (event.lint != null) {
-          const lintResult: BuildResult = {
-            name: this._pkg.name,
-            target: this._getTarget(),
-            type: "lint",
-            status: event.lint.success ? "success" : "error",
-            message: event.lint.formattedOutput !== "" ? event.lint.formattedOutput : undefined,
-          };
-          this._resultCollector?.add(lintResult);
-        }
-
-        resolver?.();
-        resolver = undefined;
-
-        if (isInitialBuild) {
-          isInitialBuild = false;
-          logger.debug(`[${this._pkg.name}] 초기 빌드 완료 (success: ${event.build.success})`);
-          resolve();
-        }
-      });
-
-      this._worker!.on("error", (data) => {
-        const event = data as { message: string };
-        const result: BuildResult = {
+    const { waitForInitialBuild, resolveInitialBuild } = setupWatchEvents(this._worker!, {
+      name: this._pkg.name,
+      target: this._getTarget(),
+      resultCollector: this._resultCollector,
+      rebuildManager: this._rebuildManager,
+      normalizeBuild: (data) =>
+        (data as CommonBuildWorkerEvents["build"]).build,
+    });
+
+    // BaseEngine 전용: 경고 로깅 + 린트 결과 보고
+    this._worker!.on("build", (data) => {
+      const event = data;
+
+      if (event.build.warnings != null && event.build.warnings.length > 0) {
+        logger.warn(`${this._pkg.name}: ${event.build.warnings.join(", ")}`);
+      }
+
+      if (event.lint != null) {
+        const lintResult: BuildResult = {
           name: this._pkg.name,
           target: this._getTarget(),
-          type: "build",
-          status: "error",
-          message: event.message,
+          type: "lint",
+          status: event.lint.success ? "success" : "error",
+          message: event.lint.formattedOutput !== "" ? event.lint.formattedOutput : undefined,
         };
-        this._resultCollector?.add(result);
-
-        resolver?.();
-        resolver = undefined;
-
-        // 에러 경로: 항상 resolve (reject하지 않음) — 호출자가 ResultCollector에서 상태를 확인
-        if (isInitialBuild) {
-          isInitialBuild = false;
-          resolve();
-        }
-      });
-
-      this._callStartWatch(output).catch(() => {
-        if (isInitialBuild) {
-          isInitialBuild = false;
-          resolve();
-        }
-      });
+        this._resultCollector?.add(lintResult);
+      }
+    });
+
+    this._callStartWatch(output).catch(() => {
+      resolveInitialBuild();
     });
+
+    return waitForInitialBuild();
   }
 
   /**

package/src/engines/{ViteEngine.ts → EsbuildClientEngine.ts}

@@ -3,43 +3,40 @@ import path from "path";
 import { Worker, type WorkerProxy } from "@simplysm/core-node";
 import { consola } from "consola";
 import type * as ClientWorkerModule from "../workers/client.worker";
-import type { BuildResult, ResultCollector } from "../infra/ResultCollector";
-import { stopEngineWorker } from "../utils/engine-stop";
-import type { RebuildManager } from "../utils/rebuild-manager";
+import type { ResultCollector } from "../runtime/ResultCollector";
+import { stopEngineWorker } from "../runtime/engine-stop";
+import { setupWatchEvents, type NormalizedBuildInfo } from "../runtime/engine-watch-events";
+import type { RebuildManager } from "../runtime/rebuild-manager";
 import type { BuildEngine, BuildOutput, ClientPackageInfo, EngineResult } from "./types";
 
-const logger = consola.withTag("sd:cli:engine:vite");
+const logger = consola.withTag("sd:cli:engine:esbuild-client");
 
 /**
- * ViteEngine 옵션
+ * EsbuildClientEngine 옵션
  */
-export interface ViteEngineOptions {
+export interface EsbuildClientEngineOptions {
   cwd: string;
   pkg: ClientPackageInfo;
   /** 워치 모드 리빌드 보고용 ResultCollector */
   resultCollector?: ResultCollector;
   /** 워치 모드 배치 조정용 RebuildManager */
   rebuildManager?: RebuildManager;
-  /** sdScopeWatchPlugin용 replaceDeps 항목 */
-  replaceDeps?: Array<{ packageName: string; sourcePath: string }>;
   /** 빌드 출력 경로 (미설정 시 pkgDir/dist) */
   outDir?: string;
-  /** Vite base 경로 (미설정 시 /{pkgName}/) */
+  /** base 경로 (미설정 시 /{pkgName}/) */
   base?: string;
 }
 
 /**
- * 클라이언트 패키지용 Vite 기반 빌드 엔진
+ * 클라이언트 패키지용 esbuild 기반 빌드 엔진
  *
- * framework 설정에 따라 sdAngularPlugin 또는 solidPlugin을 사용하며,
- * Vite의 createServer/build API를 직접 사용하는 client.worker를 래핑한다.
+ * esbuild context + HTTP dev server + HMR service를 사용하는 client.worker를 래핑한다.
  */
-export class ViteEngine implements BuildEngine {
+export class EsbuildClientEngine implements BuildEngine {
   private readonly _cwd: string;
   private readonly _pkg: ClientPackageInfo;
   private readonly _resultCollector: ResultCollector | undefined;
   private readonly _rebuildManager: RebuildManager | undefined;
-  private readonly _replaceDeps: Array<{ packageName: string; sourcePath: string }> | undefined;
   private readonly _outDir: string | undefined;
   private readonly _base: string | undefined;
 
@@ -49,12 +46,11 @@ export class ViteEngine implements BuildEngine {
   /** 개발 서버 포트 (워치 모드에서 serverReady 이벤트로 설정됨) */
   port: number | undefined;
 
-  constructor(options: ViteEngineOptions) {
+  constructor(options: EsbuildClientEngineOptions) {
     this._cwd = options.cwd;
     this._pkg = options.pkg;
     this._resultCollector = options.resultCollector;
     this._rebuildManager = options.rebuildManager;
-    this._replaceDeps = options.replaceDeps;
     this._outDir = options.outDir;
     this._base = options.base;
   }
@@ -63,23 +59,22 @@ export class ViteEngine implements BuildEngine {
    * 일회성 빌드 (프로덕션)
    */
   async run(_output: BuildOutput): Promise<EngineResult> {
-    logger.debug(`[${this._pkg.name}] ViteEngine.run 시작`);
+    logger.debug(`[${this._pkg.name}] EsbuildClientEngine.run 시작`);
     this._createWorker();
 
     const result = await this._worker!.build({
       name: this._pkg.name,
       cwd: this._cwd,
       pkgDir: this._pkg.dir,
-      framework: this._pkg.config.framework,
       env: this._pkg.config.env,
       configs: this._pkg.config.configs,
       pwa: this._pkg.config.pwa,
-      exclude: this._pkg.config.exclude,
       outDir: this._outDir,
       base: this._base,
+      browserSupport: this._pkg.config.browserSupport,
     });
 
-    logger.debug(`[${this._pkg.name}] ViteEngine.run 완료 (success: ${result.success})`);
+    logger.debug(`[${this._pkg.name}] EsbuildClientEngine.run 완료 (success: ${result.success})`);
     return {
       build: {
         success: result.success,
@@ -91,68 +86,34 @@ export class ViteEngine implements BuildEngine {
   }
 
   /**
-   * 워치 모드 시작 (Vite 개발 서버)
+   * 워치 모드 시작 (esbuild watch + HTTP dev server + HMR)
    * worker의 startWatch()가 완료되면 Promise가 resolve된다.
    */
   async startWatch(_output: BuildOutput): Promise<void> {
-    logger.debug(`[${this._pkg.name}] ViteEngine.startWatch 시작`);
+    logger.debug(`[${this._pkg.name}] EsbuildClientEngine.startWatch 시작`);
     this._isWatchMode = true;
     this._createWorker();
 
-    // serverReady를 감지하여 포트 캡처
+    // serverReady를 감지하여 포트 캡처 (EsbuildClientEngine 전용)
     this._worker!.on("serverReady", (data) => {
       const event = data as { port: number };
       this.port = event.port;
     });
 
-    // 리빌드 이벤트 처리 (HMR)
-    let resolver: (() => void) | undefined;
-    const workerKey = `${this._pkg.name}:build`;
-
-    this._worker!.on("buildStart", () => {
-      if (this._rebuildManager != null) {
-        resolver = this._rebuildManager.registerBuild(workerKey, `${this._pkg.name} (client)`);
-      }
-    });
-
-    this._worker!.on("build", (data) => {
-      const event = data as {
-        success: boolean;
-        errors?: string[];
-        warnings?: string[];
-      };
-      const buildResult: BuildResult = {
-        name: this._pkg.name,
-        target: "client",
-        type: "build",
-        status: event.success ? "success" : "error",
-        message: event.errors?.join("\n"),
-      };
-      this._resultCollector?.add(buildResult);
-
-      resolver?.();
-      resolver = undefined;
-    });
-
-    this._worker!.on("scopeRebuild", () => {
-      logger.info(`${this._pkg.name}: 의존성 변경 감지됨`);
+    // 공통 이벤트 처리 (buildStart/build/error)
+    setupWatchEvents(this._worker!, {
+      name: this._pkg.name,
+      target: "client",
+      resultCollector: this._resultCollector,
+      rebuildManager: this._rebuildManager,
+      normalizeBuild: (data) => data as NormalizedBuildInfo,
     });
+    // waitForInitialBuild 미사용 — worker.startWatch() await로 완료 감지
 
+    // EsbuildClientEngine 전용: error 로깅
     this._worker!.on("error", (data) => {
       const event = data as { message: string };
       logger.error(`${this._pkg.name}: ${event.message}`);
-
-      const buildResult: BuildResult = {
-        name: this._pkg.name,
-        target: "client",
-        type: "build",
-        status: "error",
-        message: event.message,
-      };
-      this._resultCollector?.add(buildResult);
-
-      resolver?.();
-      resolver = undefined;
     });
 
     const port =
@@ -164,13 +125,11 @@ export class ViteEngine implements BuildEngine {
       name: this._pkg.name,
       cwd: this._cwd,
       pkgDir: this._pkg.dir,
-      framework: this._pkg.config.framework,
       port,
       env: this._pkg.config.env,
       configs: this._pkg.config.configs,
-      replaceDeps: this._replaceDeps,
       pwa: this._pkg.config.pwa,
-      exclude: this._pkg.config.exclude,
+      browserSupport: this._pkg.config.browserSupport,
     });
   }
 
@@ -178,7 +137,7 @@ export class ViteEngine implements BuildEngine {
    * 엔진을 중지하고 리소스를 정리한다
    */
   async stop(): Promise<void> {
-    logger.debug(`[${this._pkg.name}] ViteEngine stop 시작`);
+    logger.debug(`[${this._pkg.name}] EsbuildClientEngine stop 시작`);
 
     // .dev-port 파일 삭제
     const portFile = path.join(this._pkg.dir, "dist", ".dev-port");
@@ -186,7 +145,7 @@ export class ViteEngine implements BuildEngine {
 
     await stopEngineWorker(this._worker, this._isWatchMode);
     this._worker = undefined;
-    logger.debug(`[${this._pkg.name}] ViteEngine stop 완료`);
+    logger.debug(`[${this._pkg.name}] EsbuildClientEngine stop 완료`);
   }
 
   /**
@@ -194,6 +153,8 @@ export class ViteEngine implements BuildEngine {
    */
   private _createWorker(): void {
     const workerPath = import.meta.resolve("../workers/client.worker");
-    this._worker = Worker.create<typeof ClientWorkerModule>(workerPath);
+    this._worker = Worker.create<typeof ClientWorkerModule>(workerPath, {
+      resourceLimits: { maxOldGenerationSizeMb: 8192 },
+    });
   }
 }

package/src/engines/NgtscEngine.ts

@@ -1,6 +1,6 @@
 import type * as NgtscBuildWorkerModule from "../workers/ngtsc-build.worker";
-import type { ResultCollector } from "../infra/ResultCollector";
-import type { RebuildManager } from "../utils/rebuild-manager";
+import type { ResultCollector } from "../runtime/ResultCollector";
+import type { RebuildManager } from "../runtime/rebuild-manager";
 import type { BuildOutput, BuildPackageInfo, EngineResult } from "./types";
 import { BaseEngine, type CommonBuildWorkerModule } from "./BaseEngine";
 import { consola } from "consola";
@@ -52,15 +52,7 @@ export class NgtscEngine extends BaseEngine<
       output,
     });
 
-    return {
-      build: {
-        success: result.build.success,
-        errors: result.build.errors ?? [],
-        warnings: result.build.warnings ?? [],
-        diagnostics: result.build.diagnostics,
-      },
-      lint: result.lint,
-    };
+    return this._normalizeResult(result);
   }
 
   protected async _callStartWatch(output: BuildOutput): Promise<void> {

package/src/engines/ServerEsbuildEngine.ts

@@ -1,6 +1,6 @@
 import type * as ServerBuildWorkerModule from "../workers/server-build.worker";
-import type { ResultCollector } from "../infra/ResultCollector";
-import type { RebuildManager } from "../utils/rebuild-manager";
+import type { ResultCollector } from "../runtime/ResultCollector";
+import type { RebuildManager } from "../runtime/rebuild-manager";
 import type { BuildOutput, EngineResult, ServerPackageInfo } from "./types";
 import { BaseEngine, type CommonBuildWorkerModule } from "./BaseEngine";
 import { consola } from "consola";
@@ -57,15 +57,7 @@ export class ServerEsbuildEngine extends BaseEngine<
       packageManager: this._pkg.config.packageManager,
     });
 
-    return {
-      build: {
-        success: result.build.success,
-        errors: result.build.errors ?? [],
-        warnings: result.build.warnings ?? [],
-        diagnostics: result.build.diagnostics,
-      },
-      lint: result.lint,
-    };
+    return this._normalizeResult(result);
   }
 
   protected async _callStartWatch(output: BuildOutput): Promise<void> {

package/src/engines/TscEngine.ts

@@ -1,6 +1,6 @@
 import type * as LibraryBuildWorkerModule from "../workers/library-build.worker";
-import type { ResultCollector } from "../infra/ResultCollector";
-import type { RebuildManager } from "../utils/rebuild-manager";
+import type { ResultCollector } from "../runtime/ResultCollector";
+import type { RebuildManager } from "../runtime/rebuild-manager";
 import type { BuildOutput, BuildPackageInfo, EngineResult } from "./types";
 import { BaseEngine, type CommonBuildWorkerModule } from "./BaseEngine";
 import { consola } from "consola";
@@ -53,15 +53,7 @@ export class TscEngine extends BaseEngine<
       output,
     });
 
-    return {
-      build: {
-        success: result.build.success,
-        errors: result.build.errors ?? [],
-        warnings: result.build.warnings ?? [],
-        diagnostics: result.build.diagnostics,
-      },
-      lint: result.lint,
-    };
+    return this._normalizeResult(result);
   }
 
   protected async _callStartWatch(output: BuildOutput): Promise<void> {

package/src/engines/index.ts

@@ -1,11 +1,11 @@
 import { consola } from "consola";
-import type { ResultCollector } from "../infra/ResultCollector";
-import type { RebuildManager } from "../utils/rebuild-manager";
+import type { ResultCollector } from "../runtime/ResultCollector";
+import type { RebuildManager } from "../runtime/rebuild-manager";
 import { hasAngularCoreDependency } from "../utils/package-utils";
 import { NgtscEngine } from "./NgtscEngine";
 import { ServerEsbuildEngine } from "./ServerEsbuildEngine";
 import { TscEngine } from "./TscEngine";
-import { ViteEngine } from "./ViteEngine";
+import { EsbuildClientEngine } from "./EsbuildClientEngine";
 import type { BuildEngine, BuildPackageInfo, ClientPackageInfo, ServerPackageInfo } from "./types";
 
 const logger = consola.withTag("sd:cli:engine");
@@ -15,7 +15,7 @@ export type { BuildEngine, BuildOutput, BuildPackageInfo, ClientPackageInfo, Eng
 /**
  * 주어진 패키지에 맞는 BuildEngine을 생성한다.
  *
- * 클라이언트 패키지는 ViteEngine을 사용한다.
+ * 클라이언트 패키지는 EsbuildClientEngine을 사용한다.
  * 서버 패키지는 ServerEsbuildEngine을 사용한다.
  * Angular 라이브러리 패키지(package.json에 @angular/core 의존성 감지)는 NgtscEngine을 사용한다.
  * 기타 라이브러리 패키지(node/browser/neutral)는 TscEngine을 사용한다.
@@ -28,20 +28,19 @@ export function createBuildEngine(
     resolvedReplaceDeps?: Array<{ packageName: string; sourcePath: string }>;
     resultCollector?: ResultCollector;
     rebuildManager?: RebuildManager;
-    /** 클라이언트 빌드 출력 경로 (ViteEngine에만 적용) */
+    /** 클라이언트 빌드 출력 경로 (EsbuildClientEngine에만 적용) */
     outDir?: string;
-    /** Vite base 경로 (ViteEngine에만 적용, 미설정 시 /{pkgName}/) */
+    /** base 경로 (EsbuildClientEngine에만 적용, 미설정 시 /{pkgName}/) */
     base?: string;
   },
 ): BuildEngine {
   if (pkg.config.target === "client") {
-    logger.debug(`[${pkg.name}] 엔진 선택: ViteEngine (client)`);
-    return new ViteEngine({
+    logger.debug(`[${pkg.name}] 엔진 선택: EsbuildClientEngine (client)`);
+    return new EsbuildClientEngine({
       cwd: options.cwd,
       pkg: pkg as ClientPackageInfo,
       resultCollector: options.resultCollector,
       rebuildManager: options.rebuildManager,
-      replaceDeps: options.resolvedReplaceDeps,
       outDir: options.outDir,
       base: options.base,
     });
@@ -60,3 +59,24 @@ export function createBuildEngine(
   logger.debug(`[${pkg.name}] 엔진 선택: TscEngine (target: ${pkg.config.target})`);
   return new TscEngine({ ...options, pkg: pkg as BuildPackageInfo });
 }
+
+/**
+ * 타입체크용 BuildEngine을 생성한다.
+ *
+ * client target은 browser로 재매핑하여 createBuildEngine에 위임한다.
+ * (client 패키지의 타입체크는 EsbuildClientEngine이 아닌 TscEngine/NgtscEngine으로 수행)
+ * 그 외 target은 createBuildEngine에 그대로 위임한다.
+ */
+export function createTypecheckEngine(
+  pkg: BuildPackageInfo | ServerPackageInfo | ClientPackageInfo,
+  options: { cwd: string },
+): BuildEngine {
+  if (pkg.config.target === "client") {
+    const browserPkg: BuildPackageInfo = {
+      ...pkg,
+      config: { target: "browser" as const },
+    };
+    return createBuildEngine(browserPkg, options);
+  }
+  return createBuildEngine(pkg, options);
+}

package/src/engines/types.ts

@@ -1,7 +1,7 @@
 import type { SdBuildPackageConfig, SdClientPackageConfig, SdPackageConfig, SdServerPackageConfig } from "../sd-config.types";
-import type { SerializedDiagnostic } from "../utils/typecheck-serialization";
+import type { SerializedDiagnostic } from "../typecheck/typecheck-serialization";
 import type { TypecheckEnv } from "../utils/tsconfig";
-import type { LintWithProgramResult } from "../utils/lint-with-program";
+import type { LintWithProgramResult } from "../lint/lint-with-program";
 
 /**
  * 패키지 정보
@@ -81,6 +81,6 @@ export interface BuildEngine {
    */
   stop(): Promise<void>;
 
-  /** 개발 서버 포트 (ViteEngine의 워치 모드에서 serverReady 이벤트로 설정됨) */
+  /** 개발 서버 포트 (EsbuildClientEngine의 워치 모드에서 serverReady 이벤트로 설정됨) */
   readonly port?: number;
 }