reverseport 0.0.0-stage → 1.2.0

package/dist/mcp/BinaryTargetResolver-DbiUzRLh.js

@@ -0,0 +1,1073 @@
+import { t as __esmMin } from "./rolldown-runtime-BjeaiXFo.js";
+import { d as init_analysisErrorCore, f as err, m as ok, p as init_result, r as AnalysisCancelledError } from "./analysisErrorCore-BqyeMw3_.js";
+import { f as BinaryTargetError, h as init_configurationErrors } from "./analysisErrorProjection-B7pHef2y.js";
+import { An as rawBinarySelectionError, En as admitRawBinary, J as hasZipSignature, On as init_rawBinary, X as isZipPackageFormat, Y as init_zipPackageFormat, Z as zipPackageFormatForPath } from "./toolOutputSchemaGroups-ChxVLGoy.js";
+import { n as readBoundedFileBytes, t as init_BoundedFileBytes } from "./BoundedFileBytes-CJPW_TzE.js";
+import { A as init_dosMz, M as parseDosMzHeader, a as preflightPropertyListDecode, i as init_InterfaceBuilderDecodeBudget, j as mzWindowsHeaderOffset, o as decodeXmlPlistText, s as init_propertyListXmlText } from "./InterfaceBuilderDecodeBudget-CUrOtfNo.js";
+import { a as parseXmlPropertyList, c as RegularFileChangedError, d as sameRegularFileState, f as OwnedFileHandle, l as init_RegularFile, n as init_propertyListKeys, p as init_OwnedFileHandle, r as omitPrototypeKeys, s as RegularFileAdmissionFailure, u as openRegularFile } from "./propertyListKeys-cX-BUv2y.js";
+import { c as validateDosComLength, s as init_dosCom } from "./managedToolContracts-o5LHFwHc.js";
+import { n as isPathWithinRoot, t as init_localPath } from "./localPath-AxvW9aPe.js";
+import { constants } from "node:fs";
+import { extname, isAbsolute, join, resolve } from "node:path";
+import { z } from "zod";
+import { access, lstat, opendir, readFile, realpath, stat } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { parseBinary } from "plist";
+
+//#region dist/domain/peMachine.js
+var architectureForMachine, NATIVE_OS_OVERRIDES, decodePeMachine;
+function init_peMachine() {
+	return (init_peMachine = __esmMin((() => {
+		architectureForMachine = (machine) => {
+			switch (machine) {
+				case 332: return "x86";
+				case 34404: return "x86_64";
+				case 448:
+				case 450:
+				case 452: return "arm";
+				case 43620: return "arm64";
+			}
+			return undefined;
+		};
+		NATIVE_OS_OVERRIDES = [
+			17988,
+			44484,
+			44485,
+			31609,
+			6547,
+			6546
+		];
+		decodePeMachine = (machine) => {
+			const direct = architectureForMachine(machine);
+			if (direct !== undefined) return {
+				architecture: direct,
+				nativeOsOverride: false
+			};
+			for (const override of NATIVE_OS_OVERRIDES) {
+				const architecture = architectureForMachine(machine ^ override);
+				if (architecture !== undefined) return {
+					architecture,
+					nativeOsOverride: true
+				};
+			}
+			return undefined;
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/domain/binaryTarget.js
+var parseExecutableHeader, parseThinMachO, parseFatMachO, parseElf, parseMz, parsePeRecord, peManagedStatus, machArchitecture, elfArchitecture;
+function init_binaryTarget() {
+	return (init_binaryTarget = __esmMin((() => {
+		init_result();
+		init_dosMz();
+		init_peMachine();
+		parseExecutableHeader = (bytes, hostArchitecture, fileSize = bytes.length) => {
+			if (bytes.length >= 4 && bytes.subarray(0, 4).equals(Buffer.from([
+				127,
+				69,
+				76,
+				70
+			]))) return parseElf(bytes, fileSize);
+			if (bytes.length >= 2 && bytes[0] === 77 && bytes[1] === 90) return parseMz(bytes, fileSize);
+			if (bytes.length < 8) return err("truncated or unsupported binary header");
+			const magic = bytes.readUInt32BE(0);
+			if ([
+				4277009102,
+				4277009103,
+				3472551422,
+				3489328638
+			].includes(magic)) return parseThinMachO(bytes, magic, fileSize);
+			if ([
+				3405691582,
+				3199925962,
+				3405691583,
+				3216703178
+			].includes(magic)) return parseFatMachO(bytes, magic, hostArchitecture, fileSize);
+			return err("unsupported binary format");
+		};
+		parseThinMachO = (bytes, magic, fileSize) => {
+			const is64 = magic === 4277009103 || magic === 3489328638;
+			const headerSize = is64 ? 32 : 28;
+			if (bytes.length < headerSize) return err(`truncated Mach-O header: a ${is64 ? 64 : 32}-bit header needs ${headerSize} bytes; the file has ${fileSize}`);
+			const little = magic === 3472551422 || magic === 3489328638;
+			const read = (offset) => little ? bytes.readUInt32LE(offset) : bytes.readUInt32BE(offset);
+			const architecture = machArchitecture(read(4));
+			if (architecture === undefined) return err("unsupported Mach-O architecture");
+			const commandBytes = read(20);
+			if (headerSize + commandBytes > fileSize) return err(`truncated Mach-O load commands: the header declares ${commandBytes} bytes after its ${headerSize}-byte header; the file has ${fileSize}`);
+			return ok({
+				format: "mach-o",
+				architecture,
+				availableArchitectures: [architecture]
+			});
+		};
+		parseFatMachO = (bytes, magic, host, fileSize) => {
+			const little = magic === 3199925962 || magic === 3216703178;
+			const is64 = magic === 3405691583 || magic === 3216703178;
+			if (bytes.length < 8) return err("truncated FAT header");
+			const read = (offset) => little ? bytes.readUInt32LE(offset) : bytes.readUInt32BE(offset);
+			const count = read(4);
+			const entrySize = is64 ? 32 : 20;
+			if (count === 0 || count > 128 || bytes.length < 8 + count * entrySize) return err("truncated or invalid FAT architecture table");
+			const architectures = [];
+			const slices = new Map();
+			for (let index = 0; index < count; index += 1) {
+				const entry = 8 + index * entrySize;
+				const architecture = machArchitecture(read(entry));
+				if (architecture === undefined || architectures.includes(architecture)) continue;
+				architectures.push(architecture);
+				const offset = is64 ? little ? bytes.readBigUInt64LE(entry + 8) : bytes.readBigUInt64BE(entry + 8) : BigInt(read(entry + 8));
+				const size = is64 ? little ? bytes.readBigUInt64LE(entry + 16) : bytes.readBigUInt64BE(entry + 16) : BigInt(read(entry + 12));
+				slices.set(architecture, {
+					offset,
+					size
+				});
+			}
+			const preferred = host === "arm64" ? "arm64" : host === "x64" ? "x86_64" : host === "ia32" ? "x86" : host === "arm" ? "arm" : undefined;
+			const slice = preferred === undefined ? undefined : slices.get(preferred);
+			if (preferred === undefined || slice === undefined) return err(`FAT binary has no host-compatible ${host} architecture`);
+			const tableEnd = BigInt(8 + count * entrySize);
+			if (slice.offset < tableEnd) return err(`FAT slice for ${preferred} overlaps the architecture table`);
+			const minimumHeaderSize = preferred === "arm64" || preferred === "x86_64" ? 32n : 28n;
+			if (slice.size < minimumHeaderSize) return err(`FAT slice for ${preferred} is shorter than its Mach-O header`);
+			const sliceEnd = slice.offset + slice.size;
+			if (sliceEnd > BigInt(fileSize)) return err(`truncated FAT slice: the ${preferred} slice ends at byte ${sliceEnd}; the file has ${fileSize}`);
+			return ok({
+				format: "mach-o-universal",
+				architecture: preferred,
+				availableArchitectures: architectures
+			});
+		};
+		parseElf = (bytes, fileSize) => {
+			if (bytes.length < 6) return err("truncated ELF header");
+			if (bytes[4] !== 1 && bytes[4] !== 2) return err("unsupported ELF class");
+			const little = bytes[5] === 1;
+			if (!little && bytes[5] !== 2) return err("unsupported ELF endianness");
+			const headerSize = bytes[4] === 1 ? 52 : 64;
+			if (bytes.length < headerSize) return err(`truncated ELF header: an ELF${bytes[4] === 1 ? 32 : 64} header needs ${headerSize} bytes; the file has ${fileSize}`);
+			const machine = little ? bytes.readUInt16LE(18) : bytes.readUInt16BE(18);
+			const architecture = elfArchitecture(machine);
+			if (architecture === undefined) return err("unsupported ELF architecture");
+			if (architecture === "mips") return ok({
+				format: "elf",
+				architecture,
+				availableArchitectures: [architecture],
+				mips: {
+					elfClass: bytes[4] === 1 ? 32 : 64,
+					byteOrder: little ? "little" : "big",
+					type: little ? bytes.readUInt16LE(16) : bytes.readUInt16BE(16),
+					flags: little ? bytes.readUInt32LE(bytes[4] === 1 ? 36 : 48) : bytes.readUInt32BE(bytes[4] === 1 ? 36 : 48)
+				}
+			});
+			return ok({
+				format: "elf",
+				architecture,
+				availableArchitectures: [architecture]
+			});
+		};
+		parseMz = (bytes, fileSize) => {
+			const offset = mzWindowsHeaderOffset(bytes);
+			if (offset !== null) {
+				if (offset < 64 || offset > bytes.length - 24) return err("invalid or truncated Windows executable header in MZ image");
+				const signature = bytes.toString("ascii", offset, offset + 2);
+				if ([
+					"NE",
+					"LE",
+					"LX"
+				].includes(signature)) return err(`unsupported ${signature} executable in MZ image`);
+				return parsePeRecord(bytes.subarray(offset));
+			}
+			const parsed = parseDosMzHeader(bytes, fileSize);
+			return parsed.ok ? ok({
+				format: "dos-mz",
+				architecture: "x86",
+				availableArchitectures: ["x86"]
+			}) : parsed;
+		};
+		parsePeRecord = (record) => {
+			if (record.length < 24 || record.toString("binary", 0, 4) !== "PE\0\0") return err("invalid or truncated PE header");
+			const machine = decodePeMachine(record.readUInt16LE(4));
+			if (machine === undefined) return err("unsupported PE architecture");
+			const { architecture } = machine;
+			const optionalHeaderSize = record.readUInt16LE(20);
+			if (optionalHeaderSize > 4096 || record.length < 24 + optionalHeaderSize) return err("invalid or truncated PE optional header");
+			const optionalHeader = record.subarray(24, 24 + optionalHeaderSize);
+			const managed = peManagedStatus(optionalHeader, architecture);
+			if (!managed.ok) return managed;
+			if (machine.nativeOsOverride && !managed.value) return err("unsupported PE architecture");
+			const characteristics = record.readUInt16LE(22);
+			return ok({
+				format: "pe",
+				architecture,
+				availableArchitectures: [architecture],
+				executableRole: (characteristics & 2) === 0 ? "non-executable" : (characteristics & 8192) === 0 ? "application" : "shared-library",
+				managed: managed.value
+			});
+		};
+		peManagedStatus = (optionalHeader, architecture) => {
+			if (optionalHeader.length < 2) return err("truncated PE optional header");
+			const magic = optionalHeader.readUInt16LE(0);
+			const expectedMagic = architecture === "x86_64" || architecture === "arm64" ? 523 : 267;
+			if (magic !== expectedMagic) return err("PE optional-header magic does not match its architecture");
+			const directoryOffset = magic === 523 ? 112 : 96;
+			const directoryCountOffset = directoryOffset - 4;
+			if (optionalHeader.length < directoryCountOffset + 4) return err("truncated PE optional header");
+			const directoryCount = optionalHeader.readUInt32LE(directoryCountOffset);
+			const requiredBytes = directoryOffset + directoryCount * 8;
+			if (!Number.isSafeInteger(requiredBytes) || requiredBytes > optionalHeader.length) return err("truncated PE data-directory table");
+			if (directoryCount <= 14) return ok(false);
+			const cliDirectory = directoryOffset + 14 * 8;
+			return ok(optionalHeader.readUInt32LE(cliDirectory) !== 0 || optionalHeader.readUInt32LE(cliDirectory + 4) !== 0);
+		};
+		machArchitecture = (cpu) => {
+			switch (cpu) {
+				case 7: return "x86";
+				case 16777223: return "x86_64";
+				case 12: return "arm";
+				case 16777228: return "arm64";
+			}
+			return undefined;
+		};
+		elfArchitecture = (machine) => {
+			switch (machine) {
+				case 3: return "x86";
+				case 62: return "x86_64";
+				case 8: return "mips";
+				case 40: return "arm";
+				case 183: return "arm64";
+			}
+			return undefined;
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/application/RegularFileRead.js
+var RegularFileCleanupFailure, retryRegularFileCleanup, failureMessage, withRegularFile, withRegularFileOwned, readRegularFile, readRegularFileText;
+function init_RegularFileRead() {
+	return (init_RegularFileRead = __esmMin((() => {
+		init_RegularFile();
+		init_OwnedFileHandle();
+		init_BoundedFileBytes();
+		RegularFileCleanupFailure = class extends Error {
+			path;
+			owner;
+			outcome;
+			cleanupCause;
+			constructor(path, owner, outcome, cleanupCause) {
+				super(`Regular file cleanup failed: ${path}`, { cause: outcome.kind === "failed" ? outcome.cause : cleanupCause });
+				this.path = path;
+				this.owner = owner;
+				this.outcome = outcome;
+				this.cleanupCause = cleanupCause;
+				this.name = "RegularFileCleanupFailure";
+			}
+		};
+		retryRegularFileCleanup = async (failure, resources) => {
+			const released = await resources.release({
+				kind: "file-handle",
+				handle: failure.owner,
+				resource: failure.path
+			});
+			if (released.kind === "released") return { outcome: failure.outcome };
+			return {
+				outcome: failure.outcome,
+				cleanup: {
+					reason: `${failureMessage(failure.cleanupCause)}; retry: ${failureMessage(released.cause)}`,
+					resources: [failure.path]
+				}
+			};
+		};
+		failureMessage = (cause) => cause instanceof Error ? cause.message : String(cause);
+		withRegularFile = async (path, read, options = {}) => options.resources === undefined ? withRegularFileOwned(path, read, options) : options.resources.run(() => withRegularFileOwned(path, read, options));
+		withRegularFileOwned = async (path, read, options) => {
+			const { signal } = options;
+			let handle;
+			try {
+				handle = await openRegularFile(path, {
+					symlinks: options.symlinks ?? "follow",
+					signal
+				});
+			} catch (cause) {
+				if (!(cause instanceof RegularFileAdmissionFailure)) throw cause;
+				const failure = new RegularFileCleanupFailure(path, cause.owner, {
+					kind: "failed",
+					cause: cause.cause
+				}, cause.cleanupCause);
+				if (options.resources === undefined) throw failure;
+				const retry = await retryRegularFileCleanup(failure, options.resources);
+				if (retry.cleanup !== undefined) throw failure;
+				throw cause.cause;
+			}
+			const owner = new OwnedFileHandle(handle);
+			let outcome;
+			try {
+				const stats = await handle.stat();
+				signal?.throwIfAborted();
+				const value = await read(handle, stats);
+				signal?.throwIfAborted();
+				const [opened, currentPath] = await Promise.all([handle.stat(), options.symlinks === "reject" ? lstat(path) : stat(path)]);
+				if (!sameRegularFileState(stats, opened) || !sameRegularFileState(stats, currentPath)) throw new RegularFileChangedError(path);
+				outcome = {
+					kind: "completed",
+					value
+				};
+			} catch (cause) {
+				outcome = {
+					kind: "failed",
+					cause
+				};
+			}
+			try {
+				await owner.close();
+			} catch (cleanupCause) {
+				const failure = new RegularFileCleanupFailure(path, owner, outcome, cleanupCause);
+				if (options.resources === undefined) throw failure;
+				const retry = await retryRegularFileCleanup(failure, options.resources);
+				if (retry.cleanup !== undefined) throw failure;
+				if (retry.outcome.kind === "failed") throw retry.outcome.cause;
+				return retry.outcome.value;
+			}
+			if (outcome.kind === "failed") throw outcome.cause;
+			return outcome.value;
+		};
+		readRegularFile = (path, options = {}) => withRegularFile(path, async (handle, stats) => {
+			const bytes = await readBoundedFileBytes(handle, stats.size, options.signal);
+			if (bytes === undefined || bytes.length !== stats.size) throw new RegularFileChangedError(path);
+			return bytes;
+		}, options);
+		readRegularFileText = async (path, options = {}) => {
+			try {
+				return (await readRegularFile(path, options)).toString("utf8");
+			} catch (cause) {
+				if (cause instanceof RegularFileCleanupFailure && cause.outcome.kind === "completed" && Buffer.isBuffer(cause.outcome.value)) throw new RegularFileCleanupFailure(cause.path, cause.owner, {
+					kind: "completed",
+					value: cause.outcome.value.toString("utf8")
+				}, cause.cleanupCause);
+				throw cause;
+			}
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/application/MipsElfSharedLoad.js
+var readMipsElfSharedLoad;
+function init_MipsElfSharedLoad() {
+	return (init_MipsElfSharedLoad = __esmMin((() => {
+		init_result();
+		readMipsElfSharedLoad = async (programHeaders, little, fileSize, read, checkCancelled, sections) => {
+			const u32 = (bytes, offset) => little ? bytes.readUInt32LE(offset) : bytes.readUInt32BE(offset);
+			const loads = [];
+			let dynamic;
+			for (let position = 0; position < programHeaders.length; position += 32) {
+				checkCancelled();
+				const type = u32(programHeaders, position);
+				const offset = u32(programHeaders, position + 4);
+				const size = u32(programHeaders, position + 16);
+				if (type === 1) {
+					const address = u32(programHeaders, position + 8);
+					const memorySize = u32(programHeaders, position + 20);
+					if (offset > fileSize - size || size > memorySize || address + memorySize > 4294967296) return err("invalid or incomplete MIPS PT_LOAD range");
+					loads.push({
+						offset,
+						address,
+						size,
+						memorySize
+					});
+				}
+				if (type === 2) {
+					if (dynamic !== undefined) return err("duplicate MIPS PT_DYNAMIC tables");
+					dynamic = {
+						offset,
+						address: u32(programHeaders, position + 8),
+						size
+					};
+				}
+			}
+			if (dynamic === undefined) return err("MIPS shared image has no PT_DYNAMIC table");
+			if (dynamic.size === 0 || dynamic.size % 8 !== 0) return err("invalid MIPS ELF32 dynamic table size");
+			if (dynamic.offset > fileSize - dynamic.size) return err("MIPS PT_DYNAMIC range extends beyond the file");
+			const ranges = loads.filter((load) => load.memorySize > 0).sort((left, right) => left.address - right.address);
+			for (let i = 1; i < ranges.length; i += 1) {
+				checkCancelled();
+				const previous = ranges[i - 1];
+				if (ranges[i].address < previous.address + previous.memorySize) return err("overlapping MIPS PT_LOAD memory ranges require separate mapping verification");
+			}
+			const mapped = (address, length, fileBacked) => {
+				let low = 0;
+				let high = ranges.length;
+				while (low < high) {
+					const middle = Math.floor((low + high) / 2);
+					if (ranges[middle].address <= address) low = middle + 1;
+					else high = middle;
+				}
+				const range = ranges[low - 1];
+				return range !== undefined && address - range.address <= (fileBacked ? range.size : range.memorySize) - length ? range : undefined;
+			};
+			const dynamicMapping = mapped(dynamic.address, dynamic.size, true);
+			if (dynamicMapping === undefined || dynamicMapping.offset + dynamic.address - dynamicMapping.address !== dynamic.offset) return err("MIPS PT_DYNAMIC has no unique matching file-backed PT_LOAD range");
+			const chunkBytes = 64 * 1024;
+			const relevant = new Set([
+				2,
+				7,
+				8,
+				9,
+				17,
+				18,
+				19,
+				20,
+				23
+			]);
+			const tags = new Map();
+			let terminated = false;
+			for (let offset = 0; offset < dynamic.size && !terminated; offset += chunkBytes) {
+				const chunk = await read(dynamic.offset + offset, Math.min(chunkBytes, dynamic.size - offset), "dynamic table");
+				if (!chunk.ok) return chunk;
+				for (let position = 0; position < chunk.value.length; position += 8) {
+					checkCancelled();
+					const tag = u32(chunk.value, position);
+					if (tag === 0) {
+						terminated = true;
+						break;
+					}
+					if (!relevant.has(tag)) continue;
+					if (tags.has(tag)) return err(`duplicate MIPS dynamic tag ${tag}`);
+					tags.set(tag, u32(chunk.value, position + 4));
+				}
+			}
+			if (!terminated) return err("MIPS dynamic table has no DT_NULL terminator");
+			if ([
+				2,
+				7,
+				8,
+				9,
+				23
+			].some((tag) => (tags.get(tag) ?? 0) !== 0)) return err("MIPS shared RELA or PLT relocation declarations require separate verification");
+			const address = tags.get(17);
+			const size = tags.get(18);
+			const stride = tags.get(19);
+			const checkSections = (offset, length) => {
+				let observed = 0;
+				for (const section of sections) {
+					checkCancelled();
+					if (section.size === 0) continue;
+					if (section.type !== 9 || section.entrySize !== 8 || section.offset !== offset || section.size !== length) return "MIPS section relocation declarations outside the dynamic REL table require separate verification";
+					observed += 1;
+				}
+				return observed > 1 ? "duplicate MIPS section relocation declarations require separate verification" : undefined;
+			};
+			const emptyRelocations = () => {
+				const reason = checkSections(0, 0);
+				return reason === undefined ? ok({
+					status: "complete",
+					relocationCount: 0,
+					relocationTypes: [],
+					symbolRelativeCount: 0
+				}) : err(reason);
+			};
+			if (address === undefined && size === undefined && stride === undefined) return emptyRelocations();
+			if (address === undefined || size === undefined || stride !== 8 || size % 8 !== 0) return err("incomplete or invalid MIPS DT_REL/DT_RELSZ/DT_RELENT declaration");
+			if (size === 0) return emptyRelocations();
+			const mapping = mapped(address, size, true);
+			if (mapping === undefined) return err("MIPS DT_REL range has no unique complete file-backed PT_LOAD mapping");
+			const fileOffset = mapping.offset + address - mapping.address;
+			const sectionReason = checkSections(fileOffset, size);
+			if (sectionReason !== undefined) return err(sectionReason);
+			let symbolRelativeCount = 0;
+			const types = new Set();
+			for (let offset = 0; offset < size; offset += chunkBytes) {
+				const chunk = await read(fileOffset + offset, Math.min(chunkBytes, size - offset), "dynamic REL records");
+				if (!chunk.ok) return chunk;
+				for (let position = 0; position < chunk.value.length; position += 8) {
+					checkCancelled();
+					const info = u32(chunk.value, position + 4);
+					const type = info & 255;
+					const relocationAddress = u32(chunk.value, position);
+					if (type === 3 && mapped(relocationAddress, 4, false) === undefined) return err("MIPS REL32 destination has no unique complete PT_LOAD memory range");
+					types.add(type);
+					if (type === 3 && info >>> 8 !== 0) symbolRelativeCount += 1;
+				}
+			}
+			return ok({
+				status: "complete",
+				relocationCount: size / 8,
+				relocationTypes: [...types].sort((left, right) => left - right),
+				symbolRelativeCount
+			});
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/application/MipsElfMetadata.js
+var readMipsElfMetadata;
+function init_MipsElfMetadata() {
+	return (init_MipsElfMetadata = __esmMin((() => {
+		init_result();
+		init_MipsElfSharedLoad();
+		readMipsElfMetadata = async (handle, metadata, checkCancelled) => {
+			checkCancelled();
+			if (metadata.elfClass !== 32) return err("MIPS ABI record inspection currently supports ELF32 only");
+			const fileSize = (await handle.stat()).size;
+			checkCancelled();
+			const read = async (offset, length, label) => {
+				checkCancelled();
+				if (!Number.isSafeInteger(fileSize) || offset < 0 || length < 0 || offset > fileSize - length) return err(`MIPS ${label} lies outside the file`);
+				const bytes = Buffer.alloc(length);
+				let total = 0;
+				while (total < length) {
+					checkCancelled();
+					const observed = await handle.read(bytes, total, length - total, offset + total);
+					checkCancelled();
+					if (observed.bytesRead === 0) return err(`truncated MIPS ${label}`);
+					total += observed.bytesRead;
+				}
+				return ok(bytes);
+			};
+			const header = await read(0, 52, "ELF32 header");
+			if (!header.ok) return header;
+			const bytes = header.value;
+			const little = metadata.byteOrder === "little";
+			const u16 = (data, offset) => little ? data.readUInt16LE(offset) : data.readUInt16BE(offset);
+			const u32 = (data, offset) => little ? data.readUInt32LE(offset) : data.readUInt32BE(offset);
+			if (bytes.toString("hex", 0, 4) !== "7f454c46" || bytes[4] !== 1 || bytes[5] !== (little ? 1 : 2) || u16(bytes, 18) !== 8 || u16(bytes, 16) !== metadata.type || u32(bytes, 36) !== metadata.flags) return err("MIPS ELF header no longer matches the resolved identity");
+			if (bytes[6] !== 1 || u32(bytes, 20) !== 1 || u16(bytes, 40) !== 52) return err("invalid MIPS ELF32 version or header size");
+			const tables = [{
+				label: "program header table",
+				offset: u32(bytes, 28),
+				count: u16(bytes, 44),
+				stride: u16(bytes, 42),
+				entrySize: 32,
+				typeOffset: 0,
+				dataOffset: 4,
+				sizeOffset: 16,
+				recordType: 1879048195,
+				optional: false
+			}, {
+				label: "section header table",
+				offset: u32(bytes, 32),
+				count: u16(bytes, 48),
+				stride: u16(bytes, 46),
+				entrySize: 40,
+				typeOffset: 4,
+				dataOffset: 16,
+				sizeOffset: 20,
+				recordType: 1879048234,
+				optional: true
+			}];
+			if (u16(bytes, 44) === 65535 || u16(bytes, 48) >= 65280) return err("extended or reserved MIPS ELF table numbering is unsupported");
+			let record;
+			let sharedLoad;
+			let programHeaders;
+			const relocationSections = [];
+			const limitations = [];
+			for (const table of tables) {
+				if (table.count === 0) {
+					if (table.offset !== 0) return err(`unsupported extended or inconsistent MIPS ${table.label}`);
+					continue;
+				}
+				if (table.offset < 52 || table.stride !== table.entrySize) return err(`invalid MIPS ${table.label} offset or entry size`);
+				const count = table.optional ? Math.min(table.count, Math.max(0, Math.floor((fileSize - table.offset) / table.entrySize))) : table.count;
+				if (count < table.count) limitations.push(`MIPS ${table.label} at file offset ${table.offset} extends beyond the captured file: examined ${count} of ${table.count} complete headers. ABI declarations in unavailable headers remain unknown.`);
+				if (count === 0) continue;
+				const contents = await read(table.offset, count * table.entrySize, table.label);
+				if (!contents.ok) return contents;
+				if (!table.optional && metadata.type === 3) programHeaders = contents.value;
+				let found = false;
+				for (let i = 0; i < count; i += 1) {
+					checkCancelled();
+					const position = i * table.entrySize;
+					const type = u32(contents.value, position + table.typeOffset);
+					if (metadata.type === 3 && table.optional && (type === 4 || type === 9)) relocationSections.push({
+						type,
+						offset: u32(contents.value, position + 16),
+						size: u32(contents.value, position + 20),
+						entrySize: u32(contents.value, position + 36)
+					});
+					if (type !== table.recordType) continue;
+					if (found) return err(`duplicate MIPS ABI records in ${table.label}`);
+					found = true;
+					const offset = u32(contents.value, position + table.dataOffset);
+					const size = u32(contents.value, position + table.sizeOffset);
+					if (size !== 24) return err("unsupported MIPS ABI record size; expected 24 bytes");
+					const candidate = await read(offset, 24, "ABI record");
+					if (!candidate.ok) return candidate;
+					if (record !== undefined && !record.equals(candidate.value)) return err("conflicting MIPS program/section ABI declarations");
+					record = candidate.value;
+				}
+			}
+			if (metadata.type === 3 && programHeaders !== undefined) {
+				if (limitations.length > 0) sharedLoad = {
+					status: "unavailable",
+					reason: `MIPS shared-image relocation declaration sources are incomplete. ${limitations.join(" ")}`
+				};
+				else {
+					const shared = await readMipsElfSharedLoad(programHeaders, little, fileSize, read, checkCancelled, relocationSections);
+					sharedLoad = shared.ok ? shared.value : {
+						status: "unavailable",
+						reason: shared.error
+					};
+				}
+			}
+			const shared = metadata.type === 3 ? { sharedLoad: sharedLoad ?? {
+				status: "unavailable",
+				reason: "MIPS shared image has no inspected program header table"
+			} } : {};
+			if (record === undefined) return ok({
+				abiFlags: null,
+				limitations,
+				...shared
+			});
+			const abiFlags = {
+				version: u16(record, 0),
+				isaLevel: record.readUInt8(2),
+				isaRevision: record.readUInt8(3),
+				gprSize: record.readUInt8(4),
+				cpr1Size: record.readUInt8(5),
+				cpr2Size: record.readUInt8(6),
+				fpAbi: record.readUInt8(7),
+				isaExtension: u32(record, 8),
+				ases: u32(record, 12),
+				flags1: u32(record, 16),
+				flags2: u32(record, 20)
+			};
+			return ok({
+				abiFlags,
+				limitations,
+				...shared
+			});
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/application/AppBundleExecutable.js
+var BINARY_PLIST_DECODE_BYTES, BUNDLE_LAYOUTS, defaultFileSystem, resolveAppBundleExecutable, presentLayout, layoutPlistPresent, isAbsence, errorCode, codeDescription, isSystemErrorCode, isPermissionDenied, errorReason, wrappedBundle, resolveLayoutExecutable, parseXmlPlistExecutable, executableName, executableEntrySchema, parseBinaryPlistExecutable, isSafeExecutableName;
+function init_AppBundleExecutable() {
+	return (init_AppBundleExecutable = __esmMin((() => {
+		init_InterfaceBuilderDecodeBudget();
+		init_configurationErrors();
+		init_localPath();
+		init_propertyListKeys();
+		init_propertyListXmlText();
+		init_result();
+		BINARY_PLIST_DECODE_BYTES = 16 * 1024 * 1024;
+		BUNDLE_LAYOUTS = [{
+			plist: ["Contents", "Info.plist"],
+			programs: ["Contents", "MacOS"],
+			programsLabel: "Contents/MacOS"
+		}, {
+			plist: ["Info.plist"],
+			programs: [],
+			programsLabel: "the bundle root"
+		}];
+		defaultFileSystem = {
+			readFile,
+			realpath
+		};
+		resolveAppBundleExecutable = async (path, fileSystem = defaultFileSystem) => {
+			try {
+				const layout = await presentLayout(path);
+				if (layout !== undefined) return resolveLayoutExecutable(path, layout, fileSystem);
+				const wrapped = await wrappedBundle(path);
+				if (wrapped !== undefined) {
+					const wrappedLayout = await presentLayout(wrapped);
+					if (wrappedLayout !== undefined) return resolveLayoutExecutable(wrapped, wrappedLayout, fileSystem);
+				}
+			} catch (cause) {
+				if (cause instanceof BinaryTargetError) return err(cause);
+				return err(new BinaryTargetError(path, errorReason(cause, path), { cause }));
+			}
+			return err(new BinaryTargetError(path, `app Info.plist is missing or no supported bundle layout was found: ${path}`, { cause: new Error("No Contents/Info.plist, root Info.plist, or single Wrapper/*.app bundle was found") }));
+		};
+		presentLayout = async (bundle) => {
+			for (const layout of BUNDLE_LAYOUTS) if (await layoutPlistPresent(join(bundle, ...layout.plist))) return layout;
+			return undefined;
+		};
+		layoutPlistPresent = async (path) => {
+			try {
+				return (await stat(path)).isFile();
+			} catch (cause) {
+				if (isAbsence(cause)) return false;
+				if (isPermissionDenied(cause)) throw new BinaryTargetError(path, `permission denied inspecting app Info.plist ${path}`, { cause });
+				throw cause;
+			}
+		};
+		isAbsence = (cause) => {
+			const code = errorCode(cause);
+			return code === "ENOENT" || code === "ENOTDIR";
+		};
+		errorCode = (cause) => cause instanceof Error ? Reflect.get(cause, "code") : undefined;
+		codeDescription = (cause) => {
+			const code = errorCode(cause);
+			return typeof code === "string" || typeof code === "number" ? ` (${String(code)})` : "";
+		};
+		isSystemErrorCode = (cause) => {
+			const code = errorCode(cause);
+			return typeof code === "string" && /^[A-Z][A-Z0-9_]+$/u.test(code) && !code.startsWith("ERR_");
+		};
+		isPermissionDenied = (cause) => errorCode(cause) === "EACCES" || errorCode(cause) === "EPERM";
+		errorReason = (cause, path) => isPermissionDenied(cause) ? `permission denied accessing app bundle path ${path}` : isAbsence(cause) ? `app bundle path is missing: ${path}` : `could not inspect app bundle path ${path}`;
+		wrappedBundle = async (bundle) => {
+			const wrapper = join(bundle, "Wrapper");
+			try {
+				if (!(await lstat(wrapper)).isDirectory()) return undefined;
+			} catch (cause) {
+				if (isAbsence(cause)) return undefined;
+				throw cause;
+			}
+			let app;
+			for await (const entry of await opendir(wrapper)) {
+				if (!entry.isDirectory() || !entry.name.toLowerCase().endsWith(".app")) continue;
+				if (app !== undefined) return undefined;
+				app = join(wrapper, entry.name);
+			}
+			return app;
+		};
+		resolveLayoutExecutable = async (bundle, layout, fileSystem) => {
+			const plistPath = join(bundle, ...layout.plist);
+			let plist;
+			try {
+				plist = await fileSystem.readFile(plistPath);
+			} catch (cause) {
+				return err(new BinaryTargetError(plistPath, isPermissionDenied(cause) ? `permission denied reading app Info.plist ${plistPath}` : isAbsence(cause) ? `app Info.plist is missing: ${plistPath}` : `could not read app Info.plist ${plistPath}${codeDescription(cause)}`, { cause }));
+			}
+			let name;
+			try {
+				name = plist.subarray(0, 6).toString("ascii") === "bplist" ? await (fileSystem.decodeBinaryPlist?.(plistPath) ?? parseBinaryPlistExecutable(plist)) : parseXmlPlistExecutable(decodeXmlPlistText(plist));
+			} catch (cause) {
+				return err(new BinaryTargetError(plistPath, isPermissionDenied(cause) ? `permission denied decoding app Info.plist ${plistPath}${codeDescription(cause)}` : isSystemErrorCode(cause) ? `could not decode app Info.plist ${plistPath}${codeDescription(cause)}` : `app Info.plist is malformed, unsupported, or lacks CFBundleExecutable: ${plistPath}${cause instanceof Error ? ` (${cause.message})` : ""}`, { cause }));
+			}
+			if (!isSafeExecutableName(name)) return err(new BinaryTargetError(bundle, "app has an unsafe CFBundleExecutable"));
+			const programs = join(bundle, ...layout.programs);
+			const executable = join(programs, name);
+			try {
+				const [canonicalPrograms, canonicalExecutable] = await Promise.all([fileSystem.realpath(programs), fileSystem.realpath(executable)]);
+				if (!isPathWithinRoot(canonicalPrograms, canonicalExecutable)) return err(new BinaryTargetError(bundle, `app program file leaves ${layout.programsLabel}`));
+				return ok({
+					executable: canonicalExecutable,
+					infoPlist: plistPath
+				});
+			} catch (cause) {
+				return err(new BinaryTargetError(executable, isPermissionDenied(cause) ? `permission denied resolving app program file ${executable}` : isAbsence(cause) ? `app program file is missing: ${executable}` : `could not resolve app program file ${executable}`, { cause }));
+			}
+		};
+		parseXmlPlistExecutable = (plist) => {
+			const { value } = parseXmlPropertyList(plist);
+			return executableName(value);
+		};
+		executableName = (value) => {
+			const executable = executableEntrySchema.safeParse(value);
+			if (!executable.success) throw new Error("CFBundleExecutable is missing");
+			return executable.data.CFBundleExecutable;
+		};
+		executableEntrySchema = z.looseObject({ CFBundleExecutable: z.string() });
+		parseBinaryPlistExecutable = (plist) => {
+			preflightPropertyListDecode(plist, BINARY_PLIST_DECODE_BYTES);
+			return executableName(omitPrototypeKeys(parseBinary(plist)).value);
+		};
+		isSafeExecutableName = (name) => name.length > 0 && name !== "." && name !== ".." && !name.includes("\0") && !/[/\\]/u.test(name);
+	})))();
+}
+
+//#endregion
+//#region dist/application/BinaryTargetResolver.js
+var parseBinaryTarget, classifyBinaryTargetFilesystemFailure, filesystemErrorCode, targetFailureReason, throwIfTargetResolutionCancelled, detectArtifactFormat, namedArtifactFormat, isArchiveFormat, sha256Handle, resolveAppBundle, readExecutableMetadata, readPeMetadata;
+function init_BinaryTargetResolver() {
+	return (init_BinaryTargetResolver = __esmMin((() => {
+		init_configurationErrors();
+		init_RegularFile();
+		init_analysisErrorCore();
+		init_result();
+		init_MipsElfMetadata();
+		init_AppBundleExecutable();
+		init_dosCom();
+		init_rawBinary();
+		init_dosMz();
+		init_zipPackageFormat();
+		init_binaryTarget();
+		parseBinaryTarget = async (input, options = {}) => {
+			const cwd = options.cwd ?? process.cwd();
+			const hostArchitecture = options.hostArchitecture ?? process.arch;
+			const { targetKind, formatHint, signal, architecture, entryPoint } = options;
+			const candidate = isAbsolute(input) ? input : resolve(cwd, input);
+			try {
+				throwIfTargetResolutionCancelled(signal);
+				await access(candidate, constants.R_OK);
+				throwIfTargetResolutionCancelled(signal);
+				const canonical = await realpath(candidate);
+				throwIfTargetResolutionCancelled(signal);
+				const resolved = await resolveAppBundle(canonical);
+				throwIfTargetResolutionCancelled(signal);
+				if (!resolved.ok) return err(resolved.error);
+				const { executable: path, infoPlist } = resolved.value;
+				const bundle = infoPlist === undefined ? {} : { bundleInfoPlist: infoPlist };
+				const handle = await openRegularFile(path, {
+					symlinks: "reject",
+					signal
+				});
+				try {
+					throwIfTargetResolutionCancelled(signal);
+					const metadata = await handle.stat();
+					throwIfTargetResolutionCancelled(signal);
+					if (formatHint === "raw-binary") {
+						if (targetKind !== undefined && targetKind !== "executable") return err(new BinaryTargetError(path, "raw-binary format requires an executable target kind", { constraint: "load_selection_rejected" }));
+						const admitted = admitRawBinary({
+							architecture,
+							entryPoint,
+							fileBytes: metadata.size
+						});
+						if (!admitted.ok) return err(new BinaryTargetError(path, admitted.error.reason, { constraint: admitted.error.constraint }));
+						return ok({
+							path,
+							sourcePath: canonical,
+							sha256: await sha256Handle(handle, path, metadata, signal),
+							kind: "executable",
+							format: "raw-binary",
+							architecture: admitted.value.architecture,
+							availableArchitectures: [admitted.value.architecture],
+							entryPoint: admitted.value.entryPoint,
+							entryPointSource: admitted.value.entryPointSource
+						});
+					}
+					const pairing = rawBinarySelectionError({
+						...formatHint === undefined ? {} : { format: formatHint },
+						architecture,
+						entryPoint
+					});
+					if (pairing !== undefined) return err(new BinaryTargetError(path, pairing, { constraint: "load_selection_rejected" }));
+					if (formatHint === "dos-com") {
+						if (targetKind !== undefined && targetKind !== "executable") return err(new BinaryTargetError(path, "DOS COM format requires an executable target kind", { constraint: "load_selection_rejected" }));
+						const length = validateDosComLength(metadata.size);
+						if (!length.ok) return err(new BinaryTargetError(path, length.error, { constraint: "file_format_rejected" }));
+						return ok({
+							path,
+							sourcePath: canonical,
+							sha256: await sha256Handle(handle, path, metadata, signal),
+							kind: "executable",
+							format: "dos-com",
+							architecture: "x86",
+							availableArchitectures: ["x86"]
+						});
+					}
+					if (targetKind === "database" || targetKind === undefined && path.toLowerCase().endsWith(".hop")) return ok({
+						path,
+						sourcePath: process.platform === "win32" ? candidate : canonical,
+						sha256: await sha256Handle(handle, path, metadata, signal),
+						kind: "database",
+						format: "analysis-database"
+					});
+					const artifactFormat = await detectArtifactFormat(path, handle, signal);
+					if (artifactFormat !== undefined) {
+						const identity = {
+							path,
+							sourcePath: process.platform === "win32" ? candidate : canonical,
+							sha256: await sha256Handle(handle, path, metadata, signal)
+						};
+						return isArchiveFormat(artifactFormat) ? ok({
+							...identity,
+							kind: "archive",
+							format: artifactFormat
+						}) : ok({
+							...identity,
+							kind: "artifact",
+							format: artifactFormat
+						});
+					}
+					const detected = await readExecutableMetadata(handle, hostArchitecture, signal);
+					if (!detected.ok) return err(new BinaryTargetError(path, detected.error, { constraint: "file_format_rejected" }));
+					return ok({
+						path,
+						sourcePath: process.platform === "win32" ? candidate : canonical,
+						...bundle,
+						sha256: await sha256Handle(handle, path, metadata, signal),
+						kind: "executable",
+						...detected.value
+					});
+				} finally {
+					await handle.close();
+				}
+			} catch (cause) {
+				if (cause instanceof AnalysisCancelledError) return err(cause);
+				if (cause instanceof BinaryTargetError) return err(cause);
+				if (!(cause instanceof Error)) throw cause;
+				const failure = classifyBinaryTargetFilesystemFailure(candidate, cause);
+				if (failure === undefined) throw cause;
+				return err(failure);
+			}
+		};
+		classifyBinaryTargetFilesystemFailure = (path, cause) => {
+			if (!(cause instanceof Error)) return undefined;
+			const code = filesystemErrorCode(cause);
+			return code === undefined ? undefined : new BinaryTargetError(path, targetFailureReason(code, cause.message), { cause });
+		};
+		filesystemErrorCode = (cause) => {
+			const code = Reflect.get(cause, "code");
+			return typeof code === "string" ? code : undefined;
+		};
+		targetFailureReason = (code, detail) => {
+			switch (code) {
+				case "ENOENT":
+				case "ENOTDIR": return `target does not exist or a path component is not a directory: ${detail}`;
+				case "EACCES":
+				case "EPERM": return `permission denied while reading target: ${detail}`;
+				case "EISDIR": return `target is a directory, not a readable file: ${detail}`;
+				case "ENOTFILE": return "target is not a regular file";
+				case "ELOOP": return `target changed while being opened: ${detail}`;
+				default: return `target could not be read (${code}): ${detail}`;
+			}
+		};
+		throwIfTargetResolutionCancelled = (signal) => {
+			if (signal?.aborted === true) throw new AnalysisCancelledError("resolve_binary_target");
+		};
+		detectArtifactFormat = async (path, handle, signal) => {
+			throwIfTargetResolutionCancelled(signal);
+			const lower = path.toLowerCase();
+			const magic = Buffer.alloc(8);
+			const observed = await handle.read(magic, 0, magic.length, 0);
+			throwIfTargetResolutionCancelled(signal);
+			if (observed.bytesRead === 8 && magic.equals(Buffer.from([
+				0,
+				97,
+				115,
+				109,
+				1,
+				0,
+				0,
+				0
+			]))) throw new BinaryTargetError(path, "WebAssembly v1 artifacts are not supported by the native opening route", { constraint: "wasm_requires_static_inspection" });
+			if (hasZipSignature(magic.subarray(0, observed.bytesRead))) {
+				if (lower.endsWith(".app")) return "app-pack";
+				return zipPackageFormatForPath(lower) ?? "zip";
+			}
+			if (observed.bytesRead === 8 && magic.equals(Buffer.from("bplist00"))) return "plist";
+			const named = namedArtifactFormat(lower);
+			if (named !== undefined) return named;
+			if (lower.endsWith(".pkg") && observed.bytesRead >= 4 && magic.subarray(0, 4).equals(Buffer.from("xar!"))) return "pkg";
+			if (lower.endsWith(".dmg")) {
+				throwIfTargetResolutionCancelled(signal);
+				const size = (await handle.stat()).size;
+				throwIfTargetResolutionCancelled(signal);
+				if (size >= 512) {
+					const trailer = Buffer.alloc(4);
+					const read = await handle.read(trailer, 0, trailer.length, size - 512);
+					throwIfTargetResolutionCancelled(signal);
+					if (read.bytesRead === 4 && trailer.equals(Buffer.from("koly"))) return "dmg";
+				}
+			}
+			return undefined;
+		};
+		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;
+		};
+		isArchiveFormat = (format) => isZipPackageFormat(format) || [
+			"asar",
+			"dmg",
+			"pkg"
+		].includes(format);
+		sha256Handle = async (handle, path, initial, signal) => {
+			const hash = createHash("sha256");
+			const chunk = Buffer.allocUnsafe(64 * 1024);
+			let position = 0;
+			while (true) {
+				throwIfTargetResolutionCancelled(signal);
+				const observed = await handle.read(chunk, 0, Math.min(chunk.length, initial.size - position + 1), position);
+				throwIfTargetResolutionCancelled(signal);
+				if (observed.bytesRead === 0) break;
+				hash.update(chunk.subarray(0, observed.bytesRead));
+				position += observed.bytesRead;
+				if (position > initial.size) throw new BinaryTargetError(path, "target grew while being read");
+			}
+			throwIfTargetResolutionCancelled(signal);
+			const [opened, currentPath] = await Promise.all([handle.stat(), lstat(path)]);
+			if (!sameRegularFileState(initial, opened) || !sameRegularFileState(initial, currentPath) || position !== initial.size) throw new BinaryTargetError(path, "target changed while being read");
+			return hash.digest("hex");
+		};
+		resolveAppBundle = async (path) => {
+			const metadata = await stat(path);
+			if (!metadata.isDirectory()) return ok({ executable: path });
+			if (extname(path).toLowerCase() !== ".app") return err(new BinaryTargetError(path, "this opening route requires a file or app bundle", { constraint: "directory_requires_file" }));
+			return resolveAppBundleExecutable(path);
+		};
+		readExecutableMetadata = async (handle, hostArchitecture, signal) => {
+			throwIfTargetResolutionCancelled(signal);
+			const prefix = Buffer.alloc(4096);
+			const prefixRead = await handle.read(prefix, 0, prefix.length, 0);
+			throwIfTargetResolutionCancelled(signal);
+			const bytes = prefix.subarray(0, prefixRead.bytesRead);
+			const fileSize = (await handle.stat()).size;
+			throwIfTargetResolutionCancelled(signal);
+			if (bytes.length >= 2 && bytes[0] === 77 && bytes[1] === 90) {
+				const offset = mzWindowsHeaderOffset(bytes);
+				if (offset !== null) {
+					if (offset < 64) return err("invalid Windows new-header offset in MZ image");
+					return readPeMetadata(handle, offset, signal);
+				}
+				const tableEnd = bytes.length >= 28 ? bytes.readUInt16LE(24) + bytes.readUInt16LE(6) * 4 : 0;
+				const headerBytes = bytes.length >= 28 ? bytes.readUInt16LE(8) * 16 : 0;
+				if (tableEnd > bytes.length && tableEnd <= headerBytes && tableEnd <= fileSize) {
+					const table = Buffer.alloc(tableEnd);
+					const observed = await handle.read(table, 0, table.length, 0);
+					throwIfTargetResolutionCancelled(signal);
+					return parseExecutableHeader(table.subarray(0, observed.bytesRead), hostArchitecture, fileSize);
+				}
+				return parseExecutableHeader(bytes, hostArchitecture, fileSize);
+			}
+			if (bytes.length >= 8) {
+				const magic = bytes.readUInt32BE(0);
+				if ([3405691583, 3216703178].includes(magic)) {
+					const little = magic === 3216703178;
+					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);
+						throwIfTargetResolutionCancelled(signal);
+						return parseExecutableHeader(header.subarray(0, headerRead.bytesRead), hostArchitecture, fileSize);
+					}
+				}
+			}
+			const parsed = parseExecutableHeader(bytes, hostArchitecture, fileSize);
+			if (!parsed.ok || parsed.value.architecture !== "mips" || parsed.value.mips.elfClass !== 32) return parsed;
+			const declarations = await readMipsElfMetadata(handle, parsed.value.mips, () => throwIfTargetResolutionCancelled(signal));
+			if (!declarations.ok) return declarations;
+			return ok({
+				...parsed.value,
+				mips: {
+					...parsed.value.mips,
+					abiFlags: declarations.value.abiFlags,
+					...declarations.value.sharedLoad === undefined ? {} : { sharedLoad: declarations.value.sharedLoad },
+					...declarations.value.limitations.length === 0 ? {} : { limitations: declarations.value.limitations }
+				}
+			});
+		};
+		readPeMetadata = async (handle, offset, signal) => {
+			throwIfTargetResolutionCancelled(signal);
+			const fileHeader = Buffer.alloc(24);
+			const fileHeaderRead = await handle.read(fileHeader, 0, fileHeader.length, offset);
+			throwIfTargetResolutionCancelled(signal);
+			if (fileHeaderRead.bytesRead !== fileHeader.length) return err("invalid or truncated PE header");
+			const signature = fileHeader.toString("ascii", 0, 2);
+			if ([
+				"NE",
+				"LE",
+				"LX"
+			].includes(signature)) return err(`unsupported ${signature} executable in MZ image`);
+			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);
+			throwIfTargetResolutionCancelled(signal);
+			return recordRead.bytesRead === record.length ? parsePeRecord(record) : err("invalid or truncated PE header");
+		};
+	})))();
+}
+
+//#endregion
+export { init_RegularFileRead as a, withRegularFile as c, decodePeMachine as d, init_peMachine as f, RegularFileCleanupFailure as i, init_binaryTarget as l, init_BinaryTargetResolver as n, readRegularFile as o, parseBinaryTarget as r, retryRegularFileCleanup as s, classifyBinaryTargetFilesystemFailure as t, parseExecutableHeader as u };