import { access } from "node:fs/promises"; import { expect, it } from "vitest"; import { ProviderCleanupError } from "../../domain/providerCleanupError.js"; import { DarwinProcessOwnershipInspectionError } from "../../process/DarwinProcessRunTokenReader.js"; import { SourceMapDecoder } from "./SourceMapDecoder.js"; import { AnalysisCancelledError } from "../../domain/analysisErrorCore.js"; import { projectAnalysisError } from "../../domain/analysisErrorProjection.js"; import { SourceMapCleanupFailure, type SourceMapDecoderDependencies, } from "./SourceMapCommand.js"; import { PrivateRuntimeRoot } from "../../process/PrivateRuntimeRoot.js"; import { spawnOwnedProviderProcess } from "../../process/ProviderProcess.js"; import { cleanupOwnedProcessGroup } from "../../process/ProcessOwnership.js"; import { webSourceLocationArgs, webSourceLocationFixture, } from "../../../tests/fixtures/webSourceLocation.js"; import { releaseOwnedCleanup } from "../../../tests/support/cleanupRelease.js"; const fixture = webSourceLocationFixture(); const input = { text: fixture.sourceMap.text, url: fixture.sourceMap.url, path: fixture.sourceMap.file.path, position: webSourceLocationArgs.generated_position, }; it("preserves the exact caller reason before source-map admission", async () => { const reason = { caller: "pre-aborted source-map decode" }; const controller = new AbortController(); controller.abort(reason); const response = await new SourceMapDecoder().trace(input, { signal: controller.signal, }); if (response.ok) throw new Error("expected cancellation"); expect(response.error).toBeInstanceOf(AnalysisCancelledError); expect(response.error.cause).toBe(reason); }); it("retains physical failure and late cancellation through cleanup failure and retry", async () => { const root = await PrivateRuntimeRoot.create({ prefix: "rea-source-map-cleanup-retry-test-", }); let denyNextClose = true; const controller = new AbortController(); const reason = { caller: "after physical exit during final cleanup" }; const dependencies: SourceMapDecoderDependencies = { prepareOwnership: async () => {}, createRuntime: async () => ({ path: root.path, close: async () => { if (denyNextClose) { denyNextClose = false; controller.abort(reason); throw new Error("injected root cleanup failure"); } await root.close(); }, }), launcher: async (options) => spawnOwnedProviderProcess({ ...options, arguments: [ "-e", 'process.stderr.write("physical exit 7"); process.exit(7)', ], }), }; const decoder = new SourceMapDecoder(dependencies); try { const failed = await decoder.trace(input, { signal: controller.signal }); if (failed.ok) throw new Error("expected physical failure with cleanup failure"); const primary = failed.error.cleanupPrimary; expect(primary).toMatchObject({ _tag: "ProviderAdapterError", diagnostics: { exit_code: 7, stderr: "physical exit 7", }, }); expect(primary?.capturedOutput?.stderr).toBe("physical exit 7"); expect(primary?.secondaryFailures).toHaveLength(1); expect(primary?.secondaryFailures[0]).toBeInstanceOf( AnalysisCancelledError, ); expect(primary?.secondaryFailures[0]?.cause).toBe(reason); expect(failed.error.capturedOutput).toEqual(primary?.capturedOutput); expect(failed.error.cleanupResources).toEqual([root.path]); expect(failed.error.diagnostics).toMatchObject({ primary_error: { code: "execution_failure" }, cleanup_error: { details: { diagnostics: { cleanup_failures: ["injected root cleanup failure"], }, }, }, }); expect(projectAnalysisError(failed.error).code).toBe("cleanup_incomplete"); await expect(access(root.path)).resolves.toBeUndefined(); const invalidInput = { ...input, text: null } as unknown as typeof input; const retried = await decoder.trace(invalidInput); if (retried.ok) throw new Error("expected invalid input after cleanup retry"); expect(retried.error._tag).toBe("AnalysisInputError"); await expect(access(root.path)).rejects.toMatchObject({ code: "ENOENT" }); expect(failed.error.cleanupIncomplete).toBe(false); expect(failed.error.cleanupResources).toEqual([]); expect(projectAnalysisError(failed.error).code).toBe("execution_failure"); expect(failed.error.cleanupPrimary).toBe(primary); expect(primary?.secondaryFailures).toHaveLength(1); expect(primary?.secondaryFailures[0]?.cause).toBe(reason); expect(failed.error.diagnostics).toMatchObject({ cleanup_error: { details: { diagnostics: { cleanup_failures: ["injected root cleanup failure"], }, }, }, }); } finally { await decoder.close(); } }); it("settles every source-map cleanup failure when final close releases the exact runtime", async () => { const root = await PrivateRuntimeRoot.create({ prefix: "rea-source-map-final-cleanup-test-", }); let attempts = 0; let denyCleanup = true; const launchCause = new Error("controlled launch failure"); const decoder = new SourceMapDecoder({ prepareOwnership: async () => {}, createRuntime: async () => ({ path: root.path, close: async () => { attempts += 1; if (denyCleanup && attempts <= 2) throw new Error(`runtime cleanup attempt ${String(attempts)} failed`); await root.close(); }, }), launcher: async () => { throw launchCause; }, }); try { const initial = await decoder.trace(input); if (initial.ok) throw new Error("expected initial cleanup failure"); expect(initial.error.cleanupPrimary?.cause).toBe(launchCause); const retry = await decoder.trace(input); if (retry.ok) throw new Error("expected retry cleanup failure"); for (const failure of [initial.error, retry.error]) { expect(failure.cleanupIncomplete).toBe(true); expect(failure.cleanupResources).toEqual([root.path]); } await expect(access(root.path)).resolves.toBeUndefined(); await decoder.close(); await expect(access(root.path)).rejects.toMatchObject({ code: "ENOENT" }); for (const failure of [initial.error, retry.error]) { expect(failure.cleanupIncomplete).toBe(false); expect(failure.cleanupResources).toEqual([]); expect(projectAnalysisError(failure).code).toBe("execution_failure"); } expect(initial.error.cleanupPrimary?.cause).toBe(launchCause); expect(initial.error.diagnostics).toMatchObject({ cleanup_error: { details: { diagnostics: { cleanup_failures: ["runtime cleanup attempt 1 failed"], }, }, }, }); expect(retry.error).toBeInstanceOf(SourceMapCleanupFailure); expect(retry.error.diagnostics?.cleanup_failures).toEqual([ "runtime cleanup attempt 2 failed", ]); } finally { denyCleanup = false; await decoder.close(); } }); it("attributes cleanup resources to the remaining process and directory owners", async () => { const root = await PrivateRuntimeRoot.create({ prefix: "rea-source-map-mixed-cleanup-test-", }); let denyProcessRelease = true; let denyRootRelease = true; let rootAttempts = 0; let runId: string | undefined; const decoder = new SourceMapDecoder({ prepareOwnership: async () => {}, createRuntime: async () => ({ path: root.path, close: async () => { rootAttempts += 1; if (denyRootRelease && rootAttempts === 1) throw new Error("controlled directory cleanup failure"); await root.close(); }, }), launcher: async (options) => { runId = options.runId; const spawned = await spawnOwnedProviderProcess({ ...options, arguments: ["-e", "process.exit(0)"], }); return { ...spawned, cleanup: async () => denyProcessRelease ? { cleaned: false, reason: "controlled process cleanup failure" } : spawned.cleanup === undefined ? cleanupOwnedProcessGroup(spawned.ownership) : spawned.cleanup(), }; }, }); try { const initial = await decoder.trace(input); if (initial.ok) throw new Error("expected process cleanup failure"); expect(initial.error.cleanupResources).toEqual([runId, root.path]); await expect(access(root.path)).resolves.toBeUndefined(); denyProcessRelease = false; await expect(decoder.close()).rejects.toMatchObject({ cleanupIncomplete: true, }); expect(initial.error.cleanupIncomplete).toBe(true); expect(initial.error.cleanupResources).toEqual([root.path]); await expect(access(root.path)).resolves.toBeUndefined(); await decoder.close(); expect(initial.error.cleanupIncomplete).toBe(false); expect(initial.error.cleanupResources).toEqual([]); await expect(access(root.path)).rejects.toMatchObject({ code: "ENOENT" }); } finally { denyProcessRelease = false; denyRootRelease = false; await decoder.close(); } }); it.each(["already closed", "queued at close"] as const)( "reports source-map readiness without inventing cleanup ownership when %s", async (phase) => { const decoder = new SourceMapDecoder(); const response = phase === "queued at close" ? decoder.trace(input) : undefined; await decoder.close(); const result = await (response ?? decoder.trace(input)); if (result.ok) throw new Error("Expected closed decoder refusal"); expect(result.error._tag).toBe("AnalysisCapabilityUnavailableError"); expect(result.error.cleanupIncomplete).toBe(false); expect(result.error.cleanupResources).toEqual([]); await decoder.close(); }, ); it("retains cancellation while retrying an earlier failed cleanup", async () => { const root = await PrivateRuntimeRoot.create({ prefix: "rea-source-map-retry-abort-", }); const controller = new AbortController(); const reason = { caller: "during retry" }; let attempts = 0; let release = false; const decoder = new SourceMapDecoder({ prepareOwnership: async () => {}, createRuntime: async () => ({ path: root.path, close: async () => { attempts++; if (!release) { if (attempts === 2) controller.abort(reason); throw new Error("root close failed"); } await root.close(); }, }), launcher: async (options) => spawnOwnedProviderProcess({ ...options, arguments: [ "-e", 'process.stderr.write("physical exit 7"); process.exit(7)', ], }), }); try { const first = await decoder.trace(input); if (first.ok) throw new Error("expected retained cleanup"); const retry = await decoder.trace(input, { signal: controller.signal }); if (retry.ok) throw new Error("expected retained cleanup on retry"); expect(controller.signal.aborted).toBe(true); const cancellation = retry.error.secondaryFailures.find( (failure) => failure instanceof AnalysisCancelledError, ); expect(cancellation?.cause).toBe(reason); expect(retry.error.cleanupIncomplete).toBe(true); expect(retry.error.cleanupResources).toContain(root.path); await expect(access(root.path)).resolves.toBeUndefined(); release = true; await decoder.close(); await expect(access(root.path)).rejects.toMatchObject({ code: "ENOENT" }); expect(first.error.cleanupIncomplete).toBe(false); } finally { release = true; await decoder.close(); } }); it("retains Darwin preparation cleanup ownership and cancellation through retry", async () => { const root = await PrivateRuntimeRoot.create({ prefix: "rea-source-map-prep-owner-", }); const controller = new AbortController(); const reason = { caller: "after preparation failure" }; const cleanup = new ProviderCleanupError("darwin-helper", [root.path], { reason: "held", }); let release = false; const physical = new DarwinProcessOwnershipInspectionError( "compiler failure", { cleanupFailure: cleanup, cleanupOwner: { close: async () => { if (!release) throw new Error("still held"); await root.close(); releaseOwnedCleanup(cleanup); }, }, }, ); const decoder = new SourceMapDecoder({ prepareOwnership: async () => { controller.abort(reason); throw physical; }, }); try { const failed = await decoder.trace(input, { signal: controller.signal }); if (failed.ok) throw new Error("expected failed preparation"); expect(failed.error.cleanupIncomplete).toBe(true); expect(failed.error.cleanupResources).toContain(root.path); expect(failed.error.cleanupPrimary?.cause).toBe(physical); expect( failed.error.cleanupPrimary?.secondaryFailures.find( (entry) => entry instanceof AnalysisCancelledError, )?.cause, ).toBe(reason); await expect(decoder.close()).rejects.toMatchObject({ cleanupIncomplete: true, }); expect(failed.error.cleanupResources).toContain(root.path); await expect(access(root.path)).resolves.toBeUndefined(); release = true; await decoder.close(); await expect(access(root.path)).rejects.toMatchObject({ code: "ENOENT" }); expect(failed.error.cleanupIncomplete).toBe(false); } finally { release = true; await decoder.close(); await root.close(); } }); it("does not claim an opaque caller reason's Darwin cleanup owner", async () => { const controller = new AbortController(); const cleanup = new ProviderCleanupError("foreign", ["opaque-resource"], { reason: "opaque", }); let ownerClosed = false; const reason = new DarwinProcessOwnershipInspectionError( "caller supplied reason", { cleanupFailure: cleanup, cleanupOwner: { close: async () => { ownerClosed = true; }, }, }, ); const decoder = new SourceMapDecoder({ prepareOwnership: async () => { controller.abort(reason); throw reason; }, }); const result = await decoder.trace(input, { signal: controller.signal }); if (result.ok) throw new Error("expected cancellation"); expect(result.error).toBeInstanceOf(AnalysisCancelledError); expect(result.error.cause).toBe(reason); expect(result.error.cleanupIncomplete).toBe(false); await decoder.close(); expect(ownerClosed).toBe(false); });