@simplysm/sd-cli 14.0.43 → 14.0.45

package/src/workers/client.worker.ts

@@ -17,6 +17,7 @@ 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
 
@@ -194,32 +195,19 @@ function createSourceFileCachePlugin(): esbuild.Plugin {
   return {
     name: "sd-build-start",
     setup(pluginBuild: esbuild.PluginBuild) {
-      const prevMtimes = new Map<string, number>();
+      const mtimeTracker = new IncrementalMtimeTracker();
 
       pluginBuild.onStart(() => {
         // sourceFileCache 무효화: 변경된 파일의 loadResultCache + TypeScript 소스 캐시 모두 제거
         if (esbuildResult != null) {
           const { loadResultCache, typeScriptFileCache } =
             esbuildResult.sourceFileCache;
-          const changedFiles = new Set<string>();
           // JS 파일 (loadResultCache) + TS 파일 (typeScriptFileCache) 모두 감시
           const watchTargets = [
             ...loadResultCache.watchFiles,
             ...typeScriptFileCache.keys(),
           ];
-          for (const file of watchTargets) {
-            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);
-              }
-            }
-          }
+          const changedFiles = mtimeTracker.detectChanges(watchTargets);
           if (changedFiles.size > 0) {
             esbuildResult.sourceFileCache.invalidate(changedFiles);
           }
@@ -232,19 +220,12 @@ function createSourceFileCachePlugin(): esbuild.Plugin {
 
       pluginBuild.onEnd(() => {
         if (esbuildResult == null) return;
-        prevMtimes.clear();
         // JS 파일 (loadResultCache) + TS 파일 (typeScriptFileCache) 모두 기록
         const watchTargets = [
           ...esbuildResult.sourceFileCache.loadResultCache.watchFiles,
           ...esbuildResult.sourceFileCache.typeScriptFileCache.keys(),
         ];
-        for (const file of watchTargets) {
-          try {
-            prevMtimes.set(file, fs.statSync(file).mtimeMs);
-          } catch {
-            // 삭제된 파일
-          }
-        }
+        mtimeTracker.updateMtimes(watchTargets);
       });
     },
   };

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();
+  }
+}

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

@@ -7,7 +7,7 @@ import type { SerializedDiagnostic } from "../typecheck/typecheck-serialization"
 import type { LintWithProgramResult } from "../lint/lint-with-program";
 import { SdTsCompiler } from "../ts-compiler/SdTsCompiler";
 import type { ISdTsCompilerResult } from "../ts-compiler/sd-ts-compiler-result";
-import { writeEmitResults, compileSideEffectScss } from "../angular/ngtsc-build-core";
+import { writeEmitResults, compileSideEffectScss, buildReverseDeps } from "../angular/ngtsc-build-core";
 import { setupWorkerLifecycle } from "./shared-worker-lifecycle";
 import { buildWatchPaths } from "./build-watch-paths";
 import { hasFileAddOrRemove, shouldSkipRebuild } from "./build-change-filter";
@@ -46,6 +46,9 @@ export interface LibraryBuildWorkerEvents extends Record<string, unknown> {
 let fsWatcher: FsWatcher | undefined;
 let compiler: SdTsCompiler | undefined;
 let combinedScssDeps = new Map<string, Set<string>>();
+let reverseScssDeps = new Map<string, Set<string>>();
+let registryReverseIndex = new Map<string, Set<string>>();
+let sideEffectScssDeps = new Map<string, Set<string>>();
 
 async function cleanup(): Promise<void> {
   const watcherToClose = fsWatcher;
@@ -53,6 +56,9 @@ async function cleanup(): Promise<void> {
   compiler = undefined;
   lastSourceFilePaths = undefined;
   combinedScssDeps = new Map();
+  reverseScssDeps = new Map();
+  registryReverseIndex = new Map();
+  sideEffectScssDeps = new Map();
   await watcherToClose?.close();
 }
 
@@ -93,13 +99,17 @@ async function build(info: LibraryBuildInfo): Promise<LibraryBuildResult> {
           scssErrors: sideEffectScssErrors,
           scssDependencies: combinedScssDeps,
           registry: compiler.sideEffectScssRegistry,
+          registryReverseIndex,
+          sideEffectScssDeps,
         });
-        // 초기 빌드: 등록된 side-effect SCSS 전체 컴파일
+        // 초기 빌드: 등록된 side-effect SCSS 전체 컴파일 (changedScssFiles 미전달)
         compileSideEffectScss(
           compiler.sideEffectScssRegistry,
           loadPaths,
           sideEffectScssErrors,
           combinedScssDeps,
+          undefined,
+          sideEffectScssDeps,
         );
       } else {
         writeEmitResults(filteredEmitResults, info.pkgDir);
@@ -147,12 +157,18 @@ function extractSourceFilePaths(program: ts.Program | undefined): Set<string> |
   return paths;
 }
 
-/** compile-time SCSS 의존성으로 combinedScssDeps를 갱신한다 */
+/** compile-time SCSS 의존성으로 combinedScssDeps와 reverseScssDeps를 갱신한다 */
 function updateCombinedScssDeps(result: ISdTsCompilerResult): void {
   combinedScssDeps = new Map();
   for (const [file, deps] of result.scssDependencies) {
     combinedScssDeps.set(file, new Set(deps));
   }
+  rebuildReverseScssDeps();
+}
+
+/** combinedScssDeps에서 역방향 인덱스를 재구축한다 */
+function rebuildReverseScssDeps(): void {
+  reverseScssDeps = buildReverseDeps(combinedScssDeps);
 }
 
 /**
@@ -162,7 +178,7 @@ function updateCombinedScssDeps(result: ISdTsCompilerResult): void {
 function buildWatchEvent(
   info: LibraryBuildInfo,
   result: ISdTsCompilerResult,
-  hasScssChanges: boolean,
+  changedScssFiles?: ReadonlySet<string>,
 ): CombinedBuildEvent {
   const isAngular = info.output.globalScss === true;
 
@@ -182,17 +198,25 @@ function buildWatchEvent(
         scssErrors: sideEffectScssErrors,
         scssDependencies: combinedScssDeps,
         registry: compiler!.sideEffectScssRegistry,
+        registryReverseIndex,
+        sideEffectScssDeps,
       },
     );
 
-    // SCSS 변경 시 side-effect SCSS 재컴파일
-    if (hasScssChanges) {
+    // side-effect SCSS 재컴파일
+    // changedScssFiles 미제공 = 초기 빌드 → 전체 컴파일
+    // changedScssFiles 제공 + size > 0 → 증분 컴파일
+    if (changedScssFiles == null || changedScssFiles.size > 0) {
       compileSideEffectScss(
         compiler!.sideEffectScssRegistry,
         loadPaths,
         sideEffectScssErrors,
         combinedScssDeps,
+        changedScssFiles,
+        sideEffectScssDeps,
       );
+      // side-effect SCSS 의존성이 combinedScssDeps에 추가되었으므로 역방향 인덱스 재구축
+      rebuildReverseScssDeps();
     }
 
     // 모든 에러 통합
@@ -240,7 +264,7 @@ async function startWatch(info: LibraryBuildInfo): Promise<void> {
     if (isAngular) {
       updateCombinedScssDeps(initialResult);
     }
-    const initialEvent = buildWatchEvent(info, initialResult, isAngular);
+    const initialEvent = buildWatchEvent(info, initialResult);
     sender.send("build", initialEvent);
 
     // workspace 의존성 경로 + replaceDeps 수집
@@ -265,12 +289,13 @@ async function startWatch(info: LibraryBuildInfo): Promise<void> {
         for (const f of changedFiles) {
           modifiedFiles.add(f.path);
 
-          // Angular: SCSS 역방향 의존성 탐색
+          // Angular: SCSS 역방향 의존성 탐색 (O(1) 조회)
           if (isAngular && (f.path.endsWith(".scss") || f.path.endsWith(".css"))) {
             const normalizedPath = pathx.posix(f.path);
-            for (const [ownerFile, deps] of combinedScssDeps) {
-              if (deps.has(normalizedPath)) {
-                modifiedFiles.add(ownerFile);
+            const owners = reverseScssDeps.get(normalizedPath);
+            if (owners != null) {
+              for (const owner of owners) {
+                modifiedFiles.add(owner);
               }
             }
           }
@@ -289,11 +314,13 @@ async function startWatch(info: LibraryBuildInfo): Promise<void> {
           updateCombinedScssDeps(result);
         }
 
-        const hasScssChanges = changedFiles.some(
-          (f) => f.path.endsWith(".scss") || f.path.endsWith(".css"),
+        const changedScssFiles = new Set(
+          changedFiles
+            .filter((f) => f.path.endsWith(".scss") || f.path.endsWith(".css"))
+            .map((f) => pathx.posix(f.path)),
         );
 
-        const event = buildWatchEvent(info, result, hasScssChanges);
+        const event = buildWatchEvent(info, result, changedScssFiles);
         sender.send("build", event);
       } catch (err) {
         sender.send("error", { message: errNs.message(err) });

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

@@ -18,6 +18,7 @@ import {
 import { collectAllExternals, generateProductionFiles } from "../deps/server-externals/server-production-files";
 import { SdTsCompiler } from "../ts-compiler/SdTsCompiler";
 import { createTscPlugin } from "../esbuild/esbuild-tsc-plugin";
+import { createWorkerBundlePlugin } from "../esbuild/esbuild-worker-plugin";
 import { setupWorkerLifecycle } from "./shared-worker-lifecycle";
 import { buildWatchPaths } from "./build-watch-paths";
 import { copyPublicFiles, watchPublicFiles } from "../utils/copy-public";
@@ -140,7 +141,7 @@ async function build(info: ServerBuildInfo): Promise<ServerBuildResult> {
     const entryPoints = getPackageSourceFiles(info.pkgDir, parsedConfig);
 
     // 외부 모듈 수집
-    const external = collectAllExternals(info.pkgDir, info.externals);
+    const { bundleExternals, prodDependencies } = collectAllExternals(info.pkgDir, info.externals);
 
     let jsResult: { success: boolean; errors?: string[]; warnings?: string[] };
     let tscErrors: string[];
@@ -162,10 +163,10 @@ async function build(info: ServerBuildInfo): Promise<ServerBuildResult> {
         pkgDir: info.pkgDir,
         entryPoints,
         env: info.env,
-        external,
+        external: bundleExternals,
       });
 
-      jsResult = await esbuild.build({ ...esbuildOptions, plugins: [tscPlugin.plugin] })
+      jsResult = await esbuild.build({ ...esbuildOptions, plugins: [createWorkerBundlePlugin(), tscPlugin.plugin] })
         .then(async (result) => {
           if (result.outputFiles) {
             await writeChangedOutputFiles(result.outputFiles);
@@ -212,7 +213,7 @@ async function build(info: ServerBuildInfo): Promise<ServerBuildResult> {
 
       await copyPublicFiles(info.pkgDir, false);
 
-      generateProductionFiles(info, external);
+      generateProductionFiles(info, prodDependencies);
     }
 
     const allErrors = [...(jsResult.errors ?? []), ...tscErrors];
@@ -310,7 +311,7 @@ async function startWatch(info: ServerWatchInfo): Promise<void> {
     const entryPoints = getPackageSourceFiles(info.pkgDir, parsedConfig);
 
     // 외부 모듈 수집 (watch 모드용 — watch manager가 자체 캐시를 유지)
-    const cachedExternal = collectAllExternals(info.pkgDir, info.externals);
+    const { bundleExternals: cachedExternal } = collectAllExternals(info.pkgDir, info.externals);
 
     // esbuild 컨텍스트 생성 (JS 출력 필요 시, tsc 플러그인 포함)
     if (info.output.js) {

package/src/workers/server-esbuild-context.ts

@@ -10,6 +10,7 @@ import { createTscPlugin, type TscPluginResult } from "../esbuild/esbuild-tsc-pl
 import type { TypecheckEnv } from "../utils/tsconfig";
 import type { SerializedDiagnostic } from "../typecheck/typecheck-serialization";
 import type { LintWithProgramResult } from "../lint/lint-with-program";
+import { createWorkerBundlePlugin } from "../esbuild/esbuild-worker-plugin";
 
 /**
  * esbuild watch context 생성 옵션
@@ -62,9 +63,10 @@ export async function createContext(options: EsbuildContextOptions): Promise<voi
     dev: true,
   });
 
+  const workerPlugin = createWorkerBundlePlugin();
   context = await esbuild.context({
     ...baseOptions,
-    plugins: tscPlugin != null ? [tscPlugin.plugin] : [],
+    plugins: tscPlugin != null ? [workerPlugin, tscPlugin.plugin] : [workerPlugin],
     metafile: true,
     write: false,
   });

package/src/workers/server-watch-manager.ts

@@ -59,7 +59,7 @@ export async function startServerWatchLoop(config: ServerWatchLoopConfig): Promi
           c.path.endsWith("package.json"),
         );
         if (hasPackageJsonChange) {
-          cachedExternal = collectAllExternals(info.pkgDir, info.externals);
+          cachedExternal = collectAllExternals(info.pkgDir, info.externals).bundleExternals;
         }
 
         if (info.output.js) {

package/tests/angular/ngtsc-build-core.acc.spec.ts

@@ -0,0 +1,210 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import path from "path";
+import type { SideEffectScssEntry, SideEffectScssOptions } from "../../src/angular/ngtsc-build-core";
+
+// Mock fs — filesystem I/O (OS 의존)
+vi.mock("fs", () => ({
+  default: {
+    mkdirSync: vi.fn(),
+    writeFileSync: vi.fn(),
+    existsSync: vi.fn(() => false),
+  },
+}));
+
+// Mock scss-compiler — dart-sass 외부 의존성
+const mockCompileScssFile = vi.fn<(filePath: string, loadPaths: string[]) => { css: string; dependencies: string[] }>()
+  .mockReturnValue({ css: "/* compiled */", dependencies: [] });
+
+vi.mock("../../src/angular/scss-compiler", () => ({
+  compileScssFile: (filePath: string, loadPaths: string[]) => mockCompileScssFile(filePath, loadPaths),
+  compileScssString: vi.fn(() => ({ css: "", dependencies: [] })),
+}));
+
+const { writeEmitResults, compileSideEffectScss } = await import("../../src/angular/ngtsc-build-core");
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  mockCompileScssFile.mockReturnValue({ css: "/* compiled */", dependencies: [] as string[] });
+});
+
+describe("writeEmitResults — registryReverseIndex", () => {
+  // 테스트용 경로 헬퍼
+  const pkgDir = path.resolve("/test-pkg");
+  const srcFile = path.resolve(pkgDir, "src", "comp.ts");
+  const distDir = path.resolve(pkgDir, "dist");
+
+  function makeEmitResult(jsContent: string, sourceFileName?: string) {
+    // createOutputPathRewriter는 dist/ 하위 파일만 처리하므로 dist/ 경로로 생성
+    return {
+      filename: path.resolve(distDir, "comp.js"),
+      contents: jsContent,
+      sourceFileName,
+    };
+  }
+
+  // Acceptance: registryReverseIndex가 제공되면 O(1) 삭제를 수행한다
+  it("deletes registry entries using reverseIndex and cleans up reverseIndex", () => {
+    const oldScssPath = path.resolve(pkgDir, "src", "old.scss");
+    const registry = new Map<string, SideEffectScssEntry>([
+      [oldScssPath, { scssAbsPath: oldScssPath, cssAbsPath: "/out/old.css", sourceFileName: srcFile }],
+    ]);
+    const registryReverseIndex = new Map<string, Set<string>>([
+      [srcFile, new Set([oldScssPath])],
+    ]);
+    const scss: SideEffectScssOptions = {
+      loadPaths: [],
+      scssErrors: [],
+      scssDependencies: new Map(),
+      registry,
+      registryReverseIndex,
+    };
+
+    // SCSS import 없는 JS → 삭제만 발생, 등록 없음
+    writeEmitResults([makeEmitResult("export class Comp {}", srcFile)], pkgDir, scss);
+
+    expect(registry.has(oldScssPath)).toBe(false);
+    expect(registryReverseIndex.has(srcFile)).toBe(false);
+  });
+
+  // Acceptance: 삭제 후 새 SCSS import가 있으면 등록하고 reverseIndex도 갱신
+  it("registers new entries and updates reverseIndex after deletion", () => {
+    const oldScssPath = path.resolve(pkgDir, "src", "old.scss");
+    const registry = new Map<string, SideEffectScssEntry>([
+      [oldScssPath, { scssAbsPath: oldScssPath, cssAbsPath: "/out/old.css", sourceFileName: srcFile }],
+    ]);
+    const registryReverseIndex = new Map<string, Set<string>>([
+      [srcFile, new Set([oldScssPath])],
+    ]);
+    const scss: SideEffectScssOptions = {
+      loadPaths: [],
+      scssErrors: [],
+      scssDependencies: new Map(),
+      registry,
+      registryReverseIndex,
+    };
+
+    // JS with SCSS import → 삭제 + 등록
+    const jsContent = 'import "./button.scss";\nexport class Comp {}';
+    writeEmitResults([makeEmitResult(jsContent, srcFile)], pkgDir, scss);
+
+    // old.scss 삭제됨
+    expect(registry.has(oldScssPath)).toBe(false);
+    // button.scss가 등록됨 (scssAbsPath = path.resolve(srcDir, "./button.scss"))
+    const expectedScssPath = path.resolve(pkgDir, "src", "button.scss");
+    expect(registry.has(expectedScssPath)).toBe(true);
+    // reverseIndex에 새 항목 반영
+    expect(registryReverseIndex.get(srcFile)).toEqual(new Set([expectedScssPath]));
+  });
+
+  // Acceptance: reverseIndex에 없는 sourceFileName이면 삭제 없음
+  it("does not delete when sourceFileName is not in reverseIndex", () => {
+    const otherScssPath = path.resolve(pkgDir, "src", "other.scss");
+    const otherSrcFile = path.resolve(pkgDir, "src", "other.ts");
+    const registry = new Map<string, SideEffectScssEntry>([
+      [otherScssPath, { scssAbsPath: otherScssPath, cssAbsPath: "/out/other.css", sourceFileName: otherSrcFile }],
+    ]);
+    const registryReverseIndex = new Map<string, Set<string>>([
+      [otherSrcFile, new Set([otherScssPath])],
+    ]);
+    const scss: SideEffectScssOptions = {
+      loadPaths: [],
+      scssErrors: [],
+      scssDependencies: new Map(),
+      registry,
+      registryReverseIndex,
+    };
+
+    // srcFile (comp.ts)에 대한 emit → other.ts의 항목은 건드리지 않음
+    writeEmitResults([makeEmitResult("export class Comp {}", srcFile)], pkgDir, scss);
+
+    expect(registry.has(otherScssPath)).toBe(true);
+    expect(registryReverseIndex.has(otherSrcFile)).toBe(true);
+  });
+});
+
+describe("compileSideEffectScss — incremental compilation", () => {
+  function makeEntry(scssAbsPath: string, sourceFileName: string): SideEffectScssEntry {
+    return {
+      scssAbsPath,
+      cssAbsPath: scssAbsPath.replace(/\.scss$/, ".css"),
+      sourceFileName,
+    };
+  }
+
+  // Acceptance: changedScssFiles 미제공 시 전체 재컴파일
+  it("compiles all entries when changedScssFiles is not provided", () => {
+    const registry = new Map<string, SideEffectScssEntry>([
+      ["/src/button.scss", makeEntry("/src/button.scss", "/src/comp.ts")],
+      ["/src/dialog.scss", makeEntry("/src/dialog.scss", "/src/comp.ts")],
+      ["/src/card.scss", makeEntry("/src/card.scss", "/src/other.ts")],
+    ]);
+
+    compileSideEffectScss(registry, [], [], new Map());
+
+    expect(mockCompileScssFile).toHaveBeenCalledTimes(3);
+  });
+
+  // Acceptance: 변경된 SCSS 파일만 재컴파일 (직접 히트)
+  it("only compiles entries whose scssAbsPath is in changedScssFiles", () => {
+    const registry = new Map<string, SideEffectScssEntry>([
+      ["/src/button.scss", makeEntry("/src/button.scss", "/src/comp.ts")],
+      ["/src/dialog.scss", makeEntry("/src/dialog.scss", "/src/other.ts")],
+    ]);
+    const changedScssFiles = new Set(["/src/button.scss"]);
+    const sideEffectScssDeps = new Map<string, Set<string>>();
+
+    compileSideEffectScss(registry, [], [], new Map(), changedScssFiles, sideEffectScssDeps);
+
+    expect(mockCompileScssFile).toHaveBeenCalledTimes(1);
+    expect(mockCompileScssFile).toHaveBeenCalledWith("/src/button.scss", []);
+  });
+
+  // Acceptance: 의존성이 변경된 SCSS도 재컴파일
+  it("recompiles entries whose dependency is in changedScssFiles", () => {
+    const registry = new Map<string, SideEffectScssEntry>([
+      ["/src/button.scss", makeEntry("/src/button.scss", "/src/comp.ts")],
+    ]);
+    const changedScssFiles = new Set(["/src/shared.scss"]);
+    // button.scss의 이전 컴파일에서 shared.scss가 의존성이었음
+    const sideEffectScssDeps = new Map<string, Set<string>>([
+      ["/src/button.scss", new Set(["/src/shared.scss"])],
+    ]);
+
+    compileSideEffectScss(registry, [], [], new Map(), changedScssFiles, sideEffectScssDeps);
+
+    expect(mockCompileScssFile).toHaveBeenCalledTimes(1);
+    expect(mockCompileScssFile).toHaveBeenCalledWith("/src/button.scss", []);
+  });
+
+  // Acceptance: 영향받지 않는 항목은 건너뜀
+  it("skips entries not affected by changedScssFiles", () => {
+    const registry = new Map<string, SideEffectScssEntry>([
+      ["/src/button.scss", makeEntry("/src/button.scss", "/src/comp.ts")],
+      ["/src/dialog.scss", makeEntry("/src/dialog.scss", "/src/other.ts")],
+    ]);
+    const changedScssFiles = new Set(["/src/shared.scss"]);
+    const sideEffectScssDeps = new Map<string, Set<string>>([
+      ["/src/button.scss", new Set(["/src/shared.scss"])],
+      ["/src/dialog.scss", new Set(["/src/theme.scss"])],
+    ]);
+
+    compileSideEffectScss(registry, [], [], new Map(), changedScssFiles, sideEffectScssDeps);
+
+    // button.scss만 재컴파일 (shared.scss가 의존성), dialog.scss는 건너뜀
+    expect(mockCompileScssFile).toHaveBeenCalledTimes(1);
+    expect(mockCompileScssFile).toHaveBeenCalledWith("/src/button.scss", []);
+  });
+
+  // Unit: 컴파일 후 sideEffectScssDeps가 갱신됨
+  it("updates sideEffectScssDeps after compilation", () => {
+    const registry = new Map<string, SideEffectScssEntry>([
+      ["/src/button.scss", makeEntry("/src/button.scss", "/src/comp.ts")],
+    ]);
+    mockCompileScssFile.mockReturnValue({ css: "/* ok */", dependencies: ["/src/new-dep.scss"] });
+    const sideEffectScssDeps = new Map<string, Set<string>>();
+
+    compileSideEffectScss(registry, [], [], new Map(), undefined, sideEffectScssDeps);
+
+    expect(sideEffectScssDeps.get("/src/button.scss")).toEqual(new Set(["/src/new-dep.scss"]));
+  });
+});

package/tests/angular/ngtsc-build-core.spec.ts

@@ -0,0 +1,52 @@
+import { describe, it, expect } from "vitest";
+import { buildReverseDeps } from "../../src/angular/ngtsc-build-core";
+
+describe("buildReverseDeps", () => {
+  // Acceptance: 정방향 맵에서 역방향 인덱스를 구축한다
+  it("builds reverse index from forward deps with multiple owners sharing a dep", () => {
+    const forward = new Map<string, ReadonlySet<string>>([
+      ["comp.ts", new Set(["shared.scss", "theme.scss"])],
+      ["dialog.ts", new Set(["shared.scss"])],
+    ]);
+
+    const reverse = buildReverseDeps(forward);
+
+    expect(reverse.get("shared.scss")).toEqual(new Set(["comp.ts", "dialog.ts"]));
+    expect(reverse.get("theme.scss")).toEqual(new Set(["comp.ts"]));
+    expect(reverse.size).toBe(2);
+  });
+
+  // Acceptance: 빈 맵이면 역방향 맵도 비어있다
+  it("returns empty map for empty input", () => {
+    const reverse = buildReverseDeps(new Map());
+
+    expect(reverse.size).toBe(0);
+  });
+
+  // Unit: 하나의 소유자가 여러 의존성을 가진 경우
+  it("maps each dep to its single owner", () => {
+    const forward = new Map<string, ReadonlySet<string>>([
+      ["comp.ts", new Set(["a.scss", "b.scss", "c.scss"])],
+    ]);
+
+    const reverse = buildReverseDeps(forward);
+
+    expect(reverse.size).toBe(3);
+    expect(reverse.get("a.scss")).toEqual(new Set(["comp.ts"]));
+    expect(reverse.get("b.scss")).toEqual(new Set(["comp.ts"]));
+    expect(reverse.get("c.scss")).toEqual(new Set(["comp.ts"]));
+  });
+
+  // Unit: 의존성이 빈 Set인 소유자는 역방향 맵에 영향 없음
+  it("ignores owners with empty dep sets", () => {
+    const forward = new Map<string, ReadonlySet<string>>([
+      ["comp.ts", new Set<string>()],
+      ["dialog.ts", new Set(["shared.scss"])],
+    ]);
+
+    const reverse = buildReverseDeps(forward);
+
+    expect(reverse.size).toBe(1);
+    expect(reverse.get("shared.scss")).toEqual(new Set(["dialog.ts"]));
+  });
+});