rea-agents 4.0.1 → 5.0.0

package/dist/ida/IdaProvider.js

@@ -0,0 +1,126 @@
+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 { 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) {
+        this.config = config;
+        this.connectionFactory = connectionFactory;
+    }
+    identity() {
+        return IDA_PROVIDER_IDENTITY;
+    }
+    capabilities() {
+        const config = this.#configuration();
+        return idaCapabilities(config.ok ? config.value.mode : "attached", config.ok && "command" in config.value);
+    }
+    inspectAvailability() {
+        const config = this.#configuration();
+        if (config.ok && config.value.mode === "headless") {
+            const privacy = privateRuntimeRootCapability();
+            if (!privacy.available)
+                return {
+                    status: "unavailable",
+                    code: "unsupported_host",
+                    reason: privacy.reason,
+                    diagnostics: {
+                        configured: true,
+                        mode: "headless",
+                        live_connection_probed: false,
+                        private_workspace_available: false,
+                    },
+                };
+        }
+        return config.ok
+            ? {
+                status: "available",
+                code: null,
+                reason: null,
+                diagnostics: {
+                    configured: true,
+                    mode: config.value.mode,
+                    transport: "command" in config.value ? "stdio" : "http",
+                    live_connection_probed: false,
+                },
+            }
+            : {
+                status: "unavailable",
+                code: this.config.idaMcpConfigPath === undefined
+                    ? "not_configured"
+                    : "open_options_invalid",
+                reason: config.error.message,
+                diagnostics: { configured: false, live_connection_probed: false },
+            };
+    }
+    inspectTargetSupport(target) {
+        const diagnostics = {
+            target_kind: target.kind,
+            target_format: target.format,
+        };
+        return target.kind === "executable"
+            ? { status: "supported", code: null, reason: null, diagnostics }
+            : {
+                status: "unsupported",
+                code: "target_kind_unsupported",
+                reason: "IDA MCP integration admits executable inputs, not analysis databases. Select the original input binary.",
+                diagnostics,
+            };
+    }
+    async resolveAnalysisProfile(_target, options) {
+        if (options?.signal?.aborted === true)
+            return err(new AnalysisCancelledError("ida:profile"));
+        const config = this.#configuration();
+        if (!config.ok)
+            return config;
+        return ok({
+            profile: createAnalysisProfile(IDA_PROVIDER_IDENTITY, {
+                version_scope: "rea-ida-adapter",
+                engine_version: null,
+                upstream_distribution_version: null,
+                mode: config.value.mode,
+                compatibility_profile: config.value.mode === "attached"
+                    ? "legacy-1.4"
+                    : "database-supervisor",
+                database_revision: null,
+                cache_policy: "live",
+                registration_digest: createHash("sha256")
+                    .update(canonicalize(config.value) ?? "")
+                    .digest("hex"),
+            }),
+            compatibility: {
+                mode: config.value.mode,
+                engine_version: null,
+                upstream_distribution_version: null,
+            },
+        });
+    }
+    createClient(target, profile) {
+        const config = this.#configuration();
+        if (!config.ok)
+            return {
+                execute: async () => err(config.error),
+                close: async () => undefined,
+            };
+        return new IdaSessionClient(config.value, target, this.connectionFactory(config.value), profile);
+    }
+    #configuration() {
+        this.#registration ??=
+            this.config.idaMcpConfigPath === undefined
+                ? readIdaConfigurationNotConfigured()
+                : readIdaConfiguration(this.config.idaMcpConfigPath);
+        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."));

package/dist/ida/IdaProviderCapabilities.js

@@ -0,0 +1,52 @@
+/** This version identifies REA's adapter, not IDA or the upstream Python package. */
+export const IDA_PROVIDER_IDENTITY = Object.freeze({
+    id: "ida",
+    name: "IDA Pro MCP adapter",
+    version: "1",
+});
+/** Read-only analyst outcomes supported by both upstream compatibility profiles. */
+export const IDA_OPERATIONS = Object.freeze([
+    "list_procedures",
+    "search_procedures",
+    "list_strings",
+    "search_strings",
+    "procedure_address",
+    "procedure_pseudo_code",
+    "procedure_assembly",
+    "procedure_callers",
+    "procedure_callees",
+    "read_function_instructions",
+    "xrefs",
+    "analyze_function",
+]);
+/** Shared limitations of observations from an externally mutable analysis database. */
+export const IDA_LIMITATIONS = Object.freeze([
+    "Provider version identifies the REA IDA adapter. IDA engine and upstream distribution versions are unknown unless separately observed; MCP serverInfo is reported independently.",
+    "Results describe the current IDA analysis database. Input identity does not prove an unmodified database; patches, annotations, analysis completeness, and database revision remain unknown.",
+    "Live results are never replayed from analysis snapshots. Target checks before and after a request do not provide an atomic lock against external GUI changes.",
+    "Caller cancellation drains the in-flight MCP request before cleanup; it does not prove that IDA engine work was interrupted.",
+    "Headless workers are released through the upstream database lifecycle. Abrupt termination of REA, its proxy, or the supervisor cannot prove worker cleanup; inspect upstream inventory after an interrupted process.",
+    "Complete function body ranges, typed references, unresolved indirect calls, referenced data, and basic blocks are unavailable in this adapter. Empty unsupported dossier facets are unknown, not observed absence.",
+]);
+/** Advertise live observations and configured lifecycle effects truthfully. */
+export const idaCapabilities = (mode, stdio) => IDA_OPERATIONS.map((operation) => ({
+    provider: IDA_PROVIDER_IDENTITY,
+    operation,
+    ...(mode === "headless" && operation === "procedure_callers"
+        ? {
+            available: false,
+            reason: "The modern upstream profile reports code references without proving direct call edges.",
+        }
+        : { available: true, reason: null }),
+    cachePolicy: "live",
+    effects: {
+        mutatesArtifact: false,
+        launchesProcess: stdio || mode === "headless",
+        mayShowUi: false,
+        mayAccessNetwork: true,
+        mayWriteFilesystem: stdio || mode === "headless",
+        changesPermissions: false,
+        requiresRoot: false,
+    },
+    limitations: IDA_LIMITATIONS,
+}));

package/dist/ida/IdaSessionClient.js

@@ -0,0 +1,318 @@
+import { z } from "zod";
+import { createAnalysisExecution, } from "../application/AnalysisProvider.js";
+import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, AnalysisProtocolError, AnalysisOutputError, AnalysisInputError, } from "../domain/analysisErrorCore.js";
+import { AnalysisError } from "../domain/analysisErrorBase.js";
+import { ProviderAdapterError } from "../domain/providerAdapterError.js";
+import { jsonValueSchema } from "../domain/jsonValue.js";
+import { err, ok } from "../domain/result.js";
+import { IdaOperationRunner } from "./IdaOperationRunner.js";
+import { IDA_LIMITATIONS, IDA_OPERATIONS, IDA_PROVIDER_IDENTITY, } from "./IdaProviderCapabilities.js";
+import { closeDatabaseSchema, databaseListSchema, legacyMetadataSchema, modernHealthSchema, openDatabaseSchema, } from "./IdaProtocolValues.js";
+import { idaFileDigest, IdaWorkspace, sameIdaHostPath, } from "./IdaWorkspace.js";
+import { parseIdaInput } from "./IdaInput.js";
+const legacyTools = [
+    "get_metadata",
+    "list_functions",
+    "list_strings",
+    "get_function_by_name",
+    "get_function_by_address",
+    "decompile_function",
+    "disassemble_function",
+    "get_callers",
+    "get_callees",
+    "get_xrefs_to",
+];
+const modernTools = [
+    "idb_open",
+    "idb_list",
+    "idb_close",
+    "server_health",
+    "list_funcs",
+    "lookup_funcs",
+    "find_regex",
+    "decompile",
+    "disasm",
+    "callees",
+    "xrefs_to",
+];
+const operationSet = new Set(IDA_OPERATIONS);
+const isIdaOperation = (operation) => operationSet.has(operation);
+const wasCancelled = (options) => options?.signal?.aborted === true;
+/** A failed cleanup retains its private workspace and reports the remaining resource. */
+class IdaCleanupError extends ProviderAdapterError {
+    cleanupIncomplete = true;
+    cleanupResources;
+    constructor(path, cause) {
+        super("ida", "close", {
+            cause,
+            diagnostics: {
+                reason: "IDA worker release could not be verified. The private workspace was retained.",
+                workspace: path,
+            },
+        });
+        this.cleanupResources = [path];
+    }
+}
+/** Serial read-only session whose lifecycle authority excludes an attached GUI. */
+export class IdaSessionClient {
+    config;
+    target;
+    connection;
+    profile;
+    #tail = Promise.resolve();
+    #startup;
+    #closed = false;
+    #closing = false;
+    #closePromise;
+    #workspace;
+    #database;
+    #openAttempted = false;
+    #openCompleted = false;
+    #initialIdentity;
+    #metadata = null;
+    #lifecycle = [];
+    constructor(config, target, connection, profile) {
+        this.config = config;
+        this.target = target;
+        this.connection = connection;
+        this.profile = profile;
+    }
+    execute(operation, parameters, options) {
+        const call = this.#tail.then(() => this.#execute(operation, parameters, options));
+        this.#tail = call.then(() => undefined, () => undefined);
+        return call;
+    }
+    async #execute(operation, parameters, options) {
+        if (this.#closed || this.#closing)
+            return err(new AnalysisProtocolError("IDA session is closing or closed; reopen the target."));
+        if (wasCancelled(options))
+            return err(new AnalysisCancelledError(operation));
+        if (operation !== "health" && !isIdaOperation(operation))
+            return err(new AnalysisCapabilityUnavailableError("ida", operation, "This integration admits read-only analysis operations only."));
+        if (operation === "procedure_callers" && this.config.mode === "headless")
+            return err(new AnalysisCapabilityUnavailableError("ida", operation, "The modern upstream profile does not prove direct callers."));
+        if (operation !== "health") {
+            const parsed = parseIdaInput(operation, parameters);
+            if (!parsed.ok)
+                return parsed;
+            parameters = parsed.value;
+        }
+        const document = parameters.document;
+        if (document !== undefined &&
+            document !== this.target.path &&
+            document !== this.target.sourcePath)
+            return err(new AnalysisInputError(operation, undefined, [
+                {
+                    path: ["document"],
+                    reason: "invalid_value",
+                    expected: this.target.path,
+                    message: "IDA document must be the REA-bound target; omit document or use its admitted path.",
+                },
+            ]));
+        try {
+            await this.#start();
+            const before = await this.#observe();
+            if (wasCancelled(options))
+                return err(new AnalysisCancelledError(operation));
+            if (operation === "health")
+                return this.#health(before);
+            if (!isIdaOperation(operation))
+                throw new AnalysisProtocolError("IDA operation changed after validation.");
+            const runner = new IdaOperationRunner(this.connection, this.config.mode === "attached" ? "legacy" : "modern", this.#database);
+            const result = await runner.run(operation, parameters);
+            const after = await this.#observe();
+            if (wasCancelled(options))
+                return err(new AnalysisCancelledError(operation));
+            return ok(createAnalysisExecution(result, IDA_PROVIDER_IDENTITY, {
+                rawResult: {
+                    upstream: this.connection.serverInfo(),
+                    metadata_before: before,
+                    metadata_after: after,
+                    observations: jsonValueSchema.parse(runner.raw),
+                },
+                limitations: [...IDA_LIMITATIONS, ...runner.limitations],
+                locations: [
+                    { kind: "artifact-path", path: this.target.path },
+                    ...runner.locations,
+                ],
+                ...(this.profile === undefined
+                    ? {}
+                    : { analysisProfile: this.profile }),
+            }));
+        }
+        catch (cause) {
+            return this.#failure(operation, cause, options);
+        }
+    }
+    #health(metadata) {
+        return ok(createAnalysisExecution({
+            ready: true,
+            mode: this.config.mode,
+            database: this.#database ?? null,
+            upstream: this.connection.serverInfo(),
+            metadata,
+            lifecycle: this.#lifecycle,
+        }, IDA_PROVIDER_IDENTITY, {
+            limitations: IDA_LIMITATIONS,
+            ...(this.profile === undefined
+                ? {}
+                : { analysisProfile: this.profile }),
+        }));
+    }
+    #failure(operation, cause, options) {
+        if (wasCancelled(options))
+            return err(new AnalysisCancelledError(operation));
+        if (cause instanceof AnalysisError)
+            return err(cause);
+        if (cause instanceof z.ZodError)
+            return err(new AnalysisOutputError(operation, `IDA MCP returned malformed or unsupported producer data: ${cause.issues.map((issue) => `${issue.path.join(".") || "$"}: ${issue.message}`).join("; ")}`, { cause }));
+        return err(new ProviderAdapterError("ida", operation, {
+            cause,
+            diagnostics: {
+                reason: cause instanceof Error ? cause.message : "Unknown upstream failure",
+                recovery: "Check the configured upstream MCP registration and selected target; see docs/ida-provider.md.",
+            },
+        }));
+    }
+    #start() {
+        this.#startup ??= this.#initialize();
+        return this.#startup;
+    }
+    async #initialize() {
+        const tools = new Set(await this.connection.connect());
+        const expected = this.config.mode === "attached" ? legacyTools : modernTools;
+        const missing = expected.filter((name) => !tools.has(name));
+        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.#openAttempted = true;
+            const raw = await this.connection.call("idb_open", {
+                input_path: this.#workspace.inputPath,
+                mode: "force_headless",
+                run_auto_analysis: true,
+                build_caches: true,
+                init_hexrays: true,
+                preferred_session_id: this.#workspace.sessionId,
+            });
+            this.#openCompleted = true;
+            this.#lifecycle.push(raw);
+            const opened = openDatabaseSchema.parse(raw);
+            if (!sameIdaHostPath(opened.session.input_path, this.#workspace.inputPath))
+                throw new AnalysisProtocolError("IDA opened a different input than the private admitted target copy.");
+            if (opened.session.session_id !== this.#workspace.sessionId)
+                throw new AnalysisProtocolError("IDA returned an adopted or unexpected session instead of the requested private worker.");
+            const inventory = databaseListSchema.parse(await this.connection.call("idb_list", {}));
+            this.#lifecycle.push(jsonValueSchema.parse(inventory));
+            const entry = inventory.sessions.find(({ session_id }) => session_id === opened.session.session_id);
+            if (entry?.owned !== true ||
+                entry.backend !== "worker" ||
+                entry.is_active !== true ||
+                !sameIdaHostPath(entry.input_path, this.#workspace.inputPath))
+                throw new AnalysisProtocolError("IDA did not return an active owned headless worker for the private input copy.");
+            this.#database = opened.session.session_id;
+        }
+    }
+    async #observe() {
+        let identity;
+        if (this.config.mode === "attached") {
+            const raw = await this.connection.call("get_metadata", {});
+            const metadata = legacyMetadataSchema.parse(raw);
+            if (metadata.sha256.toLowerCase() !== this.target.sha256.toLowerCase())
+                throw new AnalysisProtocolError(`The attached IDA input SHA-256 does not match the selected target ${this.target.path}; open that target in IDA or use headless mode.`);
+            identity = JSON.stringify([
+                metadata.path,
+                metadata.sha256.toLowerCase(),
+                metadata.base,
+            ]);
+            this.#metadata = raw;
+        }
+        else {
+            if (this.#database === undefined || this.#workspace === undefined)
+                throw new AnalysisProtocolError("IDA headless session has no database binding.");
+            const raw = await this.connection.call("server_health", {
+                database: this.#database,
+            });
+            const metadata = modernHealthSchema.parse(raw);
+            if (!sameIdaHostPath(metadata.input_path, this.#workspace.inputPath) ||
+                (await idaFileDigest(this.#workspace.inputPath)) !== this.target.sha256)
+                throw new AnalysisProtocolError("IDA headless input identity changed after target admission.");
+            if (metadata.auto_analysis_ready !== true)
+                throw new AnalysisProtocolError("IDA auto-analysis is incomplete or readiness is unknown; retry after analysis completes.");
+            identity = JSON.stringify([
+                this.#database,
+                metadata.input_path,
+                metadata.idb_path,
+                metadata.imagebase,
+            ]);
+            this.#metadata = raw;
+        }
+        if (this.#initialIdentity !== undefined &&
+            identity !== this.#initialIdentity)
+            throw new AnalysisProtocolError("The attached IDA target or image base changed during the REA session; reopen the target.");
+        this.#initialIdentity = identity;
+        return this.#metadata;
+    }
+    async closeWithOutcome() {
+        if (this.#closePromise !== undefined)
+            return this.#closePromise;
+        const closing = this.#closeOnce();
+        const shared = closing.finally(() => {
+            if (this.#closePromise === shared)
+                this.#closePromise = undefined;
+        });
+        this.#closePromise = shared;
+        return shared;
+    }
+    async #closeOnce() {
+        this.#closing = true;
+        await this.#tail;
+        if (this.#closed)
+            return ok(null);
+        try {
+            if (this.#workspace !== undefined && this.#openAttempted) {
+                if (this.#database === undefined) {
+                    const inventory = databaseListSchema.parse(await this.connection.call("idb_list", {}));
+                    const workspace = this.#workspace;
+                    this.#database = inventory.sessions.find((entry) => entry.owned &&
+                        entry.backend === "worker" &&
+                        entry.session_id === workspace.sessionId &&
+                        sameIdaHostPath(entry.input_path, workspace.inputPath))?.session_id;
+                    if (this.#database === undefined &&
+                        inventory.sessions.some((entry) => sameIdaHostPath(entry.input_path, workspace.inputPath)))
+                        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.");
+                    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.");
+                }
+                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.");
+            }
+            await this.connection.close();
+            await this.#workspace?.remove();
+            this.#closed = true;
+            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

@@ -0,0 +1,54 @@
+import { createHash, randomUUID } from "node:crypto";
+import { createReadStream, constants } from "node:fs";
+import { copyFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { basename, join, normalize } from "node:path";
+import { AnalysisProtocolError } from "../domain/analysisErrorCore.js";
+import { PrivateRuntimeRoot } from "../process/PrivateRuntimeRoot.js";
+/** Read a file digest with bounded memory rather than retaining binary bytes. */
+export const idaFileDigest = async (path) => {
+    const hash = createHash("sha256");
+    for await (const chunk of createReadStream(path))
+        hash.update(chunk);
+    return hash.digest("hex");
+};
+/** Compare host-local paths without confusing Windows paths with POSIX coordinates. */
+export const sameIdaHostPath = (left, right) => process.platform === "win32"
+    ? normalize(left).toLowerCase() === normalize(right).toLowerCase()
+    : normalize(left) === normalize(right);
+/** Private input copy isolates upstream database and sidecar writes from the original. */
+export class IdaWorkspace {
+    runtime;
+    inputPath;
+    sessionId = `rea-${randomUUID()}`;
+    constructor(runtime, inputPath) {
+        this.runtime = runtime;
+        this.inputPath = inputPath;
+    }
+    /** 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()) {
+        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;
+        }
+    }
+    /** Delete only this object's privately allocated directory after worker cleanup. */
+    async remove() {
+        await this.runtime.close();
+    }
+}

package/dist/{browser → inspector}/JavaScriptRuntimeScope.js

@@ -1,6 +1,17 @@
 import { pathToFileURL } from "node:url";
 import { browserOriginSchema, sanitizeBrowserUrl, } from "../domain/browserObservation.js";
-import { authorizedElectronFile } from "./ElectronFileScope.js";
+import { authorizedElectronFile } from "../browser/ElectronFileScope.js";
+/**
+ * Wire bucket for inspector script exclusions. The V8 observation schemas
+ * fix the `unsupported_location` key, so every canonical denial reason maps
+ * onto it; the reason itself stays available on the decision for logs and
+ * limitations text.
+ */
+export const inspectorExclusionKey = (reason) => {
+    // Every canonical denial collapses onto the fixed V8 wire bucket.
+    void reason;
+    return "unsupported_location";
+};
 /** Resolve a protocol location exposed by the explicitly selected Inspector endpoint. */
 export const authorizeRuntimeLocation = async (value) => {
     if (value.startsWith("node:") && value.length > 0)
@@ -11,21 +22,23 @@ export const authorizeRuntimeLocation = async (value) => {
     if (value.startsWith("file:")) {
         const filePath = await authorizedElectronFile(value);
         return filePath === undefined
-            ? { allowed: false, reason: "unsupported_location" }
+            ? { allowed: false, reason: "not_approved" }
             : { allowed: true, location: { kind: "file", file_path: filePath } };
     }
     let url;
     try {
         url = new URL(value);
     }
-    catch {
-        return { allowed: false, reason: "unsupported_location" };
+    catch (cause) {
+        // Non-URL input is outside the authorized runtime scope.
+        void cause;
+        return { allowed: false, reason: "unsupported_url" };
     }
     if (!["http:", "https:"].includes(url.protocol))
-        return { allowed: false, reason: "unsupported_location" };
+        return { allowed: false, reason: "unsupported_url" };
     const parsedOrigin = browserOriginSchema.safeParse(url.origin);
     if (!parsedOrigin.success)
-        return { allowed: false, reason: "unsupported_location" };
+        return { allowed: false, reason: "unsupported_url" };
     return {
         allowed: true,
         location: {

package/dist/{browser → inspector}/V8InspectorCaptureProjection.js

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { authorizeRuntimeLocation } from "./JavaScriptRuntimeScope.js";
+import { authorizeRuntimeLocation, inspectorExclusionKey, } from "./JavaScriptRuntimeScope.js";
 /** Empty durable-location exclusion counters. */
 export const createInspectorExclusionCounts = () => ({
     unsupported_location: 0,
@@ -13,18 +13,56 @@ export const describeInspectorTargetLimitations = () => [
     "Every target exposed by the selected Inspector endpoint is eligible for observation; target IDs and locations are not authenticated as operating-system process identity.",
     "No runtime graph depth is traversed because passive Inspector events do not establish require/import caller edges.",
 ];
+const LOCATION_AUTHORIZATION_WORKERS = 8;
 /** Canonically authorize, deduplicate, and sort one bounded raw capture. */
-export const finalizeInspectorCapture = async ({ input, runtime, target, state, }) => {
+export const finalizeInspectorCapture = async ({ input, runtime, target, state, authorizeLocation = authorizeRuntimeLocation, }) => {
     const exclusions = createInspectorExclusionCounts();
     const scripts = new Map();
+    const draftsByUrl = new Map();
     for (const draft of state.scripts) {
-        const decision = await authorizeRuntimeLocation(draft.rawUrl);
-        if (!decision.allowed) {
-            exclusions[decision.reason] += 1;
-            continue;
+        const drafts = draftsByUrl.get(draft.rawUrl) ?? [];
+        drafts.push(draft);
+        draftsByUrl.set(draft.rawUrl, drafts);
+    }
+    const groups = [...draftsByUrl];
+    const authorizedGroups = new Array(groups.length);
+    let nextGroup = 0;
+    let stopScheduling = false;
+    const worker = async () => {
+        try {
+            for (;;) {
+                if (stopScheduling)
+                    return;
+                const index = nextGroup;
+                nextGroup += 1;
+                const group = groups[index];
+                if (group === undefined)
+                    return;
+                const [rawUrl, drafts] = group;
+                authorizedGroups[index] = {
+                    drafts,
+                    decision: await authorizeLocation(rawUrl),
+                };
+            }
+        }
+        catch (cause) {
+            stopScheduling = true;
+            throw cause;
+        }
+    };
+    const workerResults = await Promise.allSettled(Array.from({ length: Math.min(LOCATION_AUTHORIZATION_WORKERS, groups.length) }, worker));
+    const failedWorker = workerResults.find((result) => result.status === "rejected");
+    if (failedWorker?.status === "rejected")
+        throw failedWorker.reason;
+    for (const { drafts, decision } of authorizedGroups) {
+        for (const draft of drafts) {
+            if (!decision.allowed) {
+                exclusions[inspectorExclusionKey(decision.reason)] += 1;
+                continue;
+            }
+            const script = scriptFromDraft(draft, decision.location);
+            scripts.set(script.script_key, script);
         }
-        const script = scriptFromDraft(draft, decision.location);
-        scripts.set(script.script_key, script);
     }
     const items = [...scripts.values()].sort((left, right) => left.script_key < right.script_key
         ? -1