rea-agents 6.0.0 → 6.2.0

package/dist/firmware/FirmwareFiles.js

@@ -102,7 +102,7 @@ export const readFirmwareReport = async (path, operation) => {
         if (bytes === undefined)
             throw new AnalysisOutputError(operation, `Report exceeded ${FIRMWARE_LIMITS.reportBytes} bytes`);
         try {
-            const value = JSON.parse(bytes.toString("utf8"));
+            const value = JSON.parse(new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes));
             return value;
         }
         catch (cause) {

package/dist/firmware/FirmwareProvider.js

@@ -3,7 +3,7 @@ import { z } from "zod";
 import { createAnalysisExecution, } from "../application/AnalysisProvider.js";
 import { firmwareResultSchemas, } from "../domain/firmware/firmwareAnalysis.js";
 import { AnalysisError } from "../domain/analysisErrorBase.js";
-import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, AnalysisInputError, AnalysisOutputError, AnalysisTimeoutError, } from "../domain/analysisErrorCore.js";
+import { AnalysisCancelledError, AnalysisInputError, AnalysisOutputError, AnalysisTimeoutError, } from "../domain/analysisErrorCore.js";
 import { ProviderAdapterError } from "../domain/providerAdapterError.js";
 import { ProviderCleanupError } from "../domain/providerCleanupError.js";
 import { err, ok } from "../domain/result.js";
@@ -11,7 +11,7 @@ import { PrivateRuntimeRoot } from "../process/PrivateRuntimeRoot.js";
 import { publishFirmwareExtraction } from "./FirmwarePublication.js";
 import { FIRMWARE_LIMITS, BINWALK_PROVIDER_IDENTITY, UNBLOB_PROVIDER_IDENTITY, } from "./FirmwareRelease.js";
 import { admitFirmwareVersion } from "./FirmwareVersion.js";
-import { resolveFirmwareCommand, runFirmwareCommand, readFirmwareCommandReport, } from "./FirmwareCommand.js";
+import { firmwareToolUnavailable, resolveFirmwareCommand, runFirmwareCommand, readFirmwareCommandReport, } from "./FirmwareCommand.js";
 import { inventoryFirmwareOutput, snapshotFirmware } from "./FirmwareFiles.js";
 import { normalizeBinwalkReport, normalizeUnblobReport, } from "./FirmwareReports.js";
 const waitForPredecessor = (predecessor, operation, signal) => new Promise((resolve, reject) => {
@@ -96,10 +96,10 @@ export class FirmwareProvider {
             const versionRun = await run(["--version"]);
             const version = versionRun.stdout.text.trim();
             if (versionRun.stdout.bytes > 1024)
-                throw new AnalysisCapabilityUnavailableError(engineName, request.operation, `Tool version banner is ${String(versionRun.stdout.bytes)} bytes; expected a short ${engineName} version line.`);
+                throw firmwareToolUnavailable(engineName, request.operation, `Tool version banner is ${String(versionRun.stdout.bytes)} bytes; expected a short ${engineName} version line.`);
             const admitted = admitFirmwareVersion(engineName, version);
             if (admitted.status === "unsupported" || admitted.status === "unresolved")
-                throw new AnalysisCapabilityUnavailableError(engineName, request.operation, admitted.message);
+                throw firmwareToolUnavailable(engineName, request.operation, admitted.message);
             const engine = {
                 name: engineName,
                 version: admitted.version,

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: "6.0.0", // x-release-please-version
+    version: "6.2.0", // x-release-please-version
     serverSdkVersion: "2.3.1",
     clientSdkVersion: "2.3.1",
     coreSdkVersion: "2.3.1",
-    skillVersion: "33",
+    skillVersion: "34",
 };

package/dist/ghidra/GhidraAnalysisProfile.js

@@ -8,7 +8,7 @@ export const resolveGhidraAnalysisProfile = (target, identity, installation, sig
     if (signal?.aborted === true)
         return Promise.resolve(err(new AnalysisCancelledError("open_binary")));
     if (target.kind !== "executable")
-        return Promise.resolve(ok({ profile: null, compatibility: {} }));
+        return Promise.resolve(ok({ profile: null }));
     if (installation.status === "unavailable")
         return Promise.resolve(err(new ProviderAdapterError(identity.id, "resolve_analysis_profile")));
     const provider = { ...identity, version: installation.providerVersion };
@@ -27,6 +27,12 @@ export const resolveGhidraAnalysisProfile = (target, identity, installation, sig
             annotation_policy: "atomic-function-entry-metadata-v1",
             load_image_observations: "source-mappings-entry-context-v2",
             function_body_evidence: "complete-inclusive-ranges-v1",
+            function_references: "complete-body-and-entry-reference-manager-v2",
+            location_resolution: "explicit-address-exact-entry-symbol-first-v3",
+            instruction_flow_evidence: "decoded-return-pcode-v1",
+            process_launch: installation.platform === "win32"
+                ? "official-headless-script-v1"
+                : "inspected-jvm-launch-support-v1",
             ...(dos
                 ? {
                     load_image_evidence: dosCom
@@ -63,9 +69,5 @@ export const resolveGhidraAnalysisProfile = (target, identity, installation, sig
                 : {}),
             analyzer_preset: "ghidra-default",
         }),
-        compatibility: {
-            languageId: dos ? "x86:LE:16:Real Mode" : "auto",
-            compilerSpecId: dos ? "default" : "auto",
-        },
     }));
 };

package/dist/ghidra/GhidraClient.js

@@ -1,6 +1,6 @@
 import { randomBytes, randomUUID } from "node:crypto";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { AnalysisError } from "../domain/analysisErrorBase.js";
+import { ProviderCleanupError } from "../domain/providerCleanupError.js";
 import { err, ok } from "../domain/result.js";
 import { silentLogger } from "../logger.js";
 import { PendingOperations } from "../process/PendingOperations.js";
@@ -8,7 +8,7 @@ import { PrivateRuntimeRoot } from "../process/PrivateRuntimeRoot.js";
 import { ProviderStartupDeadline } from "../process/ProviderDeadline.js";
 import { ProviderRunLineage } from "../process/ProviderRunLineage.js";
 import { ProviderProcessSupervisor, } from "../process/ProviderProcess.js";
-import { GHIDRA_STARTUP_TIMEOUT_MS } from "./GhidraDefaults.js";
+import { DEFAULT_GHIDRA_STARTUP_TIMEOUT_MS } from "../config/ghidraStartupTimeout.js";
 import { createGhidraDiagnostics } from "./GhidraDiagnostics.js";
 import { GhidraResponseBuffer } from "./GhidraResponseBuffer.js";
 import { GhidraResponseRouter } from "./GhidraResponseRouter.js";
@@ -18,10 +18,12 @@ import { isGhidraShutdownAcknowledgement, parseGhidraSessionInfo, } from "./Ghid
 import { createGhidraTargetSnapshot } from "./GhidraTargetSnapshot.js";
 import { readFile } from "node:fs/promises";
 import { connectGhidraSocket } from "./GhidraSocketConnection.js";
+import { createGhidraEndpoint, } from "./GhidraTransport.js";
 import { GhidraWire } from "./GhidraClientWire.js";
 import { completeGhidraStartupHandshake } from "./GhidraClientStartup.js";
+import { ghidraSessionRoot } from "./GhidraSessionRoot.js";
 const SHUTDOWN_TIMEOUT_MS = 10_000;
-const SESSION_ROOT = tmpdir();
+const SESSION_ROOT = ghidraSessionRoot();
 /** Owns an authenticated private Ghidra session with transport-bound mutation authority. */
 export class GhidraClient {
     #options;
@@ -32,6 +34,8 @@ export class GhidraClient {
     #launch;
     #process;
     #runtimeRoot;
+    #socketRoot;
+    #endpointPath;
     #snapshotPath;
     #targetAdmission;
     #token;
@@ -71,7 +75,7 @@ export class GhidraClient {
     constructor(options) {
         this.#options = {
             ...options,
-            startupTimeoutMs: options.startupTimeoutMs ?? GHIDRA_STARTUP_TIMEOUT_MS,
+            startupTimeoutMs: options.startupTimeoutMs ?? DEFAULT_GHIDRA_STARTUP_TIMEOUT_MS,
             platform: options.platform ?? process.platform,
             transport: options.transport ?? "unix-socket",
         };
@@ -89,9 +93,14 @@ export class GhidraClient {
     /** Launch Ghidra once and require its exact post-analysis handshake. */
     start(signal) {
         if (this.#closePromise !== undefined)
-            return this.#closePromise.then(() => this.start(signal));
-        if (this.#startPromise !== undefined)
+            return this.#closePromise.then(() => this.start(signal), (cause) => err(new GhidraSessionError("process", "Ghidra cleanup remains incomplete", this.#diagnostics(), { cause, cleanupFailure: this.#cleanupError(cause) })));
+        if (this.#startPromise !== undefined) {
+            if (this.#startupController?.signal.aborted && !signal?.aborted)
+                return this.#startPromise.then((result) => result.ok || result.error.cleanupFailure !== undefined
+                    ? result
+                    : this.start(signal));
             return this.#startPromise;
+        }
         const controller = new AbortController();
         const onAbort = () => controller.abort(signal?.reason);
         if (signal?.aborted === true)
@@ -148,8 +157,43 @@ export class GhidraClient {
         }
     }
     /** Stop the owned process group and remove all project/runtime artifacts. */
-    close() {
-        return this.#requestClose(false);
+    async close() {
+        try {
+            await this.#requestClose(false);
+            return ok(null);
+        }
+        catch (cause) {
+            return err(this.#cleanupError(cause));
+        }
+    }
+    #cleanupError(cause) {
+        if (cause instanceof AnalysisError && cause.cleanupIncomplete)
+            return cause;
+        return new ProviderCleanupError("ghidra", [
+            ...(this.#process === undefined ? [] : ["ghidra-process"]),
+            ...[this.#runtimeRoot, this.#socketRoot].flatMap((root) => root === undefined ? [] : [root.path]),
+        ], {
+            reason: cause instanceof Error ? cause.message : String(cause),
+            diagnostics: this.#diagnostics(),
+        }, { cause });
+    }
+    async #startupFailure(primary) {
+        try {
+            await this.#cleanup();
+            return err(primary);
+        }
+        catch (cause) {
+            return err(new GhidraSessionError(primary.kind, primary.message, primary.diagnostics, {
+                ...(primary.cause === undefined ? {} : { cause: primary.cause }),
+                ...(primary.timeoutMs === undefined
+                    ? {}
+                    : { timeoutMs: primary.timeoutMs }),
+                ...(primary.remoteCode === undefined
+                    ? {}
+                    : { remoteCode: primary.remoteCode }),
+                cleanupFailure: this.#cleanupError(cause),
+            }));
+        }
     }
     #requestClose(forceStop) {
         const starting = this.#startPromise;
@@ -177,10 +221,16 @@ export class GhidraClient {
             return err(this.#failure("cancelled", "Ghidra startup was cancelled"));
         if (this.#socket !== undefined || this.#runtimeRoot !== undefined)
             return err(this.#failure("protocol", "Ghidra client is already started"));
+        this.#processSnapshot = undefined;
         const deadline = new ProviderStartupDeadline(this.#options.startupTimeoutMs, signal);
         try {
             return await this.#startWithin(deadline);
         }
+        catch (cause) {
+            if (cause instanceof GhidraSessionError)
+                return err(cause);
+            throw cause;
+        }
         finally {
             deadline.dispose();
         }
@@ -198,12 +248,17 @@ export class GhidraClient {
         }
         if (deadline.signal.aborted)
             return this.#startupInterrupted(deadline);
-        const endpoint = {
-            transport: this.#options.transport,
-            path: join(this.#runtimeRoot.path, this.#options.transport === "unix-socket"
-                ? "bridge.sock"
-                : "bridge-endpoint.json"),
-        };
+        let endpoint;
+        try {
+            const allocated = await createGhidraEndpoint(this.#runtimeRoot.path, this.#options.transport, this.#options.platform);
+            endpoint = allocated.endpoint;
+            this.#socketRoot = allocated.socketRoot;
+            this.#endpointPath = endpoint.path;
+        }
+        catch (cause) {
+            const failure = this.#failure("start", "Ghidra private endpoint allocation failed", cause);
+            return this.#startupFailure(failure);
+        }
         try {
             const snapshot = await createGhidraTargetSnapshot(this.#options.targetPath, this.#runtimeRoot.path, this.#options.targetSha256, { signal: deadline.signal, platform: this.#options.platform });
             this.#snapshotPath = snapshot.path;
@@ -213,8 +268,7 @@ export class GhidraClient {
             if (deadline.signal.aborted)
                 return this.#startupInterrupted(deadline);
             const failure = this.#failure("start", "Ghidra target snapshot failed admission", cause);
-            await this.#cleanup();
-            return err(failure);
+            return this.#startupFailure(failure);
         }
         if (deadline.signal.aborted)
             return this.#startupInterrupted(deadline);
@@ -241,8 +295,7 @@ export class GhidraClient {
                 : launched.error instanceof GhidraSessionError
                     ? launched.error
                     : this.#failure("start", launched.error.message, launched.error);
-            await this.#cleanup();
-            return err(failure);
+            return this.#startupFailure(failure);
         }
         this.#launch = launched.value;
         this.#process = new ProviderProcessSupervisor(launched.value, {
@@ -251,21 +304,19 @@ export class GhidraClient {
         const connected = await this.#connect(endpoint, deadline);
         if (!connected.ok) {
             const failure = connected.error;
-            await this.#cleanup();
-            return err(failure);
+            return this.#startupFailure(failure);
         }
         const completed = await completeGhidraStartupHandshake({
             deadline,
             request: (method, params, requestOptions) => this.#wire.request(method, params, requestOptions),
             parseSessionInfo: (value) => this.#parseSessionInfo(value),
-            cleanup: () => this.#cleanup(),
             failure: this.#failure,
             startupTimeoutMs: this.#options.startupTimeoutMs,
         });
-        if (completed.ok) {
-            await this.#lineage.observe(this.#launch);
-            this.#requestQueue.reopen();
-        }
+        if (!completed.ok)
+            return this.#startupFailure(completed.error);
+        await this.#lineage.observe(this.#launch);
+        this.#requestQueue.reopen();
         return completed;
     }
     async #connect(endpoint, deadline) {
@@ -274,7 +325,7 @@ export class GhidraClient {
             deadline,
             failure: this.#failure,
             isClosed: () => this.#closing,
-            processExited: () => this.#processSnapshot?.exitCode !== undefined,
+            processExited: () => this.#process?.snapshot().exitCode !== undefined,
             startupTimeoutMs: this.#options.startupTimeoutMs,
             handlers: {
                 data: this.#onSocketData,
@@ -364,17 +415,16 @@ 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}`);
+                    // Keep the supervisor and private files available for a later close.
+                    // A still-live JVM can recreate files if its runtime is removed here.
+                    throw this.#failure("process", `Ghidra process cleanup was incomplete: ${stopped.reason}`);
                 }
             }
             this.#lastDiagnostics = this.#diagnostics();
             this.#process = undefined;
             this.#launch = undefined;
-            const runtimeRoot = this.#runtimeRoot;
-            this.#runtimeRoot = undefined;
             try {
-                await runtimeRoot?.close();
+                await this.#removeRuntimeRoots();
             }
             catch (cause) {
                 if (forceStop)
@@ -383,6 +433,7 @@ export class GhidraClient {
                     throw cause;
             }
             this.#snapshotPath = undefined;
+            this.#endpointPath = undefined;
             this.#token = undefined;
             this.#runId = undefined;
             this.#responseBuffer.reset();
@@ -393,6 +444,42 @@ export class GhidraClient {
             this.#closing = false;
         }
     }
+    /**
+     * Remove the runtime and socket roots, keeping each one that could not be
+     * removed so a later close retries it rather than reporting success.
+     */
+    async #removeRuntimeRoots() {
+        const roots = [
+            {
+                root: this.#runtimeRoot,
+                release: () => (this.#runtimeRoot = undefined),
+            },
+            { root: this.#socketRoot, release: () => (this.#socketRoot = undefined) },
+        ];
+        const leftovers = [];
+        let firstCause;
+        for (const { root, release } of roots) {
+            if (root === undefined)
+                continue;
+            try {
+                await root.close();
+                release();
+            }
+            catch (cause) {
+                firstCause ??= cause;
+                leftovers.push({
+                    path: root.path,
+                    reason: cause instanceof Error ? cause.message : String(cause),
+                });
+            }
+        }
+        if (leftovers.length > 0)
+            throw new ProviderCleanupError("ghidra", leftovers.map(({ path }) => path), {
+                reason: "Ghidra's private runtime directory could not be removed; it is retained for a later close.",
+                leftover_paths: leftovers.map(({ path }) => path),
+                failures: leftovers.map(({ path, reason }) => `${path}: ${reason}`),
+            }, { cause: firstCause });
+    }
     #redactAuthentication(value) {
         for (const token of this.#authenticationTokens)
             value = value.replaceAll(token, "[REDACTED]");
@@ -430,8 +517,7 @@ export class GhidraClient {
     }
     async #startupInterrupted(deadline) {
         const failure = this.#interruptionFailure(deadline);
-        await this.#cleanup();
-        return err(failure);
+        return this.#startupFailure(failure);
     }
     #interruptionFailure(deadline) {
         return deadline.interruption === "cancelled"
@@ -455,6 +541,12 @@ export class GhidraClient {
             ...(this.#runtimeRoot === undefined
                 ? {}
                 : { runtimeRoot: this.#runtimeRoot.path }),
+            ...(this.#socketRoot === undefined
+                ? {}
+                : { socketRoot: this.#socketRoot.path }),
+            ...(this.#endpointPath === undefined
+                ? {}
+                : { endpointPath: this.#endpointPath }),
             ...(this.#launch === undefined ? {} : { launch: this.#launch }),
             ...(snapshot === undefined ? {} : { snapshot }),
             ...(this.#token === undefined ? {} : { token: this.#token }),

package/dist/ghidra/GhidraClientStartup.js

@@ -9,7 +9,6 @@ export async function completeGhidraStartupHandshake(options) {
         const failure = options.deadline.signal.aborted
             ? interruptionFailure(options)
             : ping.error;
-        await options.cleanup();
         return err(failure);
     }
     const parsed = options.parseSessionInfo(ping.value);
@@ -17,7 +16,6 @@ export async function completeGhidraStartupHandshake(options) {
         const failure = parsed.ok
             ? options.failure("analysis_timeout", "Ghidra auto-analysis reached its per-file deadline")
             : parsed.error;
-        await options.cleanup();
         return err(failure);
     }
     return parsed;

package/dist/ghidra/GhidraDiagnostics.js

@@ -1,4 +1,3 @@
-import { join } from "node:path";
 /** Preserve actionable runtime coordinates after cleanup and redact bearer data. */
 export const createGhidraDiagnostics = (options) => {
     if (options.runtimeRoot === undefined &&
@@ -20,12 +19,13 @@ export const createGhidraDiagnostics = (options) => {
         ...(options.runId === undefined ? {} : { run_id: options.runId }),
         ...(options.runtimeRoot === undefined
             ? {}
-            : {
-                runtime_root: options.runtimeRoot,
-                endpoint_path: join(options.runtimeRoot, options.transport === "unix-socket"
-                    ? "bridge.sock"
-                    : "bridge-endpoint.json"),
-            }),
+            : { runtime_root: options.runtimeRoot }),
+        ...(options.socketRoot === undefined
+            ? {}
+            : { socket_root: options.socketRoot }),
+        ...(options.endpointPath === undefined
+            ? {}
+            : { endpoint_path: options.endpointPath }),
         ...(options.launch === undefined
             ? {}
             : {

package/dist/ghidra/GhidraDoctor.js

@@ -38,13 +38,14 @@ export const projectGhidraDoctorInspection = (inspection) => {
     };
 };
 /** Inspect the process-configured BYO Ghidra installation for `rea doctor`. */
-export const inspectSystemGhidraProvider = () => Promise.resolve(projectGhidraDoctorInspection(inspectGhidraInstallation({
-    ...(process.env.GHIDRA_INSTALL_DIR === undefined
+export const inspectSystemGhidraProvider = (environment) => Promise.resolve(projectGhidraDoctorInspection(inspectGhidraInstallation({
+    environment,
+    ...(environment.GHIDRA_INSTALL_DIR === undefined
         ? {}
-        : { installDir: process.env.GHIDRA_INSTALL_DIR }),
-    ...(process.env.JAVA_HOME === undefined
+        : { installDir: environment.GHIDRA_INSTALL_DIR }),
+    ...(environment.JAVA_HOME === undefined
         ? {}
-        : { javaHome: process.env.JAVA_HOME }),
+        : { javaHome: environment.JAVA_HOME }),
 })));
 const selectedChecks = (inspection) => {
     const byName = new Map(inspection.checks.map((candidate) => [candidate.name, candidate]));

package/dist/ghidra/GhidraFunctionValues.js

@@ -2,13 +2,14 @@ import { z } from "zod";
 import { nativeFunctionAnnotationsInputSchema, nativeFunctionAnnotationsSchema, } from "../domain/native/nativeFunctionAnnotations.js";
 import { nativeDataTypeSchema } from "../domain/native/nativeDataType.js";
 import { nativeInstructionSchema, nativeCallTargetsSchema, } from "../domain/native/nativeInstruction.js";
-import { AnalysisInputError, AnalysisOutputError, } from "../domain/analysisErrorCore.js";
+import { AnalysisOutputError, } from "../domain/analysisErrorCore.js";
 import { functionBodyEntryAgrees, functionInstructionWindowSchema, functionDossierSchema, } from "../domain/hopperValues.js";
 import { jsonObjectSchema, jsonValueSchema, } from "../domain/jsonValue.js";
 import { nativeApiBoundarySchema } from "../domain/native/nativeApiBoundary.js";
 import { nativeValueFlowSchema } from "../domain/native/nativeValueFlow.js";
 import { err, ok } from "../domain/result.js";
-import { ghidraIdentifierSchema, ghidraCanonicalAddressSchema, ghidraFunctionClassificationSchema as classification, ghidraFunctionBodySchema as ghidraFunctionBody, ghidraProcedureIdentitySchema as procedureIdentity, } from "./GhidraInventoryValues.js";
+import { analysisInputErrorFromIssues } from "../domain/inputIssueProjection.js";
+import { ghidraIdentifierSchema, ghidraInputAddressSchema, ghidraCanonicalAddressSchema, ghidraFunctionClassificationSchema as classification, ghidraFunctionBodySchema as ghidraFunctionBody, ghidraProcedureIdentitySchema as procedureIdentity, } from "./GhidraInventoryValues.js";
 /** Function analysis and annotation operations admitted by the Ghidra adapter. */
 export const GHIDRA_FUNCTION_OPERATIONS = [
     "annotate_native_function",
@@ -37,15 +38,15 @@ const inputSchemas = {
         .object({
         document,
         type: z.string().min(1).nullable().default(null),
-        address: ghidraCanonicalAddressSchema.nullable().default(null),
+        address: ghidraInputAddressSchema.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 })
+        .object({ document, address: ghidraInputAddressSchema })
         .strict(),
     resolve_native_call_targets: z
-        .object({ document, address: ghidraCanonicalAddressSchema })
+        .object({ document, address: ghidraInputAddressSchema })
         .strict(),
     analyze_function: z.object({ procedure }).strict(),
     procedure_assembly: z.object(directProcedure).strict(),
@@ -60,14 +61,16 @@ const inputSchemas = {
         direction: z.enum(["incoming", "outgoing"]).default("outgoing"),
     })
         .strict(),
-    xrefs: z.object({ document, address: ghidraCanonicalAddressSchema }).strict(),
+    xrefs: z.object({ document, address: ghidraInputAddressSchema }).strict(),
 };
 /** Validate and default one function request before it crosses the socket. */
 export const parseGhidraFunctionInput = (operation, value) => {
     const parsed = inputSchemas[operation].safeParse(value);
     return parsed.success
         ? ok(jsonObjectSchema.parse(Object.fromEntries(Object.entries(parsed.data).filter(([, value]) => value !== undefined))))
-        : err(new AnalysisInputError(operation, { cause: parsed.error }));
+        : err(analysisInputErrorFromIssues(operation, parsed.error.issues, value, {
+            cause: parsed.error,
+        }));
 };
 const localVariable = z
     .object({
@@ -109,13 +112,11 @@ 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({
+    reference_kinds_available: z.boolean(),
+    unresolved_calls: z.array(z.strictObject({
         address: ghidraCanonicalAddressSchema,
         reason: z.string(),
-    }))
-        .default([]),
+    })),
 })
     .strict();
 const procedureInfo = z