rea-agents 3.2.0 → 4.0.0

package/dist/generatedPackageMetadata.js

@@ -1,9 +1,9 @@
 /** Generated from package.json and package-lock.json; do not edit. */
 export const PACKAGE_METADATA = {
     name: "rea-agents",
-    version: "3.2.0", // x-release-please-version
+    version: "4.0.0", // x-release-please-version
     serverSdkVersion: "2.0.0",
     clientSdkVersion: "2.0.0",
     coreSdkVersion: "2.0.0",
-    skillVersion: "23",
+    skillVersion: "24",
 };

package/dist/ghidra/GhidraAnalysisProfile.js

@@ -10,6 +10,7 @@ export const resolveGhidraAnalysisProfile = (target, identity, installation, sig
     if (installation.status === "unavailable")
         return Promise.resolve(err(new ProviderAdapterError(identity.id, "resolve_analysis_profile")));
     const provider = { ...identity, version: installation.providerVersion };
+    const dosMz = target.format === "dos-mz";
     return Promise.resolve(ok({
         profile: createAnalysisProfile(provider, {
             target_kind: target.kind,
@@ -19,14 +20,23 @@ export const resolveGhidraAnalysisProfile = (target, identity, installation, sig
                 ...(target.availableArchitectures ?? []),
             ].sort(),
             import_mode: "ephemeral-read-only",
-            loader: "auto-from-header",
-            language_id: "auto-from-header",
-            compiler_spec_id: "auto-default",
+            function_body_evidence: "complete-inclusive-ranges-v1",
+            jump_table_evidence: "typed-case-default-blocks-v1",
+            decompiler_jump_loads: true,
+            loader: dosMz ? "MzLoader" : "auto-from-header",
+            language_id: dosMz ? "x86:LE:16:Real Mode" : "auto-from-header",
+            compiler_spec_id: dosMz ? "default" : "auto-default",
+            ...(dosMz
+                ? {
+                    load_segment: "0x1000",
+                    address_coordinates: "linear-byte-offset",
+                }
+                : {}),
             analyzer_preset: "ghidra-default",
         }),
         compatibility: {
-            languageId: "auto",
-            compilerSpecId: "auto",
+            languageId: dosMz ? "x86:LE:16:Real Mode" : "auto",
+            compilerSpecId: dosMz ? "default" : "auto",
         },
     }));
 };

package/dist/ghidra/GhidraClient.js

@@ -79,7 +79,7 @@ export class GhidraClient {
             logger: this.#logger,
             failure: this.#failure,
         });
-        this.#requestQueue = new GhidraRequestQueue((method, parameters, requestOptions) => this.#wire.request(method, parameters, requestOptions), (kind, message) => this.#failure(kind, message));
+        this.#requestQueue = new GhidraRequestQueue((method, parameters, requestOptions) => this.#wire.request(method, parameters, requestOptions), (kind, message, cause) => this.#failure(kind, message, cause), () => this.#stopAfterActiveCancellation());
     }
     /** Launch Ghidra once and require its exact post-analysis handshake. */
     start(signal) {
@@ -130,12 +130,21 @@ export class GhidraClient {
     }
     /** Stop the owned process group and remove all project/runtime artifacts. */
     close() {
+        return this.#requestClose(false);
+    }
+    #requestClose(forceStop) {
         const starting = this.#startPromise;
         const controller = this.#startupController;
         controller?.abort();
-        this.#closePromise ??= Promise.resolve().then(() => this.#close(starting, controller));
+        this.#closePromise ??= Promise.resolve().then(() => this.#close(starting, controller, forceStop));
         return this.#closePromise;
     }
+    #stopAfterActiveCancellation() {
+        return this.#requestClose(true).catch((cause) => {
+            this.#logger.error({ error: cause instanceof Error ? cause.message : String(cause) }, "Ghidra cleanup after active request cancellation failed");
+            throw cause;
+        });
+    }
     /** Latest bounded local diagnostics, with bearer material redacted. */
     diagnostics() {
         return structuredClone(this.#diagnostics());
@@ -229,8 +238,10 @@ export class GhidraClient {
             failure: this.#failure,
             startupTimeoutMs: this.#options.startupTimeoutMs,
         });
-        if (completed.ok)
+        if (completed.ok) {
             await this.#lineage.observe(this.#launch);
+            this.#requestQueue.reopen();
+        }
         return completed;
     }
     async #connect(endpoint, deadline) {
@@ -262,15 +273,21 @@ export class GhidraClient {
             providerVersion: this.#options.providerVersion,
             profileDigest: this.#options.profileDigest,
             targetSha256: this.#options.targetSha256,
+            ...(this.#options.expectedLanguageId === undefined
+                ? {}
+                : { expectedLanguageId: this.#options.expectedLanguageId }),
+            ...(this.#options.expectedCompilerSpecId === undefined
+                ? {}
+                : { expectedCompilerSpecId: this.#options.expectedCompilerSpecId }),
         });
         if (parsed.ok)
             return parsed;
         return err(this.#failure("protocol", "Ghidra bridge handshake is invalid", parsed.error));
     }
-    async #close(starting, controller) {
+    async #close(starting, controller, forceStop) {
         try {
             await starting?.catch(() => undefined);
-            await this.#cleanup();
+            await this.#cleanup(forceStop);
         }
         finally {
             if (this.#startPromise === starting)
@@ -280,12 +297,13 @@ export class GhidraClient {
             this.#closePromise = undefined;
         }
     }
-    async #cleanup() {
+    async #cleanup(forceStop = false) {
         this.#closing = true;
+        let forcedStopFailure;
         try {
             this.#requestQueue.failQueued(this.#failure("process", "Ghidra session closed"));
             const socket = this.#socket;
-            if (socket !== undefined && !socket.destroyed) {
+            if (!forceStop && socket !== undefined && !socket.destroyed) {
                 const shutdown = await this.#wire
                     .request("shutdown", {}, { timeoutMs: SHUTDOWN_TIMEOUT_MS })
                     .catch(() => err(this.#failure("process", "Ghidra shutdown request failed")));
@@ -308,6 +326,8 @@ export class GhidraClient {
                         reason: stopped.reason,
                     });
                     this.#logger.warn({ reason: stopped.reason }, "Ghidra process cleanup failed closed");
+                    if (forceStop)
+                        forcedStopFailure = this.#failure("process", `Ghidra process cleanup after cancellation was incomplete: ${stopped.reason}`);
                 }
             }
             this.#lastDiagnostics = this.#diagnostics();
@@ -315,11 +335,21 @@ export class GhidraClient {
             this.#launch = undefined;
             const runtimeRoot = this.#runtimeRoot;
             this.#runtimeRoot = undefined;
-            await runtimeRoot?.close();
+            try {
+                await runtimeRoot?.close();
+            }
+            catch (cause) {
+                if (forceStop)
+                    forcedStopFailure ??= this.#failure("process", "Ghidra runtime cleanup after cancellation failed", cause);
+                else
+                    throw cause;
+            }
             this.#snapshotPath = undefined;
             this.#token = undefined;
             this.#runId = undefined;
             this.#responseBuffer.reset();
+            if (forcedStopFailure !== undefined)
+                throw forcedStopFailure;
         }
         finally {
             this.#closing = false;

package/dist/ghidra/GhidraFunctionValues.js

@@ -1,12 +1,18 @@
 import { z } from "zod";
+import { nativeDataTypeSchema } from "../domain/nativeDataType.js";
+import { nativeInstructionSchema, nativeCallTargetsSchema, } from "../domain/nativeInstruction.js";
 import { AnalysisInputError, AnalysisOutputError } from "../domain/errors.js";
-import { functionInstructionWindowSchema, functionDossierSchema, } from "../domain/hopperValues.js";
+import { functionBodyEntryAgrees, functionInstructionWindowSchema, functionDossierSchema, } from "../domain/hopperValues.js";
+import { jsonObjectSchema } from "../domain/jsonValue.js";
 import { nativeApiBoundarySchema } from "../domain/nativeApiBoundary.js";
 import { nativeValueFlowSchema } from "../domain/nativeValueFlow.js";
 import { err, ok } from "../domain/result.js";
-import { ghidraIdentifierSchema, ghidraCanonicalAddressSchema, } from "./GhidraInventoryValues.js";
+import { ghidraIdentifierSchema, ghidraCanonicalAddressSchema, ghidraFunctionClassificationSchema as classification, ghidraFunctionBodySchema as ghidraFunctionBody, ghidraProcedureIdentitySchema as procedureIdentity, } from "./GhidraInventoryValues.js";
 /** Read-only function operations admitted by the Ghidra adapter. */
 export const GHIDRA_FUNCTION_OPERATIONS = [
+    "inspect_native_data_type",
+    "inspect_native_instruction",
+    "resolve_native_call_targets",
     "analyze_function",
     "procedure_assembly",
     "procedure_callees",
@@ -24,6 +30,20 @@ const document = ghidraIdentifierSchema.nullable().default(null);
 const procedure = ghidraIdentifierSchema;
 const directProcedure = { document, procedure };
 const inputSchemas = {
+    inspect_native_data_type: z
+        .object({
+        document,
+        type: z.string().min(1).nullable().default(null),
+        address: ghidraCanonicalAddressSchema.nullable().default(null),
+    })
+        .strict()
+        .refine((value) => (value.type === null) !== (value.address === null), "Supply exactly one of type or address"),
+    inspect_native_instruction: z
+        .object({ document, address: ghidraCanonicalAddressSchema })
+        .strict(),
+    resolve_native_call_targets: z
+        .object({ document, address: ghidraCanonicalAddressSchema })
+        .strict(),
     analyze_function: z.object({ procedure }).strict(),
     procedure_assembly: z.object(directProcedure).strict(),
     procedure_callees: z.object(directProcedure).strict(),
@@ -43,24 +63,9 @@ const inputSchemas = {
 export const parseGhidraFunctionInput = (operation, value) => {
     const parsed = inputSchemas[operation].safeParse(value);
     return parsed.success
-        ? ok(parsed.data)
+        ? ok(jsonObjectSchema.parse(Object.fromEntries(Object.entries(parsed.data).filter(([, value]) => value !== undefined))))
         : err(new AnalysisInputError(operation, { cause: parsed.error }));
 };
-const classification = z
-    .object({
-    external: z.boolean(),
-    thunk: z.boolean(),
-    thunk_target: ghidraCanonicalAddressSchema.nullable(),
-    provenance: z.literal("ghidra-function-manager"),
-})
-    .strict();
-const procedureIdentity = z
-    .object({
-    address: ghidraCanonicalAddressSchema,
-    name: z.string().min(1),
-    classification,
-})
-    .strict();
 const localVariable = z
     .object({
     description: z.string(),
@@ -101,6 +106,13 @@ const procedureReferences = z
     procedure: procedureIdentity,
     direction: z.enum(["incoming", "outgoing"]),
     references: z.array(referenceEdge),
+    reference_kinds_available: z.boolean().default(true),
+    unresolved_calls: z
+        .array(z.strictObject({
+        address: ghidraCanonicalAddressSchema,
+        reason: z.string(),
+    }))
+        .default([]),
 })
     .strict();
 const procedureInfo = z
@@ -112,8 +124,19 @@ const procedureInfo = z
     signature: z.string().nullable(),
     locals: z.array(localVariable),
     classification,
+    body: ghidraFunctionBody,
 })
-    .strict();
+    .strict()
+    .superRefine((value, context) => {
+    if (!functionBodyEntryAgrees(value.body, value.entrypoint) ||
+        (value.body.available &&
+            (value.length !== value.body.total_bytes ||
+                (!value.classification.external && !value.body.contains_entry))))
+        context.addIssue({
+            code: "custom",
+            message: "Ghidra function body disagrees with entry point or length",
+        });
+});
 const ghidraNativeApiBoundary = nativeApiBoundarySchema.superRefine((value, context) => {
     if (!value.available)
         return;
@@ -126,6 +149,7 @@ const ghidraNativeApiBoundary = nativeApiBoundarySchema.superRefine((value, cont
         table.dispatch_address,
         ...table.data_sources.map(({ address }) => address),
         ...table.mappings.map(({ target_address }) => target_address),
+        ...table.default_targets.map(({ target_address }) => target_address),
     ]);
     if (addresses.some((address) => !ghidraCanonicalAddressSchema.safeParse(address).success))
         context.addIssue({
@@ -172,6 +196,10 @@ const ghidraNativeValueFlow = nativeValueFlowSchema.superRefine((value, context)
 });
 const ghidraFunctionDossier = functionDossierSchema
     .extend({
+    procedure: functionDossierSchema.shape.procedure.safeExtend({
+        classification,
+        body: ghidraFunctionBody,
+    }),
     native_api: ghidraNativeApiBoundary,
     native_value_flow: ghidraNativeValueFlow,
 })
@@ -210,7 +238,12 @@ const ghidraFunctionDossier = functionDossierSchema
         ...value.incoming_references.flatMap(referenceProcedures),
         ...value.outgoing_references.flatMap(referenceProcedures),
     ];
-    if (identities.some(({ classification: facts }) => !classification.safeParse(facts).success))
+    if (identities.some((identity) => !classification.safeParse(identity.classification).success ||
+        !ghidraFunctionBody.safeParse(identity.body).success ||
+        !functionBodyEntryAgrees(identity.body, identity.address) ||
+        (identity.body.available &&
+            identity.classification?.external === false &&
+            !identity.body.contains_entry)))
         context.addIssue({
             code: "custom",
             message: "Ghidra dossier omitted function classification",
@@ -239,6 +272,9 @@ const resultSchemas = {
     procedure_info: procedureInfo,
     procedure_pseudo_code: z.string().nullable(),
     read_function_instructions: ghidraFunctionInstructionWindow,
+    inspect_native_instruction: nativeInstructionSchema,
+    inspect_native_data_type: nativeDataTypeSchema,
+    resolve_native_call_targets: nativeCallTargetsSchema,
     procedure_references: procedureReferences,
     xrefs: z.array(ghidraCanonicalAddressSchema),
 };

package/dist/ghidra/GhidraInstallation.js

@@ -110,17 +110,20 @@ const installationChecks = ({ coordinates, platform, architecture, javaHome, hos
     }),
     installationCheck({
         name: "platform",
-        passed: platform === "linux" || platform === "win32",
+        passed: platform === "linux" || platform === "win32" || platform === "darwin",
         code: "unsupported_host",
         detail: platform,
-        remediation: "Use REA's Ghidra adapter on Linux or Windows x64.",
+        remediation: "Use Linux or Windows x64, or macOS x64/arm64 with matching native Ghidra tools.",
     }),
     installationCheck({
         name: "architecture",
-        passed: (platform === "linux" || platform === "win32") && architecture === "x64",
+        passed: ((platform === "linux" || platform === "win32") &&
+            architecture === "x64") ||
+            (platform === "darwin" &&
+                (architecture === "x64" || architecture === "arm64")),
         code: "unsupported_host",
         detail: architecture,
-        remediation: "Use x64 on Linux or Windows.",
+        remediation: "Use x64 on Linux or Windows, or x64/arm64 on macOS.",
     }),
     installationCheck({
         name: "installation",

package/dist/ghidra/GhidraInventoryValues.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { AnalysisInputError, AnalysisOutputError } from "../domain/errors.js";
+import { functionBodySchema, functionBodyEntryAgrees, } from "../domain/hopperValues.js";
 import { err, ok } from "../domain/result.js";
 /** Read-only direct inventory operations admitted by the Ghidra adapter. */
 export const GHIDRA_INVENTORY_OPERATIONS = [
@@ -69,9 +70,40 @@ const procedureFacts = z
     thunk_target: canonicalAddress.nullable(),
 })
     .strict();
-const functionClassification = procedureFacts
+/** Ghidra FunctionManager classification, independent of body ownership inference. */
+export const ghidraFunctionClassificationSchema = procedureFacts
     .extend({ provenance: z.literal("ghidra-function-manager") })
     .strict();
+/** Require complete canonical AddressSet evidence on every Ghidra function identity. */
+export const ghidraFunctionBodySchema = functionBodySchema.superRefine((body, context) => {
+    if (!body.available ||
+        body.provenance !== "ghidra-function-body-address-set" ||
+        body.ranges.some(({ start, end }) => !ghidraCanonicalAddressSchema.safeParse(start).success ||
+            !ghidraCanonicalAddressSchema.safeParse(end).success))
+        context.addIssue({
+            code: "custom",
+            message: "Ghidra omitted complete canonical function-body AddressSet evidence",
+        });
+});
+/** Strict provider identity shared by inventory and function-analysis results. */
+export const ghidraProcedureIdentitySchema = z
+    .object({
+    address: ghidraCanonicalAddressSchema,
+    name: z.string().min(1),
+    classification: ghidraFunctionClassificationSchema,
+    body: ghidraFunctionBodySchema,
+})
+    .strict()
+    .superRefine((value, context) => {
+    if (!functionBodyEntryAgrees(value.body, value.address) ||
+        (value.body.available &&
+            !value.classification.external &&
+            !value.body.contains_entry))
+        context.addIssue({
+            code: "custom",
+            message: "Ghidra function body disagrees with its entry point",
+        });
+});
 const stringFacts = z
     .object({
     encoding: z.string().min(1),
@@ -119,15 +151,18 @@ const containingProcedure = z.discriminatedUnion("found", [
         .object({
         query_address: canonicalAddress,
         found: z.literal(true),
-        procedure: z
-            .object({
-            address: canonicalAddress,
-            name: z.string().min(1),
-            classification: functionClassification,
-        })
-            .strict(),
+        procedure: ghidraProcedureIdentitySchema,
     })
-        .strict(),
+        .strict()
+        .superRefine((value, context) => {
+        const body = value.procedure.body;
+        if (body.available &&
+            !functionBodyEntryAgrees({ ...body, contains_entry: true }, value.query_address))
+            context.addIssue({
+                code: "custom",
+                message: "Found containing procedure body does not contain the query address",
+            });
+    }),
     z
         .object({
         query_address: canonicalAddress,

package/dist/ghidra/GhidraLauncher.js

@@ -52,6 +52,9 @@ export class GhidraHeadlessLauncher {
                 descriptorPath: paths.descriptorPath,
                 ghidraLogPath: paths.ghidraLogPath,
                 scriptLogPath: paths.scriptLogPath,
+                ...(this.options.dosMz === undefined
+                    ? {}
+                    : { dosMz: this.options.dosMz }),
             });
             const command = ghidraHeadlessCommand({
                 platform,
@@ -69,6 +72,7 @@ export class GhidraHeadlessLauncher {
                 // the per-process run token remain the cleanup authority.
                 expectedCommand: null,
                 windowsVerbatimArguments: platform === "win32",
+                platform,
                 env: ghidraLaunchEnvironment(paths, this.options.javaHome, platform),
             });
             await writeFileAtomic(paths.ownershipPath, `${JSON.stringify({
@@ -151,6 +155,16 @@ export const ghidraHeadlessArguments = (options) => [
     "rea-project",
     "-import",
     options.targetPath,
+    ...(options.dosMz === true
+        ? [
+            "-loader",
+            "MzLoader",
+            "-processor",
+            "x86:LE:16:Real Mode",
+            "-cspec",
+            "default",
+        ]
+        : []),
     "-readOnly",
     "-deleteProject",
     "-log",
@@ -176,9 +190,10 @@ const ghidraRuntimePaths = (runtimeRoot) => ({
     scriptLogPath: join(runtimeRoot, "script.log"),
 });
 const ghidraLaunchEnvironment = (paths, javaHome, platform) => {
-    const javaOptions = platform === "win32"
-        ? `"-Duser.home=${paths.homeRoot}" "-Djava.io.tmpdir=${paths.tempRoot}"`
-        : `-Duser.home=${paths.homeRoot} -Djava.io.tmpdir=${paths.tempRoot}`;
+    // analyzeHeadless.bat wraps GHIDRA_HEADLESS_JAVA_OPTIONS in its own quotes
+    // when it builds VMARG_LIST. Nested quotes break cmd.exe tokenization before
+    // Ghidra starts, so keep this option list unquoted on every platform.
+    const javaOptions = `-Duser.home=${paths.homeRoot} -Djava.io.tmpdir=${paths.tempRoot}`;
     return {
         ...ghidraJavaEnvironment(javaHome, process.env, platform),
         HOME: paths.homeRoot,

package/dist/ghidra/GhidraProvider.js

@@ -106,6 +106,12 @@ export class GhidraProvider {
         if (!prerequisites.ok)
             return unavailableClient(prerequisites.error);
         const committedProfile = prerequisites.value.profile;
+        const targetLimitations = target.format === "dos-mz"
+            ? [
+                "DOS MZ uses 16-bit x86 real mode with the Ghidra load segment 0x1000. Returned addresses are linear byte coordinates; they do not identify a unique segment:offset alias.",
+                "Static DOS analysis does not emulate BIOS, DOS interrupts, device ports, or self-modifying unpacking code. Packed targets require a separately identified unpacked artifact for original-program analysis; appended overlays are not the initialized load module.",
+            ]
+            : [];
         const providerLimitations = installation.platform === "win32"
             ? windowsP0Limitations
             : installation.platform === "darwin"
@@ -120,6 +126,7 @@ export class GhidraProvider {
                     ? {}
                     : { javaHome: this.config.ghidraJavaHome }),
                 bridgeScriptPath: fileURLToPath(new URL("../../bridge/ghidra/ReaGhidraBridge.java", import.meta.url)),
+                ...(target.format === "dos-mz" ? { dosMz: true } : {}),
                 platform: installation.platform,
             }),
             targetPath: target.path,
@@ -129,6 +136,12 @@ export class GhidraProvider {
                 : "unix-socket",
             providerVersion: prerequisites.value.providerVersion,
             profileDigest: committedProfile.digest,
+            ...(target.format === "dos-mz"
+                ? {
+                    expectedLanguageId: "x86:LE:16:Real Mode",
+                    expectedCompilerSpecId: "default",
+                }
+                : {}),
             ...(context === undefined ? {} : { runId: context.runId }),
             logger: this.logger.child({ layer: "ghidra-bridge" }),
         });
@@ -144,7 +157,11 @@ export class GhidraProvider {
                         return err(projectSessionError(operation, started.error));
                     return ok(createAnalysisExecution(started.value, committedProfile.provider, {
                         analysisProfile: committedProfile,
-                        limitations: [...healthLimitations, ...providerLimitations],
+                        limitations: [
+                            ...healthLimitations,
+                            ...providerLimitations,
+                            ...targetLimitations,
+                        ],
                     }));
                 }
                 const input = isGhidraFunctionOperation(operation)
@@ -163,7 +180,11 @@ export class GhidraProvider {
                 return ok(createAnalysisExecution(result.value, committedProfile.provider, {
                     rawResult: called.value,
                     analysisProfile: committedProfile,
-                    limitations: [...limitationsFor(operation), ...providerLimitations],
+                    limitations: [
+                        ...limitationsFor(operation),
+                        ...providerLimitations,
+                        ...targetLimitations,
+                    ],
                 }));
             },
             runtimeLineageSnapshots: () => {

package/dist/ghidra/GhidraRequestQueue.js

@@ -3,14 +3,19 @@ import { err } from "../domain/result.js";
 export class GhidraRequestQueue {
     execute;
     failure;
+    onActiveCancellation;
     #queue = [];
     #active = false;
-    constructor(execute, failure) {
+    #closedFailure;
+    constructor(execute, failure, onActiveCancellation) {
         this.execute = execute;
         this.failure = failure;
+        this.onActiveCancellation = onActiveCancellation;
     }
     /** Queue one request until it completes, is cancelled, or the session closes. */
     run(method, parameters, options) {
+        if (this.#closedFailure !== undefined)
+            return Promise.resolve(err(this.#closedFailure));
         if (options.signal?.aborted === true)
             return Promise.resolve(err(this.failure("cancelled", "Ghidra request was cancelled")));
         return new Promise((resolve) => {
@@ -33,11 +38,16 @@ export class GhidraRequestQueue {
     }
     /** Fail requests that have not crossed the socket during session cleanup. */
     failQueued(failure) {
+        this.#closedFailure = failure;
         for (const entry of this.#queue.splice(0)) {
             this.#release(entry);
             entry.resolve(err(failure));
         }
     }
+    /** Admit requests after the owning client completes a new session startup. */
+    reopen() {
+        this.#closedFailure = undefined;
+    }
     #drain() {
         if (this.#active)
             return;
@@ -51,12 +61,43 @@ export class GhidraRequestQueue {
             return;
         }
         this.#active = true;
+        let executionSettled = false;
+        let activeCancellation;
+        const onAbort = entry.signal === undefined
+            ? undefined
+            : () => {
+                if (executionSettled)
+                    return;
+                this.failQueued(this.failure("process", "Ghidra session closed after active request cancellation"));
+                activeCancellation = this.onActiveCancellation();
+            };
+        if (onAbort !== undefined)
+            entry.signal?.addEventListener("abort", onAbort, { once: true });
         void this.execute(entry.method, entry.parameters, entry.signal === undefined ? {} : { signal: entry.signal })
-            .then(entry.resolve)
-            .catch(() => entry.resolve(err(this.failure("protocol", "Ghidra serial request execution rejected unexpectedly"))))
+            .then(async (result) => {
+            if (activeCancellation !== undefined) {
+                try {
+                    await activeCancellation;
+                }
+                catch (cause) {
+                    result = err(this.failure("process", cause instanceof Error
+                        ? `Ghidra cleanup after cancellation failed: ${cause.message}`
+                        : "Ghidra cleanup after cancellation failed", cause));
+                }
+            }
+            executionSettled = true;
+            entry.resolve(result);
+        })
+            .catch(() => {
+            executionSettled = true;
+            entry.resolve(err(this.failure("protocol", "Ghidra serial request execution rejected unexpectedly")));
+        })
             .finally(() => {
+            if (entry.signal !== undefined && onAbort !== undefined)
+                entry.signal.removeEventListener("abort", onAbort);
             this.#active = false;
-            this.#drain();
+            if (this.#closedFailure === undefined)
+                this.#drain();
         });
     }
     #rejectQueued(entry, result) {

package/dist/ghidra/GhidraSessionValues.js

@@ -47,6 +47,11 @@ export const parseGhidraSessionInfo = (value, expected) => {
         parsed.data.provider.version !== expected.providerVersion ||
         parsed.data.profile_digest !== expected.profileDigest ||
         parsed.data.target.sha256 !== expected.targetSha256 ||
+        (expected.expectedLanguageId !== undefined &&
+            parsed.data.target.language_id !== expected.expectedLanguageId) ||
+        (expected.expectedCompilerSpecId !== undefined &&
+            parsed.data.target.compiler_spec_id !==
+                expected.expectedCompilerSpecId) ||
         new Set(parsed.data.capabilities).size !==
             GHIDRA_SESSION_CAPABILITIES.length ||
         GHIDRA_SESSION_CAPABILITIES.some((capability) => !parsed.data.capabilities.includes(capability)) ||

package/dist/hopper/HopperAnalysisProfile.js

@@ -62,6 +62,8 @@ export const hopperLoaderArgsForTarget = (target) => {
             return ok(["-l", "ELF", flag]);
         case "pe":
             return ok(["-l", "WinPE", flag]);
+        case "dos-mz":
+            return err(new ProviderAdapterError("hopper", "resolve_analysis_profile"));
     }
 };
 const hopperArchitectureFlag = (architecture) => {