@simplysm/sd-cli 14.0.38 → 14.0.40

package/tests/workers/server-esbuild-context.acc.spec.ts

@@ -5,6 +5,15 @@ import { describe, it, expect, vi, afterEach } from "vitest";
 const mockRebuild = vi.fn();
 const mockDispose = vi.fn();
 
+const mockTscPlugin = {
+  plugin: { name: "sd-tsc", setup: vi.fn() },
+  getProgram: vi.fn(),
+  getAffectedFiles: vi.fn(),
+  getDiagnostics: vi.fn((): unknown[] => []),
+  getErrors: vi.fn(),
+  resetBuilderProgram: vi.fn(),
+};
+
 vi.mock("esbuild", () => ({
   default: {
     context: vi.fn(() =>
@@ -21,11 +30,18 @@ vi.mock("../../src/esbuild/esbuild-config", async (importOriginal) => {
   };
 });
 
+vi.mock("../../src/esbuild/esbuild-tsc-plugin", () => ({
+  createTscPlugin: vi.fn(() => mockTscPlugin),
+}));
+
 //#endregion
 
 const esbuild = (await import("esbuild")).default;
-const { createContext, rebuild, recreateContext, dispose, getMetafile, hasContext } =
-  await import("../../src/workers/server-esbuild-context");
+const {
+  createContext, rebuild, recreateContext, dispose, getMetafile, hasContext,
+  getTscProgram, getTscAffectedFiles, getTscDiagnostics,
+} = await import("../../src/workers/server-esbuild-context");
+const { createTscPlugin } = await import("../../src/esbuild/esbuild-tsc-plugin");
 
 const baseOptions = {
   pkgDir: "/workspace/packages/my-server",
@@ -33,11 +49,22 @@ const baseOptions = {
   external: [],
 };
 
+const baseTscOptions = {
+  cwd: "/workspace",
+  output: { dts: true },
+};
+
 describe("server-esbuild-context lifecycle", () => {
   afterEach(async () => {
     mockRebuild.mockReset();
     mockDispose.mockReset();
+    mockTscPlugin.getProgram.mockReset();
+    mockTscPlugin.getAffectedFiles.mockReset();
+    mockTscPlugin.getDiagnostics.mockReset().mockReturnValue([]);
+    mockTscPlugin.getErrors.mockReset();
+    mockTscPlugin.resetBuilderProgram.mockReset();
     vi.mocked(esbuild.context).mockClear();
+    vi.mocked(createTscPlugin).mockClear();
     await dispose();
   });
 
@@ -96,3 +123,162 @@ describe("server-esbuild-context lifecycle", () => {
     expect(result).toBeNull();
   });
 });
+
+describe("server-esbuild-context tsc integration lifecycle", () => {
+  afterEach(async () => {
+    mockRebuild.mockReset();
+    mockDispose.mockReset();
+    mockTscPlugin.getProgram.mockReset();
+    mockTscPlugin.getAffectedFiles.mockReset();
+    mockTscPlugin.getDiagnostics.mockReset().mockReturnValue([]);
+    mockTscPlugin.getErrors.mockReset();
+    mockTscPlugin.resetBuilderProgram.mockReset();
+    vi.mocked(esbuild.context).mockClear();
+    vi.mocked(createTscPlugin).mockClear();
+    await dispose();
+  });
+
+  // Acceptance: create with tsc → delegation works → dispose clears all
+  it("manages tsc plugin lifecycle: create with tsc → delegation returns plugin values → dispose clears", async () => {
+    const fakeProgram = { id: "fake-program" };
+    const fakeAffectedFiles = new Set(["/src/main.ts"]);
+    const fakeDiagnostics = [{ category: 1, code: 2322, messageText: "Type error" }];
+    mockTscPlugin.getProgram.mockReturnValue(fakeProgram);
+    mockTscPlugin.getAffectedFiles.mockReturnValue(fakeAffectedFiles);
+    mockTscPlugin.getDiagnostics.mockReturnValue(fakeDiagnostics);
+
+    // Create with tsc options
+    await createContext({ ...baseOptions, tsc: baseTscOptions });
+    expect(hasContext()).toBe(true);
+
+    // Delegation methods return plugin values
+    expect(getTscProgram()).toBe(fakeProgram);
+    expect(getTscAffectedFiles()).toBe(fakeAffectedFiles);
+    expect(getTscDiagnostics()).toEqual(fakeDiagnostics);
+
+    // Dispose clears everything
+    await dispose();
+    expect(hasContext()).toBe(false);
+    expect(getTscProgram()).toBeUndefined();
+    expect(getTscAffectedFiles()).toBeUndefined();
+    expect(getTscDiagnostics()).toEqual([]);
+  });
+
+  // Acceptance: create with tsc → recreate without tsc → plugin persists
+  it("persists tsc plugin across context recreation when tsc options omitted", async () => {
+    const fakeProgram = { id: "persisted-program" };
+    mockTscPlugin.getProgram.mockReturnValue(fakeProgram);
+
+    // Initial create with tsc
+    await createContext({ ...baseOptions, tsc: baseTscOptions });
+    expect(getTscProgram()).toBe(fakeProgram);
+
+    // Recreate without tsc options — plugin persists
+    await recreateContext(baseOptions);
+    expect(hasContext()).toBe(true);
+    expect(getTscProgram()).toBe(fakeProgram);
+  });
+
+  // Acceptance: create without tsc → no plugin → delegation returns defaults
+  it("returns default values from delegation methods when no tsc plugin exists", async () => {
+    await createContext(baseOptions);
+
+    expect(hasContext()).toBe(true);
+    expect(getTscProgram()).toBeUndefined();
+    expect(getTscAffectedFiles()).toBeUndefined();
+    expect(getTscDiagnostics()).toEqual([]);
+  });
+
+  // Acceptance: rebuild merges esbuild + tsc errors
+  it("merges esbuild and tsc errors in rebuild result", async () => {
+    mockRebuild.mockResolvedValue({
+      errors: [{ text: "esbuild syntax error" }],
+      warnings: [{ text: "deprecation" }],
+      outputFiles: [],
+      metafile: undefined,
+    });
+    mockTscPlugin.getErrors.mockReturnValue(["TS2322: type mismatch"]);
+
+    await createContext({ ...baseOptions, tsc: baseTscOptions });
+    const result = await rebuild();
+
+    expect(result).toEqual({
+      success: false,
+      errors: ["esbuild syntax error", "TS2322: type mismatch"],
+      warnings: ["deprecation"],
+    });
+  });
+
+  // Acceptance: recreateContext resets tsc and persists plugin
+  it("resets tsc builderProgram on recreateContext and persists plugin for next rebuild", async () => {
+    mockRebuild.mockResolvedValue({
+      errors: [],
+      warnings: [],
+      outputFiles: [],
+      metafile: { inputs: {}, outputs: {} },
+    });
+    mockTscPlugin.getErrors.mockReturnValue(undefined);
+
+    await createContext({ ...baseOptions, tsc: baseTscOptions });
+
+    // recreateContext — resets tsc + creates new esbuild context
+    await recreateContext(baseOptions);
+
+    expect(mockTscPlugin.resetBuilderProgram).toHaveBeenCalled();
+    expect(hasContext()).toBe(true);
+
+    // rebuild still works with merged result
+    const result = await rebuild();
+    expect(result).toEqual({
+      success: true,
+      errors: undefined,
+      warnings: undefined,
+    });
+  });
+
+  // Acceptance: rebuild() reject 시 tsc 에러와 병합하여 정상 결과 반환
+  it("merges tsc errors when context.rebuild() rejects instead of propagating throw", async () => {
+    mockRebuild.mockResolvedValueOnce({
+      errors: [],
+      warnings: [],
+      outputFiles: [],
+      metafile: { inputs: { "src/main.ts": {} }, outputs: {} },
+    });
+    mockTscPlugin.getErrors.mockReturnValue(["TS2322: type mismatch"]);
+
+    await createContext({ ...baseOptions, tsc: baseTscOptions });
+
+    // 첫 빌드 성공 (metafile 설정)
+    await rebuild();
+    const savedMetafile = getMetafile();
+    expect(savedMetafile).toBeDefined();
+
+    // 두 번째 빌드 실패 — reject
+    mockRebuild.mockRejectedValueOnce(new Error("Build failed with 1 error"));
+
+    const result = await rebuild();
+
+    // throw 전파 대신 정상 결과 반환 — esbuild + tsc 에러 병합
+    expect(result).toEqual({
+      success: false,
+      errors: ["Build failed with 1 error", "TS2322: type mismatch"],
+      warnings: undefined,
+    });
+    // 이전 metafile 유지
+    expect(getMetafile()).toBe(savedMetafile);
+  });
+
+  // Acceptance: LOGIC-001 — recreateContext failure preserves tsc plugin reset
+  it("resets tsc and disposes old context even when recreateContext fails (LOGIC-001)", async () => {
+    await createContext({ ...baseOptions, tsc: baseTscOptions });
+
+    // New context creation fails
+    vi.mocked(esbuild.context).mockRejectedValueOnce(new Error("creation failed"));
+
+    await expect(recreateContext(baseOptions)).rejects.toThrow("creation failed");
+
+    expect(mockTscPlugin.resetBuilderProgram).toHaveBeenCalled();
+    expect(mockDispose).toHaveBeenCalled();
+    expect(hasContext()).toBe(false);
+  });
+});

package/tests/workers/server-esbuild-context.spec.ts

@@ -5,6 +5,15 @@ import { describe, it, expect, vi, afterEach } from "vitest";
 const mockRebuild = vi.fn();
 const mockDispose = vi.fn();
 
+const mockTscPlugin = {
+  plugin: { name: "sd-tsc", setup: vi.fn() },
+  getProgram: vi.fn(),
+  getAffectedFiles: vi.fn(),
+  getDiagnostics: vi.fn((): unknown[] => []),
+  getErrors: vi.fn(),
+  resetBuilderProgram: vi.fn(),
+};
+
 vi.mock("esbuild", () => ({
   default: {
     context: vi.fn(() =>
@@ -21,12 +30,19 @@ vi.mock("../../src/esbuild/esbuild-config", async (importOriginal) => {
   };
 });
 
+vi.mock("../../src/esbuild/esbuild-tsc-plugin", () => ({
+  createTscPlugin: vi.fn(() => mockTscPlugin),
+}));
+
 //#endregion
 
 const esbuild = (await import("esbuild")).default;
 const { writeChangedOutputFiles } = await import("../../src/esbuild/esbuild-config");
-const { createContext, rebuild, recreateContext, dispose, getMetafile, hasContext } =
-  await import("../../src/workers/server-esbuild-context");
+const {
+  createContext, rebuild, recreateContext, dispose, getMetafile, hasContext,
+  getTscProgram, getTscAffectedFiles, getTscDiagnostics,
+} = await import("../../src/workers/server-esbuild-context");
+const { createTscPlugin } = await import("../../src/esbuild/esbuild-tsc-plugin");
 
 const baseOptions = {
   pkgDir: "/workspace/packages/my-server",
@@ -38,8 +54,14 @@ describe("createContext", () => {
   afterEach(async () => {
     mockRebuild.mockReset();
     mockDispose.mockReset();
+    mockTscPlugin.getProgram.mockReset();
+    mockTscPlugin.getAffectedFiles.mockReset();
+    mockTscPlugin.getDiagnostics.mockReset().mockReturnValue([]);
+    mockTscPlugin.getErrors.mockReset();
+    mockTscPlugin.resetBuilderProgram.mockReset();
     vi.mocked(esbuild.context).mockClear();
     vi.mocked(writeChangedOutputFiles).mockClear();
+    vi.mocked(createTscPlugin).mockClear();
     await dispose();
   });
 
@@ -72,8 +94,14 @@ describe("rebuild", () => {
   afterEach(async () => {
     mockRebuild.mockReset();
     mockDispose.mockReset();
+    mockTscPlugin.getProgram.mockReset();
+    mockTscPlugin.getAffectedFiles.mockReset();
+    mockTscPlugin.getDiagnostics.mockReset().mockReturnValue([]);
+    mockTscPlugin.getErrors.mockReset();
+    mockTscPlugin.resetBuilderProgram.mockReset();
     vi.mocked(esbuild.context).mockClear();
     vi.mocked(writeChangedOutputFiles).mockClear();
+    vi.mocked(createTscPlugin).mockClear();
     await dispose();
   });
 
@@ -124,12 +152,99 @@ describe("rebuild", () => {
   });
 });
 
+describe("rebuild — error handling on reject", () => {
+  afterEach(async () => {
+    mockRebuild.mockReset();
+    mockDispose.mockReset();
+    mockTscPlugin.getProgram.mockReset();
+    mockTscPlugin.getAffectedFiles.mockReset();
+    mockTscPlugin.getDiagnostics.mockReset().mockReturnValue([]);
+    mockTscPlugin.getErrors.mockReset();
+    mockTscPlugin.resetBuilderProgram.mockReset();
+    vi.mocked(esbuild.context).mockClear();
+    vi.mocked(writeChangedOutputFiles).mockClear();
+    vi.mocked(createTscPlugin).mockClear();
+    await dispose();
+  });
+
+  it("catches reject and returns merged esbuild + tsc errors", async () => {
+    mockRebuild.mockRejectedValue(new Error("Build failed"));
+    mockTscPlugin.getErrors.mockReturnValue(["type error"]);
+
+    await createContext({ ...baseOptions, tsc: { cwd: "/workspace", output: { dts: true } } });
+    const result = await rebuild();
+
+    expect(result).toEqual({
+      success: false,
+      errors: ["Build failed", "type error"],
+      warnings: undefined,
+    });
+  });
+
+  it("returns esbuild error only when tsc has no errors", async () => {
+    mockRebuild.mockRejectedValue(new Error("Build failed"));
+    mockTscPlugin.getErrors.mockReturnValue(undefined);
+
+    await createContext({ ...baseOptions, tsc: { cwd: "/workspace", output: { dts: true } } });
+    const result = await rebuild();
+
+    expect(result).toEqual({
+      success: false,
+      errors: ["Build failed"],
+      warnings: undefined,
+    });
+  });
+
+  it("returns esbuild error when no tsc plugin exists", async () => {
+    mockRebuild.mockRejectedValue(new Error("Build failed"));
+
+    await createContext(baseOptions);
+    const result = await rebuild();
+
+    expect(result).toEqual({
+      success: false,
+      errors: ["Build failed"],
+      warnings: undefined,
+    });
+  });
+
+  it("preserves previous metafile when rebuild rejects", async () => {
+    const mockMetafile = { inputs: { "src/main.ts": {} }, outputs: {} };
+    mockRebuild.mockResolvedValueOnce({
+      errors: [],
+      warnings: [],
+      outputFiles: [],
+      metafile: mockMetafile,
+    });
+
+    await createContext(baseOptions);
+    await rebuild();
+    expect(getMetafile()).toBe(mockMetafile);
+
+    mockRebuild.mockRejectedValueOnce(new Error("Build failed"));
+    const result = await rebuild();
+
+    expect(result).toEqual({
+      success: false,
+      errors: ["Build failed"],
+      warnings: undefined,
+    });
+    expect(getMetafile()).toBe(mockMetafile);
+  });
+});
+
 describe("recreateContext", () => {
   afterEach(async () => {
     mockRebuild.mockReset();
     mockDispose.mockReset();
+    mockTscPlugin.getProgram.mockReset();
+    mockTscPlugin.getAffectedFiles.mockReset();
+    mockTscPlugin.getDiagnostics.mockReset().mockReturnValue([]);
+    mockTscPlugin.getErrors.mockReset();
+    mockTscPlugin.resetBuilderProgram.mockReset();
     vi.mocked(esbuild.context).mockClear();
     vi.mocked(writeChangedOutputFiles).mockClear();
+    vi.mocked(createTscPlugin).mockClear();
     await dispose();
   });
 
@@ -169,8 +284,14 @@ describe("dispose", () => {
   afterEach(() => {
     mockRebuild.mockReset();
     mockDispose.mockReset();
+    mockTscPlugin.getProgram.mockReset();
+    mockTscPlugin.getAffectedFiles.mockReset();
+    mockTscPlugin.getDiagnostics.mockReset().mockReturnValue([]);
+    mockTscPlugin.getErrors.mockReset();
+    mockTscPlugin.resetBuilderProgram.mockReset();
     vi.mocked(esbuild.context).mockClear();
     vi.mocked(writeChangedOutputFiles).mockClear();
+    vi.mocked(createTscPlugin).mockClear();
   });
 
   it("is safe to call when no context exists", async () => {
@@ -195,4 +316,282 @@ describe("dispose", () => {
     expect(hasContext()).toBe(false);
     expect(getMetafile()).toBeUndefined();
   });
+
+  it("clears tscPlugin reference on dispose", async () => {
+    mockTscPlugin.getProgram.mockReturnValue({ id: "prog" });
+
+    await createContext({
+      ...baseOptions,
+      tsc: { cwd: "/workspace", output: { dts: true } },
+    });
+    expect(getTscProgram()).toEqual({ id: "prog" });
+
+    await dispose();
+
+    expect(getTscProgram()).toBeUndefined();
+    expect(getTscAffectedFiles()).toBeUndefined();
+    expect(getTscDiagnostics()).toEqual([]);
+  });
+});
+
+describe("createContext — tsc plugin", () => {
+  afterEach(async () => {
+    mockRebuild.mockReset();
+    mockDispose.mockReset();
+    mockTscPlugin.getProgram.mockReset();
+    mockTscPlugin.getAffectedFiles.mockReset();
+    mockTscPlugin.getDiagnostics.mockReset().mockReturnValue([]);
+    mockTscPlugin.getErrors.mockReset();
+    mockTscPlugin.resetBuilderProgram.mockReset();
+    vi.mocked(esbuild.context).mockClear();
+    vi.mocked(writeChangedOutputFiles).mockClear();
+    vi.mocked(createTscPlugin).mockClear();
+    await dispose();
+  });
+
+  it("includes tsc plugin in esbuild context when tsc options provided", async () => {
+    await createContext({
+      ...baseOptions,
+      tsc: { cwd: "/workspace", output: { dts: true } },
+    });
+
+    expect(esbuild.context).toHaveBeenCalledWith(
+      expect.objectContaining({
+        plugins: [mockTscPlugin.plugin],
+      }),
+    );
+  });
+
+  it("creates esbuild context without plugins when no tsc options and no existing plugin", async () => {
+    await createContext(baseOptions);
+
+    expect(esbuild.context).toHaveBeenCalledWith(
+      expect.objectContaining({
+        plugins: [],
+      }),
+    );
+  });
+
+  it("reuses existing tsc plugin when tsc options absent in subsequent createContext", async () => {
+    // First: create with tsc
+    await createContext({
+      ...baseOptions,
+      tsc: { cwd: "/workspace", output: { dts: true } },
+    });
+
+    // Dispose context only (not module-level dispose — use recreateContext pattern)
+    vi.mocked(esbuild.context).mockClear();
+
+    // Second: create without tsc — should reuse existing plugin
+    await recreateContext(baseOptions);
+
+    expect(esbuild.context).toHaveBeenCalledWith(
+      expect.objectContaining({
+        plugins: [mockTscPlugin.plugin],
+      }),
+    );
+  });
+
+  it("passes tsc env and includeTests options to createTscPlugin", async () => {
+    await createContext({
+      ...baseOptions,
+      tsc: {
+        cwd: "/workspace",
+        output: { dts: false },
+        env: "node",
+        includeTests: true,
+      },
+    });
+
+    expect(createTscPlugin).toHaveBeenCalledWith({
+      pkgDir: baseOptions.pkgDir,
+      cwd: "/workspace",
+      output: { dts: false },
+      env: "node",
+      includeTests: true,
+    });
+  });
+});
+
+describe("delegation methods", () => {
+  afterEach(async () => {
+    mockTscPlugin.getProgram.mockReset();
+    mockTscPlugin.getAffectedFiles.mockReset();
+    mockTscPlugin.getDiagnostics.mockReset().mockReturnValue([]);
+    mockTscPlugin.getErrors.mockReset();
+    mockTscPlugin.resetBuilderProgram.mockReset();
+    vi.mocked(esbuild.context).mockClear();
+    vi.mocked(createTscPlugin).mockClear();
+    await dispose();
+  });
+
+  it("getTscProgram returns plugin value when plugin exists", async () => {
+    const fakeProgram = { getSourceFiles: () => [] };
+    mockTscPlugin.getProgram.mockReturnValue(fakeProgram);
+
+    await createContext({
+      ...baseOptions,
+      tsc: { cwd: "/workspace", output: { dts: true } },
+    });
+
+    expect(getTscProgram()).toBe(fakeProgram);
+  });
+
+  it("getTscAffectedFiles returns plugin value when plugin exists", async () => {
+    const fakeFiles = new Set(["/src/main.ts"]);
+    mockTscPlugin.getAffectedFiles.mockReturnValue(fakeFiles);
+
+    await createContext({
+      ...baseOptions,
+      tsc: { cwd: "/workspace", output: { dts: true } },
+    });
+
+    expect(getTscAffectedFiles()).toBe(fakeFiles);
+  });
+
+  it("getTscDiagnostics returns plugin value when plugin exists", async () => {
+    const fakeDiag = [{ category: 1, code: 2322, messageText: "err" }];
+    mockTscPlugin.getDiagnostics.mockReturnValue(fakeDiag);
+
+    await createContext({
+      ...baseOptions,
+      tsc: { cwd: "/workspace", output: { dts: true } },
+    });
+
+    expect(getTscDiagnostics()).toEqual(fakeDiag);
+  });
+
+});
+
+describe("rebuild — tsc error merge", () => {
+  afterEach(async () => {
+    mockRebuild.mockReset();
+    mockDispose.mockReset();
+    mockTscPlugin.getProgram.mockReset();
+    mockTscPlugin.getAffectedFiles.mockReset();
+    mockTscPlugin.getDiagnostics.mockReset().mockReturnValue([]);
+    mockTscPlugin.getErrors.mockReset();
+    mockTscPlugin.resetBuilderProgram.mockReset();
+    vi.mocked(esbuild.context).mockClear();
+    vi.mocked(writeChangedOutputFiles).mockClear();
+    vi.mocked(createTscPlugin).mockClear();
+    await dispose();
+  });
+
+  it("returns success when both esbuild and tsc have no errors", async () => {
+    mockRebuild.mockResolvedValue({
+      errors: [],
+      warnings: [],
+      outputFiles: [],
+      metafile: { inputs: {}, outputs: {} },
+    });
+    mockTscPlugin.getErrors.mockReturnValue(undefined);
+
+    await createContext({ ...baseOptions, tsc: { cwd: "/workspace", output: { dts: true } } });
+    const result = await rebuild();
+
+    expect(result).toEqual({
+      success: true,
+      errors: undefined,
+      warnings: undefined,
+    });
+  });
+
+  it("returns tsc errors only when esbuild succeeds but tsc fails", async () => {
+    mockRebuild.mockResolvedValue({
+      errors: [],
+      warnings: [],
+      outputFiles: [],
+      metafile: { inputs: {}, outputs: {} },
+    });
+    mockTscPlugin.getErrors.mockReturnValue(["TS2322: type mismatch"]);
+
+    await createContext({ ...baseOptions, tsc: { cwd: "/workspace", output: { dts: true } } });
+    const result = await rebuild();
+
+    expect(result).toEqual({
+      success: false,
+      errors: ["TS2322: type mismatch"],
+      warnings: undefined,
+    });
+  });
+
+  it("returns esbuild errors only when esbuild fails but tsc succeeds", async () => {
+    mockRebuild.mockResolvedValue({
+      errors: [{ text: "syntax error" }],
+      warnings: [],
+      outputFiles: [],
+      metafile: undefined,
+    });
+    mockTscPlugin.getErrors.mockReturnValue(undefined);
+
+    await createContext({ ...baseOptions, tsc: { cwd: "/workspace", output: { dts: true } } });
+    const result = await rebuild();
+
+    expect(result).toEqual({
+      success: false,
+      errors: ["syntax error"],
+      warnings: undefined,
+    });
+  });
+
+  it("merges esbuild and tsc errors when both fail", async () => {
+    mockRebuild.mockResolvedValue({
+      errors: [{ text: "esbuild error" }],
+      warnings: [{ text: "warning" }],
+      outputFiles: [],
+      metafile: undefined,
+    });
+    mockTscPlugin.getErrors.mockReturnValue(["tsc error 1", "tsc error 2"]);
+
+    await createContext({ ...baseOptions, tsc: { cwd: "/workspace", output: { dts: true } } });
+    const result = await rebuild();
+
+    expect(result).toEqual({
+      success: false,
+      errors: ["esbuild error", "tsc error 1", "tsc error 2"],
+      warnings: ["warning"],
+    });
+  });
+
+  it("returns esbuild-only result when no tsc plugin exists", async () => {
+    mockRebuild.mockResolvedValue({
+      errors: [{ text: "error" }],
+      warnings: [],
+      outputFiles: [],
+      metafile: undefined,
+    });
+
+    await createContext(baseOptions);
+    const result = await rebuild();
+
+    expect(result).toEqual({
+      success: false,
+      errors: ["error"],
+      warnings: undefined,
+    });
+  });
+});
+
+describe("recreateContext — tsc reset", () => {
+  afterEach(async () => {
+    mockRebuild.mockReset();
+    mockDispose.mockReset();
+    mockTscPlugin.getProgram.mockReset();
+    mockTscPlugin.getAffectedFiles.mockReset();
+    mockTscPlugin.getDiagnostics.mockReset().mockReturnValue([]);
+    mockTscPlugin.getErrors.mockReset();
+    mockTscPlugin.resetBuilderProgram.mockReset();
+    vi.mocked(esbuild.context).mockClear();
+    vi.mocked(writeChangedOutputFiles).mockClear();
+    vi.mocked(createTscPlugin).mockClear();
+    await dispose();
+  });
+
+  it("does not fail when recreateContext is called without tsc plugin", async () => {
+    await createContext(baseOptions);
+
+    await expect(recreateContext(baseOptions)).resolves.not.toThrow();
+    expect(hasContext()).toBe(true);
+  });
 });