@simplysm/sd-cli 14.0.43 → 14.0.45

package/tests/esbuild/esbuild-worker-plugin.spec.ts

@@ -0,0 +1,297 @@
+import { describe, it, expect } from "vitest";
+import esbuild from "esbuild";
+import path from "path";
+import fs from "fs";
+import os from "os";
+import { fileURLToPath } from "url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const fixturesDir = path.join(__dirname, "fixtures", "worker-plugin");
+
+const { transformWorkerPatterns, createWorkerBundlePlugin } = await import(
+  "../../src/esbuild/esbuild-worker-plugin.js"
+);
+
+/**
+ * transformWorkerPatterns 테스트용 최소 PluginBuild mock 생성.
+ * 실제 esbuild 모듈을 사용하여 Worker 번들링이 동작한다.
+ */
+function createMockBuild(overrides?: Partial<esbuild.BuildOptions>): esbuild.PluginBuild {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "worker-unit-"));
+  return {
+    esbuild,
+    initialOptions: {
+      outdir: tmpDir,
+      write: false,
+      ...overrides,
+    },
+  } as unknown as esbuild.PluginBuild;
+}
+
+describe("transformWorkerPatterns — 패턴 감지", () => {
+  it("Worker 패턴이 없는 content에 대해 undefined를 반환한다", () => {
+    const result = transformWorkerPatterns(
+      'console.log("hello");',
+      "/test/entry.js",
+      createMockBuild(),
+    );
+
+    expect(result).toBeUndefined();
+  });
+
+  it("'Worker' 문자열이 있지만 new URL 패턴이 아니면 undefined를 반환한다", () => {
+    const result = transformWorkerPatterns(
+      'const w = new Worker("./worker.js");',
+      "/test/entry.js",
+      createMockBuild(),
+    );
+
+    expect(result).toBeUndefined();
+  });
+
+  it("import.meta.url이 아닌 URL 생성은 undefined를 반환한다", () => {
+    const result = transformWorkerPatterns(
+      'const w = new Worker(new URL("./worker.js", location.href));',
+      "/test/entry.js",
+      createMockBuild(),
+    );
+
+    expect(result).toBeUndefined();
+  });
+
+  it("Worker + new URL + import.meta.url 패턴을 감지하여 치환한다", () => {
+    const entryPath = path.join(fixturesDir, "entry.js");
+
+    const result = transformWorkerPatterns(
+      `const w = new Worker(new URL("./worker.js", import.meta.url));`,
+      entryPath,
+      createMockBuild(),
+    );
+
+    expect(result).toBeDefined();
+    expect(result!.contents).not.toContain("./worker.js");
+    expect(result!.contents).toMatch(/worker-[a-z0-9]+\.js/i);
+    expect(result!.errors).toHaveLength(0);
+  });
+
+  it("SharedWorker + new URL + import.meta.url 패턴을 감지하여 치환한다", () => {
+    const entryPath = path.join(fixturesDir, "entry.js");
+
+    const result = transformWorkerPatterns(
+      `const sw = new SharedWorker(new URL("./shared-worker.js", import.meta.url));`,
+      entryPath,
+      createMockBuild(),
+    );
+
+    expect(result).toBeDefined();
+    expect(result!.contents).not.toContain("./shared-worker.js");
+    expect(result!.contents).toMatch(/worker-[a-z0-9]+\.js/i);
+  });
+
+  it("복수 Worker 패턴을 모두 치환한다", () => {
+    const entryPath = path.join(fixturesDir, "entry.js");
+
+    const result = transformWorkerPatterns(
+      [
+        `const w1 = new Worker(new URL("./worker.js", import.meta.url));`,
+        `const w2 = new Worker(new URL("./worker2.js", import.meta.url));`,
+      ].join("\n"),
+      entryPath,
+      createMockBuild(),
+    );
+
+    expect(result).toBeDefined();
+    expect(result!.contents).not.toContain("./worker.js");
+    expect(result!.contents).not.toContain("./worker2.js");
+  });
+});
+
+describe("transformWorkerPatterns — type: module 처리", () => {
+  it("옵션 없는 Worker에 { type: 'module' }을 추가한다", () => {
+    const entryPath = path.join(fixturesDir, "entry.js");
+
+    const result = transformWorkerPatterns(
+      `const w = new Worker(new URL("./worker.js", import.meta.url));`,
+      entryPath,
+      createMockBuild(),
+    );
+
+    expect(result).toBeDefined();
+    // { type: "module" } 추가됨
+    expect(result!.contents).toMatch(/\{\s*type:\s*"module"\s*\}/);
+  });
+
+  it("기존 옵션이 있으면 그대로 유지한다", () => {
+    const entryPath = path.join(fixturesDir, "entry.js");
+
+    const result = transformWorkerPatterns(
+      `const w = new Worker(new URL("./worker.js", import.meta.url), { type: "module" });`,
+      entryPath,
+      createMockBuild(),
+    );
+
+    expect(result).toBeDefined();
+    expect(result!.contents).toContain('{ type: "module" }');
+  });
+});
+
+describe("transformWorkerPatterns — 에러 처리", () => {
+  it("Worker 빌드 에러를 errors에 포함하여 반환한다", () => {
+    const entryPath = path.join(fixturesDir, "entry.js");
+
+    const result = transformWorkerPatterns(
+      `const w = new Worker(new URL("./worker-error.js", import.meta.url));`,
+      entryPath,
+      createMockBuild(),
+    );
+
+    expect(result).toBeDefined();
+    expect(result!.errors.length).toBeGreaterThan(0);
+  });
+});
+
+describe("transformWorkerPatterns — write 옵션", () => {
+  it("write: false일 때 workerOutputFiles를 반환한다", () => {
+    const entryPath = path.join(fixturesDir, "entry.js");
+
+    const result = transformWorkerPatterns(
+      `const w = new Worker(new URL("./worker.js", import.meta.url));`,
+      entryPath,
+      createMockBuild({ write: false }),
+    );
+
+    expect(result).toBeDefined();
+    expect(result!.workerOutputFiles).toBeDefined();
+    expect(result!.workerOutputFiles!.length).toBeGreaterThan(0);
+  });
+
+  it("write: true일 때 workerOutputFiles가 undefined이다", () => {
+    const entryPath = path.join(fixturesDir, "entry.js");
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "worker-write-"));
+
+    const result = transformWorkerPatterns(
+      `const w = new Worker(new URL("./worker.js", import.meta.url));`,
+      entryPath,
+      createMockBuild({ write: true, outdir: tmpDir }),
+    );
+
+    expect(result).toBeDefined();
+    expect(result!.workerOutputFiles).toBeUndefined();
+
+    // 대신 디스크에 파일이 기록됨
+    const files = fs.readdirSync(tmpDir);
+    const workerFile = files.find((f) => /worker-[a-z0-9]+\.js$/i.test(f));
+    expect(workerFile).toBeDefined();
+  });
+});
+
+describe("transformWorkerPatterns — import.meta.resolve 패턴", () => {
+  it("import.meta.resolve 상대 경로 패턴을 감지하여 치환한다", () => {
+    const entryPath = path.join(fixturesDir, "entry.js");
+
+    const result = transformWorkerPatterns(
+      `const p = import.meta.resolve("./node-worker.js");`,
+      entryPath,
+      createMockBuild({ platform: "node" }),
+    );
+
+    expect(result).toBeDefined();
+    expect(result!.contents).not.toContain("./node-worker.js");
+    expect(result!.contents).toMatch(/new URL\("worker-[a-z0-9]+\.js", import\.meta\.url\)\.href/i);
+    expect(result!.errors).toHaveLength(0);
+  });
+
+  it("절대 모듈 경로의 import.meta.resolve는 무시한다", () => {
+    const result = transformWorkerPatterns(
+      `const p = import.meta.resolve("some-package");`,
+      "/test/entry.js",
+      createMockBuild({ platform: "node" }),
+    );
+
+    expect(result).toBeUndefined();
+  });
+
+  it("import.meta.resolve 패턴 없는 파일은 undefined를 반환한다", () => {
+    const result = transformWorkerPatterns(
+      `console.log("no resolve");`,
+      "/test/entry.js",
+      createMockBuild({ platform: "node" }),
+    );
+
+    expect(result).toBeUndefined();
+  });
+
+  it("브라우저 + Node.js Worker 패턴이 공존하면 모두 치환한다", () => {
+    const entryPath = path.join(fixturesDir, "entry.js");
+
+    const result = transformWorkerPatterns(
+      [
+        `const w = new Worker(new URL("./worker.js", import.meta.url));`,
+        `const p = import.meta.resolve("./node-worker.js");`,
+      ].join("\n"),
+      entryPath,
+      createMockBuild({ platform: "node" }),
+    );
+
+    expect(result).toBeDefined();
+    // 브라우저 Worker 치환
+    expect(result!.contents).not.toContain('"./worker.js"');
+    // Node.js resolve 치환
+    expect(result!.contents).not.toContain("import.meta.resolve");
+    expect(result!.contents).toMatch(/new URL\("worker-[a-z0-9]+\.js", import\.meta\.url\)\.href/i);
+  });
+
+  it("import.meta.resolve Worker 빌드 에러를 errors에 포함한다", () => {
+    const entryPath = path.join(fixturesDir, "entry.js");
+
+    const result = transformWorkerPatterns(
+      `const p = import.meta.resolve("./worker-error.js");`,
+      entryPath,
+      createMockBuild({ platform: "node" }),
+    );
+
+    expect(result).toBeDefined();
+    expect(result!.errors.length).toBeGreaterThan(0);
+  });
+
+  it("write: false일 때 workerOutputFiles를 반환한다", () => {
+    const entryPath = path.join(fixturesDir, "entry.js");
+
+    const result = transformWorkerPatterns(
+      `const p = import.meta.resolve("./node-worker.js");`,
+      entryPath,
+      createMockBuild({ write: false, platform: "node" }),
+    );
+
+    expect(result).toBeDefined();
+    expect(result!.workerOutputFiles).toBeDefined();
+    expect(result!.workerOutputFiles!.length).toBeGreaterThan(0);
+  });
+});
+
+describe("createWorkerBundlePlugin — 플러그인 구조", () => {
+  it("esbuild Plugin 프로토콜을 따르는 객체를 반환한다", () => {
+    const plugin = createWorkerBundlePlugin();
+
+    expect(plugin.name).toBe("sd-worker-bundle");
+    expect(typeof plugin.setup).toBe("function");
+  });
+
+  it("setup에서 onLoad/onEnd 훅이 등록된다", async () => {
+    const plugin = createWorkerBundlePlugin();
+
+    let hasOnLoad = false;
+    let hasOnEnd = false;
+
+    const mockBuild = {
+      initialOptions: {},
+      onLoad(_opts: unknown, _cb: unknown) { hasOnLoad = true; },
+      onEnd(_cb: unknown) { hasOnEnd = true; },
+    } as unknown as esbuild.PluginBuild;
+
+    await plugin.setup(mockBuild);
+
+    expect(hasOnLoad).toBe(true);
+    expect(hasOnEnd).toBe(true);
+  });
+});

package/tests/esbuild/esbuild-worker-plugin.verify.md

@@ -0,0 +1,7 @@
+# Worker 빌드 경고가 메인 빌드로 전파됨 — LLM 검증
+
+## 검증 항목
+
+- [x] `transformWorkerPatterns`에서 `workerResult.warnings`를 warnings 배열에 push: `esbuild-worker-plugin.ts:109` — `warnings.push(...workerResult.warnings)` 확인. esbuild.buildSync의 BuildResult.warnings가 그대로 전달됨.
+- [x] 반환 결과의 `warnings` 필드에 수집된 경고가 포함됨: `esbuild-worker-plugin.ts:172` — `warnings` 배열이 결과 객체에 포함됨.
+- [x] 플러그인의 onLoad에서 warnings를 esbuild에 전달: `esbuild-worker-plugin.ts:210` — `warnings: result.warnings.length > 0 ? result.warnings : undefined` — onLoad 결과에 warnings를 포함하여 esbuild가 빌드 경고로 처리.

package/tests/esbuild/fixtures/worker-plugin/node-worker.js

@@ -0,0 +1,2 @@
+const path = require("path");
+process.stdout.write("node-worker:" + path.resolve("."));

package/tests/esbuild/fixtures/worker-plugin/shared-worker.js

@@ -0,0 +1,6 @@
+self.onconnect = (e) => {
+  const port = e.ports[0];
+  port.onmessage = (ev) => {
+    port.postMessage(ev.data);
+  };
+};

package/tests/esbuild/fixtures/worker-plugin/worker-error.js

@@ -0,0 +1 @@
+this is not valid javascript }{][

package/tests/esbuild/fixtures/worker-plugin/worker.js

@@ -0,0 +1,3 @@
+self.onmessage = (e) => {
+  self.postMessage(e.data);
+};

package/tests/esbuild/fixtures/worker-plugin/worker2.js

@@ -0,0 +1,3 @@
+self.onmessage = (e) => {
+  self.postMessage("worker2:" + e.data);
+};

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