@simplysm/sd-cli 13.0.76 → 13.0.77

package/tests/run-lint.spec.ts

@@ -40,19 +40,23 @@ vi.mock("@simplysm/core-node", () => {
     return child.startsWith(parentWithSlash);
   };
   return {
-    fsExists: vi.fn(),
-    fsGlob: vi.fn(),
-    pathPosix: vi.fn(posix),
-    pathIsChildPath: vi.fn(isChildPath),
-    pathFilterByTargets: vi.fn((files: string[], targets: string[], cwd: string) => {
-      if (targets.length === 0) return files;
-      return files.filter((file) => {
-        const relativePath = posix(file.replace(cwd + "/", ""));
-        return targets.some(
-          (target) => relativePath === target || isChildPath(relativePath, target),
-        );
-      });
-    }),
+    fsx: {
+      exists: vi.fn(),
+      glob: vi.fn(),
+    },
+    pathx: {
+      posix: vi.fn(posix),
+      isChildPath: vi.fn(isChildPath),
+      filterByTargets: vi.fn((files: string[], targets: string[], cwd: string) => {
+        if (targets.length === 0) return files;
+        return files.filter((file) => {
+          const relativePath = posix(file.replace(cwd + "/", ""));
+          return targets.some(
+            (target) => relativePath === target || isChildPath(relativePath, target),
+          );
+        });
+      }),
+    },
   };
 });
 
@@ -81,7 +85,7 @@ vi.mock("consola", () => {
   };
 });
 
-import { fsExists, fsGlob } from "@simplysm/core-node";
+import { fsx } from "@simplysm/core-node";
 import { runLint, executeLint } from "../src/commands/lint";
 
 describe("runLint", () => {
@@ -108,7 +112,7 @@ describe("runLint", () => {
 
   it("sets exitCode to 1 when lint errors occur", async () => {
     const cwd = "/project";
-    vi.mocked(fsExists).mockImplementation((filePath: string) => {
+    vi.mocked(fsx.exists).mockImplementation((filePath: string) => {
       return Promise.resolve(filePath === path.join(cwd, "eslint.config.ts"));
     });
 
@@ -116,7 +120,7 @@ describe("runLint", () => {
       default: [{ ignores: ["node_modules/**"] }],
     });
 
-    vi.mocked(fsGlob).mockResolvedValue(["/project/src/index.ts"]);
+    vi.mocked(fsx.glob).mockResolvedValue(["/project/src/index.ts"]);
 
     mockState.lintResults = [{ errorCount: 2, warningCount: 0 }];
 
@@ -127,7 +131,7 @@ describe("runLint", () => {
 
   it("does not set exitCode when no lint errors", async () => {
     const cwd = "/project";
-    vi.mocked(fsExists).mockImplementation((filePath: string) => {
+    vi.mocked(fsx.exists).mockImplementation((filePath: string) => {
       return Promise.resolve(filePath === path.join(cwd, "eslint.config.ts"));
     });
 
@@ -135,7 +139,7 @@ describe("runLint", () => {
       default: [{ ignores: ["node_modules/**"] }],
     });
 
-    vi.mocked(fsGlob).mockResolvedValue(["/project/src/index.ts"]);
+    vi.mocked(fsx.glob).mockResolvedValue(["/project/src/index.ts"]);
 
     mockState.lintResults = [{ errorCount: 0, warningCount: 0 }];
 
@@ -146,7 +150,7 @@ describe("runLint", () => {
 
   it("filters files using targets option", async () => {
     const cwd = "/project";
-    vi.mocked(fsExists).mockImplementation((filePath: string) => {
+    vi.mocked(fsx.exists).mockImplementation((filePath: string) => {
       return Promise.resolve(filePath === path.join(cwd, "eslint.config.ts"));
     });
 
@@ -154,7 +158,7 @@ describe("runLint", () => {
       default: [{ ignores: ["node_modules/**"] }],
     });
 
-    vi.mocked(fsGlob).mockResolvedValue([
+    vi.mocked(fsx.glob).mockResolvedValue([
       "/project/packages/core-common/src/index.ts",
       "/project/packages/core-node/src/index.ts",
       "/project/packages/cli/src/index.ts",
@@ -174,7 +178,7 @@ describe("runLint", () => {
 
   it("filters files from all paths when multiple targets specified", async () => {
     const cwd = "/project";
-    vi.mocked(fsExists).mockImplementation((filePath: string) => {
+    vi.mocked(fsx.exists).mockImplementation((filePath: string) => {
       return Promise.resolve(filePath === path.join(cwd, "eslint.config.ts"));
     });
 
@@ -182,7 +186,7 @@ describe("runLint", () => {
       default: [{ ignores: ["node_modules/**"] }],
     });
 
-    vi.mocked(fsGlob).mockResolvedValue([
+    vi.mocked(fsx.glob).mockResolvedValue([
       "/project/packages/core-common/src/index.ts",
       "/project/packages/core-node/src/index.ts",
       "/project/packages/cli/src/index.ts",
@@ -206,7 +210,7 @@ describe("runLint", () => {
 
   it("calls ESLint.outputFixes when fix option is enabled", async () => {
     const cwd = "/project";
-    vi.mocked(fsExists).mockImplementation((filePath: string) => {
+    vi.mocked(fsx.exists).mockImplementation((filePath: string) => {
       return Promise.resolve(filePath === path.join(cwd, "eslint.config.ts"));
     });
 
@@ -214,7 +218,7 @@ describe("runLint", () => {
       default: [{ ignores: ["node_modules/**"] }],
     });
 
-    vi.mocked(fsGlob).mockResolvedValue(["/project/src/index.ts"]);
+    vi.mocked(fsx.glob).mockResolvedValue(["/project/src/index.ts"]);
 
     mockState.lintResults = [{ errorCount: 0, warningCount: 0 }];
 
@@ -225,7 +229,7 @@ describe("runLint", () => {
 
   it("exits early when no files to lint", async () => {
     const cwd = "/project";
-    vi.mocked(fsExists).mockImplementation((filePath: string) => {
+    vi.mocked(fsx.exists).mockImplementation((filePath: string) => {
       return Promise.resolve(filePath === path.join(cwd, "eslint.config.ts"));
     });
 
@@ -233,7 +237,7 @@ describe("runLint", () => {
       default: [{ ignores: ["node_modules/**"] }],
     });
 
-    vi.mocked(fsGlob).mockResolvedValue([]);
+    vi.mocked(fsx.glob).mockResolvedValue([]);
 
     await runLint({ targets: [], fix: false, timing: false });
 
@@ -244,7 +248,7 @@ describe("runLint", () => {
 
   it("throws error when ESLint config file is not found", async () => {
     // When all config files are missing
-    vi.mocked(fsExists).mockResolvedValue(false);
+    vi.mocked(fsx.exists).mockResolvedValue(false);
 
     await expect(runLint({ targets: [], fix: false, timing: false })).rejects.toThrow(
       "Cannot find ESLint config file",
@@ -257,7 +261,7 @@ describe("runLint", () => {
 
   it("sets TIMING environment variable when timing option is enabled", async () => {
     const cwd = "/project";
-    vi.mocked(fsExists).mockImplementation((filePath: string) => {
+    vi.mocked(fsx.exists).mockImplementation((filePath: string) => {
       return Promise.resolve(filePath === path.join(cwd, "eslint.config.ts"));
     });
 
@@ -265,7 +269,7 @@ describe("runLint", () => {
       default: [{ ignores: ["node_modules/**"] }],
     });
 
-    vi.mocked(fsGlob).mockResolvedValue(["/project/src/index.ts"]);
+    vi.mocked(fsx.glob).mockResolvedValue(["/project/src/index.ts"]);
 
     mockState.lintResults = [{ errorCount: 0, warningCount: 0 }];
 
@@ -287,7 +291,7 @@ describe("runLint", () => {
 
   it("uses eslint.config.mts when eslint.config.ts is not found", async () => {
     const cwd = "/project";
-    vi.mocked(fsExists).mockImplementation((filePath: string) => {
+    vi.mocked(fsx.exists).mockImplementation((filePath: string) => {
       // eslint.config.ts does not exist, only eslint.config.mts
       return Promise.resolve(filePath === path.join(cwd, "eslint.config.mts"));
     });
@@ -296,7 +300,7 @@ describe("runLint", () => {
       default: [{ ignores: ["dist/**"] }],
     });
 
-    vi.mocked(fsGlob).mockResolvedValue(["/project/src/index.ts"]);
+    vi.mocked(fsx.glob).mockResolvedValue(["/project/src/index.ts"]);
 
     mockState.lintResults = [{ errorCount: 0, warningCount: 0 }];
 
@@ -324,7 +328,7 @@ describe("executeLint", () => {
 
     // Default ESLint config mock
     const cwd = "/project";
-    vi.mocked(fsExists).mockImplementation((filePath: string) => {
+    vi.mocked(fsx.exists).mockImplementation((filePath: string) => {
       return Promise.resolve(filePath === path.join(cwd, "eslint.config.ts"));
     });
     mockJitiImportFn.mockResolvedValue({
@@ -339,7 +343,7 @@ describe("executeLint", () => {
 
   it("returns success result when no errors", async () => {
     mockState.lintResults = [{ errorCount: 0, warningCount: 0 }];
-    vi.mocked(fsGlob).mockResolvedValue(["/project/packages/core-common/src/index.ts"]);
+    vi.mocked(fsx.glob).mockResolvedValue(["/project/packages/core-common/src/index.ts"]);
 
     const result = await executeLint({ targets: [], fix: false, timing: false });
 
@@ -350,7 +354,7 @@ describe("executeLint", () => {
 
   it("returns failure result when errors exist", async () => {
     mockState.lintResults = [{ errorCount: 2, warningCount: 1 }];
-    vi.mocked(fsGlob).mockResolvedValue(["/project/packages/core-common/src/index.ts"]);
+    vi.mocked(fsx.glob).mockResolvedValue(["/project/packages/core-common/src/index.ts"]);
 
     const result = await executeLint({ targets: [], fix: false, timing: false });
 

package/tests/run-typecheck.spec.ts

@@ -49,21 +49,25 @@ vi.mock("@simplysm/core-node", () => {
   });
 
   return {
-    fsExists: vi.fn(),
-    fsExistsSync: vi.fn(() => false),
-    fsReadJson: vi.fn(),
-    fsReadSync: vi.fn(() => ""),
-    pathPosix: vi.fn(posix),
-    pathIsChildPath: vi.fn(isChildPath),
-    pathFilterByTargets: vi.fn((files: string[], targets: string[], cwd: string) => {
-      if (targets.length === 0) return files;
-      return files.filter((file) => {
-        const relativePath = posix(file.replace(cwd + "/", ""));
-        return targets.some(
-          (target) => relativePath === target || isChildPath(relativePath, target),
-        );
-      });
-    }),
+    fsx: {
+      exists: vi.fn(),
+      existsSync: vi.fn(() => false),
+      readJson: vi.fn(),
+      readSync: vi.fn(() => ""),
+    },
+    pathx: {
+      posix: vi.fn(posix),
+      isChildPath: vi.fn(isChildPath),
+      filterByTargets: vi.fn((files: string[], targets: string[], cwd: string) => {
+        if (targets.length === 0) return files;
+        return files.filter((file) => {
+          const relativePath = posix(file.replace(cwd + "/", ""));
+          return targets.some(
+            (target) => relativePath === target || isChildPath(relativePath, target),
+          );
+        });
+      }),
+    },
     Worker: {
       create: vi.fn(() => createMockWorkerProxy()),
     },
@@ -98,9 +102,40 @@ vi.mock("jiti", () => ({
 
 import path from "path";
 import ts from "typescript";
-import { fsExists, fsReadJson } from "@simplysm/core-node";
+import { fsx } from "@simplysm/core-node";
 import { runTypecheck } from "../src/commands/typecheck";
 
+/**
+ * Create mock parsed tsconfig
+ */
+function createMockParsedCommandLine(overrides: Partial<ts.ParsedCommandLine> = {}): ts.ParsedCommandLine {
+  return {
+    options: {},
+    fileNames: [],
+    errors: [],
+    ...overrides,
+  } as ts.ParsedCommandLine;
+}
+
+/**
+ * Create mock diagnostic array
+ */
+function createMockDiagnosticArray(diagnostics: ts.Diagnostic[] = []): ts.SortedReadonlyArray<ts.Diagnostic> {
+  return ts.sortAndDeduplicateDiagnostics(diagnostics);
+}
+
+/**
+ * Create mock Worker
+ */
+function createMockWorker<T extends Record<string, unknown>>(overrides?: Partial<T>): any {
+  return {
+    on: vi.fn(),
+    send: vi.fn(),
+    terminate: vi.fn().mockResolvedValue(undefined),
+    ...overrides,
+  };
+}
+
 describe("runTypecheck", () => {
   let originalExitCode: typeof process.exitCode;
   let originalCwd: () => string;
@@ -123,11 +158,13 @@ describe("runTypecheck", () => {
       config: {},
     });
 
-    vi.mocked(ts.parseJsonConfigFileContent).mockReturnValue({
-      options: { lib: ["ES2024"], types: [] },
-      fileNames: [],
-      errors: [],
-    } as unknown as ts.ParsedCommandLine);
+    vi.mocked(ts.parseJsonConfigFileContent).mockReturnValue(
+      createMockParsedCommandLine({
+        options: { lib: ["ES2024"], types: [] },
+        fileNames: [],
+        errors: [],
+      }),
+    );
 
     await runTypecheck({ targets: [], options: [] });
 
@@ -154,11 +191,13 @@ describe("runTypecheck", () => {
       config: {},
     });
 
-    vi.mocked(ts.parseJsonConfigFileContent).mockReturnValue({
-      options: {},
-      fileNames: [],
-      errors: [{ category: ts.DiagnosticCategory.Error, messageText: "Parse error" }],
-    } as unknown as ts.ParsedCommandLine);
+    vi.mocked(ts.parseJsonConfigFileContent).mockReturnValue(
+      createMockParsedCommandLine({
+        options: {},
+        fileNames: [],
+        errors: [{ category: ts.DiagnosticCategory.Error, messageText: "Parse error", code: 0, file: undefined, start: undefined, length: undefined } as ts.Diagnostic],
+      }),
+    );
 
     vi.mocked(ts.formatDiagnosticsWithColorAndContext).mockReturnValue("");
 
@@ -172,21 +211,23 @@ describe("runTypecheck", () => {
       config: {},
     });
 
-    vi.mocked(ts.parseJsonConfigFileContent).mockReturnValue({
-      options: { lib: ["ES2024"], types: [] },
-      fileNames: [
-        "/project/packages/core-common/src/index.ts",
-        "/project/packages/core-node/src/index.ts",
-        "/project/packages/cli/src/index.ts",
-      ],
-      errors: [],
-    } as unknown as ts.ParsedCommandLine);
+    vi.mocked(ts.parseJsonConfigFileContent).mockReturnValue(
+      createMockParsedCommandLine({
+        options: { lib: ["ES2024"], types: [] },
+        fileNames: [
+          "/project/packages/core-common/src/index.ts",
+          "/project/packages/core-node/src/index.ts",
+          "/project/packages/cli/src/index.ts",
+        ],
+        errors: [],
+      }),
+    );
 
-    vi.mocked(fsExists).mockResolvedValue(false);
-    vi.mocked(fsReadJson).mockResolvedValue({ devDependencies: {} });
+    vi.mocked(fsx.exists).mockResolvedValue(false);
+    vi.mocked(fsx.readJson).mockResolvedValue({ devDependencies: {} });
 
     vi.mocked(ts.sortAndDeduplicateDiagnostics).mockReturnValue(
-      [] as unknown as ts.SortedReadonlyArray<ts.Diagnostic>,
+      createMockDiagnosticArray([]),
     );
 
     await runTypecheck({
@@ -203,19 +244,21 @@ describe("runTypecheck", () => {
       config: {},
     });
 
-    vi.mocked(ts.parseJsonConfigFileContent).mockReturnValue({
-      options: { lib: ["ES2024"], types: [] },
-      fileNames: [
-        "/project/packages/core-common/src/index.ts",
-        "/project/packages/core-common/tests/utils.spec.ts",
-        "/project/packages/core-node/src/index.ts",
-        "/project/packages/cli/src/index.ts",
-      ],
-      errors: [],
-    } as unknown as ts.ParsedCommandLine);
+    vi.mocked(ts.parseJsonConfigFileContent).mockReturnValue(
+      createMockParsedCommandLine({
+        options: { lib: ["ES2024"], types: [] },
+        fileNames: [
+          "/project/packages/core-common/src/index.ts",
+          "/project/packages/core-common/tests/utils.spec.ts",
+          "/project/packages/core-node/src/index.ts",
+          "/project/packages/cli/src/index.ts",
+        ],
+        errors: [],
+      }),
+    );
 
-    vi.mocked(fsExists).mockResolvedValue(false);
-    vi.mocked(fsReadJson).mockResolvedValue({ devDependencies: {} });
+    vi.mocked(fsx.exists).mockResolvedValue(false);
+    vi.mocked(fsx.readJson).mockResolvedValue({ devDependencies: {} });
 
     const { Worker } = await import("@simplysm/core-node");
     const mockBuildDts = vi.fn(() =>
@@ -226,13 +269,15 @@ describe("runTypecheck", () => {
         warningCount: 0,
       }),
     );
-    vi.mocked(Worker.create).mockReturnValue({
-      build: mockBuildDts,
-      terminate: vi.fn(() => Promise.resolve()),
-    } as unknown as ReturnType<typeof Worker.create>);
+    vi.mocked(Worker.create).mockReturnValue(
+      createMockWorker({
+        build: mockBuildDts,
+        terminate: vi.fn(() => Promise.resolve()),
+      }),
+    );
 
     vi.mocked(ts.sortAndDeduplicateDiagnostics).mockReturnValue(
-      [] as unknown as ts.SortedReadonlyArray<ts.Diagnostic>,
+      createMockDiagnosticArray([]),
     );
 
     await runTypecheck({
@@ -252,16 +297,18 @@ describe("runTypecheck", () => {
       config: {},
     });
 
-    vi.mocked(ts.parseJsonConfigFileContent).mockReturnValue({
-      options: { lib: ["ES2024"], types: [] },
-      fileNames: ["/project/sd.config.ts"],
-      errors: [],
-    } as unknown as ts.ParsedCommandLine);
+    vi.mocked(ts.parseJsonConfigFileContent).mockReturnValue(
+      createMockParsedCommandLine({
+        options: { lib: ["ES2024"], types: [] },
+        fileNames: ["/project/sd.config.ts"],
+        errors: [],
+      }),
+    );
 
-    vi.mocked(fsExists).mockResolvedValue(false);
+    vi.mocked(fsx.exists).mockResolvedValue(false);
 
     vi.mocked(ts.sortAndDeduplicateDiagnostics).mockReturnValue(
-      [] as unknown as ts.SortedReadonlyArray<ts.Diagnostic>,
+      createMockDiagnosticArray([]),
     );
 
     // Should proceed without error even if sd.config.ts fails to load
@@ -273,38 +320,42 @@ describe("runTypecheck", () => {
   it("sets exitCode to 1 when typecheck errors occur", async () => {
     vi.mocked(ts.readConfigFile).mockReturnValue({ config: {} });
 
-    vi.mocked(ts.parseJsonConfigFileContent).mockReturnValue({
-      options: { lib: ["ES2024"], types: [] },
-      fileNames: ["/project/packages/core-common/src/index.ts"],
-      errors: [],
-    } as unknown as ts.ParsedCommandLine);
+    vi.mocked(ts.parseJsonConfigFileContent).mockReturnValue(
+      createMockParsedCommandLine({
+        options: { lib: ["ES2024"], types: [] },
+        fileNames: ["/project/packages/core-common/src/index.ts"],
+        errors: [],
+      }),
+    );
 
-    vi.mocked(fsExists).mockResolvedValue(false);
-    vi.mocked(fsReadJson).mockResolvedValue({ devDependencies: {} });
+    vi.mocked(fsx.exists).mockResolvedValue(false);
+    vi.mocked(fsx.readJson).mockResolvedValue({ devDependencies: {} });
 
     // Mock Worker to return error results
     const { Worker } = await import("@simplysm/core-node");
-    vi.mocked(Worker.create).mockReturnValue({
-      build: vi.fn(() =>
-        Promise.resolve({
-          success: false,
-          diagnostics: [
-            {
-              category: 1,
-              code: 2322,
-              messageText: "Type error",
-              fileName: "/project/packages/core-common/src/index.ts",
-            },
-          ],
-          errorCount: 1,
-          warningCount: 0,
-        }),
-      ),
-      terminate: vi.fn(() => Promise.resolve()),
-    } as unknown as ReturnType<typeof Worker.create>);
+    vi.mocked(Worker.create).mockReturnValue(
+      createMockWorker({
+        build: vi.fn(() =>
+          Promise.resolve({
+            success: false,
+            diagnostics: [
+              {
+                category: 1,
+                code: 2322,
+                messageText: "Type error",
+                fileName: "/project/packages/core-common/src/index.ts",
+              },
+            ],
+            errorCount: 1,
+            warningCount: 0,
+          }),
+        ),
+        terminate: vi.fn(() => Promise.resolve()),
+      }),
+    );
 
     vi.mocked(ts.sortAndDeduplicateDiagnostics).mockReturnValue(
-      [] as unknown as ts.SortedReadonlyArray<ts.Diagnostic>,
+      createMockDiagnosticArray([]),
     );
     vi.mocked(ts.formatDiagnosticsWithColorAndContext).mockReturnValue("");
 
@@ -316,15 +367,17 @@ describe("runTypecheck", () => {
   it("creates other task when non-package files (like tests/) are included", async () => {
     vi.mocked(ts.readConfigFile).mockReturnValue({ config: {} });
 
-    vi.mocked(ts.parseJsonConfigFileContent).mockReturnValue({
-      options: { lib: ["ES2024"], types: [] },
-      fileNames: ["/project/packages/core-node/src/index.ts", "/project/tests/orm/some-test.ts"],
-      errors: [],
-    } as unknown as ts.ParsedCommandLine);
+    vi.mocked(ts.parseJsonConfigFileContent).mockReturnValue(
+      createMockParsedCommandLine({
+        options: { lib: ["ES2024"], types: [] },
+        fileNames: ["/project/packages/core-node/src/index.ts", "/project/tests/orm/some-test.ts"],
+        errors: [],
+      }),
+    );
 
-    vi.mocked(fsExists).mockResolvedValue(false);
+    vi.mocked(fsx.exists).mockResolvedValue(false);
     // Set core-node as node target package
-    vi.mocked(fsReadJson).mockImplementation((filePath: string) => {
+    vi.mocked(fsx.readJson).mockImplementation((filePath: string) => {
       if (filePath.includes("core-node")) {
         return Promise.resolve({ name: "@simplysm/core-node" });
       }
@@ -341,7 +394,7 @@ describe("runTypecheck", () => {
     });
 
     vi.mocked(ts.sortAndDeduplicateDiagnostics).mockReturnValue(
-      [] as unknown as ts.SortedReadonlyArray<ts.Diagnostic>,
+      createMockDiagnosticArray([]),
     );
 
     const { Worker } = await import("@simplysm/core-node");
@@ -353,10 +406,12 @@ describe("runTypecheck", () => {
         warningCount: 0,
       }),
     );
-    vi.mocked(Worker.create).mockReturnValue({
-      build: mockBuildDts,
-      terminate: vi.fn(() => Promise.resolve()),
-    } as unknown as ReturnType<typeof Worker.create>);
+    vi.mocked(Worker.create).mockReturnValue(
+      createMockWorker({
+        build: mockBuildDts,
+        terminate: vi.fn(() => Promise.resolve()),
+      }),
+    );
 
     await runTypecheck({ targets: [], options: [] });
 
@@ -406,23 +461,25 @@ describe("executeTypecheck", () => {
       errors: [],
     } as never);
 
-    vi.mocked(fsExists).mockResolvedValue(false);
-    vi.mocked(fsReadJson).mockResolvedValue({ devDependencies: {} });
-
-    vi.mocked(Worker.create).mockReturnValue({
-      build: vi.fn(() =>
-        Promise.resolve({
-          success: true,
-          diagnostics: [],
-          errorCount: 0,
-          warningCount: 0,
-        }),
-      ),
-      terminate: vi.fn(() => Promise.resolve()),
-    } as unknown as ReturnType<typeof Worker.create>);
+    vi.mocked(fsx.exists).mockResolvedValue(false);
+    vi.mocked(fsx.readJson).mockResolvedValue({ devDependencies: {} });
+
+    vi.mocked(Worker.create).mockReturnValue(
+      createMockWorker({
+        build: vi.fn(() =>
+          Promise.resolve({
+            success: true,
+            diagnostics: [],
+            errorCount: 0,
+            warningCount: 0,
+          }),
+        ),
+        terminate: vi.fn(() => Promise.resolve()),
+      }),
+    );
 
     vi.mocked(ts.sortAndDeduplicateDiagnostics).mockReturnValue(
-      [] as unknown as ts.SortedReadonlyArray<ts.Diagnostic>,
+      createMockDiagnosticArray([]),
     );
 
     const result = await executeTypecheck({ targets: [], options: [] });
@@ -444,28 +501,30 @@ describe("executeTypecheck", () => {
       errors: [],
     } as never);
 
-    vi.mocked(fsExists).mockResolvedValue(false);
-    vi.mocked(fsReadJson).mockResolvedValue({ devDependencies: {} });
+    vi.mocked(fsx.exists).mockResolvedValue(false);
+    vi.mocked(fsx.readJson).mockResolvedValue({ devDependencies: {} });
 
     // Mock worker to return error results
-    vi.mocked(Worker.create).mockReturnValue({
-      build: vi.fn(() =>
-        Promise.resolve({
-          success: false,
-          diagnostics: [
-            {
-              category: 1,
-              code: 2322,
-              messageText: "Type error",
-              fileName: "/project/packages/core-common/src/index.ts",
-            },
-          ],
-          errorCount: 1,
-          warningCount: 0,
-        }),
-      ),
-      terminate: vi.fn(() => Promise.resolve()),
-    } as unknown as ReturnType<typeof Worker.create>);
+    vi.mocked(Worker.create).mockReturnValue(
+      createMockWorker({
+        build: vi.fn(() =>
+          Promise.resolve({
+            success: false,
+            diagnostics: [
+              {
+                category: 1,
+                code: 2322,
+                messageText: "Type error",
+                fileName: "/project/packages/core-common/src/index.ts",
+              },
+            ],
+            errorCount: 1,
+            warningCount: 0,
+          }),
+        ),
+        terminate: vi.fn(() => Promise.resolve()),
+      }),
+    );
 
     vi.mocked(ts.sortAndDeduplicateDiagnostics).mockImplementation(
       (diagnostics) => diagnostics as ts.SortedReadonlyArray<ts.Diagnostic>,