rea-agents 6.1.0 → 6.3.0

package/dist/hopper/HopperTargetLease.js

@@ -1,15 +1,13 @@
 import { createHash } from "node:crypto";
-import { chmod, lstat, mkdir, realpath, rm } from "node:fs/promises";
+import { chmod, lstat, mkdir, realpath, rm, rmdir } from "node:fs/promises";
 import { createConnection, createServer, } from "node:net";
 import { join, resolve } from "node:path";
 import { HopperStartError } from "../domain/hopperErrors.js";
 import { safeParseJson } from "../domain/safeJson.js";
-/** Shared private parent of per-target lease sockets; it outlives individual sessions. */
+/** Shared private parent of Hopper lease sockets; it outlives individual sessions. */
 export const HOPPER_TARGET_LEASE_DIRECTORY = join("/tmp", `rea-hopper-${process.getuid?.() ?? 0}`);
 /** Keep two REA processes from opening duplicate Hopper documents for one target/profile. */
 export const acquireHopperTargetLease = async (input) => {
-    const directory = input.directory ?? HOPPER_TARGET_LEASE_DIRECTORY;
-    await ensureLeaseDirectory(directory);
     // The canonical path only derives the lease key; it never authorizes access.
     // Common expected `realpath` failures include a missing target or path
     // component (ENOENT, ENOTDIR), an unreadable component (EACCES), or a
@@ -18,43 +16,105 @@ export const acquireHopperTargetLease = async (input) => {
     // still yields a deterministic key, but aliases may take separate leases
     // whenever `realpath` cannot resolve them.
     const targetPath = await realpath(input.targetPath).catch(() => resolve(input.targetPath));
+    return acquireLease({
+        ...input,
+        identity: {
+            targetPath,
+            targetKind: input.targetKind,
+            loaderArgs: input.loaderArgs,
+        },
+    });
+};
+/** Reserve the Linux demo's singleton application before it can forward a target to another owner. */
+export const acquireLinuxHopperApplicationLease = (input) => acquireLease({ ...input, identity: { application: "linux-hopper-demo" } });
+const acquireLease = async (input) => {
+    const directory = input.directory ?? HOPPER_TARGET_LEASE_DIRECTORY;
+    await ensureLeaseDirectory(directory);
     const key = createHash("sha256")
-        .update(JSON.stringify({
-        targetPath,
-        targetKind: input.targetKind,
-        loaderArgs: input.loaderArgs,
-    }))
+        .update(JSON.stringify(input.identity))
         .digest("hex")
         .slice(0, 32);
     const socketPath = join(directory, `${key}.sock`);
     const owner = { runId: input.runId, processId: process.pid };
-    for (let attempt = 0; attempt < 2; attempt += 1) {
-        const server = createServer((socket) => sendOwner(socket, owner));
-        const bound = await bind(server, socketPath);
-        if (bound) {
-            await chmod(socketPath, 0o600);
-            let released = false;
-            return {
-                acquired: true,
-                lease: {
-                    release: async () => {
-                        if (released)
-                            return;
-                        released = true;
-                        await closeServer(server);
-                        await rm(socketPath, { force: true });
-                    },
-                },
-            };
+    const acquisition = await tryAcquireLease(socketPath, owner);
+    if (typeof acquisition !== "string")
+        return acquisition;
+    // Serialize stale cleanup through the replacement bind: otherwise two
+    // recoverers can unlink the socket that one of them has just acquired.
+    const recoveryPath = `${socketPath}.recovery`;
+    await reserveRecovery(recoveryPath);
+    let recovered;
+    try {
+        recovered = await tryAcquireLease(socketPath, owner);
+        if (recovered === "stale")
+            await rm(socketPath, { force: true });
+        if (typeof recovered === "string")
+            recovered = await tryAcquireLease(socketPath, owner);
+        if (typeof recovered !== "string")
+            return recovered;
+        throw new HopperStartError({
+            userMessage: "REA could not reserve Hopper for this request. Close competing REA sessions and retry.",
+        });
+    }
+    finally {
+        try {
+            await rmdir(recoveryPath);
+        }
+        catch (cause) {
+            if (typeof recovered !== "string" && recovered?.acquired)
+                await recovered.lease.release();
+            throw new HopperStartError({
+                cause,
+                userMessage: `REA could not remove its Hopper recovery directory at ${JSON.stringify(recoveryPath)}. Check this directory's write access before retrying.`,
+            });
         }
+    }
+};
+const reserveRecovery = async (recoveryPath) => {
+    try {
+        await mkdir(recoveryPath, { mode: 0o700 });
+    }
+    catch (cause) {
+        const busy = typeof cause === "object" &&
+            cause !== null &&
+            Reflect.get(cause, "code") === "EEXIST";
+        throw new HopperStartError({
+            cause,
+            userMessage: busy
+                ? `REA could not reserve Hopper lease recovery at ${JSON.stringify(recoveryPath)}; the existing socket was left unchanged. Retry after concurrent startup finishes. If recovery was interrupted, stop REA sessions and remove this recovery directory before retrying.`
+                : `REA could not create its Hopper recovery directory at ${JSON.stringify(recoveryPath)}; the existing socket was left unchanged. Check the parent directory's write access before retrying.`,
+        });
+    }
+};
+const tryAcquireLease = async (socketPath, owner) => {
+    const server = createServer((socket) => sendOwner(socket, owner));
+    if (!(await bind(server, socketPath))) {
         const existingOwner = await readOwner(socketPath);
-        if (existingOwner !== undefined)
-            return { acquired: false, owner: existingOwner };
-        await rm(socketPath, { force: true });
+        return typeof existingOwner === "string"
+            ? existingOwner
+            : { acquired: false, owner: existingOwner };
     }
-    throw new HopperStartError({
-        userMessage: "REA could not reserve this Hopper target. Close competing REA sessions and retry.",
-    });
+    try {
+        await chmod(socketPath, 0o600);
+    }
+    catch (cause) {
+        await closeServer(server);
+        throw cause;
+    }
+    let released = false;
+    return {
+        acquired: true,
+        lease: {
+            release: async () => {
+                if (released)
+                    return;
+                // Node removes a bound Unix socket on close. A second unlink here
+                // could remove a new owner's socket bound after that close.
+                await closeServer(server);
+                released = true;
+            },
+        },
+    };
 };
 const ensureLeaseDirectory = async (directory) => {
     let directoryStat;
@@ -96,14 +156,26 @@ const bind = (server, socketPath) => new Promise((resolveBind, reject) => {
 const sendOwner = (socket, owner) => {
     socket.end(`${JSON.stringify(owner)}\n`);
 };
-const readOwner = (socketPath) => new Promise((resolveOwner) => {
+const readOwner = (socketPath) => new Promise((resolveOwner, rejectOwner) => {
     const socket = createConnection(socketPath);
     let response = "";
-    const timer = setTimeout(() => {
+    let settled = false;
+    const fail = (reason, cause) => {
+        if (settled)
+            return;
+        settled = true;
+        clearTimeout(timer);
         socket.destroy();
-        resolveOwner(undefined);
-    }, 250);
+        rejectOwner(new HopperStartError({
+            cause,
+            userMessage: `REA could not verify the existing Hopper lease (${reason}); it was left unchanged. Retry when the owning REA session is responsive.`,
+        }));
+    };
+    const timer = setTimeout(() => fail("owner response timed out"), 250);
     const finish = (owner) => {
+        if (settled)
+            return;
+        settled = true;
         clearTimeout(timer);
         socket.destroy();
         resolveOwner(owner);
@@ -115,23 +187,34 @@ const readOwner = (socketPath) => new Promise((resolveOwner) => {
             return;
         const parsed = safeParseJson(response.slice(0, newline));
         if (!parsed.ok) {
-            finish(undefined);
+            fail("malformed owner response");
             return;
         }
         const value = parsed.value;
-        if (typeof value === "object" &&
-            value !== null &&
-            typeof Reflect.get(value, "runId") === "string" &&
-            typeof Reflect.get(value, "processId") === "number")
-            finish({
-                runId: Reflect.get(value, "runId"),
-                processId: Reflect.get(value, "processId"),
-            });
+        const runId = typeof value === "object" && value !== null
+            ? Reflect.get(value, "runId")
+            : undefined;
+        const processId = typeof value === "object" && value !== null
+            ? Reflect.get(value, "processId")
+            : undefined;
+        if (typeof runId === "string" &&
+            runId.length > 0 &&
+            typeof processId === "number" &&
+            Number.isSafeInteger(processId) &&
+            processId > 0)
+            finish({ runId, processId });
+        else
+            fail("invalid owner identity");
+    });
+    socket.on("error", (cause) => {
+        if (cause.code === "ENOENT")
+            finish("missing");
+        else if (cause.code === "ECONNREFUSED")
+            finish("stale");
         else
-            finish(undefined);
+            fail(cause.code ?? "owner connection failed", cause);
     });
-    socket.on("error", () => finish(undefined));
-    socket.on("end", () => finish(undefined));
+    socket.on("end", () => fail("owner closed without a complete response"));
 });
 const closeServer = (server) => new Promise((resolveClose, reject) => {
     if (!server.listening) {

package/dist/hopper/LinuxPrivateDisplayProbe.js

@@ -50,6 +50,9 @@ export const runLinuxPrivateDisplayProbe = async (strategy, options) => {
             arguments: command.arguments,
             runId: randomUUID(),
             expectedCommand: null,
+            ...(options.environment === undefined
+                ? {}
+                : { hostEnvironment: options.environment }),
             ...(options.signal === undefined ? {} : { signal: options.signal }),
         });
     }
@@ -111,6 +114,9 @@ const evaluatedProbe = async (strategy, options, timeoutMs, runner) => {
     try {
         processResult = await runner(strategy, {
             helperPath: options.helperPath,
+            ...(options.environment === undefined
+                ? {}
+                : { environment: options.environment }),
             timeoutMs,
             ...(options.signal === undefined ? {} : { signal: options.signal }),
         });

package/dist/ida/IdaConfiguration.js

@@ -40,7 +40,7 @@ const registrationSchema = z.union([
 export const readIdaConfiguration = (path) => {
     try {
         if (statSync(path).size > 65_536)
-            return err(new ConfigurationError("REA_IDA_MCP_CONFIG exceeds the 64 KiB registration size."));
+            return err(idaConfigurationError("REA_IDA_MCP_CONFIG exceeds the 64 KiB registration size."));
         const input = JSON.parse(readFileSync(path, "utf8"));
         const envelope = z
             .object({ mcpServers: z.object({ "ida-pro-mcp": z.unknown() }) })
@@ -48,9 +48,14 @@ export const readIdaConfiguration = (path) => {
         const parsed = registrationSchema.safeParse(envelope.success ? envelope.data.mcpServers["ida-pro-mcp"] : input);
         return parsed.success
             ? ok(parsed.data)
-            : err(new ConfigurationError("REA_IDA_MCP_CONFIG must contain an IDA MCP command/args or local url registration; see docs/ida-provider.md.", { cause: parsed.error }));
+            : err(idaConfigurationError("REA_IDA_MCP_CONFIG must contain an IDA MCP command/args or local url registration; see docs/ida-provider.md.", parsed.error));
     }
     catch (cause) {
-        return err(new ConfigurationError(`Cannot read IDA MCP registration ${path}; provide a readable JSON configuration.`, { cause }));
+        return err(idaConfigurationError(`Cannot read IDA MCP registration ${path}; provide a readable JSON configuration.`, cause));
     }
 };
+/** A REA_IDA_MCP_CONFIG rejection that names the setting it concerns. */
+export const idaConfigurationError = (constraint, cause) => new ConfigurationError(constraint, {
+    ...(cause === undefined ? {} : { cause }),
+    settings: [{ setting: "REA_IDA_MCP_CONFIG", constraint }],
+});

package/dist/ida/IdaInput.js

@@ -1,4 +1,3 @@
-import { z } from "zod";
 import { TOOL_CONTRACTS } from "../contracts/toolContracts.js";
 import { AnalysisInputError } from "../domain/analysisErrorCore.js";
 import { jsonObjectSchema } from "../domain/jsonValue.js";
@@ -8,12 +7,7 @@ import { projectInputIssues } from "../domain/inputIssueProjection.js";
 /** Apply the named public contract and IDA's explicit-address boundary before startup. */
 export const parseIdaInput = (operation, parameters) => {
     const contract = TOOL_CONTRACTS.find(({ name }) => name === operation);
-    const schema = contract?.inputSchema;
-    if (schema instanceof z.ZodObject) {
-        const shape = schema.shape;
-        parameters = Object.fromEntries(Object.entries(parameters).filter(([key, value]) => value !== null || shape[key]?.safeParse(undefined).success !== true));
-    }
-    const parsed = (schema instanceof z.ZodObject ? schema.strict() : schema)?.safeParse(parameters);
+    const parsed = contract?.inputSchema.safeParse(parameters);
     if (parsed?.success !== true)
         return err(new AnalysisInputError(operation, { cause: parsed?.error }, parsed?.error === undefined
             ? []

package/dist/ida/IdaMcpConnection.js

@@ -1,5 +1,6 @@
+import { snapshotEnvironment } from "../process/snapshotEnvironment.js";
 import { Client, StreamableHTTPClientTransport, } from "@modelcontextprotocol/client";
-import { StdioClientTransport } from "@modelcontextprotocol/client/stdio";
+import { DEFAULT_INHERITED_ENV_VARS, StdioClientTransport, } from "@modelcontextprotocol/client/stdio";
 import { z } from "zod";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { AnalysisProtocolError } from "../domain/analysisErrorCore.js";
@@ -66,7 +67,7 @@ export const redactIdaTransportFailure = (cause, config) => {
     return new Error(message, { cause });
 };
 /** Create a standard SDK connection to an existing upstream registration. */
-export const createIdaMcpConnection = (config) => {
+export const createIdaMcpConnection = (config, environment) => {
     const client = new Client({ name: "rea-ida-provider", version: "1" });
     const transportFailure = (cause) => {
         throw redactIdaTransportFailure(cause, config);
@@ -76,9 +77,12 @@ export const createIdaMcpConnection = (config) => {
             command: config.command,
             args: config.args,
             env: {
-                ...Object.fromEntries(Object.entries(process.env).filter((entry) => entry[1] !== undefined)),
+                // The SDK always merges ambient defaults. Its string-only environment
+                // API requires empty values to suppress omitted caller-selected keys.
+                ...Object.fromEntries(DEFAULT_INHERITED_ENV_VARS.map((key) => [key, ""])),
+                ...Object.fromEntries(Object.entries(snapshotEnvironment(environment)).filter((entry) => entry[1] !== undefined)),
                 IDA_MCP_MAX_WORKERS: "1",
-                ...config.env,
+                ...snapshotEnvironment(config.env),
             },
             stderr: "pipe",
         })

package/dist/ida/IdaOperationRunner.js

@@ -141,7 +141,7 @@ export class IdaOperationRunner {
                 offset,
                 max_lines: 100,
             }));
-            if (page.code === null)
+            if (page.code === null || page.error !== undefined)
                 throw new AnalysisProtocolError(`IDA decompilation failed: ${page.error ?? "missing code"}`);
             result.push(page.code);
             offset = nextOffset(page.cursor, offset);
@@ -152,7 +152,7 @@ export class IdaOperationRunner {
         if (this.protocol === "legacy")
             return legacyXrefsSchema.parse(await this.call("get_xrefs_to", { address }));
         const page = modernXrefsSchema.parse(await this.call("xrefs_to", { addrs: [address], limit: 1000 }))[0];
-        if (page?.xrefs == null)
+        if (page?.xrefs == null || page.error !== undefined)
             throw new AnalysisProtocolError(`IDA xrefs failed: ${page?.error ?? "missing references"}`);
         if (page.more === true)
             this.limitations.push("Upstream xrefs_to capped results at 1000 references; additional references remain unknown.");
@@ -183,7 +183,7 @@ export class IdaOperationRunner {
         }
         else {
             const page = modernCalleesSchema.parse(await this.call("callees", { addrs: [fn.address], limit: 500 }))[0];
-            if (page?.callees == null)
+            if (page?.callees == null || page.error !== undefined)
                 throw new AnalysisProtocolError(`IDA callees failed: ${page?.error ?? "missing callees"}`);
             if (page.more === true)
                 this.limitations.push("Upstream callees capped results at 500; additional callees remain unknown.");
@@ -288,6 +288,8 @@ export class IdaOperationRunner {
             referenced_strings: [],
             referenced_names: [],
             basic_blocks: [],
+            native_api: null,
+            native_value_flow: null,
             limitations: [
                 ...IDA_LIMITATIONS,
                 ...this.limitations,

package/dist/ida/IdaProvider.js

@@ -1,23 +1,24 @@
+import { snapshotEnvironment } from "../process/snapshotEnvironment.js";
 import { createAnalysisProfile } from "../domain/analysisProfile.js";
 import { err, ok } from "../domain/result.js";
 import { AnalysisCancelledError } from "../domain/analysisErrorCore.js";
-import { ConfigurationError } from "../domain/configurationErrors.js";
 import { createHash } from "node:crypto";
 import canonicalize from "canonicalize";
-import { readIdaConfiguration, } from "./IdaConfiguration.js";
+import { readIdaConfiguration, idaConfigurationError, } from "./IdaConfiguration.js";
 import { createIdaMcpConnection, } from "./IdaMcpConnection.js";
 import { idaCapabilities, IDA_PROVIDER_IDENTITY, } from "./IdaProviderCapabilities.js";
 import { IdaSessionClient } from "./IdaSessionClient.js";
 import { privateRuntimeRootCapability } from "../process/PrivateRuntimeRoot.js";
-export { IDA_PROVIDER_IDENTITY } from "./IdaProviderCapabilities.js";
 /** Bring-your-own IDA MCP candidate; discovery performs no provider startup. */
 export class IdaProvider {
     config;
     connectionFactory;
     #registration;
-    constructor(config, connectionFactory = createIdaMcpConnection) {
+    environment;
+    constructor(config, environment, connectionFactory = createIdaMcpConnection) {
         this.config = config;
         this.connectionFactory = connectionFactory;
+        this.environment = snapshotEnvironment(environment);
     }
     identity() {
         return IDA_PROVIDER_IDENTITY;
@@ -99,11 +100,6 @@ export class IdaProvider {
                     .update(canonicalize(config.value) ?? "")
                     .digest("hex"),
             }),
-            compatibility: {
-                mode: config.value.mode,
-                engine_version: null,
-                upstream_distribution_version: null,
-            },
         });
     }
     createClient(target, profile) {
@@ -111,9 +107,9 @@ export class IdaProvider {
         if (!config.ok)
             return {
                 execute: async () => err(config.error),
-                close: async () => undefined,
+                close: async () => ok(null),
             };
-        return new IdaSessionClient(config.value, target, this.connectionFactory(config.value), profile);
+        return new IdaSessionClient(config.value, target, this.connectionFactory(config.value, this.environment), profile);
     }
     #configuration() {
         this.#registration ??=
@@ -123,4 +119,4 @@ export class IdaProvider {
         return this.#registration;
     }
 }
-const readIdaConfigurationNotConfigured = () => err(new ConfigurationError("Set REA_IDA_MCP_CONFIG to an upstream IDA MCP JSON registration; see docs/ida-provider.md."));
+const readIdaConfigurationNotConfigured = () => err(idaConfigurationError("Set REA_IDA_MCP_CONFIG to an upstream IDA MCP JSON registration; see docs/ida-provider.md."));

package/dist/ida/IdaSessionClient.js

@@ -46,7 +46,8 @@ class IdaCleanupError extends ProviderAdapterError {
         super("ida", "close", {
             cause,
             diagnostics: {
-                reason: "IDA worker release could not be verified. The private workspace was retained.",
+                reason: "IDA cleanup could not be verified; the remaining connection or private workspace is retained for retry.",
+                failure_reason: cause instanceof Error ? cause.message : String(cause),
                 workspace: path,
             },
         });
@@ -66,6 +67,7 @@ export class IdaSessionClient {
     #closePromise;
     #workspace;
     #database;
+    #databaseCloseAcknowledged = false;
     #openAttempted = false;
     #openCompleted = false;
     #initialIdentity;
@@ -99,8 +101,10 @@ export class IdaSessionClient {
         }
         const document = parameters.document;
         if (document !== undefined &&
-            document !== this.target.path &&
-            document !== this.target.sourcePath)
+            (typeof document !== "string" ||
+                (!sameIdaHostPath(document, this.target.path) &&
+                    (this.target.sourcePath === undefined ||
+                        !sameIdaHostPath(document, this.target.sourcePath)))))
             return err(new AnalysisInputError(operation, undefined, [
                 {
                     path: ["document"],
@@ -185,7 +189,8 @@ export class IdaSessionClient {
         if (missing.length > 0)
             throw new AnalysisProtocolError(`IDA MCP ${this.config.mode} compatibility profile is missing tools: ${missing.join(", ")}. Attached mode requires the legacy 1.4 profile; headless mode requires the database supervisor profile. See docs/ida-provider.md.`);
         if (this.config.mode === "headless") {
-            this.#workspace = await IdaWorkspace.create(this.target, this.config.workspaceRoot);
+            this.#workspace = await IdaWorkspace.allocate(this.target, this.config.workspaceRoot);
+            await this.#workspace.copyInput();
             this.#openAttempted = true;
             const raw = await this.connection.call("idb_open", {
                 input_path: this.#workspace.inputPath,
@@ -253,7 +258,7 @@ export class IdaSessionClient {
         this.#initialIdentity = identity;
         return this.#metadata;
     }
-    async closeWithOutcome() {
+    async close() {
         if (this.#closePromise !== undefined)
             return this.#closePromise;
         const closing = this.#closeOnce();
@@ -283,22 +288,27 @@ export class IdaSessionClient {
                         throw new AnalysisProtocolError("An unowned worker still uses the private workspace; it was retained.");
                 }
                 if (this.#database !== undefined) {
-                    const closed = closeDatabaseSchema.parse(await this.connection.call("idb_close", {
-                        database: this.#database,
-                        save: false,
-                    }));
-                    if (closed.session_id !== this.#database ||
-                        closed.saved === true ||
-                        closed.owned !== true ||
-                        closed.backend !== "worker")
-                        throw new AnalysisProtocolError("IDA database close did not confirm the requested owned, unsaved session release.");
+                    if (!this.#databaseCloseAcknowledged) {
+                        const closed = closeDatabaseSchema.parse(await this.connection.call("idb_close", {
+                            database: this.#database,
+                            save: false,
+                        }));
+                        if (closed.session_id !== this.#database ||
+                            closed.saved === true ||
+                            closed.owned !== true ||
+                            closed.backend !== "worker")
+                            throw new AnalysisProtocolError("IDA database close did not confirm the requested owned, unsaved session release.");
+                        this.#databaseCloseAcknowledged = true;
+                    }
                     const inventory = databaseListSchema.parse(await this.connection.call("idb_list", {}));
                     if (inventory.sessions.some((entry) => entry.session_id === this.#database ||
                         sameIdaHostPath(entry.input_path, this.#workspace?.inputPath ?? "")))
                         throw new AnalysisProtocolError("IDA worker remains registered after close.");
+                    this.#database = undefined;
                 }
                 if (!this.#openCompleted)
                     throw new AnalysisProtocolError("IDA database open did not return a completed response. Worker inventory cannot prove that the request has stopped; the private workspace was retained.");
+                this.#openAttempted = false;
             }
             await this.connection.close();
             await this.#workspace?.remove();
@@ -306,13 +316,7 @@ export class IdaSessionClient {
             return ok(null);
         }
         catch (cause) {
-            await this.connection.close().catch(() => undefined);
             return err(new IdaCleanupError(this.#workspace?.directory ?? "IDA MCP connection", cause));
         }
     }
-    async close() {
-        const result = await this.closeWithOutcome();
-        if (!result.ok)
-            throw result.error;
-    }
 }

package/dist/ida/IdaWorkspace.js

@@ -20,32 +20,31 @@ export const sameIdaHostPath = (left, right) => process.platform === "win32"
 export class IdaWorkspace {
     runtime;
     inputPath;
+    target;
     sessionId = `rea-${randomUUID()}`;
-    constructor(runtime, inputPath) {
+    constructor(runtime, inputPath, target) {
         this.runtime = runtime;
         this.inputPath = inputPath;
+        this.target = target;
     }
     /** Filesystem root owned exclusively by this headless session. */
     get directory() {
         return this.runtime.path;
     }
-    /** Allocate a protected workspace and copy the admitted input with digest verification. */
-    static async create(target, root = tmpdir()) {
+    /** Allocate a protected workspace so its owner can retain it before input preparation. */
+    static async allocate(target, root = tmpdir()) {
         const runtime = await PrivateRuntimeRoot.create({
             parent: normalize(root),
             prefix: "rea-ida-",
         });
         const inputPath = join(runtime.path, basename(target.path));
-        try {
-            await copyFile(target.path, inputPath, constants.COPYFILE_EXCL);
-            if ((await idaFileDigest(inputPath)) !== target.sha256)
-                throw new AnalysisProtocolError("IDA target changed between admission and the private input copy; reopen the target.");
-            return new IdaWorkspace(runtime, inputPath);
-        }
-        catch (cause) {
-            await runtime.close();
-            throw cause;
-        }
+        return new IdaWorkspace(runtime, inputPath, target);
+    }
+    /** Copy and verify admitted bytes after the session owns this workspace's cleanup. */
+    async copyInput() {
+        await copyFile(this.target.path, this.inputPath, constants.COPYFILE_EXCL);
+        if ((await idaFileDigest(this.inputPath)) !== this.target.sha256)
+            throw new AnalysisProtocolError("IDA target changed between admission and the private input copy; reopen the target.");
     }
     /** Delete only this object's privately allocated directory after worker cleanup. */
     async remove() {

package/dist/inspector/JavaScriptRuntimeScope.js

@@ -21,11 +21,6 @@ export const inspectorExclusionKey = (reason) => {
 /** Resolve a protocol location exposed by the explicitly selected Inspector endpoint. */
 export const authorizeRuntimeLocation = async (value, signal) => {
     throwIfRuntimeObservationCancelled(signal);
-    if (value.startsWith("node:") && value.length > 0)
-        return {
-            allowed: true,
-            location: { kind: "builtin", specifier: value },
-        };
     if (value.startsWith("file:")) {
         const filePath = await authorizedElectronFile(value);
         throwIfRuntimeObservationCancelled(signal);
@@ -33,6 +28,15 @@ export const authorizeRuntimeLocation = async (value, signal) => {
             ? { allowed: false, reason: "not_approved" }
             : { allowed: true, location: { kind: "file", file_path: filePath } };
     }
+    return projectReportedRuntimeUrl(value);
+};
+/** Project non-file Inspector URLs without filesystem access. */
+export const projectReportedRuntimeUrl = (value) => {
+    if (value.startsWith("node:") && value.length > 0)
+        return {
+            allowed: true,
+            location: { kind: "builtin", specifier: value },
+        };
     let url;
     try {
         url = new URL(value);