@simplysm/sd-cli 14.0.42 → 14.0.43

package/tests/deps/replace-deps/collect-deps.spec.ts

@@ -0,0 +1,49 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { collectDeps } from "../../../src/deps/replace-deps/collect-deps";
+import { pathx } from "@simplysm/core-node";
+
+describe("collectDeps", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = pathx.posix(fs.mkdtempSync(path.join(os.tmpdir(), "sd-cli-test-")));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  function createPkg(relDir: string, name: string, deps: Record<string, string> = {}): void {
+    const dir = pathx.posix(path.join(tmpDir, relDir));
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(
+      pathx.posix(path.join(dir, "package.json")),
+      JSON.stringify({ name, dependencies: deps }),
+    );
+  }
+
+  it("tests/ 패키지만 의존하면 workspaceDeps가 빈 배열이다", () => {
+    createPkg("tests/orm", "@test/orm");
+    createPkg("tests/service", "@test/service");
+    createPkg("packages/my-lib", "@test/my-lib", {
+      "@test/orm": "workspace:*",
+      "@test/service": "workspace:*",
+    });
+
+    const result = collectDeps(pathx.posix(path.join(tmpDir, "packages/my-lib")), tmpDir);
+
+    expect(result.workspaceDeps).toEqual([]);
+  });
+
+  it("의존성이 없는 패키지는 빈 결과를 반환한다", () => {
+    createPkg("packages/my-lib", "@test/my-lib");
+
+    const result = collectDeps(pathx.posix(path.join(tmpDir, "packages/my-lib")), tmpDir);
+
+    expect(result.workspaceDeps).toEqual([]);
+    expect(result.replaceDeps).toEqual([]);
+  });
+});

package/tests/deps/replace-deps/replace-deps-filter.spec.ts

@@ -0,0 +1,103 @@
+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 {
+  createCopyFilter,
+  loadFilesField,
+  NPM_DEFAULT_FILE_PATTERN,
+} from "../../../src/deps/replace-deps/replace-deps";
+
+describe("NPM_DEFAULT_FILE_PATTERN", () => {
+  it("README 변형을 매칭한다", () => {
+    expect(NPM_DEFAULT_FILE_PATTERN.test("README")).toBe(true);
+    expect(NPM_DEFAULT_FILE_PATTERN.test("README.md")).toBe(true);
+    expect(NPM_DEFAULT_FILE_PATTERN.test("readme.txt")).toBe(true);
+  });
+
+  it("LICENSE/LICENCE 변형을 매칭한다", () => {
+    expect(NPM_DEFAULT_FILE_PATTERN.test("LICENSE")).toBe(true);
+    expect(NPM_DEFAULT_FILE_PATTERN.test("LICENCE")).toBe(true);
+    expect(NPM_DEFAULT_FILE_PATTERN.test("license.md")).toBe(true);
+  });
+
+  it("CHANGELOG/HISTORY 변형을 매칭한다", () => {
+    expect(NPM_DEFAULT_FILE_PATTERN.test("CHANGELOG")).toBe(true);
+    expect(NPM_DEFAULT_FILE_PATTERN.test("CHANGELOG.md")).toBe(true);
+    expect(NPM_DEFAULT_FILE_PATTERN.test("HISTORY.md")).toBe(true);
+  });
+
+  it("관련없는 파일명은 매칭하지 않는다", () => {
+    expect(NPM_DEFAULT_FILE_PATTERN.test("tsconfig.json")).toBe(false);
+    expect(NPM_DEFAULT_FILE_PATTERN.test("CLAUDE.md")).toBe(false);
+    expect(NPM_DEFAULT_FILE_PATTERN.test("package.json")).toBe(false);
+  });
+});
+
+describe("createCopyFilter", () => {
+  const sourcePath = "/source/pkg";
+
+  it("allowedNames에 포함된 첫 번째 세그먼트는 허용한다", () => {
+    const filter = createCopyFilter(sourcePath, new Set(["dist", "src"]));
+
+    expect(filter(path.join(sourcePath, "dist"))).toBe(true);
+    expect(filter(path.join(sourcePath, "src"))).toBe(true);
+    expect(filter(path.join(sourcePath, "dist", "index.js"))).toBe(true);
+    expect(filter(path.join(sourcePath, "src", "utils", "helper.ts"))).toBe(true);
+  });
+
+  it("allowedNames에 없는 항목은 거부한다", () => {
+    const filter = createCopyFilter(sourcePath, new Set(["dist", "src"]));
+
+    expect(filter(path.join(sourcePath, "tsconfig.json"))).toBe(false);
+    expect(filter(path.join(sourcePath, "CLAUDE.md"))).toBe(false);
+    expect(filter(path.join(sourcePath, "node_modules"))).toBe(false);
+  });
+
+  it("package.json은 항상 거부한다", () => {
+    const filter = createCopyFilter(sourcePath, new Set(["dist", "src"]));
+
+    expect(filter(path.join(sourcePath, "package.json"))).toBe(false);
+  });
+
+  it("npm 기본 파일 패턴은 allowedNames에 없어도 허용한다", () => {
+    const filter = createCopyFilter(sourcePath, new Set(["dist"]));
+
+    expect(filter(path.join(sourcePath, "README.md"))).toBe(true);
+    expect(filter(path.join(sourcePath, "LICENSE"))).toBe(true);
+    expect(filter(path.join(sourcePath, "CHANGELOG.md"))).toBe(true);
+  });
+});
+
+describe("loadFilesField", () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = pathx.posix(await fs.promises.mkdtemp(path.join(os.tmpdir(), "sd-load-files-")));
+  });
+
+  afterEach(async () => {
+    await fs.promises.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it("files 필드가 있으면 문자열 배열을 반환한다", async () => {
+    await fs.promises.writeFile(
+      pathx.posix(path.join(tmpDir, "package.json")),
+      JSON.stringify({ name: "test", files: ["dist", "src"] }),
+    );
+
+    const result = await loadFilesField(tmpDir);
+    expect(result).toEqual(["dist", "src"]);
+  });
+
+  it("files 필드가 없으면 undefined를 반환한다", async () => {
+    await fs.promises.writeFile(
+      pathx.posix(path.join(tmpDir, "package.json")),
+      JSON.stringify({ name: "test" }),
+    );
+
+    const result = await loadFilesField(tmpDir);
+    expect(result).toBeUndefined();
+  });
+});

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

@@ -0,0 +1,156 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { setupReplaceDeps } from "../../../src/deps/replace-deps/replace-deps";
+import { pathx } from "@simplysm/core-node";
+
+describe("setupReplaceDeps 화이트리스트 복사", () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = pathx.posix(await fs.promises.mkdtemp(path.join(os.tmpdir(), "sd-replace-deps-")));
+
+    // pnpm-workspace.yaml
+    const 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",
+    );
+
+    // 타겟 (node_modules에 기존 패키지)
+    const targetPkgDir = pathx.posix(
+      path.join(projectRoot, "node_modules", "@test", "pkg"),
+    );
+    await fs.promises.mkdir(targetPkgDir, { recursive: true });
+    await fs.promises.writeFile(
+      pathx.posix(path.join(targetPkgDir, "package.json")),
+      JSON.stringify({ name: "@test/pkg", version: "2.0.0" }),
+    );
+  });
+
+  afterEach(async () => {
+    await fs.promises.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  /**
+   * 소스 패키지를 생성하는 헬퍼
+   */
+  async function createSourcePkg(opts: {
+    files?: string[];
+    extraFiles?: Record<string, string>;
+  }): Promise<string> {
+    const sourcePath = pathx.posix(path.join(tmpDir, "source-pkg"));
+    await fs.promises.mkdir(sourcePath, { recursive: true });
+
+    // package.json
+    const pkgJson: Record<string, unknown> = { name: "@test/pkg", version: "1.0.0" };
+    if (opts.files != null) {
+      pkgJson["files"] = opts.files;
+    }
+    await fs.promises.writeFile(
+      pathx.posix(path.join(sourcePath, "package.json")),
+      JSON.stringify(pkgJson),
+    );
+
+    // 기본 디렉토리/파일 생성
+    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 = {};",
+    );
+    await fs.promises.mkdir(pathx.posix(path.join(sourcePath, "src")), { recursive: true });
+    await fs.promises.writeFile(
+      pathx.posix(path.join(sourcePath, "src", "index.ts")),
+      "export const v = 1;",
+    );
+    // files에 없는 파일들
+    await fs.promises.writeFile(
+      pathx.posix(path.join(sourcePath, "tsconfig.json")),
+      "{}",
+    );
+    await fs.promises.writeFile(
+      pathx.posix(path.join(sourcePath, "CLAUDE.md")),
+      "# CLAUDE",
+    );
+
+    // 추가 파일
+    if (opts.extraFiles != null) {
+      for (const [relPath, content] of Object.entries(opts.extraFiles)) {
+        const fullPath = pathx.posix(path.join(sourcePath, relPath));
+        await fs.promises.mkdir(pathx.posix(path.dirname(fullPath)), { recursive: true });
+        await fs.promises.writeFile(fullPath, content);
+      }
+    }
+
+    return sourcePath;
+  }
+
+  it("files에 포함된 디렉토리가 복사되고, files에 없는 파일은 복사되지 않는다", async () => {
+    const sourcePath = await createSourcePkg({ files: ["dist", "src"] });
+    const projectRoot = pathx.posix(path.join(tmpDir, "project"));
+    const targetPkgDir = pathx.posix(
+      path.join(projectRoot, "node_modules", "@test", "pkg"),
+    );
+
+    await setupReplaceDeps(projectRoot, { "@test/pkg": sourcePath });
+
+    // files에 포함된 디렉토리가 복사됨
+    expect(fs.existsSync(pathx.posix(path.join(targetPkgDir, "dist", "index.js")))).toBe(true);
+    expect(fs.existsSync(pathx.posix(path.join(targetPkgDir, "src", "index.ts")))).toBe(true);
+
+    // files에 없는 파일은 복사되지 않음
+    expect(fs.existsSync(pathx.posix(path.join(targetPkgDir, "tsconfig.json")))).toBe(false);
+    expect(fs.existsSync(pathx.posix(path.join(targetPkgDir, "CLAUDE.md")))).toBe(false);
+  });
+
+  it("npm 기본 포함 파일(README, LICENSE)은 files에 없어도 복사된다", async () => {
+    const sourcePath = await createSourcePkg({
+      files: ["dist", "src"],
+      extraFiles: {
+        "README.md": "# README",
+        "LICENSE": "MIT License",
+      },
+    });
+    const projectRoot = pathx.posix(path.join(tmpDir, "project"));
+    const targetPkgDir = pathx.posix(
+      path.join(projectRoot, "node_modules", "@test", "pkg"),
+    );
+
+    await setupReplaceDeps(projectRoot, { "@test/pkg": sourcePath });
+
+    expect(fs.existsSync(pathx.posix(path.join(targetPkgDir, "README.md")))).toBe(true);
+    expect(fs.existsSync(pathx.posix(path.join(targetPkgDir, "LICENSE")))).toBe(true);
+  });
+
+  it("package.json은 복사되지 않고 대상의 기존 package.json이 보존된다", async () => {
+    const sourcePath = await createSourcePkg({ files: ["dist", "src"] });
+    const projectRoot = pathx.posix(path.join(tmpDir, "project"));
+    const targetPkgDir = pathx.posix(
+      path.join(projectRoot, "node_modules", "@test", "pkg"),
+    );
+
+    await setupReplaceDeps(projectRoot, { "@test/pkg": sourcePath });
+
+    // 대상의 기존 package.json이 보존됨 (소스의 것으로 덮어씌워지지 않음)
+    const targetPkgJson = JSON.parse(
+      fs.readFileSync(pathx.posix(path.join(targetPkgDir, "package.json")), "utf-8"),
+    );
+    expect(targetPkgJson.version).toBe("2.0.0");
+  });
+
+  it("files 필드가 없는 패키지는 건너뛰고 복사하지 않는다", async () => {
+    const sourcePath = await createSourcePkg({ files: undefined });
+    const projectRoot = pathx.posix(path.join(tmpDir, "project"));
+    const targetPkgDir = pathx.posix(
+      path.join(projectRoot, "node_modules", "@test", "pkg"),
+    );
+
+    await setupReplaceDeps(projectRoot, { "@test/pkg": sourcePath });
+
+    // 복사가 수행되지 않음
+    expect(fs.existsSync(pathx.posix(path.join(targetPkgDir, "dist")))).toBe(false);
+    expect(fs.existsSync(pathx.posix(path.join(targetPkgDir, "src")))).toBe(false);
+  });
+});

package/tests/electron/electron.spec.ts

@@ -70,7 +70,10 @@ vi.mock("esbuild", () => ({
 const mockLoggerDebug = vi.fn();
 const mockLoggerWarn = vi.fn();
 const mockLoggerInfo = vi.fn();
-vi.spyOn(consola, "withTag").mockReturnValue({ debug: mockLoggerDebug, warn: mockLoggerWarn, info: mockLoggerInfo } as any);
+const mockLoggerStart = vi.fn();
+const mockLoggerSuccess = vi.fn();
+const mockLoggerError = vi.fn();
+vi.spyOn(consola, "withTag").mockReturnValue({ debug: mockLoggerDebug, warn: mockLoggerWarn, info: mockLoggerInfo, start: mockLoggerStart, success: mockLoggerSuccess, error: mockLoggerError } as any);
 
 //#endregion
 

package/tests/engines/engine-adapter-isolation.spec.ts

@@ -49,7 +49,6 @@ describe("NgtscEngine adapter isolation", () => {
 
     const filesToCheck = [
       path.join(sdCliSrc, "engines", "NgtscEngine.ts"),
-      path.join(sdCliSrc, "workers", "ngtsc-build.worker.ts"),
       path.join(sdCliSrc, "angular", "ngtsc-build-core.ts"),
       path.join(sdCliSrc, "utils", "output-path-rewriter.ts"),
     ];
@@ -68,13 +67,13 @@ describe("NgtscEngine adapter isolation", () => {
 
   it("all Angular API access goes through angular-compiler.ts adapter", () => {
 
-    // Angular API 접근은 angular-build-pipeline.ts를 통해 angular-compiler.ts로 이루어진다
-    const buildPipeline = path.resolve(
+    // Angular API 접근은 ngtsc-build-core.ts → angular-compiler.ts 또는 SdTsCompiler → angular-compiler.ts로 이루어진다
+    const compilerFile = path.resolve(
       import.meta.dirname,
-      "../../src/angular/angular-build-pipeline.ts",
+      "../../src/ts-compiler/SdTsCompiler.ts",
     );
-    const content = fs.readFileSync(buildPipeline, "utf-8");
+    const content = fs.readFileSync(compilerFile, "utf-8");
 
-    expect(content).toContain("./angular-compiler");
+    expect(content).toContain("angular-compiler");
   });
 });

package/tests/engines/engine-duplicate-output-removal.verify.md

@@ -0,0 +1,10 @@
+# 엔진별 중복 출력 제거 — LLM 검증
+
+## 검증 항목
+
+- [x] esbuild-client-config.ts logLevel이 모든 모드에서 "silent"인지: `esbuild-client-config.ts:191` — `logLevel: "silent"` 확인. 기존 `isDev ? "warning" : "silent"` 삼항 연산자 제거됨
+- [x] EsbuildClientEngine에 중복 error 핸들러가 없는지: `EsbuildClientEngine.ts:103-110` — setupWatchEvents만 error 이벤트 처리. 기존 `worker.on("error", ...)` 핸들러(logger.error 호출) 제거됨
+- [x] EsbuildClientEngine 초기 빌드 실패 시 logger.error 미호출: `EsbuildClientEngine.ts:129-138` — `!result.success` 분기에서 `resultCollector.add()`만 호출. logger.error 줄 제거됨
+- [x] BaseEngine에 logger.warn() 블록이 없는지: `BaseEngine.ts:166-180` — build 이벤트 핸들러에 lint 결과 보고만 존재. warnings에 대한 logger.warn() 블록 제거됨
+- [x] BaseEngine startWatch 실패 시 logger.debug 사용: `BaseEngine.ts:182-183` — `logger.debug(...)` 확인. 기존 `logger.error(...)` → `logger.debug(...)` 변경됨
+- [x] BaseEngine lint 결과 보고 로직 유지: `BaseEngine.ts:170-179` — `event.lint != null` 조건의 ResultCollector 보고 로직이 그대로 유지됨

package/tests/engines/esbuild-client-engine.acc.spec.ts

@@ -163,6 +163,85 @@ describe("EsbuildClientEngine Acceptance", () => {
     await engine.stop();
   });
 
+  //#region Feature 2.1: 초기 빌드 warnings → ResultCollector
+
+  it("초기 빌드 성공 + warnings → ResultCollector에 success + warnings 저장", async () => {
+    const mockResultCollector = { add: vi.fn() };
+
+    mockWorker.startWatch.mockResolvedValue({
+      success: true,
+      warnings: ["unused variable"],
+    });
+
+    const engine = new EsbuildClientEngine({
+      cwd: "/root",
+      pkg: createMockPkg(),
+      resultCollector: mockResultCollector as any,
+    });
+
+    await engine.startWatch({ js: true, dts: false });
+
+    const warningReport = mockResultCollector.add.mock.calls.find(
+      (c: any[]) => c[0].type === "build" && c[0].warnings != null,
+    );
+    expect(warningReport).toBeDefined();
+    expect(warningReport![0].status).toBe("success");
+    expect(warningReport![0].warnings).toBe("unused variable");
+
+    await engine.stop();
+  });
+
+  it("초기 빌드 실패 + warnings → ResultCollector에 error + warnings 모두 저장", async () => {
+    const mockResultCollector = { add: vi.fn() };
+
+    mockWorker.startWatch.mockResolvedValue({
+      success: false,
+      errors: ["type error"],
+      warnings: ["deprecated API"],
+    });
+
+    const engine = new EsbuildClientEngine({
+      cwd: "/root",
+      pkg: createMockPkg(),
+      resultCollector: mockResultCollector as any,
+    });
+
+    await engine.startWatch({ js: true, dts: false });
+
+    const errorReport = mockResultCollector.add.mock.calls.find(
+      (c: any[]) => c[0].type === "build" && c[0].status === "error",
+    );
+    expect(errorReport).toBeDefined();
+    expect(errorReport![0].message).toContain("type error");
+    expect(errorReport![0].warnings).toBe("deprecated API");
+
+    await engine.stop();
+  });
+
+  it("초기 빌드 성공 + warnings 없음 → ResultCollector에 추가 저장 없음", async () => {
+    const mockResultCollector = { add: vi.fn() };
+
+    mockWorker.startWatch.mockResolvedValue({ success: true });
+
+    const engine = new EsbuildClientEngine({
+      cwd: "/root",
+      pkg: createMockPkg(),
+      resultCollector: mockResultCollector as any,
+    });
+
+    await engine.startWatch({ js: true, dts: false });
+
+    // setupWatchEvents에 의한 호출은 있을 수 있으나, startWatch 결과에 의한 추가 저장은 없음
+    const warningReport = mockResultCollector.add.mock.calls.find(
+      (c: any[]) => c[0].warnings != null,
+    );
+    expect(warningReport).toBeUndefined();
+
+    await engine.stop();
+  });
+
+  //#endregion
+
   // Scenario: 엔진 중지
   it("stop()으로 worker를 종료하고 .dev-port를 삭제한다", async () => {
     // Given: dev watch 모드가 실행 중이다

package/tests/engines/esbuild-client-engine.spec.ts

@@ -271,7 +271,7 @@ describe("EsbuildClientEngine", () => {
       await engine.stop();
     });
 
-    it("초기 빌드 실패 시 에러를 logger.error로 출력한다", async () => {
+    it("초기 빌드 실패 시 reject하지 않고 정상 완료된다", async () => {
       mockWorker.startWatch.mockResolvedValue({
         success: false,
         errors: ["Module not found: @angular/core", "Syntax error in app.ts"],
@@ -280,8 +280,7 @@ describe("EsbuildClientEngine", () => {
       const engine = new EsbuildClientEngine({ cwd: "/root", pkg: createMockPkg() });
       await engine.startWatch({ js: true, dts: false });
 
-      // startWatch가 reject하지 않고 정상 완료되는지 확인 (기존 동작 유지)
-      // 에러 로깅은 verify.md에서 검증
+      // startWatch가 reject하지 않고 정상 완료되는지 확인
       expect(mockWorker.startWatch).toHaveBeenCalled();
 
       await engine.stop();
@@ -297,6 +296,77 @@ describe("EsbuildClientEngine", () => {
       await engine.stop();
     });
 
+    it("초기 빌드 ��공 + warnings 시 ResultCollector에 success와 warnings가 저장된다", async () => {
+      const mockResultCollector = { add: vi.fn(), get: vi.fn(), toMap: vi.fn() };
+      mockWorker.startWatch.mockResolvedValue({ success: true, warnings: ["w1", "w2"] });
+
+      const engine = new EsbuildClientEngine({
+        cwd: "/root",
+        pkg: createMockPkg(),
+        resultCollector: mockResultCollector as any,
+      });
+      await engine.startWatch({ js: true, dts: false });
+
+      const addCall = mockResultCollector.add.mock.calls.find(
+        (c: any[]) => c[0].warnings != null,
+      );
+      expect(addCall).toBeDefined();
+      expect(addCall![0]).toMatchObject({
+        status: "success",
+        warnings: "w1\nw2",
+      });
+
+      await engine.stop();
+    });
+
+    it("초기 빌드 실패 + warnings 시 ResultCollector에 에러와 경고 모두 저장된다", async () => {
+      const mockResultCollector = { add: vi.fn(), get: vi.fn(), toMap: vi.fn() };
+      mockWorker.startWatch.mockResolvedValue({
+        success: false,
+        errors: ["e1"],
+        warnings: ["w1"],
+      });
+
+      const engine = new EsbuildClientEngine({
+        cwd: "/root",
+        pkg: createMockPkg(),
+        resultCollector: mockResultCollector as any,
+      });
+      await engine.startWatch({ js: true, dts: false });
+
+      const errorResult = mockResultCollector.add.mock.calls.find(
+        (c: any[]) => c[0].status === "error",
+      );
+      expect(errorResult).toBeDefined();
+      expect(errorResult![0]).toMatchObject({
+        status: "error",
+        message: "e1",
+        warnings: "w1",
+      });
+
+      await engine.stop();
+    });
+
+    it("초기 빌드 성공 + warnings 없음 시 ResultCollector에 추가 저장하지 않는다", async () => {
+      const mockResultCollector = { add: vi.fn(), get: vi.fn(), toMap: vi.fn() };
+      mockWorker.startWatch.mockResolvedValue({ success: true });
+
+      const engine = new EsbuildClientEngine({
+        cwd: "/root",
+        pkg: createMockPkg(),
+        resultCollector: mockResultCollector as any,
+      });
+      await engine.startWatch({ js: true, dts: false });
+
+      // setupWatchEvents에 의한 add 호출만 있고, 초기 빌드 경로의 add 호출은 없어야 한다
+      const directAdd = mockResultCollector.add.mock.calls.find(
+        (c: any[]) => c[0].target === "client" && (c[0].message != null || c[0].warnings != null),
+      );
+      expect(directAdd).toBeUndefined();
+
+      await engine.stop();
+    });
+
     it("scopeRebuild 이벤트를 구독하지 않는다", async () => {
       mockWorker.startWatch.mockResolvedValue({ success: true });
 

package/tests/esbuild/esbuild-angular-compiler-plugin-hmr.verify.md

@@ -0,0 +1,23 @@
+# esbuild Angular Compiler Plugin — 증분 빌드 + HMR — LLM 검증
+
+## 검증 항목
+
+- [x] **증분 빌드 조건 판단**: `esbuild-angular-compiler-plugin.ts:200` — `angularCompiler != null && sourceFileCache != null && sourceFileCache.modifiedFiles.size > 0`으로 증분 빌드 감지. 첫 빌드는 `angularCompiler == null` 경로로 진입.
+
+- [x] **staleSourceFiles 캡처 타이밍**: `esbuild-angular-compiler-plugin.ts:208-219` — `invalidate()` 호출 전에 이전 `ts.Program`에서 stale source files를 캡처. `invalidate` 후에는 캐시에서 삭제되므로 순서가 중요.
+
+- [x] **FileReferenceTracker.update → sourceFileCache.invalidate**: `esbuild-angular-compiler-plugin.ts:221-224` — `referencedFileTracker.update()`로 전이적 의존성 확장 후 `invalidate()` 호출. 확장된 파일 집합이 전달됨.
+
+- [x] **stale additionalResults 제거**: `esbuild-angular-compiler-plugin.ts:226-229` — expandedModifiedFiles의 각 파일에 대해 `additionalResults.delete()` 호출.
+
+- [x] **HMR 활성화 조건**: `esbuild-angular-compiler-plugin.ts:204-206` — `templateUpdates != null && modifiedFiles.size <= 32`. 32개 초과 시 HMR 건너뜀.
+
+- [x] **collectHmrCandidates 호출**: `esbuild-angular-compiler-plugin.ts:235-239` — `ngtscProgram`과 `staleSourceFiles`를 전달. `sourceFileCache.modifiedFiles`(확장 전 원본)을 대상으로 분석.
+
+- [x] **emitHmrUpdateModule 호출 및 null 처리**: `esbuild-angular-compiler-plugin.ts:259-264` — `emitHmrUpdateModule`이 null/undefined 반환 시 break (templateUpdates 전파 중단). NgCompiler API를 Record 캐스팅으로 접근 (타입이 private이므로).
+
+- [x] **templateUpdates Map 전파**: `esbuild-angular-compiler-plugin.ts:266` — `pluginOptions.templateUpdates!.set(updateId, updateText)`로 외부 Map에 직접 기록.
+
+- [x] **updateId 형식**: `esbuild-angular-compiler-plugin.ts:256-258` — `encodeURIComponent("{relativePath}@{className}")`. relativePath는 hostDir 기준 상대경로, 백슬래시를 슬래시로 변환.
+
+- [x] **hmr-candidates.ts 구조**: `hmr-candidates.ts` — `collectHmrCandidates` 함수가 원본 `hmr-candidates.js`의 로직을 TypeScript로 이식. `analyzeFileUpdates`, `analyzeMetaUpdates`, `equalRangeText` 헬퍼 포함. SUPPORTED_FIELD_NAMES = {template, templateUrl, styles, styleUrl, stylesUrl}.

package/tests/esbuild/esbuild-angular-compiler-plugin-onload.verify.md

@@ -0,0 +1,21 @@
+# onLoad 훅 — LLM 검증
+
+## 검증 항목
+
+- [x] TS onLoad 훅이 `/\.[cm]?[jt]sx?$/` 필터로 등록된다: :517 `build.onLoad({ filter: /\.[cm]?[jt]sx?$/ }, ...)`
+- [x] JS onLoad 훅이 `/\.[cm]?js$/` 필터로 등록된다: :584 `build.onLoad({ filter: /\.[cm]?js$/ }, ...)`
+- [x] TS onLoad: shouldTsIgnoreJs=true이고 JS 파일이면 undefined 반환: :522 `if (shouldTsIgnoreJs && isJS) return undefined`
+- [x] TS onLoad: 캐시 미스 + hasCompilationErrors이면 `{ contents: '', loader: 'js' }` 반환: :530
+- [x] TS onLoad: 캐시 미스 + allowJs + JS이면 undefined 반환: :535
+- [x] TS onLoad: 캐시 미스 + Angular 데코레이터 없으면 warning 반환: :541-547
+- [x] TS onLoad: 캐시 미스 + Angular 데코레이터 있으면 error 반환: :550-552
+- [x] TS onLoad: string 캐시 + (useTypeScriptTranspilation || isJS)이면 transformData 호출 → Uint8Array 재캐싱: :556-565
+- [x] TS onLoad: Uint8Array 캐시이면 재변환 없이 그대로 반환: :556 조건 `typeof contents === "string"` — Uint8Array는 조건 불일치로 통과
+- [x] TS onLoad: loader 결정 — (useTypeScriptTranspilation || isJS) → 'js', .tsx → 'tsx', 기타 → 'ts': :569-574
+- [x] JS onLoad: createCachedLoad(loadResultCache, callback)으로 래핑: :586
+- [x] JS onLoad: transformFile(request, false, sideEffects) 호출: :589
+- [x] hasSideEffects: advancedOptimizations=false → undefined 반환: :292-293
+- [x] hasSideEffects: advancedOptimizations=true → build.resolve() 호출: :295-298
+- [x] shouldTsIgnoreJs: onStart에서 !compilerOptions.allowJs로 결정: :405
+- [x] useTypeScriptTranspilation: !isolatedModules || !!sourceMap || !!inlineSourceMap으로 결정: :406-407
+- [x] loadResultCache 옵션이 AngularCompilerPluginOptions에 추가됨: :33

package/tests/esbuild/esbuild-angular-compiler-plugin-onstart-extraction.verify.md

@@ -0,0 +1,16 @@
+# onStart 서브함수 추출 — LLM 검증
+
+## 검증 항목
+
+- [x] **handleIncrementalBuild 클로저 변수 접근**: `pluginOptions.sourceFileCache!` (314줄), `pluginOptions.templateUpdates` (316줄), `angularCompiler!` (322, 342, 345, 353줄), `referencedFileTracker` (332줄), `additionalResults` (339줄), `cwd` (359줄) — 모두 setup 스코프(248-289줄)에서 선언된 변수를 파라미터 없이 직접 접근. 원본에서 `errors`/`warnings`를 사용하지 않아 파라미터 불필요 (lint 에러로 확인, 제거)
+- [x] **handleFirstBuild 클로저 변수 접근**: `pluginOptions` (378, 387-390줄), `preserveSymlinks` (381줄), `angularCompiler` (394줄 대입), `shouldTsIgnoreJs` (398줄 대입), `useTypeScriptTranspilation` (399줄 대입) — 모두 setup 스코프 변수 직접 접근. 파라미터 없음
+- [x] **createWebWorkerProcessor 클로저 변수 접근**: `build` (410줄), `pluginOptions.sourcemap` (410줄), `cwd` (422, 437줄), `referencedFileTracker` (417, 435줄), `additionalResults` (424, 428줄) — 모두 setup 스코프 변수 직접 접근. `errors`/`warnings`만 파라미터로 전달
+- [x] **onStart 반환값 동일**: onStart 콜백(456-526줄)이 동일한 `result` 객체를 반환 (`errors`/`warnings` 할당 로직 523-525줄 유지). 추출 전과 동일한 `{errors, warnings}` 구조
+- [x] **내부 상태 변화 동일**: `handleIncrementalBuild`에서 `sourceFileCache.invalidate()` (328줄), `additionalResults.delete()` (332줄), `angularCompiler.update()` (335줄), `templateUpdates.set()/clear()` (366, 370줄) — 원본 코드(316-383줄)와 동일한 mutation 순서와 로직
+- [x] **handleFirstBuild 상태 설정**: `angularCompiler = compiler` (394줄), `shouldTsIgnoreJs = !co.allowJs` (398줄), `useTypeScriptTranspilation` (399-400줄) — 원본 코드(384-409줄)와 동일
+- [x] **HMR 실패 시 templateUpdates 초기화**: `updateText === null || updateText === undefined` 조건(364줄) → `pluginOptions.templateUpdates!.clear()` (366줄) + `break` (367줄) — 원본과 동일
+- [x] **Worker 빌드 성공 경로**: `additionalResults.set(fullWorkerPath, {outputFiles, metafile})` (428-431줄) → `workerCodeFile` 찾기 (442-444줄) → 상대 경로 반환 (450-451줄) — 원본과 동일
+- [x] **Worker 빌드 실패 경로**: `errors.push(...workerResult.errors)` (415줄) → `referencedFileTracker.add()` (417-423줄) → `additionalResults.set()` (424줄) → `return workerFile` (425줄) — 원본과 동일
+- [x] **onStart 오케스트레이션 축소**: onStart 콜백이 456-526줄 = ~70줄로 축소됨. 구성: stylesheetErrors 리셋(4줄) + 분기 호출(5줄) + processWebWorker 생성(1줄) + emit(5줄) + diagnostics(8줄) + stylesheet 브릿징(12줄) + 에러 핸들링(13줄) + 결과 반환(3줄)
+- [x] **onLoad/onEnd/onDispose 미변경**: 528줄 이후의 onLoad(528-593줄), onEnd(615-625줄), onDispose(628-632줄) 핸들러가 변경되지 않음
+- [x] **기존 테스트 26개 통과**: vitest run 실행 결과 26 passed, 0 failed

package/tests/esbuild/esbuild-angular-compiler-plugin-sdtscompiler.verify.md

@@ -0,0 +1,15 @@
+# esbuild-angular-compiler-plugin SdTsCompiler 전환 — LLM 검증
+
+## 검증 항목
+
+- [x] SdTsCompiler 인스턴스 생성: `:402-414` — `new SdTsCompiler({ pkgDir: path.dirname(pluginOptions.tsconfig), cwd, output: { js: true, dts: false }, sourceFileCache, transformStylesheet, externalStylesheets, compilerOptionsTransformer })` 올바르게 구성
+- [x] compileAsync 호출: `:422-425` — 첫 빌드 시 `compileAsync(undefined, { additionalTransformers })`, 증분 빌드 시 `compileAsync(expandedModifiedFiles, { additionalTransformers })`
+- [x] emitResults → typeScriptFileCache 매핑: `:428-430` — `compileResult.emitResults`를 순회하여 `path.normalize(sourceFileName)` 키로 저장
+- [x] diagnostics 변환: `:441-448` — `convertSerializedDiagnosticToEsbuild(d, compileResult.program, cwd)` 사용, `d.category` 기반 분류
+- [x] HMR staleSourceFiles 캡처: `:380-388` — `lastResult.program.getSourceFile(modifiedFile)` 사용, compileAsync 전에 수행
+- [x] HMR collectHmrCandidates: `:468-471` — `compileResult.ngtscProgram` 사용, staleSourceFiles 전달
+- [x] SCSS bridging: `:451-462` — `pluginOptions.stylesheetDependencies`/`stylesheetErrors` 직접 읽기 (plugin-owned maps)
+- [x] parseTsconfigFile 함수 제거 확인: 파일 전체에서 `parseTsconfigFile` 미발견
+- [x] AngularCompiler import 제거 확인: `:7` — `import type { AngularSourceFileCache }` (type import만 유지)
+- [x] onDispose에서 참조 해제: `sdTsCompiler = undefined; lastResult = undefined;` 확인
+- [x] onLoad 플래그 결정: `:432-438` — `lastResult == null` 조건으로 첫 빌드에서만 결정

package/tests/esbuild/esbuild-angular-compiler-plugin-stylesheet.verify.md

@@ -0,0 +1,31 @@
+# Feature 2.1 컴포넌트 스타일시트 번들링 — LLM 검증
+
+## 검증 항목
+
+### AngularCompilerPluginOptions 인터페이스 확장
+
+- [x] `stylesheetDependencies?: Map<string, Set<string>>` 필드 존재: `esbuild-angular-compiler-plugin.ts:42` — `Map<string, Set<string>>` 타입으로 선언됨. `createClientTransformStylesheet`의 `scssDependencies` 타입과 일치
+- [x] `stylesheetErrors?: string[]` 필드 존재: `esbuild-angular-compiler-plugin.ts:44` — `string[]` 타입으로 선언됨. `createClientTransformStylesheet`의 `scssErrors` 타입과 일치
+
+### onStart — stylesheetErrors 리셋
+
+- [x] 리셋 코드가 try 블록 **앞**에 위치: `esbuild-angular-compiler-plugin.ts:204-207` — `if (pluginOptions.stylesheetErrors != null) { pluginOptions.stylesheetErrors.length = 0; }` 가 `try {` (`:209`) 이전에 위치. 컴파일 실패 시에도 리셋이 보장됨
+- [x] null guard 존재: `pluginOptions.stylesheetErrors != null` 체크로 미제공 시 TypeError 방지
+
+### onStart — stylesheetDependencies → FileReferenceTracker 브릿징
+
+- [x] 브릿징 코드가 emit 후, additionalResults 수집 전에 위치: `esbuild-angular-compiler-plugin.ts:315-320` — `emitAffectedFiles` 루프(`:300-303`)와 `diagnostics 수집`(`:305-313`) 후, `additionalResults 에러 수집`(`:322`) 전에 위치
+- [x] `referencedFileTracker.add(containingFile, deps)` 호출: `:318` — Map의 각 엔트리에 대해 `referencedFileTracker.add(containingFile, deps)` 호출. `FileReferenceTracker.add()` 시그니처(`file-reference-tracker.ts:22`)와 일치
+- [x] null guard 존재: `:316` — `pluginOptions.stylesheetDependencies != null` 체크
+
+### onStart — stylesheetErrors → esbuild errors 변환
+
+- [x] 변환 코드가 additionalResults 에러 수집 후에 위치: `esbuild-angular-compiler-plugin.ts:329-334` — `additionalResults` 루프(`:322-327`) 후에 위치
+- [x] `{ text: errText, location: null }` 형식으로 push: `:332` — `errors.push({ text: errText, location: null })`. esbuild `PartialMessage` 형식에 부합
+- [x] null guard 존재: `:330` — `pluginOptions.stylesheetErrors != null` 체크
+- [x] 빈 배열 시 push 없음: `for...of` 루프이므로 빈 배열일 때 자연스럽게 0회 실행
+
+### 증분 빌드 전이적 재컴파일 경로
+
+- [x] `referencedFileTracker.update(sourceFileCache.modifiedFiles)` 호출: `:231-233` — 증분 빌드 경로에서 `referencedFileTracker.update()`가 호출됨. Feature 2.1에서 등록한 SCSS 의존성이 여기서 전이적으로 확장됨
+- [x] 확장된 파일이 `sourceFileCache.invalidate()`에 전달됨: `:234` — `sourceFileCache.invalidate(expandedModifiedFiles)`. SCSS 의존성 파일 변경 시 해당 스타일시트 파일도 무효화되어 Angular compiler가 컴포넌트를 재컴파일