@simplysm/sd-cli 14.0.42 → 14.0.43

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

@@ -1,25 +1,18 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
 import type esbuild from "esbuild";
-import type { TscPackageBuildResult } from "../../src/utils/tsc-build";
+import type { ISdTsCompilerResult } from "../../src/ts-compiler/sd-ts-compiler-result";
 
 //#region Mocks
 
-const mockRunTscPackageBuild = vi.fn<(...args: unknown[]) => TscPackageBuildResult>();
+const mockCompileAsync = vi.fn<() => Promise<ISdTsCompilerResult>>();
+const MockSdTsCompiler = vi.fn().mockImplementation(function () {
+  return { compileAsync: mockCompileAsync };
+});
 
-vi.mock("../../src/utils/tsc-build", () => ({
-  runTscPackageBuild: (...args: unknown[]) => mockRunTscPackageBuild(...args),
+vi.mock("../../src/ts-compiler/SdTsCompiler", () => ({
+  SdTsCompiler: MockSdTsCompiler,
 }));
 
-const mockParseTsconfig = vi.fn();
-
-vi.mock("../../src/utils/tsconfig", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("../../src/utils/tsconfig")>();
-  return {
-    ...actual,
-    parseTsconfig: (...args: unknown[]) => mockParseTsconfig(...args),
-  };
-});
-
 //#endregion
 
 const { createTscPlugin } = await import("../../src/esbuild/esbuild-tsc-plugin");
@@ -59,42 +52,36 @@ const baseOptions = {
   output: { dts: true },
 };
 
-const mockParsedConfig = {
-  options: { target: 99 },
-  fileNames: [],
-  errors: [],
-} as any;
-
-function createSuccessTscResult(): TscPackageBuildResult {
+function createSuccessCompileResult(): ISdTsCompilerResult {
   return {
-    success: true,
+    program: { getSourceFiles: () => [] } as any,
+    builderProgram: {} as any,
+    isForAngular: false,
+    affectedFiles: new Set(["/workspace/packages/my-server/src/main.ts"]),
     diagnostics: [],
     errorCount: 0,
     warningCount: 0,
-    program: { getSourceFiles: () => [] } as any,
-    affectedFiles: new Set(["/workspace/packages/my-server/src/main.ts"]),
-    builderProgram: {} as any,
+    errors: undefined,
+    emitResults: undefined,
+    lint: undefined,
+    scssErrors: [],
+    scssDependencies: new Map(),
   };
 }
 
-function createErrorTscResult(): TscPackageBuildResult {
+function createErrorCompileResult(): ISdTsCompilerResult {
   return {
-    success: false,
+    ...createSuccessCompileResult(),
     errors: ["TS2322: Type 'string' is not assignable to type 'number'"],
-    diagnostics: [{ category: 1, code: 2322, messageText: "Type mismatch" }],
+    diagnostics: [{ category: 1, code: 2322, messageText: "Type mismatch" }] as any,
     errorCount: 1,
-    warningCount: 0,
-    program: { getSourceFiles: () => [] } as any,
-    affectedFiles: new Set(["/workspace/packages/my-server/src/main.ts"]),
-    builderProgram: {} as any,
   };
 }
 
 describe("createTscPlugin — Acceptance Tests", () => {
   beforeEach(() => {
     vi.clearAllMocks();
-    mockParseTsconfig.mockReturnValue(mockParsedConfig);
-    mockRunTscPackageBuild.mockReturnValue(createSuccessTscResult());
+    mockCompileAsync.mockResolvedValue(createSuccessCompileResult());
   });
 
   // Rule: createTscPlugin은 esbuild.Plugin과 getter 객체를 반환한다
@@ -108,12 +95,13 @@ describe("createTscPlugin — Acceptance Tests", () => {
       expect(typeof result.getAffectedFiles).toBe("function");
       expect(typeof result.getDiagnostics).toBe("function");
       expect(typeof result.getErrors).toBe("function");
+      expect(typeof result.getLintResult).toBe("function");
       expect(typeof result.resetBuilderProgram).toBe("function");
     });
   });
 
   describe("Scenario: 선택 옵션 포함 플러그인 생성", () => {
-    it("env, includeTests 옵션이 runTscPackageBuild에 전달된다", async () => {
+    it("env, includeTests 옵션이 SdTsCompiler에 전달된다", async () => {
       const result = createTscPlugin({
         ...baseOptions,
         env: "node",
@@ -124,7 +112,7 @@ describe("createTscPlugin — Acceptance Tests", () => {
       await lifecycle.invokeOnStart();
       await lifecycle.invokeOnEnd();
 
-      expect(mockRunTscPackageBuild).toHaveBeenCalledWith(
+      expect(MockSdTsCompiler).toHaveBeenCalledWith(
         expect.objectContaining({
           env: "node",
           includeTests: true,
@@ -135,10 +123,9 @@ describe("createTscPlugin — Acceptance Tests", () => {
 
   // Rule: onStart에서 tsc를 microtask로 스케줄링하고 await하지 않는다
   describe("Scenario: tsc microtask 스케줄링", () => {
-    it("onStart는 tsc 완료를 기다리지 않고 즉시 반환한다", async () => {
+    it("onStart는 compileAsync 완료를 기다리지 않고 즉시 반환한다", async () => {
       const result = createTscPlugin(baseOptions);
 
-      // onStart 콜백을 직접 캡처하여 동기적으로 호출
       let onStartCb!: () => void;
       const mockBuild = {
         onStart(cb: () => void) { onStartCb = cb; },
@@ -150,17 +137,17 @@ describe("createTscPlugin — Acceptance Tests", () => {
       const onStartResult = onStartCb();
       expect(onStartResult).toBeUndefined();
 
-      // onStart 반환 직후, microtask 전이므로 tsc 미호출
-      expect(mockRunTscPackageBuild).not.toHaveBeenCalled();
+      // onStart 반환 직후, microtask 전이므로 SdTsCompiler 미생성
+      expect(MockSdTsCompiler).not.toHaveBeenCalled();
 
-      // microtask flush 후 tsc 호출됨
+      // microtask flush 후 SdTsCompiler 생성됨
       await Promise.resolve();
-      expect(mockRunTscPackageBuild).toHaveBeenCalledOnce();
+      expect(MockSdTsCompiler).toHaveBeenCalledOnce();
     });
   });
 
-  describe("Scenario: parsedConfig 갱신", () => {
-    it("매 onStart마다 parseTsconfig를 호출하여 최신 tsconfig를 반영한다", async () => {
+  describe("Scenario: SdTsCompiler 인스턴스 재사용", () => {
+    it("매 onStart마다 같은 SdTsCompiler 인스턴스를 재사용하여 증분 빌드를 지원한다", async () => {
       const result = createTscPlugin(baseOptions);
       const lifecycle = setupPlugin(result.plugin);
 
@@ -169,25 +156,21 @@ describe("createTscPlugin — Acceptance Tests", () => {
       await lifecycle.invokeOnEnd();
 
       // 두 번째 빌드
-      const updatedConfig = { ...mockParsedConfig, fileNames: ["/new-file.ts"] };
-      mockParseTsconfig.mockReturnValue(updatedConfig);
-
       await lifecycle.invokeOnStart();
       await lifecycle.invokeOnEnd();
 
-      expect(mockParseTsconfig).toHaveBeenCalledTimes(2);
-      expect(mockParseTsconfig).toHaveBeenCalledWith(baseOptions.pkgDir);
-      expect(mockRunTscPackageBuild).toHaveBeenLastCalledWith(
-        expect.objectContaining({ parsedConfig: updatedConfig }),
-      );
+      // SdTsCompiler 생성은 1회 (재사용)
+      expect(MockSdTsCompiler).toHaveBeenCalledTimes(1);
+      // compileAsync는 2회 호출
+      expect(mockCompileAsync).toHaveBeenCalledTimes(2);
     });
   });
 
   // Rule: onEnd에서 tsc Promise를 await하여 결과를 내부 상태에 저장한다
   describe("Scenario: tsc 정상 완료", () => {
     it("program, affectedFiles, diagnostics를 저장하고 errors는 undefined", async () => {
-      const tscResult = createSuccessTscResult();
-      mockRunTscPackageBuild.mockReturnValue(tscResult);
+      const compileResult = createSuccessCompileResult();
+      mockCompileAsync.mockResolvedValue(compileResult);
 
       const result = createTscPlugin(baseOptions);
       const lifecycle = setupPlugin(result.plugin);
@@ -195,8 +178,8 @@ describe("createTscPlugin — Acceptance Tests", () => {
       await lifecycle.invokeOnStart();
       await lifecycle.invokeOnEnd();
 
-      expect(result.getProgram()).toBe(tscResult.program);
-      expect(result.getAffectedFiles()).toBe(tscResult.affectedFiles);
+      expect(result.getProgram()).toBe(compileResult.program);
+      expect(result.getAffectedFiles()).toBe(compileResult.affectedFiles);
       expect(result.getDiagnostics()).toEqual([]);
       expect(result.getErrors()).toBeUndefined();
     });
@@ -204,8 +187,8 @@ describe("createTscPlugin — Acceptance Tests", () => {
 
   describe("Scenario: tsc 타입 에러 발생", () => {
     it("errors를 string[]로, diagnostics를 SerializedDiagnostic[]로 저장한다", async () => {
-      const tscResult = createErrorTscResult();
-      mockRunTscPackageBuild.mockReturnValue(tscResult);
+      const compileResult = createErrorCompileResult();
+      mockCompileAsync.mockResolvedValue(compileResult);
 
       const result = createTscPlugin(baseOptions);
       const lifecycle = setupPlugin(result.plugin);
@@ -215,16 +198,14 @@ describe("createTscPlugin — Acceptance Tests", () => {
 
       expect(result.getErrors()).toEqual(["TS2322: Type 'string' is not assignable to type 'number'"]);
       expect(result.getDiagnostics()).toEqual([{ category: 1, code: 2322, messageText: "Type mismatch" }]);
-      expect(result.getProgram()).toBe(tscResult.program);
-      expect(result.getAffectedFiles()).toBe(tscResult.affectedFiles);
+      expect(result.getProgram()).toBe(compileResult.program);
+      expect(result.getAffectedFiles()).toBe(compileResult.affectedFiles);
     });
   });
 
   describe("Scenario: tsc 예외 발생", () => {
     it("try-catch로 포착하여 errors에 메시지 저장, program/affectedFiles는 undefined", async () => {
-      mockRunTscPackageBuild.mockImplementation(() => {
-        throw new Error("tsconfig parse failed");
-      });
+      mockCompileAsync.mockRejectedValue(new Error("tsconfig parse failed"));
 
       const result = createTscPlugin(baseOptions);
       const lifecycle = setupPlugin(result.plugin);
@@ -242,7 +223,7 @@ describe("createTscPlugin — Acceptance Tests", () => {
   // Rule: result.errors에 push하지 않는다
   describe("Scenario: tsc 에러가 있어도 result.errors는 변경하지 않음", () => {
     it("onEnd의 result.errors에 tsc 에러를 push하지 않는다", async () => {
-      mockRunTscPackageBuild.mockReturnValue(createErrorTscResult());
+      mockCompileAsync.mockResolvedValue(createErrorCompileResult());
 
       const result = createTscPlugin(baseOptions);
       const lifecycle = setupPlugin(result.plugin);
@@ -255,9 +236,7 @@ describe("createTscPlugin — Acceptance Tests", () => {
       };
       await lifecycle.invokeOnEnd(buildResult);
 
-      // result.errors는 비어있어야 함 (tsc 에러가 push되지 않음)
       expect(buildResult.errors).toEqual([]);
-      // tsc 에러는 getErrors()로만 조회 가능
       expect(result.getErrors()).toBeDefined();
     });
   });
@@ -271,13 +250,14 @@ describe("createTscPlugin — Acceptance Tests", () => {
       expect(result.getAffectedFiles()).toBeUndefined();
       expect(result.getDiagnostics()).toEqual([]);
       expect(result.getErrors()).toBeUndefined();
+      expect(result.getLintResult()).toBeUndefined();
     });
   });
 
   describe("Scenario: 빌드 후 getter 호출", () => {
-    it("tsc 빌드 성공 후 program과 affectedFiles를 반환한다", async () => {
-      const tscResult = createSuccessTscResult();
-      mockRunTscPackageBuild.mockReturnValue(tscResult);
+    it("compileAsync 성공 후 program과 affectedFiles를 반환한다", async () => {
+      const compileResult = createSuccessCompileResult();
+      mockCompileAsync.mockResolvedValue(compileResult);
 
       const result = createTscPlugin(baseOptions);
       const lifecycle = setupPlugin(result.plugin);
@@ -285,65 +265,30 @@ describe("createTscPlugin — Acceptance Tests", () => {
       await lifecycle.invokeOnStart();
       await lifecycle.invokeOnEnd();
 
-      expect(result.getProgram()).toBe(tscResult.program);
+      expect(result.getProgram()).toBe(compileResult.program);
       expect(result.getAffectedFiles()).toEqual(new Set(["/workspace/packages/my-server/src/main.ts"]));
       expect(result.getDiagnostics()).toEqual([]);
     });
   });
 
-  // Rule: lastBuilderProgram을 캐싱하여 watch 모드 증분 빌드를 지원한다
-  describe("Scenario: 증분 빌드 — builderProgram 재사용", () => {
-    it("첫 번째 빌드 후 캐싱된 builderProgram을 두 번째 빌드에 oldBuilderProgram으로 전달한다", async () => {
-      const firstBuilderProgram = { kind: "first" } as any;
-      mockRunTscPackageBuild.mockReturnValue({
-        ...createSuccessTscResult(),
-        builderProgram: firstBuilderProgram,
-      });
-
-      const result = createTscPlugin(baseOptions);
-      const lifecycle = setupPlugin(result.plugin);
-
-      // 첫 번째 빌드
-      await lifecycle.invokeOnStart();
-      await lifecycle.invokeOnEnd();
-
-      // 두 번째 빌드
-      await lifecycle.invokeOnStart();
-      await lifecycle.invokeOnEnd();
-
-      // 두 번째 호출에서 oldBuilderProgram이 첫 번째 결과의 builderProgram
-      expect(mockRunTscPackageBuild).toHaveBeenCalledTimes(2);
-      expect(mockRunTscPackageBuild).toHaveBeenLastCalledWith(
-        expect.objectContaining({ oldBuilderProgram: firstBuilderProgram }),
-      );
-    });
-  });
-
+  // Rule: SdTsCompiler 인스턴스를 유지하여 증분 빌드를 지원하고 resetBuilderProgram 시 재생성한다
   describe("Scenario: builderProgram 리셋", () => {
-    it("resetBuilderProgram 호출 후 다음 빌드는 fresh build로 실행된다", async () => {
-      const cachedBuilderProgram = { kind: "cached" } as any;
-      mockRunTscPackageBuild.mockReturnValue({
-        ...createSuccessTscResult(),
-        builderProgram: cachedBuilderProgram,
-      });
-
+    it("resetBuilderProgram 호출 후 다음 빌드는 새 SdTsCompiler 인스턴스로 실행된다", async () => {
       const result = createTscPlugin(baseOptions);
       const lifecycle = setupPlugin(result.plugin);
 
-      // 첫 번째 빌드 — builderProgram 캐싱
+      // 첫 번째 빌드
       await lifecycle.invokeOnStart();
       await lifecycle.invokeOnEnd();
+      expect(MockSdTsCompiler).toHaveBeenCalledTimes(1);
 
       // 리셋
       result.resetBuilderProgram();
 
-      // 다음 빌드 — oldBuilderProgram이 undefined (fresh build)
+      // 다음 빌드 — 새 SdTsCompiler 인스턴스 생성
       await lifecycle.invokeOnStart();
       await lifecycle.invokeOnEnd();
-
-      expect(mockRunTscPackageBuild).toHaveBeenLastCalledWith(
-        expect.objectContaining({ oldBuilderProgram: undefined }),
-      );
+      expect(MockSdTsCompiler).toHaveBeenCalledTimes(2);
     });
   });
 });

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

@@ -1,25 +1,18 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
 import type esbuild from "esbuild";
-import type { TscPackageBuildResult } from "../../src/utils/tsc-build";
+import type { ISdTsCompilerResult } from "../../src/ts-compiler/sd-ts-compiler-result";
 
 //#region Mocks
 
-const mockRunTscPackageBuild = vi.fn<(...args: unknown[]) => TscPackageBuildResult>();
+const mockCompileAsync = vi.fn<() => Promise<ISdTsCompilerResult>>();
+const MockSdTsCompiler = vi.fn().mockImplementation(function () {
+  return { compileAsync: mockCompileAsync };
+});
 
-vi.mock("../../src/utils/tsc-build", () => ({
-  runTscPackageBuild: (...args: unknown[]) => mockRunTscPackageBuild(...args),
+vi.mock("../../src/ts-compiler/SdTsCompiler", () => ({
+  SdTsCompiler: MockSdTsCompiler,
 }));
 
-const mockParseTsconfig = vi.fn();
-
-vi.mock("../../src/utils/tsconfig", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("../../src/utils/tsconfig")>();
-  return {
-    ...actual,
-    parseTsconfig: (...args: unknown[]) => mockParseTsconfig(...args),
-  };
-});
-
 //#endregion
 
 const { createTscPlugin } = await import("../../src/esbuild/esbuild-tsc-plugin");
@@ -59,29 +52,27 @@ const baseOptions = {
   output: { dts: true },
 };
 
-const mockParsedConfig = {
-  options: { target: 99 },
-  fileNames: [],
-  errors: [],
-} as any;
-
-function createSuccessTscResult(): TscPackageBuildResult {
+function createSuccessCompileResult(): ISdTsCompilerResult {
   return {
-    success: true,
+    program: { getSourceFiles: () => [] } as any,
+    builderProgram: {} as any,
+    isForAngular: false,
+    affectedFiles: new Set(["/workspace/packages/my-server/src/main.ts"]),
     diagnostics: [],
     errorCount: 0,
     warningCount: 0,
-    program: { getSourceFiles: () => [] } as any,
-    affectedFiles: new Set(["/workspace/packages/my-server/src/main.ts"]),
-    builderProgram: {} as any,
+    errors: undefined,
+    emitResults: undefined,
+    lint: undefined,
+    scssErrors: [],
+    scssDependencies: new Map(),
   };
 }
 
 describe("createTscPlugin — Unit Tests", () => {
   beforeEach(() => {
     vi.clearAllMocks();
-    mockParseTsconfig.mockReturnValue(mockParsedConfig);
-    mockRunTscPackageBuild.mockReturnValue(createSuccessTscResult());
+    mockCompileAsync.mockResolvedValue(createSuccessCompileResult());
   });
 
   describe("plugin 구조", () => {
@@ -102,20 +93,19 @@ describe("createTscPlugin — Unit Tests", () => {
     });
   });
 
-  describe("onStart — runTscPackageBuild 옵션 전달", () => {
-    it("pkgDir, cwd, output.dts를 올바르게 전달한다", async () => {
+  describe("onStart — SdTsCompiler 옵션 전달", () => {
+    it("pkgDir, cwd, output.js=false, output.dts를 올바르게 전달한다", async () => {
       const result = createTscPlugin(baseOptions);
       const lifecycle = setupPlugin(result.plugin);
 
       await lifecycle.invokeOnStart();
       await lifecycle.invokeOnEnd();
 
-      expect(mockRunTscPackageBuild).toHaveBeenCalledWith(
+      expect(MockSdTsCompiler).toHaveBeenCalledWith(
         expect.objectContaining({
           pkgDir: "/workspace/packages/my-server",
           cwd: "/workspace",
           output: { js: false, dts: true },
-          parsedConfig: mockParsedConfig,
         }),
       );
     });
@@ -130,23 +120,59 @@ describe("createTscPlugin — Unit Tests", () => {
       await lifecycle.invokeOnStart();
       await lifecycle.invokeOnEnd();
 
-      expect(mockRunTscPackageBuild).toHaveBeenCalledWith(
+      expect(MockSdTsCompiler).toHaveBeenCalledWith(
         expect.objectContaining({
           output: { js: false, dts: false },
         }),
       );
     });
+
+    it("lint 옵션을 SdTsCompiler에 전달한다", async () => {
+      const result = createTscPlugin({
+        ...baseOptions,
+        lint: true,
+      });
+      const lifecycle = setupPlugin(result.plugin);
+
+      await lifecycle.invokeOnStart();
+      await lifecycle.invokeOnEnd();
+
+      expect(MockSdTsCompiler).toHaveBeenCalledWith(
+        expect.objectContaining({
+          lint: true,
+        }),
+      );
+    });
+
+    it("env, includeTests 옵션을 SdTsCompiler에 전달한다", async () => {
+      const result = createTscPlugin({
+        ...baseOptions,
+        env: "node" as any,
+        includeTests: true,
+      });
+      const lifecycle = setupPlugin(result.plugin);
+
+      await lifecycle.invokeOnStart();
+      await lifecycle.invokeOnEnd();
+
+      expect(MockSdTsCompiler).toHaveBeenCalledWith(
+        expect.objectContaining({
+          env: "node",
+          includeTests: true,
+        }),
+      );
+    });
   });
 
   describe("onEnd — 상태 저장", () => {
-    it("tsc 결과의 diagnostics를 정확히 저장한다", async () => {
+    it("compileAsync 결과의 diagnostics를 정확히 저장한다", async () => {
       const diagnostics = [
         { category: 0, code: 6031, messageText: "Watching for changes" },
         { category: 1, code: 2322, messageText: "Type error" },
       ];
-      mockRunTscPackageBuild.mockReturnValue({
-        ...createSuccessTscResult(),
-        diagnostics,
+      mockCompileAsync.mockResolvedValue({
+        ...createSuccessCompileResult(),
+        diagnostics: diagnostics as any,
       });
 
       const result = createTscPlugin(baseOptions);
@@ -158,10 +184,8 @@ describe("createTscPlugin — Unit Tests", () => {
       expect(result.getDiagnostics()).toEqual(diagnostics);
     });
 
-    it("parseTsconfig 예외 시에도 에러를 저장한다", async () => {
-      mockParseTsconfig.mockImplementation(() => {
-        throw new Error("Invalid tsconfig.json");
-      });
+    it("compileAsync 예외 시에도 에러를 저장한다", async () => {
+      mockCompileAsync.mockRejectedValue(new Error("Invalid tsconfig.json"));
 
       const result = createTscPlugin(baseOptions);
       const lifecycle = setupPlugin(result.plugin);
@@ -172,6 +196,28 @@ describe("createTscPlugin — Unit Tests", () => {
       expect(result.getErrors()).toEqual(["Invalid tsconfig.json"]);
       expect(result.getDiagnostics()).toEqual([]);
       expect(result.getProgram()).toBeUndefined();
+      expect(result.getLintResult()).toBeUndefined();
+    });
+
+    it("compileAsync 결과에서 lint 결과를 저장한다", async () => {
+      const lintResult = {
+        success: true,
+        errorCount: 0,
+        warningCount: 0,
+        formattedOutput: "",
+      };
+      mockCompileAsync.mockResolvedValue({
+        ...createSuccessCompileResult(),
+        lint: lintResult,
+      });
+
+      const result = createTscPlugin({ ...baseOptions, lint: true });
+      const lifecycle = setupPlugin(result.plugin);
+
+      await lifecycle.invokeOnStart();
+      await lifecycle.invokeOnEnd();
+
+      expect(result.getLintResult()).toEqual(lintResult);
     });
   });
 
@@ -181,20 +227,17 @@ describe("createTscPlugin — Unit Tests", () => {
       const lifecycle = setupPlugin(result.plugin);
 
       // 첫 번째 빌드 — 에러
-      const errorResult: TscPackageBuildResult = {
-        success: false,
+      mockCompileAsync.mockResolvedValue({
+        ...createSuccessCompileResult(),
         errors: ["first error"],
-        diagnostics: [{ category: 1, code: 1, messageText: "err" }],
         errorCount: 1,
-        warningCount: 0,
-      };
-      mockRunTscPackageBuild.mockReturnValue(errorResult);
+      });
       await lifecycle.invokeOnStart();
       await lifecycle.invokeOnEnd();
       expect(result.getErrors()).toEqual(["first error"]);
 
       // 두 번째 빌드 — 성공
-      mockRunTscPackageBuild.mockReturnValue(createSuccessTscResult());
+      mockCompileAsync.mockResolvedValue(createSuccessCompileResult());
       await lifecycle.invokeOnStart();
       await lifecycle.invokeOnEnd();
       expect(result.getErrors()).toBeUndefined();
@@ -208,23 +251,44 @@ describe("createTscPlugin — Unit Tests", () => {
       expect(() => result.resetBuilderProgram()).not.toThrow();
     });
 
-    it("여러 번 호출해도 안전하다", async () => {
+    it("리셋 후 다음 빌드에서 새 SdTsCompiler 인스턴스를 생성한다", async () => {
       const result = createTscPlugin(baseOptions);
       const lifecycle = setupPlugin(result.plugin);
 
+      // 첫 번째 빌드
+      await lifecycle.invokeOnStart();
+      await lifecycle.invokeOnEnd();
+      expect(MockSdTsCompiler).toHaveBeenCalledTimes(1);
+
+      // 두 번째 빌드 — 같은 인스턴스 재사용
       await lifecycle.invokeOnStart();
       await lifecycle.invokeOnEnd();
+      expect(MockSdTsCompiler).toHaveBeenCalledTimes(1);
 
+      // 리셋 후 세 번째 빌드 — 새 인스턴스 생성
+      result.resetBuilderProgram();
+      await lifecycle.invokeOnStart();
+      await lifecycle.invokeOnEnd();
+      expect(MockSdTsCompiler).toHaveBeenCalledTimes(2);
+    });
+
+    it("여러 번 호출해도 안전하다", () => {
+      const result = createTscPlugin(baseOptions);
       result.resetBuilderProgram();
       result.resetBuilderProgram();
+      // No throw
+    });
+  });
+
+  describe("getLintResult", () => {
+    it("lint 미활성 시 undefined를 반환한다", async () => {
+      const result = createTscPlugin(baseOptions);
+      const lifecycle = setupPlugin(result.plugin);
 
-      // 리셋 후 빌드 가능
       await lifecycle.invokeOnStart();
       await lifecycle.invokeOnEnd();
 
-      expect(mockRunTscPackageBuild).toHaveBeenLastCalledWith(
-        expect.objectContaining({ oldBuilderProgram: undefined }),
-      );
+      expect(result.getLintResult()).toBeUndefined();
     });
   });
 });