@simplysm/sd-cli 13.0.75 → 13.0.77

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,130 +297,21 @@ 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(fsExists).mockResolvedValue(false);
-
-    vi.mocked(ts.sortAndDeduplicateDiagnostics).mockReturnValue(
-      [] as unknown as ts.SortedReadonlyArray<ts.Diagnostic>,
-    );
-
-    // Should proceed without error even if sd.config.ts fails to load
-    await runTypecheck({ targets: [], options: [] });
-
-    expect(process.exitCode).toBeUndefined();
-  });
-
-  it("uses default value when default export is not a function", 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(fsExists).mockResolvedValue(false);
-    vi.mocked(fsReadJson).mockResolvedValue({ devDependencies: {} });
-
-    // When sd.config.ts's default export is an object, not a function
-    mockJitiImport.mockResolvedValue({
-      default: { packages: {} }, // object, not a function
-    });
-
-    vi.mocked(ts.sortAndDeduplicateDiagnostics).mockReturnValue(
-      [] as unknown as ts.SortedReadonlyArray<ts.Diagnostic>,
+    vi.mocked(ts.parseJsonConfigFileContent).mockReturnValue(
+      createMockParsedCommandLine({
+        options: { lib: ["ES2024"], types: [] },
+        fileNames: ["/project/sd.config.ts"],
+        errors: [],
+      }),
     );
 
-    // Should proceed with default value without error
-    await runTypecheck({ targets: [], options: [] });
-
-    expect(process.exitCode).toBeUndefined();
-  });
-
-  it("uses default value when no default export in sd.config.ts", 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(fsExists).mockResolvedValue(false);
-    vi.mocked(fsReadJson).mockResolvedValue({ devDependencies: {} });
-
-    // When sd.config.ts has no default export
-    mockJitiImport.mockResolvedValue({
-      someOtherExport: () => ({}),
-    });
-
-    const { Worker } = await import("@simplysm/core-node");
-    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(ts.sortAndDeduplicateDiagnostics).mockReturnValue(
-      [] as unknown as ts.SortedReadonlyArray<ts.Diagnostic>,
-    );
-
-    // Should proceed with default value without error
-    await runTypecheck({ targets: [], options: [] });
-
-    expect(process.exitCode).toBeUndefined();
-  });
-
-  it("typecheck multiple packages", async () => {
-    vi.mocked(ts.readConfigFile).mockReturnValue({
-      config: {},
-    });
-
-    vi.mocked(ts.parseJsonConfigFileContent).mockReturnValue({
-      options: { lib: ["ES2024", "DOM"], types: [] },
-      fileNames: [
-        "/project/packages/core-node/src/index.ts",
-        "/project/packages/core-browser/src/index.ts",
-        "/project/packages/core-common/src/index.ts",
-      ],
-      errors: [],
-    } as unknown as ts.ParsedCommandLine);
-
-    vi.mocked(fsExists).mockResolvedValue(false);
-    vi.mocked(fsReadJson).mockResolvedValue({ devDependencies: {} });
-
-    const { Worker } = await import("@simplysm/core-node");
-    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(ts.sortAndDeduplicateDiagnostics).mockReturnValue(
-      [] as unknown as ts.SortedReadonlyArray<ts.Diagnostic>,
+      createMockDiagnosticArray([]),
     );
 
+    // Should proceed without error even if sd.config.ts fails to load
     await runTypecheck({ targets: [], options: [] });
 
     expect(process.exitCode).toBeUndefined();
@@ -384,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("");
 
@@ -427,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" });
       }
@@ -452,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");
@@ -464,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: [] });
 
@@ -486,44 +430,6 @@ describe("runTypecheck", () => {
     expect(pkgCall).toBeDefined();
   });
 
-  it("does not create other task when only packages/ files exist", 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(fsExists).mockResolvedValue(false);
-    vi.mocked(fsReadJson).mockResolvedValue({ devDependencies: {} });
-
-    vi.mocked(ts.sortAndDeduplicateDiagnostics).mockReturnValue(
-      [] as unknown as ts.SortedReadonlyArray<ts.Diagnostic>,
-    );
-
-    const { Worker } = await import("@simplysm/core-node");
-    const mockBuildDts = vi.fn(() =>
-      Promise.resolve({
-        success: true,
-        diagnostics: [],
-        errorCount: 0,
-        warningCount: 0,
-      }),
-    );
-    vi.mocked(Worker.create).mockReturnValue({
-      build: mockBuildDts,
-      terminate: vi.fn(() => Promise.resolve()),
-    } as unknown as ReturnType<typeof Worker.create>);
-
-    await runTypecheck({ targets: [], options: [] });
-
-    // Should have no call with name="root"
-    const nonPkgCall = (mockBuildDts.mock.calls as unknown[][]).find(
-      (call) => (call[0] as { name: string }).name === "root",
-    );
-    expect(nonPkgCall).toBeUndefined();
-  });
 });
 
 describe("executeTypecheck", () => {
@@ -555,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: [] });
@@ -593,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>,
@@ -631,23 +541,4 @@ describe("executeTypecheck", () => {
     expect(process.exitCode).toBeUndefined();
   });
 
-  it("returns failure result when tsconfig.json fails to load", async () => {
-    const { executeTypecheck } = await import("../src/commands/typecheck");
-
-    vi.mocked(ts.readConfigFile).mockReturnValue({
-      error: {
-        category: ts.DiagnosticCategory.Error,
-        messageText: "Failed to read tsconfig.json",
-      } as ts.Diagnostic,
-    });
-
-    vi.mocked(ts.formatDiagnosticsWithColorAndContext).mockReturnValue("");
-
-    const result = await executeTypecheck({ targets: [], options: [] });
-
-    expect(result.success).toBe(false);
-    expect(result.errorCount).toBe(1);
-    // executeTypecheck should not set process.exitCode
-    expect(process.exitCode).toBeUndefined();
-  });
 });

package/tests/run-watch.spec.ts

@@ -38,38 +38,4 @@ describe("filterPackagesByTargets", () => {
     expect(result["core-node"]).toEqual({ target: "node" });
   });
 
-  it("returns empty result when specifying non-existent package", () => {
-    const result = filterPackagesByTargets(mockPackages, ["non-existent"]);
-
-    expect(Object.keys(result)).toHaveLength(0);
-  });
-
-  it("ignores undefined package config", () => {
-    const result = filterPackagesByTargets(mockPackages, ["empty-pkg"]);
-
-    expect(Object.keys(result)).toHaveLength(0);
-  });
-
-  it("filters client target packages", () => {
-    const result = filterPackagesByTargets(mockPackages, ["solid-demo"]);
-
-    expect(Object.keys(result)).toHaveLength(1);
-    expect(result["solid-demo"]).toEqual({ target: "client", server: 3000 });
-  });
-
-  it("handles empty packages object", () => {
-    const result = filterPackagesByTargets({}, []);
-
-    expect(Object.keys(result)).toHaveLength(0);
-  });
-
-  it("handles case where all packages are scripts", () => {
-    const scriptsOnly: Record<string, SdPackageConfig> = {
-      pkg1: { target: "scripts" },
-      pkg2: { target: "scripts" },
-    };
-    const result = filterPackagesByTargets(scriptsOnly, []);
-
-    expect(Object.keys(result)).toHaveLength(0);
-  });
 });