rea-agents 6.1.0 → 6.3.0

package/dist/application/Doctor.js

@@ -1,13 +1,14 @@
 import { constants } from "node:fs";
-import { access, readFile, readdir } from "node:fs/promises";
-import { homedir } from "node:os";
-import { delimiter, join } from "node:path";
+import { access, readdir } from "node:fs/promises";
+import { homeDirectoryFromEnvironment } from "../config/homeDirectory.js";
+import { join } from "node:path";
 import { analysisErrorRemediationAction } from "../domain/analysisErrorPresentation.js";
+import { BinaryTargetError } from "../domain/configurationErrors.js";
 import { parseBinaryTarget } from "./BinaryTargetResolver.js";
 import { execFileOutput } from "../process/ExecFileOutput.js";
-import { probeHomebrew } from "./homebrew.js";
+import { installedCaskAppdir, probeHomebrew } from "./homebrew.js";
 import { linuxHopperBinarySupported, linuxSharedLibrariesAvailable, readLinuxDistribution, } from "./LinuxHopper.js";
-import { canonicalSkillNeedsInstall } from "./SetupSkill.js";
+import { claudeCodeSkillsDirectory, readInstalledSkillIdentity, } from "./SetupSkill.js";
 import { CATALOG_IDENTITY } from "../catalogIdentity.js";
 import { PRODUCT_IDENTITY, SDK_IDENTITY } from "../identity.js";
 import { readClientRegistrationStatuses, } from "./ClientRegistrationStatus.js";
@@ -21,8 +22,9 @@ export const DOCTOR_PROVIDER_IDS = ["hopper", "ghidra", "ida"];
  * or an agent consuming the structured result.
  */
 export const runDoctor = async (target, host = systemDoctorHost(), requestedScope) => {
+    const scope = normalizeDoctorScope(requestedScope, target);
     const { checks: diagnosticChecks, hopperPath, providerInspections, } = await collectDoctorDiagnostics(target, host);
-    const identity = await collectDoctorIdentity(host);
+    const identity = await collectDoctorIdentity(host, scope);
     const checks = [...diagnosticChecks, ...identity.checks];
     const providers = {
         hopperAvailable: hopperPath !== undefined &&
@@ -33,7 +35,6 @@ export const runDoctor = async (target, host = systemDoctorHost(), requestedScop
         providerInspections,
     };
     const environmentHealthy = doctorHealthy(checks, providers);
-    const scope = normalizeDoctorScope(requestedScope, target);
     const scoped = scopeDoctorChecks({
         checks,
         registrations: identity.value.registrations,
@@ -53,11 +54,14 @@ export const runDoctor = async (target, host = systemDoctorHost(), requestedScop
         identity: identity.value,
     };
 };
-const collectDoctorIdentity = async (host) => {
+const collectDoctorIdentity = async (host, scope) => {
     const installationPaths = (await host.installationPaths?.()) ?? [];
-    const installedSkillIdentity = await host.installedSkillIdentity?.();
-    const skillAligned = skillIdentityAligned(installedSkillIdentity);
     const registrations = (await host.clientRegistrations?.()) ?? [];
+    const skillClientIds = scope.mode === "audit-wide"
+        ? registrations.map(({ client }) => client)
+        : scope.clients;
+    const installedSkillIdentity = await host.installedSkillIdentity?.(skillClientIds);
+    const skillAligned = skillIdentityAligned(installedSkillIdentity);
     return {
         checks: [
             ...(skillAligned ? [] : [skillIdentityCheck(installedSkillIdentity)]),
@@ -81,7 +85,6 @@ const collectDoctorIdentity = async (host) => {
             skill: {
                 installed_version: installedSkillIdentity?.version ?? null,
                 installed_tool_count: installedSkillIdentity?.toolCount ?? null,
-                installed_catalog_digest: installedSkillIdentity?.catalogDigest ?? null,
                 state: installedSkillIdentity === undefined
                     ? "missing"
                     : skillAligned
@@ -115,23 +118,13 @@ const registrationCheck = (registration) => ({
     remediation: registration.remediation,
 });
 const installationState = (paths) => paths.length === 0 ? "unknown" : paths.length === 1 ? "single" : "multiple";
-const homeFromEnvironment = (environment, platform) => {
-    const selected = platform === "win32"
-        ? (environment.USERPROFILE ??
-            (environment.HOMEDRIVE !== undefined &&
-                environment.HOMEPATH !== undefined
-                ? `${environment.HOMEDRIVE}${environment.HOMEPATH}`
-                : environment.HOME))
-        : (environment.HOME ?? environment.USERPROFILE);
-    return selected ?? homedir();
-};
 /** Create diagnostics backed by the current process and host commands. */
 export const systemDoctorHost = (options = {}) => {
     const platform = options.platform ?? process.platform;
     const architecture = options.architecture ?? process.arch;
     const environment = options.environment ?? process.env;
     const hostExecFileOutput = options.execFileOutput ?? execFileOutput;
-    const homeDirectory = homeFromEnvironment(environment, platform);
+    const homeDirectory = homeDirectoryFromEnvironment(environment, platform);
     const commandEnvironment = { env: environment };
     return {
         platform,
@@ -147,10 +140,16 @@ export const systemDoctorHost = (options = {}) => {
         macosVersion: () => readMacosVersion(hostExecFileOutput, commandEnvironment),
         linuxDistribution: readLinuxDistribution,
         async validTarget(path) {
-            return (await parseBinaryTarget(path, process.cwd(), architecture)).ok;
+            return (await parseBinaryTarget(path, {
+                cwd: process.cwd(),
+                hostArchitecture: architecture,
+            })).ok;
         },
         async inspectTarget(path) {
-            const result = await parseBinaryTarget(path, process.cwd(), architecture);
+            const result = await parseBinaryTarget(path, {
+                cwd: process.cwd(),
+                hostArchitecture: architecture,
+            });
             if (result.ok)
                 return {
                     name: "target",
@@ -159,18 +158,19 @@ export const systemDoctorHost = (options = {}) => {
                     detail: path,
                 };
             const error = result.error;
+            const targetError = error instanceof BinaryTargetError ? error : undefined;
             return {
                 name: "target",
                 ok: false,
-                classification: error.constraint === "directory_requires_file"
+                classification: targetError?.constraint === "directory_requires_file"
                     ? "unsupported_target"
                     : "config_drift",
                 detail: path,
                 details: {
-                    reason: error.reason,
-                    ...(error.constraint === undefined
+                    reason: targetError?.reason ?? error.message,
+                    ...(targetError?.constraint === undefined
                         ? {}
-                        : { constraint: error.constraint }),
+                        : { constraint: targetError.constraint }),
                 },
                 remediation: analysisErrorRemediationAction(error),
             };
@@ -180,15 +180,21 @@ export const systemDoctorHost = (options = {}) => {
         supportedLinuxHopper: linuxHopperBinarySupported,
         async brewHopperPath() {
             return probeHomebrew(async (command) => {
+                let caskroom;
                 try {
-                    const prefix = (await hostExecFileOutput(command, ["--prefix", "--cask", "hopper-disassembler"], commandEnvironment)).stdout.trim();
-                    return `${prefix}/Hopper Disassembler.app/Contents/MacOS/hopper`;
+                    // Without a cask argument, `--caskroom` does not load Homebrew's
+                    // cask API, so doctor writes no Homebrew cache files.
+                    caskroom = (await hostExecFileOutput(command, ["--caskroom"], commandEnvironment)).stdout.trim();
                 }
                 catch (cause) {
                     // best-effort cleanup: optional Homebrew probing; absence means uninstalled.
                     void cause;
                     return undefined;
                 }
+                const appdir = await installedCaskAppdir(caskroom, "hopper-disassembler", homeDirectory);
+                return appdir === undefined
+                    ? undefined
+                    : join(appdir, "Hopper Disassembler.app/Contents/MacOS/hopper");
             });
         },
         manualHopperPaths: () => manualHopperPaths(homeDirectory),
@@ -222,14 +228,14 @@ export const systemDoctorHost = (options = {}) => {
                 return [];
             }
         },
-        installedSkillIdentity: () => installedSkillIdentity(homeDirectory),
+        installedSkillIdentity: (clientIds) => readInstalledSkillIdentity(homeDirectory, clientIds, claudeCodeSkillsDirectory(homeDirectory, environment)),
         clientRegistrations: () => readClientRegistrationStatuses(homeDirectory, undefined, {
             platform,
             environment,
         }),
     };
 };
-const readMacosVersion = async (run = execFileOutput, options = { env: process.env }) => {
+const readMacosVersion = async (run, options) => {
     try {
         return (await run("sw_vers", ["-productVersion"], options)).stdout.trim();
     }
@@ -239,7 +245,7 @@ const readMacosVersion = async (run = execFileOutput, options = { env: process.e
         return undefined;
     }
 };
-const executableAvailable = async (path, platform = process.platform, run = execFileOutput, options = { env: process.env }) => {
+const executableAvailable = async (path, platform, run, options) => {
     try {
         await access(path, constants.X_OK);
         if (platform !== "linux")
@@ -260,7 +266,7 @@ const uncomposedLinuxDemoRuntimeCheck = () => Promise.resolve({
     detail: "Linux Hopper private-display diagnostics were not composed",
     remediation: "Run rea doctor through the production CLI adapter.",
 });
-const manualHopperPaths = async (home = homedir()) => {
+const manualHopperPaths = async (home) => {
     const paths = [];
     for (const root of ["/Applications", join(home, "Applications")]) {
         try {
@@ -276,25 +282,6 @@ const manualHopperPaths = async (home = homedir()) => {
     }
     return paths;
 };
-const readInstalledSkill = (home) => readFile(join(home, ".agents/skills", PRODUCT_IDENTITY.skillName, "SKILL.md"), "utf8");
-const installedSkillIdentity = async (home) => {
-    try {
-        const content = await readInstalledSkill(home);
-        const countText = /^\s{2}tool_count:\s*(\d+)\s*$/mu.exec(content)?.[1];
-        return {
-            canonical: !(await canonicalSkillNeedsInstall(home)),
-            version: /^\s{2}version:\s*"([^"]+)"\s*$/mu.exec(content)?.[1] ?? null,
-            toolCount: countText === undefined ? null : Number.parseInt(countText, 10),
-            catalogDigest: /^\s{2}catalog_digest:\s*"([a-f0-9]{64})"\s*$/mu.exec(content)?.[1] ??
-                null,
-        };
-    }
-    catch (cause) {
-        // best-effort cleanup: optional skill probing; failure means unknown.
-        void cause;
-        return undefined;
-    }
-};
 const uniqueLines = (value) => [
     ...new Set(value
         .split(/\r?\n/u)

package/dist/application/DoctorDiagnostics.js

@@ -1,4 +1,3 @@
-import { homedir } from "node:os";
 import { SUPPORTED_NODE_VERSION_PROSE, supportsNodeVersion, } from "../domain/runtimeVersion.js";
 import { linuxHopperLauncherPath } from "./LinuxHopper.js";
 const DEFAULT_HOPPER = "/Applications/Hopper Disassembler.app/Contents/MacOS/hopper";
@@ -66,7 +65,7 @@ const hostCheck = async (host) => {
             ? `${host.platform} ${host.architecture}`
             : `${linuxDistribution.id} ${linuxDistribution.versionId ?? "unknown"}`);
     return check("host", supported, detail, {
-        remediation: "REA supports macOS 12+, Ubuntu 24.04+, Fedora 41+, 64-bit Arch Linux, CachyOS, and the experimental Windows x64 Ghidra P0 boundary.",
+        remediation: "REA supports macOS 12+, Ubuntu 24.04+, Fedora 41+, Nobara 44+, 64-bit Arch Linux, CachyOS, and the experimental Windows x64 Ghidra P0 boundary.",
         classification: "unsupported_host",
     });
 };
@@ -75,7 +74,7 @@ const findHopper = async (host) => {
         ? [
             DEFAULT_HOPPER,
             SYSTEM_LINUX_HOPPER,
-            linuxHopperLauncherPath(host.homeDirectory ?? homedir()),
+            linuxHopperLauncherPath(host.homeDirectory),
             ...(await host.manualHopperPaths()),
         ]
         : [host.configuredHopperPath];

package/dist/application/EnhancedTools.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { enhancedInputSchemas } from "../contracts/enhancedInputs.js";
-import { AnalysisCancelledError, AnalysisOutputError, } from "../domain/analysisErrorCore.js";
+import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, AnalysisOutputError, } from "../domain/analysisErrorCore.js";
 import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 import {} from "../domain/analysisErrorBase.js";
 import { addressDistance, functionDossierSchema, parseFunctionDossier, parseListCount, parseRelatedAddresses, parseSegments, } from "../domain/hopperValues.js";
@@ -179,20 +179,34 @@ export class EnhancedTools {
     }
     async #batchDecompile(addresses, signal) {
         const items = await Promise.all(addresses.map(async (address) => {
-            const result = await this.#call("procedure_pseudo_code", { procedure: address }, signal);
+            const resolved = await resolveProcedureAddress(this.#call.bind(this), address, signal);
+            const procedure = resolved.ok
+                ? await this.#batchProcedureIdentity(resolved.value, signal)
+                : {
+                    status: "unknown",
+                    error: projectAnalysisError(resolved.error),
+                };
+            const result = await this.#call("procedure_pseudo_code", { procedure: resolved.ok ? resolved.value : address }, signal);
             if (!result.ok)
                 return {
                     address,
+                    procedure,
                     status: "error",
                     error: projectAnalysisError(result.error),
                 };
             if (typeof result.value !== "string" || result.value.length === 0)
                 return {
                     address,
+                    procedure,
                     status: "error",
                     error: projectAnalysisError(new AnalysisOutputError("procedure_pseudo_code", "provider returned empty pseudocode")),
                 };
-            return { address, status: "ok", pseudocode: result.value };
+            return {
+                address,
+                procedure,
+                status: "ok",
+                pseudocode: result.value,
+            };
         }));
         const succeeded = items.filter(({ status }) => status === "ok").length;
         return ok({
@@ -202,6 +216,23 @@ export class EnhancedTools {
             failed: items.length - succeeded,
         });
     }
+    async #batchProcedureIdentity(address, signal) {
+        const observed = await this.#call("address_name", { address }, signal);
+        const named = observed.ok &&
+            (typeof observed.value === "string" || observed.value === null);
+        return {
+            status: "resolved",
+            address,
+            name: named ? observed.value : null,
+            ...(named
+                ? {}
+                : {
+                    name_error: projectAnalysisError(observed.ok
+                        ? new AnalysisOutputError("address_name", "provider returned an invalid entry label")
+                        : observed.error),
+                }),
+        };
+    }
     async #callGraph(input, signal) {
         const relation = input.direction === "forward" ? "callees" : "callers";
         const tool = input.direction === "forward" ? "procedure_callees" : "procedure_callers";
@@ -254,9 +285,23 @@ export class EnhancedTools {
     }
     async #analyzeSwiftTypes(input, signal) {
         const procedures = await this.#allAddressed("list_procedures", signal);
-        return procedures.ok
-            ? ok(categorizeSwiftTypes(procedures.value, input))
-            : procedures;
+        if (!procedures.ok)
+            return procedures;
+        const symbols = await this.#allAddressed("list_names", signal);
+        if (!symbols.ok &&
+            !(symbols.error instanceof AnalysisCapabilityUnavailableError))
+            return symbols;
+        const result = categorizeSwiftTypes(procedures.value, input, symbols.ok ? symbols.value : []);
+        return ok(symbols.ok
+            ? result
+            : {
+                ...result,
+                symbol_inventory_error: projectAnalysisError(symbols.error),
+                limitations: [
+                    ...result.limitations,
+                    "The provider's symbol inventory is unavailable; demangled procedures could not be joined to their Swift aliases.",
+                ],
+            });
     }
     async #findXrefs(name, signal) {
         const names = await this.#allAddressed("list_names", signal);

package/dist/application/EvidenceBundleFiles.js

@@ -1,7 +1,8 @@
 import { describeEvidenceBundleFailure, describeValidationFailure, parseEvidenceBundle, } from "../domain/evidenceBundle.js";
 import { EvidenceFileError, EvidenceIntegrityError, } from "../domain/evidenceErrors.js";
 import { err, ok } from "../domain/result.js";
-import { parseProcessCapture } from "../domain/process/processCapture.js";
+import { AnalysisCancelledError, } from "../domain/analysisErrorCore.js";
+import { parseProcessCapture } from "../domain/process/processCaptureParsing.js";
 import { bufferedJsonParts, canonicalJsonParts, } from "../domain/jsonSerialization.js";
 import { readJsonFile, writeTextParts } from "./JsonFiles.js";
 /** Read and validate an evidence bundle at the caller-supplied path. */
@@ -35,7 +36,9 @@ export const readEvidenceBundle = async (path) => {
     return ok(bundle);
 };
 /** Atomically write deterministic evidence JSON at the caller-supplied path. */
-export const writeEvidenceBundle = async (bundle, path, overwrite) => {
+export const writeEvidenceBundle = async (bundle, path, overwrite, signal) => {
+    if (signal?.aborted === true)
+        return err(new AnalysisCancelledError("export_evidence_bundle"));
     let checked;
     try {
         checked = parseEvidenceBundle(bundle);
@@ -45,5 +48,7 @@ export const writeEvidenceBundle = async (bundle, path, overwrite) => {
             cause,
         }));
     }
-    return writeTextParts(bufferedJsonParts(canonicalJsonParts(checked)), path, overwrite);
+    return writeTextParts(bufferedJsonParts(canonicalJsonParts(checked)), path, overwrite, signal === undefined
+        ? undefined
+        : { signal, operation: "export_evidence_bundle" });
 };

package/dist/application/InvestigationProviders.js

@@ -8,20 +8,22 @@ export const REA_WORKFLOW_PROVIDER = {
 /** Commit a workflow result to its upstream profile and applicable semantic revision. */
 export const workflowAnalysisProfile = (upstream, operation) => createAnalysisProfile(REA_WORKFLOW_PROVIDER, {
     upstream_analysis_profile: upstream,
-    ...(operation === "binary_overview" ? { workflow_revision: 2 } : {}),
+    ...(operation === "binary_overview" || operation === "batch_decompile"
+        ? { workflow_revision: 2 }
+        : {}),
 });
 /** Provider identity for deterministic artifact inventories. */
-export const ARTIFACT_GRAPH_PROVIDER = {
+export const ARTIFACT_GRAPH_PROVIDER = Object.freeze({
     id: "rea-artifact-graph",
     name: "REA safe artifact graph provider",
     version: "1",
-};
+});
 /** Provider identity for execution-free managed PE/CLI analysis. */
-export const MANAGED_STATIC_PROVIDER = {
+export const MANAGED_STATIC_PROVIDER = Object.freeze({
     id: "rea-dotnet-static",
     name: "REA managed static analysis provider",
     version: "1",
-};
+});
 /** Provider identity for deterministic managed-code comparison workflows. */
 export const MANAGED_WORKFLOW_PROVIDER = {
     id: "rea-dotnet-workflows",
@@ -58,6 +60,12 @@ export const JAVASCRIPT_RUNTIME_RECONCILIATION_PROVIDER = {
     name: "REA JavaScript runtime reconciliation",
     version: "1",
 };
+/** Provider identity for selected views of retained analysis Evidence. */
+export const ANALYSIS_VIEW_PROVIDER = {
+    id: "rea-analysis-view",
+    name: "REA analysis view projection",
+    version: "1",
+};
 /** Provider identity for graph-native feature tracing and version comparison. */
 export const JAVASCRIPT_APPLICATION_WORKFLOW_PROVIDER = {
     id: "rea-javascript-application-workflows",

package/dist/application/JsonFiles.js

@@ -1,30 +1,31 @@
-import { link, lstat, mkdtemp, open, readFile, realpath, rename, rm, } from "node:fs/promises";
+import { link, lstat, mkdtemp, open, realpath, rename, rm, } from "node:fs/promises";
 import { basename, dirname, resolve } from "node:path";
 import { EvidenceFileError } from "../domain/evidenceErrors.js";
+import { AnalysisCancelledError, AnalysisResourceConstraintError, } from "../domain/analysisErrorCore.js";
 import { err, ok } from "../domain/result.js";
+import { parseUtf8Json } from "./Utf8JsonInput.js";
+import { readRegularFile } from "./RegularFileRead.js";
+import { NonRegularFileReadError } from "../filesystem/RegularFile.js";
 /** Read JSON data from a regular file at the caller-supplied path. */
 export const readJsonFile = async (path) => {
     const requestedPath = resolve(path);
     try {
-        const canonicalPath = await realpath(requestedPath);
-        const stats = await lstat(canonicalPath);
-        if (!stats.isFile())
-            return err(new EvidenceFileError("read", "not-file", { path: requestedPath }));
-        const encoded = await readFile(canonicalPath);
-        let decoded;
-        try {
-            decoded = JSON.parse(new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(encoded));
-        }
-        catch (cause) {
+        const encoded = await readRegularFile(requestedPath);
+        const decoded = parseUtf8Json(encoded, "read_evidence_file", requestedPath);
+        if (!decoded.ok) {
             return err(new EvidenceFileError("read", "invalid-json", {
-                cause,
+                cause: decoded.cause,
                 path: requestedPath,
             }));
         }
-        return ok(decoded);
+        return ok(decoded.value);
     }
     catch (cause) {
-        return err(new EvidenceFileError("read", missingOrIo(cause), {
+        if (cause instanceof AnalysisResourceConstraintError)
+            return err(cause);
+        return err(new EvidenceFileError("read", cause instanceof NonRegularFileReadError
+            ? "not-file"
+            : missingOrIo(cause), {
             cause,
             path: requestedPath,
         }));
@@ -32,10 +33,10 @@ export const readJsonFile = async (path) => {
 };
 /** Atomically write text to the caller-supplied path. */
 export const writeTextFile = async (encoded, path, overwrite) => writeTextParts([encoded], path, overwrite);
-/** Publish complete streamed text atomically, keeping only one encoded part in memory. */
-export const writeTextParts = async (parts, path, overwrite) => {
+export async function writeTextParts(parts, path, overwrite, cancellation) {
     const requestedPath = resolve(path);
     try {
+        assertWriteActive(cancellation);
         const canonicalParent = await realpath(dirname(requestedPath));
         const destination = resolve(canonicalParent, basename(requestedPath));
         const existing = await lstat(destination).catch((cause) => {
@@ -49,10 +50,15 @@ export const writeTextParts = async (parts, path, overwrite) => {
             if (!existing.isFile() || existing.isSymbolicLink())
                 return err(new EvidenceFileError("write", "not-file", { path: requestedPath }));
         }
-        const bytes = await publishFile(destination, parts, overwrite);
+        assertWriteActive(cancellation);
+        const bytes = await publishFile(destination, parts, overwrite, cancellation);
         return ok({ path: requestedPath, bytes });
     }
     catch (cause) {
+        if (cancellation?.signal.aborted === true &&
+            cause instanceof AnalysisCancelledError &&
+            cause.operation === cancellation.operation)
+            return err(cause);
         if (!overwrite && fileErrorCode(cause) === "EEXIST")
             return err(new EvidenceFileError("write", "exists", {
                 cause,
@@ -63,28 +69,28 @@ export const writeTextParts = async (parts, path, overwrite) => {
             path: requestedPath,
         }));
     }
-};
+}
 /** A missing path or parent is a selection error, not a permission failure. */
 const missingOrIo = (cause) => {
     const code = fileErrorCode(cause);
     return code === "ENOENT" || code === "ENOTDIR" ? "missing" : "io";
 };
-const publishFile = async (destination, parts, overwrite) => {
+const publishFile = async (destination, parts, overwrite, cancellation) => {
     const stagingDirectory = await mkdtemp(resolve(dirname(destination), ".rea-write-"));
     try {
         const staged = resolve(stagingDirectory, "content");
         const file = await open(staged, "wx", 0o600);
         let bytes = 0;
         try {
-            for (const part of parts) {
-                await file.writeFile(part, { encoding: "utf8" });
-                bytes += Buffer.byteLength(part, "utf8");
-            }
+            bytes = await writeStagedParts(file, parts, cancellation);
+            assertWriteActive(cancellation);
             await file.sync();
         }
         finally {
             await file.close();
         }
+        // Once submitted, the atomic publication can win a later cancellation race.
+        assertWriteActive(cancellation);
         if (overwrite)
             await rename(staged, destination);
         // A hard link publishes complete bytes atomically and cannot replace an existing name.
@@ -96,6 +102,33 @@ const publishFile = async (destination, parts, overwrite) => {
         await rm(stagingDirectory, { recursive: true, force: true });
     }
 };
+const writeStagedParts = async (file, parts, cancellation) => {
+    assertWriteActive(cancellation);
+    const iterator = parts[Symbol.iterator]();
+    let exhausted = false;
+    let bytes = 0;
+    try {
+        for (;;) {
+            assertWriteActive(cancellation);
+            const part = iterator.next();
+            if (part.done)
+                exhausted = true;
+            assertWriteActive(cancellation);
+            if (part.done)
+                return bytes;
+            await file.writeFile(part.value, { encoding: "utf8" });
+            bytes += Buffer.byteLength(part.value, "utf8");
+        }
+    }
+    finally {
+        if (!exhausted)
+            iterator.return?.();
+    }
+};
+const assertWriteActive = (cancellation) => {
+    if (cancellation?.signal.aborted === true)
+        throw new AnalysisCancelledError(cancellation.operation);
+};
 const fileErrorCode = (cause) => typeof cause === "object" && cause !== null && "code" in cause
     ? cause.code
     : undefined;

package/dist/application/LinuxHopper.js

@@ -63,7 +63,8 @@ export const parseLinuxDistribution = (text) => {
         (id === "arch" ||
             id === "cachyos" ||
             (id === "ubuntu" && versionAtLeast(versionId, 24)) ||
-            (id === "fedora" && versionAtLeast(versionId, 41)));
+            (id === "fedora" && versionAtLeast(versionId, 41)) ||
+            (id === "nobara" && versionAtLeast(versionId, 44)));
     const identity = {
         id,
         ...(versionId === undefined ? {} : { versionId }),
@@ -84,7 +85,7 @@ export const readLinuxDistribution = async () => {
     }
 };
 /** Download, verify, install, and read back the official Hopper Linux package. */
-export const installLinuxHopper = async (host = systemLinuxHopperInstallHost(), options = {}) => {
+export const installLinuxHopper = async (host = systemLinuxHopperInstallHost(process.env), options = {}) => {
     if (options.signal?.aborted === true)
         return { status: "failed", reason: "cancelled" };
     const distribution = await host.distribution();
@@ -124,7 +125,8 @@ export const installLinuxHopper = async (host = systemLinuxHopperInstallHost(),
 };
 /** Canonical launcher path for a legacy user-local Linux Hopper installation. */
 export const linuxHopperLauncherPath = (home) => join(home, ".local/share/rea/hopper/bin/Hopper");
-const systemLinuxHopperInstallHost = () => ({
+/** Compose package-manager and linker checks from the selected caller environment. */
+export const systemLinuxHopperInstallHost = (environment) => ({
     distribution: readLinuxDistribution,
     async download(url, options) {
         const response = await fetch(url, {
@@ -138,11 +140,11 @@ const systemLinuxHopperInstallHost = () => ({
     },
     createTemporaryDirectory: () => mkdtemp(join(tmpdir(), "rea-hopper-")),
     writeArchive: (path, bytes) => writeFile(path, bytes, { mode: 0o600 }),
-    installPackage: installSystemPackage,
+    installPackage: (family, archive) => installSystemPackage(family, archive, environment),
     async launcherStatus(path) {
         try {
             await access(path);
-            const linked = await execFileOutput("ldd", [path]);
+            const linked = await execFileOutput("ldd", [path], { env: environment });
             if (!linuxSharedLibrariesAvailable(`${linked.stdout}\n${linked.stderr}`))
                 return "runtime_dependencies";
             return (await linuxHopperBinarySupported(path))
@@ -175,10 +177,12 @@ export const linuxHopperBinarySupported = async (path) => {
 export const linuxHopperLauncherDigestSupported = (digest) => SUPPORTED_HOPPER_SHA256.has(digest);
 /** Interpret ldd output conservatively so a present but broken launcher is unhealthy. */
 export const linuxSharedLibrariesAvailable = (output) => !/(?:=>\s+not found|error while loading shared libraries)/iu.test(output);
-const installSystemPackage = async (family, archive) => {
+const installSystemPackage = async (family, archive, environment) => {
     try {
         for (const command of linuxPackageManagerCommands(family, archive, process.getuid?.() === 0))
-            await execFileAsync(command.executable, command.args);
+            await execFileAsync(command.executable, command.args, {
+                env: environment,
+            });
         return true;
     }
     catch (cause) {