@simplysm/sd-cli 14.0.8 → 14.0.10

package/tests/utils/output-path-rewriter.spec.ts

@@ -2,9 +2,10 @@ import { describe, it, expect } from "vitest";
 import path from "path";
 import { createOutputPathRewriter, adjustMapSources, addJsExtensionToImports, rewriteScssImports } from "../../src/utils/output-path-rewriter";
 
-// Use path.resolve to get platform-correct absolute paths
+// POSIX paths for assertions — after migration, createOutputPathRewriter returns POSIX paths
 const pkgDir = path.resolve("/workspace/packages/my-pkg");
 const distDir = path.resolve(pkgDir, "dist");
+const posixDistDir = distDir.replace(/\\/g, "/");
 
 describe("createOutputPathRewriter", () => {
   const rewrite = createOutputPathRewriter(pkgDir);
@@ -14,7 +15,7 @@ describe("createOutputPathRewriter", () => {
     const result = rewrite(nestedPath, "declare const x: number;");
 
     expect(result).not.toBeNull();
-    expect(result![0]).toBe(path.join(distDir, "index.d.ts"));
+    expect(result![0]).toBe(posixDistDir + "/index.d.ts");
     expect(result![1]).toBe("declare const x: number;");
   });
 
@@ -23,7 +24,7 @@ describe("createOutputPathRewriter", () => {
     const result = rewrite(nestedPath, "declare const y: string;");
 
     expect(result).not.toBeNull();
-    expect(result![0]).toBe(path.join(distDir, "utils", "helper.d.ts"));
+    expect(result![0]).toBe(posixDistDir + "/utils/helper.d.ts");
   });
 
   it("returns null for other packages' nested .d.ts", () => {
@@ -38,7 +39,7 @@ describe("createOutputPathRewriter", () => {
     const result = rewrite(flatPath, "declare const z: boolean;");
 
     expect(result).not.toBeNull();
-    expect(result![0]).toBe(flatPath);
+    expect(result![0]).toBe(flatPath.replace(/\\/g, "/"));
     expect(result![1]).toBe("declare const z: boolean;");
   });
 
@@ -55,7 +56,7 @@ describe("createOutputPathRewriter", () => {
     const result = rewrite(nestedPath, mapContent);
 
     expect(result).not.toBeNull();
-    expect(result![0]).toBe(path.join(distDir, "index.d.ts.map"));
+    expect(result![0]).toBe(posixDistDir + "/index.d.ts.map");
     // Sources path should be adjusted for the new location
     const parsedMap = JSON.parse(result![1]) as { sources: string[] };
     expect(parsedMap.sources).toBeDefined();
@@ -83,7 +84,7 @@ describe("adjustMapSources", () => {
 
     // The absolute source should be the same, just the relative path changes
     const absoluteFromOriginal = path.resolve(original, "..", "..", "..", "src", "index.ts");
-    const expectedRelative = path.relative(target, absoluteFromOriginal);
+    const expectedRelative = path.relative(target, absoluteFromOriginal).replace(/\\/g, "/");
     expect(parsed.sources[0]).toBe(expectedRelative);
   });
 

package/tests/utils/output-utils.spec.ts

@@ -25,8 +25,8 @@ describe("formatBuildMessages", () => {
   });
 
   it("handles multiple messages", () => {
-    const result = formatBuildMessages("core", "dts", ["err1", "err2"]);
-    expect(result).toContain("core (dts)");
+    const result = formatBuildMessages("core", "node", ["err1", "err2"]);
+    expect(result).toContain("core (node)");
     expect(result).toContain("→ err1");
     expect(result).toContain("→ err2");
   });
@@ -53,13 +53,13 @@ describe("printErrors", () => {
     expect(consola.error).toHaveBeenCalledOnce();
   });
 
-  it("uses 'dts' as label for dts type errors", () => {
+  it("uses target as label for build type errors", () => {
     const results = new Map<string, BuildResult>([
-      ["core:dts", { name: "core", target: "node", type: "dts", status: "error", message: "type error" }],
+      ["core:build", { name: "core", target: "node", type: "build", status: "error", message: "type error" }],
     ]);
     printErrors(results);
     const callArg = vi.mocked(consola.error).mock.calls[0][0] as string;
-    expect(callArg).toContain("dts");
+    expect(callArg).toContain("node");
   });
 
   it("skips non-error results", () => {

package/tests/utils/rebuild-manager.spec.ts

@@ -2,7 +2,7 @@ import { describe, it, expect, vi } from "vitest";
 import { RebuildManager } from "../../src/utils/rebuild-manager";
 
 function createManager() {
-  const logger = { start: vi.fn(), success: vi.fn(), error: vi.fn() };
+  const logger = { start: vi.fn(), success: vi.fn(), error: vi.fn(), debug: vi.fn() };
   const manager = new RebuildManager(logger as any);
   return { manager, logger };
 }

package/tests/utils/sd-config.spec.ts

@@ -1,4 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
+import path from "path";
 
 const mockExists = vi.fn();
 const mockJitiImport = vi.fn();
@@ -7,6 +8,9 @@ vi.mock("@simplysm/core-node", () => ({
   fsx: {
     exists: (...args: unknown[]) => mockExists(...args),
   },
+  pathx: {
+    posixResolve: (...args: string[]) => path.resolve(...args).replace(/\\/g, "/"),
+  },
 }));
 
 vi.mock("jiti", () => ({

package/tests/utils/tsc-build.spec.ts

@@ -45,6 +45,7 @@ vi.mock("../../src/utils/typecheck-serialization", () => ({
 vi.mock("@simplysm/core-node", () => ({
   pathx: {
     isChildPath: vi.fn((filePath: string, parentDir: string) => filePath.startsWith(parentDir)),
+    posix: vi.fn((p: string) => p.replace(/\\/g, "/")),
   },
 }));
 
@@ -183,7 +184,7 @@ describe("runTscPackageBuild", () => {
     );
   });
 
-  it("typecheck mode uses all package files as rootNames", async () => {
+  it("typecheck mode without includeTests uses only source files as rootNames", async () => {
     const tsModule = await import("typescript");
     const { runTscPackageBuild } = await import("../../src/utils/tsc-build");
 
@@ -193,7 +194,24 @@ describe("runTscPackageBuild", () => {
       output: { js: false, dts: false },
     });
 
-    // createEmitAndSemanticDiagnosticsBuilderProgram(rootNames, options, host)
+    expect(vi.mocked(tsModule.default.createEmitAndSemanticDiagnosticsBuilderProgram)).toHaveBeenCalledWith(
+      [SRC_INDEX, SRC_UTIL],
+      expect.any(Object),
+      expect.any(Object),
+    );
+  });
+
+  it("typecheck mode with includeTests uses all package files as rootNames", async () => {
+    const tsModule = await import("typescript");
+    const { runTscPackageBuild } = await import("../../src/utils/tsc-build");
+
+    runTscPackageBuild({
+      pkgDir: PKG_DIR,
+      cwd: path.resolve("/"),
+      output: { js: false, dts: false },
+      includeTests: true,
+    });
+
     expect(vi.mocked(tsModule.default.createEmitAndSemanticDiagnosticsBuilderProgram)).toHaveBeenCalledWith(
       [SRC_INDEX, SRC_UTIL, TEST_INDEX],
       expect.any(Object),
@@ -459,8 +477,8 @@ describe("runTscPackageBuild", () => {
     );
   });
 
-  // Unit: env suffix is NOT applied in emit mode
-  it("does not add env suffix to tsBuildInfoFile in emit mode", async () => {
+  // Unit: env suffix IS applied in emit mode (distinguishes build artifacts by env)
+  it("adds env suffix to tsBuildInfoFile in emit mode", async () => {
     const { runTscPackageBuild } = await import("../../src/utils/tsc-build");
     runTscPackageBuild({
       pkgDir: PKG_DIR,
@@ -469,7 +487,7 @@ describe("runTscPackageBuild", () => {
       env: "node",
     });
     expect(capturedOptions!.tsBuildInfoFile).toBe(
-      path.join(PKG_DIR, ".cache", "build.tsbuildinfo"),
+      path.join(PKG_DIR, ".cache", "build-node.tsbuildinfo"),
     );
   });
 

package/tests/workers/library-build-worker.spec.ts

@@ -1,4 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
+import path from "path";
 
 //#region Mocks
 
@@ -9,13 +10,16 @@ let mockSend: ReturnType<typeof vi.fn>;
 const mockOnChange = vi.fn();
 const mockWatcherClose = vi.fn();
 
-// tsc build mock
+// tsc build mock — default includes program with /pkg/src/index.ts
 const mockRunTscPackageBuild = vi.fn(() => ({
   success: true,
   errors: undefined,
   diagnostics: [],
   errorCount: 0,
   warningCount: 0,
+  program: {
+    getSourceFiles: () => [{ fileName: "/pkg/src/index.ts" }],
+  },
 }));
 
 vi.mock("@simplysm/core-node", () => ({
@@ -30,16 +34,21 @@ vi.mock("@simplysm/core-node", () => ({
       close: mockWatcherClose,
     })),
   },
+  pathx: {
+    posix: vi.fn((p: string) => p.replace(/\\/g, "/")),
+    posixResolve: vi.fn((...args: string[]) => path.resolve(...args).replace(/\\/g, "/")),
+  },
 }));
 
 vi.mock("@simplysm/core-common", () => ({
   err: { message: (e: any) => e?.message ?? String(e) },
 }));
 
+const mockDebug = vi.fn();
 vi.mock("consola", () => ({
   consola: {
     withTag: vi.fn(() => ({
-      debug: vi.fn(),
+      debug: mockDebug,
       warn: vi.fn(),
     })),
   },
@@ -71,6 +80,9 @@ beforeEach(async () => {
     diagnostics: [],
     errorCount: 0,
     warningCount: 0,
+    program: {
+      getSourceFiles: () => [{ fileName: "/pkg/src/index.ts" }],
+    },
   });
   mockCollectDeps.mockReturnValue({ workspaceDeps: [], replaceDeps: [] });
   // Re-import to get fresh workerFns
@@ -91,8 +103,7 @@ describe("library-build.worker build()", () => {
   it("runs tsc with output flags and returns combined result", async () => {
     const result = await workerFns["build"]({ ...buildInfo, output: { js: true, dts: true } });
 
-    expect(result.js.success).toBe(true);
-    expect(result.dts.success).toBe(true);
+    expect(result.build.success).toBe(true);
     expect(mockRunTscPackageBuild).toHaveBeenCalledWith(
       expect.objectContaining({ output: { js: true, dts: true } }),
     );
@@ -102,8 +113,7 @@ describe("library-build.worker build()", () => {
   it("passes dts-only output to tsc", async () => {
     const result = await workerFns["build"]({ ...buildInfo, output: { js: false, dts: true } });
 
-    expect(result.js.success).toBe(true);
-    expect(result.dts.success).toBe(true);
+    expect(result.build.success).toBe(true);
     expect(mockRunTscPackageBuild).toHaveBeenCalledWith(
       expect.objectContaining({ output: { js: false, dts: true } }),
     );
@@ -113,28 +123,30 @@ describe("library-build.worker build()", () => {
   it("runs typecheck only when both false", async () => {
     const result = await workerFns["build"]({ ...buildInfo, output: { js: false, dts: false } });
 
-    expect(result.dts.success).toBe(true);
+    expect(result.build.success).toBe(true);
     expect(mockRunTscPackageBuild).toHaveBeenCalledWith(
       expect.objectContaining({ output: { js: false, dts: false } }),
     );
   });
 
-  // Unit: tsc failure reflects in both js and dts results
-  it("reports failure in both js and dts when tsc fails", async () => {
+  // Unit: tsc failure reflects in build result
+  it("reports failure in build when tsc fails", async () => {
     mockRunTscPackageBuild.mockReturnValueOnce({
       success: false,
       errors: ["TS2345: type error"] as any,
       diagnostics: [{ code: 2345, category: 1 }] as any,
       errorCount: 1,
       warningCount: 0,
+      program: {
+        getSourceFiles: () => [{ fileName: "/pkg/src/index.ts" }],
+      },
     });
 
     const result = await workerFns["build"]({ ...buildInfo, output: { js: true, dts: true } });
 
-    expect(result.js.success).toBe(false);
-    expect(result.js.errors).toContain("TS2345: type error");
-    expect(result.dts.success).toBe(false);
-    expect(result.dts.diagnostics).toHaveLength(1);
+    expect(result.build.success).toBe(false);
+    expect(result.build.errors).toContain("TS2345: type error");
+    expect(result.build.diagnostics).toHaveLength(1);
   });
 
   // Acceptance: env from BuildOutput is passed through to runTscPackageBuild
@@ -168,8 +180,7 @@ describe("library-build.worker startWatch()", () => {
     await workerFns["startWatch"]({ ...buildInfo, output: { js: true, dts: true } });
 
     expect(mockSend).toHaveBeenCalledWith("build", expect.objectContaining({
-      js: expect.objectContaining({ success: true }),
-      dts: expect.objectContaining({ success: true }),
+      build: expect.objectContaining({ success: true }),
     }));
   });
 
@@ -194,12 +205,11 @@ describe("library-build.worker startWatch()", () => {
     const onChangeCallback = mockOnChange.mock.calls[0][1];
     mockSend.mockClear();
 
-    await onChangeCallback();
+    await onChangeCallback([{ event: "change", path: "/pkg/src/index.ts" }]);
 
     expect(mockSend).toHaveBeenCalledWith("buildStart", {});
     expect(mockSend).toHaveBeenCalledWith("build", expect.objectContaining({
-      js: expect.objectContaining({ success: true }),
-      dts: expect.objectContaining({ success: true }),
+      build: expect.objectContaining({ success: true }),
     }));
   });
 
@@ -221,7 +231,7 @@ describe("library-build.worker startWatch()", () => {
     const onChangeCallback = mockOnChange.mock.calls[0][1];
     mockSend.mockClear();
 
-    await onChangeCallback();
+    await onChangeCallback([{ event: "change", path: "/pkg/src/index.ts" }]);
 
     expect(mockSend).toHaveBeenCalledWith("error", { message: "tsc crash" });
   });
@@ -273,7 +283,7 @@ describe("library-build.worker startWatch()", () => {
     const onChangeCallback = mockOnChange.mock.calls[0][1];
     mockRunTscPackageBuild.mockClear();
 
-    await onChangeCallback();
+    await onChangeCallback([{ event: "change", path: "/pkg/src/index.ts" }]);
 
     expect(mockRunTscPackageBuild).toHaveBeenCalledWith(
       expect.objectContaining({ env: "browser" }),
@@ -281,6 +291,89 @@ describe("library-build.worker startWatch()", () => {
   });
 });
 
+describe("library-build.worker startWatch() dependency filter", () => {
+  const createMockProgram = (fileNames: string[]) => ({
+    getSourceFiles: () => fileNames.map((f) => ({ fileName: f })),
+  });
+
+  const buildInfoWithProgram = () => {
+    mockRunTscPackageBuild.mockReturnValue({
+      success: true,
+      errors: undefined,
+      diagnostics: [],
+      errorCount: 0,
+      warningCount: 0,
+      program: createMockProgram(["/pkg/src/index.ts", "/pkg/src/utils.ts"]),
+    });
+  };
+
+  // Acceptance: Skip rebuild when changed file is not in program
+  it("skips rebuild when changed file is not in program source files", async () => {
+    buildInfoWithProgram();
+    await workerFns["startWatch"]({ ...buildInfo, output: { js: true, dts: true } });
+    const onChangeCallback = mockOnChange.mock.calls[0][1];
+    mockSend.mockClear();
+
+    await onChangeCallback([{ event: "change", path: "/other/src/unrelated.ts" }]);
+
+    expect(mockSend).not.toHaveBeenCalledWith("buildStart", {});
+    expect(mockSend).not.toHaveBeenCalledWith("build", expect.anything());
+  });
+
+  // Acceptance: Rebuild when changed file is in program
+  it("rebuilds when changed file is in program source files", async () => {
+    buildInfoWithProgram();
+    await workerFns["startWatch"]({ ...buildInfo, output: { js: true, dts: true } });
+    const onChangeCallback = mockOnChange.mock.calls[0][1];
+    mockSend.mockClear();
+
+    await onChangeCallback([{ event: "change", path: "/pkg/src/index.ts" }]);
+
+    expect(mockSend).toHaveBeenCalledWith("buildStart", {});
+    expect(mockSend).toHaveBeenCalledWith("build", expect.anything());
+  });
+
+  // Acceptance: Always rebuild on file add
+  it("always rebuilds on file add event regardless of program", async () => {
+    buildInfoWithProgram();
+    await workerFns["startWatch"]({ ...buildInfo, output: { js: true, dts: true } });
+    const onChangeCallback = mockOnChange.mock.calls[0][1];
+    mockSend.mockClear();
+
+    await onChangeCallback([{ event: "add", path: "/pkg/src/brand-new.ts" }]);
+
+    expect(mockSend).toHaveBeenCalledWith("buildStart", {});
+    expect(mockSend).toHaveBeenCalledWith("build", expect.anything());
+  });
+
+  // Acceptance: Always rebuild on file unlink
+  it("always rebuilds on file unlink event regardless of program", async () => {
+    buildInfoWithProgram();
+    await workerFns["startWatch"]({ ...buildInfo, output: { js: true, dts: true } });
+    const onChangeCallback = mockOnChange.mock.calls[0][1];
+    mockSend.mockClear();
+
+    await onChangeCallback([{ event: "unlink", path: "/pkg/src/old-file.ts" }]);
+
+    expect(mockSend).toHaveBeenCalledWith("buildStart", {});
+    expect(mockSend).toHaveBeenCalledWith("build", expect.anything());
+  });
+
+  // Acceptance: Debug log when skipping rebuild
+  it("logs debug message when skipping rebuild", async () => {
+    buildInfoWithProgram();
+    await workerFns["startWatch"]({ ...buildInfo, output: { js: true, dts: true } });
+    const onChangeCallback = mockOnChange.mock.calls[0][1];
+    mockDebug.mockClear();
+
+    await onChangeCallback([{ event: "change", path: "/other/src/unrelated.ts" }]);
+
+    expect(mockDebug).toHaveBeenCalledWith(
+      expect.stringContaining("빌드에 포함되지 않아 리빌드 건너뜀"),
+    );
+  });
+});
+
 describe("library-build.worker stopWatch()", () => {
   it("cleans up FsWatcher", async () => {
     await workerFns["startWatch"]({ ...buildInfo, output: { js: true, dts: true } });

package/tests/workers/ngtsc-build-lint.spec.ts

@@ -22,8 +22,7 @@ vi.mock("../../src/utils/lint-with-program", () => ({
 const mockTsProgram = { getSourceFiles: () => [] };
 
 const mockRunNgtscBuild = vi.fn().mockResolvedValue({
-  js: { success: true },
-  dts: { success: true, diagnostics: [] },
+  build: { success: true, diagnostics: [] },
 });
 
 vi.mock("../../src/utils/ngtsc-build-core", () => ({
@@ -119,8 +118,7 @@ beforeEach(() => {
     formattedOutput: "",
   });
   mockRunNgtscBuild.mockResolvedValue({
-    js: { success: true },
-    dts: { success: true, diagnostics: [] },
+    build: { success: true, diagnostics: [] },
   });
 });
 
@@ -128,8 +126,7 @@ describe("ngtsc-build.worker lint integration (Slice 4)", () => {
   describe("Scenario: ngtsc-build.worker runs lint after typecheck (one-time build)", () => {
     it("returns lint result when lint is enabled", async () => {
       mockRunNgtscBuild.mockResolvedValue({
-        js: { success: true },
-        dts: { success: true, diagnostics: [] },
+        build: { success: true, diagnostics: [] },
         program: mockTsProgram,
       });
 

package/tests/workers/ngtsc-build-worker.spec.ts

@@ -11,14 +11,14 @@ describe("ngtsc-build-core: NgtscProgram AOT compilation", () => {
   beforeAll(() => {
     // Clean dist before tests
     if (fs.existsSync(distDir)) {
-      fs.rmSync(distDir, { recursive: true, force: true });
+      fs.rmSync(distDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
     }
   });
 
   afterAll(() => {
     // Clean up dist after tests
     if (fs.existsSync(distDir)) {
-      fs.rmSync(distDir, { recursive: true, force: true });
+      fs.rmSync(distDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
     }
   });
 
@@ -32,12 +32,11 @@ describe("ngtsc-build-core: NgtscProgram AOT compilation", () => {
     });
 
     // Debug: print errors if build failed
-    if (!result.js.success) {
-      console.error("JS errors:", result.js.errors);
-      console.error("DTS errors:", result.dts.errors);
+    if (!result.build.success) {
+      console.error("Build errors:", result.build.errors);
     }
 
-    expect(result.js.success).toBe(true);
+    expect(result.build.success).toBe(true);
 
     // Find the provider file output
     const providerJsPath = resolve(distDir, "core", "providers", "sd-theme-provider.js");
@@ -64,7 +63,7 @@ describe("ngtsc-build-core: NgtscProgram AOT compilation", () => {
   it("outputs .d.ts files with Angular type metadata", async () => {
     // Clean dist and run with dts: true
     if (fs.existsSync(distDir)) {
-      fs.rmSync(distDir, { recursive: true, force: true });
+      fs.rmSync(distDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
     }
 
     const result = await runNgtscBuild({
@@ -74,7 +73,7 @@ describe("ngtsc-build-core: NgtscProgram AOT compilation", () => {
       output: { js: true, dts: true },
     });
 
-    expect(result.dts.success).toBe(true);
+    expect(result.build.success).toBe(true);
 
     const providerDtsPath = resolve(distDir, "core", "providers", "sd-theme-provider.d.ts");
     expect(fs.existsSync(providerDtsPath)).toBe(true);
@@ -97,7 +96,7 @@ describe("ngtsc-build-core: NgtscProgram AOT compilation", () => {
   // Acceptance: Scenario "run()에서 dts: false면 .d.ts를 생략한다"
   it("omits .d.ts when output is {js: true, dts: false}", async () => {
     if (fs.existsSync(distDir)) {
-      fs.rmSync(distDir, { recursive: true, force: true });
+      fs.rmSync(distDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
     }
 
     const result = await runNgtscBuild({
@@ -107,7 +106,7 @@ describe("ngtsc-build-core: NgtscProgram AOT compilation", () => {
       output: { js: true, dts: false },
     });
 
-    expect(result.js.success).toBe(true);
+    expect(result.build.success).toBe(true);
 
     const jsExists = fs.existsSync(resolve(distDir, "core", "providers", "sd-theme-provider.js"));
     expect(jsExists).toBe(true);
@@ -120,7 +119,7 @@ describe("ngtsc-build-core: NgtscProgram AOT compilation", () => {
   // Acceptance: Scenario "TypeScript + Angular diagnostics를 통합 수집한다"
   it("collects diagnostics from both TypeScript and Angular compiler", async () => {
     if (fs.existsSync(distDir)) {
-      fs.rmSync(distDir, { recursive: true, force: true });
+      fs.rmSync(distDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
     }
 
     const result = await runNgtscBuild({
@@ -131,8 +130,8 @@ describe("ngtsc-build-core: NgtscProgram AOT compilation", () => {
     });
 
     // Angular package should compile cleanly
-    expect(result.dts.diagnostics).toBeDefined();
-    expect(Array.isArray(result.dts.diagnostics)).toBe(true);
+    expect(result.build.diagnostics).toBeDefined();
+    expect(Array.isArray(result.build.diagnostics)).toBe(true);
   }, 60_000);
 
   // Acceptance: Scenario "타입 에러가 있어도 빌드 결과를 반환한다"
@@ -146,16 +145,15 @@ describe("ngtsc-build-core: NgtscProgram AOT compilation", () => {
     });
 
     // Verify result structure completeness
-    expect(result.js).toHaveProperty("success");
-    expect(result.dts).toHaveProperty("success");
-    expect(result.dts).toHaveProperty("diagnostics");
-    expect(Array.isArray(result.dts.diagnostics)).toBe(true);
+    expect(result.build).toHaveProperty("success");
+    expect(result.build).toHaveProperty("diagnostics");
+    expect(Array.isArray(result.build.diagnostics)).toBe(true);
   }, 60_000);
 
   // Acceptance: Scenario "scss/styles.scss가 CSS로 컴파일되어 dist에 출력된다"
   it("compiles scss/styles.scss to dist/styles.css", async () => {
     if (fs.existsSync(distDir)) {
-      fs.rmSync(distDir, { recursive: true, force: true });
+      fs.rmSync(distDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
     }
 
     const result = await runNgtscBuild({
@@ -165,7 +163,7 @@ describe("ngtsc-build-core: NgtscProgram AOT compilation", () => {
       output: { js: true, dts: false },
     });
 
-    expect(result.dts.success).toBe(true);
+    expect(result.build.success).toBe(true);
 
     const stylesCssPath = resolve(distDir, "styles.css");
     expect(fs.existsSync(stylesCssPath)).toBe(true);

package/tests/workers/server-build-lint.spec.ts

@@ -87,7 +87,10 @@ vi.mock("@simplysm/core-node", () => ({
     },
   ),
   FsWatcher: { watch: vi.fn() },
-  pathx: { norm: vi.fn((base: string, rel: string) => `${base}/${rel}`) },
+  pathx: {
+    posix: vi.fn((p: string) => p.replace(/\\/g, "/")),
+    posixResolve: vi.fn((...args: string[]) => args.join("/").replace(/\/+/g, "/").replace(/\\/g, "/")),
+  },
 }));
 
 vi.mock("fs", () => ({