@simplysm/sd-cli 14.0.42 → 14.0.44

package/tests/esbuild/esbuild-angular-compiler-plugin.spec.ts

@@ -0,0 +1,397 @@
+import { describe, it, expect } from "vitest";
+import path from "path";
+import type esbuild from "esbuild";
+import ts from "typescript";
+
+// 자동 테스트 가능한 순수 함수들을 테스트한다.
+// Angular 프로젝트 의존 항목은 LLM 검증(.verify.md)으로 분리.
+
+const {
+  createAngularCompilerPlugin,
+  createCompilerOptionsTransformer,
+  convertDiagnostic,
+  convertSerializedDiagnosticToEsbuild,
+  requiresAngularCompiler,
+  createMissingFileDiagnostic,
+} = await import("../../src/esbuild/esbuild-angular-compiler-plugin.js");
+
+//#region esbuild Plugin 시뮬레이션 헬퍼
+
+function setupPlugin(plugin: esbuild.Plugin) {
+  let onStartCb: (() => esbuild.OnStartResult | null | void | Promise<esbuild.OnStartResult | null | void>) | undefined;
+  let onEndCb: ((result: esbuild.BuildResult) => void | Promise<void>) | undefined;
+  let onDisposeCb: (() => void) | undefined;
+
+  const initialOptions: esbuild.BuildOptions = {
+    define: {},
+    absWorkingDir: "/workspace",
+  };
+
+  const mockBuild = {
+    initialOptions,
+    onStart(cb: typeof onStartCb) { onStartCb = cb; },
+    onEnd(cb: typeof onEndCb) { onEndCb = cb; },
+    onLoad() { /* noop — Feature 1.2 onLoad 훅 등록을 수용 */ },
+    onDispose(cb: typeof onDisposeCb) { onDisposeCb = cb; },
+  } as unknown as esbuild.PluginBuild;
+
+  void plugin.setup(mockBuild);
+
+  return {
+    initialOptions,
+    async invokeOnStart() { return (await onStartCb?.()) ?? null; },
+    async invokeOnEnd(result: Partial<esbuild.BuildResult>) {
+      await onEndCb?.({
+        errors: [],
+        warnings: [],
+        mangleCache: {},
+        outputFiles: [],
+        metafile: { inputs: {}, outputs: {} },
+        ...result,
+      } as esbuild.BuildResult);
+    },
+    invokeOnDispose() { onDisposeCb?.(); },
+    get onStartCb() { return onStartCb; },
+    get onEndCb() { return onEndCb; },
+    get onDisposeCb() { return onDisposeCb; },
+  };
+}
+
+//#endregion
+
+describe("createAngularCompilerPlugin — Plugin 구조", () => {
+  it("esbuild Plugin 프로토콜을 따르는 객체를 반환한다", () => {
+    const plugin = createAngularCompilerPlugin({
+      tsconfig: "/workspace/tsconfig.json",
+      sourcemap: false,
+      advancedOptimizations: false,
+      thirdPartySourcemaps: false,
+      incremental: false,
+    });
+
+    expect(plugin.name).toBe("sd-angular-compiler");
+    expect(typeof plugin.setup).toBe("function");
+  });
+
+  it("setup에서 onStart/onEnd/onDispose 훅이 등록된다", () => {
+    const plugin = createAngularCompilerPlugin({
+      tsconfig: "/workspace/tsconfig.json",
+      sourcemap: false,
+      advancedOptimizations: false,
+      thirdPartySourcemaps: false,
+      incremental: false,
+    });
+
+    const ctx = setupPlugin(plugin);
+    expect(ctx.onStartCb).toBeDefined();
+    expect(ctx.onEndCb).toBeDefined();
+    expect(ctx.onDisposeCb).toBeDefined();
+  });
+
+  it("setup에서 ngI18nClosureMode define이 주입된다", () => {
+    const plugin = createAngularCompilerPlugin({
+      tsconfig: "/workspace/tsconfig.json",
+      sourcemap: false,
+      advancedOptimizations: false,
+      thirdPartySourcemaps: false,
+      incremental: false,
+    });
+
+    const ctx = setupPlugin(plugin);
+    expect(ctx.initialOptions.define!["ngI18nClosureMode"]).toBe("false");
+  });
+});
+
+describe("createCompilerOptionsTransformer", () => {
+  const baseCompilerOptions: ts.CompilerOptions = {
+    target: ts.ScriptTarget.ES2015,
+    module: ts.ModuleKind.CommonJS,
+    strict: true,
+  };
+
+  it("target을 ES2022로, module을 ES2022로 설정한다", () => {
+    const transform = createCompilerOptionsTransformer(
+      { tsconfig: "", sourcemap: false, advancedOptimizations: false, thirdPartySourcemaps: false, incremental: false },
+      undefined,
+    );
+
+    const result = transform(baseCompilerOptions);
+    expect(result.target).toBe(ts.ScriptTarget.ES2022);
+    expect(result.module).toBe(ts.ModuleKind.ES2022);
+  });
+
+  it("noEmitOnError: false, composite: false를 설정한다", () => {
+    const transform = createCompilerOptionsTransformer(
+      { tsconfig: "", sourcemap: false, advancedOptimizations: false, thirdPartySourcemaps: false, incremental: false },
+      undefined,
+    );
+
+    const result = transform(baseCompilerOptions);
+    expect(result.noEmitOnError).toBe(false);
+    expect(result.composite).toBe(false);
+  });
+
+  it("sourcemap: true일 때 inlineSources/inlineSourceMap을 설정한다", () => {
+    const transform = createCompilerOptionsTransformer(
+      { tsconfig: "", sourcemap: true, advancedOptimizations: false, thirdPartySourcemaps: false, incremental: false },
+      undefined,
+    );
+
+    const result = transform(baseCompilerOptions);
+    expect(result.inlineSources).toBe(true);
+    expect(result.inlineSourceMap).toBe(true);
+    expect(result.sourceMap).toBeUndefined();
+  });
+
+  it("templateUpdates 제공 시 _enableHmr: true를 설정한다", () => {
+    const transform = createCompilerOptionsTransformer(
+      { tsconfig: "", sourcemap: false, advancedOptimizations: false, thirdPartySourcemaps: false, incremental: false, templateUpdates: new Map() },
+      undefined,
+    );
+
+    const result = transform(baseCompilerOptions);
+    expect((result as Record<string, unknown>)["_enableHmr"]).toBe(true);
+  });
+
+  it("includeTestMetadata: true일 때 supportTestBed/supportJitMode: true를 설정한다", () => {
+    const transform = createCompilerOptionsTransformer(
+      { tsconfig: "", sourcemap: false, advancedOptimizations: false, thirdPartySourcemaps: false, incremental: false, includeTestMetadata: true },
+      undefined,
+    );
+
+    const result = transform(baseCompilerOptions);
+    expect((result as Record<string, unknown>)["supportTestBed"]).toBe(true);
+    expect((result as Record<string, unknown>)["supportJitMode"]).toBe(true);
+  });
+
+  it("useDefineForClassFields가 미설정이면 false로 기본 설정한다", () => {
+    const transform = createCompilerOptionsTransformer(
+      { tsconfig: "", sourcemap: false, advancedOptimizations: false, thirdPartySourcemaps: false, incremental: false },
+      undefined,
+    );
+
+    const result = transform(baseCompilerOptions);
+    expect(result.useDefineForClassFields).toBe(false);
+  });
+
+  it("persistentCachePath 제공 시 incremental: true, tsBuildInfoFile 설정한다", () => {
+    const transform = createCompilerOptionsTransformer(
+      { tsconfig: "", sourcemap: false, advancedOptimizations: false, thirdPartySourcemaps: false, incremental: false, persistentCachePath: "/cache" },
+      undefined,
+    );
+
+    const result = transform(baseCompilerOptions);
+    expect(result.incremental).toBe(true);
+    expect(result.tsBuildInfoFile).toContain(".tsbuildinfo");
+  });
+});
+
+describe("stylesheetErrors / stylesheetDependencies 브릿징", () => {
+  it("onStart 시작 시 stylesheetErrors를 리셋한다", async () => {
+    const stylesheetErrors = ["SCSS error in style.scss: undefined variable", "SCSS error in other.scss: missing import"];
+
+    const plugin = createAngularCompilerPlugin({
+      tsconfig: "/nonexistent/tsconfig.json",
+      sourcemap: false,
+      advancedOptimizations: false,
+      thirdPartySourcemaps: false,
+      incremental: false,
+      stylesheetErrors,
+    });
+
+    const ctx = setupPlugin(plugin);
+
+    // onStart는 tsconfig 파싱 실패로 에러를 반환하지만, 그 전에 stylesheetErrors가 리셋되어야 한다
+    await ctx.invokeOnStart();
+
+    expect(stylesheetErrors).toHaveLength(0);
+  });
+
+  it("stylesheetErrors 미제공 시 onStart가 에러 없이 진행된다", async () => {
+    const plugin = createAngularCompilerPlugin({
+      tsconfig: "/nonexistent/tsconfig.json",
+      sourcemap: false,
+      advancedOptimizations: false,
+      thirdPartySourcemaps: false,
+      incremental: false,
+      // stylesheetErrors 미제공
+    });
+
+    const ctx = setupPlugin(plugin);
+
+    // TypeError 없이 정상 진행 (컴파일 에러는 발생하지만 stylesheetErrors 관련 에러는 없음)
+    const result = await ctx.invokeOnStart();
+    // 컴파일 실패 에러만 포함되어야 함
+    expect(result?.errors?.every((e) => !(e.text ?? "").includes("SCSS"))).toBe(true);
+  });
+});
+
+describe("convertDiagnostic", () => {
+  it("에러 진단을 esbuild PartialMessage로 변환한다", () => {
+    const sourceFile = ts.createSourceFile("app.ts", "const x: number = 'str';", ts.ScriptTarget.ES2022, true);
+    const diagnostic: ts.Diagnostic = {
+      file: sourceFile,
+      start: 0,
+      length: 5,
+      messageText: "Type 'string' is not assignable to type 'number'.",
+      category: ts.DiagnosticCategory.Error,
+      code: 2322,
+    };
+
+    const result = convertDiagnostic(diagnostic, "/workspace");
+
+    expect(result.text).toContain("Type 'string' is not assignable");
+    expect(result.location).not.toBeNull();
+    expect(result.location?.line).toBe(1);
+  });
+
+  it("파일 정보 없는 진단은 location: null을 반환한다", () => {
+    const diagnostic: ts.Diagnostic = {
+      file: undefined,
+      start: undefined,
+      length: undefined,
+      messageText: "Option error",
+      category: ts.DiagnosticCategory.Error,
+      code: 5000,
+    };
+
+    const result = convertDiagnostic(diagnostic, "/workspace");
+
+    expect(result.text).toBe("Option error");
+    expect(result.location).toBeNull();
+  });
+});
+
+describe("convertSerializedDiagnosticToEsbuild", () => {
+  it("파일 위치가 있는 진단을 line/column 포함 PartialMessage로 변환한다", () => {
+    const sourceFile = ts.createSourceFile(
+      "/workspace/src/app.ts",
+      "const x: number = 'str';",
+      ts.ScriptTarget.ES2022,
+      true,
+    );
+    // 간이 Program 생성 (getSourceFile 조회용)
+    const program = {
+      getSourceFile: (fileName: string) =>
+        fileName === "/workspace/src/app.ts" ? sourceFile : undefined,
+    } as unknown as ts.Program;
+
+    const serialized = {
+      category: ts.DiagnosticCategory.Error,
+      code: 2322,
+      messageText: "Type 'string' is not assignable to type 'number'.",
+      file: { fileName: "/workspace/src/app.ts" },
+      start: 0,
+      length: 5,
+    };
+
+    const result = convertSerializedDiagnosticToEsbuild(serialized, program, "/workspace");
+
+    expect(result.text).toContain("Type 'string' is not assignable");
+    expect(result.location).not.toBeNull();
+    expect(result.location?.file).toBe(path.relative("/workspace", "/workspace/src/app.ts"));
+    expect(result.location?.line).toBe(1);
+    expect(result.location?.column).toBe(0);
+  });
+
+  it("파일 정보 없는 진단은 location: null을 반환한다", () => {
+    const program = {
+      getSourceFile: () => undefined,
+    } as unknown as ts.Program;
+
+    const serialized = {
+      category: ts.DiagnosticCategory.Error,
+      code: 5000,
+      messageText: "Option error",
+    };
+
+    const result = convertSerializedDiagnosticToEsbuild(serialized, program, "/workspace");
+
+    expect(result.text).toBe("Option error");
+    expect(result.location).toBeNull();
+  });
+
+  it("program에서 소스 파일을 찾을 수 없으면 location: null을 반환한다", () => {
+    const program = {
+      getSourceFile: () => undefined,
+    } as unknown as ts.Program;
+
+    const serialized = {
+      category: ts.DiagnosticCategory.Warning,
+      code: 1234,
+      messageText: "Some warning",
+      file: { fileName: "/workspace/src/missing.ts" },
+      start: 10,
+    };
+
+    const result = convertSerializedDiagnosticToEsbuild(serialized, program, "/workspace");
+
+    expect(result.text).toBe("Some warning");
+    expect(result.location).toBeNull();
+  });
+});
+
+describe("requiresAngularCompiler", () => {
+  it("@Component 포함 시 true를 반환한다", () => {
+    expect(requiresAngularCompiler("import { Component } from '@angular/core'; @Component({})")).toBe(true);
+  });
+
+  it("@Directive 포함 시 true를 반환한다", () => {
+    expect(requiresAngularCompiler("@Directive({})")).toBe(true);
+  });
+
+  it("@Injectable 포함 시 true를 반환한다", () => {
+    expect(requiresAngularCompiler("@Injectable()")).toBe(true);
+  });
+
+  it("@Pipe 포함 시 true를 반환한다", () => {
+    expect(requiresAngularCompiler("@Pipe({ name: 'x' })")).toBe(true);
+  });
+
+  it("@NgModule 포함 시 true를 반환한다", () => {
+    expect(requiresAngularCompiler("@NgModule({})")).toBe(true);
+  });
+
+  it("@angular/core import만 있어도 true를 반환한다", () => {
+    expect(requiresAngularCompiler("import { inject } from '@angular/core';")).toBe(true);
+  });
+
+  it("Angular 관련 코드가 없으면 false를 반환한다", () => {
+    expect(requiresAngularCompiler("export function helper() { return 42; }")).toBe(false);
+  });
+
+  it("빈 문자열에 대해 false를 반환한다", () => {
+    expect(requiresAngularCompiler("")).toBe(false);
+  });
+});
+
+describe("createMissingFileDiagnostic", () => {
+  it("Angular 파일이면 TypeScript compilation 에러 메시지를 생성한다", () => {
+    const result = createMissingFileDiagnostic("/workspace/comp.ts", "/workspace/comp.ts", "/workspace", true);
+
+    expect(result.text).toContain("comp.ts");
+    expect(result.text).toContain("not found in TypeScript compilation");
+    expect(result.notes?.[0]?.text).toContain("Angular metadata");
+  });
+
+  it("Angular 파일이 아니면 번들링 경고 메시지를 생성한다", () => {
+    const result = createMissingFileDiagnostic("/workspace/helper.ts", "/workspace/helper.ts", "/workspace", false);
+
+    expect(result.text).toContain("helper.ts");
+    expect(result.notes?.[0]?.text).toContain("bundled and included in the output");
+  });
+
+  it("request와 original이 다르면 file replacement 노트를 추가한다", () => {
+    const result = createMissingFileDiagnostic("/workspace/replaced.ts", "/workspace/original.ts", "/workspace", false);
+
+    expect(result.notes?.length).toBe(2);
+    expect(result.notes?.[1]?.text).toContain("file replacement");
+    expect(result.notes?.[1]?.text).toContain("original.ts");
+  });
+
+  it("request와 original이 같으면 file replacement 노트가 없다", () => {
+    const result = createMissingFileDiagnostic("/workspace/same.ts", "/workspace/same.ts", "/workspace", true);
+
+    expect(result.notes?.length).toBe(1);
+  });
+});

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

@@ -0,0 +1,21 @@
+# esbuild Angular Compiler Plugin — LLM 검증
+
+## 검증 항목
+
+- [x] **JavaScriptTransformer 초기화**: `esbuild-angular-compiler-plugin.ts:170-181` — `@angular/build/private`에서 import한 `JavaScriptTransformer`를 `{ sourcemap, thirdPartySourcemaps, advancedOptimizations, jit }` 옵션과 `maxWorkers`, `cacheStore?.createCache("jstransformer")`로 초기화. jit은 `includeTestMetadata`에 매핑됨.
+
+- [x] **AngularCompiler 생성 시 transformStylesheet 콜백 전달**: `esbuild-angular-compiler-plugin.ts:222-229` — `AngularCompiler` 생성자에 `pluginOptions.transformStylesheet`를 직접 전달. 미제공 시 undefined로 전달되어 AngularCompiler에서 무시됨.
+
+- [x] **AngularCompiler 생성 시 externalStylesheets 전달**: `esbuild-angular-compiler-plugin.ts:228` — `pluginOptions.externalStylesheets`가 AngularCompiler 옵션에 전달됨.
+
+- [x] **첫 빌드 시 tsconfig 파싱 → AngularCompiler 생성 → initialize()**: `esbuild-angular-compiler-plugin.ts:214-231` — `angularCompiler == null` 조건에서 `parseTsconfigFile()` → `new AngularCompiler()` → `initialize()` 순서로 호출. compilerOptionsTransformer도 전달됨.
+
+- [x] **emitAffectedFiles → typeScriptFileCache 저장**: `esbuild-angular-compiler-plugin.ts:235-238` — emit 결과를 `path.normalize(filename)` 키로 저장. 원본 compiler-plugin.js와 동일한 패턴.
+
+- [x] **onDispose에서 리소스 정리**: `esbuild-angular-compiler-plugin.ts:295-299` — `angularCompiler = undefined`, `javascriptTransformer.close()`, `cacheStore?.close()` 호출. void로 fire-and-forget 처리 (원본과 동일).
+
+- [x] **LMDB 캐시 초기화 실패 시 graceful degradation**: `esbuild-angular-compiler-plugin.ts:160-168` — try-catch로 감싸고 logger.warn 후 cacheStore = undefined 유지. JavaScriptTransformer에 cache 없이 초기화됨.
+
+- [x] **onEnd에서 additionalResults 병합**: `esbuild-angular-compiler-plugin.ts:282-292` — outputFiles push + metafile Object.assign. result.outputFiles가 undefined일 수 있으므로 optional chaining 사용.
+
+- [x] **onStart 에러 처리**: `esbuild-angular-compiler-plugin.ts:262-274` — catch에서 "Angular compilation failed." 에러 메시지 + stack trace를 notes에 포함. hasCompilationErrors = true 설정.

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/esbuild/esbuild-tsc-plugin-imports.verify.md

@@ -0,0 +1,13 @@
+# esbuild-tsc-plugin 전환 — LLM 검증
+
+## 검증 항목
+
+- [x] `esbuild-tsc-plugin.ts`에서 `runTscPackageBuild`/`parseTsconfig` import 제거됨: Grep 결과 0건
+- [x] `esbuild-tsc-plugin.ts`에서 `SdTsCompiler` import 존재: `import { SdTsCompiler } from "../ts-compiler/SdTsCompiler"` (line 4)
+- [x] `TscPluginOptions`에 `lint?: boolean` 필드 존재: `esbuild-tsc-plugin.ts` 인터페이스 확인
+- [x] `TscPluginResult`에 `getLintResult()` getter 존재: `esbuild-tsc-plugin.ts` 인터페이스 확인
+- [x] `server-build.worker.ts`에서 `runTscPackageBuild` import 제거됨: Grep 결과 0건
+- [x] `server-build.worker.ts`에서 `LintWithProgramRunner` import 제거됨: Grep 결과 0건
+- [x] `server-build.worker.ts`에서 `SdTsCompiler` import 존재: `import { SdTsCompiler } from "../ts-compiler/SdTsCompiler"` 확인
+- [x] `server-esbuild-context.ts`에 `getTscLintResult()` 위임 메서드 존재: 코드 확인
+- [x] `server-esbuild-context.ts`의 `EsbuildContextOptions.tsc`에 `lint?: boolean` 존재: 코드 확인