@simplysm/sd-cli 14.0.11 → 14.0.13

package/src/workers/client.worker.ts

@@ -1,6 +1,8 @@
 import { createServer, build as viteBuild, type ViteDevServer } from "vite";
 import path from "path";
 import fs from "node:fs";
+import http from "node:http";
+import mime from "mime";
 import { createWorker } from "@simplysm/core-node";
 import { err as errNs } from "@simplysm/core-common";
 import { consola } from "consola";
@@ -31,8 +33,14 @@ export interface ClientBuildInfo {
   browserSupport?: SdBrowserSupportConfig;
   /** PWA 설정. false로 비활성화. 미설정 시 기본값으로 활성화 */
   pwa?: false | SdPwaConfig;
-  /** Enable lint using ts.Program from compilation */
+  /** 컴파일의 ts.Program을 사용하여 lint 실행 */
   enableLint?: boolean;
+  /** Vite optimizeDeps.exclude에 전달할 패키지 목록 */
+  exclude?: string[];
+  /** 빌드 출력 경로 (미설정 시 pkgDir/dist) */
+  outDir?: string;
+  /** Vite base 경로 (미설정 시 /{pkgName}/) */
+  base?: string;
 }
 
 /** Client 빌드 결과 */
@@ -58,7 +66,113 @@ export interface ClientWorkerEvents extends Record<string, unknown> {
 
 const logger = consola.withTag("sd:cli:client:worker");
 
+/** viteBuild({ build: { watch: {} } }) 반환 타입의 최소 인터페이스 */
+interface WatcherHandle {
+  on(event: string, handler: (event: { code: string; error?: { message: string } }) => void): void;
+  close(): Promise<void>;
+}
+
 let viteServer: ViteDevServer | undefined;
+let rollupWatcher: WatcherHandle | undefined;
+let legacyHttpServer: http.Server | undefined;
+
+/** SSE 연결된 클라이언트 목록 (live reload용) */
+const sseClients = new Set<http.ServerResponse>();
+
+/** SSE 연결된 모든 클라이언트에 reload 신호를 전송한다 */
+function notifyLiveReload(): void {
+  for (const client of sseClients) {
+    client.write("data: reload\n\n");
+  }
+}
+
+
+/** live reload 클라이언트 스크립트 (HTML에 주입) */
+const LIVE_RELOAD_SCRIPT = `<script>(function(){var s=new EventSource("__live-reload");s.onmessage=function(){location.reload();};})()</script>`;
+
+/**
+ * HTML 응답 시 live reload 스크립트를 </body> 직전에 주입한다.
+ */
+function injectLiveReloadScript(html: string): string {
+  const idx = html.lastIndexOf("</body>");
+  if (idx !== -1) {
+    return html.slice(0, idx) + LIVE_RELOAD_SCRIPT + html.slice(idx);
+  }
+  return html + LIVE_RELOAD_SCRIPT;
+}
+
+/**
+ * legacy dev 모드용 HTTP 정적 파일 서버를 생성한다.
+ * dist/ 디렉토리의 파일을 서빙하고, SPA fallback + SSE live reload를 지원한다.
+ */
+function createLegacyHttpServer(distDir: string, basePath: string): http.Server {
+  return http.createServer((req, res) => {
+    const url = (req.url ?? "/").split("?")[0];
+
+    // basePath prefix 제거
+    let relativePath: string;
+    if (url.startsWith(basePath)) {
+      relativePath = url.slice(basePath.length);
+    } else {
+      res.writeHead(404);
+      res.end("Not Found");
+      return;
+    }
+
+    // SSE live reload 엔드포인트
+    if (relativePath === "__live-reload" || relativePath === "/__live-reload") {
+      res.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        "Connection": "keep-alive",
+      });
+      sseClients.add(res);
+      req.on("close", () => {
+        sseClients.delete(res);
+      });
+      return;
+    }
+
+    // 빈 경로 또는 / → index.html
+    if (relativePath === "" || relativePath === "/") {
+      relativePath = "index.html";
+    }
+
+    // 선행 슬래시 제거
+    if (relativePath.startsWith("/")) {
+      relativePath = relativePath.slice(1);
+    }
+
+    const filePath = path.join(distDir, relativePath);
+    const ext = path.extname(filePath);
+
+    // 파일 존재 확인
+    if (fs.existsSync(filePath) && !fs.statSync(filePath).isDirectory()) {
+      const contentType = mime.getType(ext) ?? "application/octet-stream";
+      if (ext === ".html") {
+        // HTML: live reload 스크립트 주입
+        const content = injectLiveReloadScript(fs.readFileSync(filePath, "utf-8"));
+        res.writeHead(200, { "Content-Type": contentType });
+        res.end(content);
+      } else {
+        const content = fs.readFileSync(filePath);
+        res.writeHead(200, { "Content-Type": contentType });
+        res.end(content);
+      }
+    } else {
+      // SPA fallback: index.html 반환 (live reload 스크립트 주입)
+      const indexPath = path.join(distDir, "index.html");
+      if (fs.existsSync(indexPath)) {
+        const content = injectLiveReloadScript(fs.readFileSync(indexPath, "utf-8"));
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(content);
+      } else {
+        res.writeHead(404);
+        res.end("Not Found");
+      }
+    }
+  });
+}
 
 function resolvePackageInfo(info: ClientBuildInfo): {
   tsconfigPath: string;
@@ -77,6 +191,9 @@ function resolvePackageInfo(info: ClientBuildInfo): {
  * 서버가 준비되면 serverReady 이벤트로 포트를 알린다.
  */
 async function startWatch(info: ClientBuildInfo): Promise<ClientBuildResult> {
+  if (info.browserSupport?.legacyModule === true) {
+    return startLegacyWatch(info);
+  }
   logger.debug(`[${info.name}] client worker startWatch 시작 (port: ${info.port ?? "auto"})`);
   try {
     const { tsconfigPath, pkgName } = resolvePackageInfo(info);
@@ -102,6 +219,7 @@ async function startWatch(info: ClientBuildInfo): Promise<ClientBuildResult> {
       legacyModule: info.browserSupport?.legacyModule,
       polyfills,
       pwa: info.pwa,
+      exclude: info.exclude,
     });
 
     logger.debug(`[${info.name}] Vite server 생성 시작`);
@@ -138,15 +256,134 @@ async function startWatch(info: ClientBuildInfo): Promise<ClientBuildResult> {
 }
 
 /**
- * dev server 중지. Vite server를 정리한다.
+ * legacy watch 시작. Vite build --watch로 파일 변경을 감시한다.
+ * legacyModule: true일 때 createServer 대신 사용한다.
+ */
+async function startLegacyWatch(info: ClientBuildInfo): Promise<ClientBuildResult> {
+  logger.debug(`[${info.name}] client worker startLegacyWatch 시작`);
+  try {
+    const { tsconfigPath, pkgName } = resolvePackageInfo(info);
+
+    // dist 초기화 (첫 빌드만 비움)
+    const distDir = path.join(info.pkgDir, "dist");
+    fs.rmSync(distDir, { recursive: true, force: true });
+
+    // polyfills.ts 자동 감지
+    const polyfillsPath = path.join(info.pkgDir, "src", "polyfills.ts");
+    const polyfills = fs.existsSync(polyfillsPath) ? ["./src/polyfills.ts"] : undefined;
+
+    const viteConfig = await createClientViteConfig({
+      pkgDir: info.pkgDir,
+      pkgName,
+      mode: "build",
+      tsconfigPath,
+      serverPort: 0,
+      env: info.env,
+      watch: true,
+      onBuildStart: () => sender.send("buildStart", {}),
+      onBuild: (result) => sender.send("build", result),
+      enableLint: info.enableLint,
+      replaceDeps: info.replaceDeps,
+      onScopeRebuild: () => sender.send("scopeRebuild", {}),
+      browserslist: info.browserSupport?.browserslist,
+      postCssPlugins: info.browserSupport?.postCss?.plugins,
+      legacyModule: info.browserSupport?.legacyModule,
+      polyfills,
+      pwa: false,
+      exclude: info.exclude,
+    });
+
+    const watcher = (await viteBuild(viteConfig)) as WatcherHandle;
+    rollupWatcher = watcher;
+
+    // .config.json 생성
+    writeConfigJson(info.pkgDir, info.configs);
+
+    // HTTP 정적 파일 서버 시작
+    const name = pkgName.replace(/^@[^/]+\//, "");
+    const basePath = `/${name}/`;
+    const httpServer = createLegacyHttpServer(distDir, basePath);
+    legacyHttpServer = httpServer;
+
+    const serverPort = await new Promise<number>((resolve, reject) => {
+      httpServer.listen(info.port ?? 0, "0.0.0.0", () => {
+        const addr = httpServer.address();
+        if (typeof addr === "object" && addr != null) {
+          resolve(addr.port);
+        } else {
+          reject(new Error("HTTP 서버 포트를 감지할 수 없습니다."));
+        }
+      });
+      httpServer.on("error", reject);
+    });
+
+    sender.send("serverReady", { port: serverPort });
+
+    // 첫 빌드 완료 대기
+    return await new Promise<ClientBuildResult>((resolve) => {
+      let firstBuildResolved = false;
+
+      watcher.on("event", (event: { code: string; error?: { message: string } }) => {
+        if (event.code === "END") {
+          if (!firstBuildResolved) {
+            firstBuildResolved = true;
+            resolve({ success: true });
+          } else {
+            // 재빌드 완료 → 브라우저 live reload
+            notifyLiveReload();
+          }
+        } else if (event.code === "ERROR") {
+          const message = event.error?.message ?? "Unknown build error";
+          sender.send("error", { message });
+          if (!firstBuildResolved) {
+            firstBuildResolved = true;
+            resolve({ success: false, errors: [message] });
+          }
+        }
+      });
+    });
+  } catch (err) {
+    const message = errNs.message(err);
+    sender.send("error", { message });
+    return { success: false, errors: [message] };
+  }
+}
+
+/**
+ * dev server 중지. Vite server 또는 RollupWatcher를 정리한다.
  */
 async function stopWatch(): Promise<void> {
   logger.debug("Vite server 정리 시작");
+
+  const watcherToClose = rollupWatcher;
+  rollupWatcher = undefined;
+  if (watcherToClose != null) {
+    await watcherToClose.close();
+  }
+
+  // SSE 클라이언트 정리
+  for (const client of sseClients) {
+    client.end();
+  }
+  sseClients.clear();
+
+  const httpServerToClose = legacyHttpServer;
+  legacyHttpServer = undefined;
+  if (httpServerToClose != null) {
+    await new Promise<void>((resolve, reject) => {
+      httpServerToClose.close((err) => {
+        if (err != null) reject(err);
+        else resolve();
+      });
+    });
+  }
+
   const serverToClose = viteServer;
   viteServer = undefined;
   if (serverToClose != null) {
     await serverToClose.close();
   }
+
   logger.debug("Vite server 정리 완료");
 }
 
@@ -182,12 +419,15 @@ async function build(info: ClientBuildInfo): Promise<ClientBuildResult> {
       legacyModule: info.browserSupport?.legacyModule,
       polyfills,
       pwa: info.pwa,
+      exclude: info.exclude,
+      outDir: info.outDir,
+      base: info.base,
     });
 
     await viteBuild(viteConfig);
 
-    // .config.json 생성
-    writeConfigJson(info.pkgDir, info.configs);
+    // .config.json 생성 (항상 dist/에 기록 — outDir과 무관)
+    writeConfigJson(path.join(info.pkgDir, "dist"), info.configs);
 
     logger.debug(`[${info.name}] client worker build 완료`);
     return { success: true, lint: lintResult };
@@ -198,12 +438,11 @@ async function build(info: ClientBuildInfo): Promise<ClientBuildResult> {
   }
 }
 
-/** dist/.config.json 생성 */
+/** .config.json 생성 */
 function writeConfigJson(
-  pkgDir: string,
+  distDir: string,
   configs?: Record<string, unknown>,
 ): void {
-  const distDir = path.join(pkgDir, "dist");
   fs.mkdirSync(distDir, { recursive: true });
   fs.writeFileSync(
     path.join(distDir, ".config.json"),

package/src/workers/library-build.worker.ts

@@ -21,7 +21,7 @@ export interface LibraryBuildInfo {
   cwd: string;
   pkgDir: string;
   output: BuildOutput;
-  /** replaceDeps configuration from sd.config.ts */
+  /** sd.config.ts의 replaceDeps 설정 */
   replaceDeps?: Record<string, string>;
 }
 
@@ -73,7 +73,7 @@ async function build(info: LibraryBuildInfo): Promise<LibraryBuildResult> {
   });
   logger.debug(`[${info.name}] library worker build 완료 (success: ${tscResult.success})`);
 
-  // Run lint if enabled and program is available
+  // lint 실행 (활성화 + program 사용 가능 시)
   let lint: LintWithProgramResult | undefined;
   if (info.output.lint === true && tscResult.program != null) {
     logger.debug(`[${info.name}] lint 시작`);
@@ -102,7 +102,7 @@ async function build(info: LibraryBuildInfo): Promise<LibraryBuildResult> {
 
 const guardStartWatch = createOnceGuard("startWatch");
 
-// Mutable state for watch mode
+// watch 모드용 가변 상태
 let watchInfo: LibraryBuildInfo | undefined;
 let watchLintRunner: LintWithProgramRunner | undefined;
 let lastSourceFilePaths: Set<string> | undefined;
@@ -128,10 +128,10 @@ async function rebuildAll(): Promise<CombinedBuildEvent> {
     includeTests: info.output.includeTests,
   });
 
-  // Update source file paths for dependency filtering
+  // 의존성 필터링을 위한 소스 파일 경로 업데이트
   lastSourceFilePaths = extractSourceFilePaths(tscResult.program) ?? lastSourceFilePaths;
 
-  // Run lint if enabled and program is available
+  // lint 실행 (활성화 + program 사용 가능 시)
   let lint: LintWithProgramResult | undefined;
   if (info.output.lint === true && tscResult.program != null) {
     logger.debug(`[${info.name}] lint 시작`);
@@ -160,14 +160,14 @@ async function startWatch(info: LibraryBuildInfo): Promise<void> {
   watchInfo = info;
 
   try {
-    // Initial build
+    // 초기 빌드
     const initialResult = await rebuildAll();
     sender.send("build", initialResult);
 
-    // Collect workspace dependency paths + replaceDeps
+    // workspace 의존성 경로 + replaceDeps 수집
     const { workspaceDeps, replaceDeps } = collectDeps(info.pkgDir, info.cwd, info.replaceDeps);
 
-    // Start FsWatcher — own src/ + workspace deps' src/ + replaceDeps dist/
+    // FsWatcher 시작 — 자체 src/ + workspace 의존성 src/ + replaceDeps dist/
     logger.debug(`[${info.name}] FsWatcher 시작`);
     const watchPaths = [
       pathx.posixResolve(info.pkgDir, "src", "**", "*.ts"),

package/src/workers/lint.worker.ts

@@ -4,8 +4,8 @@ import { executeLint, type LintOptions, type LintResult } from "../commands/lint
 //#region Worker
 
 /**
- * Lint worker.
- * Worker to run lint in separate thread from check command and BuildOrchestrator
+ * lint 워커.
+ * check 명령어와 BuildOrchestrator에서 별도 스레드로 lint를 실행하는 워커
  */
 async function lint(options: LintOptions): Promise<LintResult> {
   return executeLint(options);

package/src/workers/ngtsc-build.worker.ts

@@ -30,7 +30,7 @@ import { collectDeps } from "../utils/package-utils";
 
 applyDebugLevel();
 
-//#region Types (re-export for worker interface)
+//#region 타입 (워커 인터페이스용 re-export)
 
 export type { NgtscBuildInfo, NgtscBuildResult, NgtscCombinedBuildEvent };
 
@@ -69,7 +69,7 @@ async function build(info: NgtscBuildInfo): Promise<NgtscBuildResult> {
   const { program, ...result } = await runNgtscBuild({ ...info, env: info.output.env });
   logger.debug(`[${info.name}] ngtsc worker build 완료 (build.success: ${result.build.success})`);
 
-  // Run lint if enabled and program is available
+  // lint 실행 (활성화 + program 사용 가능 시)
   if (info.output.lint === true && program != null) {
     logger.debug(`[${info.name}] lint 시작`);
     const lintRunner = new LintWithProgramRunner({
@@ -104,11 +104,11 @@ function extractSourceFilePaths(program: ReturnType<AngularCompiler["getTsProgra
 }
 
 /**
- * Perform a watch build (initial or incremental) using AngularCompiler.
- * Returns NgtscCombinedBuildEvent for sending to the engine.
+ * AngularCompiler를 사용하여 watch 빌드(초기 또는 증분)를 수행한다.
+ * 엔진에 전송할 NgtscCombinedBuildEvent를 반환한다.
  *
- * @param affectedFileNames - When provided (watch rebuild), only these files are linted.
- *   When undefined (initial build), all workspace files are linted.
+ * @param affectedFileNames - 제공 시(watch 재빌드) 해당 파일만 lint 수행.
+ *   미제공 시(초기 빌드) workspace 전체 파일을 lint 수행.
  */
 async function performWatchBuild(
   info: NgtscBuildInfo,
@@ -122,7 +122,7 @@ async function performWatchBuild(
   const pkgSrcDir = path.join(info.pkgDir, "src");
   const normalizedSrcDir = pathx.posix(pkgSrcDir);
 
-  // Collect diagnostics — workspace scope (no package-level filtering)
+  // 진단 수집 — workspace 스코프 (패키지 단위 필터링 없음)
   const allDiagnostics = [...compiler.collectDiagnostics()].filter(
     (d) => isWorkspaceDiagnostic(d, info.cwd),
   );
@@ -134,7 +134,7 @@ async function performWatchBuild(
     .filter((d) => d.category === ts.DiagnosticCategory.Error)
     .map(formatDiagnosticError);
 
-  // Emit via AngularCompiler + output-path-rewriting
+  // AngularCompiler로 emit + output-path-rewriting 적용
   const loadPaths = buildScssLoadPaths(info);
   const emitResults = compiler.emitAffectedFiles({
     sourceFilter: (fileName: string) =>
@@ -147,17 +147,17 @@ async function performWatchBuild(
     registry: sideEffectScssRegistry,
   });
 
-  // Side-effect SCSS compilation (skip when no .scss/.css files changed)
+  // 사이드 이펙트 SCSS 컴파일 (.scss/.css 파일 변경 없으면 건너뜀)
   if (hasScssChanges) {
     compileSideEffectScss(sideEffectScssRegistry, loadPaths, scssErrors, scssDependencies);
   }
 
-  // Global SCSS compilation
+  // 전역 SCSS 컴파일
   const globalScssErrors = compileGlobalScss(info.pkgDir, loadPaths);
 
   const allErrors = [...errors, ...scssErrors, ...globalScssErrors];
 
-  // Run lint if enabled
+  // lint 실행 (활성화 시)
   let lint: LintWithProgramResult | undefined;
   if (info.output.lint === true) {
     logger.debug(`[${info.name}] lint 시작`);
@@ -189,7 +189,7 @@ async function startWatch(info: NgtscBuildInfo): Promise<void> {
   watchInfo = { ...info, env: info.output.env };
 
   try {
-    // Parse tsconfig and prepare compiler options
+    // tsconfig 파싱 및 컴파일러 옵션 준비
     const parsedConfig = parseTsconfig(watchInfo.pkgDir);
     const sourceFiles = watchInfo.output.includeTests === true
       ? getPackageFiles(watchInfo.pkgDir, parsedConfig)
@@ -202,13 +202,13 @@ async function startWatch(info: NgtscBuildInfo): Promise<void> {
 
     const angularOptions = (parsedConfig.raw?.angularCompilerOptions ?? {}) as Record<string, unknown>;
 
-    // SCSS closure variables
+    // SCSS 클로저 변수
     const scssErrors: string[] = [];
     const scssDependencies = new Map<string, Set<string>>();
     const loadPaths = buildScssLoadPaths(watchInfo);
     currentScssDependencies = scssDependencies;
 
-    // Create AngularSourceFileCache + AngularCompiler
+    // AngularSourceFileCache + AngularCompiler 생성
     const sourceFileCache = new AngularSourceFileCache();
     const compiler = new AngularCompiler({
       rootNames: sourceFiles,
@@ -217,34 +217,34 @@ async function startWatch(info: NgtscBuildInfo): Promise<void> {
       sourceFileCache,
       transformStylesheet: createLibraryTransformStylesheet(loadPaths, scssErrors, scssDependencies),
     });
-    // Initial build
+    // 초기 빌드
     await compiler.initialize();
     lastSourceFilePaths = extractSourceFilePaths(compiler.getTsProgram());
     const initialResult = await performWatchBuild(watchInfo, compiler, scssDependencies, scssErrors);
     sender.send("build", initialResult);
 
-    // Collect workspace dependency paths + replaceDeps
+    // workspace 의존성 경로 + replaceDeps 수집
     const { workspaceDeps, replaceDeps } = collectDeps(
       watchInfo.pkgDir,
       watchInfo.cwd,
       watchInfo.replaceDeps,
     );
 
-    // Start FsWatcher
+    // FsWatcher 시작
     logger.debug(`[${watchInfo.name}] FsWatcher 시작`);
     const watchPaths = [
-      path.join(watchInfo.pkgDir, "src", "**", "*.{ts,scss,css}"),
-      path.join(watchInfo.pkgDir, "scss", "**", "*.{scss,css}"),
+      pathx.posixResolve(watchInfo.pkgDir, "src", "**", "*.{ts,scss,css}"),
+      pathx.posixResolve(watchInfo.pkgDir, "scss", "**", "*.{scss,css}"),
       ...workspaceDeps.flatMap((d) => {
-        const depDir = path.join(watchInfo!.cwd, "packages", d);
+        const depDir = pathx.posixResolve(watchInfo!.cwd, "packages", d);
         return [
-          path.join(depDir, "src", "**", "*.{ts,scss,css}"),
-          path.join(depDir, "scss", "**", "*.{scss,css}"),
+          pathx.posixResolve(depDir, "src", "**", "*.{ts,scss,css}"),
+          pathx.posixResolve(depDir, "scss", "**", "*.{scss,css}"),
         ];
       }),
       ...replaceDeps.flatMap((pkg) => [
-        path.join(watchInfo!.cwd, "node_modules", ...pkg.split("/"), "dist", "**", "*.{js,mjs,cjs}"),
-        path.join(watchInfo!.pkgDir, "node_modules", ...pkg.split("/"), "dist", "**", "*.{js,mjs,cjs}"),
+        pathx.posixResolve(watchInfo!.cwd, "node_modules", ...pkg.split("/"), "dist", "**", "*.{js,mjs,cjs}"),
+        pathx.posixResolve(watchInfo!.pkgDir, "node_modules", ...pkg.split("/"), "dist", "**", "*.{js,mjs,cjs}"),
       ]),
     ];
     fsWatcher = await FsWatcher.watch(watchPaths);
@@ -255,12 +255,12 @@ async function startWatch(info: NgtscBuildInfo): Promise<void> {
           (c) => c.event === "add" || c.event === "unlink",
         );
 
-        // Collect modified files (all changed + SCSS dependency reverse-lookup)
+        // 변경된 파일 수집 (전체 변경 + SCSS 의존성 역방향 탐색)
         const modifiedFiles = new Set<string>();
         for (const f of changedFiles) {
           modifiedFiles.add(f.path);
 
-          // SCSS dependency reverse-lookup
+          // SCSS 의존성 역방향 탐색
           if (
             (f.path.endsWith(".scss") || f.path.endsWith(".css")) &&
             currentScssDependencies != null
@@ -273,7 +273,7 @@ async function startWatch(info: NgtscBuildInfo): Promise<void> {
           }
         }
 
-        // Dependency filter: skip rebuild if no relevant changes
+        // 의존성 필터: 관련 변경이 없으면 리빌드 건너뜀
         if (!hasFileAddOrRemove && lastSourceFilePaths != null) {
           const hasRelevantChange = [...modifiedFiles].some((p) =>
             lastSourceFilePaths!.has(p),
@@ -286,17 +286,17 @@ async function startWatch(info: NgtscBuildInfo): Promise<void> {
 
         sender.send("buildStart", {});
 
-        // Clear SCSS errors for fresh rebuild
+        // 새 리빌드를 위해 SCSS 에러 초기화
         scssErrors.length = 0;
         scssDependencies.clear();
 
-        // Incremental rebuild via AngularCompiler.update()
+        // AngularCompiler.update()를 통한 증분 리빌드
         const updateResult = await compiler.update(modifiedFiles);
 
-        // Update source file paths after rebuild
+        // 리빌드 후 소스 파일 경로 업데이트
         lastSourceFilePaths = extractSourceFilePaths(compiler.getTsProgram());
 
-        // Convert affected ts.SourceFile set to file name strings for incremental lint
+        // 증분 lint를 위해 영향받은 ts.SourceFile 집합을 파일명 문자열로 변환
         const affectedFileNames = new Set<string>();
         for (const sf of updateResult.affectedFiles) {
           affectedFileNames.add(pathx.posix(sf.fileName));