rea-agents 5.0.0 → 6.1.0

package/dist/hopper/BridgeLauncher.js

@@ -10,6 +10,7 @@ import { spawnOwnedProviderProcess, } from "../process/ProviderProcess.js";
 import { waitForAbortableDelay } from "../process/ProviderDeadline.js";
 import { selectLinuxPrivateDisplayStrategy, } from "./LinuxPrivateDisplayProbe.js";
 import writeFileAtomic from "write-file-atomic";
+import { prepareHopperMachOImage, } from "./HopperMachOImage.js";
 import { acquireHopperTargetLease } from "./HopperTargetLease.js";
 const execFileAsync = promisify(execFile);
 const HOPPER_BACKGROUND_STARTUP_MS = 5_000;
@@ -41,14 +42,22 @@ export class HopperApplicationLauncher {
         const lease = leaseResult.value;
         let leaseTransferred = false;
         try {
+            let loadedPath = this.options.targetPath;
+            if (this.options.preparedImage !== undefined) {
+                const prepared = await prepareHopperMachOImage(this.options.targetPath, this.options.preparedImage.sourceSha256, this.options.preparedImage.image, join(session.directory, "image.macho"), options.signal);
+                if (!prepared.ok)
+                    return prepared;
+                loadedPath = prepared.value;
+            }
             const ownsProcessLifetime = usesLinuxDemo(this.options);
-            const bootstrap = await this.#writeBootstrap(session, ownsProcessLifetime);
+            const bootstrap = await this.#writeBootstrap(session, ownsProcessLifetime, loadedPath);
             if (!bootstrap.ok)
                 return bootstrap;
             const launched = await this.#launchPreparedTarget({
                 session,
                 signal: options.signal,
                 bootstrapPath: bootstrap.value,
+                loadedPath,
                 ownsProcessLifetime,
                 lease,
             });
@@ -69,7 +78,7 @@ export class HopperApplicationLauncher {
             "-Y",
             bootstrapPath,
             action,
-            this.options.targetPath,
+            input.loadedPath,
         ];
         try {
             if (signal?.aborted === true)
@@ -108,15 +117,26 @@ export class HopperApplicationLauncher {
                 await cleanupOwnedProcessGroup(started.ownership);
                 return err(new HopperStartError({ cause }));
             }
-            return ok({
+            const ownedLauncher = {
+                ...(this.options.preparedImage === undefined
+                    ? {}
+                    : { preparedImagePath: input.loadedPath }),
                 process: started.process,
                 ownsProcessLifetime: true,
                 ownership: started.ownership,
-                shutdownMode: ownsProcessLifetime
-                    ? "process-cleanup"
-                    : "bridge-request",
                 cleanup,
-            });
+            };
+            return ownsProcessLifetime
+                ? ok({
+                    ...ownedLauncher,
+                    providerLifetime: "launcher-process",
+                    shutdownMode: "process-cleanup",
+                })
+                : ok({
+                    ...ownedLauncher,
+                    providerLifetime: "external-application",
+                    shutdownMode: "bridge-request",
+                });
         }
         catch (cause) {
             return err(hopperLaunchFailure(cause, signal));
@@ -144,10 +164,10 @@ export class HopperApplicationLauncher {
             return err(new HopperStartError({ cause }));
         }
     }
-    async #writeBootstrap(session, ownsProcessLifetime) {
+    async #writeBootstrap(session, ownsProcessLifetime, loadedPath) {
         const bootstrapPath = `${session.directory}/bootstrap.py`;
         try {
-            await writeFile(bootstrapPath, bridgeBootstrapSource(session, this.options, ownsProcessLifetime), { encoding: "utf8", mode: 0o600 });
+            await writeFile(bootstrapPath, bridgeBootstrapSource(session, this.options, ownsProcessLifetime, loadedPath), { encoding: "utf8", mode: 0o600 });
             await chmod(bootstrapPath, 0o600);
             return ok(bootstrapPath);
         }
@@ -173,11 +193,11 @@ export class HopperApplicationLauncher {
             };
     }
 }
-const bridgeBootstrapSource = (session, options, ownsProcessLifetime) => [
+const bridgeBootstrapSource = (session, options, ownsProcessLifetime, loadedPath) => [
     `REA_SOCKET = ${JSON.stringify(session.socketPath)}`,
     `REA_TOKEN = ${JSON.stringify(session.token)}`,
     `REA_RUN_ID = ${JSON.stringify(session.runId)}`,
-    `REA_TARGET_PATH = ${JSON.stringify(options.targetPath)}`,
+    `REA_TARGET_PATH = ${JSON.stringify(loadedPath)}`,
     `REA_OWNS_PROCESS_LIFETIME = ${ownsProcessLifetime ? "True" : "False"}`,
     `exec(compile(open(${JSON.stringify(options.bridgeScriptPath)}, 'rb').read(), ${JSON.stringify(options.bridgeScriptPath)}, 'exec'))`,
     "",
@@ -189,6 +209,7 @@ const launchHopperProcess = async (input) => {
         arguments: arguments_,
         runId: input.session.runId,
         expectedCommand: ownershipCommand,
+        ...(input.signal === undefined ? {} : { signal: input.signal }),
     });
     if (input.linuxDemo !== undefined)
         return spawnOwnedProviderProcess({
@@ -196,6 +217,7 @@ const launchHopperProcess = async (input) => {
             arguments: input.linuxDemo.args,
             runId: input.session.runId,
             expectedCommand: ownershipCommand,
+            ...(input.signal === undefined ? {} : { signal: input.signal }),
         });
     return spawn(input.argumentsForTarget);
 };

package/dist/hopper/HopperAnalysisProfile.js

@@ -1,15 +1,37 @@
 import { createHash } from "node:crypto";
 import { createReadStream } from "node:fs";
 import { createAnalysisProfile } from "../domain/analysisProfile.js";
-import { AnalysisCancelledError } from "../domain/analysisErrorCore.js";
+import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, } from "../domain/analysisErrorCore.js";
+import { BinaryTargetError } from "../domain/configurationErrors.js";
 import { ProviderAdapterError } from "../domain/providerAdapterError.js";
 import {} from "../domain/analysisErrorBase.js";
 import { err, ok } from "../domain/result.js";
+import { resolveHopperMachOImage, } from "./HopperMachOImage.js";
 /** Resolve Hopper open semantics without placing its CLI flags in BinaryTarget. */
 export const resolveHopperAnalysisProfile = async (target, options) => {
     if (target.kind !== "executable" && target.kind !== "database")
         return ok({ profile: null, compatibility: {} });
-    const derived = hopperLoaderArgsForTarget(target);
+    let machoContainer;
+    if (target.kind === "executable" && target.format === "mach-o") {
+        const header = await readMachoMagic(target.path, options.signal);
+        if (!header.ok)
+            return header;
+        machoContainer = [0xcafebabf, 0xbfbafeca].includes(header.value)
+            ? "fat64"
+            : [0xcafebabe, 0xbebafeca].includes(header.value)
+                ? "fat32"
+                : "thin";
+    }
+    let preparedImage;
+    if (target.kind === "executable" &&
+        machoContainer === "fat64" &&
+        options.loaderArgsOverride.length === 0) {
+        const resolved = await resolveHopperMachOImage(target, options.signal);
+        if (!resolved.ok)
+            return resolved;
+        preparedImage = resolved.value;
+    }
+    const derived = hopperLoaderArgsForTarget(target, preparedImage === undefined ? machoContainer : "thin");
     if (!derived.ok)
         return derived;
     const loaderArgs = options.loaderArgsOverride.length === 0
@@ -34,6 +56,12 @@ export const resolveHopperAnalysisProfile = async (target, options) => {
             available_architectures: [
                 ...(target.availableArchitectures ?? []),
             ].sort(),
+            ...(machoContainer === undefined
+                ? {}
+                : { macho_container: machoContainer }),
+            ...(preparedImage === undefined
+                ? {}
+                : { prepared_image: { ...preparedImage } }),
             loader: {
                 source: options.loaderArgsOverride.length === 0
                     ? "derived"
@@ -48,7 +76,7 @@ export const resolveHopperAnalysisProfile = async (target, options) => {
     });
 };
 /** Derive Hopper's complete non-interactive CLI loader selection. */
-export const hopperLoaderArgsForTarget = (target) => {
+export const hopperLoaderArgsForTarget = (target, machoContainer) => {
     if (target.kind === "database")
         return ok([]);
     if (target.kind !== "executable")
@@ -57,7 +85,9 @@ export const hopperLoaderArgsForTarget = (target) => {
     const flag = hopperArchitectureFlag(architecture);
     switch (target.format) {
         case "mach-o":
-            return ok((target.availableArchitectures?.length ?? 0) > 1
+            if (machoContainer === undefined)
+                return err(new AnalysisCapabilityUnavailableError("hopper", "resolve_analysis_profile", "Mach-O container kind is unknown; resolve the Hopper analysis profile before starting its client."));
+            return ok(machoContainer === "fat32" || machoContainer === "fat64"
                 ? ["-l", "FAT", flag, "-l", "Mach-O"]
                 : ["-l", "Mach-O", flag]);
         case "elf":
@@ -81,6 +111,34 @@ const hopperArchitectureFlag = (architecture) => {
             return "--aarch64";
     }
 };
+const readMachoMagic = async (path, signal) => {
+    if (signalIsAborted(signal))
+        return err(new AnalysisCancelledError("open_binary"));
+    const stream = createReadStream(path, { start: 0, end: 3 });
+    const onAbort = () => {
+        stream.destroy();
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+    try {
+        const chunks = [];
+        for await (const chunk of stream)
+            chunks.push(Buffer.from(chunk));
+        if (signalIsAborted(signal))
+            return err(new AnalysisCancelledError("open_binary"));
+        const bytes = Buffer.concat(chunks);
+        return bytes.length === 4
+            ? ok(bytes.readUInt32BE(0))
+            : err(new BinaryTargetError(path, "Mach-O header became truncated before Hopper loader selection"));
+    }
+    catch (cause) {
+        return signalIsAborted(signal)
+            ? err(new AnalysisCancelledError("open_binary"))
+            : err(new BinaryTargetError(path, `Cannot read the Mach-O container header: ${cause instanceof Error ? cause.message : String(cause)}`, { cause }));
+    }
+    finally {
+        signal?.removeEventListener("abort", onAbort);
+    }
+};
 const sha256File = async (path, signal) => {
     if (signalIsAborted(signal))
         return err(new AnalysisCancelledError("open_binary"));

package/dist/hopper/HopperCleanup.js

@@ -11,7 +11,7 @@ export const cleanupHopperSession = async (input) => {
         cleanupResult: undefined,
         shutdownConfirmed: false,
     };
-    await report(input.progress, 0, input.retainDocument
+    await report(input.progress, 0, input.retainDocument && input.launch?.preparedImagePath === undefined
         ? "detaching REA from the Hopper document"
         : "requesting Hopper document shutdown");
     await requestShutdown(input, state);
@@ -20,7 +20,18 @@ export const cleanupHopperSession = async (input) => {
     await stopProcess(input, state);
     recordUnconfirmedDocument(input, state);
     await report(input.progress, 0.75, "removing Hopper private runtime files");
-    await closeRuntimeRoot(input.runtimeRoot, state);
+    if (input.launch?.preparedImagePath !== undefined &&
+        !state.shutdownConfirmed) {
+        const resource = input.runtimeRoot?.path ?? input.launch.preparedImagePath;
+        state.resources.add(resource);
+        state.issues.push({
+            resource,
+            reason: "Prepared image retained because native document closure was not confirmed",
+        });
+    }
+    else {
+        await closeRuntimeRoot(input.runtimeRoot, state);
+    }
     return cleanupOutcome(input, state);
 };
 const requestShutdown = async (input, state) => {
@@ -34,7 +45,8 @@ const requestShutdown = async (input, state) => {
             }, "Hopper shutdown skipped because a bridge operation remained active");
         return;
     }
-    const method = input.retainDocument || input.launch?.shutdownMode === "process-cleanup"
+    const method = (input.retainDocument && input.launch?.preparedImagePath === undefined) ||
+        input.launch?.shutdownMode === "process-cleanup"
         ? "shutdown"
         : "shutdown_document";
     const shutdown = await input

package/dist/hopper/HopperClient.js

@@ -6,12 +6,14 @@ import { AnalysisCapabilityUnavailableError } from "../domain/analysisErrorCore.
 import { HopperCancelledError, HopperProcessError, HopperProtocolError, HopperRemoteError, HopperStartError, HopperTimeoutError, } from "../domain/hopperErrors.js";
 import {} from "../domain/analysisErrorBase.js";
 import { hopperStartupFailure, } from "../domain/hopperStartupFailure.js";
+import { providerRetryAction, sharedProviderFailureStage, } from "../domain/providerOperationHealth.js";
 import { err, ok } from "../domain/result.js";
 import { silentLogger } from "../logger.js";
 import { PrivateRuntimeRoot } from "../process/PrivateRuntimeRoot.js";
 import { ProviderStartupDeadline } from "../process/ProviderDeadline.js";
 import { ProviderRunLineage } from "../process/ProviderRunLineage.js";
 import { ProviderProcessSupervisor, } from "../process/ProviderProcess.js";
+import { hopperOperationStage } from "./HopperOperationStage.js";
 import { cleanupHopperSession } from "./HopperCleanup.js";
 import { parseHopperServerInfo, } from "./HopperSessionValues.js";
 import { connectHopperSocketOnce } from "./HopperSocketConnection.js";
@@ -21,7 +23,6 @@ import { HopperResponseStream } from "./HopperResponseStream.js";
 import { responseResult, } from "./protocol.js";
 const SHUTDOWN_TIMEOUT_MS = 30_000;
 const SESSION_ROOT = process.platform === "darwin" ? "/tmp" : tmpdir();
-/** Safe launcher telemetry; stderr content is intentionally never exposed. */
 /**
  * Owns one authenticated NDJSON-over-Unix-socket bridge session.
  *
@@ -45,6 +46,7 @@ export class HopperClient {
     #closing = false;
     #launcherExitCode;
     #launcherFailureDiagnostic;
+    #operationFailure;
     #startupController;
     #startPromise;
     #closePromise;
@@ -52,11 +54,31 @@ export class HopperClient {
         this.#responses.push(chunk);
     };
     #onSocketError = () => {
-        this.#failAll(new HopperProcessError(null));
+        const error = new HopperProcessError(null, undefined, undefined, undefined, "unreachable");
+        this.#failAll(error);
+        this.#rememberProcessFailure(error, []);
     };
     #onSocketClose = () => {
-        if (!this.#closing)
-            this.#failAll(new HopperProcessError(null));
+        if (this.#closing)
+            return;
+        const launch = this.#launch;
+        if (launch?.providerLifetime === "launcher-process" &&
+            this.#launcherExitCode !== undefined)
+            return;
+        if (launch?.providerLifetime === "launcher-process") {
+            setImmediate(() => {
+                if (this.#closing || this.#launcherExitCode !== undefined)
+                    return;
+                const exitCode = launch.process.exitCode ?? null;
+                const error = new HopperProcessError(exitCode, this.#launcherFailureDiagnostic, undefined, undefined, exitCode !== null ? "exited" : "unreachable");
+                this.#failAll(error);
+                this.#rememberProcessFailure(error, []);
+            });
+            return;
+        }
+        const error = new HopperProcessError(null, undefined, undefined, undefined, "unreachable");
+        this.#failAll(error);
+        this.#rememberProcessFailure(error, []);
     };
     constructor(options) {
         this.#logger = options.logger ?? silentLogger;
@@ -91,6 +113,56 @@ export class HopperClient {
     requestActivity() {
         return this.#requests.activity();
     }
+    /**
+     * Latest operational health for this owned bridge.
+     * A recorded exit remains visible after request activity returns to idle.
+     */
+    operationHealth() {
+        const failure = this.#operationFailure;
+        if (failure !== undefined) {
+            const requests = failure.requests.map((request) => ({
+                ...request,
+                stage: failure.startupFailure
+                    ? "launch"
+                    : hopperOperationStage(request.operation),
+            }));
+            return {
+                state: failure.state,
+                stage: requests.length === 0
+                    ? failure.startupFailure
+                        ? "launch"
+                        : "connection"
+                    : sharedProviderFailureStage(requests),
+                retryAction: providerRetryAction(failure.state, failure.startupFailure),
+                exitCode: failure.exitCode,
+                requests,
+            };
+        }
+        const activity = this.requestActivity();
+        if (activity !== null) {
+            const stage = hopperOperationStage(activity.operation);
+            return {
+                state: "busy",
+                stage,
+                retryAction: "wait",
+                exitCode: null,
+                requests: [
+                    {
+                        requestId: activity.requestId,
+                        operation: activity.operation,
+                        stage,
+                    },
+                ],
+            };
+        }
+        return {
+            state: "idle",
+            stage: null,
+            retryAction: null,
+            exitCode: null,
+            requests: [],
+        };
+    }
     /** Launch the bridge once and complete its authenticated health handshake. */
     start(signal) {
         if (this.#closePromise !== undefined) {
@@ -120,8 +192,22 @@ export class HopperClient {
         };
         void started.then((result) => {
             release();
-            if (!result.ok)
+            if (!result.ok) {
+                if (result.error instanceof HopperProcessError)
+                    this.#rememberProcessFailure(result.error, []);
+                else if (this.#operationFailure === undefined &&
+                    (result.error instanceof HopperTimeoutError ||
+                        result.error instanceof HopperStartError))
+                    this.#operationFailure = {
+                        state: result.error instanceof HopperTimeoutError
+                            ? "not_started"
+                            : "unknown",
+                        exitCode: null,
+                        startupFailure: true,
+                        requests: [],
+                    };
                 reset();
+            }
         }, (cause) => {
             this.#logger.debug({ error: cause instanceof Error ? cause.message : String(cause) }, "Hopper startup promise rejected during bookkeeping");
             release();
@@ -132,6 +218,7 @@ export class HopperClient {
     async #start(signal) {
         if (isAborted(signal))
             return err(new HopperCancelledError());
+        this.#operationFailure = undefined;
         if (this.#socket !== undefined || this.#runtimeRoot !== undefined) {
             return err(new HopperProtocolError("Hopper client is already started"));
         }
@@ -283,12 +370,18 @@ export class HopperClient {
     async #connect(socketPath, deadline) {
         while (deadline.remainingMs() > 0) {
             if (deadline.signal.aborted)
-                return err(startupInterruption(deadline));
+                return err(await this.#startupInterruption(deadline));
             if (this.#closing)
                 return err(new HopperProcessError(null));
             if (this.#launcherExitCode !== undefined &&
-                hopperStartupFailure(this.#launcherExitCode) !== undefined)
-                return err(new HopperProcessError(this.#launcherExitCode, this.#launcherFailureDiagnostic));
+                this.#launch !== undefined &&
+                (this.#launch.providerLifetime === "launcher-process" ||
+                    this.#launcherExitCode !== 0)) {
+                const failure = await this.#launcherStartupFailure(this.#launch.providerLifetime === "launcher-process", this.#launcherExitCode, deadline);
+                return deadline.interruption === "cancelled"
+                    ? err(await this.#startupInterruption(deadline))
+                    : err(failure);
+            }
             try {
                 await access(socketPath);
             }
@@ -296,7 +389,7 @@ export class HopperClient {
                 // best-effort cleanup: socket polling; absence means keep waiting.
                 void cause;
                 if ((await deadline.wait(50)) === "aborted")
-                    return err(startupInterruption(deadline));
+                    return err(await this.#startupInterruption(deadline));
                 continue;
             }
             const attempt = await connectHopperSocketOnce(socketPath, deadline.signal);
@@ -306,24 +399,63 @@ export class HopperClient {
                 return ok(undefined);
             }
             if ((await deadline.wait(50)) === "aborted")
-                return err(startupInterruption(deadline));
+                return err(await this.#startupInterruption(deadline));
         }
-        return err(new HopperTimeoutError(this.#options.startupTimeoutMs));
+        return err(await this.#startupInterruption(deadline));
+    }
+    async #startupInterruption(deadline) {
+        if (deadline.interruption === "cancelled")
+            return new HopperCancelledError();
+        return new HopperTimeoutError(deadline.timeoutMs, undefined, undefined, "not_started", "launch", this.#launcherOutcome((await this.#process?.waitForOutputClose(0)) ?? false));
+    }
+    #launcherOutcome(outputClosed) {
+        const snapshot = this.#process?.snapshot();
+        const token = this.#token;
+        if (snapshot === undefined)
+            return undefined;
+        const redact = (text) => token === undefined
+            ? text
+            : text.replaceAll(token, "[redacted transport credential]");
+        return {
+            exit_code: snapshot.exitCode ?? null,
+            signal: snapshot.signal ?? null,
+            stdout: { ...snapshot.stdout, text: redact(snapshot.stdout.text) },
+            stderr: { ...snapshot.stderr, text: redact(snapshot.stderr.text) },
+            output_closed: outputClosed,
+            diagnostic_truncated: snapshot.diagnosticTruncated === true,
+        };
+    }
+    async #launcherStartupFailure(ownsProviderLifetime, exitCode, deadline) {
+        const process = this.#process;
+        // Descendants may inherit the helper's pipes. Bound drainage independently
+        // from readiness, and report whether producer output actually closed.
+        const outputClosed = (await process?.waitForOutputClose(Math.min(1_000, deadline.remainingMs()))) ?? false;
+        const launcherFailure = this.#launcherOutcome(outputClosed);
+        if (ownsProviderLifetime)
+            return new HopperProcessError(exitCode, this.#launcherFailureDiagnostic, undefined, undefined, "exited", "launch", launcherFailure);
+        return new HopperStartError({
+            userMessage: "Hopper's launcher helper failed before bridge readiness. Review details.launcher and complete Hopper setup before retrying.",
+            ...(launcherFailure === undefined ? {} : { launcherFailure }),
+        });
     }
     async #request(method, params, options) {
         const id = this.#nextId++;
         const socket = this.#socket;
         const token = this.#token;
         if (socket === undefined || socket.destroyed || token === undefined) {
-            return err(new HopperProcessError(null, undefined, method, id));
+            return this.#unavailableRequest(new HopperProcessError(null, undefined, method, id, "unreachable", hopperOperationStage(method)));
         }
         if (options.signal?.aborted === true)
             return err(new HopperCancelledError());
         const startedAt = performance.now();
         const result = await this.#requests.run(id, method, params, {
             ...(options.signal === undefined ? {} : { signal: options.signal }),
+            ...(options.timeoutMs === undefined
+                ? {}
+                : { timeoutMs: options.timeoutMs }),
             ...(options.progress !== undefined ? { progress: options.progress } : {}),
         });
+        this.#retainRequestHealth(result, id, method);
         this.#logger[result.ok ? "debug" : "warn"]({
             method,
             durationMs: Math.round((performance.now() - startedAt) * 100) / 100,
@@ -394,8 +526,10 @@ export class HopperClient {
             type: "launcher-exit",
             code: event.code,
         });
-        if (launch.ownsProcessLifetime && !this.#closing)
-            this.#failAll(new HopperProcessError(event.code, this.#launcherFailureDiagnostic));
+        if (launch.providerLifetime === "launcher-process" && !this.#closing) {
+            this.#rememberExit(event.code);
+            this.#failAll(new HopperProcessError(event.code, this.#launcherFailureDiagnostic, undefined, undefined, "exited"));
+        }
     }
     #abortProtocol(message, cause) {
         this.#failAll(new HopperProtocolError(message, { cause }));
@@ -404,7 +538,81 @@ export class HopperClient {
     #failAll(error) {
         this.#requests.failAll(error);
     }
+    #unavailableRequest(error) {
+        this.#rememberProcessFailure(error, error.requestId === undefined || error.operation === undefined
+            ? []
+            : [{ requestId: error.requestId, operation: error.operation }]);
+        return err(error);
+    }
+    #retainRequestHealth(result, requestId, operation) {
+        if (this.#closing)
+            return;
+        if (result.ok)
+            return;
+        if (!(result.error instanceof HopperProcessError))
+            return;
+        this.#rememberProcessFailure(result.error, [
+            {
+                requestId: result.error.requestId ?? requestId,
+                operation: result.error.operation ?? operation,
+            },
+        ]);
+    }
+    #rememberExit(code) {
+        if (this.#closing)
+            return;
+        const previous = this.#operationFailure;
+        this.#operationFailure = {
+            state: "exited",
+            exitCode: code ?? previous?.exitCode ?? null,
+            startupFailure: hopperStartupFailure(code) !== undefined ||
+                previous?.startupFailure === true,
+            requests: previous?.requests ?? [],
+        };
+    }
+    #rememberProcessFailure(error, requests) {
+        if (this.#closing)
+            return;
+        const previous = this.#operationFailure;
+        const state = processFailureState(error);
+        const startupFailure = error.stage === "launch" ||
+            error.failureCode !== undefined ||
+            previous?.startupFailure === true;
+        const merged = mergeFailedRequests(previous?.requests ?? [], requests);
+        if (previous !== undefined &&
+            PROCESS_FAILURE_RANK[previous.state] > PROCESS_FAILURE_RANK[state]) {
+            this.#operationFailure = {
+                ...previous,
+                startupFailure,
+                requests: merged,
+            };
+            return;
+        }
+        this.#operationFailure = {
+            state,
+            exitCode: state === "exited"
+                ? (error.exitCode ?? previous?.exitCode ?? null)
+                : null,
+            startupFailure,
+            requests: merged,
+        };
+    }
 }
+const PROCESS_FAILURE_RANK = {
+    not_started: 0,
+    unknown: 0,
+    unreachable: 1,
+    exited: 2,
+};
+const processFailureState = (error) => error.providerState === "exited" || error.exitCode !== null
+    ? "exited"
+    : error.providerState;
+const mergeFailedRequests = (current, added) => {
+    const byId = new Map();
+    for (const request of [...current, ...added])
+        byId.set(request.requestId, request);
+    return [...byId.values()].sort((left, right) => left.requestId - right.requestId);
+};
 const isAborted = (signal) => signal?.aborted === true;
 const startupInterruption = (deadline) => deadline.interruption === "cancelled"
     ? new HopperCancelledError()