rea-agents 6.5.0 → 6.7.0

package/dist/cli-runtime/{officialToolContracts-CCFF0an9.js → officialToolContracts-CzzVLx8I.js}

@@ -1,8 +1,8 @@
 import { __esmMin } from "./rolldown-runtime-DXoylpqc.js";
-import { canonicalJson, compareUnicodeCodePoints, createEvidence, digestCanonicalValue, digestProcessCommitment, dimensionResult, functionComparisonResultSchema, functionDossierSchema, init_canonicalDigest, init_canonicalOrdering, init_comparisonSemantics, init_evidence, init_functionComparisonResults, init_functionComparisonSchemas, init_hopperValues, init_nativeInstruction, init_nativeValueTrace, init_processCaptureParsing, init_processScenario, init_relationshipCoverage, init_toolOutputSchemaPrimitives, init_unicodeCodePointOrder, nativeInstructionInputSchema, nativeValueTraceInputSchema, overallStatus, parseEvidence, parseProcessCapture, relationshipCoverageLimitations, requireOutputSchema, summarize, uniqueSorted, unresolvedDimension } from "./reconstructionObligationLedgerSchemas-Bao0xMr-.js";
-import { init_jsonValue, jsonValueSchema } from "./errorSchemas-CTRmvMl3.js";
-import { analysisDetailSchema, appleAssetCatalogInputSchema, artifactOutputSchemas, bytePatternFields, compareProcessCaptures, dylibResolutionInputSchema, init_analysisDetail, init_appleAssetCatalog, init_bytePattern, init_dylibResolution, init_keyedArchive, init_nativeDataType, init_nativeFunctionAnnotations, init_processComparison, init_toolEffects, init_toolOutputSchemaGroups, keyedArchiveInputSchema, nativeDataTypeInputSchema, nativeFunctionAnnotationsInputSchema, officialOutputSchemas, toolContractMetadata, validateBytePattern } from "./toolOutputSchemaGroups-DRiYs1je.js";
-import { artifactIntegrityPolicySchema, init_artifactIntegrityPolicy } from "./javascriptApplicationAnalysis-HgMzVMQw.js";
+import { artifactGraphDigest, artifactIdForContent, artifactManifestId, canonicalJson, compareUnicodeCodePoints, createEvidence, digestProcessCommitment, dimensionResult, functionComparisonResultSchema, functionDossierSchema, init_artifactIdentity, init_canonicalOrdering, init_comparisonSemantics, init_evidence, init_functionComparisonResults, init_functionComparisonSchemas, init_hopperValues, init_localPath, init_nativeInstruction, init_nativeValueTrace, init_processCaptureParsing, init_processScenario, init_relationshipCoverage, init_toolOutputSchemaPrimitives, init_unicodeCodePointOrder, localPathStringSchema, nativeInstructionInputSchema, nativeValueTraceInputSchema, occurrenceIdForLocation, overallStatus, parseEvidence, parseProcessCapture, relationshipCoverageLimitations, requireOutputSchema, summarize, uniqueSorted, unresolvedDimension } from "./reconstructionObligationLedgerSchemas-Bi6sect1.js";
+import { init_jsonValue, jsonValueSchema } from "./errorSchemas-Ixz_q7qt.js";
+import { analysisDetailSchema, appleAssetCatalogInputSchema, artifactOutputSchemas, bytePatternFields, compareProcessCaptures, dylibResolutionInputSchema, init_analysisDetail, init_appleAssetCatalog, init_bytePattern, init_dylibResolution, init_keyedArchive, init_nativeDataType, init_nativeFunctionAnnotations, init_processComparison, init_toolEffects, init_toolOutputSchemaGroups, keyedArchiveInputSchema, nativeDataTypeInputSchema, nativeFunctionAnnotationsInputSchema, officialOutputSchemas, toolContractMetadata, validateBytePattern } from "./toolOutputSchemaGroups-BqdSzySu.js";
+import { artifactIntegrityPolicySchema, init_artifactIntegrityPolicy } from "./javascriptApplicationAnalysis-Dk6yBV8g.js";
 import { z } from "zod";
 import { diffLines } from "diff";
 
@@ -18,11 +18,12 @@ function init_artifactToolContracts() {
 		init_appleAssetCatalog();
 		init_dylibResolution();
 		init_keyedArchive();
+		init_localPath();
 		init_analysisDetail();
 		artifactInventoryInputSchema = z.strictObject({ integrity_policy: artifactIntegrityPolicySchema });
 		artifactInspectionInputSchema = artifactInventoryInputSchema.extend({ detail: analysisDetailSchema.unwrap().optional().describe("Omitted or complete returns the complete inspection Evidence. summary retains that complete Evidence in this session and returns its inspect_analysis_view summary; use normalized_result.parent_evidence_id for inventory views.") });
 		artifactExtractionInputSchema = z.strictObject({ integrity_policy: artifactIntegrityPolicySchema });
-		artifactExtractionExecutionSchema = artifactExtractionInputSchema.extend({ output_root: z.string().min(1) });
+		artifactExtractionExecutionSchema = artifactExtractionInputSchema.extend({ output_root: localPathStringSchema });
 		exampleInputSchema$1 = z.record(z.string(), jsonValueSchema);
 		examples = {
 			inspect_artifact: {},
@@ -117,13 +118,12 @@ function init_unknownContractExamples() {
 var inventory, provider, ARTIFACT_COMPARISON_EXAMPLE;
 function init_artifactComparisonExample() {
 	return (init_artifactComparisonExample = __esmMin((() => {
-		init_canonicalDigest();
+		init_artifactIdentity();
 		init_evidence();
 		init_jsonValue();
 		inventory = (digit) => {
 			const sha = digit.repeat(64);
-			const artifactId = `art_${digestCanonicalValue({ sha256: sha }, "Artifact example")}`;
-			const occurrenceId = `occ_${digestCanonicalValue({ root: artifactId }, "Artifact example")}`;
+			const artifactId = artifactIdForContent(sha);
 			const nodes = [{
 				artifact_id: artifactId,
 				format: "file",
@@ -135,7 +135,11 @@ function init_artifactComparisonExample() {
 				limitations: []
 			}];
 			const occurrences = [{
-				occurrence_id: occurrenceId,
+				occurrence_id: occurrenceIdForLocation({
+					rootArtifactId: artifactId,
+					logicalPath: ".",
+					entryKind: "file"
+				}),
 				artifact_id: artifactId,
 				parent_occurrence_id: null,
 				logical_path: ".",
@@ -150,30 +154,34 @@ function init_artifactComparisonExample() {
 				source_location: null,
 				limitations: []
 			}];
-			const graphSha256 = digestCanonicalValue({
+			const edges = [];
+			const integrityContradictions = [];
+			const graphSha256 = artifactGraphDigest({
 				nodes,
 				occurrences,
-				edges: [],
-				integrity_contradictions: []
-			}, "Artifact example");
+				edges,
+				contradictions: integrityContradictions
+			});
 			return jsonValueSchema.parse({
 				manifest: {
-					manifest_id: `agm_${digestCanonicalValue({
-						root_artifact_id: artifactId,
-						graph_sha256: graphSha256
-					}, "Artifact example")}`,
+					manifest_id: artifactManifestId(artifactId, graphSha256),
 					root_artifact_id: artifactId,
 					root_sha256: sha,
 					root_format: "file",
 					graph_sha256: graphSha256,
 					node_count: nodes.length,
 					occurrence_count: occurrences.length,
-					edge_count: 0
+					edge_count: edges.length
 				},
 				nodes,
 				occurrences,
-				edges: [],
+				edges,
 				provenance: [],
+				integrity_contradictions: integrityContradictions,
+				coverage: {
+					scope: "root",
+					status: "complete"
+				},
 				limitations: []
 			});
 		};
@@ -487,7 +495,7 @@ function init_processCaptureExample() {
 
 //#endregion
 //#region dist/domain/functionCallCoverage.js
-var callerCoveragePrefix, calleeCoveragePrefix, combineFunctionRelationshipCoverage, isCallerOnlyIncompleteCoverage, functionCallCoverageLimitations;
+var callerCoveragePrefix, calleeCoveragePrefix, combineFunctionRelationshipCoverage, isCallerOnlyIncompleteCoverage, assessFunctionCallCoverage;
 function init_functionCallCoverage() {
 	return (init_functionCallCoverage = __esmMin((() => {
 		init_relationshipCoverage();
@@ -533,13 +541,10 @@ function init_functionCallCoverage() {
 			if (coverage.limited_directions !== undefined) return !coverage.limited_directions.some((direction) => direction === "callees");
 			return coverage.status === "unknown" && coverage.reason.startsWith(callerCoveragePrefix) && !coverage.reason.includes(calleeCoveragePrefix);
 		};
-		functionCallCoverageLimitations = (coverage, dossier) => {
-			return uniqueSorted([
-				...relationshipCoverageLimitations(coverage),
-				...coverage?.status === "complete" ? [] : coverage?.diagnostics ?? [],
-				...(dossier.unresolved_calls ?? []).map(({ address, reason }) => `Unresolved call at ${address}: ${reason}`)
-			]);
-		};
+		assessFunctionCallCoverage = (coverage, dossier) => ({
+			blockers: uniqueSorted([...relationshipCoverageLimitations(coverage), ...(dossier.unresolved_calls ?? []).map(({ address, reason }) => `Unresolved call at ${address}: ${reason}`)]),
+			diagnostics: uniqueSorted(coverage?.diagnostics ?? [])
+		});
 	})))();
 }
 
@@ -557,13 +562,14 @@ function init_functionDossierEvidence() {
 			if (evidence.operation !== "analyze_function") throw new TypeError("Function comparison requires analyze_function Evidence");
 			if (evidence.subject === null) throw new TypeError("Function comparison requires artifact-bound Evidence");
 			const dossier = functionDossierSchema.parse(evidence.normalized_result);
-			const callCoverageLimitations = functionCallCoverageLimitations(evidence.relationship_coverage, dossier);
+			const callCoverage = assessFunctionCallCoverage(evidence.relationship_coverage, dossier);
 			return {
 				evidence,
 				subject: evidence.subject,
 				dossier,
 				limitations: [...new Set([...evidence.limitations, ...dossier.limitations])].sort((left, right) => compareUnicodeCodePoints(left, right)),
-				callCoverageLimitations
+				callCoverageBlockers: callCoverage.blockers,
+				callCoverageDiagnostics: callCoverage.diagnostics
 			};
 		};
 	})))();
@@ -571,7 +577,7 @@ function init_functionDossierEvidence() {
 
 //#endregion
 //#region dist/domain/functionComparisonNormalization.js
-var identityProjection, functionMatch, normalizeCfg, referenceProjection, referenceKindProjection, commentProjection, stringAndNameProjection, swiftLiteralSitesConflict, swiftLiteralSites, sorted, isAutoName, parseAddress, relativeAddress;
+var identityProjection, functionMatch, normalizeCfg, referenceEndpoint, referenceProjection, referenceKindProjection, commentProjection, stringAndNameProjection, swiftLiteralSitesConflict, swiftLiteralSites, sorted, isAutoName, parseAddress, relativeAddress;
 function init_functionComparisonNormalization() {
 	return (init_functionComparisonNormalization = __esmMin((() => {
 		init_comparisonSemantics();
@@ -630,16 +636,19 @@ function init_functionComparisonNormalization() {
 			}
 			return graph;
 		};
-		referenceProjection = (snapshot) => sorted([...snapshot.dossier.incoming_references.map((item) => ({
+		referenceEndpoint = (procedure, address, sameArtifact) => procedure !== null ? procedure.name : sameArtifact ? { address } : null;
+		referenceProjection = (snapshot, sameArtifact) => sorted([...snapshot.dossier.incoming_references.map((item) => ({
 			direction: "in",
-			source: item.source_procedure?.name ?? null,
-			target: item.target_procedure?.name ?? null
+			item
 		})), ...snapshot.dossier.outgoing_references.map((item) => ({
 			direction: "out",
-			source: item.source_procedure?.name ?? null,
-			target: item.target_procedure?.name ?? null
-		}))]);
-		referenceKindProjection = (snapshot) => {
+			item
+		}))].map(({ direction, item }) => ({
+			direction,
+			source: referenceEndpoint(item.source_procedure, item.source_address, sameArtifact),
+			target: referenceEndpoint(item.target_procedure, item.target_address, sameArtifact)
+		})));
+		referenceKindProjection = (snapshot, sameArtifact) => {
 			const edges = [...snapshot.dossier.incoming_references.map((edge) => ({
 				direction: "in",
 				edge
@@ -652,8 +661,8 @@ function init_functionComparisonNormalization() {
 				if (!edge.kind.available) throw new TypeError("Reference-kind availability changed during projection");
 				return {
 					direction,
-					source: edge.source_procedure?.name ?? null,
-					target: edge.target_procedure?.name ?? null,
+					source: referenceEndpoint(edge.source_procedure, edge.source_address, sameArtifact),
+					target: referenceEndpoint(edge.target_procedure, edge.target_address, sameArtifact),
 					type: edge.kind.type,
 					flow: edge.kind.flow,
 					call: edge.kind.call,
@@ -749,7 +758,7 @@ function init_functionComparisonNormalization() {
 
 //#endregion
 //#region dist/domain/functionComparisonDimensions.js
-var compareDimensions, facetLimitations, compareText, compareComments, compareStringsAndNames, swiftLiteralCoverage, compareReferences, compareIdentity, compareCalls, callProjection, compareCfg, compareValues;
+var compareDimensions, facetLimitations, compareText, compareComments, compareStringsAndNames, swiftLiteralCoverage, hasUnnamedEndpoint, compareReferences, compareIdentity, compareCalls, callProjection, compareCfg, compareValues;
 function init_functionComparisonDimensions() {
 	return (init_functionComparisonDimensions = __esmMin((() => {
 		init_comparisonSemantics();
@@ -874,9 +883,11 @@ function init_functionComparisonDimensions() {
 			});
 		};
 		swiftLiteralCoverage = (snapshot) => (snapshot.dossier.swift_string_literal_omissions ?? []).length > 0 ? "partial" : snapshot.dossier.swift_string_literals === undefined ? "absent" : "complete";
+		hasUnnamedEndpoint = (snapshot) => [...snapshot.dossier.incoming_references, ...snapshot.dossier.outgoing_references].some((edge) => edge.source_procedure === null || edge.target_procedure === null);
 		compareReferences = (left, right, context) => {
-			const leftProjection = referenceProjection(left);
-			const rightProjection = referenceProjection(right);
+			const sameArtifact = left.subject.digest.sha256 === right.subject.digest.sha256;
+			const leftProjection = referenceProjection(left, sameArtifact);
+			const rightProjection = referenceProjection(right, sameArtifact);
 			if (leftProjection.length === 0 && rightProjection.length === 0) return compareValues("references", leftProjection, rightProjection, context);
 			if (canonicalJson(leftProjection, "Function comparison") !== canonicalJson(rightProjection, "Function comparison")) return dimensionResult({
 				dimension: "references",
@@ -889,9 +900,18 @@ function init_functionComparisonDimensions() {
 				textDelta: null,
 				limitations: ["Reference endpoints differ independently of provider reference-kind metadata."]
 			});
-			const leftKinds = referenceKindProjection(left);
-			const rightKinds = referenceKindProjection(right);
-			if (leftKinds !== null && rightKinds !== null) return compareValues("references", leftKinds, rightKinds, context);
+			const leftKinds = referenceKindProjection(left, sameArtifact);
+			const rightKinds = referenceKindProjection(right, sameArtifact);
+			const kindsKnown = leftKinds !== null && rightKinds !== null;
+			if (kindsKnown && canonicalJson(leftKinds, "Function comparison") !== canonicalJson(rightKinds, "Function comparison")) return compareValues("references", leftKinds, rightKinds, context);
+			if (!sameArtifact && (hasUnnamedEndpoint(left) || hasUnnamedEndpoint(right))) return unresolvedDimension({
+				dimension: "references",
+				links: context.links,
+				leftCount: leftProjection.length,
+				rightCount: rightProjection.length,
+				limitations: ["Unnamed reference endpoints have no stable identity across different artifacts, so equal named endpoints do not establish equal references."]
+			});
+			if (kindsKnown) return compareValues("references", leftKinds, rightKinds, context);
 			return unresolvedDimension({
 				dimension: "references",
 				links: context.links,
@@ -913,22 +933,23 @@ function init_functionComparisonDimensions() {
 		compareCalls = (left, right, context) => {
 			const leftValues = callProjection(left);
 			const rightValues = callProjection(right);
-			const coverageLimitations = [...left.callCoverageLimitations.map((reason) => `Left: ${reason}`), ...right.callCoverageLimitations.map((reason) => `Right: ${reason}`)];
+			const coverageLimitations = [...left.callCoverageBlockers.map((reason) => `Left: ${reason}`), ...right.callCoverageBlockers.map((reason) => `Right: ${reason}`)];
+			const coverageDiagnostics = [...left.callCoverageDiagnostics.map((reason) => `Left: ${reason}`), ...right.callCoverageDiagnostics.map((reason) => `Right: ${reason}`)];
 			if (coverageLimitations.length > 0) return unresolvedDimension({
 				dimension: "calls",
 				links: context.links,
 				leftCount: leftValues.length,
 				rightCount: rightValues.length,
-				limitations: coverageLimitations
+				limitations: [...coverageLimitations, ...coverageDiagnostics]
 			});
 			if ([...leftValues, ...rightValues].some(({ name }) => isAutoName(name))) return unresolvedDimension({
 				dimension: "calls",
 				links: context.links,
 				leftCount: leftValues.length,
 				rightCount: rightValues.length,
-				limitations: ["Address-derived callee or caller names cannot be matched safely."]
+				limitations: ["Address-derived callee or caller names cannot be matched safely.", ...coverageDiagnostics]
 			});
-			return compareValues("calls", sorted(leftValues), sorted(rightValues), context);
+			return compareValues("calls", sorted(leftValues), sorted(rightValues), context, coverageDiagnostics);
 		};
 		callProjection = (snapshot) => [...snapshot.dossier.callers.map(({ name }) => ({
 			direction: "in",
@@ -951,7 +972,7 @@ function init_functionComparisonDimensions() {
 			});
 			return compareValues("cfg", leftGraph, rightGraph, context);
 		};
-		compareValues = (dimension, left, right, context) => {
+		compareValues = (dimension, left, right, context, limitations = []) => {
 			const leftJson = canonicalJson(left, "Function comparison");
 			const rightJson = canonicalJson(right, "Function comparison");
 			return dimensionResult({
@@ -963,7 +984,7 @@ function init_functionComparisonDimensions() {
 				leftCount: Array.isArray(left) ? left.length : null,
 				rightCount: Array.isArray(right) ? right.length : null,
 				textDelta: null,
-				limitations: []
+				limitations
 			});
 		};
 	})))();
@@ -1412,7 +1433,7 @@ function init_officialToolContracts() {
 			})),
 			official("list_procedures", "List every analyzed procedure as address/value pairs after provider analysis. Ghidra metadata distinguishes thunks and external functions; use returned addresses in later function operations.", z.object({ document })),
 			official("list_segments", "List segments or memory blocks using exclusive end addresses. Ghidra reports block permissions, address space, image base, initialization, and overlay facts; Hopper marks unavailable permissions explicitly.", z.object({ document })),
-			official("list_strings", "List every provider-defined string object, or filter to one address, as address/value pairs with encoding, terminator status, and byte length when available. Hopper reads complete typed objects and retains its original display text as provider_value; long literals may span adjacent unterminated objects.", z.object({
+			official("list_strings", "List every provider-reported string object or candidate, or filter to one address, as address/value pairs with encoding, terminator status, and byte length when available. Hopper reads complete typed objects and retains its original display text as provider_value; long literals may span adjacent unterminated objects. Kuna scans mapped printable sequences of at least five characters, including unterminated fragments; references are not computed.", z.object({
 				document,
 				address: optionalAddress
 			})),
@@ -1460,7 +1481,7 @@ function init_officialToolContracts() {
 				document
 			})),
 			official("search_procedures", "Search every analyzed procedure name using literal matching by default or regex when requested. Results are deterministic and complete. Hopper regex mode uses ECMAScript Unicode syntax in a cancellable worker; a matching deadline leaves its API usable.", z.object(analysisSearchInput)),
-			official("search_strings", "Search every provider-defined string object using literal matching by default or regex when requested. Results are deterministic and complete over those defined objects, not every text sequence in artifact bytes. Ghidra may omit packed or undefined literals, including Rust strings; an empty result does not prove text is absent. If an address is known, read_bytes and xrefs inspect its bytes and references. Hopper retains typed byte decoding, native display, and explicit decoding unknowns. Adjacent long-literal fragments match independently. Hopper regex mode uses ECMAScript Unicode syntax in a cancellable worker; a matching deadline leaves its API usable.", z.object(analysisSearchInput)),
+			official("search_strings", "Search every provider-reported string object or candidate using literal matching by default or regex when requested. Results are deterministic and complete over that provider inventory, not every text sequence in artifact bytes. Kuna scans mapped sequences of at least five characters, including unterminated fragments, without computing references. Ghidra may omit packed or undefined literals, including Rust strings; an empty result does not prove text is absent. If an address is known, read_bytes and xrefs inspect its bytes and references. Hopper retains typed byte decoding, native display, and explicit decoding unknowns. Adjacent long-literal fragments match independently. Hopper regex mode uses ECMAScript Unicode syntax in a cancellable worker; a matching deadline leaves its API usable.", z.object(analysisSearchInput)),
 			official("set_address_name", "Assign an analyst name to one mapped hexadecimal address and report whether the native edit succeeded and exact readback matched. Hopper rejects symbol names exceeding 1024 UTF-16 code units before mutation, and rejects names owned by another address; use set_addresses_names to explicitly move or swap labels among selected addresses. This mutates analysis metadata.", z.object({
 				address,
 				name: z.string(),

package/dist/cli-runtime/peMachine-B9ggfSJJ.js

@@ -0,0 +1,95 @@
+import { __esmMin } from "./rolldown-runtime-DXoylpqc.js";
+import { err, init_result, ok } from "./reconstructionObligationLedgerSchemas-Bi6sect1.js";
+
+//#region dist/domain/elfFixedHeader.js
+var readElfFixedHeader, elfArchitecture;
+function init_elfFixedHeader() {
+	return (init_elfFixedHeader = __esmMin((() => {
+		init_result();
+		readElfFixedHeader = (bytes, totalBytes = bytes.length) => {
+			if (bytes.length >= 4 && bytes.toString("hex", 0, 4) !== "7f454c46") return err("not an ELF image");
+			if (bytes.length < 16) return err("ELF identification is truncated");
+			const classByte = bytes[4];
+			if (classByte !== 1 && classByte !== 2) return err("unsupported ELF class");
+			const dataByte = bytes[5];
+			if (dataByte !== 1 && dataByte !== 2) return err("unsupported ELF endianness");
+			if (bytes[6] !== 1) return err("unsupported ELF identification version");
+			const elfClass = classByte === 1 ? 32 : 64;
+			const minimumSize = elfClass === 32 ? 52 : 64;
+			if (!Number.isSafeInteger(totalBytes) || totalBytes < bytes.length || totalBytes < minimumSize || bytes.length < minimumSize) return err(`truncated ELF header: an ELF${elfClass} header needs ${minimumSize} bytes; the file has ${totalBytes}`);
+			const littleEndian = dataByte === 1;
+			const readU16 = (offset) => littleEndian ? bytes.readUInt16LE(offset) : bytes.readUInt16BE(offset);
+			const readU32 = (offset) => littleEndian ? bytes.readUInt32LE(offset) : bytes.readUInt32BE(offset);
+			if (readU32(20) !== 1) return err("unsupported ELF header version");
+			const headerSize = readU16(elfClass === 32 ? 40 : 52);
+			if (headerSize < minimumSize || headerSize > totalBytes) return err("invalid ELF header size");
+			const machine = readU16(18);
+			return ok({
+				elfClass,
+				byteOrder: littleEndian ? "little" : "big",
+				headerSize,
+				machine,
+				architecture: elfArchitecture(machine) ?? null
+			});
+		};
+		elfArchitecture = (machine) => {
+			switch (machine) {
+				case 3: return "x86";
+				case 62: return "x86_64";
+				case 8: return "mips";
+				case 20: return "powerpc";
+				case 40: return "arm";
+				case 164: return "hexagon";
+				case 183: return "arm64";
+				case 243: return "riscv";
+			}
+			return undefined;
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/domain/peMachine.js
+var architectureForMachine, peOptionalHeaderMagic, 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;
+		};
+		peOptionalHeaderMagic = (architecture) => architecture === "x86_64" || architecture === "arm64" ? 523 : 267;
+		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
+export { decodePeMachine, init_elfFixedHeader, init_peMachine, peOptionalHeaderMagic, readElfFixedHeader };