rea-agents 6.3.0 → 6.5.0

package/dist/javascript/analysis/JavaScriptAnalysisWorkerServer.js

@@ -0,0 +1,126 @@
+import { createHash } from "node:crypto";
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { createInterface } from "node:readline";
+import { getHeapStatistics } from "node:v8";
+import { AnalysisResourceConstraintError } from "../../domain/analysisErrorCore.js";
+import { javaScriptRuntime } from "../../domain/runtimeVersion.js";
+import { javaScriptTransferByteBudget, writeJavaScriptAnalysisTransfer, } from "./JavaScriptAnalysisTransfer.js";
+import { javaScriptWorkerStaticAnalysisSchema } from "./JavaScriptAnalysisWorkerSchemas.js";
+import { JAVASCRIPT_ANALYSIS_WORKER_DEFAULTS as DEFAULTS, javaScriptWorkerRequestSchema, javaScriptWorkerAdmissionSchema, javaScriptWorkerMessageSchema, } from "./JavaScriptAnalysisWorkerProtocol.js";
+const send = async (input) => {
+    const value = javaScriptWorkerMessageSchema.parse(input);
+    const frame = `${JSON.stringify(value)}\n`;
+    if (Buffer.byteLength(frame) > DEFAULTS.protocolBytes)
+        throw new RangeError("JavaScript worker control frame exceeds its byte budget");
+    await new Promise((resolve, reject) => {
+        process.stdout.write(frame, (error) => error === null || error === undefined ? resolve() : reject(error));
+    });
+};
+/** Serve sequential inert-source requests from a parent-owned private runtime root. */
+export const serveJavaScriptAnalysisWorker = async (analyze) => {
+    const root = process.cwd();
+    const input = createInterface({ input: process.stdin, crlfDelay: Infinity });
+    const requests = input[Symbol.asyncIterator]();
+    await send({
+        kind: "ready",
+        heap_limit_bytes: javaScriptRuntime(process.versions).id === "node"
+            ? getHeapStatistics().heap_size_limit
+            : null,
+    });
+    try {
+        for (;;) {
+            const next = await requests.next();
+            if (next.done)
+                break;
+            const line = next.value;
+            if (Buffer.byteLength(line) > DEFAULTS.protocolBytes)
+                throw new RangeError("JavaScript worker request exceeds its byte budget");
+            const raw = JSON.parse(line);
+            const request = javaScriptWorkerRequestSchema.parse(raw);
+            // Function scope releases source AST/IR/results before accepting another job.
+            await analyzeJob(root, request, analyze, requests);
+            if (process.memoryUsage().heapUsed >
+                getHeapStatistics().heap_size_limit / 2)
+                global.gc?.();
+        }
+    }
+    finally {
+        input.close();
+    }
+};
+const analyzeJob = async (root, request, analyze, requests) => {
+    try {
+        let resultBudgetBytes = 0;
+        const source = await readFile(join(root, `${request.id}.source`), "utf8");
+        if (createHash("sha256").update(source).digest("hex") !== request.text_sha256)
+            throw new TypeError("JavaScript worker source text digest does not match its request");
+        const result = await analyze({
+            ...request.file,
+            text: { included: true, value: source },
+        }, request.node_budget, {
+            phase: async (phase) => send({ kind: "phase", id: request.id, phase }),
+            checkpoint: async (facts) => {
+                const value = javaScriptWorkerStaticAnalysisSchema.parse(facts);
+                const text = JSON.stringify(value);
+                const bytes = Buffer.byteLength(text);
+                if (bytes > DEFAULTS.checkpointBytes)
+                    throw new AnalysisResourceConstraintError("analyze_javascript_application", "transport", "JavaScript static checkpoint exceeds its complete-fact byte budget", {
+                        checkpoint_bytes: bytes,
+                        checkpoint_limit_bytes: DEFAULTS.checkpointBytes,
+                    });
+                await writeFile(join(root, `${request.id}.static.json`), text, {
+                    flag: "wx",
+                    mode: 0o600,
+                });
+                await send({
+                    kind: "static",
+                    id: request.id,
+                    bytes,
+                    sha256: createHash("sha256").update(text).digest("hex"),
+                });
+                const next = await requests.next();
+                if (next.done ||
+                    Buffer.byteLength(next.value) > DEFAULTS.protocolBytes)
+                    throw new TypeError("JavaScript worker admission frame is missing or oversized");
+                const raw = JSON.parse(next.value);
+                const admission = javaScriptWorkerAdmissionSchema.parse(raw);
+                if (admission.id !== request.id)
+                    throw new TypeError("JavaScript worker admission names a different source job");
+                resultBudgetBytes = admission.semantic_result_budget_bytes;
+                return resultBudgetBytes;
+            },
+        });
+        await send({ kind: "phase", id: request.id, phase: "transfer" });
+        const descriptor = result === null
+            ? null
+            : await writeJavaScriptAnalysisTransfer(join(root, `${request.id}.records`), result.module, result.projection, javaScriptTransferByteBudget(resultBudgetBytes));
+        await send({ kind: "complete", id: request.id, descriptor });
+    }
+    catch (cause) {
+        await send({
+            kind: "failure",
+            id: request.id,
+            reason: cause instanceof AnalysisResourceConstraintError ||
+                cause instanceof RangeError
+                ? "resource"
+                : cause instanceof TypeError
+                    ? "output"
+                    : "io",
+            resource: cause instanceof AnalysisResourceConstraintError
+                ? cause.resource
+                : cause instanceof RangeError
+                    ? "memory"
+                    : null,
+            limits: cause instanceof AnalysisResourceConstraintError
+                ? cause.reportedLimits
+                : null,
+            // The parent owns resource-error formatting; send its canonical reason.
+            message: cause instanceof AnalysisResourceConstraintError
+                ? cause.reason
+                : cause instanceof Error
+                    ? cause.message
+                    : String(cause),
+        });
+    }
+};

package/dist/javascript/recovery/RecoveryFiles.js

@@ -1,8 +1,9 @@
 import { createHash } from "node:crypto";
 import { constants } from "node:fs";
-import { lstat, open, readdir, writeFile } from "node:fs/promises";
-import { isAbsolute, join } from "node:path";
+import { lstat, mkdir, open, opendir, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { TextDecoder } from "node:util";
+import { normalizeArtifactPath } from "../../artifacts/ArtifactPaths.js";
 import { AnalysisCancelledError, AnalysisInputError, AnalysisOutputError, AnalysisTimeoutError, } from "../../domain/analysisErrorCore.js";
 import { RECOVERY_LIMITS } from "./WakaruRelease.js";
 const OPERATION = "recover_javascript_sources";
@@ -49,13 +50,13 @@ export const readRecoveryFile = async (path, maximum, signal) => {
     const result = await scanRecoveryFile(path, maximum, (chunk) => chunks.push(chunk), signal);
     return Buffer.concat(chunks, result.bytes);
 };
-/** Snapshot one caller-selected UTF-8 script before invoking the engine. */
-export const snapshotRecoveryInput = async (path, snapshotPath, signal) => {
+/** Snapshot one script within the remaining operation-wide input budget. */
+const snapshotRecoveryInput = async (path, snapshotPath, relativePath, maximum, signal) => {
     if (!isAbsolute(path))
         throw recoveryInputFailure("path", "Select an absolute JavaScript file path");
     let bytes;
     try {
-        bytes = await readRecoveryFile(path, RECOVERY_LIMITS.inputBytes, signal);
+        bytes = await readRecoveryFile(path, maximum, signal);
         new TextDecoder("utf-8", { fatal: true }).decode(bytes);
     }
     catch (cause) {
@@ -63,14 +64,58 @@ export const snapshotRecoveryInput = async (path, snapshotPath, signal) => {
             throw cause;
         throw recoveryInputFailure("path", `Cannot snapshot UTF-8 JavaScript input ${path}: ${recoveryFailureMessage(cause)}`, cause);
     }
+    await mkdir(dirname(snapshotPath), { recursive: true, mode: 0o700 });
     await writeFile(snapshotPath, bytes, { flag: "wx", mode: 0o600 });
     return {
         path,
         snapshot_path: snapshotPath,
+        relative_path: relativePath,
         sha256: recoveryDigest(bytes),
         bytes: bytes.length,
     };
 };
+/** Preserve each selected file and its relative input layout without concatenation. */
+export const snapshotRecoveryInputs = async (paths, directory, signal) => {
+    let commonDirectory = dirname(resolve(paths[0]));
+    for (const path of paths) {
+        while (true) {
+            const fromCommon = relative(commonDirectory, resolve(path));
+            if (fromCommon !== ".." &&
+                !fromCommon.startsWith(`..${sep}`) &&
+                !isAbsolute(fromCommon))
+                break;
+            const parent = dirname(commonDirectory);
+            if (parent === commonDirectory)
+                throw recoveryInputFailure("additional_paths", "Selected files must share a filesystem root");
+            commonDirectory = parent;
+        }
+    }
+    const snapshots = [];
+    let remaining = RECOVERY_LIMITS.inputBytes;
+    for (const path of paths) {
+        const relativePath = paths.length === 1
+            ? "bundle.js"
+            : relative(commonDirectory, resolve(path)).split(sep).join("/");
+        try {
+            // Wakaru's multi-input public paths interpret backslashes as separators.
+            if (relativePath.includes("\\"))
+                throw new TypeError("Wakaru cannot preserve literal backslashes in input paths");
+            if (normalizeArtifactPath(relativePath) !== relativePath)
+                throw new TypeError("Input names must already use NFC Unicode spelling");
+        }
+        catch (cause) {
+            throw recoveryInputFailure("path", `Cannot preserve selected input path in published artifacts: ${path}: ${recoveryFailureMessage(cause)}`, cause);
+        }
+        const snapshot = await snapshotRecoveryInput(path, join(directory, relativePath), relativePath, remaining, signal);
+        snapshots.push(snapshot);
+        remaining -= snapshot.bytes;
+    }
+    // The selected-input tuple guarantees a primary snapshot.
+    const [primary, ...additional] = snapshots;
+    if (primary === undefined)
+        throw recoveryInputFailure("path", "Select a JavaScript input");
+    return [primary, ...additional];
+};
 /** Inventory staging without following symlinks or publishing special files. */
 export const inventoryRecoveryFiles = async (root, signal) => {
     const files = [];
@@ -80,14 +125,25 @@ export const inventoryRecoveryFiles = async (root, signal) => {
         const metadata = await lstat(directory);
         if (!metadata.isDirectory() || metadata.isSymbolicLink())
             throw new AnalysisOutputError(OPERATION, `Unsafe staging directory: ${directory}`);
-        for (const entry of await readdir(directory, { withFileTypes: true })) {
+        const handle = await opendir(directory);
+        const children = [];
+        try {
+            for await (const entry of handle) {
+                checkRecoveryCancellation(signal);
+                entries++;
+                if (entries > RECOVERY_LIMITS.outputEntries)
+                    throw new AnalysisOutputError(OPERATION, "Recovery staging exceeds the 10000-entry resource limit");
+                children.push(entry.name);
+            }
+        }
+        finally {
+            await handle.close().catch(() => undefined);
+        }
+        for (const name of children) {
             checkRecoveryCancellation(signal);
-            entries++;
-            const relativePath = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
-            const path = join(directory, entry.name);
+            const relativePath = prefix === "" ? name : `${prefix}/${name}`;
+            const path = join(directory, name);
             const info = await lstat(path);
-            if (entries > RECOVERY_LIMITS.outputEntries)
-                throw new AnalysisOutputError(OPERATION, "Recovery staging exceeds the 10000-entry resource limit");
             if (info.isSymbolicLink() || (!info.isDirectory() && !info.isFile()))
                 throw new AnalysisOutputError(OPERATION, `Recovery produced a symlink or special file: ${relativePath}`);
             if (info.isDirectory())
@@ -117,6 +173,6 @@ export const checkRecoveryCancellation = (signal) => {
 /** Keep both tool invocations within one operation's execution budget. */
 export const checkRecoveryDeadline = (deadline, signal) => {
     checkRecoveryCancellation(signal);
-    if (Date.now() >= deadline)
+    if (performance.now() >= deadline)
         throw new AnalysisTimeoutError(OPERATION, RECOVERY_LIMITS.timeoutMs);
 };

package/dist/javascript/recovery/WakaruCommand.js

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { constants } from "node:fs";
-import { access, realpath } from "node:fs/promises";
+import { access, realpath, stat } from "node:fs/promises";
 import { isAbsolute } from "node:path";
 import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, AnalysisOutputError, } from "../../domain/analysisErrorCore.js";
 import { ProviderAdapterError } from "../../domain/providerAdapterError.js";
@@ -10,7 +10,24 @@ import { ProviderProcessSupervisor, spawnOwnedProviderProcess, } from "../../pro
 import { checkRecoveryDeadline, inventoryRecoveryFiles, fingerprintRecoveryFile, recoveryFailureMessage, } from "./RecoveryFiles.js";
 import { RECOVERY_LIMITS } from "./WakaruRelease.js";
 const OPERATION = "recover_javascript_sources";
-const WAKARU_REQUIREMENT = "Provide an absolute REA_WAKARU_COMMAND pointing to Wakaru 1.13.0 on Linux x64; no tool is installed by REA";
+const WAKARU_REQUIREMENT = "Provide an absolute REA_WAKARU_COMMAND pointing to a Wakaru ^1.13.0 Linux x64 binary (verified with 1.14.0); no tool is installed by REA. See docs/javascript-recovery.md#install-wakaru.";
+/** Cleanup failure carrying the live supervisor so the provider can retry it. */
+export class WakaruCleanupFailure extends ProviderCleanupError {
+    cleanupOwner;
+    runId;
+    cwd;
+    constructor(cleanupOwner, runId, cwd, reason, previousError, snapshot) {
+        super("wakaru", [runId, cwd], {
+            reason,
+            previous_error: previousError instanceof Error ? previousError.message : null,
+            exit_code: snapshot.exitCode ?? null,
+            signal: snapshot.signal ?? null,
+        }, { operation: OPERATION, cause: previousError });
+        this.cleanupOwner = cleanupOwner;
+        this.runId = runId;
+        this.cwd = cwd;
+    }
+}
 /** Resolve and fingerprint explicitly configured tools; acquire nothing at startup. */
 export const resolveWakaruCommand = async (environment) => {
     const configured = environment.REA_WAKARU_COMMAND;
@@ -27,6 +44,8 @@ export const resolveWakaruCommand = async (environment) => {
         if (!isAbsolute(limiter))
             throw new TypeError("REA_JAVASCRIPT_PRLIMIT_COMMAND must be absolute");
         await access(limiter, constants.X_OK);
+        if (!(await stat(limiter)).isFile())
+            throw new TypeError(`Resource limiter is not a regular file: ${limiter}`);
         return { command, limiter, ...fingerprint };
     }
     catch (cause) {
@@ -100,14 +119,8 @@ export const runWakaruCommand = async (context) => {
     }
     const stopped = await supervisor.stop();
     const snapshot = supervisor.snapshot();
-    supervisor.dispose();
     if (stopped.status === "incomplete")
-        throw new ProviderCleanupError("wakaru", [runId, context.cwd], {
-            reason: stopped.reason,
-            previous_error: failure instanceof Error ? failure.message : null,
-            exit_code: snapshot.exitCode ?? null,
-            signal: snapshot.signal ?? null,
-        });
+        throw new WakaruCleanupFailure(supervisor, runId, context.cwd, stopped.reason, failure, snapshot);
     if (failure !== undefined)
         throw failure;
     if (context.signal?.aborted === true)

package/dist/javascript/recovery/WakaruExecution.js

@@ -2,11 +2,12 @@ import { join } from "node:path";
 import { createAnalysisExecution, } from "../../application/AnalysisProvider.js";
 import { AnalysisCapabilityUnavailableError, AnalysisOutputError, } from "../../domain/analysisErrorCore.js";
 import { jsonValueSchema } from "../../domain/jsonValue.js";
-import { fingerprintRecoveryFile, inventoryRecoveryFiles, readRecoveryFile, recoveryDigest, } from "./RecoveryFiles.js";
+import { fingerprintRecoveryFile, inventoryRecoveryFiles, readRecoveryFile, } from "./RecoveryFiles.js";
 import { runWakaruCommand, } from "./WakaruCommand.js";
 import { parseWakaruReports } from "./WakaruReport.js";
 import { publishWakaruArtifacts } from "./WakaruPublication.js";
-import { RECOVERY_LIMITS, WAKARU_RELEASE, WAKARU_PROVIDER_IDENTITY, } from "./WakaruRelease.js";
+import { RECOVERY_LIMITS, WAKARU_PROVIDER_IDENTITY } from "./WakaruRelease.js";
+import { admitWakaruVersion } from "./WakaruVersion.js";
 const OPERATION = "recover_javascript_sources";
 const MODES = {
     structural: "strict",
@@ -15,7 +16,7 @@ const MODES = {
 };
 /** Consume the pinned producer representation in a private workspace. */
 const executeWakaruRecovery = async (context) => {
-    const { root, input, source, engine, environment, launcher, options } = context;
+    const { root, input, sources, engine, environment, launcher, options } = context;
     const staging = join(root, "modules");
     const commandContext = {
         ...engine,
@@ -29,17 +30,19 @@ const executeWakaruRecovery = async (context) => {
         ...commandContext,
         arguments: ["--version"],
     });
-    if (version.exit_code !== 0 ||
-        version.stdout.trim() !== `wakaru ${WAKARU_RELEASE.version}`) {
+    const admitted = version.exit_code === 0
+        ? admitWakaruVersion(version.stdout.trim())
+        : undefined;
+    if (admitted === undefined || admitted.status === "unsupported") {
         // The message names the mismatch; the reason also keeps the tool's stderr.
-        const mismatch = `This adapter requires Wakaru ${WAKARU_RELEASE.version}; reported version: ${version.stdout.trim()}; exit: ${String(version.exit_code)}`;
+        const mismatch = `${admitted?.message ?? `Wakaru --version failed; reported version: ${version.stdout.trim()}`}; exit: ${String(version.exit_code)}`;
         throw new AnalysisCapabilityUnavailableError("wakaru", OPERATION, `${mismatch}; stderr: ${version.stderr}`, { userMessage: `${mismatch}.` });
     }
     const run = await runWakaruCommand({
         ...commandContext,
         staging,
         arguments: [
-            source.snapshot_path,
+            ...sources.map((source) => source.snapshot_path),
             `--unpack=${MODES[input.extraction_mode]}`,
             `--level=${input.rewrite_level}`,
             "--provenance",
@@ -50,36 +53,42 @@ const executeWakaruRecovery = async (context) => {
         ],
     });
     const files = await inventoryRecoveryFiles(staging, options?.signal);
-    const snapshot = await readRecoveryFile(source.snapshot_path, RECOVERY_LIMITS.inputBytes, options?.signal);
+    const snapshots = new Map();
+    for (const source of sources)
+        snapshots.set(source.snapshot_path, await readRecoveryFile(source.snapshot_path, source.bytes, options?.signal));
     const parsed = await parseWakaruReports({
         execution: run,
         provenancePath: join(staging, "provenance.json"),
-        snapshotPath: source.snapshot_path,
-        sourceBytes: snapshot,
+        snapshots,
         files,
     });
-    return { version, run, parsed };
+    return { version, admitted, run, parsed };
 };
 /** Publish validated recovery and retain exact source and engine bindings. */
 export const prepareWakaruExecution = async (context) => {
-    const { root, tree, input, source, engine, options } = context;
+    const { root, tree, input, sources, engine, options } = context;
+    const [source] = sources;
     const staging = join(root, "modules");
-    const { version, run, parsed } = await executeWakaruRecovery(context);
+    const { version, admitted, run, parsed } = await executeWakaruRecovery(context);
     const result = await publishWakaruArtifacts({
         tree,
         staging,
         input,
-        source,
+        sources,
         engine,
+        admitted,
         parsed,
         execution: run,
         ...(options?.signal === undefined ? {} : { signal: options.signal }),
     });
-    if (recoveryDigest(await readRecoveryFile(input.path, RECOVERY_LIMITS.inputBytes, options?.signal)) !== source.sha256)
-        throw new AnalysisOutputError(OPERATION, `Original input changed during recovery: ${input.path}`);
+    for (const selected of sources) {
+        const current = await fingerprintRecoveryFile(selected.path, RECOVERY_LIMITS.inputBytes, options?.signal);
+        if (current.sha256 !== selected.sha256 || current.bytes !== selected.bytes)
+            throw new AnalysisOutputError(OPERATION, `Original input changed during recovery: ${selected.path}`);
+    }
     if ((await fingerprintRecoveryFile(engine.command, RECOVERY_LIMITS.outputBytes, options?.signal)).sha256 !== engine.sha256)
         throw new AnalysisOutputError(OPERATION, "Configured engine bytes changed during recovery");
-    return createAnalysisExecution(result, WAKARU_PROVIDER_IDENTITY, {
+    return createAnalysisExecution(result, { ...WAKARU_PROVIDER_IDENTITY, version: admitted.version }, {
         rawResult: jsonValueSchema.parse({
             version,
             execution: run,
@@ -92,7 +101,10 @@ export const prepareWakaruExecution = async (context) => {
             format: "javascript",
         },
         locations: [
-            { kind: "artifact-path", path: source.path },
+            ...sources.map((selected) => ({
+                kind: "artifact-path",
+                path: selected.path,
+            })),
             ...result.modules.map((module) => ({
                 kind: "artifact-path",
                 path: module.artifact.path,

package/dist/javascript/recovery/WakaruProvider.js

@@ -1,33 +1,51 @@
 import { mkdir, mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import {} from "../../application/AnalysisProvider.js";
 import { SafeOutputTree } from "../../artifacts/SafeOutputTree.js";
+import { SafeOutputTreeCreationFailure } from "../../artifacts/SafeOutputTreeCreationFailure.js";
 import { AnalysisError } from "../../domain/analysisErrorBase.js";
-import { AnalysisOutputError } from "../../domain/analysisErrorCore.js";
+import { AnalysisCancelledError, AnalysisOutputError, } from "../../domain/analysisErrorCore.js";
+import { ArtifactReaderFailure } from "../../artifacts/ArtifactReader.js";
+import { javascriptRecoveryResultSchema, } from "../../domain/javascript/javascriptRecovery.js";
 import { ProviderAdapterError } from "../../domain/providerAdapterError.js";
 import { ProviderCleanupError } from "../../domain/providerCleanupError.js";
 import { err, ok } from "../../domain/result.js";
-import { checkRecoveryCancellation, checkRecoveryDeadline, recoveryFailureMessage, recoveryInputFailure, snapshotRecoveryInput, } from "./RecoveryFiles.js";
-import { resolveWakaruCommand } from "./WakaruCommand.js";
+import { checkRecoveryCancellation, checkRecoveryDeadline, recoveryFailureMessage, recoveryInputFailure, snapshotRecoveryInputs, } from "./RecoveryFiles.js";
+import { resolveWakaruCommand, WakaruCleanupFailure, } from "./WakaruCommand.js";
 import { prepareWakaruExecution } from "./WakaruExecution.js";
 import { RECOVERY_LIMITS } from "./WakaruRelease.js";
 const OPERATION = "recover_javascript_sources";
-/** Stateless adapter; each recovery owns its snapshot, process and publication. */
+/** Serialized recovery adapter retaining failed process, workspace and publication cleanup. */
 export class WakaruProvider {
     environment;
     launcher;
+    #tail = Promise.resolve();
+    #closing = false;
+    #closePromise;
+    #pendingCleanup;
     constructor(environment = process.env, launcher) {
         this.environment = environment;
         this.launcher = launcher;
     }
-    /** Recover one script using validated upstream reports and verified output bytes. */
-    async recover(input, options) {
+    /** Recover selected scripts using validated reports and verified output bytes. */
+    recover(input, options) {
+        if (this.#closing)
+            return Promise.resolve(err(new ProviderCleanupError("wakaru", [], { reason: "Provider is closing" }, { operation: OPERATION })));
+        const operation = this.#tail.then(() => this.#closing
+            ? err(new ProviderCleanupError("wakaru", [], { reason: "Provider is closing" }, { operation: OPERATION }))
+            : this.#recover(input, options));
+        this.#tail = operation.then(() => undefined, () => undefined);
+        return operation;
+    }
+    async #recover(input, options) {
+        const pending = await this.#retire();
+        if (pending !== undefined)
+            return err(pending);
         let root;
         let tree;
-        let failure;
+        let failed;
         let execution;
-        const deadline = Date.now() + RECOVERY_LIMITS.timeoutMs;
+        const deadline = performance.now() + RECOVERY_LIMITS.timeoutMs;
         try {
             checkRecoveryCancellation(options?.signal);
             const engine = await resolveWakaruCommand(this.environment);
@@ -36,15 +54,20 @@ export class WakaruProvider {
             const staging = join(root, "modules");
             await mkdir(inputs, { mode: 0o700 });
             await mkdir(staging, { mode: 0o700 });
-            const source = await snapshotRecoveryInput(input.path, join(inputs, "bundle.js"), options?.signal);
-            tree = await SafeOutputTree.create(input.output_directory).catch((cause) => {
+            const sources = await snapshotRecoveryInputs([input.path, ...(input.additional_paths ?? [])], inputs, options?.signal);
+            try {
+                tree = await SafeOutputTree.create(input.output_directory);
+            }
+            catch (cause) {
+                if (cause instanceof SafeOutputTreeCreationFailure)
+                    tree = cause.tree;
                 throw recoveryInputFailure("output_directory", `Cannot create new recovery directory ${input.output_directory}: ${recoveryFailureMessage(cause)}`, cause);
-            });
+            }
             execution = await prepareWakaruExecution({
                 root,
                 tree,
                 input,
-                source,
+                sources,
                 engine,
                 environment: this.environment,
                 launcher: this.launcher,
@@ -55,33 +78,86 @@ export class WakaruProvider {
             await rm(root, { recursive: true, force: true });
             root = undefined;
             checkRecoveryDeadline(deadline, options?.signal);
-            await tree.commit();
+            await tree.commit(options?.signal);
         }
         catch (cause) {
-            failure = cause;
+            failed = { cause };
         }
-        if (failure !== undefined) {
+        if (failed !== undefined) {
+            const failure = failed.cause instanceof ArtifactReaderFailure &&
+                failed.cause.reason === "cancelled"
+                ? new AnalysisCancelledError(OPERATION, { cause: failed.cause })
+                : failed.cause;
             const residuals = [];
+            const cleanupFailures = [];
+            const cleanupOwner = failure instanceof WakaruCleanupFailure
+                ? failure.cleanupOwner
+                : undefined;
+            let failedTree;
             try {
                 await tree?.rollback();
             }
-            catch {
-                if (tree !== undefined)
+            catch (cause) {
+                if (tree !== undefined) {
+                    failedTree = tree;
                     residuals.push(tree.outputRoot);
+                    cleanupFailures.push({
+                        resource: tree.outputRoot,
+                        reason: recoveryFailureMessage(cause),
+                    });
+                }
             }
-            if (root !== undefined &&
-                !(failure instanceof AnalysisError && failure.cleanupIncomplete)) {
+            if (cleanupOwner !== undefined)
+                residuals.push(cleanupOwner.launch.ownership?.runId ?? "wakaru-worker");
+            if (root !== undefined && cleanupOwner === undefined) {
+                const failedRoot = root;
                 try {
-                    await rm(root, { recursive: true, force: true });
+                    await rm(failedRoot, { recursive: true, force: true });
+                    root = undefined;
                 }
-                catch {
-                    residuals.push(root);
+                catch (cause) {
+                    residuals.push(failedRoot);
+                    cleanupFailures.push({
+                        resource: failedRoot,
+                        reason: recoveryFailureMessage(cause),
+                    });
                 }
             }
+            if (cleanupOwner !== undefined ||
+                failedTree !== undefined ||
+                root !== undefined) {
+                this.#pendingCleanup = {
+                    root,
+                    process: cleanupOwner,
+                    tree: failedTree,
+                };
+                if (root !== undefined)
+                    residuals.push(root);
+                root = undefined;
+            }
             if (residuals.length > 0)
                 return err(new ProviderCleanupError("wakaru", residuals, {
-                    previous_error: recoveryFailureMessage(failure),
+                    ...(failure instanceof WakaruCleanupFailure
+                        ? failure.diagnostics
+                        : {}),
+                    previous_error: failure instanceof WakaruCleanupFailure
+                        ? (failure.diagnostics?.previous_error ?? null)
+                        : recoveryFailureMessage(failure),
+                    cleanup_failures: cleanupFailures,
+                }, {
+                    operation: OPERATION,
+                    cause: failure,
+                    ...(tree?.published && execution !== undefined
+                        ? {
+                            partialObservation: {
+                                kind: "javascript-recovery",
+                                result: javascriptRecoveryResultSchema.parse(execution.result),
+                            },
+                        }
+                        : {}),
                 }));
+            if (tree?.published === true && execution !== undefined)
+                return ok(execution);
             return err(failure instanceof AnalysisError
                 ? failure
                 : new ProviderAdapterError("wakaru", OPERATION, {
@@ -93,4 +169,54 @@ export class WakaruProvider {
             ? err(new AnalysisOutputError(OPERATION, "Recovery returned no execution"))
             : ok(execution);
     }
+    async close() {
+        this.#closing = true;
+        this.#closePromise ??= this.#tail
+            .then(async () => {
+            const failure = await this.#retire();
+            if (failure !== undefined)
+                throw failure;
+        })
+            .catch((cause) => {
+            this.#closePromise = undefined;
+            throw cause;
+        });
+        return this.#closePromise;
+    }
+    async #retire() {
+        const pending = this.#pendingCleanup;
+        if (pending === undefined)
+            return undefined;
+        if (pending.process !== undefined) {
+            const stopped = await pending.process.stop();
+            if (stopped.status === "incomplete")
+                return new ProviderCleanupError("wakaru", [
+                    pending.process.launch.ownership?.runId ?? "wakaru-worker",
+                    ...(pending.root === undefined ? [] : [pending.root]),
+                ], { reason: stopped.reason }, { operation: OPERATION });
+            pending.process = undefined;
+        }
+        if (pending.tree !== undefined) {
+            const tree = pending.tree;
+            try {
+                await tree.rollback();
+                pending.tree = undefined;
+            }
+            catch (cause) {
+                return new ProviderCleanupError("wakaru", [tree.outputRoot], { reason: recoveryFailureMessage(cause) }, { operation: OPERATION, cause });
+            }
+        }
+        if (pending.root !== undefined) {
+            const root = pending.root;
+            try {
+                await rm(root, { recursive: true, force: true });
+                pending.root = undefined;
+            }
+            catch (cause) {
+                return new ProviderCleanupError("wakaru", [root], { reason: recoveryFailureMessage(cause) }, { operation: OPERATION, cause });
+            }
+        }
+        this.#pendingCleanup = undefined;
+        return undefined;
+    }
 }