@simplysm/sd-cli 14.0.46 → 14.0.48

package/src/deps/replace-deps/replace-deps.ts

@@ -50,14 +50,27 @@ async function copyWithUnlink(
   if (stats.isDirectory()) {
     await fsx.mkdir(targetPath);
     const names = await fs.promises.readdir(sourcePath);
+    const allowedChildren = names
+      .map((name) => path.resolve(sourcePath, name))
+      .filter((child) => filter == null || filter(child));
+    const allowedBasenames = new Set(allowedChildren.map((c) => path.basename(c)));
+
+    // 고아 엔트리 정리: filter 범위 내이면서 소스에 없는 타겟 엔트리 삭제
+    const targetNames = await fs.promises.readdir(targetPath).catch(() => [] as string[]);
+    await Promise.all(
+      targetNames.map(async (name) => {
+        const targetChild = path.join(targetPath, name);
+        if (filter != null && !filter(targetChild)) return;
+        if (allowedBasenames.has(name)) return;
+        await fs.promises.rm(targetChild, { recursive: true, force: true });
+      }),
+    );
+
     await Promise.all(
-      names
-        .map((name) => path.resolve(sourcePath, name))
-        .filter((child) => filter == null || filter(child))
-        .map((child) => copyWithUnlink(
-          child,
-          path.join(targetPath, path.basename(child)),
-        )),
+      allowedChildren.map((child) => copyWithUnlink(
+        child,
+        path.join(targetPath, path.basename(child)),
+      )),
     );
   } else {
     if (await isFileContentSame(sourcePath, targetPath)) return;
@@ -201,115 +214,136 @@ export async function watchReplaceDeps(
 
   const entries = await resolveAllReplaceDepEntries(projectRoot, replaceDeps, logger);
 
-  // 소스 디렉토리 감시자 설정
-  const watchers: FsWatcher[] = [];
-  const watchedSources = new Set<string>();
-
   logger.start(`replace-deps 워치 시작 중... (${entries.length}개 대상)`);
 
+  // resolvedSourcePath(posix) → entries 그룹화
+  // resolvedSourcePath는 replace-deps-resolve의 pathx.posixResolve 결과로 이미 POSIX이다.
+  const sourceMap = new Map<string, ReplaceDepEntry[]>();
   for (const entry of entries) {
-    if (watchedSources.has(entry.resolvedSourcePath)) continue;
-    watchedSources.add(entry.resolvedSourcePath);
+    const key = entry.resolvedSourcePath;
+    const arr = sourceMap.get(key) ?? [];
+    arr.push(entry);
+    sourceMap.set(key, arr);
+  }
 
-    try {
-      // 소스 패키지의 files 필드를 읽어 감시 대상 경로 구성
-      const files = await loadFilesField(entry.resolvedSourcePath);
-      if (files == null) {
-        logger.warn(`[${entry.targetName}] package.json에 files 필드가 없어 감시 건너뜀`);
-        continue;
-      }
+  // 각 source의 watchPaths 수집 (files 필드 없는 source는 경고 후 제외). source 단위 병렬.
+  const allWatchPaths = new Set<string>();
+  await Promise.all(
+    [...sourceMap].map(async ([sourcePath, sourceEntries]) => {
+      try {
+        const files = await loadFilesField(sourcePath);
+
+        if (files == null) {
+          logger.warn(
+            `[${sourceEntries[0].targetName}] package.json에 files 필드가 없어 감시 건너뜀`,
+          );
+          sourceMap.delete(sourcePath);
+          return;
+        }
 
-      // files 항목 경로 + npm 기본 파일 경로
-      const watchPaths = files.map((f) =>
-        pathx.posix(path.join(entry.resolvedSourcePath, f)),
-      );
+        for (const f of files) {
+          allWatchPaths.add(pathx.posix(path.join(sourcePath, f)));
+        }
 
-      // 소스 루트에서 npm 기본 파일 패턴에 매칭되는 파일 추가
-      try {
-        const rootEntries = await fs.promises.readdir(entry.resolvedSourcePath);
+        const rootEntries = await fs.promises
+          .readdir(sourcePath)
+          .catch(() => [] as string[]);
         for (const name of rootEntries) {
           if (NPM_DEFAULT_FILE_PATTERN.test(name)) {
-            watchPaths.push(pathx.posix(path.join(entry.resolvedSourcePath, name)));
+            allWatchPaths.add(pathx.posix(path.join(sourcePath, name)));
           }
         }
-      } catch {
-        // readdir 실패 시 npm 기본 파일 감시 생략
+      } catch (err) {
+        logger.error(
+          `[${sourceEntries[0].targetName}] 감시 설정 실패: ${err instanceof Error ? err.message : err}`,
+        );
+        sourceMap.delete(sourcePath);
       }
+    }),
+  );
+
+  if (allWatchPaths.size === 0) {
+    if (entries.length > 0) {
+      logger.warn("감시 대상이 없어 워치가 시작되지 않음");
+    } else {
+      logger.success("replace-deps 워치 준비 완료");
+    }
+    return { entries, dispose: () => {} };
+  }
 
-      // 이 소스 경로에 해당하는 entries만 사전 필터링하여 캡처
-      const sourceEntries = entries.filter(
-        (e) => e.resolvedSourcePath === entry.resolvedSourcePath,
-      );
+  // longest-prefix 매칭을 위해 긴 경로 우선 정렬
+  const sortedSources = [...sourceMap.keys()].sort((a, b) => b.length - a.length);
+
+  const findSource = (changedPath: string): string | undefined => {
+    for (const src of sortedSources) {
+      if (changedPath === src || changedPath.startsWith(src + "/")) return src;
+    }
+    return undefined;
+  };
+
+  const watcher = await FsWatcher.watch([...allWatchPaths], {
+    followSymlinks: false,
+  });
 
-      const watcher = await FsWatcher.watch(watchPaths, {
-        followSymlinks: false,
-      });
-      watcher.onChange({ delay: 300 }, async (changeInfos) => {
-        let hasActualCopy = false;
+  watcher.onChange({ delay: 300 }, async (changeInfos) => {
+    const flags = await Promise.all(
+      changeInfos.map(async ({ path: changedPath }) => {
+        const src = findSource(changedPath);
+        if (src == null) return false;
+        const sourceEntries = sourceMap.get(src)!;
 
-        for (const { path: changedPath } of changeInfos) {
-          // 사전 필터링된 항목만 순회
-          for (const e of sourceEntries) {
-            // 소스로부터의 상대 경로 계산
-            const relativePath = pathx.posix(path.relative(e.resolvedSourcePath, changedPath));
-            const destPath = pathx.posix(path.join(e.actualTargetPath, relativePath));
+        let localActualCopy = false;
 
+        // 동일 source의 복수 target 복사는 순차로 유지한다 (destination 중복 시 race 방지).
+        for (const e of sourceEntries) {
+          const relativePath = pathx.posix(path.relative(e.resolvedSourcePath, changedPath));
+          const destPath = pathx.posix(path.join(e.actualTargetPath, relativePath));
+
+          try {
+            let sourceExists = false;
             try {
-              // 소스 존재 여부 확인
-              let sourceExists = false;
-              try {
-                await fs.promises.access(changedPath);
-                sourceExists = true;
-              } catch {
-                // 소스가 삭제됨
-              }
+              await fs.promises.access(changedPath);
+              sourceExists = true;
+            } catch {
+              // 소스가 삭제됨
+            }
 
-              if (sourceExists) {
-                // 소스가 디렉토리인지 파일인지 확인
-                const stat = await fs.promises.stat(changedPath);
-                if (stat.isDirectory()) {
-                  await fsx.mkdir(destPath);
-                } else {
-                  // 파일 내용이 동일하면 복사 건너뜀 (불필요한 리빌드 방지)
-                  if (await isFileContentSame(changedPath, destPath)) continue;
-                  await fsx.mkdir(pathx.posix(path.dirname(destPath)));
-                  await fsx.copy(changedPath, destPath);
-                  hasActualCopy = true;
-                }
+            if (sourceExists) {
+              const stat = await fs.promises.stat(changedPath);
+              if (stat.isDirectory()) {
+                await fsx.mkdir(destPath);
               } else {
-                // 소스가 삭제됨 → 대상도 삭제
-                await fsx.rm(destPath);
-                hasActualCopy = true;
+                if (await isFileContentSame(changedPath, destPath)) continue;
+                await fsx.mkdir(pathx.posix(path.dirname(destPath)));
+                await fsx.copy(changedPath, destPath);
+                localActualCopy = true;
               }
-            } catch (err) {
-              logger.error(
-                `[${e.targetName}] 복사 실패 (${relativePath}): ${err instanceof Error ? err.message : err}`,
-              );
+            } else {
+              await fsx.rm(destPath);
+              localActualCopy = true;
             }
+          } catch (err) {
+            logger.error(
+              `[${e.targetName}] 복사 실패 (${relativePath}): ${err instanceof Error ? err.message : err}`,
+            );
           }
         }
 
-        if (hasActualCopy) {
-          options?.onChanged?.();
-        }
-      });
+        return localActualCopy;
+      }),
+    );
 
-      watchers.push(watcher);
-    } catch (err) {
-      logger.error(
-        `[${entry.targetName}] 감시 설정 실패: ${err instanceof Error ? err.message : err}`,
-      );
+    if (flags.some((f) => f)) {
+      options?.onChanged?.();
     }
-  }
+  });
 
   logger.success("replace-deps 워치 준비 완료");
 
   return {
     entries,
     dispose: () => {
-      for (const watcher of watchers) {
-        void watcher.close();
-      }
+      void watcher.close();
     },
   };
 }

package/src/deps/server-externals/server-production-files.ts

@@ -4,10 +4,10 @@ import fs from "fs";
 import YAML from "yaml";
 import TOML from "smol-toml";
 import { cpx } from "@simplysm/core-node";
-import { consola } from "consola";
+import { createLazyLogger } from "../../runtime/lazy-logger";
 import { collectAllDependencyExternals } from "../../esbuild/esbuild-config";
 
-const logger = consola.withTag("sd:cli:server-production-files");
+const logger = createLazyLogger("sd:cli:server-production-files");
 
 /**
  * 외부 모듈을 두 용도로 분리하여 수집한다.

package/src/electron/electron.ts

@@ -3,11 +3,12 @@ import fs from "fs";
 import module from "module";
 import { cpx, fsx, pathx } from "@simplysm/core-node";
 import { consola, LogLevels } from "consola";
+import { createLazyLogger } from "../runtime/lazy-logger";
 import type { NpmConfig, SdElectronConfig } from "../sd-config.types.js";
 import { createEnvBanner } from "../esbuild/esbuild-config.js";
 
 export class Electron {
-  private static readonly _logger = consola.withTag("sd:cli:electron");
+  private static readonly _logger = createLazyLogger("sd:cli:electron");
 
   private readonly _electronPath: string;
   private readonly _srcPath: string;

package/src/engines/BaseEngine.ts

@@ -1,15 +1,15 @@
 import { Worker, type WorkerProxy } from "@simplysm/core-node";
 import { err as errNs } from "@simplysm/core-common";
-import { consola } from "consola";
 import type { BuildResult, ResultCollector } from "../runtime/ResultCollector";
 import { stopEngineWorker } from "../runtime/engine-stop";
 import { setupWatchEvents } from "../runtime/engine-watch-events";
+import { createLazyLogger } from "../runtime/lazy-logger";
 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");
+const logger = createLazyLogger("sd:cli:engine");
 
 /**
  * 모든 빌드 워커가 공유하는 공통 빌드 워커 이벤트

package/src/engines/EsbuildClientEngine.ts

@@ -1,15 +1,15 @@
 import fs from "node:fs";
 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 { ResultCollector } from "../runtime/ResultCollector";
 import { stopEngineWorker } from "../runtime/engine-stop";
 import { setupWatchEvents, type NormalizedBuildInfo } from "../runtime/engine-watch-events";
+import { createLazyLogger } from "../runtime/lazy-logger";
 import type { RebuildManager } from "../runtime/rebuild-manager";
 import type { BuildEngine, BuildOutput, ClientPackageInfo, EngineResult } from "./types";
 
-const logger = consola.withTag("sd:cli:engine:esbuild-client");
+const logger = createLazyLogger("sd:cli:engine:esbuild-client");
 
 /**
  * EsbuildClientEngine 옵션

package/src/engines/NgtscEngine.ts

@@ -3,9 +3,9 @@ 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";
+import { createLazyLogger } from "../runtime/lazy-logger";
 
-const logger = consola.withTag("sd:cli:engine:ngtsc");
+const logger = createLazyLogger("sd:cli:engine:ngtsc");
 
 /**
  * NgtscEngine 옵션

package/src/engines/ServerEsbuildEngine.ts

@@ -3,9 +3,9 @@ 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";
+import { createLazyLogger } from "../runtime/lazy-logger";
 
-const logger = consola.withTag("sd:cli:engine:server");
+const logger = createLazyLogger("sd:cli:engine:server");
 
 /**
  * ServerEsbuildEngine 옵션

package/src/engines/TscEngine.ts

@@ -3,9 +3,9 @@ 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";
+import { createLazyLogger } from "../runtime/lazy-logger";
 
-const logger = consola.withTag("sd:cli:engine:tsc");
+const logger = createLazyLogger("sd:cli:engine:tsc");
 
 /**
  * TscEngine 옵션

package/src/engines/engine-factory.ts

@@ -1,5 +1,5 @@
-import { consola } from "consola";
 import type { ResultCollector } from "../runtime/ResultCollector";
+import { createLazyLogger } from "../runtime/lazy-logger";
 import type { RebuildManager } from "../runtime/rebuild-manager";
 import { hasAngularCoreDependency } from "../utils/package-utils";
 import { NgtscEngine } from "./NgtscEngine";
@@ -8,7 +8,7 @@ import { TscEngine } from "./TscEngine";
 import { EsbuildClientEngine } from "./EsbuildClientEngine";
 import type { BuildEngine, BuildPackageInfo, ClientPackageInfo, ServerPackageInfo } from "./types";
 
-const logger = consola.withTag("sd:cli:engine");
+const logger = createLazyLogger("sd:cli:engine");
 
 
 /**

package/src/esbuild/esbuild-angular-compiler-plugin.ts

@@ -3,10 +3,13 @@ import fs from "fs";
 import os from "os";
 import ts from "typescript";
 import type esbuild from "esbuild";
-import { consola } from "consola";
 import { JavaScriptTransformer, Cache as AngularCache } from "@angular/build/private";
+import { createLazyLogger } from "../runtime/lazy-logger";
 import type { AngularSourceFileCache } from "../angular/angular-compiler";
-import type { SerializedDiagnostic } from "../typecheck/typecheck-serialization";
+import type {
+  SerializedDiagnostic,
+  SerializedMessageChain,
+} from "../typecheck/typecheck-serialization";
 import { SdTsCompiler } from "../ts-compiler/SdTsCompiler";
 import type { ISdTsCompilerResult } from "../ts-compiler/sd-ts-compiler-result";
 import { FileReferenceTracker } from "./file-reference-tracker";
@@ -15,7 +18,7 @@ import { createCachedLoad, type LoadResultCache } from "./load-result-cache";
 import { collectHmrCandidates, HMR_MODIFIED_FILE_LIMIT } from "../angular/hmr-candidates";
 import { transformWorkerPatterns } from "./esbuild-worker-plugin";
 
-const logger = consola.withTag("sd:cli:angular-plugin");
+const logger = createLazyLogger("sd:cli:angular-plugin");
 
 //#region Types
 
@@ -125,29 +128,67 @@ export function convertDiagnostic(
   return { text, location };
 }
 
+function flattenSerializedMessage(
+  messageText: string | SerializedMessageChain,
+  indent = 0,
+): string {
+  if (typeof messageText === "string") return messageText;
+  const prefix = "  ".repeat(indent);
+  let text = prefix + messageText.messageText;
+  if (messageText.next != null) {
+    for (const n of messageText.next) {
+      text += "\n" + flattenSerializedMessage(n, indent + 1);
+    }
+  }
+  return text;
+}
+
+function locationOf(
+  fileInfo: { fileName: string } | undefined,
+  start: number | undefined,
+  length: number | undefined,
+  program: ts.Program,
+  cwd: string,
+): esbuild.PartialMessage["location"] {
+  if (fileInfo == null || start == null) return null;
+  const sf = program.getSourceFile(fileInfo.fileName);
+  if (sf == null) return null;
+  const pos = sf.getLineAndCharacterOfPosition(start);
+  const lineStart = sf.getLineStarts()[pos.line];
+  const lineEnd = sf.getLineStarts()[pos.line + 1] ?? sf.text.length;
+  const lineText = sf.text.slice(lineStart, lineEnd).replace(/\r?\n$/, "");
+  return {
+    file: path.relative(cwd, fileInfo.fileName),
+    line: pos.line + 1,
+    column: pos.character,
+    lineText,
+    length: length ?? 0,
+  };
+}
+
 export function convertSerializedDiagnosticToEsbuild(
   d: SerializedDiagnostic,
   program: ts.Program,
   cwd: string,
 ): esbuild.PartialMessage {
-  let location: esbuild.PartialMessage["location"] = null;
-  if (d.file != null && d.start != null) {
-    const sf = program.getSourceFile(d.file.fileName);
-    if (sf != null) {
-      const pos = sf.getLineAndCharacterOfPosition(d.start);
-      const lineStart = sf.getLineStarts()[pos.line];
-      const lineEnd = sf.getLineStarts()[pos.line + 1] ?? sf.text.length;
-      const lineText = sf.text.slice(lineStart, lineEnd).replace(/\r?\n$/, "");
-      location = {
-        file: path.relative(cwd, d.file.fileName),
-        line: pos.line + 1,
-        column: pos.character,
-        lineText,
-        length: d.length ?? 0,
-      };
+  const location = locationOf(d.file, d.start, d.length, program, cwd);
+  const text = flattenSerializedMessage(d.messageText);
+
+  const notes: esbuild.PartialNote[] = [];
+  if (d.relatedInformation != null) {
+    for (const ri of d.relatedInformation) {
+      notes.push({
+        text: flattenSerializedMessage(ri.messageText),
+        location: locationOf(ri.file, ri.start, ri.length, program, cwd),
+      });
     }
   }
-  return { text: d.messageText, location };
+
+  return {
+    text,
+    location,
+    notes: notes.length > 0 ? notes : undefined,
+  };
 }
 
 //#endregion
@@ -340,7 +381,11 @@ export function createAngularCompilerPlugin(
           // ── emitResults → typeScriptFileCache (Worker 패턴 처리 포함) ──
           for (const { contents, sourceFileName } of compileResult.emitResults ?? []) {
             const normalized = path.normalize(sourceFileName);
-            const workerResult = transformWorkerPatterns(contents, normalized, build);
+            // emitResults.contents는 ngtsc가 이미 JS로 방출한 결과이므로 TS 재변환 스킵.
+            // sourceFileName은 원본 .ts 경로이지만 content는 JS이다.
+            const workerResult = transformWorkerPatterns(contents, normalized, build, {
+              skipTsTransform: true,
+            });
             if (workerResult != null) {
               typeScriptFileCache.set(normalized, workerResult.contents);
               errors.push(...workerResult.errors);
@@ -541,7 +586,7 @@ export function createAngularCompilerPlugin(
             sideEffects,
           );
 
-          // Worker 패턴 처리 (D2)
+          // Worker 패턴 처리
           const textContents = new TextDecoder().decode(contents);
           const workerResult = transformWorkerPatterns(textContents, request, build);
           if (workerResult != null) {

package/src/esbuild/esbuild-config.ts

@@ -3,10 +3,10 @@ import { readFileSync, existsSync } from "fs";
 import fs from "fs/promises";
 import { createRequire } from "module";
 import type esbuild from "esbuild";
-import { consola } from "consola";
+import { createLazyLogger } from "../runtime/lazy-logger";
 import { addJsExtensionToImports } from "../utils/output-path-rewriter";
 
-const logger = consola.withTag("sd:cli:esbuild-config");
+const logger = createLazyLogger("sd:cli:esbuild-config");
 
 /**
  * esbuild outputFiles에서 변경된 파일만 디스크에 쓴다.

package/src/esbuild/esbuild-worker-plugin.ts

@@ -41,6 +41,8 @@ function isImportMetaUrl(node: any): boolean {
  *
  * 정규식과 달리 주석, 문자열 리터럴 내부의 패턴을 오탐하지 않는다.
  * 파싱 실패 시 빈 배열을 반환한다.
+ *
+ * @param content - JavaScript 소스 코드. TypeScript는 상위 `transformWorkerPatterns()`가 사전 변환한다.
  */
 export function findWorkerPatterns(content: string): WorkerMatch[] {
   let ast: acorn.Node;
@@ -153,6 +155,17 @@ export interface TransformWorkerResult {
   workerMetafile?: esbuild.Metafile;
 }
 
+/**
+ * transformWorkerPatterns 옵션.
+ */
+export interface TransformWorkerOptions {
+  /**
+   * true이면 .ts/.cts/.mts 확장자여도 esbuild.transformSync(loader: "ts")를 스킵한다.
+   * 호출자가 content가 이미 JS임을 보장하는 경우에만 사용한다 (예: ngtsc emit 결과).
+   */
+  skipTsTransform?: boolean;
+}
+
 /**
  * Worker 파일을 esbuild.buildSync()로 별도 ESM 번들로 빌드한다.
  * esbuild-angular-compiler-plugin.ts의 bundleWebWorker를 기반으로 작성.
@@ -202,7 +215,7 @@ function bundleWorker(
  * 파일 내용에서 Worker/SharedWorker 패턴을 감지하여 Worker 파일을 번들링하고
  * URL 경로를 번들된 파일 경로로 치환한다.
  *
- * Angular 플러그인 등 외부에서 직접 호출할 수 있도록 export한다 (D2).
+ * Angular 컴파일러 플러그인 등 외부에서 직접 호출한다.
  *
  * @returns 변환 결과. 패턴이 없으면 undefined.
  */
@@ -210,9 +223,14 @@ export function transformWorkerPatterns(
   content: string,
   filePath: string,
   build: esbuild.PluginBuild,
+  options?: TransformWorkerOptions,
 ): TransformWorkerResult | undefined {
-  // 빠른 사전 필터 — AST 파싱 전에 키워드 존재 여부로 걸러냄 (원본 TS content 기준)
-  if (!content.includes("Worker") && !content.includes("import.meta.resolve")) {
+  // 빠른 사전 필터 — new Worker(), new SharedWorker(), import.meta.resolve()의 단어 경계
+  // 호출 형태만 통과시킨다. 식별자·타입·interface로만 등장하는 Worker 키워드는 차단하여
+  // TS transformSync 오버헤드를 줄인다. 정확성은 후속 AST 판별(findWorkerPatterns)이 담당한다.
+  // new 와 Worker/SharedWorker 사이에 주석이 낀 호출(예: `new /* c */ Worker`)은 의도된
+  // 트레이드오프로 탈락한다. 실발생 가능성이 희박하여 현행을 유지한다.
+  if (!/\b(new\s+Worker|new\s+SharedWorker|import\.meta\.resolve)\b/.test(content)) {
     return undefined;
   }
 
@@ -221,8 +239,10 @@ export function transformWorkerPatterns(
 
   // TS(.ts/.cts/.mts)는 JS로 변환한 후 AST 파싱. acorn은 TS 구문을 처리하지 못하므로
   // import type, 타입 어노테이션 등이 있으면 파싱 실패로 Worker 패턴이 조용히 누락된다.
+  // skipTsTransform이 true이면 호출자가 content가 이미 JS임을 보장하므로 변환을 스킵한다
+  // (예: Angular 컴파일러 플러그인이 ngtsc emit 결과를 전달하는 경로).
   let effectiveContent = content;
-  if (/\.[cm]?ts$/.test(filePath)) {
+  if (options?.skipTsTransform !== true && /\.[cm]?ts$/.test(filePath)) {
     try {
       const transformed = build.esbuild.transformSync(content, {
         loader: "ts",

package/src/lint/lint-with-program.ts

@@ -1,9 +1,9 @@
 import type ts from "typescript";
 import { ESLint } from "eslint";
 import { pathx } from "@simplysm/core-node";
-import { consola } from "consola";
+import { createLazyLogger } from "../runtime/lazy-logger";
 
-const logger = consola.withTag("sd:cli:lint-with-program");
+const logger = createLazyLogger("sd:cli:lint-with-program");
 
 /**
  * LintWithProgramRunner.lint()가 반환하는 lint 결과

package/src/runtime/lazy-logger.ts

@@ -0,0 +1,23 @@
+import { consola, type ConsolaInstance } from "consola";
+
+/**
+ * 모듈 레벨에서 선언해도 안전한 lazy logger 프록시.
+ *
+ * consola.withTag()는 호출 시점의 consola.options(level/reporters)를
+ * 스냅샷 복사한 새 인스턴스를 반환한다. 모듈 import 시점에 호출하면
+ * setupConsola 이전의 기본 level(info) 상태가 고정되어 이후 setupConsola가
+ * level을 debug로 올려도 반영되지 않는다.
+ *
+ * createLazyLogger는 실제 ConsolaInstance 생성을 첫 접근 시점까지 미뤄
+ * setupConsola 이후의 설정이 반영된 스냅샷을 갖도록 한다.
+ */
+export function createLazyLogger(tag: string): ConsolaInstance {
+  let cached: ConsolaInstance | undefined;
+  return new Proxy({} as ConsolaInstance, {
+    get(_target, prop) {
+      cached ??= consola.withTag(tag);
+      const value: unknown = Reflect.get(cached, prop);
+      return typeof value === "function" ? value.bind(cached) : value;
+    },
+  });
+}

package/src/sd-cli-entry.ts

@@ -15,10 +15,10 @@ import path from "path";
 import fs from "fs";
 import { fileURLToPath } from "url";
 import { EventEmitter } from "node:events";
-import { consola } from "consola";
 import { setupConsola } from "@simplysm/core-node";
+import { createLazyLogger } from "./runtime/lazy-logger";
 
-const logger = consola.withTag("sd:cli:entry");
+const logger = createLazyLogger("sd:cli:entry");
 
 Error.stackTraceLimit = Infinity;
 EventEmitter.defaultMaxListeners = 100;

package/src/sd-cli.ts

@@ -8,15 +8,15 @@
  */
 
 import { cpx, setupConsola } from "@simplysm/core-node";
-import { consola } from "consola";
 import os from "os";
 import path from "path";
 import { fileURLToPath } from "url";
+import { createLazyLogger } from "./runtime/lazy-logger";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const isDev = path.extname(__filename) === ".ts";
-const logger = consola.withTag("sd:cli");
+const logger = createLazyLogger("sd:cli");
 
 if (isDev) {
   // 개발 모드 (.ts): affinity 적용 후 직접 실행