rea-agents 3.1.0 → 3.2.1

package/dist/application/AuthorizedArtifactInventory.js

@@ -1,17 +1,7 @@
 import { realpath } from "node:fs/promises";
-import { ArtifactReaderFailure } from "../artifacts/ArtifactReader.js";
-import { withinRoot } from "../reference/ReferenceSourceReaderPaths.js";
 import { scanCanonicalArtifactInventory, } from "./ArtifactInventory.js";
-import { canonicalizeConfiguredRoots } from "./ConfiguredRoots.js";
 /** Resolve, authorize, and scan one artifact without a second path resolution. */
-export const scanAuthorizedArtifactInventory = async (inputPath, roots, limits, options = {}) => {
-    if (roots.length === 0)
-        throw new ArtifactReaderFailure("path", "Artifact input roots are disabled");
-    const [path, approved] = await Promise.all([
-        realpath(inputPath),
-        canonicalizeConfiguredRoots(roots),
-    ]);
-    if (!approved.some((root) => withinRoot(root, path)))
-        throw new ArtifactReaderFailure("path", "Artifact path is outside approved input roots");
-    return scanCanonicalArtifactInventory(path, limits, options);
+export const scanAuthorizedArtifactInventory = async (inputPath, options = {}) => {
+    const path = await realpath(inputPath);
+    return scanCanonicalArtifactInventory(path, options);
 };

package/dist/application/BinarySession.js

@@ -19,20 +19,15 @@ const ENHANCED_OPERATIONS = new Set(GENERATED_MCP_TOOL_CATALOG.filter(({ kind })
  * of retaining a client whose resources were already shut down.
  */
 export class BinarySession extends BinarySessionRecords {
-    provider;
     #active;
     #transition = Promise.resolve();
     #calls = new Set();
     #providerRouter;
     #runtimeUnavailability = new Map();
     #availabilityListeners = new Set();
-    constructor(provider, options = {}) {
+    constructor(providerRouter) {
         super();
-        this.provider = provider;
-        this.#providerRouter =
-            provider instanceof SessionProviderRouter
-                ? provider
-                : SessionProviderRouter.legacy(provider, options);
+        this.#providerRouter = providerRouter;
     }
     /** Identify the provider producing evidence for this session. */
     providerIdentity(operation) {
@@ -173,7 +168,14 @@ export class BinarySession extends BinarySessionRecords {
             await this.#drainCalls();
             const closed = previous === undefined
                 ? ok(null)
-                : await closeAnalysisClient(previous.client, previous.route.identity.id, options);
+                : await closeAnalysisClient(previous.client, previous.route.identity.id, {
+                    ...(options.progress === undefined
+                        ? {}
+                        : { progress: options.progress }),
+                    ...(options.retainProviderDocuments === true
+                        ? { retainDocument: true }
+                        : {}),
+                });
             this.clearSessionRecords();
             this.#clearRuntimeAvailability();
             return closed;
@@ -214,7 +216,9 @@ export class BinarySession extends BinarySessionRecords {
             operation: name,
             parameters: arguments_,
             unboundOperationError: (operation, route) => this.#providerRouter.unboundOperationError(operation, route),
-            lookupSnapshot: (target, profile, operation, parameters) => this.lookupSnapshot(target, profile, operation, parameters),
+            lookupSnapshot: (target, profile, operation, parameters) => operation === "decode_interface_builder"
+                ? undefined
+                : this.lookupSnapshot(target, profile, operation, parameters),
         });
         if (!prepared.ok)
             return prepared;
@@ -225,9 +229,12 @@ export class BinarySession extends BinarySessionRecords {
         this.#calls.add(call);
         try {
             const result = await call;
-            const profiled = commitExecutionProfile(name, result, profile);
+            const profiled = bindExecutionTarget(commitExecutionProfile(name, result, profile), name, active.target);
             this.#observeRuntimeAvailability(name, profiled);
-            if (profiled.ok && cacheable && profile !== undefined)
+            if (profiled.ok &&
+                cacheable &&
+                profile !== undefined &&
+                name !== "decode_interface_builder")
                 this.recordSnapshot({
                     target: active.target,
                     profile,
@@ -259,7 +266,6 @@ export class BinarySession extends BinarySessionRecords {
             "ProviderAdapterError",
             "HopperProcessError",
             "HopperStartError",
-            "HopperRemoteError",
         ].includes(result.error._tag)) {
             const capabilities = this.#active?.route.capabilities;
             const providerId = capabilities?.get(operation)?.provider.id;
@@ -267,7 +273,7 @@ export class BinarySession extends BinarySessionRecords {
             for (const descriptor of capabilities?.values() ?? [])
                 if (providerId !== undefined && descriptor.provider.id === providerId)
                     changed =
-                        this.#markRuntimeUnavailable(descriptor.operation, "Provider became unavailable during this session.") || changed;
+                        this.#markRuntimeUnavailable(descriptor.operation, `${result.error._tag}: ${result.error.message}`) || changed;
             if (changed)
                 this.#emitAvailabilityChanged();
         }
@@ -370,3 +376,25 @@ const commitExecutionProfile = (operation, result, profile) => {
         analysisProfile: structuredClone(profile),
     });
 };
+const bindExecutionTarget = (result, operation, target) => {
+    if (!result.ok)
+        return result;
+    const subject = {
+        path: target.path,
+        sha256: target.sha256,
+        format: target.format === "analysis-database"
+            ? "analysis-database"
+            : target.format,
+        ...(target.architecture === undefined
+            ? {}
+            : { architecture: target.architecture }),
+    };
+    if (result.value.subject !== null &&
+        result.value.subject.sha256 !== target.sha256) {
+        if (!isArtifactInventorySubject(operation, result.value.subject, target))
+            return err(new ProviderAdapterError(result.value.provider.id, `${operation}:subject`));
+    }
+    return ok({ ...result.value, subject: result.value.subject ?? subject });
+};
+const isArtifactInventorySubject = (operation, subject, target) => (operation === "inventory_artifact" || operation === "inspect_artifact") &&
+    subject.path === (target.sourcePath ?? target.path);

package/dist/application/BinarySessionComposition.js

@@ -1,9 +1,6 @@
 import { AnalysisProviderRegistry } from "./AnalysisProviderRegistry.js";
 import { BinarySession } from "./BinarySession.js";
 import { SessionProviderRouter } from "./SessionProviderRouter.js";
-const normalizeBinarySessionOptions = (optionsOrResolver) => typeof optionsOrResolver === "function"
-    ? { resolveAnalysisProfile: optionsOrResolver }
-    : (optionsOrResolver ?? {});
 /**
  * Compose one provider-neutral session from deep-provider selection and
  * disjoint auxiliary operation families.
@@ -11,11 +8,3 @@ const normalizeBinarySessionOptions = (optionsOrResolver) => typeof optionsOrRes
 export const composeBinarySession = (registry, auxiliaryProviders = []) => new BinarySession(registry instanceof SessionProviderRouter
     ? registry
     : SessionProviderRouter.selectable(registry, auxiliaryProviders));
-/**
- * Compose a session through the same internal seam for focused adapter tests.
- * The constructor remains private to this composition module, so callers test
- * provider behavior without coupling to BinarySession construction.
- */
-export const composeBinarySessionFromFactory = (provider, optionsOrResolver) => new BinarySession(provider, normalizeBinarySessionOptions(optionsOrResolver));
-/** Compose a focused session from any provider-shaped test seam. */
-export const composeBinarySessionFromProvider = (provider, optionsOrResolver) => new BinarySession(provider, normalizeBinarySessionOptions(optionsOrResolver));

package/dist/application/BinarySessionOpen.js

@@ -1,5 +1,6 @@
 import { snapshotMatchesBinding, snapshotMatchesTarget, snapshotTarget, } from "../domain/analysisSnapshot.js";
-import { parseBinaryTarget, } from "../domain/binaryTarget.js";
+import { parseBinaryTarget } from "./BinaryTargetResolver.js";
+import {} from "../domain/binaryTarget.js";
 import { EvidenceIntegrityError, } from "../domain/errors.js";
 import { err } from "../domain/result.js";
 import { SessionProviderRouter } from "./SessionProviderRouter.js";

package/dist/application/BinarySessionRecords.js

@@ -1,25 +1,14 @@
 import { createEvidence } from "../domain/evidence.js";
-import { evidenceBundleForTarget, serializeEvidenceBundle, } from "../domain/evidenceBundle.js";
-import { EvidenceIntegrityError, EvidenceLimitError, } from "../domain/errors.js";
-import { parseInvestigationWorkspace, } from "../domain/investigationWorkspace.js";
-import { parseReconstructionCoverageWorkspace, } from "../domain/reconstructionCoverage.js";
+import { evidenceBundleForTarget } from "../domain/evidenceBundle.js";
+import { EvidenceIntegrityError, } from "../domain/errors.js";
 import { err, ok } from "../domain/result.js";
 import { AnalysisSnapshotCache } from "./AnalysisSnapshotCache.js";
 import { EvidenceLedger } from "./EvidenceLedger.js";
 import { UNKNOWN_REGISTRY_PROVIDER, unknownEvidenceLinks, unknownMutationEvidence, } from "./UnknownEvidence.js";
-/** Owns session evidence, snapshots, workspaces, and residual unknowns. */
+/** Owns session evidence, snapshots, and residual unknowns. */
 export class BinarySessionRecords {
-    static MAX_RETAINED_BUNDLES = 16;
-    static MAX_RETAINED_BUNDLE_BYTES = 64 * 1024 * 1024;
-    #evidence = new EvidenceLedger({
-        maxRecords: 10_000,
-        maxBytes: 64 * 1024 * 1024,
-    });
+    #evidence = new EvidenceLedger();
     #snapshot = new AnalysisSnapshotCache();
-    #retainedBundles = new Map();
-    #retainedBundleBytes = 0;
-    #investigationWorkspaces = new Map();
-    #coverageWorkspaces = new Map();
     #snapshotInvalidated = false;
     #snapshotListeners = new Set();
     /** Observe changes to the mutable current analysis snapshot resource. */
@@ -42,45 +31,6 @@ export class BinarySessionRecords {
     exportEvidenceBundle() {
         return this.#evidence.export();
     }
-    snapshotEvidenceBundle() {
-        const bundle = this.#evidence.export();
-        const encoded = serializeEvidenceBundle(bundle);
-        const digest = createHash("sha256").update(encoded).digest("hex");
-        const existing = this.#retainedBundles.get(digest);
-        if (existing === undefined) {
-            if (this.#retainedBundles.size >= BinarySessionRecords.MAX_RETAINED_BUNDLES)
-                return err(new EvidenceLimitError("records", BinarySessionRecords.MAX_RETAINED_BUNDLES));
-            const bytes = Buffer.byteLength(encoded);
-            if (this.#retainedBundleBytes + bytes >
-                BinarySessionRecords.MAX_RETAINED_BUNDLE_BYTES)
-                return err(new EvidenceLimitError("bytes", BinarySessionRecords.MAX_RETAINED_BUNDLE_BYTES));
-            this.#retainedBundles.set(digest, encoded);
-            this.#retainedBundleBytes += bytes;
-        }
-        return ok({
-            bundleDigest: digest,
-            bundleVersion: 2,
-            bytes: Buffer.byteLength(existing ?? encoded),
-            records: bundle.records.length,
-            unknowns: bundle.unknowns.length,
-            scope: "session",
-            survivesSession: false,
-            uri: `rea://evidence-bundle/${digest}`,
-        });
-    }
-    retainedEvidenceBundle(digest) {
-        return this.#retainedBundles.get(digest);
-    }
-    /** Release one immutable bundle so bounded retention has an explicit recovery path. */
-    releaseEvidenceBundle(bundleDigest) {
-        const encoded = this.#retainedBundles.get(bundleDigest);
-        if (encoded === undefined)
-            return false;
-        this.#retainedBundles.delete(bundleDigest);
-        this.#retainedBundleBytes -= Buffer.byteLength(encoded);
-        this.#emitSnapshotChanged();
-        return true;
-    }
     importEvidenceBundle(bundle) {
         const imported = this.#evidence.import(bundle);
         if (!imported.ok)
@@ -148,8 +98,6 @@ export class BinarySessionRecords {
         this.#evidence.clear();
         this.#snapshot.clear();
         this.#snapshotInvalidated = false;
-        this.#retainedBundles.clear();
-        this.#retainedBundleBytes = 0;
         this.#emitSnapshotChanged();
     }
     #emitSnapshotChanged() {
@@ -165,36 +113,6 @@ export class BinarySessionRecords {
             }
         }
     }
-    retainInvestigationWorkspace(workspace) {
-        const parsed = parseInvestigationWorkspace(workspace);
-        const key = workspaceKey(parsed.workspace_id, parsed.revision);
-        if (this.#investigationWorkspaces.has(key))
-            return "duplicate";
-        this.#investigationWorkspaces.set(key, parsed);
-        return "added";
-    }
-    investigationWorkspace(workspaceId, revision) {
-        const workspace = this.#investigationWorkspaces.get(workspaceKey(workspaceId, revision));
-        return workspace === undefined ? undefined : structuredClone(workspace);
-    }
-    investigationWorkspaces() {
-        return sortedWorkspaces(this.#investigationWorkspaces.values());
-    }
-    retainReconstructionCoverageWorkspace(workspace) {
-        const parsed = parseReconstructionCoverageWorkspace(workspace);
-        const key = workspaceKey(parsed.workspace_id, parsed.revision);
-        if (this.#coverageWorkspaces.has(key))
-            return "duplicate";
-        this.#coverageWorkspaces.set(key, parsed);
-        return "added";
-    }
-    reconstructionCoverageWorkspace(workspaceId, revision) {
-        const workspace = this.#coverageWorkspaces.get(workspaceKey(workspaceId, revision));
-        return workspace === undefined ? undefined : structuredClone(workspace);
-    }
-    reconstructionCoverageWorkspaces() {
-        return sortedWorkspaces(this.#coverageWorkspaces.values());
-    }
     recordUnknown(input) {
         const target = this.activeAnalysisBinding()?.target;
         const recorded = this.#evidence.recordUnknown(input, unknownMutationEvidence(target, input));
@@ -211,7 +129,7 @@ export class BinarySessionRecords {
     updateUnknown(input) {
         const target = this.activeAnalysisBinding()?.target;
         const evidence = createEvidence(target, UNKNOWN_REGISTRY_PROVIDER, {
-            predicateType: "rea.residual-unknown-mutation/v1",
+            predicateType: "rea.residual-unknown-mutation",
             operation: "update_unknown",
             parameters: {
                 unknown_id: input.unknown_id,
@@ -237,9 +155,3 @@ export class BinarySessionRecords {
         return this.#evidence.verifyUnknownResolution(unknownId);
     }
 }
-const workspaceKey = (workspaceId, revision) => `${workspaceId}:${String(revision)}`;
-const sortedWorkspaces = (workspaces) => [...workspaces]
-    .sort((left, right) => left.workspace_id.localeCompare(right.workspace_id) ||
-    left.revision - right.revision)
-    .map((workspace) => structuredClone(workspace));
-import { createHash } from "node:crypto";

package/dist/application/BinarySessionStatus.js

@@ -4,6 +4,7 @@ export const binarySessionStatus = ({ target, route, router, runtimeUnavailabili
     const provider = providerSummary(configuredProvider);
     const providers = router.providerIdentities(route).map(providerSummary);
     const capabilities = [...(route.capabilities?.values() ?? [])]
+        .filter(({ operation }) => operation !== "inventory_artifact")
         .sort((left, right) => left.operation.localeCompare(right.operation))
         .map((descriptor) => {
         const unavailable = runtimeUnavailability.get(descriptor.operation);
@@ -32,6 +33,7 @@ export const binarySessionStatus = ({ target, route, router, runtimeUnavailabili
         selected: candidate.selected,
         capabilities: candidate.capabilities
             .slice()
+            .filter(({ operation }) => operation !== "inventory_artifact")
             .sort((left, right) => left.operation.localeCompare(right.operation))
             .map(capabilityStatus),
     }));
@@ -73,7 +75,6 @@ const requestActivityStatus = (snapshots) => {
                 request_id: active.requestId,
                 operation: active.operation,
                 elapsed_ms: active.elapsedMs,
-                timeout_ms: active.timeoutMs,
                 caller_state: active.callerState,
             },
         queued_requests: queuedRequests,
@@ -82,11 +83,9 @@ const requestActivityStatus = (snapshots) => {
     return {
         status: snapshots.length === 0
             ? "not_observed"
-            : active.some(({ callerState }) => callerState === "timed_out")
-                ? "timed_out_busy"
-                : active.length > 0
-                    ? "busy"
-                    : "idle",
+            : active.length > 0
+                ? "busy"
+                : "idle",
         providers,
     };
 };
@@ -111,7 +110,6 @@ const processLineageStatus = (snapshots) => snapshots.length === 0
                 : {
                     status: observation.status,
                     observed_at: observation.observedAt,
-                    schema_version: observation.lineage.schemaVersion,
                     launcher_pid: observation.lineage.launcherPid,
                     launcher_parent_pid: observation.lineage.launcherParentPid,
                     process_group_id: observation.lineage.processGroupId,
@@ -128,10 +126,6 @@ const capabilityStatus = (descriptor) => ({
     available: descriptor.available,
     reason: descriptor.reason,
     availability_code: descriptor.availabilityCode ?? null,
-    input_contract_version: descriptor.inputContractVersion,
-    output_contract_version: descriptor.outputContractVersion,
-    pagination: descriptor.pagination,
-    exhaustive: descriptor.exhaustive,
     effects: {
         mutates_artifact: descriptor.effects.mutatesArtifact,
         launches_process: descriptor.effects.launchesProcess,
@@ -141,10 +135,5 @@ const capabilityStatus = (descriptor) => ({
         changes_permissions: descriptor.effects.changesPermissions,
         requires_root: descriptor.effects.requiresRoot,
     },
-    limits: {
-        max_results: descriptor.limits.maxResults,
-        max_payload_bytes: descriptor.limits.maxPayloadBytes,
-        timeout_ms: descriptor.limits.timeoutMs,
-    },
     limitations: [...descriptor.limitations],
 });

package/dist/application/BinaryTargetResolver.js

@@ -0,0 +1,216 @@
+import { constants } from "node:fs";
+import { createHash } from "node:crypto";
+import { access, open, readFile, realpath, stat, } from "node:fs/promises";
+import { execFile } from "node:child_process";
+import { extname, isAbsolute, join, resolve } from "node:path";
+import { promisify } from "node:util";
+import { isPathWithinRoot } from "../domain/localPath.js";
+import { BinaryTargetError } from "../domain/errors.js";
+import { err, ok } from "../domain/result.js";
+import { hasZipSignature, zipPackageFormatForPath, } from "../domain/zipPackageFormat.js";
+import { parseExecutableHeader, parsePeRecord, } from "../domain/binaryTarget.js";
+const execFileAsync = promisify(execFile);
+/**
+ * Resolve and classify a readable local target before a provider is selected.
+ * FAT Mach-O inputs select only a host-compatible architecture so setup remains
+ * non-interactive; unsupported or ambiguous inputs are returned as typed errors.
+ */
+export const parseBinaryTarget = async (input, cwd = process.cwd(), hostArchitecture = process.arch, targetKind) => {
+    const candidate = isAbsolute(input) ? input : resolve(cwd, input);
+    try {
+        await access(candidate, constants.R_OK);
+        const canonical = await realpath(candidate);
+        const resolved = await resolveAppBundle(canonical);
+        if (!resolved.ok)
+            return err(resolved.error);
+        const path = resolved.value;
+        const handle = await open(path, "r");
+        try {
+            if (!(await handle.stat()).isFile())
+                return err(new BinaryTargetError(path, "target is not a regular file"));
+            if (targetKind === "database" ||
+                (targetKind === undefined && path.toLowerCase().endsWith(".hop")))
+                return ok({
+                    path,
+                    sourcePath: canonical,
+                    sha256: await sha256Handle(handle),
+                    kind: "database",
+                    format: "analysis-database",
+                });
+            const artifactFormat = await detectArtifactFormat(path, handle);
+            if (artifactFormat !== undefined) {
+                const identity = {
+                    path,
+                    sourcePath: canonical,
+                    sha256: await sha256Handle(handle),
+                };
+                return isArchiveFormat(artifactFormat)
+                    ? ok({ ...identity, kind: "archive", format: artifactFormat })
+                    : ok({ ...identity, kind: "artifact", format: artifactFormat });
+            }
+            const detected = await readExecutableMetadata(handle, hostArchitecture);
+            if (!detected.ok)
+                return err(new BinaryTargetError(path, detected.error));
+            return ok({
+                path,
+                sourcePath: canonical,
+                sha256: await sha256Handle(handle),
+                kind: "executable",
+                ...detected.value,
+            });
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    catch (cause) {
+        return err(new BinaryTargetError(candidate, "path is not readable", { cause }));
+    }
+};
+const detectArtifactFormat = async (path, handle) => {
+    const lower = path.toLowerCase();
+    const magic = Buffer.alloc(8);
+    const observed = await handle.read(magic, 0, magic.length, 0);
+    if (hasZipSignature(magic.subarray(0, observed.bytesRead))) {
+        return zipPackageFormatForPath(lower) ?? "zip";
+    }
+    const named = namedArtifactFormat(lower);
+    if (named !== undefined)
+        return named;
+    if (lower.endsWith(".pkg") &&
+        observed.bytesRead >= 4 &&
+        magic.subarray(0, 4).toString("ascii") === "xar!")
+        return "pkg";
+    if (lower.endsWith(".dmg")) {
+        const size = (await handle.stat()).size;
+        if (size >= 512) {
+            const trailer = Buffer.alloc(4);
+            const read = await handle.read(trailer, 0, trailer.length, size - 512);
+            if (read.bytesRead === 4 && trailer.toString("ascii") === "koly")
+                return "dmg";
+        }
+    }
+    return undefined;
+};
+const namedArtifactFormat = (lowerPath) => {
+    if (lowerPath.endsWith(".asar"))
+        return "asar";
+    if (lowerPath.endsWith(".plist"))
+        return "plist";
+    if (lowerPath.endsWith(".map"))
+        return "source-map";
+    return /\.(?:m?js|cjs)$/u.test(lowerPath) ? "javascript" : undefined;
+};
+const isArchiveFormat = (format) => ["zip", "ipa", "apk", "msix", "appx", "asar", "dmg", "pkg"].includes(format);
+const sha256Handle = async (handle) => {
+    const hash = createHash("sha256");
+    const chunk = Buffer.allocUnsafe(64 * 1024);
+    let position = 0;
+    while (true) {
+        const observed = await handle.read(chunk, 0, chunk.length, position);
+        if (observed.bytesRead === 0)
+            break;
+        hash.update(chunk.subarray(0, observed.bytesRead));
+        position += observed.bytesRead;
+    }
+    return hash.digest("hex");
+};
+const resolveAppBundle = async (path) => {
+    const metadata = await stat(path);
+    if (!metadata.isDirectory())
+        return ok(path);
+    if (extname(path).toLowerCase() !== ".app")
+        return err(new BinaryTargetError(path, "target is not an app or file"));
+    const plistPath = join(path, "Contents", "Info.plist");
+    let name;
+    try {
+        const plist = await readFile(plistPath);
+        name =
+            plist.subarray(0, 6).toString("ascii") === "bplist"
+                ? await readBinaryPlistExecutable(plistPath)
+                : parseXmlPlistExecutable(plist.toString("utf8"));
+    }
+    catch (cause) {
+        return err(new BinaryTargetError(path, "app has no readable CFBundleExecutable", {
+            cause,
+        }));
+    }
+    if (!isSafeExecutableName(name))
+        return err(new BinaryTargetError(path, "app has an unsafe CFBundleExecutable"));
+    const programs = join(path, "Contents", "MacOS");
+    const executable = join(programs, name);
+    try {
+        const [canonicalPrograms, canonicalExecutable] = await Promise.all([
+            realpath(programs),
+            realpath(executable),
+        ]);
+        if (!isPathWithinRoot(canonicalPrograms, canonicalExecutable))
+            return err(new BinaryTargetError(path, "app program file leaves Contents/MacOS"));
+        return ok(canonicalExecutable);
+    }
+    catch (cause) {
+        return err(new BinaryTargetError(path, "app program file is missing", { cause }));
+    }
+};
+const parseXmlPlistExecutable = (plist) => {
+    const match = /<key>\s*CFBundleExecutable\s*<\/key>\s*<string>([^<]+)<\/string>/u.exec(plist);
+    if (match?.[1] === undefined)
+        throw new Error("CFBundleExecutable is missing");
+    return decodeXml(match[1].trim());
+};
+const readBinaryPlistExecutable = async (plistPath) => (await execFileAsync("/usr/bin/plutil", [
+    "-extract",
+    "CFBundleExecutable",
+    "raw",
+    "-o",
+    "-",
+    plistPath,
+])).stdout.trim();
+const isSafeExecutableName = (name) => name.length > 0 &&
+    name !== "." &&
+    name !== ".." &&
+    !name.includes("\0") &&
+    !/[/\\]/u.test(name);
+const decodeXml = (value) => value
+    .replaceAll("&amp;", "&")
+    .replaceAll("&lt;", "<")
+    .replaceAll("&gt;", ">")
+    .replaceAll("&quot;", '"')
+    .replaceAll("&apos;", "'");
+const readExecutableMetadata = async (handle, hostArchitecture) => {
+    const prefix = Buffer.alloc(4096);
+    const prefixRead = await handle.read(prefix, 0, prefix.length, 0);
+    const bytes = prefix.subarray(0, prefixRead.bytesRead);
+    if (bytes.length >= 64 && bytes[0] === 0x4d && bytes[1] === 0x5a) {
+        const offset = bytes.readUInt32LE(0x3c);
+        return readPeMetadata(handle, offset);
+    }
+    if (bytes.length >= 8) {
+        const magic = bytes.readUInt32BE(0);
+        if ([0xcafebabf, 0xbfbafeca].includes(magic)) {
+            const little = magic === 0xbfbafeca;
+            const count = little ? bytes.readUInt32LE(4) : bytes.readUInt32BE(4);
+            const required = 8 + count * 32;
+            if (count <= 128 && required > bytes.length) {
+                const header = Buffer.alloc(required);
+                const headerRead = await handle.read(header, 0, header.length, 0);
+                return parseExecutableHeader(header.subarray(0, headerRead.bytesRead), hostArchitecture);
+            }
+        }
+    }
+    return parseExecutableHeader(bytes, hostArchitecture);
+};
+const readPeMetadata = async (handle, offset) => {
+    const fileHeader = Buffer.alloc(24);
+    const fileHeaderRead = await handle.read(fileHeader, 0, fileHeader.length, offset);
+    if (fileHeaderRead.bytesRead !== fileHeader.length)
+        return err("invalid or truncated PE header");
+    const optionalHeaderSize = fileHeader.readUInt16LE(20);
+    if (optionalHeaderSize > 4096)
+        return err("invalid PE optional header size");
+    const record = Buffer.alloc(24 + optionalHeaderSize);
+    const recordRead = await handle.read(record, 0, record.length, offset);
+    return recordRead.bytesRead === record.length
+        ? parsePeRecord(record)
+        : err("invalid or truncated PE header");
+};