@simplysm/sd-cli 14.0.42 → 14.0.44

package/src/ts-compiler/sd-ts-compiler-options.ts

@@ -0,0 +1,46 @@
+import type ts from "typescript";
+import type { AngularSourceFileCache } from "../angular/angular-compiler";
+import type { TypecheckEnv } from "../utils/tsconfig";
+
+export interface ISdTsCompilerEmitOptions {
+  /** emit 대상 소스 필터 (Angular only, 지정 시 해당 파일만 EmitResult에 포함) */
+  sourceFilter?: (fileName: string) => boolean;
+  /** Angular transformers 외 추가 transformers (Angular only) */
+  additionalTransformers?: {
+    before?: ts.TransformerFactory<ts.SourceFile>[];
+    after?: ts.TransformerFactory<ts.SourceFile>[];
+  };
+}
+
+export interface ISdTsCompilerOptions {
+  /** 패키지 디렉토리 */
+  pkgDir: string;
+  /** workspace 루트 (diagnostics 필터링 등에 사용) */
+  cwd: string;
+  /** 출력 제어 플래그 */
+  output: { js: boolean; dts: boolean };
+  /** tests/ 파일을 rootNames에 포함할지 여부. 기본값 false */
+  includeTests?: boolean;
+  /** 타입체크 환경. 설정 시 getCompilerOptionsForEnv()를 적용 */
+  env?: TypecheckEnv;
+
+  // === Angular 전용 (선택적, isForAngular 시 활성화) ===
+  /** SourceFile 캐시 (Angular 증분 빌드용). 미제공 시 내부 생성 */
+  sourceFileCache?: AngularSourceFileCache;
+  /** 스타일시트 변환 콜백 (Feature 1.3에서 활용) */
+  transformStylesheet?: (
+    data: string,
+    containingFile: string,
+    stylesheetFile?: string,
+  ) => Promise<string | null>;
+  /** 외부 스타일시트 맵 (클라이언트 빌드용, resourceNameToFileName에서 사용) */
+  externalStylesheets?: Map<string, string>;
+  /** compilerOptions 후처리 (클라이언트의 target/module 강제 등) */
+  compilerOptionsTransformer?: (options: ts.CompilerOptions) => ts.CompilerOptions;
+
+  // === SCSS/lint 통합 (Feature 1.3) ===
+  /** lint 실행 여부. true이면 compileAsync 결과에 lint 결과 포함 */
+  lint?: boolean;
+  /** 글로벌 SCSS 컴파일 여부. true이면 scss/styles.scss → dist/styles.css 생성 */
+  globalScss?: boolean;
+}

package/src/ts-compiler/sd-ts-compiler-result.ts

@@ -0,0 +1,34 @@
+import type ts from "typescript";
+import type { SerializedDiagnostic } from "../typecheck/typecheck-serialization";
+import type { EmitResult } from "../angular/angular-compiler";
+import type { LintWithProgramResult } from "../lint/lint-with-program";
+import type { NgtscProgram } from "../angular/angular-build";
+
+export interface ISdTsCompilerResult {
+  /** TypeScript Program 참조 (lint, 외부 도구용) */
+  program: ts.Program;
+  /** Builder Program 참조 */
+  builderProgram: ts.EmitAndSemanticDiagnosticsBuilderProgram;
+  /** Angular 패키지 여부 */
+  isForAngular: boolean;
+  /** 이 빌드에서 영향받은 파일 (posix 경로). undefined = 전역 변경 (전체 리빌드) */
+  affectedFiles: ReadonlySet<string> | undefined;
+  /** 직렬화된 진단 정보 (Worker 경계 통과용) */
+  diagnostics: SerializedDiagnostic[];
+  /** Error 카테고리 진단 수 */
+  errorCount: number;
+  /** Warning 카테고리 진단 수 */
+  warningCount: number;
+  /** Error 카테고리 진단을 "파일:줄:열: TS코드: 메시지" 형식으로 포맷한 배열 */
+  errors?: string[];
+  /** NgtscProgram 참조 (Angular only, HMR용). Non-Angular이면 undefined */
+  ngtscProgram?: NgtscProgram;
+  /** Angular emit 결과 (Non-Angular이면 undefined — writeFile 훅으로 디스크 직접 쓰기) */
+  emitResults?: EmitResult[];
+  /** lint 결과 (lint 옵션 활성 시) */
+  lint?: LintWithProgramResult;
+  /** SCSS 에러 목록 */
+  scssErrors: string[];
+  /** SCSS 의존성 맵 (소유자 파일 → 의존 SCSS 경로 집합). watch 역방향 탐색용 */
+  scssDependencies: ReadonlyMap<string, ReadonlySet<string>>;
+}

package/src/utils/copy-public.ts

@@ -6,14 +6,15 @@ import {
 } from "@simplysm/core-node";
 
 /**
- * public/ 및 public-dev/ 디렉토리의 파일을 dist/로 복사한다.
+ * public/ 및 public-dev/ 디렉토리의 파일을 출력 디렉토리로 복사한다.
  * public-dev/가 public/보다 우선한다 (오버레이).
  *
  * @param pkgDir 패키지 루트 디렉토리
  * @param includeDev public-dev/ 포함 여부 (dev 모드에서만 true)
+ * @param outDir 출력 디렉토리 (미지정 시 pkgDir/dist)
  */
-export async function copyPublicFiles(pkgDir: string, includeDev: boolean): Promise<void> {
-  const distDir = pathx.posix(path.join(pkgDir, "dist"));
+export async function copyPublicFiles(pkgDir: string, includeDev: boolean, outDir?: string): Promise<void> {
+  const distDir = pathx.posix(outDir ?? path.join(pkgDir, "dist"));
   await fsx.mkdir(distDir);
 
   // public/ 복사
@@ -48,23 +49,25 @@ export async function copyPublicFiles(pkgDir: string, includeDev: boolean): Prom
 }
 
 /**
- * public/ 및 public-dev/ 디렉토리를 감시하고 변경사항을 실시간으로 dist/에 복사한다.
+ * public/ 및 public-dev/ 디렉토리를 감시하고 변경사항을 실시간으로 출력 디렉토리에 복사한다.
  * 초기 복사 후 변경/추가/삭제를 자동으로 반영한다.
  *
  * @param pkgDir 패키지 루트 디렉토리
  * @param includeDev public-dev/ 포함 여부 (dev 모드에서만 true)
+ * @param outDir 출력 디렉토리 (미지정 시 pkgDir/dist)
  * @returns FsWatcher 인스턴스 (종료 시 close() 호출 필요) 또는 감시 대상이 없으면 undefined
  */
 export async function watchPublicFiles(
   pkgDir: string,
   includeDev: boolean,
+  outDir?: string,
 ): Promise<FsWatcher | undefined> {
-  const distDir = pathx.posix(path.join(pkgDir, "dist"));
+  const distDir = pathx.posix(outDir ?? path.join(pkgDir, "dist"));
   const publicDir = pathx.posix(path.join(pkgDir, "public"));
   const publicDevDir = pathx.posix(path.join(pkgDir, "public-dev"));
 
   // 초기 복사
-  await copyPublicFiles(pkgDir, includeDev);
+  await copyPublicFiles(pkgDir, includeDev, outDir);
 
   // 감시 대상 경로 수집
   const watchPaths: string[] = [];

package/src/utils/diagnostic-utils.ts

@@ -30,14 +30,13 @@ export function formatDiagnosticsOutput(diagnostics: ts.Diagnostic[], cwd: strin
 }
 
 /**
- * 진단 에러를 "파일:줄:열: TS코드: 메시지" 형식으로 포맷한다.
- * 파일 정보가 없는 경우 "TS코드: 메시지" 형식으로 반환한다.
+ * 진단 에러를 TypeScript 네이티브 컬러+코드 컨텍스트 포맷으로 변환한다.
  */
-export function formatDiagnosticError(diagnostic: ts.Diagnostic): string {
-  const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
-  if (diagnostic.file != null && diagnostic.start != null) {
-    const { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
-    return `${diagnostic.file.fileName}:${line + 1}:${character + 1}: TS${diagnostic.code}: ${message}`;
-  }
-  return `TS${diagnostic.code}: ${message}`;
+export function formatDiagnosticError(diagnostic: ts.Diagnostic, cwd: string): string {
+  const formatHost: ts.FormatDiagnosticsHost = {
+    getCanonicalFileName: (f) => f,
+    getCurrentDirectory: () => cwd,
+    getNewLine: () => ts.sys.newLine,
+  };
+  return ts.formatDiagnosticsWithColorAndContext([diagnostic], formatHost).trimEnd();
 }

package/src/utils/output-utils.ts

@@ -1,6 +1,23 @@
+import { formatMessagesSync, type PartialMessage } from "esbuild";
 import { consola } from "consola";
 import type { BuildResult } from "../runtime/ResultCollector";
 
+const logger = consola.withTag("sd:cli:output");
+
+/**
+ * esbuild Message 배열을 포맷된 문자열 배열로 변환한다.
+ * esbuild 네이티브 포맷(코드 컨텍스트, 위치 정보, 밑줄)을 유지한다.
+ */
+export function formatEsbuildMessages(
+  messages: PartialMessage[],
+  kind: "error" | "warning",
+): string[] {
+  if (messages.length === 0) return [];
+  return formatMessagesSync(messages, { kind, color: true }).map((msg) =>
+    msg.replace(/^.*?\x1b\[0m |^X \[ERROR] |^▲ \[WARNING] /, "").trimEnd(),
+  );
+}
+
 /**
  * 빌드 경고/에러 메시지를 포맷팅한다.
  */
@@ -8,27 +25,40 @@ export function formatBuildMessages(name: string, label: string, messages: strin
   const lines: string[] = [`${name} (${label})`];
   for (const msg of messages) {
     for (const line of msg.split("\n")) {
-      lines.push(`  → ${line}`);
+      if (line === "") {
+        lines.push("");
+      } else {
+        lines.push(`  ${line}`);
+      }
     }
   }
   return lines.join("\n");
 }
 
 /**
- * 에러만 출력한다.
+ * 에러와 경고를 출력한다. 에러를 먼저, 경고를 나중에 출력한다.
  * @param results 패키지별 빌드 결과 상태
  */
-export function printErrors(results: ReadonlyMap<string, BuildResult>): void {
+export function printDiagnostics(results: ReadonlyMap<string, BuildResult>): void {
+  // 에러 출력
   for (const result of results.values()) {
     if (result.status === "error") {
       const typeLabel = result.type === "lint" ? "lint" : result.target;
       if (result.message != null && result.message !== "") {
-        consola.error(formatBuildMessages(result.name, typeLabel, [result.message]));
+        logger.error(formatBuildMessages(result.name, typeLabel, [result.message]));
       } else {
-        consola.error(`[${result.name}] (${typeLabel}) 실패`);
+        logger.error(`[${result.name}] (${typeLabel}) 실패`);
       }
     }
   }
+
+  // 경고 출력
+  for (const result of results.values()) {
+    if (result.warnings != null && result.warnings !== "") {
+      const typeLabel = result.type === "lint" ? "lint" : result.target;
+      logger.warn(formatBuildMessages(result.name, typeLabel, [result.warnings]));
+    }
+  }
 }
 
 /**
@@ -53,15 +83,15 @@ export function printServers(
         const activeClients = clients.filter((c) => results.get(`${c}:build`)?.status !== "error");
         if (activeClients.length > 0) {
           for (const clientName of activeClients) {
-            consola.info(`[server] http://localhost:${server.port}/${clientName}/`);
+            logger.info(`[server] http://localhost:${server.port}/${clientName}/`);
           }
         } else {
           // 연결된 클라이언트가 없으면 서버 루트 URL 출력
-          consola.info(`[server] http://localhost:${server.port}/`);
+          logger.info(`[server] http://localhost:${server.port}/`);
         }
       } else {
         // 독립형 클라이언트: 이름 포함하여 출력
-        consola.info(`[server] http://localhost:${server.port}/${server.name}/`);
+        logger.info(`[server] http://localhost:${server.port}/${server.name}/`);
       }
     }
   }

package/src/workers/client.worker.ts

@@ -2,19 +2,22 @@ import path from "path";
 import fs from "node:fs";
 import { createWorker, FsWatcher } from "@simplysm/core-node";
 import { err as errNs } from "@simplysm/core-common";
-import { setupWorkerLifecycle } from "./shared-worker-lifecycle.js";
+import { setupWorkerLifecycle } from "./shared-worker-lifecycle";
 import {
   createClientEsbuildContext,
   type ClientEsbuildResult,
-} from "../esbuild/esbuild-client-config.js";
-import { generateIndexHtml } from "../esbuild/esbuild-index-html.js";
-import { applyPwa, createPwaHtmlTransform } from "../esbuild/esbuild-pwa.js";
-import { createDevHttpServer, type DevHttpServer } from "../dev-server/dev-http-server.js";
-import { createHmrService, type HmrService } from "../dev-server/hmr-service.js";
-import { createHmrPostTransform } from "../dev-server/hmr-client-script.js";
-import { copyPublicFiles, watchPublicFiles } from "../utils/copy-public.js";
-import type { SdBrowserSupportConfig, SdPwaConfig } from "../sd-config.types.js";
+} from "../esbuild/esbuild-client-config";
+import { generateIndexHtml } from "../esbuild/esbuild-index-html";
+import { formatEsbuildMessages } from "../utils/output-utils";
+import { applyPwa, createPwaHtmlTransform } from "../esbuild/esbuild-pwa";
+import { createDevHttpServer, type DevHttpServer } from "../dev-server/dev-http-server";
+import { createHmrService, type HmrService } from "../dev-server/hmr-service";
+import { createHmrPostTransform } from "../dev-server/hmr-client-script";
+import { copyPublicFiles, watchPublicFiles } from "../utils/copy-public";
+import type { SdBrowserSupportConfig, SdPwaConfig } from "../sd-config.types";
 import type esbuild from "esbuild";
+import type { PartialMessage } from "esbuild";
+import { IncrementalMtimeTracker } from "./incremental-mtime-tracker";
 
 //#region Types
 
@@ -63,6 +66,9 @@ let devServer: DevHttpServer | undefined;
 let hmrService: HmrService | undefined;
 let publicWatcher: FsWatcher | undefined;
 let indexHtmlWatcher: FsWatcher | undefined;
+let lastMetafile: esbuild.Metafile | undefined;
+let isInitialBuild = true;
+let initialBuildResolve: ((result: ClientBuildResult) => void) | undefined;
 
 const { logger, guardStartWatch } = setupWorkerLifecycle("client", async () => {
   await stopWatch();
@@ -98,7 +104,7 @@ async function build(info: ClientBuildInfo): Promise<ClientBuildResult> {
     const outdir = info.outDir ?? path.join(info.pkgDir, "dist");
 
     // 1. public/ 복사
-    await copyPublicFiles(info.pkgDir, false);
+    await copyPublicFiles(info.pkgDir, false, outdir);
 
     // 2. polyfills 감지
     const polyfillsPath = path.join(info.pkgDir, "src", "polyfills.ts");
@@ -160,7 +166,7 @@ async function build(info: ClientBuildInfo): Promise<ClientBuildResult> {
     // SourceFileCache는 LMDB 기반. context.dispose()에 의해 정리됨.
 
     // 8. .config.json 기록
-    writeConfigJson(path.join(info.pkgDir, "dist"), info.configs);
+    writeConfigJson(outdir, info.configs);
 
     logger.debug(`[${info.name}] client worker build 완료`);
     return {
@@ -171,17 +177,131 @@ async function build(info: ClientBuildInfo): Promise<ClientBuildResult> {
   } catch (err) {
     const errors: string[] = [];
     if (err != null && typeof err === "object" && "errors" in err) {
-      const buildErrors = (err as { errors: Array<{ text: string }> }).errors;
-      errors.push(...buildErrors.map((e) => e.text));
+      const buildErrors = (err as { errors: PartialMessage[] }).errors;
+      errors.push(...formatEsbuildMessages(buildErrors, "error"));
     }
     if (errors.length === 0) {
       errors.push(errNs.message(err));
     }
-    logger.debug(`[${info.name}] client worker build 예외: ${errors.join("; ")}`);
+    logger.debug(`[${info.name}] client worker build 예외: ${errors.join("\n")}`);
     return { success: false, errors };
   }
 }
 
+/**
+ * sourceFileCache 무효화 + mtime 추적 플러그인 생성
+ */
+function createSourceFileCachePlugin(): esbuild.Plugin {
+  return {
+    name: "sd-build-start",
+    setup(pluginBuild: esbuild.PluginBuild) {
+      const mtimeTracker = new IncrementalMtimeTracker();
+
+      pluginBuild.onStart(() => {
+        // sourceFileCache 무효화: 변경된 파일의 loadResultCache + TypeScript 소스 캐시 모두 제거
+        if (esbuildResult != null) {
+          const { loadResultCache, typeScriptFileCache } =
+            esbuildResult.sourceFileCache;
+          // JS 파일 (loadResultCache) + TS 파일 (typeScriptFileCache) 모두 감시
+          const watchTargets = [
+            ...loadResultCache.watchFiles,
+            ...typeScriptFileCache.keys(),
+          ];
+          const changedFiles = mtimeTracker.detectChanges(watchTargets);
+          if (changedFiles.size > 0) {
+            esbuildResult.sourceFileCache.invalidate(changedFiles);
+          }
+        }
+
+        if (!isInitialBuild) {
+          sender.send("buildStart", {});
+        }
+      });
+
+      pluginBuild.onEnd(() => {
+        if (esbuildResult == null) return;
+        // JS 파일 (loadResultCache) + TS 파일 (typeScriptFileCache) 모두 기록
+        const watchTargets = [
+          ...esbuildResult.sourceFileCache.loadResultCache.watchFiles,
+          ...esbuildResult.sourceFileCache.typeScriptFileCache.keys(),
+        ];
+        mtimeTracker.updateMtimes(watchTargets);
+      });
+    },
+  };
+}
+
+/**
+ * dev watch 빌드 완료 핸들러 생성 (index.html 재생성 + HMR + 이벤트 전송)
+ */
+function createDevBuildEndHandler(
+  basePath: string,
+  actualPort: number,
+  outdir: string,
+  entryNames: string[],
+  pkgDir: string,
+): (result: esbuild.BuildResult) => Promise<void> {
+  return async (result: esbuild.BuildResult) => {
+    try {
+      // index.html 재생성 (lastMetafile 보관 — index.html 단독 변경 시 재생성용)
+      if (result.metafile != null) {
+        lastMetafile = result.metafile;
+        const hmrPostTransform = createHmrPostTransform(basePath, actualPort);
+        const indexPath = path.join(pkgDir, "src", "index.html");
+        const indexResult = await generateIndexHtml({
+          indexPath,
+          metafile: result.metafile,
+          outdir,
+          baseHref: basePath,
+          mode: "dev",
+          entryNames,
+          postTransform: hmrPostTransform,
+        });
+        fs.writeFileSync(path.join(outdir, "index.html"), indexResult.content);
+      }
+
+      // HMR 메시지 디스패치
+      if (hmrService != null && result.metafile != null && !isInitialBuild) {
+        hmrService.onBuildEnd(result.metafile);
+      }
+
+      // build 이벤트 전송
+      const success = result.errors.length === 0;
+      const errors = result.errors.length > 0
+        ? formatEsbuildMessages(result.errors, "error")
+        : undefined;
+      const warnings = result.warnings.length > 0
+        ? formatEsbuildMessages(result.warnings, "warning")
+        : undefined;
+
+      if (!isInitialBuild) {
+        sender.send("build", { success, errors, warnings });
+      }
+
+      // 초기 빌드 완료 시 resolve
+      if (isInitialBuild) {
+        isInitialBuild = false;
+        initialBuildResolve?.({ success, errors, warnings });
+      }
+    } catch (err) {
+      const message = errNs.message(err);
+      if (!isInitialBuild) {
+        sender.send("error", { message });
+      } else {
+        isInitialBuild = false;
+        initialBuildResolve?.({
+          success: false,
+          errors: [message],
+          warnings:
+            result.warnings.length > 0
+              ? formatEsbuildMessages(result.warnings, "warning")
+              : undefined,
+        });
+      }
+    }
+  };
+}
+
 /**
  * dev watch 시작
  */
@@ -232,10 +352,6 @@ async function startWatch(info: ClientBuildInfo): Promise<ClientBuildResult> {
     });
 
     // 7. esbuild context 생성
-    let lastMetafile: esbuild.Metafile | undefined;
-    let initialBuildResolve: ((result: ClientBuildResult) => void) | undefined;
-    let isInitialBuild = true;
-
     esbuildResult = await createClientEsbuildContext({
       pkgDir: info.pkgDir,
       cwd: info.cwd,
@@ -247,114 +363,8 @@ async function startWatch(info: ClientBuildInfo): Promise<ClientBuildResult> {
       legacyModule,
       postcssPlugins,
       templateUpdates: legacyModule ? undefined : templateUpdates,
-      plugins: [
-        {
-          name: "sd-build-start",
-          setup(pluginBuild: esbuild.PluginBuild) {
-            const prevMtimes = new Map<string, number>();
-
-            pluginBuild.onStart(() => {
-              // sourceFileCache 무효화: 변경된 파일의 loadResultCache + TypeScript 소스 캐시 모두 제거
-              if (esbuildResult != null) {
-                const { loadResultCache } = esbuildResult.sourceFileCache;
-                const changedFiles = new Set<string>();
-                for (const file of loadResultCache.watchFiles) {
-                  try {
-                    const mtime = fs.statSync(file).mtimeMs;
-                    const prev = prevMtimes.get(file);
-                    if (prev != null && prev !== mtime) {
-                      changedFiles.add(file);
-                    }
-                  } catch {
-                    if (prevMtimes.has(file)) {
-                      changedFiles.add(file);
-                    }
-                  }
-                }
-                if (changedFiles.size > 0) {
-                  esbuildResult.sourceFileCache.invalidate(changedFiles);
-                }
-              }
-
-              if (!isInitialBuild) {
-                sender.send("buildStart", {});
-              }
-            });
-
-            pluginBuild.onEnd(() => {
-              if (esbuildResult == null) return;
-              prevMtimes.clear();
-              for (const file of esbuildResult.sourceFileCache.loadResultCache.watchFiles) {
-                try {
-                  prevMtimes.set(file, fs.statSync(file).mtimeMs);
-                } catch {
-                  // 삭제된 파일
-                }
-              }
-            });
-          },
-        },
-      ],
-      onEnd: async (result: esbuild.BuildResult) => {
-        try {
-          // index.html 재생성 (lastMetafile 보관 — index.html 단독 변경 시 재생성용)
-          if (result.metafile != null) {
-            lastMetafile = result.metafile;
-            const hmrPostTransform = createHmrPostTransform(basePath, actualPort);
-            const indexPath = path.join(info.pkgDir, "src", "index.html");
-            const indexResult = await generateIndexHtml({
-              indexPath,
-              metafile: result.metafile,
-              outdir,
-              baseHref: basePath,
-              mode: "dev",
-              entryNames,
-              postTransform: hmrPostTransform,
-            });
-            fs.writeFileSync(path.join(outdir, "index.html"), indexResult.content);
-          }
-
-          // HMR 메시지 디스패치
-          if (hmrService != null && result.metafile != null && !isInitialBuild) {
-            hmrService.onBuildEnd(result.metafile);
-          }
-
-          // build 이벤트 전송
-          const success = result.errors.length === 0;
-          if (!isInitialBuild) {
-            sender.send("build", {
-              success,
-              errors:
-                result.errors.length > 0
-                  ? result.errors.map((e) => e.text)
-                  : undefined,
-              warnings:
-                result.warnings.length > 0
-                  ? result.warnings.map((w) => w.text)
-                  : undefined,
-            });
-          }
-
-          // 초기 빌드 완료 시 resolve
-          if (isInitialBuild) {
-            isInitialBuild = false;
-            initialBuildResolve?.({
-              success,
-              errors:
-                result.errors.length > 0
-                  ? result.errors.map((e) => e.text)
-                  : undefined,
-            });
-          }
-        } catch (err) {
-          const message = errNs.message(err);
-          sender.send("error", { message });
-          if (isInitialBuild) {
-            isInitialBuild = false;
-            initialBuildResolve?.({ success: false, errors: [message] });
-          }
-        }
-      },
+      plugins: [createSourceFileCachePlugin()],
+      onEnd: createDevBuildEndHandler(basePath, actualPort, outdir, entryNames, info.pkgDir),
     });
 
     // 8. esbuild watch 시작 + 초기 빌드 대기
@@ -440,6 +450,11 @@ async function stopWatch(): Promise<void> {
     indexHtmlWatcher = undefined;
   }
 
+  // 6. 빌드 세션 상태 리셋
+  lastMetafile = undefined;
+  isInitialBuild = true;
+  initialBuildResolve = undefined;
+
   logger.debug("esbuild watch 정리 완료");
 }
 

package/src/workers/incremental-mtime-tracker.ts

@@ -0,0 +1,68 @@
+import fs from "node:fs";
+
+/**
+ * 증분 방식으로 파일 mtime을 추적하여 변경 파일을 감지한다.
+ *
+ * - `detectChanges`: watchTargets 전체를 stat하여 이전 mtime과 비교, 변경 파일 Set 반환
+ * - `updateMtimes`: 변경/신규 파일만 stat하여 prevMtimes를 증분 갱신
+ */
+export class IncrementalMtimeTracker {
+  private readonly _prevMtimes = new Map<string, number>();
+  private _lastChangedFiles = new Set<string>();
+
+  detectChanges(watchTargets: Iterable<string>): Set<string> {
+    const changedFiles = new Set<string>();
+    for (const file of watchTargets) {
+      try {
+        const mtime = fs.statSync(file).mtimeMs;
+        const prev = this._prevMtimes.get(file);
+        if (prev != null && prev !== mtime) {
+          changedFiles.add(file);
+        }
+      } catch {
+        if (this._prevMtimes.has(file)) {
+          changedFiles.add(file);
+        }
+      }
+    }
+    this._lastChangedFiles = changedFiles;
+    return changedFiles;
+  }
+
+  updateMtimes(currentWatchTargets: Iterable<string>): void {
+    const targetSet =
+      currentWatchTargets instanceof Set
+        ? (currentWatchTargets as Set<string>)
+        : new Set(currentWatchTargets);
+
+    // 1) 삭제된 파일 정리: prevMtimes에 있지만 watchTargets에 없는 파일 제거
+    for (const file of this._prevMtimes.keys()) {
+      if (!targetSet.has(file)) {
+        this._prevMtimes.delete(file);
+      }
+    }
+
+    // 2) 변경된 파일 mtime 재조회 (watchTargets에 있는 파일만)
+    for (const file of this._lastChangedFiles) {
+      if (!targetSet.has(file)) continue;
+      try {
+        this._prevMtimes.set(file, fs.statSync(file).mtimeMs);
+      } catch {
+        this._prevMtimes.delete(file);
+      }
+    }
+
+    // 3) 신규 파일만 stat (prevMtimes에 없는 파일)
+    for (const file of targetSet) {
+      if (!this._prevMtimes.has(file)) {
+        try {
+          this._prevMtimes.set(file, fs.statSync(file).mtimeMs);
+        } catch {
+          // 삭제된 파일 — 무시
+        }
+      }
+    }
+
+    this._lastChangedFiles = new Set();
+  }
+}