rea-agents 0.5.0 → 1.1.0

package/dist/application/Setup.js

@@ -1,30 +1,30 @@
 import { access, copyFile, mkdir, readFile, rename, rm, writeFile, } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
 import { z } from "zod";
 import writeFileAtomic from "write-file-atomic";
 import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
 import { PRODUCT_IDENTITY } from "../identity.js";
+import { supportsNodeVersion } from "../domain/runtimeVersion.js";
 import { runDoctor, systemDoctorHost } from "./Doctor.js";
-import { probeHomebrew } from "./homebrew.js";
 import { installLinuxHopper, readLinuxDistribution, } from "./LinuxHopper.js";
-const execFileAsync = promisify(execFile);
+import { installMacHopper } from "./MacHopper.js";
 const registrationCommand = () => process.env.npm_command === "exec"
     ? ["npx", "-y", PRODUCT_IDENTITY.packageName, "mcp"]
     : [resolve(process.argv[1] ?? PRODUCT_IDENTITY.cliBinary), "mcp"];
 /**
  * Install prerequisites and configure detected clients idempotently.
- * With `yes` false, mutations requiring consent are reported as `needs_human`;
- * with `yes` true, external installers still fail closed if they require UI.
+ * Discovery always precedes mutation. Interactive confirmation or explicit
+ * unattended options authorize only the actions represented in the result.
  */
-export const runSetup = async (yes, host = systemSetupHost()) => {
-    const actions = [];
+export const runSetup = async (options, host = systemSetupHost(), confirm) => {
+    const appliedActions = [];
+    let plannedActions = [];
     const clients = {};
     const fail = async (remediation) => ({
         status: "needs_human",
-        actions,
+        plannedActions,
+        appliedActions,
         clients,
         doctor: await host.doctor(),
         remediation,
@@ -32,43 +32,85 @@ export const runSetup = async (yes, host = systemSetupHost()) => {
     const unsupported = await hostRemediation(host);
     if (unsupported !== undefined)
         return fail(unsupported);
-    if (host.platform === "darwin" && !(await host.hasHomebrew())) {
-        if (!yes)
-            return fail("Re-run with --yes to install Homebrew.");
-        if (!(await host.installHomebrew()))
-            return fail("Homebrew installation was interrupted; resolve the installer prompt and re-run setup.");
-        actions.push("installed_homebrew");
-    }
     let hopperPath = await host.hopperPath();
-    if (hopperPath === undefined) {
-        if (!yes)
-            return fail("Re-run with --yes to install Hopper.");
-        if (!(await host.installHopper()))
-            return fail("Hopper installation was interrupted; resolve the system prompt and re-run setup.");
-        actions.push("installed_hopper");
-        hopperPath = await host.hopperPath();
+    const detectedClients = await host.detectedClients();
+    plannedActions = [
+        ...(hopperPath === undefined
+            ? [
+                {
+                    kind: "install_hopper",
+                    target: host.platform === "darwin"
+                        ? "~/Applications/Hopper Disassembler.app"
+                        : "system package manager",
+                    detail: "Download the official Hopper package, verify it, install it, and open Hopper for activation.",
+                    external: true,
+                },
+            ]
+            : []),
+        ...detectedClients
+            .filter(({ format }) => format !== "unsupported")
+            .map((client) => ({
+            kind: "configure_client",
+            target: client.configPath,
+            detail: `Add the REA MCP registration for ${client.name}; preserve unrelated configuration.`,
+            external: false,
+        })),
+        {
+            kind: "install_skill",
+            target: "~/.agents/skills/rea-analysis/SKILL.md",
+            detail: "Install or update the bundled REA analysis skill.",
+            external: false,
+        },
+    ];
+    let approved = options.approved;
+    let interactiveApproval = false;
+    if (!approved && confirm !== undefined && !options.structured) {
+        interactiveApproval = await confirm(plannedActions);
+        approved = interactiveApproval;
+    }
+    if (!approved)
+        return {
+            status: confirm === undefined ? "needs_confirmation" : "planned",
+            plannedActions,
+            appliedActions,
+            clients,
+            doctor: await host.doctor(),
+            remediation: "Review the setup plan, then rerun interactively or with --yes.",
+        };
+    if (hopperPath === undefined &&
+        (interactiveApproval || options.installHopper)) {
+        hopperPath = await host.installHopper();
         if (hopperPath === undefined)
-            return fail("Hopper installation completed but its launcher was not found.");
+            return {
+                status: "needs_human",
+                plannedActions,
+                appliedActions,
+                clients,
+                doctor: await host.doctor(),
+                remediation: "Hopper installation failed; install Hopper manually or rerun setup after resolving the reported system error.",
+            };
+        appliedActions.push("installed_hopper");
     }
-    for (const client of await host.detectedClients()) {
+    for (const client of detectedClients) {
         const result = await host.configureClient(client, hopperPath, registrationCommand());
         clients[client.name] = result;
         if (result.status === "failed")
             return fail(`${client.name} configuration ${result.reason} verification failed; no successful configuration was reported.`);
         if (result.status === "configured")
-            actions.push(`configured_${client.name}`);
+            appliedActions.push(`configured_${client.name}`);
     }
     const skill = await host.installSkill();
     if (skill === "failed")
         return fail("Agent skill installation or readback failed.");
     if (skill === "installed")
-        actions.push("installed_skill");
+        appliedActions.push("installed_skill");
     const doctor = await host.doctor();
-    const activationRequired = actions.includes("installed_hopper");
+    const activationRequired = appliedActions.includes("installed_hopper");
     const ready = doctor.healthy && !activationRequired;
     return {
         status: ready ? "ready" : "needs_human",
-        actions,
+        plannedActions,
+        appliedActions,
         clients,
         doctor,
         ...(ready
@@ -76,15 +118,17 @@ export const runSetup = async (yes, host = systemSetupHost()) => {
             : {
                 remediation: activationRequired
                     ? "Open Hopper, complete its one-time activation, then rerun rea doctor --json."
-                    : "Run rea doctor and apply each reported remediation.",
+                    : hopperPath === undefined
+                        ? "Hopper is optional for non-Hopper providers. Rerun with --yes --install-hopper for deep native analysis."
+                        : "Run rea doctor and apply each reported remediation.",
             }),
     };
 };
 const hostRemediation = async (host) => {
     if (host.platform !== "darwin" && host.platform !== "linux")
         return "REA supports Hopper on macOS and selected 64-bit Linux distributions.";
-    if (major(host.nodeVersion) < 24)
-        return "Install Node.js 24.18 or newer.";
+    if (!supportsNodeVersion(host.nodeVersion))
+        return "Install Node.js 22.19+ or 24.11+ and rerun setup.";
     if (host.platform === "darwin") {
         const version = await host.macosVersion();
         return version === undefined || major(version) < 12
@@ -95,7 +139,7 @@ const hostRemediation = async (host) => {
         ? undefined
         : "REA supports Hopper on Ubuntu 24.04+, Fedora 41+, and 64-bit Arch Linux.";
 };
-/** Production setup effects for macOS, Homebrew, JSON MCP clients, and the canonical skill directory. */
+/** Production setup effects for Hopper, agent configuration, and the canonical skill directory. */
 const systemSetupHost = () => {
     const doctorHost = systemDoctorHost();
     return {
@@ -103,15 +147,13 @@ const systemSetupHost = () => {
         nodeVersion: process.versions.node,
         macosVersion: () => doctorHost.macosVersion(),
         linuxDistribution: readLinuxDistribution,
-        hasHomebrew: () => brewSucceeds(["--version"]),
-        installHomebrew: () => commandSucceeds("/bin/bash", [
-            "-c",
-            "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)",
-        ], { ...process.env, NONINTERACTIVE: "1" }),
         hopperPath: async () => (await runDoctor(undefined, doctorHost)).hopperPath,
-        installHopper: () => process.platform === "linux"
-            ? installLinuxHopper().then(({ status }) => status === "installed")
-            : brewSucceeds(["install", "--cask", "hopper-disassembler"]),
+        installHopper: async () => {
+            const result = process.platform === "linux"
+                ? await installLinuxHopper()
+                : await installMacHopper();
+            return result.status === "installed" ? result.launcherPath : undefined;
+        },
         detectedClients: () => detectClients(homedir()),
         configureClient: (client, hopperPath, command) => client.format === "unsupported"
             ? Promise.resolve({ status: "skipped" })
@@ -351,19 +393,6 @@ export const installCanonicalSkill = async (home) => {
         return "failed";
     }
 };
-const commandSucceeds = async (command, args, env) => {
-    try {
-        await execFileAsync(command, args, env === undefined ? {} : { env });
-        return true;
-    }
-    catch {
-        return false;
-    }
-};
-const brewSucceeds = async (args) => {
-    const result = await probeHomebrew(async (command) => (await commandSucceeds(command, args)) ? true : undefined);
-    return result === true;
-};
 const major = (version) => Number.parseInt(version.split(".")[0] ?? "0", 10);
 const exists = async (path) => {
     try {

package/dist/application/Upgrade.js

@@ -0,0 +1,106 @@
+import { execFile, spawn } from "node:child_process";
+import { realpath } from "node:fs/promises";
+import { basename, dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+import { z } from "zod";
+import { PRODUCT_IDENTITY } from "../identity.js";
+const execFileAsync = promisify(execFile);
+const registryResponseSchema = z.object({ version: z.string().min(1) });
+const UPGRADE_COMMAND = "npm install --global rea-agents@latest";
+/** Check the npm registry and update the same global REA installation. */
+export const runUpgrade = async (currentVersion, host = systemUpgradeHost(), output = "human") => {
+    const latestVersion = await host.latestVersion();
+    if (latestVersion === currentVersion)
+        return {
+            status: "current",
+            currentVersion,
+            latestVersion,
+            installMethod: "npm",
+        };
+    const installation = await host.installation();
+    if (installation === undefined)
+        return {
+            status: "failed",
+            currentVersion,
+            latestVersion: latestVersion ?? null,
+            reason: "unknown-install-method",
+            remediation: `Update manually with: ${UPGRADE_COMMAND}`,
+        };
+    if (!(await host.installLatest(installation, output)))
+        return {
+            status: "failed",
+            currentVersion,
+            latestVersion: latestVersion ?? null,
+            reason: "install",
+            remediation: `${UPGRADE_COMMAND} failed.`,
+        };
+    return {
+        status: "upgraded",
+        previousVersion: currentVersion,
+        latestVersion: latestVersion ?? null,
+        versionCheck: latestVersion === undefined ? "unavailable" : "available",
+        installMethod: "npm",
+        command: UPGRADE_COMMAND,
+    };
+};
+/** Create the npm registry and subprocess effects for a production upgrade. */
+export const systemUpgradeHost = () => ({
+    latestVersion: async () => {
+        try {
+            const response = await fetch(`https://registry.npmjs.org/${PRODUCT_IDENTITY.packageName}/latest`, { signal: AbortSignal.timeout(10_000) });
+            if (!response.ok)
+                return undefined;
+            const parsed = registryResponseSchema.safeParse(await response.json());
+            return parsed.success ? parsed.data.version : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    },
+    installation: () => detectNpmInstallation(fileURLToPath(new URL("../..", import.meta.url)), systemNpmInstallationHost),
+    installLatest: ({ prefix }, output) => runCommand("npm", [
+        "install",
+        "--global",
+        "--prefix",
+        prefix,
+        `${PRODUCT_IDENTITY.packageName}@latest`,
+    ], output),
+});
+const systemNpmInstallationHost = {
+    canonicalPath: realpath,
+    globalRoot: async () => (await execFileAsync("npm", ["root", "--global"])).stdout.trim(),
+    globalPrefix: async () => (await execFileAsync("npm", ["prefix", "--global"])).stdout.trim(),
+};
+/** Identify the npm prefix only when it owns the running package. */
+export const detectNpmInstallation = async (packageRoot, host) => {
+    try {
+        const canonicalPackageRoot = await host.canonicalPath(packageRoot);
+        const npmRoot = await host.globalRoot();
+        const globalPackageRoot = await host.canonicalPath(resolve(npmRoot, PRODUCT_IDENTITY.packageName));
+        if (canonicalPackageRoot === globalPackageRoot) {
+            const prefix = await host.globalPrefix();
+            return prefix.length === 0 ? undefined : { prefix };
+        }
+        return inferUnixGlobalPrefix(canonicalPackageRoot);
+    }
+    catch {
+        return inferUnixGlobalPrefix(packageRoot);
+    }
+};
+const inferUnixGlobalPrefix = (packageRoot) => {
+    const nodeModules = dirname(packageRoot);
+    const library = dirname(nodeModules);
+    if (basename(packageRoot) !== PRODUCT_IDENTITY.packageName ||
+        basename(nodeModules) !== "node_modules" ||
+        basename(library) !== "lib")
+        return undefined;
+    return { prefix: dirname(library) };
+};
+const runCommand = (command, arguments_, output) => new Promise((resolveResult) => {
+    const child = spawn(command, [...arguments_], {
+        stdio: output === "human" ? "inherit" : ["inherit", process.stderr, "inherit"],
+    });
+    child.once("error", () => resolveResult(false));
+    child.once("exit", (code) => resolveResult(code === 0));
+});

package/dist/cli.js

@@ -1,9 +1,11 @@
 import { Cli, z } from "incur";
 import { fileURLToPath } from "node:url";
+import { createInterface } from "node:readline/promises";
 import { runDoctor } from "./application/Doctor.js";
 import { runDirectAnalysis, runProviderAnalysis, runSessionStatus, } from "./application/DirectAnalysis.js";
 import { runSetup } from "./application/Setup.js";
 import { runUninstall } from "./application/Uninstall.js";
+import { runUpgrade, systemUpgradeHost } from "./application/Upgrade.js";
 import { PRODUCT_IDENTITY } from "./identity.js";
 import { createLogger, parseLogLevel } from "./logger.js";
 import { logCliCommand } from "./cliLogging.js";
@@ -59,10 +61,20 @@ const registerCoreCommands = (cli, logger) => {
             yes: z
                 .boolean()
                 .default(false)
-                .describe("Approve prerequisite installation"),
+                .describe("Approve user-owned setup actions without prompting"),
+            installHopper: z
+                .boolean()
+                .default(false)
+                .describe("Also approve Hopper installation with --yes"),
         }),
-        alias: { yes: "y" },
-        run: ({ options }) => logCliCommand(logger, "setup", () => runSetup(options.yes)),
+        alias: { yes: "y", installHopper: "install-hopper" },
+        run: ({ options, formatExplicit }) => logCliCommand(logger, "setup", () => runSetup({
+            approved: options.yes,
+            installHopper: options.installHopper,
+            structured: formatExplicit,
+        }, undefined, options.yes || formatExplicit || process.stdin.isTTY !== true
+            ? undefined
+            : confirmSetup)),
     });
     cli.command("doctor", {
         description: "Check whether REA is ready",
@@ -82,6 +94,10 @@ const registerCoreCommands = (cli, logger) => {
         alias: { purgeData: "purge-data" },
         run: ({ options }) => logCliCommand(logger, "uninstall", () => runUninstall(options.purgeData)),
     });
+    cli.command("upgrade", {
+        description: "Upgrade a global npm installation to the latest REA release",
+        run: ({ formatExplicit }) => logCliCommand(logger, "upgrade", () => runUpgrade(process.env.REA_PACKAGE_VERSION ?? "0.0.0-development", systemUpgradeHost(), formatExplicit ? "structured" : "human")),
+    });
     cli.command("analyze", {
         description: "Get an overview of an app",
         args: z.object({
@@ -107,6 +123,24 @@ const registerCoreCommands = (cli, logger) => {
         run: ({ args }) => logCliCommand(logger, "decompile", () => runDirectAnalysis(args.path, "procedure_pseudo_code", { procedure: args.address }, logger)),
     });
 };
+const confirmSetup = async (actions) => {
+    process.stdout.write("\nREA setup plan\n");
+    for (const action of actions)
+        process.stdout.write(`  - ${action.detail}\n    ${action.target}${action.external ? " (external software)" : ""}\n`);
+    const prompt = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    try {
+        const answer = (await prompt.question("Continue? [Y/n] "))
+            .trim()
+            .toLowerCase();
+        return answer === "" || answer === "y" || answer === "yes";
+    }
+    finally {
+        prompt.close();
+    }
+};
 const registerXrefsCommand = (cli, logger) => {
     cli.command("xrefs", {
         description: "List bounded references to an analyzed address",

package/dist/contracts/toolContracts.js

@@ -146,10 +146,10 @@ export const ENHANCED_TOOL_CONTRACTS = [
     enhanced("swift_classes", "Discover legacy-mangled Swift class procedures after exhaustively paging analyzed procedures. Returns at most 100 entries and scans at most 5,000 symbols; use analyze_swift_types for other Swift kinds.", enhancedInputSchemas.swift_classes),
     enhanced("get_objc_classes", "Discover and deduplicate Objective-C class labels after exhaustively paging names, optionally filtering by literal substring. Returns at most 100 classes; inspect matching metadata and references next.", enhancedInputSchemas.get_objc_classes),
     enhanced("get_objc_protocols", "Discover and deduplicate Objective-C and Swift protocol labels after exhaustively paging names. Returns at most 100 entries; use xrefs or analyze_function to connect a protocol to implementations.", enhancedInputSchemas.get_objc_protocols),
-    enhanced("batch_decompile", "Decompile up to 20 explicit procedure symbols or addresses concurrently. Per-item strings may contain errors or no-output markers, so validate each result; use analyze_function for a richer single-function dossier.", enhancedInputSchemas.batch_decompile),
-    enhanced("get_call_graph", "Traverse Hopper's caller or callee relationships from one symbol or address for at most five levels. Nodes preserve per-procedure errors; indirect calls may be missing and results are not a whole-program CFG.", enhancedInputSchemas.get_call_graph),
+    enhanced("batch_decompile", "Decompile up to 20 explicit procedure symbols or addresses concurrently. Returns ordered per-item ok/error variants and aggregate counts; use analyze_function for a richer single-function dossier.", enhancedInputSchemas.batch_decompile),
+    enhanced("get_call_graph", "Traverse Hopper's caller or callee relationships from one symbol or address for at most five levels. Every node has an ok/error status and failures use safe typed projections; indirect calls may be missing and results are not a whole-program CFG.", enhancedInputSchemas.get_call_graph),
     enhanced("analyze_swift_types", "Categorize exhaustively paged procedure names into Swift classes, structs, enums, protocols, extensions, and other symbols. Scans at most 5,000 names and returns at most 50 entries per category.", enhancedInputSchemas.analyze_swift_types),
-    enhanced("find_xrefs_to_name", "Resolve a name through Hopper and return analyzed references to its address. Use when starting from a selector or symbol; resolution failure is returned explicitly and xrefs remain untyped.", enhancedInputSchemas.find_xrefs_to_name),
+    enhanced("find_xrefs_to_name", "Resolve an exact name through Hopper's exhaustively paged name inventory and return a resolved or unresolved result. Unresolved names use the stable name_not_found reason; xrefs remain untyped.", enhancedInputSchemas.find_xrefs_to_name),
     enhanced("binary_overview", "Use immediately after opening a target to summarize document, exhaustive procedure/string counts, and a bounded segment sample. detail controls segment fields and limit controls only the returned segment sample.", enhancedInputSchemas.binary_overview),
     enhanced("analyze_function", "Preferred bounded analysis for one procedure symbol or address. Returns identity, pseudocode, optional assembly, comments, calls, incoming references, and blocks; unsupported outgoing references and CFG edges carry explicit unavailable metadata.", enhancedInputSchemas.analyze_function),
     enhanced("trace_feature", "Trace a bounded literal feature query through matching strings and procedures, xrefs, and truthful containing-procedure resolution. Returns the operation budget, truncation, and residual unknowns; unknown_registry_approved: true records them durably without inferring reference kinds.", enhancedInputSchemas.trace_feature),

package/dist/contracts/toolOutputSchemas.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { ANALYSIS_ERROR_TAGS } from "../domain/errors.js";
 import { evidenceSchema } from "../domain/evidence.js";
 import { processCaptureComparisonSchema, processCaptureSchema, } from "../domain/processCapture.js";
 import { evidenceBundleSchema } from "../domain/evidenceBundle.js";
@@ -149,9 +150,24 @@ const symbolDiscoveryOutput = (property) => resultOf(z.object({
     count: z.number().int().min(0),
     [property]: z.array(addressedEntry),
 }));
-const graphNode = z.union([
-    z.object({ address: z.string(), calls: z.array(z.string()) }),
-    z.object({ address: z.string(), error: z.string() }),
+const analysisErrorProjectionSchema = z
+    .object({
+    tag: z.enum(ANALYSIS_ERROR_TAGS),
+    message: z.string(),
+    details: z.record(z.string(), z.union([z.string(), z.number(), z.null()])),
+})
+    .strict();
+const graphNode = z.discriminatedUnion("status", [
+    z.object({
+        address: z.string(),
+        status: z.literal("ok"),
+        calls: z.array(z.string()),
+    }),
+    z.object({
+        address: z.string(),
+        status: z.literal("error"),
+        error: analysisErrorProjectionSchema,
+    }),
 ]);
 const functionDossierOutput = resultOf(functionDossierSchema);
 /** Exact structured-content schemas for the direct Hopper operations. */
@@ -207,10 +223,23 @@ export const enhancedOutputSchemas = {
     swift_classes: symbolDiscoveryOutput("classes"),
     get_objc_classes: symbolDiscoveryOutput("classes"),
     get_objc_protocols: symbolDiscoveryOutput("protocols"),
-    batch_decompile: resultOf(z.union([
-        z.object({ error: z.literal("No addresses provided") }),
-        z.record(z.string(), z.string()),
-    ])),
+    batch_decompile: resultOf(z.object({
+        items: z.array(z.discriminatedUnion("status", [
+            z.object({
+                address: z.string(),
+                status: z.literal("ok"),
+                pseudocode: z.string().min(1),
+            }),
+            z.object({
+                address: z.string(),
+                status: z.literal("error"),
+                error: analysisErrorProjectionSchema,
+            }),
+        ])),
+        total: z.number().int().min(0),
+        succeeded: z.number().int().min(0),
+        failed: z.number().int().min(0),
+    })),
     get_call_graph: resultOf(z.record(z.string(), z.array(graphNode))),
     analyze_swift_types: resultOf(z.object({
         total: z.number().int().min(0),
@@ -219,9 +248,18 @@ export const enhancedOutputSchemas = {
             items: z.array(addressedEntry),
         })),
     })),
-    find_xrefs_to_name: resultOf(z.union([
-        z.object({ xrefs: addressList }),
-        z.object({ error: z.string() }),
+    find_xrefs_to_name: resultOf(z.discriminatedUnion("status", [
+        z.object({
+            status: z.literal("resolved"),
+            name: z.string(),
+            address: z.string(),
+            xrefs: addressList,
+        }),
+        z.object({
+            status: z.literal("unresolved"),
+            name: z.string(),
+            reason: z.literal("name_not_found"),
+        }),
     ])),
     binary_overview: resultOf(z.object({
         document: z.string(),

package/dist/domain/errors.js

@@ -1,3 +1,29 @@
+/** Stable tags exposed by safe analysis-error projections. */
+export const ANALYSIS_ERROR_TAGS = [
+    "AnalysisProtocolError",
+    "AnalysisInputError",
+    "AnalysisOutputError",
+    "AnalysisCapabilityUnavailableError",
+    "AnalysisCancelledError",
+    "AnalysisTimeoutError",
+    "ProviderSelectionError",
+    "ProviderAdapterError",
+    "ArtifactOperationError",
+    "ProcessCaptureError",
+    "EvidenceIntegrityError",
+    "EvidenceLimitError",
+    "EvidenceFileError",
+    "UnknownRegistryError",
+    "HopperTimeoutError",
+    "HopperCancelledError",
+    "HopperProtocolError",
+    "HopperRemoteError",
+    "HopperProcessError",
+    "HopperStartError",
+    "ConfigurationError",
+    "NoBinaryOpenError",
+    "BinaryTargetError",
+];
 /** Base class for expected analysis, provider, and session failures. */
 export class AnalysisError extends Error {
 }

package/dist/domain/hopperValues.js

@@ -1,6 +1,8 @@
 import { z } from "zod";
 import { AnalysisOutputError, HopperProtocolError } from "./errors.js";
 import { err, ok } from "./result.js";
+/** Return the non-negative byte distance between hexadecimal addresses. */
+export const addressDistance = (start, end) => Math.max(0, Number.parseInt(end, 16) - Number.parseInt(start, 16));
 const procedureMapSchema = z.record(z.string(), z.string());
 const addressedNamesSchema = z.array(z.object({ address: z.string(), name: z.string() }));
 const addressedNameMapSchema = z.record(z.string(), z.string());

package/dist/domain/runtimeVersion.js

@@ -0,0 +1,8 @@
+/** Return whether a Node.js version satisfies REA's tested runtime families. */
+export const supportsNodeVersion = (version) => {
+    const [majorText = "", minorText = ""] = version.split(".");
+    const major = Number.parseInt(majorText, 10);
+    const minor = Number.parseInt(minorText, 10);
+    return ((major === 22 && minor >= 19) ||
+        (major >= 24 && (major !== 24 || minor >= 11)));
+};

package/dist/native/NativeMacOSProvider.js

@@ -81,6 +81,8 @@ class NativeMacOSClient {
         this.runner = runner;
     }
     async execute(operation, parameters, options) {
+        if (options?.signal?.aborted === true)
+            return err(new AnalysisCancelledError(operation));
         if (operation === "health")
             return ok(createAnalysisExecution(null, IDENTITY));
         if (!isNativeOperation(operation))