@simplysm/sd-cli 14.0.47 → 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

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/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 적용 후 직접 실행