@simplysm/sd-cli 14.0.43 → 14.0.44

package/src/commands/publish/version-upgrade.ts

@@ -46,28 +46,35 @@ export async function upgradeVersion(
   await fsx.write(projPkgPath, json.stringify(projPkg, { space: 2 }) + "\n");
   changedFiles.push(projPkgPath);
 
-  // 각 패키지의 package.json에 버전 설정
-  for (const pkgPath of allPkgPaths) {
-    const pkgJsonPath = path.resolve(pkgPath, "package.json");
-    const pkgJson = await fsx.readJson<PackageJson>(pkgJsonPath);
-    pkgJson.version = newVersion;
-    await fsx.write(pkgJsonPath, json.stringify(pkgJson, { space: 2 }) + "\n");
-    changedFiles.push(pkgJsonPath);
-  }
+  // 각 패키지의 package.json에 버전 설정 (병렬)
+  const pkgChangedFiles = await Promise.all(
+    allPkgPaths.map(async (pkgPath) => {
+      const pkgJsonPath = path.resolve(pkgPath, "package.json");
+      const pkgJson = await fsx.readJson<PackageJson>(pkgJsonPath);
+      pkgJson.version = newVersion;
+      await fsx.write(pkgJsonPath, json.stringify(pkgJson, { space: 2 }) + "\n");
+      return pkgJsonPath;
+    }),
+  );
+  changedFiles.push(...pkgChangedFiles);
 
   // 템플릿 파일의 @simplysm 패키지 버전 동기화
   const templateFiles = await fsx.glob(path.resolve(cwd, "packages/sd-cli/templates/**/*.hbs"));
   const versionRegex = /("@simplysm\/[^"]+"\s*:\s*)"~[^"]+"/g;
 
-  for (const templatePath of templateFiles) {
-    const content = await fsx.read(templatePath);
-    const newContent = content.replace(versionRegex, `$1"~${newVersion}"`);
+  const templateChangedFiles = await Promise.all(
+    templateFiles.map(async (templatePath) => {
+      const content = await fsx.read(templatePath);
+      const newContent = content.replace(versionRegex, `$1"~${newVersion}"`);
 
-    if (content !== newContent) {
-      await fsx.write(templatePath, newContent);
-      changedFiles.push(templatePath);
-    }
-  }
+      if (content !== newContent) {
+        await fsx.write(templatePath, newContent);
+        return templatePath;
+      }
+      return undefined;
+    }),
+  );
+  changedFiles.push(...templateChangedFiles.filter((f) => f != null));
 
   return { version: newVersion, changedFiles };
 }
@@ -81,25 +88,27 @@ export async function computePublishLevels<T extends { name: string; path: strin
 ): Promise<T[][]> {
   const pkgNames = new Set(publishPkgs.map((p) => p.name));
 
-  // 각 패키지의 워크스페이스 의존성 수집
-  const depsMap = new Map<string, Set<string>>();
-  for (const pkg of publishPkgs) {
-    const pkgJson = await fsx.readJson<PackageJson>(path.resolve(pkg.path, "package.json"));
-    const allDeps = {
-      ...pkgJson.dependencies,
-      ...pkgJson.peerDependencies,
-      ...pkgJson.optionalDependencies,
-    };
-
-    const workspaceDeps = new Set<string>();
-    for (const depName of Object.keys(allDeps)) {
-      const shortName = depName.replace(/^@simplysm\//, "");
-      if (shortName !== depName && pkgNames.has(shortName)) {
-        workspaceDeps.add(shortName);
+  // 각 패키지의 워크스페이스 의존성 수집 (병렬)
+  const depsEntries = await Promise.all(
+    publishPkgs.map(async (pkg) => {
+      const pkgJson = await fsx.readJson<PackageJson>(path.resolve(pkg.path, "package.json"));
+      const allDeps = {
+        ...pkgJson.dependencies,
+        ...pkgJson.peerDependencies,
+        ...pkgJson.optionalDependencies,
+      };
+
+      const workspaceDeps = new Set<string>();
+      for (const depName of Object.keys(allDeps)) {
+        const shortName = depName.replace(/^@simplysm\//, "");
+        if (shortName !== depName && pkgNames.has(shortName)) {
+          workspaceDeps.add(shortName);
+        }
       }
-    }
-    depsMap.set(pkg.name, workspaceDeps);
-  }
+      return [pkg.name, workspaceDeps] as const;
+    }),
+  );
+  const depsMap = new Map(depsEntries);
 
   // 위상 정렬로 레벨 분류
   const levels: T[][] = [];

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

@@ -7,6 +7,70 @@ import { promisify } from "util";
 import type { ReplaceDepEntry } from "./replace-deps-resolve";
 import { resolveAllReplaceDepEntries } from "./replace-deps-resolve";
 
+/**
+ * 파일 내용이 동일한지 비교한다.
+ * mtime + size가 같으면 동일로 간주하고, 다르면 바이트 비교한다.
+ */
+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;
+  }
+}
+
+/**
+ * pnpm hard link를 끊으면서 파일/디렉토리를 복사한다.
+ * 대상 파일을 먼저 unlink하여 글로벌 store의 hard link를 끊고 새 파일을 생성한다.
+ * 다른 프로젝트의 node_modules에 영향을 주지 않기 위함이다.
+ */
+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 필드와 무관하게 항상 포함되는 파일 패턴 (대소문자 무시)
  */
@@ -69,33 +133,31 @@ 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);
-  const copiedEntries: ReplaceDepEntry[] = [];
 
-  for (const entry of entries) {
+  const results = await Promise.all(entries.map(async (entry) => {
     try {
-      // 소스 패키지의 files 필드를 읽어 화이트리스트 구성
       const files = await loadFilesField(entry.resolvedSourcePath);
       if (files == null) {
         logger.warn(`[${entry.targetName}] package.json에 files 필드가 없어 건너뜀`);
-        continue;
+        return undefined;
       }
 
       const filter = createCopyFilter(entry.resolvedSourcePath, new Set(files));
-      await fsx.copy(entry.resolvedSourcePath, entry.actualTargetPath, filter);
-
-      copiedEntries.push(entry);
-      setupCount += 1;
+      await copyWithUnlink(entry.resolvedSourcePath, entry.actualTargetPath, filter);
+      return entry;
     } catch (err) {
       logger.error(`[${entry.targetName}] 복사 실패: ${err instanceof Error ? err.message : err}`);
+      return undefined;
     }
-  }
+  }));
 
-  logger.success(`replace-deps 설정 완료 (${setupCount}개 의존성 교체)`);
+  const copiedEntries = results.filter((e): e is ReplaceDepEntry => e != null);
+
+  logger.success(`replace-deps 설정 완료 (${copiedEntries.length}개 의존성 교체)`);
 
   // 교체된 패키지의 postinstall 스크립트 실행
   for (const { targetName, resolvedSourcePath, actualTargetPath } of copiedEntries) {
@@ -174,15 +236,20 @@ export async function watchReplaceDeps(
         // readdir 실패 시 npm 기본 파일 감시 생략
       }
 
+      // 이 소스 경로에 해당하는 entries만 사전 필터링하여 캡처
+      const sourceEntries = entries.filter(
+        (e) => e.resolvedSourcePath === entry.resolvedSourcePath,
+      );
+
       const watcher = await FsWatcher.watch(watchPaths, {
         followSymlinks: false,
       });
       watcher.onChange({ delay: 300 }, async (changeInfos) => {
-        for (const { path: changedPath } of changeInfos) {
-          // 이 소스 경로를 사용하는 모든 항목에 대해 복사
-          for (const e of entries) {
-            if (e.resolvedSourcePath !== entry.resolvedSourcePath) continue;
+        let hasActualCopy = false;
 
+        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));
@@ -203,12 +270,16 @@ export async function watchReplaceDeps(
                 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.rm(destPath);
+                hasActualCopy = true;
               }
             } catch (err) {
               logger.error(
@@ -217,7 +288,10 @@ export async function watchReplaceDeps(
             }
           }
         }
-        options?.onChanged?.();
+
+        if (hasActualCopy) {
+          options?.onChanged?.();
+        }
       });
 
       watchers.push(watcher);

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

@@ -88,16 +88,19 @@ export function createPostcssPlugin(options: CreatePostcssPluginOptions): esbuil
 
             if (replacements.length === 0) continue;
 
-            // PostCSS 적용 및 역순 교체
-            let modified = code;
-            // 끝에서 시작 방향으로 교체하여 offset 유지
-            const sorted = replacements.sort((a, b) => b.start - a.start);
+            // PostCSS 적용 — 정방향 청크 배열 + join
+            const sorted = replacements.sort((a, b) => a.start - b.start);
+            const chunks: string[] = [];
+            let cursor = 0;
 
             for (const rep of sorted) {
+              chunks.push(code.slice(cursor, rep.start));
               const processed = await processor.process(rep.text, { from: file });
-              const escaped = JSON.stringify(processed.css);
-              modified = modified.slice(0, rep.start) + escaped + modified.slice(rep.end);
+              chunks.push(JSON.stringify(processed.css));
+              cursor = rep.end;
             }
+            chunks.push(code.slice(cursor));
+            const modified = chunks.join("");
 
             await fs.promises.writeFile(file, modified);
           } catch (e: unknown) {

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