@simplysm/sd-cli 14.0.42 → 14.0.44

package/src/commands/replace-deps.ts

@@ -2,6 +2,8 @@ import { consola } from "consola";
 import { loadSdConfig } from "../utils/sd-config";
 import { setupReplaceDeps } from "../deps/replace-deps/replace-deps";
 
+const logger = consola.withTag("sd:cli:replace-deps");
+
 /**
  * replace-deps 명령어 옵션
  */
@@ -19,7 +21,7 @@ export async function runReplaceDeps(opts: ReplaceDepsOptions): Promise<void> {
   const sdConfig = await loadSdConfig({ cwd, dev: false, opt: opts.options });
 
   if (sdConfig.replaceDeps == null) {
-    consola.warn("sd.config.ts에 replaceDeps 설정이 없습니다.");
+    logger.warn("sd.config.ts에 replaceDeps 설정이 없습니다.");
     return;
   }
 

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

@@ -12,13 +12,15 @@ export interface DepsResult {
 }
 
 /**
- * pnpm-workspace.yaml 기반으로 workspace 패키지의 name → 상대 디렉토리 맵을 구성한다.
+ * 워크스페이스 디렉토리(packages/, tests/) 스캔 기반으로 packages/ 패키지의 name → 상대 디렉토리 맵을 구성한다.
+ * tests/ 패키지는 제외된다.
  * 예: "@simplysm/core-node" → "packages/core-node"
  */
 function buildWorkspacePkgMap(cwd: string): Map<string, string> {
   const map = new Map<string, string>();
   const wsPkgs = discoverWorkspacePackages(cwd);
   for (const [, relDir] of wsPkgs) {
+    if (relDir.startsWith("tests/")) continue;
     const pkgJsonPath = pathx.posix(path.join(cwd, relDir, "package.json"));
     if (!fs.existsSync(pkgJsonPath)) continue;
     const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, "utf-8")) as { name: string };
@@ -35,7 +37,7 @@ export function collectDeps(
   const startTime = performance.now();
   logger.debug("의존성 수집 시작");
 
-  // pnpm-workspace.yaml에서 workspace 패키지 디렉토리 패턴을 읽어 실제 패키지 맵 구성
+  // 워크스페이스 디렉토리 스캔으로 packages/ 패키지 맵 구성 (tests/ 제외)
   const workspacePkgMap = buildWorkspacePkgMap(cwd);
 
   const replaceDepsPatterns: Array<{ regex: RegExp }> = [];

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

@@ -140,6 +140,7 @@ export async function resolveAllReplaceDepEntries(
   logger: ReturnType<typeof consola.withTag>,
 ): Promise<ReplaceDepEntry[]> {
   const entries: ReplaceDepEntry[] = [];
+  const seenTargetPaths = new Set<string>();
   const searchedDirs = new Set<string>();
 
   // 초기 탐색 대상: 프로젝트 루트 + workspace 패키지들의 node_modules
@@ -162,12 +163,15 @@ export async function resolveAllReplaceDepEntries(
       continue;
     }
 
-    // replaceDeps의 각 glob 패턴으로 node_modules 디렉토리 탐색
-    const targetNames: string[] = [];
-    for (const pattern of Object.keys(replaceDeps)) {
-      const matches = await glob(pattern, { cwd: nodeModulesDir });
-      targetNames.push(...matches.map((m) => m.replaceAll("\\", "/")));
-    }
+    // replaceDeps의 각 glob 패턴으로 node_modules 디렉토리 탐색 (병렬)
+    const globResults = await Promise.all(
+      Object.keys(replaceDeps).map((pattern) =>
+        glob(pattern, { cwd: nodeModulesDir }),
+      ),
+    );
+    const targetNames = globResults.flatMap((matches) =>
+      matches.map((m) => m.replaceAll("\\", "/")),
+    );
 
     logger.debug(`[replace-deps] 탐색: ${nodeModulesDir} → ${targetNames.length}개 매칭 (${targetNames.join(", ")})`);
 
@@ -200,7 +204,8 @@ export async function resolveAllReplaceDepEntries(
       }
 
       // 동일 actualTargetPath가 이미 등록된 경우 건너뜀 (pnpm 중복 방지)
-      if (entries.some((e) => e.actualTargetPath === actualTargetPath)) continue;
+      if (seenTargetPaths.has(actualTargetPath)) continue;
+      seenTargetPaths.add(actualTargetPath);
 
       entries.push({
         targetName,

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

@@ -8,20 +8,106 @@ import type { ReplaceDepEntry } from "./replace-deps-resolve";
 import { resolveAllReplaceDepEntries } from "./replace-deps-resolve";
 
 /**
- * 복사 시 제외할 이름 목록
+ * 파일 내용이 동일한지 비교한다.
+ * mtime + size가 같으면 동일로 간주하고, 다르면 바이트 비교한다.
  */
-const EXCLUDED_NAMES = new Set(["node_modules", "package.json", ".cache", "tests"]);
+async function isFileContentSame(pathA: string, pathB: string): Promise<boolean> {
+  try {
+    const [statA, statB] = await Promise.all([
+      fs.promises.stat(pathA),
+      fs.promises.stat(pathB),
+    ]);
+    if (statA.size !== statB.size) return false;
+    if (statA.mtimeMs === statB.mtimeMs) return true;
+
+    const [bufA, bufB] = await Promise.all([
+      fs.promises.readFile(pathA),
+      fs.promises.readFile(pathB),
+    ]);
+    return bufA.equals(bufB);
+  } catch {
+    return false;
+  }
+}
 
 /**
- * replaceDeps 복사용 필터 함수
- * node_modules, package.json, .cache, tests를 제외한다.
- *
- * @param itemPath - 복사할 항목의 절대 경로
- * @returns 복사 대상이면 true, 제외 대상이면 false
+ * pnpm hard link를 끊으면서 파일/디렉토리를 복사한다.
+ * 대상 파일을 먼저 unlink하여 글로벌 store의 hard link를 끊고 새 파일을 생성한다.
+ * 다른 프로젝트의 node_modules에 영향을 주지 않기 위함이다.
  */
-function replaceDepsCopyFilter(itemPath: string): boolean {
-  const basename = path.basename(itemPath);
-  return !EXCLUDED_NAMES.has(basename);
+async function copyWithUnlink(
+  sourcePath: string,
+  targetPath: string,
+  filter?: (absolutePath: string) => boolean,
+): Promise<void> {
+  let stats: fs.Stats;
+  try {
+    stats = await fs.promises.lstat(sourcePath);
+  } catch {
+    return;
+  }
+
+  if (stats.isDirectory()) {
+    await fsx.mkdir(targetPath);
+    const names = await fs.promises.readdir(sourcePath);
+    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)),
+        )),
+    );
+  } else {
+    if (await isFileContentSame(sourcePath, targetPath)) return;
+    await fsx.mkdir(path.dirname(targetPath));
+    try {
+      await fs.promises.unlink(targetPath);
+    } catch {
+      // 대상이 없으면 무시
+    }
+    await fs.promises.copyFile(sourcePath, targetPath);
+  }
+}
+
+/**
+ * npm publish 시 files 필드와 무관하게 항상 포함되는 파일 패턴 (대소문자 무시)
+ */
+export const NPM_DEFAULT_FILE_PATTERN = /^(readme|license|licence|changelog|history)/i;
+
+/**
+ * 소스 패키지의 package.json에서 files 필드를 읽어 반환한다.
+ * files 필드가 없으면 undefined를 반환한다.
+ */
+export async function loadFilesField(sourcePath: string): Promise<string[] | undefined> {
+  const pkgJsonPath = pathx.posix(path.join(sourcePath, "package.json"));
+  const pkgJson = JSON.parse(await fs.promises.readFile(pkgJsonPath, "utf-8"));
+  return pkgJson.files as string[] | undefined;
+}
+
+/**
+ * files 필드 기반 화이트리스트 복사 필터를 생성한다.
+ * 소스 루트 기준 상대경로의 첫 번째 세그먼트로 판단한다.
+ *  - files에 포함 → 허용
+ *  - npm 기본 파일 패턴 매칭 → 허용
+ *  - package.json → 제외
+ *  - 그 외 → 제외
+ */
+export function createCopyFilter(
+  sourcePath: string,
+  allowedNames: Set<string>,
+): (itemPath: string) => boolean {
+  return (itemPath: string) => {
+    const relativePath = path.relative(sourcePath, itemPath);
+    const firstSegment = relativePath.split(path.sep)[0];
+
+    if (firstSegment === "package.json") return false;
+    if (allowedNames.has(firstSegment)) return true;
+    if (NPM_DEFAULT_FILE_PATTERN.test(firstSegment)) return true;
+
+    return false;
+  };
 }
 
 /**
@@ -37,7 +123,7 @@ export interface WatchReplaceDepResult {
  *
  * 1. pnpm-workspace.yaml 파싱 → 워크스페이스 패키지 경로
  * 2. [루트, ...워크스페이스 패키지] node_modules에서 매칭 패키지 탐색
- * 3. 기존 symlink/디렉토리 제거 → 소스 경로 복사 (node_modules, package.json, .cache, tests 제외)
+ * 3. 소스 package.json의 files 필드 + npm 기본 파일만 대상 경로에 복사 (package.json 제외)
  *
  * @param projectRoot - 프로젝트 루트 경로
  * @param replaceDeps - sd.config.ts의 replaceDeps 설정
@@ -47,27 +133,34 @@ export async function setupReplaceDeps(
   replaceDeps: Record<string, string>,
 ): Promise<void> {
   const logger = consola.withTag("sd:cli:replace-deps");
-  let setupCount = 0;
 
   logger.start("replace-deps 설정 중...");
 
   const entries = await resolveAllReplaceDepEntries(projectRoot, replaceDeps, logger);
 
-  for (const { targetName, resolvedSourcePath, actualTargetPath } of entries) {
+  const results = await Promise.all(entries.map(async (entry) => {
     try {
-      // 소스 파일을 actualTargetPath에 덮어쓰기 복사 (기존 디렉토리 유지, symlink 보존)
-      await fsx.copy(resolvedSourcePath, actualTargetPath, replaceDepsCopyFilter);
+      const files = await loadFilesField(entry.resolvedSourcePath);
+      if (files == null) {
+        logger.warn(`[${entry.targetName}] package.json에 files 필드가 없어 건너뜀`);
+        return undefined;
+      }
 
-      setupCount += 1;
+      const filter = createCopyFilter(entry.resolvedSourcePath, new Set(files));
+      await copyWithUnlink(entry.resolvedSourcePath, entry.actualTargetPath, filter);
+      return entry;
     } catch (err) {
-      logger.error(`[${targetName}] 복사 실패: ${err instanceof Error ? err.message : err}`);
+      logger.error(`[${entry.targetName}] 복사 실패: ${err instanceof Error ? err.message : err}`);
+      return undefined;
     }
-  }
+  }));
+
+  const copiedEntries = results.filter((e): e is ReplaceDepEntry => e != null);
 
-  logger.success(`replace-deps 설정 완료 (${setupCount}개 의존성 교체)`);
+  logger.success(`replace-deps 설정 완료 (${copiedEntries.length}개 의존성 교체)`);
 
   // 교체된 패키지의 postinstall 스크립트 실행
-  for (const { targetName, resolvedSourcePath, actualTargetPath } of entries) {
+  for (const { targetName, resolvedSourcePath, actualTargetPath } of copiedEntries) {
     const sourcePkgJsonPath = pathx.posix(path.join(resolvedSourcePath, "package.json"));
     try {
       const pkgJson = JSON.parse(await fs.promises.readFile(sourcePkgJsonPath, "utf-8"));
@@ -91,8 +184,8 @@ export async function setupReplaceDeps(
  *
  * 1. pnpm-workspace.yaml 파싱 → 워크스페이스 패키지 경로
  * 2. [루트, ...워크스페이스 패키지] node_modules에서 매칭 패키지 탐색
- * 3. FsWatcher로 소스 디렉토리 감시 (300ms 딜레이)
- * 4. 변경사항을 대상 경로에 복사 (node_modules, package.json, .cache, tests 제외)
+ * 3. FsWatcher로 files 항목 경로만 감시 (300ms 딜레이)
+ * 4. 변경사항을 대상 경로에 복사
  *
  * @param projectRoot - 프로젝트 루트 경로
  * @param replaceDeps - sd.config.ts의 replaceDeps 설정
@@ -118,66 +211,95 @@ export async function watchReplaceDeps(
     if (watchedSources.has(entry.resolvedSourcePath)) continue;
     watchedSources.add(entry.resolvedSourcePath);
 
-    const excludedPaths = [...EXCLUDED_NAMES].map((name) =>
-      pathx.posix(path.join(entry.resolvedSourcePath, name)),
-    );
+    try {
+      // 소스 패키지의 files 필드를 읽어 감시 대상 경로 구성
+      const files = await loadFilesField(entry.resolvedSourcePath);
+      if (files == null) {
+        logger.warn(`[${entry.targetName}] package.json에 files 필드가 없어 감시 건너뜀`);
+        continue;
+      }
+
+      // files 항목 경로 + npm 기본 파일 경로
+      const watchPaths = files.map((f) =>
+        pathx.posix(path.join(entry.resolvedSourcePath, f)),
+      );
 
-    const watcher = await FsWatcher.watch([entry.resolvedSourcePath], {
-      followSymlinks: false,
-      ignored: [...EXCLUDED_NAMES].map((name) => `**/${name}`),
-    });
-    watcher.onChange({ delay: 300 }, async (changeInfos) => {
-      for (const { path: changedPath } of changeInfos) {
-        // 제외 항목 필터: basename 매칭 또는 제외 디렉토리 내 경로
-        if (
-          EXCLUDED_NAMES.has(path.basename(changedPath)) ||
-          excludedPaths.some((ep) => pathx.isChildPath(changedPath, ep))
-        ) {
-          continue;
+      // 소스 루트에서 npm 기본 파일 패턴에 매칭되는 파일 추가
+      try {
+        const rootEntries = await fs.promises.readdir(entry.resolvedSourcePath);
+        for (const name of rootEntries) {
+          if (NPM_DEFAULT_FILE_PATTERN.test(name)) {
+            watchPaths.push(pathx.posix(path.join(entry.resolvedSourcePath, name)));
+          }
         }
+      } catch {
+        // readdir 실패 시 npm 기본 파일 감시 생략
+      }
 
-        // 이 소스 경로를 사용하는 모든 항목에 대해 복사
-        for (const e of entries) {
-          if (e.resolvedSourcePath !== entry.resolvedSourcePath) continue;
+      // 이 소스 경로에 해당하는 entries만 사전 필터링하여 캡처
+      const sourceEntries = entries.filter(
+        (e) => e.resolvedSourcePath === entry.resolvedSourcePath,
+      );
+
+      const watcher = await FsWatcher.watch(watchPaths, {
+        followSymlinks: false,
+      });
+      watcher.onChange({ delay: 300 }, async (changeInfos) => {
+        let hasActualCopy = false;
 
-          // 소스로부터의 상대 경로 계산
-          const relativePath = pathx.posix(path.relative(e.resolvedSourcePath, changedPath));
-          const destPath = pathx.posix(path.join(e.actualTargetPath, relativePath));
+        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));
 
-          try {
-            // 소스 존재 여부 확인
-            let sourceExists = false;
             try {
-              await fs.promises.access(changedPath);
-              sourceExists = true;
-            } catch {
-              // 소스가 삭제됨
-            }
+              // 소스 존재 여부 확인
+              let sourceExists = false;
+              try {
+                await fs.promises.access(changedPath);
+                sourceExists = true;
+              } catch {
+                // 소스가 삭제됨
+              }
 
-            if (sourceExists) {
-              // 소스가 디렉토리인지 파일인지 확인
-              const stat = await fs.promises.stat(changedPath);
-              if (stat.isDirectory()) {
-                await fsx.mkdir(destPath);
+              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;
+                }
               } else {
-                await fsx.mkdir(pathx.posix(path.dirname(destPath)));
-                await fsx.copy(changedPath, destPath, replaceDepsCopyFilter);
+                // 소스가 삭제됨 → 대상도 삭제
+                await fsx.rm(destPath);
+                hasActualCopy = true;
               }
-            } else {
-              // 소스가 삭제됨 → 대상도 삭제
-              await fsx.rm(destPath);
+            } catch (err) {
+              logger.error(
+                `[${e.targetName}] 복사 실패 (${relativePath}): ${err instanceof Error ? err.message : err}`,
+              );
             }
-          } catch (err) {
-            logger.error(
-              `[${e.targetName}] 복사 실패 (${relativePath}): ${err instanceof Error ? err.message : err}`,
-            );
           }
         }
-      }
-      options?.onChanged?.();
-    });
 
-    watchers.push(watcher);
+        if (hasActualCopy) {
+          options?.onChanged?.();
+        }
+      });
+
+      watchers.push(watcher);
+    } catch (err) {
+      logger.error(
+        `[${entry.targetName}] 감시 설정 실패: ${err instanceof Error ? err.message : err}`,
+      );
+    }
   }
 
   logger.success("replace-deps 워치 준비 완료");

package/src/electron/electron.ts

@@ -60,7 +60,7 @@ export class Electron {
   //#region Public Methods
 
   async initialize(): Promise<void> {
-    Electron._logger.debug("initialize 시작");
+    Electron._logger.start("initialize 중...");
 
     Electron._logger.debug("package.json 설정 시작");
     await this._setupNpmConf();
@@ -83,11 +83,11 @@ export class Electron {
       await this._exec("pnpm", ["exec", "electron-rebuild"], this._srcPath);
       Electron._logger.debug("electron-rebuild 완료");
     }
-    Electron._logger.debug("initialize 완료");
+    Electron._logger.success("initialize 완료");
   }
 
   async run(url: string): Promise<void> {
-    Electron._logger.debug(`run 시작 (url: ${url})`);
+    Electron._logger.start(`run 중... (url: ${url})`);
 
     await this.initialize();
     await this._copyPublicAssets();
@@ -126,7 +126,7 @@ export class Electron {
           setup: (build) => {
             build.onEnd(async (result) => {
               if (result.errors.length > 0) {
-                Electron._logger.warn("번들링 실패. Electron을 재시작하지 않습니다.");
+                Electron._logger.error("번들링 실패. Electron을 재시작하지 않습니다.");
                 return;
               }
 
@@ -181,11 +181,11 @@ export class Electron {
       process.once("SIGINT", signalHandler);
       process.once("SIGTERM", signalHandler);
     });
-    Electron._logger.debug("run 완료");
+    Electron._logger.success("run 완료");
   }
 
   async build(outPath: string): Promise<void> {
-    Electron._logger.debug("build 시작");
+    Electron._logger.start("build 중...");
 
     await this.initialize();
 
@@ -205,7 +205,7 @@ export class Electron {
     await this._copyBuildOutput(outPath);
     Electron._logger.debug("빌드 산출물 복사 완료");
 
-    Electron._logger.debug("build 완료");
+    Electron._logger.success("build 완료");
   }
 
   //#endregion

package/src/engines/BaseEngine.ts

@@ -163,14 +163,10 @@ export abstract class BaseEngine<
         (data as CommonBuildWorkerEvents["build"]).build,
     });
 
-    // BaseEngine 전용: 경고 로깅 + 린트 결과 보고
+    // 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,
@@ -184,7 +180,7 @@ export abstract class BaseEngine<
     });
 
     this._callStartWatch(output).catch((err: unknown) => {
-      logger.error(`[${this._pkg.name}] startWatch 실패:`, errNs.message(err));
+      logger.debug(`[${this._pkg.name}] startWatch 실패:`, errNs.message(err));
       this._resultCollector?.add({
         name: this._pkg.name,
         target: this._getTarget(),

package/src/engines/EsbuildClientEngine.ts

@@ -101,20 +101,14 @@ export class EsbuildClientEngine implements BuildEngine {
     });
 
     // 공통 이벤트 처리 (buildStart/build/error)
-    setupWatchEvents(this._worker!, {
+    const { resolveInitialBuild } = 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}`);
-    });
+    resolveInitialBuild(); // EsbuildClientEngine은 worker.startWatch() await로 초기 빌드 완료를 감지하므로 즉시 정리
 
     const port =
       typeof this._pkg.config.server === "number"
@@ -132,15 +126,27 @@ export class EsbuildClientEngine implements BuildEngine {
       browserSupport: this._pkg.config.browserSupport,
     });
 
+    const warningsText = result.warnings != null && result.warnings.length > 0
+      ? result.warnings.join("\n")
+      : undefined;
+
     if (!result.success) {
-      const errorDetail = result.errors?.join("; ") ?? "unknown error";
-      logger.error(`[${this._pkg.name}] 초기 빌드 실패: ${errorDetail}`);
+      const errorDetail = result.errors?.join("\n") ?? "unknown error";
       this._resultCollector?.add({
         name: this._pkg.name,
         target: "client",
         type: "build",
         status: "error",
         message: errorDetail,
+        warnings: warningsText,
+      });
+    } else if (warningsText != null) {
+      this._resultCollector?.add({
+        name: this._pkg.name,
+        target: "client",
+        type: "build",
+        status: "success",
+        warnings: warningsText,
       });
     }
   }

package/src/engines/NgtscEngine.ts

@@ -1,4 +1,4 @@
-import type * as NgtscBuildWorkerModule from "../workers/ngtsc-build.worker";
+import type * as LibraryBuildWorkerModule from "../workers/library-build.worker";
 import type { ResultCollector } from "../runtime/ResultCollector";
 import type { RebuildManager } from "../runtime/rebuild-manager";
 import type { BuildOutput, BuildPackageInfo, EngineResult } from "./types";
@@ -24,19 +24,19 @@ export interface NgtscEngineOptions {
 /**
  * NgtscProgram 기반 Angular 라이브러리 패키지용 빌드 엔진
  *
- * NgtscProgram을 사용하여 AOT 컴파일을 수행하는 ngtsc-build.worker를 래핑한다.
- * package.json에 @angular/core 의존성이 있는 Angular 패키지용.
+ * 통합된 library-build.worker를 사용하며, globalScss: true를 전달하여
+ * Angular AOT 컴파일 + SCSS 빌드를 활성화한다.
  */
 export class NgtscEngine extends BaseEngine<
   BuildPackageInfo,
-  typeof NgtscBuildWorkerModule & CommonBuildWorkerModule
+  typeof LibraryBuildWorkerModule & CommonBuildWorkerModule
 > {
   constructor(options: NgtscEngineOptions) {
     super(options);
   }
 
   protected _getWorkerPath(): string {
-    return import.meta.resolve("../workers/ngtsc-build.worker");
+    return import.meta.resolve("../workers/library-build.worker");
   }
 
   protected _getTarget(): string {
@@ -49,7 +49,7 @@ export class NgtscEngine extends BaseEngine<
       name: this._pkg.name,
       cwd: this._cwd,
       pkgDir: this._pkg.dir,
-      output,
+      output: { ...output, globalScss: true },
     });
 
     return this._normalizeResult(result);
@@ -61,7 +61,7 @@ export class NgtscEngine extends BaseEngine<
       name: this._pkg.name,
       cwd: this._cwd,
       pkgDir: this._pkg.dir,
-      output,
+      output: { ...output, globalScss: true },
       replaceDeps: this._replaceDeps,
     });
   }

package/src/engines/TscEngine.ts

@@ -47,7 +47,6 @@ export class TscEngine extends BaseEngine<
     logger.debug(`[${this._pkg.name}] worker.build 호출`);
     const result = await this._worker!.build({
       name: this._pkg.name,
-      config: this._pkg.config,
       cwd: this._cwd,
       pkgDir: this._pkg.dir,
       output,
@@ -60,7 +59,6 @@ export class TscEngine extends BaseEngine<
     logger.debug(`[${this._pkg.name}] worker.startWatch 호출`);
     await this._worker!.startWatch({
       name: this._pkg.name,
-      config: this._pkg.config,
       cwd: this._cwd,
       pkgDir: this._pkg.dir,
       output,

package/src/engines/types.ts

@@ -39,6 +39,8 @@ export interface BuildOutput {
   env?: TypecheckEnv;
   /** 타입체크 범위에 tests/ 파일을 포함한다. check 커맨드에서만 사용된다. */
   includeTests?: boolean;
+  /** Angular 라이브러리의 글로벌 SCSS 컴파일 여부 */
+  globalScss?: boolean;
 }
 
 /**