@simplysm/sd-cli 14.0.43 → 14.0.44

package/tests/deps/replace-deps/replace-deps-resolve.acc.spec.ts

@@ -0,0 +1,124 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { pathx } from "@simplysm/core-node";
+import { resolveAllReplaceDepEntries } from "../../../src/deps/replace-deps/replace-deps-resolve";
+import { consola } from "consola";
+
+describe("resolveAllReplaceDepEntries", () => {
+  let tmpDir: string;
+  let projectRoot: string;
+  const logger = consola.withTag("test");
+
+  beforeEach(async () => {
+    tmpDir = pathx.posix(await fs.promises.mkdtemp(path.join(os.tmpdir(), "sd-resolve-deps-")));
+    projectRoot = pathx.posix(path.join(tmpDir, "project"));
+    await fs.promises.mkdir(projectRoot, { recursive: true });
+    await fs.promises.writeFile(
+      pathx.posix(path.join(projectRoot, "pnpm-workspace.yaml")),
+      "packages:\n",
+    );
+  });
+
+  afterEach(async () => {
+    await fs.promises.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  /**
+   * node_modules에 패키지 디렉토리를 생성하는 헬퍼
+   */
+  async function createNodeModulesPkg(
+    nodeModulesDir: string,
+    pkgName: string,
+  ): Promise<string> {
+    const pkgDir = pathx.posix(path.join(nodeModulesDir, pkgName));
+    await fs.promises.mkdir(pkgDir, { recursive: true });
+    await fs.promises.writeFile(
+      pathx.posix(path.join(pkgDir, "package.json")),
+      JSON.stringify({ name: pkgName }),
+    );
+    return pkgDir;
+  }
+
+  /**
+   * 소스 패키지를 생성하는 헬퍼
+   */
+  async function createSourcePkg(name: string): Promise<string> {
+    const sourcePath = pathx.posix(path.join(tmpDir, name));
+    await fs.promises.mkdir(sourcePath, { recursive: true });
+    await fs.promises.writeFile(
+      pathx.posix(path.join(sourcePath, "package.json")),
+      JSON.stringify({ name, files: ["dist"] }),
+    );
+    await fs.promises.mkdir(pathx.posix(path.join(sourcePath, "dist")), { recursive: true });
+    await fs.promises.writeFile(
+      pathx.posix(path.join(sourcePath, "dist", "index.js")),
+      "module.exports = {};",
+    );
+    return sourcePath;
+  }
+
+  it("동일 actualTargetPath를 가진 항목은 중복 등록되지 않는다", async () => {
+    // Given: 루트 node_modules와 workspace pkg의 node_modules에 동일 패키지가 존재하고
+    //        둘 다 같은 실제 경로(symlink 해석 후)를 가리킨다
+    const sourcePath = await createSourcePkg("@test/pkg");
+    const nodeModulesDir = pathx.posix(path.join(projectRoot, "node_modules"));
+    await createNodeModulesPkg(nodeModulesDir, "@test/pkg");
+
+    // workspace 패키지 설정 (pnpm-workspace.yaml에 추가)
+    const workspacePkgDir = pathx.posix(path.join(projectRoot, "packages", "my-app"));
+    await fs.promises.mkdir(workspacePkgDir, { recursive: true });
+    await fs.promises.writeFile(
+      pathx.posix(path.join(projectRoot, "pnpm-workspace.yaml")),
+      "packages:\n  - packages/*\n",
+    );
+
+    // workspace 패키지의 node_modules에도 동일 패키지 생성
+    const wsPkgNodeModules = pathx.posix(path.join(workspacePkgDir, "node_modules"));
+    await createNodeModulesPkg(wsPkgNodeModules, "@test/pkg");
+
+    // When
+    const entries = await resolveAllReplaceDepEntries(
+      projectRoot,
+      { "@test/pkg": sourcePath },
+      logger,
+    );
+
+    // Then: actualTargetPath가 다르므로 2개가 반환되어야 한다
+    //       (symlink가 아닌 실제 디렉토리이므로 actualTargetPath가 각각 다름)
+    //       중복 방지 로직은 동일 actualTargetPath일 때만 작동한다
+    const actualTargetPaths = entries.map((e) => e.actualTargetPath);
+    const uniqueActualTargetPaths = new Set(actualTargetPaths);
+    expect(actualTargetPaths.length).toBe(uniqueActualTargetPaths.size);
+  });
+
+  it("여러 replaceDeps 패턴이 올바르게 매칭되어 결과를 반환한다", async () => {
+    // Given: 2개의 다른 패턴과 각각의 소스 패키지
+    const sourceA = await createSourcePkg("@test/pkg-a");
+    const sourceB = await createSourcePkg("@other/lib");
+    const nodeModulesDir = pathx.posix(path.join(projectRoot, "node_modules"));
+    await createNodeModulesPkg(nodeModulesDir, "@test/pkg-a");
+    await createNodeModulesPkg(nodeModulesDir, "@other/lib");
+
+    // When: 2개 패턴으로 호출 (glob이 병렬 실행되어야 함)
+    const entries = await resolveAllReplaceDepEntries(
+      projectRoot,
+      {
+        "@test/pkg-a": sourceA,
+        "@other/lib": sourceB,
+      },
+      logger,
+    );
+
+    // Then: 두 패턴 모두 매칭되어 2개 entries 반환
+    expect(entries).toHaveLength(2);
+    const targetNames = entries.map((e) => e.targetName).sort();
+    expect(targetNames).toEqual(["@other/lib", "@test/pkg-a"]);
+  });
+
+  it("빈 replaceDeps 설정이면 빈 배열을 반환한다", async () => {
+    const entries = await resolveAllReplaceDepEntries(projectRoot, {}, logger);
+    expect(entries).toEqual([]);
+  });
+});

package/tests/esbuild/esbuild-postcss-plugin-chunking.verify.md

@@ -0,0 +1,17 @@
+# PostCSS 문자열 교체 청크화 — LLM 검증
+
+## 검증 항목
+
+- [x] 정방향 청크 배열 + join이 역순 slice와 수학적으로 동일한 결과를 생성하는가:
+  역순 slice 방식은 `code[0..start_n] + rep_n + code[end_n..start_{n-1}] + rep_{n-1} + ... + code[end_1..]` 순서로 최종 문자열을 구성한다.
+  정방향 청크 방식은 `code[0..start_1] + rep_1 + code[end_1..start_2] + rep_2 + ... + code[end_n..]` 순서로 청크를 수집하고 join한다.
+  두 방식 모두 원본 텍스트의 비교체 구간과 PostCSS 처리된 교체 텍스트를 동일한 순서로 결합하므로, replacements가 비중첩(acorn AST 노드 보장)인 한 결과가 동일하다.
+  검증 결과: **동일성 보장됨**
+
+- [x] cursor 초기값 0과 마지막 `code.slice(cursor)` 호출이 파일 전체를 커버하는가:
+  cursor는 0에서 시작하여 각 replacement의 end로 갱신된다. 마지막 `chunks.push(code.slice(cursor))`가 마지막 replacement 이후의 원본 텍스트를 수집한다. replacements가 0건이면 `code.slice(0)` = 전체 코드가 되지만, 이 경우 `replacements.length === 0`에서 continue되므로 도달하지 않는다.
+  검증 결과: **전체 커버됨**
+
+- [x] `replacements.sort()`가 원본 배열을 변경하는 것이 문제되지 않는가:
+  `replacements`는 각 파일 처리 시 새로 생성되는 로컬 배열이므로 in-place sort가 안전하다. 기존 코드도 동일하게 in-place sort를 사용했다.
+  검증 결과: **문제 없음**

package/tests/esbuild/esbuild-postcss-plugin.acc.spec.ts

@@ -0,0 +1,152 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import type esbuild from "esbuild";
+import fs from "fs";
+import path from "path";
+import os from "os";
+import type { AcceptedPlugin } from "postcss";
+import { createPostcssPlugin } from "../../src/esbuild/esbuild-postcss-plugin";
+
+/** esbuild 플러그인 lifecycle을 시뮬레이션하는 헬퍼 */
+function setupPlugin(plugin: esbuild.Plugin) {
+  let onEndCb:
+    | ((
+        result: esbuild.BuildResult,
+      ) => esbuild.OnEndResult | null | void | Promise<esbuild.OnEndResult | null | void>)
+    | undefined;
+
+  const mockBuild = {
+    onEnd(cb: typeof onEndCb) {
+      onEndCb = cb;
+    },
+  } as unknown as esbuild.PluginBuild;
+
+  void plugin.setup(mockBuild);
+
+  return {
+    async invokeOnEnd(result: Partial<esbuild.BuildResult>) {
+      return (
+        (await onEndCb?.({
+          errors: [],
+          warnings: [],
+          mangleCache: {},
+          outputFiles: [],
+          metafile: { inputs: {}, outputs: {} },
+          ...result,
+        } as esbuild.BuildResult)) ?? null
+      );
+    },
+  };
+}
+
+/** 테스트용 PostCSS 플러그인: 모든 CSS 앞에 주석을 추가 */
+function createTestPostcssPlugin(): AcceptedPlugin {
+  return {
+    postcssPlugin: "test-prefix",
+    Once(root) {
+      root.prepend({ text: "processed" });
+    },
+  };
+}
+
+/** ɵɵdefineComponent styles 배열을 포함하는 JS 코드를 생성 (실제 Angular 컴파일 출력 패턴) */
+function generateJsWithStyles(styles: string[]): string {
+  const stylesLiteral = styles.map((s) => JSON.stringify(s)).join(", ");
+  return [
+    `import * as i0 from "@angular/core";`,
+    `class MyComponent {}`,
+    `MyComponent.\u0275cmp = /*@__PURE__*/ i0.\u0275\u0275defineComponent({`,
+    `  type: MyComponent,`,
+    `  styles: [${stylesLiteral}],`,
+    `  template: function() {}`,
+    `});`,
+    `export { MyComponent };`,
+  ].join("\n");
+}
+
+describe("createPostcssPlugin — Acceptance Tests", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "postcss-test-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("replacements가 0건이면 파일 내용이 변경되지 않음", async () => {
+    // Given: ɵɵdefineComponent styles 배열이 없는 JS 파일
+    const jsContent = `const x = 1;\nexport default x;\n`;
+    const jsFile = path.join(tmpDir, "no-styles.js");
+    fs.writeFileSync(jsFile, jsContent, "utf-8");
+
+    const plugin = createPostcssPlugin({ plugins: [createTestPostcssPlugin()] });
+    const lifecycle = setupPlugin(plugin);
+
+    // When: PostCSS 처리를 시도
+    await lifecycle.invokeOnEnd({
+      metafile: { inputs: {}, outputs: { [jsFile]: {} as any } },
+    });
+
+    // Then: 파일 내용이 변경되지 않음
+    const result = fs.readFileSync(jsFile, "utf-8");
+    expect(result).toBe(jsContent);
+  });
+
+  it("replacements가 1건이면 PostCSS 처리된 CSS로 교체됨", async () => {
+    // Given: ɵɵdefineComponent styles 배열에 문자열 리터럴이 1개
+    const originalCss = ".host { color: red; }";
+    const jsContent = generateJsWithStyles([originalCss]);
+    const jsFile = path.join(tmpDir, "one-style.js");
+    fs.writeFileSync(jsFile, jsContent, "utf-8");
+
+    const plugin = createPostcssPlugin({ plugins: [createTestPostcssPlugin()] });
+    const lifecycle = setupPlugin(plugin);
+
+    // When: PostCSS 처리 수행
+    await lifecycle.invokeOnEnd({
+      metafile: { inputs: {}, outputs: { [jsFile]: {} as any } },
+    });
+
+    // Then: PostCSS 처리된 CSS가 파일에 반영됨
+    const result = fs.readFileSync(jsFile, "utf-8");
+    expect(result).toContain("/* processed */");
+    expect(result).toContain(".host { color: red; }");
+    // 파일 앞뒤의 JS 구조가 유지됨
+    expect(result).toContain("import");
+    expect(result).toContain("export");
+  });
+
+  it("replacements가 3건이면 모든 CSS가 PostCSS 처리됨", async () => {
+    // Given: ɵɵdefineComponent styles 배열에 문자열 리터럴이 3개
+    const styles = [
+      ".a { color: red; }",
+      ".b { color: blue; }",
+      ".c { color: green; }",
+    ];
+    const jsContent = generateJsWithStyles(styles);
+    const jsFile = path.join(tmpDir, "three-styles.js");
+    fs.writeFileSync(jsFile, jsContent, "utf-8");
+
+    const plugin = createPostcssPlugin({ plugins: [createTestPostcssPlugin()] });
+    const lifecycle = setupPlugin(plugin);
+
+    // When: PostCSS 처리 수행
+    await lifecycle.invokeOnEnd({
+      metafile: { inputs: {}, outputs: { [jsFile]: {} as any } },
+    });
+
+    // Then: 3개 모두 PostCSS 처리됨
+    const result = fs.readFileSync(jsFile, "utf-8");
+    // 3번의 "/* processed */" 주석이 삽입됨
+    const processedCount = (result.match(/\/\* processed \*\//g) ?? []).length;
+    expect(processedCount).toBe(3);
+    // 원본 CSS 내용이 모두 유지됨
+    expect(result).toContain("color: red");
+    expect(result).toContain("color: blue");
+    expect(result).toContain("color: green");
+    // JS 구조가 유지됨
+    expect(result).toContain("import");
+    expect(result).toContain("export");
+  });
+});

package/tests/utils/ngtsc-build-core-write-emit.spec.ts

@@ -428,6 +428,130 @@ describe("writeEmitResults with registry", () => {
   });
 });
 
+// Feature 1.1 (review fix): writeEmitResults에서 sideEffectScssDeps 갱신
+describe("writeEmitResults with sideEffectScssDeps", () => {
+  let tmpDir: string;
+  let pkgDir: string;
+  let srcDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "write-emit-se-deps-"));
+    pkgDir = path.join(tmpDir, "my-pkg");
+    srcDir = path.join(pkgDir, "src");
+    fs.mkdirSync(path.join(pkgDir, "dist"), { recursive: true });
+    fs.mkdirSync(path.join(srcDir, "ui", "layout"), { recursive: true });
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  // Acceptance: 새 side-effect SCSS의 의존성이 sideEffectScssDeps에 기록된다
+  it("records side-effect SCSS dependencies in sideEffectScssDeps after compileScssFile", async () => {
+    const { writeEmitResults } = await import("../../src/angular/ngtsc-build-core");
+
+    // Create shared variables file
+    const scssLoadDir = path.join(pkgDir, "scss");
+    fs.mkdirSync(path.join(scssLoadDir, "commons"), { recursive: true });
+    fs.writeFileSync(
+      path.join(scssLoadDir, "commons", "_variables.scss"),
+      "$primary: #ff0000;",
+      "utf-8",
+    );
+
+    // Create source SCSS that uses @use
+    const scssPath = path.join(srcDir, "ui", "layout", "sd-card.scss");
+    fs.writeFileSync(
+      scssPath,
+      '@use "commons/variables" as vars;\n.sd-card { color: vars.$primary; }',
+      "utf-8",
+    );
+
+    const distDir = path.join(pkgDir, "dist");
+    const jsPath = path.join(distDir, "my-pkg", "src", "ui", "layout", "sd-card.directive.js");
+    const sourceFileName = path.join(srcDir, "ui", "layout", "sd-card.directive.ts");
+    const emitResults = [
+      {
+        filename: jsPath,
+        contents: 'import "./sd-card.scss";\nexport class SdCardDirective {}',
+        sourceFileName,
+      },
+    ];
+
+    const sideEffectScssDeps = new Map<string, Set<string>>();
+    const scss: SideEffectScssOptions = {
+      loadPaths: [scssLoadDir],
+      scssErrors: [],
+      scssDependencies: new Map(),
+      sideEffectScssDeps,
+    };
+    writeEmitResults(emitResults, pkgDir, scss);
+
+    // sideEffectScssDeps should have the SCSS entry with its dependencies
+    expect(sideEffectScssDeps.has(scssPath)).toBe(true);
+    const deps = sideEffectScssDeps.get(scssPath)!;
+    expect(deps.size).toBeGreaterThan(0);
+    expect([...deps].some((d) => d.includes("_variables.scss"))).toBe(true);
+  });
+
+  // Unit: sideEffectScssDeps 미제공 시 기존 동작 유지
+  it("does not crash when sideEffectScssDeps is not provided", async () => {
+    const { writeEmitResults } = await import("../../src/angular/ngtsc-build-core");
+
+    const scssPath = path.join(srcDir, "ui", "layout", "sd-flex.scss");
+    fs.writeFileSync(scssPath, ".sd-flex { display: flex; }", "utf-8");
+
+    const distDir = path.join(pkgDir, "dist");
+    const jsPath = path.join(distDir, "my-pkg", "src", "ui", "layout", "sd-flex.directive.js");
+    const emitResults = [
+      {
+        filename: jsPath,
+        contents: 'import "./sd-flex.scss";\nexport class SdFlexDirective {}',
+        sourceFileName: path.join(srcDir, "ui", "layout", "sd-flex.directive.ts"),
+      },
+    ];
+
+    const scss: SideEffectScssOptions = {
+      loadPaths: [],
+      scssErrors: [],
+      scssDependencies: new Map(),
+    };
+
+    // Should not throw
+    writeEmitResults(emitResults, pkgDir, scss);
+    expect(scss.scssErrors).toEqual([]);
+  });
+
+  // Unit: SCSS 컴파일 에러 시 sideEffectScssDeps에 기록하지 않는다
+  it("does not record in sideEffectScssDeps when SCSS compilation fails", async () => {
+    const { writeEmitResults } = await import("../../src/angular/ngtsc-build-core");
+
+    const distDir = path.join(pkgDir, "dist");
+    const jsPath = path.join(distDir, "my-pkg", "src", "ui", "layout", "missing.directive.js");
+    const emitResults = [
+      {
+        filename: jsPath,
+        contents: 'import "./missing.scss";\nexport class MissingDirective {}',
+        sourceFileName: path.join(srcDir, "ui", "layout", "missing.directive.ts"),
+      },
+    ];
+
+    const sideEffectScssDeps = new Map<string, Set<string>>();
+    const scss: SideEffectScssOptions = {
+      loadPaths: [],
+      scssErrors: [],
+      scssDependencies: new Map(),
+      sideEffectScssDeps,
+    };
+    writeEmitResults(emitResults, pkgDir, scss);
+
+    // Error should be reported
+    expect(scss.scssErrors.length).toBeGreaterThan(0);
+    // sideEffectScssDeps should be empty (no successful compilation)
+    expect(sideEffectScssDeps.size).toBe(0);
+  });
+});
+
 // Feature 1.2: compileSideEffectScss
 describe("compileSideEffectScss", () => {
   let tmpDir: string;

package/tests/workers/client-worker-mtime-incremental.verify.md

@@ -0,0 +1,10 @@
+# client.worker mtime 증분 추적 — LLM 검증
+
+## 검증 항목
+
+- [x] createSourceFileCachePlugin이 IncrementalMtimeTracker를 사용하는지 확인: `client.worker.ts:198` — `const mtimeTracker = new IncrementalMtimeTracker();` 확인됨
+- [x] onStart에서 detectChanges 결과로 invalidate가 호출되는지 확인: `client.worker.ts:210-213` — `mtimeTracker.detectChanges(watchTargets)` 결과를 `sourceFileCache.invalidate(changedFiles)`에 전달. 기존 로직과 동작 동일
+- [x] onEnd에서 updateMtimes가 호출되는지 확인: `client.worker.ts:228` — `mtimeTracker.updateMtimes(watchTargets)` 호출 확인. `prevMtimes.clear()` + 전체 순회 제거됨
+- [x] esbuildResult == null 가드가 유지되는지 확인: onStart의 `if (esbuildResult != null)` (라인 202), onEnd의 `if (esbuildResult == null) return;` (라인 222) 모두 유지됨
+- [x] isInitialBuild 가드와 sender.send("buildStart")가 유지되는지 확인: `client.worker.ts:216-218` — `if (!isInitialBuild) { sender.send("buildStart", {}); }` 유지됨
+- [x] import 경로에 .js 확장자가 없는지 확인: `client.worker.ts:20` — `from "./incremental-mtime-tracker"` (확장자 없음)

package/tests/workers/incremental-mtime-tracker.acc.spec.ts

@@ -0,0 +1,144 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { IncrementalMtimeTracker } from "../../src/workers/incremental-mtime-tracker";
+
+describe("IncrementalMtimeTracker — Acceptance", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "mtime-acc-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  function createFile(name: string): string {
+    const filePath = path.join(tmpDir, name);
+    fs.writeFileSync(filePath, `content-${name}`, "utf-8");
+    return filePath;
+  }
+
+  function touchFile(filePath: string): void {
+    const stat = fs.statSync(filePath);
+    const newTime = stat.mtimeMs / 1000 + 2;
+    fs.utimesSync(filePath, newTime, newTime);
+  }
+
+  // Scenario: 변경된 파일만 mtime 갱신
+  it("onEnd에서 변경된 파일만 stat 호출한다", () => {
+    const tracker = new IncrementalMtimeTracker();
+    const fileA = createFile("a.ts");
+    const fileB = createFile("b.ts");
+    const fileC = createFile("c.ts");
+    const targets = [fileA, fileB, fileC];
+
+    // 초기 빌드: prevMtimes 채우기
+    tracker.updateMtimes(targets);
+
+    // 파일 A 변경
+    touchFile(fileA);
+
+    // onStart: 변경 감지
+    const changed = tracker.detectChanges(targets);
+    expect(changed.size).toBe(1);
+    expect(changed.has(fileA)).toBe(true);
+
+    // onEnd: 증분 갱신 — 변경된 A만 stat
+    const spy = vi.spyOn(fs, "statSync");
+    tracker.updateMtimes(targets);
+    const statPaths = spy.mock.calls.map((c) => c[0]);
+    expect(statPaths).toContain(fileA);
+    expect(statPaths).not.toContain(fileB);
+    expect(statPaths).not.toContain(fileC);
+    spy.mockRestore();
+  });
+
+  // Scenario: 새로 추가된 파일만 stat 호출
+  it("onEnd에서 새로 추가된 파일만 stat 호출한다", () => {
+    const tracker = new IncrementalMtimeTracker();
+    const fileA = createFile("a.ts");
+    const fileB = createFile("b.ts");
+
+    tracker.updateMtimes([fileA, fileB]);
+
+    const fileC = createFile("c.ts");
+    tracker.detectChanges([fileA, fileB, fileC]);
+
+    const spy = vi.spyOn(fs, "statSync");
+    tracker.updateMtimes([fileA, fileB, fileC]);
+    const statPaths = spy.mock.calls.map((c) => c[0]);
+    expect(statPaths).toEqual([fileC]);
+    spy.mockRestore();
+  });
+
+  // Scenario: 변경도 신규도 없으면 stat 호출 0회
+  it("변경도 신규도 없으면 onEnd에서 stat 호출이 0회이다", () => {
+    const tracker = new IncrementalMtimeTracker();
+    const fileA = createFile("a.ts");
+    const fileB = createFile("b.ts");
+
+    tracker.updateMtimes([fileA, fileB]);
+    tracker.detectChanges([fileA, fileB]);
+
+    const spy = vi.spyOn(fs, "statSync");
+    tracker.updateMtimes([fileA, fileB]);
+    expect(spy.mock.calls).toHaveLength(0);
+    spy.mockRestore();
+  });
+
+  // Scenario: 삭제된 파일이 prevMtimes에서 제거된다
+  it("삭제된 파일은 이후 빌드에서 변경으로 감지되지 않는다", () => {
+    const tracker = new IncrementalMtimeTracker();
+    const fileA = createFile("a.ts");
+    const fileB = createFile("b.ts");
+
+    tracker.updateMtimes([fileA, fileB]);
+
+    // fileB를 watchTargets에서 제거
+    tracker.detectChanges([fileA]);
+    tracker.updateMtimes([fileA]);
+
+    // fileB를 다시 추가 — "신규" 파일이므로 changedFiles에 포함되지 않음
+    const changed = tracker.detectChanges([fileA, fileB]);
+    expect(changed.has(fileB)).toBe(false);
+  });
+
+  // Scenario: mtime 변경된 파일이 changedFiles에 포함된다
+  it("mtime이 변경된 파일이 changedFiles에 포함된다", () => {
+    const tracker = new IncrementalMtimeTracker();
+    const fileA = createFile("a.ts");
+
+    tracker.updateMtimes([fileA]);
+    touchFile(fileA);
+
+    const changed = tracker.detectChanges([fileA]);
+    expect(changed.has(fileA)).toBe(true);
+  });
+
+  // Scenario: 삭제된 파일이 changedFiles에 포함된다
+  it("삭제된 파일이 changedFiles에 포함된다", () => {
+    const tracker = new IncrementalMtimeTracker();
+    const fileA = createFile("a.ts");
+
+    tracker.updateMtimes([fileA]);
+    fs.unlinkSync(fileA);
+
+    const changed = tracker.detectChanges([fileA]);
+    expect(changed.has(fileA)).toBe(true);
+  });
+
+  // Scenario: 신규 파일은 changedFiles에 포함되지 않는다
+  it("신규 파일은 changedFiles에 포함되지 않는다", () => {
+    const tracker = new IncrementalMtimeTracker();
+    const fileA = createFile("a.ts");
+
+    tracker.updateMtimes([fileA]);
+
+    const fileB = createFile("b.ts");
+    const changed = tracker.detectChanges([fileA, fileB]);
+    expect(changed.has(fileB)).toBe(false);
+  });
+});

package/tests/workers/incremental-mtime-tracker.spec.ts

@@ -0,0 +1,102 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { IncrementalMtimeTracker } from "../../src/workers/incremental-mtime-tracker";
+
+describe("IncrementalMtimeTracker", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "mtime-unit-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  function createFile(name: string): string {
+    const filePath = path.join(tmpDir, name);
+    fs.writeFileSync(filePath, name, "utf-8");
+    return filePath;
+  }
+
+  it("빈 watchTargets로 detectChanges하면 빈 Set을 반환한다", () => {
+    const tracker = new IncrementalMtimeTracker();
+    const changed = tracker.detectChanges([]);
+    expect(changed.size).toBe(0);
+  });
+
+  it("빈 watchTargets로 updateMtimes하면 stat 호출이 없다", () => {
+    const tracker = new IncrementalMtimeTracker();
+    const spy = vi.spyOn(fs, "statSync");
+    tracker.updateMtimes([]);
+    expect(spy.mock.calls).toHaveLength(0);
+    spy.mockRestore();
+  });
+
+  it("모든 파일이 watchTargets에서 제거되면 이후 detectChanges에서 감지되지 않는다", () => {
+    const tracker = new IncrementalMtimeTracker();
+    const fileA = createFile("a.ts");
+    const fileB = createFile("b.ts");
+
+    tracker.updateMtimes([fileA, fileB]);
+
+    // 모든 파일 제거
+    tracker.detectChanges([]);
+    tracker.updateMtimes([]);
+
+    // 다시 추가 — "신규"로 취급
+    const changed = tracker.detectChanges([fileA]);
+    expect(changed.has(fileA)).toBe(false);
+  });
+
+  it("동일 파일이 watchTargets에 중복되어도 정상 동작한다", () => {
+    const tracker = new IncrementalMtimeTracker();
+    const fileA = createFile("a.ts");
+
+    tracker.updateMtimes([fileA, fileA]);
+
+    const changed = tracker.detectChanges([fileA]);
+    expect(changed.size).toBe(0);
+  });
+
+  it("detectChanges 없이 연속 updateMtimes를 호출하면 모두 신규로 처리된다", () => {
+    const tracker = new IncrementalMtimeTracker();
+    const fileA = createFile("a.ts");
+
+    const spy = vi.spyOn(fs, "statSync");
+    tracker.updateMtimes([fileA]);
+    expect(spy.mock.calls).toHaveLength(1);
+    spy.mockRestore();
+  });
+
+  it("존재하지 않는 파일은 detectChanges에서 prevMtimes에 없으면 무시된다", () => {
+    const tracker = new IncrementalMtimeTracker();
+    const nonExistent = path.join(tmpDir, "ghost.ts");
+
+    const changed = tracker.detectChanges([nonExistent]);
+    expect(changed.size).toBe(0);
+  });
+
+  it("updateMtimes 중 stat이 실패하는 변경 파일은 prevMtimes에서 제거된다", () => {
+    const tracker = new IncrementalMtimeTracker();
+    const fileA = createFile("a.ts");
+
+    tracker.updateMtimes([fileA]);
+
+    // 파일 삭제 후 detectChanges — changedFiles에 포함
+    fs.unlinkSync(fileA);
+    tracker.detectChanges([fileA]);
+
+    // updateMtimes — stat 실패 → prevMtimes에서 제거
+    tracker.updateMtimes([fileA]);
+
+    // 파일 재생성
+    const fileANew = createFile("a.ts");
+
+    // 다음 detectChanges — "신규"로 취급 (prevMtimes에 없으므로)
+    const changed = tracker.detectChanges([fileANew]);
+    expect(changed.has(fileANew)).toBe(false);
+  });
+});