@simplysm/sd-cli 13.0.99 → 14.0.1

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

@@ -0,0 +1,358 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import path from "path";
+import type ts from "typescript";
+
+// Mocks
+
+const PKG_DIR = path.resolve("/pkg");
+const SRC_DIR = path.join(PKG_DIR, "src");
+const SRC_INDEX = path.join(SRC_DIR, "index.ts");
+const SRC_UTIL = path.join(SRC_DIR, "util.ts");
+const TEST_INDEX = path.join(PKG_DIR, "tests", "index.spec.ts");
+
+const mockParsedConfig: ts.ParsedCommandLine = {
+  options: { target: 1, module: 99, strict: true },
+  fileNames: [SRC_INDEX, SRC_UTIL, TEST_INDEX],
+  errors: [],
+};
+
+vi.mock("../../src/utils/tsconfig", () => ({
+  parseTsconfig: vi.fn(() => mockParsedConfig),
+  getPackageSourceFiles: vi.fn(() => [SRC_INDEX, SRC_UTIL]),
+  getPackageFiles: vi.fn(() => [SRC_INDEX, SRC_UTIL, TEST_INDEX]),
+}));
+
+const mockRewritePath = vi.fn(
+  (fileName: string, content: string) => [fileName, content] as [string, string],
+);
+vi.mock("../../src/utils/output-path-rewriter", () => ({
+  createOutputPathRewriter: vi.fn(() => mockRewritePath),
+  addJsExtensionToImports: vi.fn((text: string) => text + "/* js-ext-applied */"),
+}));
+
+vi.mock("../../src/utils/typecheck-serialization", () => ({
+  serializeDiagnostic: vi.fn((d: any) => ({ code: d.code, category: d.category })),
+}));
+
+vi.mock("@simplysm/core-node", () => ({
+  pathx: {
+    isChildPath: vi.fn((filePath: string, parentDir: string) => filePath.startsWith(parentDir)),
+  },
+}));
+
+let mockEmitResult: { diagnostics: ts.Diagnostic[] };
+let mockProgram: {
+  emit: ReturnType<typeof vi.fn>;
+  getConfigFileParsingDiagnostics: ReturnType<typeof vi.fn>;
+  getSyntacticDiagnostics: ReturnType<typeof vi.fn>;
+  getOptionsDiagnostics: ReturnType<typeof vi.fn>;
+  getGlobalDiagnostics: ReturnType<typeof vi.fn>;
+  getSemanticDiagnostics: ReturnType<typeof vi.fn>;
+};
+let capturedOptions: ts.CompilerOptions | undefined;
+let capturedHost: any;
+
+vi.mock("typescript", () => {
+  const DiagnosticCategory = { Warning: 0, Error: 1, Suggestion: 2, Message: 3 };
+  return {
+    default: {
+      DiagnosticCategory,
+      createIncrementalCompilerHost: vi.fn((options: ts.CompilerOptions) => {
+        capturedOptions = options;
+        capturedHost = { writeFile: vi.fn() };
+        return capturedHost;
+      }),
+      createIncrementalProgram: vi.fn(() => mockProgram),
+      flattenDiagnosticMessageText: vi.fn((msg: string) => msg),
+    },
+  };
+});
+
+describe("runTscPackageBuild", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    capturedOptions = undefined;
+    capturedHost = undefined;
+    mockEmitResult = { diagnostics: [] };
+    mockProgram = {
+      emit: vi.fn(() => mockEmitResult),
+      getConfigFileParsingDiagnostics: vi.fn(() => []),
+      getSyntacticDiagnostics: vi.fn(() => []),
+      getOptionsDiagnostics: vi.fn(() => []),
+      getGlobalDiagnostics: vi.fn(() => []),
+      getSemanticDiagnostics: vi.fn(() => []),
+    };
+  });
+
+  // Acceptance: Scenario "JS + DTS 모두 emit"
+  it("output {js:true, dts:true} sets JS+DTS compilerOptions", async () => {
+    const { runTscPackageBuild } = await import("../../src/utils/tsc-build");
+    const result = runTscPackageBuild({
+      pkgDir: PKG_DIR,
+      cwd: path.resolve("/"),
+      output: { js: true, dts: true },
+    });
+
+    expect(result.success).toBe(true);
+    expect(capturedOptions!.noEmit).toBe(false);
+    expect(capturedOptions!.declaration).toBe(true);
+    expect(capturedOptions!.declarationMap).toBe(true);
+    expect(capturedOptions!.emitDeclarationOnly).toBe(false);
+    expect(capturedOptions!.sourceMap).toBe(true);
+    expect(capturedOptions!.outDir).toBe(path.join(PKG_DIR, "dist"));
+  });
+
+  // Acceptance: Scenario "JS만 emit"
+  it("output {js:true, dts:false} sets JS-only compilerOptions", async () => {
+    const { runTscPackageBuild } = await import("../../src/utils/tsc-build");
+    runTscPackageBuild({
+      pkgDir: PKG_DIR,
+      cwd: path.resolve("/"),
+      output: { js: true, dts: false },
+    });
+
+    expect(capturedOptions!.noEmit).toBe(false);
+    expect(capturedOptions!.declaration).toBe(false);
+    expect(capturedOptions!.declarationMap).toBe(false);
+    expect(capturedOptions!.emitDeclarationOnly).toBe(false);
+    expect(capturedOptions!.sourceMap).toBe(true);
+    expect(capturedOptions!.outDir).toBe(path.join(PKG_DIR, "dist"));
+  });
+
+  // Acceptance: Scenario "DTS만 emit"
+  it("output {js:false, dts:true} sets DTS-only compilerOptions", async () => {
+    const { runTscPackageBuild } = await import("../../src/utils/tsc-build");
+    runTscPackageBuild({
+      pkgDir: PKG_DIR,
+      cwd: path.resolve("/"),
+      output: { js: false, dts: true },
+    });
+
+    expect(capturedOptions!.noEmit).toBe(false);
+    expect(capturedOptions!.declaration).toBe(true);
+    expect(capturedOptions!.declarationMap).toBe(true);
+    expect(capturedOptions!.emitDeclarationOnly).toBe(true);
+    expect(capturedOptions!.sourceMap).toBe(false);
+    expect(capturedOptions!.outDir).toBe(path.join(PKG_DIR, "dist"));
+  });
+
+  // Acceptance: Scenario "typecheck만 실행 (emit 없음)"
+  it("output {js:false, dts:false} sets noEmit compilerOptions", async () => {
+    const { runTscPackageBuild } = await import("../../src/utils/tsc-build");
+    runTscPackageBuild({
+      pkgDir: PKG_DIR,
+      cwd: path.resolve("/"),
+      output: { js: false, dts: false },
+    });
+
+    expect(capturedOptions!.noEmit).toBe(true);
+    expect(capturedOptions!.declaration).toBe(false);
+    expect(capturedOptions!.declarationMap).toBe(false);
+  });
+
+  // Unit: emit modes use src files, typecheck uses all files
+  it("emit mode uses only source 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: true, dts: true },
+    });
+
+    expect(vi.mocked(tsModule.default.createIncrementalProgram)).toHaveBeenCalledWith(
+      expect.objectContaining({ rootNames: [SRC_INDEX, SRC_UTIL] }),
+    );
+  });
+
+  it("typecheck mode 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 },
+    });
+
+    expect(vi.mocked(tsModule.default.createIncrementalProgram)).toHaveBeenCalledWith(
+      expect.objectContaining({ rootNames: [SRC_INDEX, SRC_UTIL, TEST_INDEX] }),
+    );
+  });
+
+  // Unit: tsBuildInfoFile path differs by emit vs typecheck
+  it("emit mode uses build.tsbuildinfo", async () => {
+    const { runTscPackageBuild } = await import("../../src/utils/tsc-build");
+    runTscPackageBuild({
+      pkgDir: PKG_DIR,
+      cwd: path.resolve("/"),
+      output: { js: true, dts: true },
+    });
+    expect(capturedOptions!.tsBuildInfoFile).toBe(path.join(PKG_DIR, ".cache", "build.tsbuildinfo"));
+  });
+
+  it("typecheck mode uses typecheck.tsbuildinfo", async () => {
+    const { runTscPackageBuild } = await import("../../src/utils/tsc-build");
+    runTscPackageBuild({
+      pkgDir: PKG_DIR,
+      cwd: path.resolve("/"),
+      output: { js: false, dts: false },
+    });
+    expect(capturedOptions!.tsBuildInfoFile).toBe(path.join(PKG_DIR, ".cache", "typecheck.tsbuildinfo"));
+  });
+
+  // Unit: path rewriter is applied in emit modes
+  it("applies path rewriter in emit mode", async () => {
+    const { createOutputPathRewriter } = await import("../../src/utils/output-path-rewriter");
+    const { runTscPackageBuild } = await import("../../src/utils/tsc-build");
+
+    runTscPackageBuild({
+      pkgDir: PKG_DIR,
+      cwd: path.resolve("/"),
+      output: { js: true, dts: true },
+    });
+    expect(createOutputPathRewriter).toHaveBeenCalledWith(PKG_DIR);
+  });
+
+  it("does not apply path rewriter in typecheck mode", async () => {
+    const { createOutputPathRewriter } = await import("../../src/utils/output-path-rewriter");
+    vi.mocked(createOutputPathRewriter).mockClear();
+
+    const { runTscPackageBuild } = await import("../../src/utils/tsc-build");
+    runTscPackageBuild({
+      pkgDir: PKG_DIR,
+      cwd: path.resolve("/"),
+      output: { js: false, dts: false },
+    });
+    expect(createOutputPathRewriter).not.toHaveBeenCalled();
+  });
+
+  // Unit: JS extension rewriter is applied to .js files in writeFile hook
+  it("applies addJsExtensionToImports for .js files via writeFile hook", async () => {
+    const { addJsExtensionToImports } = await import("../../src/utils/output-path-rewriter");
+    vi.mocked(addJsExtensionToImports).mockClear();
+    mockRewritePath.mockImplementation(
+      (fileName: string, content: string) => [fileName, content] as [string, string],
+    );
+
+    const { runTscPackageBuild } = await import("../../src/utils/tsc-build");
+    runTscPackageBuild({
+      pkgDir: PKG_DIR,
+      cwd: path.resolve("/"),
+      output: { js: true, dts: true },
+    });
+
+    // Simulate writeFile call with a .js file
+    const hookedWriteFile = capturedHost.writeFile;
+    hookedWriteFile("dist/index.js", 'import { x } from "./foo";', false);
+
+    expect(addJsExtensionToImports).toHaveBeenCalledWith('import { x } from "./foo";');
+  });
+
+  it("does not apply addJsExtensionToImports for .d.ts files", async () => {
+    const { addJsExtensionToImports } = await import("../../src/utils/output-path-rewriter");
+    vi.mocked(addJsExtensionToImports).mockClear();
+    mockRewritePath.mockImplementation(
+      (fileName: string, content: string) => [fileName, content] as [string, string],
+    );
+
+    const { runTscPackageBuild } = await import("../../src/utils/tsc-build");
+    runTscPackageBuild({
+      pkgDir: PKG_DIR,
+      cwd: path.resolve("/"),
+      output: { js: false, dts: true },
+    });
+
+    // Simulate writeFile call with a .d.ts file
+    const hookedWriteFile = capturedHost.writeFile;
+    hookedWriteFile("dist/index.d.ts", 'import type { x } from "./foo";', false);
+
+    expect(addJsExtensionToImports).not.toHaveBeenCalled();
+  });
+
+  // Unit: diagnostics are collected and returned
+  it("collects error diagnostics and returns failure", async () => {
+    const errorDiag: Partial<ts.Diagnostic> = {
+      category: 1, // Error
+      code: 2345,
+      messageText: "Type 'string' is not assignable to type 'number'",
+      file: { fileName: SRC_INDEX, getLineAndCharacterOfPosition: () => ({ line: 5, character: 10 }) } as any,
+      start: 100,
+    };
+    mockProgram.getSemanticDiagnostics.mockReturnValue([errorDiag]);
+
+    const { runTscPackageBuild } = await import("../../src/utils/tsc-build");
+    const result = runTscPackageBuild({
+      pkgDir: PKG_DIR,
+      cwd: path.resolve("/"),
+      output: { js: true, dts: true },
+    });
+
+    expect(result.success).toBe(false);
+    expect(result.errorCount).toBe(1);
+    expect(result.errors![0]).toContain("TS2345");
+  });
+
+  // Unit: filters out diagnostics from other packages
+  it("filters diagnostics to current package only", async () => {
+    const ownDiag: Partial<ts.Diagnostic> = {
+      category: 1,
+      code: 1001,
+      messageText: "own error",
+      file: { fileName: SRC_INDEX, getLineAndCharacterOfPosition: () => ({ line: 0, character: 0 }) } as any,
+      start: 0,
+    };
+    const otherDiag: Partial<ts.Diagnostic> = {
+      category: 1,
+      code: 1002,
+      messageText: "other error",
+      file: { fileName: path.resolve("/other-pkg/src/index.ts"), getLineAndCharacterOfPosition: () => ({ line: 0, character: 0 }) } as any,
+      start: 0,
+    };
+    mockProgram.getSemanticDiagnostics.mockReturnValue([ownDiag, otherDiag]);
+
+    const { runTscPackageBuild } = await import("../../src/utils/tsc-build");
+    const result = runTscPackageBuild({
+      pkgDir: PKG_DIR,
+      cwd: path.resolve("/"),
+      output: { js: true, dts: true },
+    });
+
+    expect(result.errorCount).toBe(1);
+    expect(result.errors![0]).toContain("TS1001");
+  });
+
+  // Unit: parsedConfig passed → skips parseTsconfig
+  it("uses provided parsedConfig instead of calling parseTsconfig", async () => {
+    const { parseTsconfig } = await import("../../src/utils/tsconfig");
+    vi.mocked(parseTsconfig).mockClear();
+
+    const { runTscPackageBuild } = await import("../../src/utils/tsc-build");
+    runTscPackageBuild({
+      pkgDir: PKG_DIR,
+      cwd: path.resolve("/"),
+      output: { js: true, dts: true },
+      parsedConfig: mockParsedConfig as any,
+    });
+
+    expect(parseTsconfig).not.toHaveBeenCalled();
+  });
+
+  // Unit: exception handling
+  it("returns error result on exception", async () => {
+    const { parseTsconfig } = await import("../../src/utils/tsconfig");
+    vi.mocked(parseTsconfig).mockImplementationOnce(() => { throw new Error("tsconfig not found"); });
+
+    const { runTscPackageBuild } = await import("../../src/utils/tsc-build");
+    const result = runTscPackageBuild({
+      pkgDir: PKG_DIR,
+      cwd: path.resolve("/"),
+      output: { js: true, dts: true },
+    });
+
+    expect(result.success).toBe(false);
+    expect(result.errorCount).toBe(1);
+    expect(result.errors![0]).toBe("tsconfig not found");
+  });
+});

package/tests/utils/tsconfig-angular.spec.ts

@@ -0,0 +1,71 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+
+vi.mock("@simplysm/core-node", () => ({
+  pathx: {
+    norm: (p: string) => p.replace(/\\/g, "/"),
+    isChildPath: (child: string, parent: string) => child.startsWith(parent),
+  },
+}));
+
+const mockReadConfigFile = vi.fn();
+vi.mock("typescript", () => ({
+  default: {
+    readConfigFile: (...args: any[]) => mockReadConfigFile(...args),
+    sys: {
+      readFile: vi.fn(),
+    },
+  },
+}));
+
+const { hasAngularCompilerOptions } = await import("../../src/utils/tsconfig");
+
+afterEach(() => {
+  vi.clearAllMocks();
+});
+
+describe("hasAngularCompilerOptions", () => {
+  // Unit: returns true when angularCompilerOptions present
+  it("returns true when tsconfig has angularCompilerOptions", () => {
+    mockReadConfigFile.mockReturnValue({
+      config: {
+        compilerOptions: {},
+        angularCompilerOptions: { strictTemplates: true },
+      },
+    });
+
+    const result = hasAngularCompilerOptions("/packages/angular");
+    expect(result).toBe(true);
+  });
+
+  // Unit: returns false when angularCompilerOptions absent
+  it("returns false when tsconfig has no angularCompilerOptions", () => {
+    mockReadConfigFile.mockReturnValue({
+      config: {
+        compilerOptions: {},
+      },
+    });
+
+    const result = hasAngularCompilerOptions("/packages/core-common");
+    expect(result).toBe(false);
+  });
+
+  // Unit: returns false on read error
+  it("returns false when tsconfig read fails", () => {
+    mockReadConfigFile.mockReturnValue({
+      error: { messageText: "File not found" },
+    });
+
+    const result = hasAngularCompilerOptions("/nonexistent");
+    expect(result).toBe(false);
+  });
+
+  // Unit: returns false for empty config
+  it("returns false for null/undefined config", () => {
+    mockReadConfigFile.mockReturnValue({
+      config: null,
+    });
+
+    const result = hasAngularCompilerOptions("/empty");
+    expect(result).toBe(false);
+  });
+});

package/tests/utils/typecheck-non-package.spec.ts

@@ -0,0 +1,120 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+  parseTsconfig: vi.fn(),
+  createIncrementalCompilerHost: vi.fn(),
+  createIncrementalProgram: vi.fn(),
+  serializeDiagnostic: vi.fn((d: any) => d),
+}));
+
+vi.mock("../../src/utils/tsconfig", () => ({
+  parseTsconfig: mocks.parseTsconfig,
+}));
+
+vi.mock("../../src/utils/typecheck-serialization", () => ({
+  serializeDiagnostic: mocks.serializeDiagnostic,
+}));
+
+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,
+      createIncrementalCompilerHost: mocks.createIncrementalCompilerHost,
+      createIncrementalProgram: mocks.createIncrementalProgram,
+      DiagnosticCategory: { Error: 1, Warning: 0 },
+    },
+  };
+});
+
+const { typecheckNonPackageFiles } = await import("../../src/utils/typecheck-non-package");
+
+describe("typecheckNonPackageFiles", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    mocks.parseTsconfig.mockReturnValue({
+      fileNames: [
+        "/project/vitest.config.ts",
+        "/project/packages/core/src/index.ts",
+        "/project/packages/core/vitest.config.ts",
+      ],
+      options: { strict: true },
+      errors: [],
+    });
+
+    mocks.createIncrementalCompilerHost.mockReturnValue({});
+
+    const mockProgram = {
+      emit: vi.fn(() => ({ diagnostics: [] })),
+      getConfigFileParsingDiagnostics: vi.fn(() => []),
+      getSyntacticDiagnostics: vi.fn(() => []),
+      getOptionsDiagnostics: vi.fn(() => []),
+      getGlobalDiagnostics: vi.fn(() => []),
+      getSemanticDiagnostics: vi.fn(() => []),
+    };
+    mocks.createIncrementalProgram.mockReturnValue(mockProgram);
+  });
+
+  it("returns success when no diagnostics", () => {
+    const result = typecheckNonPackageFiles("/project");
+
+    expect(result.success).toBe(true);
+    expect(result.errorCount).toBe(0);
+    expect(result.warningCount).toBe(0);
+    expect(result.diagnostics).toHaveLength(0);
+  });
+
+  it("filters to only non-package files", () => {
+    typecheckNonPackageFiles("/project");
+
+    // createIncrementalProgram should receive only root-level + package config files
+    expect(mocks.createIncrementalProgram).toHaveBeenCalledWith(
+      expect.objectContaining({
+        rootNames: expect.arrayContaining(["/project/vitest.config.ts"]),
+      }),
+    );
+    // Should NOT include package source files
+    const rootNames = mocks.createIncrementalProgram.mock.calls[0][0].rootNames;
+    expect(rootNames).not.toContainEqual(
+      expect.stringContaining("packages/core/src/index.ts"),
+    );
+  });
+
+  it("includes package root config files (e.g., packages/core/vitest.config.ts)", () => {
+    typecheckNonPackageFiles("/project");
+
+    const rootNames = mocks.createIncrementalProgram.mock.calls[0][0].rootNames;
+    expect(rootNames).toContainEqual(
+      expect.stringContaining("packages/core/vitest.config.ts"),
+    );
+  });
+
+  it("reports errors from diagnostics", () => {
+    const mockDiag = { category: 1, code: 2322, messageText: "Type error", file: null, start: null };
+    const mockProgram = {
+      emit: vi.fn(() => ({ diagnostics: [] })),
+      getConfigFileParsingDiagnostics: vi.fn(() => []),
+      getSyntacticDiagnostics: vi.fn(() => []),
+      getOptionsDiagnostics: vi.fn(() => []),
+      getGlobalDiagnostics: vi.fn(() => []),
+      getSemanticDiagnostics: vi.fn(() => [mockDiag]),
+    };
+    mocks.createIncrementalProgram.mockReturnValue(mockProgram);
+
+    const result = typecheckNonPackageFiles("/project");
+
+    expect(result.success).toBe(false);
+    expect(result.errorCount).toBe(1);
+  });
+
+  it("uses noEmit=true for typecheck only", () => {
+    typecheckNonPackageFiles("/project");
+
+    const options = mocks.createIncrementalProgram.mock.calls[0][0].options;
+    expect(options.noEmit).toBe(true);
+    expect(options.declaration).toBe(false);
+  });
+});

package/tests/utils/worker-events.spec.ts

@@ -0,0 +1,155 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { registerWorkerEventHandlers } from "../../src/utils/worker-events";
+import type { BuildResult } from "../../src/infra/ResultCollector";
+import type { RebuildManager } from "../../src/utils/rebuild-manager";
+
+vi.mock("consola", () => ({
+  consola: {
+    withTag: vi.fn(() => ({
+      debug: vi.fn(),
+      warn: vi.fn(),
+    })),
+  },
+}));
+
+function createMockWorker() {
+  const handlers = new Map<string, (data: any) => void>();
+  return {
+    on: vi.fn((event: string, handler: (data: any) => void) => {
+      handlers.set(event, handler);
+    }),
+    emit(event: string, data: any) {
+      handlers.get(event)?.(data);
+    },
+  };
+}
+
+function createMockRebuildManager() {
+  return {
+    registerBuild: vi.fn(() => vi.fn()),
+  } as unknown as RebuildManager;
+}
+
+describe("registerWorkerEventHandlers", () => {
+  let results: Map<string, BuildResult>;
+  let rebuildManager: RebuildManager;
+
+  beforeEach(() => {
+    results = new Map();
+    rebuildManager = createMockRebuildManager();
+  });
+
+  it("stores success result on build event with success=true", () => {
+    const worker = createMockWorker();
+    const workerInfo = {
+      name: "core",
+      config: { target: "node" },
+      worker,
+      isInitialBuild: true,
+      buildResolver: vi.fn(),
+    };
+
+    registerWorkerEventHandlers(
+      workerInfo,
+      { resultKey: "core:build", listrTitle: "core", resultType: "build" },
+      results,
+      rebuildManager,
+    );
+
+    worker.emit("build", { success: true });
+
+    expect(results.get("core:build")).toBeDefined();
+    expect(results.get("core:build")!.status).toBe("success");
+  });
+
+  it("stores error result on build event with success=false", () => {
+    const worker = createMockWorker();
+    const workerInfo = {
+      name: "core",
+      config: { target: "node" },
+      worker,
+      isInitialBuild: true,
+      buildResolver: vi.fn(),
+    };
+
+    registerWorkerEventHandlers(
+      workerInfo,
+      { resultKey: "core:build", listrTitle: "core", resultType: "build" },
+      results,
+      rebuildManager,
+    );
+
+    worker.emit("build", { success: false, errors: ["type error"] });
+
+    expect(results.get("core:build")!.status).toBe("error");
+    expect(results.get("core:build")!.message).toBe("type error");
+  });
+
+  it("stores error result on error event", () => {
+    const worker = createMockWorker();
+    const workerInfo = {
+      name: "core",
+      config: { target: "node" },
+      worker,
+      isInitialBuild: true,
+      buildResolver: vi.fn(),
+    };
+
+    registerWorkerEventHandlers(
+      workerInfo,
+      { resultKey: "core:build", listrTitle: "core", resultType: "build" },
+      results,
+      rebuildManager,
+    );
+
+    worker.emit("error", { message: "fatal error" });
+
+    expect(results.get("core:build")!.status).toBe("error");
+    expect(results.get("core:build")!.message).toBe("fatal error");
+  });
+
+  it("calls buildResolver on build completion", () => {
+    const worker = createMockWorker();
+    const resolver = vi.fn();
+    const workerInfo = {
+      name: "core",
+      config: { target: "node" },
+      worker,
+      isInitialBuild: true,
+      buildResolver: resolver,
+    };
+
+    registerWorkerEventHandlers(
+      workerInfo,
+      { resultKey: "core:build", listrTitle: "core", resultType: "build" },
+      results,
+      rebuildManager,
+    );
+
+    worker.emit("build", { success: true });
+
+    expect(resolver).toHaveBeenCalledOnce();
+  });
+
+  it("registers rebuild on buildStart for non-initial builds", () => {
+    const worker = createMockWorker();
+    const workerInfo = {
+      name: "core",
+      config: { target: "node" },
+      worker,
+      isInitialBuild: false,
+      buildResolver: undefined,
+    };
+
+    registerWorkerEventHandlers(
+      workerInfo,
+      { resultKey: "core:build", listrTitle: "core", resultType: "build" },
+      results,
+      rebuildManager,
+    );
+
+    worker.emit("buildStart", {});
+
+    expect(rebuildManager.registerBuild).toHaveBeenCalledWith("core:build", "core");
+  });
+});