@simplysm/sd-cli 14.0.64 → 14.0.65

package/tests/commands/git-phase.acc.spec.ts

@@ -1,18 +1,11 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
+import { cpx } from "@simplysm/core-node";
 
-const mocks = vi.hoisted(() => ({
-  execa: vi.fn(),
-}));
+const mocks = {
+  execa: vi.spyOn(cpx, "spawn"),
+};
 
-vi.mock("@simplysm/core-node", () => ({
-  cpx: {
-    spawn: mocks.execa,
-  },
-}));
-
-const { ensureCleanWorkingTree, commitTagAndPush } = await import(
-  "../../src/commands/publish/git-phase"
-);
+import { ensureCleanWorkingTree, commitTagAndPush } from "../../src/commands/publish/git-phase";
 
 function createLogger() {
   return {
@@ -29,65 +22,23 @@ describe("ensureCleanWorkingTree", () => {
     vi.clearAllMocks();
   });
 
-  it("auto-commits with codex when uncommitted changes detected", async () => {
-    const logger = createLogger();
-    mocks.execa.mockImplementation((cmd: string, args?: string[]) => {
-      if (cmd === "git" && args?.[0] === "diff") {
-        return { stdout: "file.txt", stderr: "", exitCode: 0 };
-      }
-      return { stdout: "", stderr: "", exitCode: 0 };
-    });
-
-    await ensureCleanWorkingTree(true, logger);
-
-    const codexCalls = mocks.execa.mock.calls.filter(
-      (c: unknown[]) => c[0] === "codex",
-    );
-    expect(codexCalls).toHaveLength(1);
-    expect((codexCalls[0][1] as string[])).toContain("exec");
-    expect((codexCalls[0][1] as string[])).toContain("gpt-5.3-codex-spark");
-    expect((codexCalls[0][1] as string[])).toContain('model_reasoning_effort="low"');
-    expect((codexCalls[0][1] as string[]).some((arg) => arg.includes("$sd-commit"))).toBe(true);
-  });
-
-  it("skips auto-commit when no uncommitted changes", async () => {
+  it("throws when auto-commit fails", async () => {
     const logger = createLogger();
-    mocks.execa.mockImplementation(() => {
-      return { stdout: "", stderr: "", exitCode: 0 };
-    });
-
-    await ensureCleanWorkingTree(true, logger);
-
-    const codexCalls = mocks.execa.mock.calls.filter(
-      (c: unknown[]) => c[0] === "codex",
-    );
-    expect(codexCalls).toHaveLength(0);
-  });
-
-  it("throws when codex auto-commit fails", async () => {
-    const logger = createLogger();
-    mocks.execa.mockImplementation((cmd: string, args?: string[]) => {
+    mocks.execa.mockImplementation(((cmd: string, args?: string[]) => {
       if (cmd === "git" && args?.[0] === "diff") {
         return { stdout: "file.txt", stderr: "", exitCode: 0 };
       }
-      if (cmd === "codex") {
-        throw new Error("codex commit failed");
+      // 자동 커밋 명령 실패 시뮬레이션
+      if (cmd !== "git") {
+        throw new Error("auto-commit failed");
       }
       return { stdout: "", stderr: "", exitCode: 0 };
-    });
+    }) as never);
 
     await expect(ensureCleanWorkingTree(true, logger)).rejects.toThrow(
       "자동 커밋에 실패했습니다",
     );
   });
-
-  it("does nothing when hasGit is false", async () => {
-    const logger = createLogger();
-
-    await ensureCleanWorkingTree(false, logger);
-
-    expect(mocks.execa).not.toHaveBeenCalled();
-  });
 });
 
 describe("commitTagAndPush", () => {
@@ -95,67 +46,17 @@ describe("commitTagAndPush", () => {
     vi.clearAllMocks();
   });
 
-  it("commits, tags, and pushes version changes", async () => {
-    const logger = createLogger();
-    mocks.execa.mockResolvedValue({ stdout: "", stderr: "", exitCode: 0 });
-
-    await commitTagAndPush(true, "14.0.1", ["package.json"], logger, false);
-
-    const gitCalls = mocks.execa.mock.calls.filter(
-      (c: unknown[]) => c[0] === "git",
-    );
-
-    // git add
-    const addCall = gitCalls.find((c: unknown[]) => (c[1] as string[])[0] === "add");
-    expect(addCall).toBeDefined();
-    expect((addCall![1] as string[])).toContain("package.json");
-
-    // git commit
-    const commitCall = gitCalls.find((c: unknown[]) => (c[1] as string[])[0] === "commit");
-    expect(commitCall).toBeDefined();
-    expect((commitCall![1] as string[])).toContain("v14.0.1");
-
-    // git tag
-    const tagCall = gitCalls.find((c: unknown[]) => (c[1] as string[])[0] === "tag");
-    expect(tagCall).toBeDefined();
-    expect((tagCall![1] as string[])).toContain("-a");
-    expect((tagCall![1] as string[])).toContain("v14.0.1");
-
-    // git push (2 calls: push + push --tags)
-    const pushCalls = gitCalls.filter((c: unknown[]) => (c[1] as string[])[0] === "push");
-    expect(pushCalls).toHaveLength(2);
-  });
-
-  it("outputs simulation logs in dry-run mode without executing git", async () => {
-    const logger = createLogger();
-
-    await commitTagAndPush(true, "14.0.1", ["package.json"], logger, true);
-
-    // No actual git commands
-    expect(mocks.execa).not.toHaveBeenCalled();
-    // Simulation logs
-    expect(logger.info).toHaveBeenCalled();
-  });
-
   it("throws with recovery guide when git commit fails", async () => {
     const logger = createLogger();
-    mocks.execa.mockImplementation((_cmd: string, args?: string[]) => {
+    mocks.execa.mockImplementation(((_cmd: string, args?: string[]) => {
       if (args?.[0] === "commit") {
         throw new Error("git commit failed");
       }
       return { stdout: "", stderr: "", exitCode: 0 };
-    });
+    }) as never);
 
     await expect(
       commitTagAndPush(true, "14.0.1", ["package.json"], logger, false),
     ).rejects.toThrow("Git 작업 실패");
   });
-
-  it("does nothing when hasGit is false", async () => {
-    const logger = createLogger();
-
-    await commitTagAndPush(false, "14.0.1", ["package.json"], logger, false);
-
-    expect(mocks.execa).not.toHaveBeenCalled();
-  });
 });

package/tests/commands/lint.spec.ts

@@ -1,33 +1,17 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-
-//#region Mocks
-
-const mocks = vi.hoisted(() => ({
-  executeLint: vi.fn(),
-}));
-
-vi.mock("../../src/lint/lint-core", () => ({
-  executeLint: mocks.executeLint,
-}));
-
-const { runLint } = await import("../../src/commands/lint");
-
-//#endregion
-
-//#region runLint
+import * as lintCore from "../../src/lint/lint-core";
+import { runLint } from "../../src/commands/lint";
 
 describe("runLint", () => {
   let savedExitCode: typeof process.exitCode;
   let writeSpy: ReturnType<typeof vi.spyOn>;
+  let executeLintSpy: ReturnType<typeof vi.spyOn>;
 
   beforeEach(() => {
-    vi.clearAllMocks();
     savedExitCode = process.exitCode;
     process.exitCode = undefined;
     writeSpy = vi.spyOn(process.stdout, "write").mockReturnValue(true);
-
-    // Default: successful lint
-    mocks.executeLint.mockResolvedValue({
+    executeLintSpy = vi.spyOn(lintCore, "executeLint").mockResolvedValue({
       success: true,
       errorCount: 0,
       warningCount: 0,
@@ -38,10 +22,11 @@ describe("runLint", () => {
   afterEach(() => {
     process.exitCode = savedExitCode;
     writeSpy.mockRestore();
+    executeLintSpy.mockRestore();
   });
 
   it("writes formatted output to stdout when there are results", async () => {
-    mocks.executeLint.mockResolvedValue({
+    executeLintSpy.mockResolvedValue({
       success: false,
       errorCount: 1,
       warningCount: 0,
@@ -54,7 +39,7 @@ describe("runLint", () => {
   });
 
   it("sets exitCode to 1 when lint errors are found", async () => {
-    mocks.executeLint.mockResolvedValue({
+    executeLintSpy.mockResolvedValue({
       success: false,
       errorCount: 1,
       warningCount: 0,
@@ -78,5 +63,3 @@ describe("runLint", () => {
     expect(writeSpy).not.toHaveBeenCalled();
   });
 });
-
-//#endregion

package/tests/commands/post-publish-phase.acc.spec.ts

@@ -1,16 +1,11 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
+import { cpx } from "@simplysm/core-node";
 
-const mocks = vi.hoisted(() => ({
-  execa: vi.fn(),
-}));
+const mocks = {
+  execa: vi.spyOn(cpx, "spawn"),
+};
 
-vi.mock("@simplysm/core-node", () => ({
-  cpx: {
-    spawn: mocks.execa,
-  },
-}));
-
-const { runPostPublish } = await import("../../src/commands/publish/post-publish-phase");
+import { runPostPublish } from "../../src/commands/publish/post-publish-phase";
 
 function createLogger() {
   return {

package/tests/commands/typecheck.spec.ts

@@ -1,60 +1,28 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
 import { consola } from "consola";
 
-const mocks = vi.hoisted(() => ({
-  loadSdConfig: vi.fn(),
-  deserializeDiagnostic: vi.fn((d: any) => d),
-  typecheckNonPackageFiles: vi.fn(),
-  createTypecheckEngine: vi.fn(),
-  discoverWorkspacePackages: vi.fn(),
-  mergeTestsPackagesIntoConfig: vi.fn(),
-}));
+import * as sdConfigMod from "../../src/utils/sd-config";
+import * as typecheckSerialization from "../../src/typecheck/typecheck-serialization";
+import * as typecheckNonPackage from "../../src/typecheck/typecheck-non-package";
+import * as engineFactory from "../../src/engines/engine-factory";
+import * as packageUtils from "../../src/utils/package-utils";
+
+import { executeTypecheck } from "../../src/commands/typecheck";
+
+const mocks = {
+  loadSdConfig: undefined as unknown as ReturnType<typeof vi.spyOn>,
+  deserializeDiagnostic: undefined as unknown as ReturnType<typeof vi.spyOn>,
+  typecheckNonPackageFiles: undefined as unknown as ReturnType<typeof vi.spyOn>,
+  createTypecheckEngine: undefined as unknown as ReturnType<typeof vi.spyOn>,
+  discoverWorkspacePackages: undefined as unknown as ReturnType<typeof vi.spyOn>,
+  mergeTestsPackagesIntoConfig: undefined as unknown as ReturnType<typeof vi.spyOn>,
+};
 
 const mockEngines: Array<{
   run: ReturnType<typeof vi.fn>;
   stop: ReturnType<typeof vi.fn>;
 }> = [];
 
-vi.mock("../../src/utils/sd-config", () => ({
-  loadSdConfig: mocks.loadSdConfig,
-}));
-
-vi.mock("../../src/typecheck/typecheck-serialization", () => ({
-  deserializeDiagnostic: mocks.deserializeDiagnostic,
-}));
-
-vi.mock("../../src/typecheck/typecheck-non-package", () => ({
-  typecheckNonPackageFiles: mocks.typecheckNonPackageFiles,
-}));
-
-vi.mock("../../src/engines/engine-factory", () => ({
-  createTypecheckEngine: mocks.createTypecheckEngine,
-}));
-
-vi.mock("../../src/utils/package-utils", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("../../src/utils/package-utils")>();
-  return {
-    ...actual,
-    discoverWorkspacePackages: mocks.discoverWorkspacePackages,
-    mergeTestsPackagesIntoConfig: mocks.mergeTestsPackagesIntoConfig,
-  };
-});
-
-vi.mock("typescript", async (importOriginal) => {
-  const orig = await importOriginal<Record<string, unknown>>();
-  const origDefault = (orig["default"] ?? orig) as Record<string, unknown>;
-  return {
-    ...orig,
-    default: {
-      ...origDefault,
-      sortAndDeduplicateDiagnostics: vi.fn((d: unknown[]) => d),
-      formatDiagnosticsWithColorAndContext: vi.fn((diags: Array<{ messageText: string }>) =>
-        diags.map((d) => `formatted: ${d.messageText}`).join("\n"),
-      ),
-    },
-  };
-});
-
 const mockTypecheckLogger = {
   debug: vi.fn(),
   start: vi.fn(),
@@ -66,22 +34,6 @@ const mockTypecheckLogger = {
   withTag: vi.fn(),
 };
 
-vi.spyOn(consola, "withTag").mockImplementation((tag: string) => {
-  if (tag === "sd:cli:typecheck") return mockTypecheckLogger as any;
-  return {
-    debug: vi.fn(),
-    start: vi.fn(),
-    success: vi.fn(),
-    info: vi.fn(),
-    error: vi.fn(),
-    warn: vi.fn(),
-    log: vi.fn(),
-    withTag: vi.fn(),
-  } as any;
-});
-
-const { executeTypecheck } = await import("../../src/commands/typecheck");
-
 function createMockEngine() {
   const engine = {
     run: vi.fn().mockResolvedValue({
@@ -118,8 +70,34 @@ function setupDefaults(packages: Record<string, any> = {}) {
 }
 
 beforeEach(() => {
-  vi.clearAllMocks();
+  vi.restoreAllMocks();
   mockEngines.length = 0;
+
+  Object.values(mockTypecheckLogger).forEach((m) => {
+    if (typeof m === "function" && "mockReset" in m) (m as any).mockReset();
+  });
+
+  vi.spyOn(consola, "withTag").mockImplementation((tag: string) => {
+    if (tag === "sd:cli:typecheck") return mockTypecheckLogger as any;
+    return {
+      debug: vi.fn(),
+      start: vi.fn(),
+      success: vi.fn(),
+      info: vi.fn(),
+      error: vi.fn(),
+      warn: vi.fn(),
+      log: vi.fn(),
+      withTag: vi.fn(),
+    } as any;
+  });
+
+  mocks.loadSdConfig = vi.spyOn(sdConfigMod, "loadSdConfig");
+  mocks.deserializeDiagnostic = vi.spyOn(typecheckSerialization, "deserializeDiagnostic")
+    .mockImplementation((d: any) => d);
+  mocks.typecheckNonPackageFiles = vi.spyOn(typecheckNonPackage, "typecheckNonPackageFiles");
+  mocks.createTypecheckEngine = vi.spyOn(engineFactory, "createTypecheckEngine");
+  mocks.discoverWorkspacePackages = vi.spyOn(packageUtils, "discoverWorkspacePackages");
+  mocks.mergeTestsPackagesIntoConfig = vi.spyOn(packageUtils, "mergeTestsPackagesIntoConfig");
 });
 
 describe("executeTypecheck", () => {

package/tests/electron/electron.spec.ts

@@ -1,48 +1,12 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
 import { consola } from "consola";
+import { fsx, cpx } from "@simplysm/core-node";
 
-//#region Mocks
-
-// fsx mock
-const mockFsxExists = vi.fn();
-const mockFsxReadJson = vi.fn();
-const mockFsxWriteJson = vi.fn().mockResolvedValue(undefined);
-const mockFsxWrite = vi.fn().mockResolvedValue(undefined);
-const mockFsxMkdir = vi.fn().mockResolvedValue(undefined);
-const mockFsxCopy = vi.fn().mockResolvedValue(undefined);
-const mockFsxReaddir = vi.fn();
-const mockFsxGlob = vi.fn();
-
-vi.mock("@simplysm/core-node", async (importOriginal) => {
-  const original = await importOriginal<typeof import("@simplysm/core-node")>();
-  return {
-    ...original,
-    fsx: {
-      exists: mockFsxExists,
-      readJson: mockFsxReadJson,
-      writeJson: mockFsxWriteJson,
-      write: mockFsxWrite,
-      mkdir: mockFsxMkdir,
-      copy: mockFsxCopy,
-      readdir: mockFsxReaddir,
-      glob: mockFsxGlob,
-    },
-    cpx: {
-      spawn: mockCpxSpawn,
-      spawnSync: vi.fn().mockReturnValue({ stdout: "", stderr: "", exitCode: 0 }),
-    },
-  };
-});
-
-// cpx mock (was execa)
-const mockCpxSpawn = vi.fn().mockResolvedValue({ stdout: "", stderr: "", exitCode: 0 });
-
-// esbuild mock
+// esbuild는 외부 npm으로 ESM namespace immutable이라 vi.mock 유지
 const mockEsbuildBuild = vi.fn().mockResolvedValue({});
 let mockEsbuildOnEndCallback: ((result: { errors: unknown[] }) => void | Promise<void>) | null =
   null;
 const mockEsbuildContext = vi.fn().mockImplementation((options: any) => {
-  // Extract the electron-restart plugin's onEnd callback
   const plugin = options?.plugins?.find((p: any) => p.name === "electron-restart");
   if (plugin != null) {
     plugin.setup({
@@ -53,7 +17,6 @@ const mockEsbuildContext = vi.fn().mockImplementation((options: any) => {
   }
   return {
     watch: vi.fn().mockImplementation(async () => {
-      // Simulate initial build success — trigger onEnd
       if (mockEsbuildOnEndCallback != null) {
         await mockEsbuildOnEndCallback({ errors: [] });
       }
@@ -66,7 +29,20 @@ vi.mock("esbuild", () => ({
   context: mockEsbuildContext,
 }));
 
-// consola mock
+// @simplysm/core-node fsx, cpx는 spy로 전환
+const mockFsxExists = vi.spyOn(fsx, "exists");
+const mockFsxReadJson = vi.spyOn(fsx, "readJson");
+const mockFsxWriteJson = vi.spyOn(fsx, "writeJson").mockResolvedValue(undefined);
+vi.spyOn(fsx, "write").mockResolvedValue(undefined);
+vi.spyOn(fsx, "mkdir").mockResolvedValue(undefined);
+const mockFsxCopy = vi.spyOn(fsx, "copy").mockResolvedValue(undefined);
+const mockFsxReaddir = vi.spyOn(fsx, "readdir");
+const mockFsxGlob = vi.spyOn(fsx, "glob");
+
+const mockCpxSpawn = vi.spyOn(cpx, "spawn").mockResolvedValue({ stdout: "", stderr: "", exitCode: 0 });
+vi.spyOn(cpx, "spawnSync").mockReturnValue({ stdout: "", stderr: "", exitCode: 0 });
+
+// consola spy
 const mockLoggerDebug = vi.fn();
 const mockLoggerWarn = vi.fn();
 const mockLoggerInfo = vi.fn();
@@ -130,8 +106,8 @@ function findBuilderConfig(): Record<string, unknown> | undefined {
 
 function normalizedCopyCalls(): string[][] {
   return mockFsxCopy.mock.calls.map((c) => [
-    (c[0] as string).replace(/\\/g, "/"),
-    (c[1] as string).replace(/\\/g, "/"),
+    c[0].replace(/\\/g, "/"),
+    c[1].replace(/\\/g, "/"),
   ]);
 }
 
@@ -183,13 +159,13 @@ describe("Electron", () => {
 
       const spawnCalls = mockCpxSpawn.mock.calls;
       const installCall = spawnCalls.find(
-        (c) => c[0] === "pnpm" && (c[1] as string[]).includes("install"),
+        (c) => c[0] === "pnpm" && c[1].includes("install"),
       );
       expect(installCall).toBeDefined();
       expect(installCall?.[2]).toEqual(expect.objectContaining({ shell: true }));
       expect(
         spawnCalls.find(
-          (c) => c[0] === "pnpm" && (c[1] as string[]).includes("electron-rebuild"),
+          (c) => c[0] === "pnpm" && c[1].includes("electron-rebuild"),
         ),
       ).toBeDefined();
     });
@@ -201,7 +177,7 @@ describe("Electron", () => {
       await electron.initialize();
 
       const rebuildCall = mockCpxSpawn.mock.calls.find(
-        (c) => c[0] === "pnpm" && (c[1] as string[]).includes("electron-rebuild"),
+        (c) => c[0] === "pnpm" && c[1].includes("electron-rebuild"),
       );
       expect(rebuildCall).toBeUndefined();
     });
@@ -523,7 +499,7 @@ describe("Electron", () => {
       expect(callArgs.bundle).toBe(true);
       expect(callArgs.external).toContain("electron");
       const electronCall = mockCpxSpawn.mock.calls.find(
-        (c) => c[0] === "pnpm" && (c[1] as string[]).includes("electron"),
+        (c) => c[0] === "pnpm" && c[1].includes("electron"),
       );
       expect(electronCall?.[2]).toEqual(expect.objectContaining({ shell: true, reject: false }));
 

package/tests/engines/base-engine.spec.ts

@@ -1,6 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
-
-// --- Mock factories (vi.mock is hoisted) ---
+import { Worker } from "@simplysm/core-node";
 
 const mockWorker = {
   build: vi.fn(),
@@ -10,16 +9,10 @@ const mockWorker = {
   on: vi.fn(),
 };
 
-vi.mock("@simplysm/core-node", () => ({
-  Worker: {
-    create: vi.fn(() => mockWorker),
-  },
-}));
-
-// --- Dynamic imports after mocking ---
+vi.spyOn(Worker, "create").mockReturnValue(mockWorker as any);
 
-const { TscEngine } = await import("../../src/engines/TscEngine");
-const { BaseEngine } = await import("../../src/engines/BaseEngine");
+import { TscEngine } from "../../src/engines/TscEngine";
+import { BaseEngine } from "../../src/engines/BaseEngine";
 
 import type { BuildPackageInfo, BuildOutput } from "../../src/engines/types";
 import type { BuildResult } from "../../src/runtime/ResultCollector";
@@ -64,8 +57,6 @@ describe("BaseEngine", () => {
 
   describe("_createWorker resourceLimits", () => {
     it("Worker.create에 resourceLimits를 전달한다", async () => {
-      const { Worker } = await import("@simplysm/core-node");
-
       const engine = new TscEngine({ cwd: "/root", pkg: createMockPkg() });
       await engine.run({ js: true, dts: true });
 

package/tests/engines/engine-selection.spec.ts

@@ -1,23 +1,20 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
+import { Worker } from "@simplysm/core-node";
 import * as packageUtils from "../../src/utils/package-utils";
 
-vi.mock("@simplysm/core-node", () => ({
-  Worker: {
-    create: vi.fn(() => ({
-      build: vi.fn(),
-      startWatch: vi.fn(),
-      stopWatch: vi.fn(),
-      terminate: vi.fn(),
-      on: vi.fn(),
-    })),
-  },
-}));
-
-const { createBuildEngine, createTypecheckEngine } = await import("../../src/engines/engine-factory");
-const { TscEngine } = await import("../../src/engines/TscEngine");
-const { NgtscEngine } = await import("../../src/engines/NgtscEngine");
-const { ServerEsbuildEngine } = await import("../../src/engines/ServerEsbuildEngine");
-const { EsbuildClientEngine } = await import("../../src/engines/EsbuildClientEngine");
+vi.spyOn(Worker, "create").mockReturnValue({
+  build: vi.fn(),
+  startWatch: vi.fn(),
+  stopWatch: vi.fn(),
+  terminate: vi.fn(),
+  on: vi.fn(),
+} as any);
+
+import { createBuildEngine, createTypecheckEngine } from "../../src/engines/engine-factory";
+import { TscEngine } from "../../src/engines/TscEngine";
+import { NgtscEngine } from "../../src/engines/NgtscEngine";
+import { ServerEsbuildEngine } from "../../src/engines/ServerEsbuildEngine";
+import { EsbuildClientEngine } from "../../src/engines/EsbuildClientEngine";
 
 import type { BuildPackageInfo, ClientPackageInfo, ServerPackageInfo } from "../../src/engines/types";
 

package/tests/engines/engine-typecheck-selection.acc.spec.ts

@@ -1,22 +1,19 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
+import { Worker } from "@simplysm/core-node";
 import * as packageUtils from "../../src/utils/package-utils";
 
-vi.mock("@simplysm/core-node", () => ({
-  Worker: {
-    create: vi.fn(() => ({
-      build: vi.fn(),
-      startWatch: vi.fn(),
-      stopWatch: vi.fn(),
-      terminate: vi.fn(),
-      on: vi.fn(),
-    })),
-  },
-}));
-
-const { createTypecheckEngine } = await import("../../src/engines/engine-factory");
-const { TscEngine } = await import("../../src/engines/TscEngine");
-const { NgtscEngine } = await import("../../src/engines/NgtscEngine");
-const { ServerEsbuildEngine } = await import("../../src/engines/ServerEsbuildEngine");
+vi.spyOn(Worker, "create").mockReturnValue({
+  build: vi.fn(),
+  startWatch: vi.fn(),
+  stopWatch: vi.fn(),
+  terminate: vi.fn(),
+  on: vi.fn(),
+} as any);
+
+import { createTypecheckEngine } from "../../src/engines/engine-factory";
+import { TscEngine } from "../../src/engines/TscEngine";
+import { NgtscEngine } from "../../src/engines/NgtscEngine";
+import { ServerEsbuildEngine } from "../../src/engines/ServerEsbuildEngine";
 
 import type {
   BuildPackageInfo,