rea-agents 6.2.0 → 6.4.0

package/dist/ghidra/GhidraLanguageCatalog.js

@@ -0,0 +1,99 @@
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { DOMParser, onWarningStopParsing } from "@xmldom/xmldom";
+import { ConfigurationError } from "../domain/configurationErrors.js";
+// Language definitions are small XML files; refuse anything implausibly large.
+const MAX_LDEFS_BYTES = 4 * 1024 * 1024;
+// Processor modules ship under Processors; installed extensions may add more.
+const LANGUAGE_ROOTS = ["Ghidra/Processors", "Ghidra/Extensions"];
+/** Parse the `<language>` elements of one `.ldefs` document. */
+export const parseGhidraLanguageDefinitions = (text) => {
+    const definitions = [];
+    const document = new DOMParser({
+        onError: onWarningStopParsing,
+    }).parseFromString(text, "application/xml");
+    const root = document.documentElement;
+    if (root?.tagName !== "language_definitions")
+        throw new SyntaxError("Expected Ghidra language_definitions XML root");
+    for (const language of Array.from(root.getElementsByTagName("language"))) {
+        if (language.parentNode !== root)
+            continue;
+        const id = language.getAttribute("id");
+        if (id === null)
+            continue;
+        const compilerSpecIds = [];
+        for (const compiler of Array.from(language.getElementsByTagName("compiler"))) {
+            if (compiler.parentNode !== language)
+                continue;
+            const compilerId = compiler.getAttribute("id");
+            if (compilerId !== null)
+                compilerSpecIds.push(compilerId);
+        }
+        definitions.push({ id, compilerSpecIds });
+    }
+    return definitions;
+};
+const languageDirectories = async (installDir) => {
+    const directories = [];
+    for (const root of LANGUAGE_ROOTS) {
+        let modules;
+        try {
+            modules = await readdir(join(installDir, root));
+        }
+        catch {
+            continue;
+        }
+        for (const module of modules.sort())
+            directories.push(join(installDir, root, module, "data", "languages"));
+    }
+    return directories;
+};
+/** Read every language definition shipped by one Ghidra installation. */
+export const readGhidraLanguageCatalog = async (installDir) => {
+    const definitions = [];
+    for (const directory of await languageDirectories(installDir)) {
+        let entries;
+        try {
+            entries = await readdir(directory);
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries.sort()) {
+            if (!entry.endsWith(".ldefs"))
+                continue;
+            const bytes = await readFile(join(directory, entry));
+            if (bytes.length > MAX_LDEFS_BYTES)
+                continue;
+            definitions.push(...parseGhidraLanguageDefinitions(bytes.toString("utf8")));
+        }
+    }
+    return definitions;
+};
+/**
+ * Check a configured import language against the installation before launch,
+ * so an unknown ID fails as configuration instead of as a failed import.
+ */
+export const admitGhidraLanguageOverride = (override, catalog, providerVersion) => {
+    const language = catalog.find((value) => value.id === override.languageId);
+    if (language === undefined)
+        return new ConfigurationError("Invalid REA environment configuration", {
+            settings: [
+                {
+                    setting: "REA_GHIDRA_LANGUAGE_ID",
+                    constraint: `is not a language defined by Ghidra ${providerVersion}`,
+                },
+            ],
+        });
+    if (override.compilerSpecId !== undefined &&
+        !language.compilerSpecIds.includes(override.compilerSpecId))
+        return new ConfigurationError("Invalid REA environment configuration", {
+            settings: [
+                {
+                    setting: "REA_GHIDRA_COMPILER_SPEC_ID",
+                    constraint: `must be one of the selected language's compiler specs: ${language.compilerSpecIds.join(", ")}`,
+                },
+            ],
+        });
+    return null;
+};

package/dist/ghidra/GhidraLauncher.js

@@ -1,6 +1,7 @@
+import { GHIDRA_SEED_SCRIPT, snapshotGhidraAnalysisSeeds, } from "./GhidraAnalysisSeeds.js";
 import { snapshotEnvironment } from "../process/snapshotEnvironment.js";
 import { mkdir } from "node:fs/promises";
-import { basename, dirname, join, win32 } from "node:path";
+import { basename, dirname, join, posix, win32 } from "node:path";
 import writeFileAtomic from "write-file-atomic";
 import { windowsPrivateRuntime } from "../windows/WindowsPrivateRuntime.js";
 import { AnalysisCancelledError } from "../domain/analysisErrorCore.js";
@@ -12,9 +13,16 @@ import { ghidraJavaLaunch } from "./GhidraJavaLaunch.js";
 import { snapshotGhidraExtensions, } from "./extensions/GhidraExtensions.js";
 /** Local launch failure retained as the cause of a provider-neutral error. */
 export class GhidraLaunchError extends Error {
+    #partialLaunch;
     constructor(message, options) {
-        super(message, options);
+        const { partialLaunch, ...errorOptions } = options ?? {};
+        super(message, errorOptions);
         this.name = "GhidraLaunchError";
+        this.#partialLaunch = partialLaunch;
+    }
+    /** Process ownership retained for the client to retry an incomplete rollback. */
+    get partialLaunch() {
+        return this.#partialLaunch;
     }
 }
 /** Launch Ghidra without copying scripts into or modifying its installation. */
@@ -34,6 +42,9 @@ export class GhidraHeadlessLauncher {
         let started;
         try {
             await createGhidraRuntimeDirectories(paths, platform);
+            const seedPath = this.options.analysisSeeds === undefined
+                ? undefined
+                : await snapshotGhidraAnalysisSeeds(this.options.analysisSeeds, session.runtimeRoot);
             const extensions = await snapshotGhidraExtensions(this.options.analysisExtensions ?? [], session.runtimeRoot);
             await writeGhidraRuntimeFile(paths.descriptorPath, `${JSON.stringify({
                 transport: session.transport,
@@ -50,6 +61,7 @@ export class GhidraHeadlessLauncher {
             if (isAborted(options.signal))
                 return err(new AnalysisCancelledError("open_binary"));
             const headlessArguments = ghidraHeadlessArguments({
+                platform,
                 projectRoot: paths.projectRoot,
                 targetPath: session.targetPath,
                 bridgeScriptPath: this.options.bridgeScriptPath,
@@ -62,6 +74,10 @@ export class GhidraHeadlessLauncher {
                 ...(this.options.dosMz === undefined
                     ? {}
                     : { dosMz: this.options.dosMz }),
+                ...(this.options.languageOverride === undefined
+                    ? {}
+                    : { languageOverride: this.options.languageOverride }),
+                ...(seedPath === undefined ? {} : { seedPath }),
             });
             const scriptCommand = ghidraHeadlessCommand({
                 environment: this.options.environment,
@@ -89,7 +105,7 @@ export class GhidraHeadlessLauncher {
                         : { signal: options.signal }),
                 })
                 : { ...scriptCommand, environment };
-            started = await spawnOwnedProviderProcess({
+            started = await (this.options.spawnProcess ?? spawnOwnedProviderProcess)({
                 command: command.command,
                 arguments: command.arguments,
                 runId: session.runId,
@@ -102,6 +118,7 @@ export class GhidraHeadlessLauncher {
                 hostEnvironment: {},
                 ...(options.signal === undefined ? {} : { signal: options.signal }),
             });
+            const partialLaunch = ownedGhidraLaunch(started, paths, platform);
             await writeGhidraRuntimeFile(paths.ownershipPath, `${JSON.stringify({
                 run_id: session.runId,
                 transport: session.transport,
@@ -115,29 +132,45 @@ export class GhidraHeadlessLauncher {
                 created_at: new Date().toISOString(),
             })}\n`, platform);
             if (isAborted(options.signal)) {
-                await cleanupStartedProcess(started, platform);
-                return err(new AnalysisCancelledError("open_binary"));
+                throw new AnalysisCancelledError("open_binary");
             }
-            const spawned = started;
-            return ok({
-                ...ownedGhidraProcess(spawned, platform),
-                projectRoot: paths.projectRoot,
-                ghidraLogPath: paths.ghidraLogPath,
-                scriptLogPath: paths.scriptLogPath,
-            });
+            return ok(partialLaunch);
         }
         catch (cause) {
-            if (started !== undefined)
-                await cleanupStartedProcess(started, platform).catch((cause) => {
-                    // best-effort cleanup: started-process cleanup must not mask the launch failure.
-                    void cause;
-                });
-            return isAborted(options.signal)
-                ? err(new AnalysisCancelledError("open_binary"))
-                : err(new GhidraLaunchError("Ghidra headless launch failed", { cause }));
+            const primary = isAborted(options.signal)
+                ? new AnalysisCancelledError("open_binary", { cause })
+                : new GhidraLaunchError("Ghidra headless launch failed", { cause });
+            if (started === undefined)
+                return err(primary);
+            let cleanupFailure;
+            try {
+                const cleanup = await cleanupStartedProcess(started, platform);
+                if (!cleanup.cleaned)
+                    cleanupFailure = new Error(`Ghidra process cleanup was incomplete: ${cleanup.reason}`);
+            }
+            catch (failure) {
+                cleanupFailure = failure;
+            }
+            if (cleanupFailure !== undefined) {
+                const partialLaunch = ownedGhidraLaunch(started, paths, platform);
+                const primaryMessage = isAborted(options.signal)
+                    ? primary.message
+                    : `Ghidra headless launch failed: ${cause instanceof Error ? cause.message : String(cause)}`;
+                return err(new GhidraLaunchError(`${primaryMessage}; process cleanup remains incomplete`, {
+                    cause: new AggregateError([primary, cleanupFailure], "Ghidra launch rollback did not release its process", { cause: primary }),
+                    partialLaunch,
+                }));
+            }
+            return err(primary);
         }
     }
 }
+const ownedGhidraLaunch = (spawned, paths, platform) => ({
+    ...ownedGhidraProcess(spawned, platform),
+    projectRoot: paths.projectRoot,
+    ghidraLogPath: paths.ghidraLogPath,
+    scriptLogPath: paths.scriptLogPath,
+});
 const ownedGhidraProcess = (spawned, platform) => ({
     process: spawned.process,
     ownsProcessLifetime: true,
@@ -185,52 +218,84 @@ const cleanupStartedProcess = (started, platform) => started.cleanup !== undefin
         ? cleanupWindowsProcessTree(started.ownership.leaderPid)
         : cleanupOwnedProcessGroup(started.ownership);
 /** Build the complete read-only headless invocation in deterministic order. */
-export const ghidraHeadlessArguments = (options) => [
-    options.projectRoot,
-    "rea-project",
-    "-import",
-    options.targetPath,
-    ...(options.dosMz === true
-        ? [
-            "-loader",
-            "MzLoader",
-            "-processor",
-            "x86:LE:16:Real Mode",
-            "-cspec",
-            "default",
-        ]
-        : options.dosCom === true
+export const ghidraHeadlessArguments = (options) => {
+    // Bridge script paths use the target platform's syntax, which differs from
+    // the host when building a cross-platform invocation.
+    const scriptPath = (options.platform ?? process.platform) === "win32" ? win32 : posix;
+    const bridgeDirectory = scriptPath.dirname(options.bridgeScriptPath);
+    const override = options.languageOverride;
+    if (override !== undefined &&
+        (options.dosMz === true || options.dosCom === true))
+        throw new Error("A Ghidra language override cannot be combined with a DOS import.");
+    return [
+        options.projectRoot,
+        "rea-project",
+        "-import",
+        options.targetPath,
+        ...(options.dosMz === true
             ? [
                 "-loader",
-                "BinaryLoader",
-                "-loader-baseAddr",
-                "1000:0100",
+                "MzLoader",
                 "-processor",
                 "x86:LE:16:Real Mode",
                 "-cspec",
                 "default",
             ]
+            : options.dosCom === true
+                ? [
+                    "-loader",
+                    "BinaryLoader",
+                    "-loader-baseAddr",
+                    "1000:0100",
+                    "-processor",
+                    "x86:LE:16:Real Mode",
+                    "-cspec",
+                    "default",
+                ]
+                : override !== undefined
+                    ? [
+                        "-processor",
+                        override.languageId,
+                        ...(override.compilerSpecId === undefined
+                            ? []
+                            : ["-cspec", override.compilerSpecId]),
+                    ]
+                    : []),
+        "-readOnly",
+        "-deleteProject",
+        "-log",
+        options.ghidraLogPath,
+        "-scriptlog",
+        options.scriptLogPath,
+        "-scriptPath",
+        bridgeDirectory,
+        ...(options.dosCom === true
+            ? [
+                "-preScript",
+                scriptPath.join(bridgeDirectory, "ReaGhidraPrepareCom.java"),
+            ]
             : []),
-    "-readOnly",
-    "-deleteProject",
-    "-log",
-    options.ghidraLogPath,
-    "-scriptlog",
-    options.scriptLogPath,
-    "-scriptPath",
-    dirname(options.bridgeScriptPath),
-    ...(options.dosCom === true
-        ? [
-            "-preScript",
-            join(dirname(options.bridgeScriptPath), "ReaGhidraPrepareCom.java"),
-        ]
-        : []),
-    "-postScript",
-    // Ghidra checks the caller's cwd before scriptPath for a basename. Select
-    // the packaged source explicitly so unrelated entries cannot shadow it.
-    options.bridgeScriptPath,
-    options.descriptorPath,
-];
+        // Seeds follow any loader preparation and precede default auto-analysis.
+        ...(options.seedPath === undefined
+            ? []
+            : [
+                "-preScript",
+                scriptPath.join(bridgeDirectory, GHIDRA_SEED_SCRIPT),
+                options.seedPath,
+            ]),
+        ...((options.platform ?? process.platform) === "win32"
+            ? []
+            : [
+                "-postScript",
+                scriptPath.join(bridgeDirectory, "ReaGhidraNoReturnFix.java"),
+            ]),
+        "-postScript",
+        // Ghidra checks the caller's cwd before scriptPath for a basename. Select
+        // the packaged source explicitly so unrelated entries cannot shadow it.
+        options.bridgeScriptPath,
+        options.descriptorPath,
+    ];
+};
 const ghidraRuntimePaths = (runtimeRoot) => ({
     projectRoot: join(runtimeRoot, "project"),
     homeRoot: join(runtimeRoot, "home"),

package/dist/ghidra/GhidraLoadImageAttest.js

@@ -1,11 +1,52 @@
+import { AnalysisCancelledError } from "../domain/analysisErrorCore.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { nativeLoadImageObservationSchema, nativeLoadImageSchema, } from "../domain/native/nativeLoadImage.js";
 import { ProviderAdapterError } from "../domain/providerAdapterError.js";
 import { err, ok } from "../domain/result.js";
 import { attestGhidraDosComLoadImage, attestGhidraDosLoadImage, } from "./GhidraLoadImageValues.js";
+import {} from "../domain/native/nativeAotPe.js";
+const isSignalAborted = (signal) => signal?.aborted === true;
 /** Independently verify measured load-image observations for admitted DOS targets. */
-export const attestGhidraNativeLoadImage = async (target, operation, measured, client, mapSessionError) => {
+export const attestGhidraNativeLoadImage = async (input) => {
+    const { target, operation, measured, client, mapSessionError, nativeAotResult, signal, } = input;
+    if (isSignalAborted(signal))
+        return err(new AnalysisCancelledError(operation));
     const observations = nativeLoadImageObservationSchema.parse(measured);
+    if (target.format === "pe") {
+        if (nativeAotResult === undefined)
+            return err(new ProviderAdapterError("ghidra", operation, {
+                diagnostics: {
+                    reason: "The Ghidra provider did not produce read-only NativeAOT metadata for this admitted PE snapshot.",
+                },
+            }));
+        if (isSignalAborted(signal))
+            return err(new AnalysisCancelledError(operation));
+        try {
+            return ok(jsonValueSchema.parse(nativeLoadImageSchema.parse({
+                status: "unsupported",
+                reason: "Independent load-image verification currently supports DOS MZ and explicit DOS COM targets only.",
+                observations: {
+                    ...observations,
+                    metadata_recovery: [
+                        ...(observations.metadata_recovery ?? []),
+                        nativeAotResult.summary,
+                    ],
+                },
+                limitations: [
+                    "Load-image verification is not performed for PE targets; NativeAOT metadata observations are derived separately from the exact admitted snapshot.",
+                ],
+            })));
+        }
+        catch (cause) {
+            return err(new ProviderAdapterError("ghidra", operation, {
+                diagnostics: {
+                    reason: cause instanceof Error
+                        ? cause.message
+                        : "NativeAOT metadata could not be represented in the load-image result",
+                },
+            }));
+        }
+    }
     if (target.format !== "dos-mz" && target.format !== "dos-com") {
         return ok(jsonValueSchema.parse(nativeLoadImageSchema.parse({
             status: "unsupported",
@@ -25,9 +66,15 @@ export const attestGhidraNativeLoadImage = async (target, operation, measured, c
     const snapshot = await client.readTargetSnapshot();
     if (!snapshot.ok)
         return err(mapSessionError(snapshot.error));
+    if (snapshot.value.kind !== "captured")
+        return err(new ProviderAdapterError("ghidra", operation, {
+            diagnostics: {
+                reason: "The uncapped DOS load-image snapshot was unexpectedly not captured.",
+            },
+        }));
     const attested = (target.format === "dos-com"
         ? attestGhidraDosComLoadImage
-        : attestGhidraDosLoadImage)(snapshot.value, target.sha256 ?? "", observations);
+        : attestGhidraDosLoadImage)(snapshot.value.bytes, target.sha256 ?? "", observations);
     if (!attested.ok)
         return err(new ProviderAdapterError("ghidra", operation, {
             diagnostics: { reason: attested.error },

package/dist/ghidra/GhidraMipsProfile.js

@@ -0,0 +1,79 @@
+/** Keep family recognition separate from the deliberately bounded Ghidra lane. */
+export const ghidraMipsUnsupportedReason = (target) => {
+    if (target.kind !== "executable" || target.architecture !== "mips")
+        return null;
+    const metadata = target.mips;
+    if (target.format !== "elf" || metadata === undefined)
+        return "MIPS analysis requires ELF header metadata; a family name alone does not select an ISA or ABI.";
+    if (metadata.elfClass !== 32)
+        return "This Ghidra MIPS lane supports ELF32 only; MIPS64 and n64 remain unsupported.";
+    if (metadata.type !== 2)
+        return "This Ghidra MIPS lane supports ET_EXEC only; relocatable objects, shared images and PSP PRX need separate load verification.";
+    if ((metadata.flags & 0x0f000000) !== 0)
+        return "MIPS16, microMIPS and other ASE encodings are outside this standard-instruction MIPS lane.";
+    if ((metadata.flags & 0x00ff0000) !== 0)
+        return "Machine-specific MIPS variants, including PSP Allegrex, need a separately supported processor profile.";
+    if ((metadata.flags & 0xf0000000) !== 0x70000000)
+        return "This Ghidra MIPS lane requires EF_MIPS_ARCH_32R2; other ISA revisions need separate verification.";
+    if ((metadata.flags & 0x0000f000) !== 0x00001000 ||
+        (metadata.flags & 0x20) !== 0)
+        return "This Ghidra MIPS lane requires an explicit o32 ABI; unspecified, n32 and EABI targets remain unsupported.";
+    if ((metadata.flags & 0x00000200) !== 0)
+        return "EF_MIPS_FP64 requires separate verification of 64-bit floating-point register semantics in this Ghidra lane.";
+    if ((metadata.flags & 0x00000400) !== 0)
+        return "EF_MIPS_NAN2008 requires separate verification of NaN encoding semantics in this Ghidra lane.";
+    const abi = metadata.abiFlags;
+    if (abi === undefined || abi === null)
+        return [
+            "This Ghidra MIPS lane requires an inspected ABI flags record; header flags alone do not establish the floating-point ABI.",
+            ...(metadata.limitations ?? []),
+        ].join(" ");
+    if (abi.version !== 0)
+        return "This Ghidra MIPS lane requires ABI flags version 0; newer record semantics are unsupported.";
+    if (abi.isaLevel !== 32 || abi.isaRevision !== 2)
+        return "MIPS ABI flags must agree with the declared MIPS32r2 ISA.";
+    if (abi.gprSize !== 1 || abi.cpr1Size !== 1 || abi.cpr2Size !== 0)
+        return "This Ghidra MIPS lane requires 32-bit GPR/CPR1 and no CPR2; other register modes need separate verification.";
+    if (abi.fpAbi !== 1 && abi.fpAbi !== 5)
+        return "This Ghidra MIPS lane admits double-precision or FPXX ABI declarations only; soft-float, FP64 and unspecified modes need separate verification.";
+    if (abi.isaExtension !== 0 || abi.ases !== 0)
+        return "MIPS ABI flags declare an ISA extension or ASE outside this standard-instruction lane.";
+    if ((abi.flags1 & ~1) !== 0 || abi.flags2 !== 0)
+        return "MIPS ABI flags contain unsupported general flags.";
+    return null;
+};
+/** Commit source ELF interpretation without confusing target ISA with host CPU. */
+export const ghidraMipsProfileParameters = (target) => {
+    if (target.kind !== "executable" ||
+        target.architecture !== "mips" ||
+        target.mips === undefined)
+        return {};
+    const abi = target.mips.abiFlags;
+    return {
+        mips_elf: {
+            elf_class: target.mips.elfClass,
+            byte_order: target.mips.byteOrder,
+            type: target.mips.type,
+            flags: target.mips.flags,
+            ...(target.mips.limitations === undefined
+                ? {}
+                : { abi_flags_limitations: [...target.mips.limitations] }),
+            abi_flags: abi === undefined || abi === null
+                ? null
+                : {
+                    version: abi.version,
+                    isa_level: abi.isaLevel,
+                    isa_revision: abi.isaRevision,
+                    gpr_size: abi.gprSize,
+                    cpr1_size: abi.cpr1Size,
+                    cpr2_size: abi.cpr2Size,
+                    fp_abi: abi.fpAbi,
+                    isa_extension: abi.isaExtension,
+                    ases: abi.ases,
+                    flags1: abi.flags1,
+                    flags2: abi.flags2,
+                },
+        },
+        mips_support_lane: "elf32-exec-o32-arch32r2-standard-v3",
+    };
+};

package/dist/ghidra/GhidraProvider.js

@@ -2,15 +2,26 @@ import { snapshotEnvironment } from "../process/snapshotEnvironment.js";
 import {} from "../application/AnalysisProvider.js";
 import { createAnalysisProfile, } from "../domain/analysisProfile.js";
 import { jsonObjectSchema, jsonValueSchema, } from "../domain/jsonValue.js";
-import { ok } from "../domain/result.js";
+import { err, ok } from "../domain/result.js";
+import { ProviderAdapterError } from "../domain/providerAdapterError.js";
 import { GhidraClient } from "./GhidraClient.js";
 import { ghidraInstallationDiagnostics, inspectGhidraInstallation, } from "./GhidraInstallation.js";
 import { resolveGhidraAnalysisProfile } from "./GhidraAnalysisProfile.js";
+import { AnalysisCancelledError } from "../domain/analysisErrorCore.js";
+import { resolveGhidraAnalysisSeeds } from "./GhidraAnalysisSeeds.js";
+import { admitGhidraLanguageOverride, readGhidraLanguageCatalog, } from "./GhidraLanguageCatalog.js";
+import { ghidraMipsUnsupportedReason } from "./GhidraMipsProfile.js";
 import { resolveGhidraExtensions } from "./extensions/GhidraExtensions.js";
 import { CAPABILITIES, windowsP0Capabilities, GHIDRA_PROVIDER_IDENTITY, GHIDRA_OPERATIONS, } from "./GhidraProviderCapabilities.js";
 import { createGhidraProviderClient, } from "./GhidraProviderClient.js";
 import { windowsNativeAuthorityUnavailableReason, hasWindowsNativeAuthority, windowsNativeCapabilities, } from "../process/WindowsAuthority.js";
-const SUPPORTED_ARCHITECTURES = new Set(["x86", "x86_64", "arm", "arm64"]);
+const SUPPORTED_ARCHITECTURES = new Set([
+    "x86",
+    "x86_64",
+    "arm",
+    "arm64",
+    "mips",
+]);
 /** Ghidra candidate backed by an isolated ephemeral headless import. */
 export class GhidraProvider {
     config;
@@ -85,6 +96,14 @@ export class GhidraProvider {
             };
         if (hostPlatform === "win32")
             return inspectWindowsP0TargetSupport(target, diagnostics);
+        const mipsReason = ghidraMipsUnsupportedReason(target);
+        if (mipsReason !== null)
+            return {
+                status: "unsupported",
+                code: "architecture_unsupported",
+                reason: mipsReason,
+                diagnostics,
+            };
         if (target.format === "mach-o" && target.availableArchitectures.length > 1)
             return {
                 status: "unsupported",
@@ -96,7 +115,7 @@ export class GhidraProvider {
             return {
                 status: "unsupported",
                 code: "architecture_unsupported",
-                reason: "Ghidra v1 requires a concrete x86, x86_64, arm, or arm64 target architecture.",
+                reason: "Ghidra v1 requires a supported x86, x86_64, arm, arm64, or MIPS target profile.",
                 diagnostics,
             };
         return {
@@ -108,19 +127,47 @@ export class GhidraProvider {
     }
     async resolveAnalysisProfile(target, options) {
         const installation = this.#inspectInstallation();
-        const resolved = await resolveGhidraAnalysisProfile(target, GHIDRA_PROVIDER_IDENTITY, installation, options?.signal);
+        const resolved = await resolveGhidraAnalysisProfile(target, GHIDRA_PROVIDER_IDENTITY, installation, options?.signal, this.config.ghidraLanguageOverride);
         if (!resolved.ok || resolved.value.profile === null)
             return resolved;
+        const override = this.config.ghidraLanguageOverride;
+        if (override !== undefined && installation.status === "available") {
+            let catalog;
+            try {
+                catalog = await readGhidraLanguageCatalog(installation.installDir);
+            }
+            catch (cause) {
+                return err(new ProviderAdapterError("ghidra", "resolve_analysis_profile", {
+                    cause,
+                    diagnostics: {
+                        reason: "Could not read the installed Ghidra language definitions.",
+                    },
+                }));
+            }
+            const refused = admitGhidraLanguageOverride(override, catalog, installation.providerVersion);
+            if (refused !== null)
+                return err(refused);
+        }
         const extensions = await resolveGhidraExtensions(this.config, target, installation.platform, options?.signal);
         if (!extensions.ok)
             return extensions;
-        if (extensions.value.length === 0)
+        if (options?.signal?.aborted === true)
+            return err(new AnalysisCancelledError("open_binary"));
+        const seeds = await resolveGhidraAnalysisSeeds(this.config.ghidraSeedFile);
+        if (!seeds.ok)
+            return seeds;
+        if (extensions.value.length === 0 && seeds.value === undefined)
             return resolved;
         return ok({
             ...resolved.value,
             profile: createAnalysisProfile(resolved.value.profile.provider, {
                 ...resolved.value.profile.parameters,
-                analysis_extensions: jsonValueSchema.parse(extensions.value),
+                ...(extensions.value.length === 0
+                    ? {}
+                    : { analysis_extensions: jsonValueSchema.parse(extensions.value) }),
+                ...(seeds.value === undefined
+                    ? {}
+                    : { analysis_seeds: jsonValueSchema.parse(seeds.value) }),
             }),
         });
     }
@@ -174,18 +221,19 @@ const inspectWindowsP0TargetSupport = (target, diagnostics) => {
             reason: "Windows Ghidra P0 accepts x86 and x86-64 PE targets only.",
             diagnostics,
         };
-    if (target.executableRole !== "application")
+    if (target.executableRole !== "application" &&
+        target.executableRole !== "shared-library")
         return {
             status: "unsupported",
             code: "target_role_unsupported",
-            reason: "Windows Ghidra P0 accepts PE applications, not DLL or non-executable images.",
+            reason: "Windows Ghidra P0 accepts PE applications and DLLs, not non-executable or unclassified images.",
             diagnostics,
         };
     if (target.managed !== false)
         return {
             status: "unsupported",
             code: "managed_target_unsupported",
-            reason: "Windows Ghidra P0 accepts native PE applications; managed or unclassified PE targets are unsupported.",
+            reason: "Windows Ghidra P0 accepts native PE applications and DLLs; managed or unclassified PE targets are unsupported.",
             diagnostics,
         };
     return {