rea-agents 6.4.0 → 6.5.0

package/dist/cli-runtime/lipo-DSWP6fv-.js

@@ -0,0 +1,396 @@
+import { __esmMin } from "./rolldown-runtime-DXoylpqc.js";
+import { err, init_machoCpuIdentity, init_result, machoCpuSubtypeBase, ok } from "./reconstructionObligationLedgerSchemas-Bao0xMr-.js";
+import { init_snapshotEnvironment, snapshotEnvironment } from "./snapshotEnvironment-D_tWyOub.js";
+import { DarwinProcessOwnershipInspectionError, boundedUtf8Text, init_DarwinProcessRunTokenReader, init_boundedUtf8Text } from "./ProcessOwnership-DXC5-UWt.js";
+import { OwnedCommandFailure, init_OwnedCommand, runOwnedCommand } from "./OwnedCommand-Cj9GhmPR.js";
+import { z } from "zod";
+import { createHash, randomUUID } from "node:crypto";
+import { realpath } from "node:fs/promises";
+import { createReadStream } from "node:fs";
+
+//#region dist/native/CommandRunner.js
+var NATIVE_COMMAND_TIMEOUT_MS, NATIVE_COMMAND_OUTPUT_BUDGET_BYTES, NATIVE_FAILURE_DIAGNOSTIC_BYTES, NativeCommandFailure, XcrunCommandRunner, commandProcessResources, commandCleanupFailure, ALLOWED_TOOLS, resolveXcrunTool, failureCapture, captureProcess, processFailureReason, processCaptureFromSnapshot, hashFile;
+function init_CommandRunner() {
+	return (init_CommandRunner = __esmMin((() => {
+		init_snapshotEnvironment();
+		init_result();
+		init_DarwinProcessRunTokenReader();
+		init_OwnedCommand();
+		init_boundedUtf8Text();
+		NATIVE_COMMAND_TIMEOUT_MS = 6e4;
+		NATIVE_COMMAND_OUTPUT_BUDGET_BYTES = 64 * 1024 * 1024;
+		NATIVE_FAILURE_DIAGNOSTIC_BYTES = 64 * 1024;
+		NativeCommandFailure = class extends Error {
+			tool;
+			reason;
+			exitCode;
+			capture;
+			cleanupFailure;
+			cleanupResources;
+			cleanupOwner;
+			cleanupFailures;
+			detail;
+			constructor(tool, reason, exitCode = null, options, capture = null, cleanupFailure = null, cleanupResources = []) {
+				super(`Native command ${tool} failed: ${reason}`, options);
+				this.tool = tool;
+				this.reason = reason;
+				this.exitCode = exitCode;
+				this.capture = capture;
+				this.cleanupFailure = cleanupFailure;
+				this.cleanupResources = cleanupResources;
+				this.cleanupOwner = options?.cleanupOwner;
+				this.cleanupFailures = options?.cleanupFailures ?? [];
+				this.detail = options?.detail ?? null;
+			}
+		};
+		XcrunCommandRunner = class {
+			resolveTool;
+			launcher;
+			environment;
+			#pendingCleanup = new Set();
+			#cleanupAttempt;
+			constructor(environment, resolveTool = (tool, signal) => resolveXcrunTool(tool, this.environment, signal, this.launcher), launcher) {
+				this.resolveTool = resolveTool;
+				this.launcher = launcher;
+				this.environment = snapshotEnvironment(environment);
+			}
+			run(tool, arguments_, options) {
+				if (!ALLOWED_TOOLS.has(tool)) return Promise.resolve(err(new NativeCommandFailure(tool, "unavailable")));
+				return this.#runAfterCleanup(tool, arguments_, options);
+			}
+			/** Retry every retained owner; a failed retry prevents another command launch. */
+			retryCleanup() {
+				if (this.#pendingCleanup.size === 0) return Promise.resolve([]);
+				if (this.#cleanupAttempt !== undefined) return this.#cleanupAttempt;
+				this.#cleanupAttempt = this.#retryCleanup().finally(() => {
+					this.#cleanupAttempt = undefined;
+				});
+				return this.#cleanupAttempt;
+			}
+			async #runAfterCleanup(tool, arguments_, options) {
+				const pendingFailures = await this.retryCleanup();
+				if (pendingFailures.length > 0) return err(commandCleanupFailure(tool, pendingFailures));
+				const resolved = await this.resolveTool(tool, options.signal, this.launcher);
+				if (!resolved.ok) {
+					if (resolved.error.cleanupOwner !== undefined) this.#pendingCleanup.add(resolved.error.cleanupOwner);
+					return resolved;
+				}
+				const captured = await captureProcess(resolved.value.path, arguments_, tool, options, this.environment, this.launcher);
+				if (!captured.ok && captured.error.cleanupOwner !== undefined) this.#pendingCleanup.add(captured.error.cleanupOwner);
+				return captured.ok ? ok({
+					...captured.value,
+					tool,
+					executable: resolved.value.path,
+					executableSha256: resolved.value.sha256,
+					toolVersion: null,
+					versionReason: "Tool exposes no uniform stable version flag; executable SHA-256 is a prelaunch file sample and does not prove atomic OS image binding.",
+					arguments: [...arguments_]
+				}) : captured;
+			}
+			async #retryCleanup() {
+				const failures = [];
+				for (const owner of this.#pendingCleanup) {
+					let reason;
+					try {
+						const stopped = await owner.stop();
+						if (stopped.status !== "incomplete") {
+							this.#pendingCleanup.delete(owner);
+							continue;
+						}
+						reason = stopped.reason || "native command cleanup remains unverified";
+					} catch (cause) {
+						reason = cause instanceof Error ? cause.message || cause.name : String(cause) || "native command cleanup failed unexpectedly";
+					}
+					failures.push({
+						owner,
+						reason: reason ?? "native command cleanup remains unverified",
+						resources: commandProcessResources(owner)
+					});
+				}
+				return failures;
+			}
+		};
+		commandProcessResources = (owner) => {
+			const ownership = owner.launch.ownership;
+			return ownership === undefined ? ["native-command-process"] : [
+				ownership.runId,
+				`pid:${String(ownership.leaderPid)}`,
+				`process-group:${String(ownership.processGroupId)}`
+			];
+		};
+		commandCleanupFailure = (tool, failures) => new NativeCommandFailure(tool, "io", null, {
+			cleanupFailures: failures,
+			cause: new AggregateError(failures.map(({ reason, resources }) => new Error(`${reason} (${resources.join(", ")})`)), "Previously owned native command cleanup remains incomplete")
+		}, null, failures.map(({ reason, resources }) => `${resources.join(", ")}: ${reason}`).join("; "), [...new Set(failures.flatMap(({ resources }) => resources))]);
+		ALLOWED_TOOLS = new Set([
+			"codesign",
+			"dyld_info",
+			"dwarfdump",
+			"file",
+			"lipo",
+			"nm",
+			"otool",
+			"plutil",
+			"strings",
+			"swift-demangle",
+			"vtool"
+		]);
+		resolveXcrunTool = async (tool, environment, signal, launcher) => {
+			const found = await captureProcess("/usr/bin/xcrun", ["--find", tool], "xcrun", signal === undefined ? {} : { signal }, environment, launcher);
+			if (!found.ok) {
+				return err(new NativeCommandFailure(tool, found.error.reason === "nonzero-exit" || found.error.reason === "unavailable" ? "unavailable" : found.error.reason, found.error.exitCode, {
+					cause: found.error,
+					...found.error.cleanupOwner === undefined ? {} : { cleanupOwner: found.error.cleanupOwner },
+					...found.error.cleanupFailures.length === 0 ? {} : { cleanupFailures: found.error.cleanupFailures },
+					...found.error.detail === null ? {} : { detail: found.error.detail }
+				}, found.error.capture, found.error.cleanupFailure, found.error.cleanupResources));
+			}
+			if (found.value.exitCode !== 0) return err(new NativeCommandFailure(tool, "unavailable", found.value.exitCode, undefined, failureCapture(found.value, false)));
+			const candidate = found.value.stdout.trim();
+			if (!candidate.startsWith("/")) return err(new NativeCommandFailure(tool, "unavailable", found.value.exitCode, undefined, failureCapture(found.value, false)));
+			try {
+				const path = await realpath(candidate);
+				return ok({
+					path,
+					sha256: await hashFile(path, signal)
+				});
+			} catch (cause) {
+				const capture = failureCapture(found.value, false);
+				if (signal?.aborted === true) return err(new NativeCommandFailure(tool, "cancelled", capture.exitCode, { cause }, capture));
+				return err(new NativeCommandFailure(tool, "io", capture.exitCode, { cause }, capture));
+			}
+		};
+		failureCapture = (capture, truncated) => {
+			const stdout = boundedUtf8Text(capture.stdout, NATIVE_FAILURE_DIAGNOSTIC_BYTES);
+			const stderr = boundedUtf8Text(capture.stderr, NATIVE_FAILURE_DIAGNOSTIC_BYTES);
+			return {
+				stdout: stdout.text,
+				stderr: stderr.text,
+				stdoutBytes: capture.stdoutBytes,
+				stderrBytes: capture.stderrBytes,
+				exitCode: capture.exitCode,
+				signal: capture.signal,
+				truncated: truncated || stdout.truncated || stderr.truncated
+			};
+		};
+		captureProcess = async (executable, arguments_, tool, options, environment, launcher) => {
+			const runId = `rea-native-command-${randomUUID()}`;
+			try {
+				const snapshot = await runOwnedCommand({
+					command: executable,
+					arguments: [...arguments_],
+					runId,
+					env: {
+						LC_ALL: "C",
+						LANG: "C"
+					},
+					hostEnvironment: environment,
+					...options.signal === undefined ? {} : { signal: options.signal }
+				}, {
+					timeoutMs: NATIVE_COMMAND_TIMEOUT_MS,
+					diagnosticBytes: NATIVE_COMMAND_OUTPUT_BUDGET_BYTES,
+					acceptNonZeroExit: options.acceptNonZero === true
+				}, launcher === undefined ? {} : { launcher });
+				return ok(processCaptureFromSnapshot(snapshot));
+			} catch (cause) {
+				if (cause instanceof OwnedCommandFailure) {
+					const capture = cause.snapshot === null ? null : failureCapture(processCaptureFromSnapshot(cause.snapshot), cause.snapshot.diagnosticTruncated === true);
+					return err(new NativeCommandFailure(tool, cause.reason === "process" ? processFailureReason(capture) : cause.reason, capture?.exitCode ?? null, {
+						cause,
+						...cause.cleanupOwner === undefined ? {} : { cleanupOwner: cause.cleanupOwner }
+					}, capture, cause.cleanupFailure, cause.resources));
+				}
+				return err(new NativeCommandFailure(tool, "io", null, {
+					cause,
+					...cause instanceof DarwinProcessOwnershipInspectionError ? { detail: cause.message } : {}
+				}));
+			}
+		};
+		processFailureReason = (capture) => capture !== null && (capture.signal !== null || capture.exitCode !== null && capture.exitCode !== 0) ? "nonzero-exit" : "io";
+		processCaptureFromSnapshot = (snapshot) => ({
+			stdout: snapshot.stdout.text,
+			stderr: snapshot.stderr.text,
+			stdoutBytes: snapshot.stdout.bytes,
+			stderrBytes: snapshot.stderr.bytes,
+			exitCode: snapshot.exitCode ?? null,
+			signal: snapshot.signal ?? null
+		});
+		hashFile = (path, signal) => new Promise((resolve, reject) => {
+			const hash = createHash("sha256");
+			const stream = createReadStream(path, signal === undefined ? undefined : { signal });
+			stream.on("data", (chunk) => hash.update(chunk));
+			stream.once("error", reject);
+			stream.once("end", () => resolve(hash.digest("hex")));
+		});
+	})))();
+}
+
+//#endregion
+//#region dist/native/parsers/lipo.js
+var architectureSchema, parseLipoOutput, integer, CPU_TYPES, CPU_SUBTYPES, cpuTypeCode, cpuSubtypeCode, cpuSubtypeBase, capabilityBits, unsigned32, alignment;
+function init_lipo() {
+	return (init_lipo = __esmMin((() => {
+		init_machoCpuIdentity();
+		architectureSchema = z.object({
+			name: z.string().min(1),
+			cpu_type: z.string().nullable(),
+			cpu_subtype: z.string().nullable(),
+			cpu_type_code: z.number().int().nonnegative().nullable(),
+			cpu_subtype_code: z.number().int().nonnegative().nullable(),
+			cpu_subtype_base: z.number().int().nonnegative().nullable(),
+			capabilities: z.string().nullable(),
+			file_offset: z.number().int().min(0).nullable(),
+			size: z.number().int().min(0).nullable(),
+			alignment: z.number().int().min(0).nullable()
+		});
+		parseLipoOutput = (output, operandPath) => {
+			if (operandPath !== undefined) {
+				const header = `Fat header in: ${operandPath}`;
+				if (output.startsWith(header)) {
+					if (output.startsWith("\r\n", header.length)) output = output.slice(header.length + 2);
+					else if (output.startsWith("\n", header.length)) output = output.slice(header.length + 1);
+				}
+			}
+			const thinArchitecture = /(?:^|\r?\n)Non-fat file:[\s\S]* is architecture: ([^\s]+)\s*$/u.exec(output)?.[1];
+			if (thinArchitecture !== undefined) return {
+				format: "thin",
+				architectures: [architectureSchema.parse({
+					name: thinArchitecture,
+					cpu_type: null,
+					cpu_subtype: null,
+					cpu_type_code: null,
+					cpu_subtype_code: null,
+					cpu_subtype_base: null,
+					capabilities: null,
+					file_offset: null,
+					size: null,
+					alignment: null
+				})]
+			};
+			const architectures = [];
+			let current;
+			const flush = () => {
+				if (current === undefined) return;
+				const name = current.architecture ?? current["Non-fat file"];
+				if (name !== undefined) architectures.push(architectureSchema.parse({
+					name: name.includes(" is architecture: ") ? name.split(" is architecture: ").at(-1) ?? name : name,
+					cpu_type: current.cputype ?? null,
+					cpu_subtype: current.cpusubtype ?? null,
+					cpu_type_code: cpuTypeCode(current.cputype),
+					cpu_subtype_code: cpuSubtypeCode(current.cpusubtype, current.capabilities),
+					cpu_subtype_base: cpuSubtypeBase(current.cpusubtype),
+					capabilities: current.capabilities ?? null,
+					file_offset: integer(current.offset),
+					size: integer(current.size),
+					alignment: alignment(current.align)
+				}));
+				current = undefined;
+			};
+			for (const rawLine of output.split(/\r?\n/u)) {
+				const line = rawLine.trim();
+				if (line.startsWith("Non-fat file:")) {
+					flush();
+					current = { "Non-fat file": line };
+					continue;
+				}
+				if (line.startsWith("architecture ")) {
+					flush();
+					current = { architecture: line.slice("architecture ".length).trim() };
+					continue;
+				}
+				const match = /^(cputype|cpusubtype|capabilities|offset|size|align)\s+(.+)$/u.exec(line);
+				if (match?.[1] !== undefined && match[2] !== undefined) {
+					current ??= {};
+					current[match[1]] = match[2].trim();
+				}
+			}
+			flush();
+			if (architectures.length === 0) throw new TypeError("lipo output contained no architectures");
+			return {
+				format: "fat",
+				architectures
+			};
+		};
+		integer = (value) => {
+			if (value === undefined || !/^\d+$/u.test(value)) return null;
+			const parsed = Number.parseInt(value, 10);
+			return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : null;
+		};
+		CPU_TYPES = {
+			CPU_TYPE_X86: 7,
+			CPU_TYPE_X86_64: 16777223,
+			CPU_TYPE_ARM: 12,
+			CPU_TYPE_ARM64: 16777228,
+			CPU_TYPE_ARM64_32: 33554444,
+			CPU_TYPE_POWERPC: 18,
+			CPU_TYPE_POWERPC64: 16777234
+		};
+		CPU_SUBTYPES = {
+			CPU_SUBTYPE_X86_ALL: 3,
+			CPU_SUBTYPE_X86_64_ALL: 3,
+			CPU_SUBTYPE_X86_64_H: 8,
+			CPU_SUBTYPE_ARM64_ALL: 0,
+			CPU_SUBTYPE_ARM64_V8: 1,
+			CPU_SUBTYPE_ARM64E: 2,
+			CPU_SUBTYPE_ARM64_32_ALL: 0,
+			CPU_SUBTYPE_ARM64_32_V8: 1,
+			CPU_SUBTYPE_ARM_V7: 9,
+			CPU_SUBTYPE_ARM_V7S: 11,
+			CPU_SUBTYPE_ARM_V7K: 12,
+			CPU_SUBTYPE_POWERPC_ALL: 0,
+			CPU_SUBTYPE_POWERPC_970: 100
+		};
+		cpuTypeCode = (value) => {
+			if (value === undefined) return null;
+			const numeric = unsigned32(value);
+			return numeric ?? CPU_TYPES[value] ?? null;
+		};
+		cpuSubtypeCode = (value, capabilities) => {
+			if (value === undefined) return null;
+			const numeric = unsigned32(value);
+			if (numeric !== null) return numeric;
+			const subtype = CPU_SUBTYPES[value];
+			if (subtype === undefined) return null;
+			if (value !== "CPU_SUBTYPE_ARM64E") {
+				const bits = capabilityBits(capabilities);
+				return bits === null ? null : (bits << 24 | subtype) >>> 0;
+			}
+			const version = /PTR_AUTH_VERSION\s+USERSPACE\s+(\d+)/u.exec(capabilities ?? "")?.[1];
+			if (version === undefined) return null;
+			const parsedVersion = Number(version);
+			if (!Number.isInteger(parsedVersion) || parsedVersion < 0 || parsedVersion > 15) return null;
+			return (2147483648 | parsedVersion << 24 | subtype) >>> 0;
+		};
+		cpuSubtypeBase = (value) => {
+			if (value === undefined) return null;
+			const subtype = unsigned32(value) ?? CPU_SUBTYPES[value];
+			return subtype === undefined ? null : machoCpuSubtypeBase(subtype);
+		};
+		capabilityBits = (capabilities) => {
+			if (capabilities === "CPU_SUBTYPE_LIB64") return 128;
+			const bits = /^0x([\da-f]{1,2})$/iu.exec(capabilities ?? "")?.[1];
+			return bits === undefined ? null : Number.parseInt(bits, 16);
+		};
+		unsigned32 = (value) => {
+			if (!/^(?:\d+|0x[\da-f]+)$/iu.test(value)) return null;
+			const parsed = Number(value);
+			return Number.isInteger(parsed) && parsed >= 0 && parsed <= 4294967295 ? parsed >>> 0 : null;
+		};
+		alignment = (value) => {
+			if (value === undefined) return null;
+			const exponent = /^2\^(\d+)(?: \((\d+)\))?$/u.exec(value);
+			const powerText = exponent?.[1];
+			if (powerText !== undefined) {
+				const power = Number.parseInt(powerText, 10);
+				if (power > 52) return null;
+				const alignment = 2 ** power;
+				const reported = exponent?.[2];
+				return reported === undefined || integer(reported) === alignment ? alignment : null;
+			}
+			return integer(value);
+		};
+	})))();
+}
+
+//#endregion
+export { NATIVE_COMMAND_OUTPUT_BUDGET_BYTES, NATIVE_COMMAND_TIMEOUT_MS, NativeCommandFailure, XcrunCommandRunner, failureCapture, init_CommandRunner, init_lipo, parseLipoOutput, resolveXcrunTool };

package/dist/cli-runtime/logger-CQQCI4a2.js

@@ -0,0 +1,48 @@
+import { __esmMin } from "./rolldown-runtime-DXoylpqc.js";
+import { err, init_result, ok } from "./reconstructionObligationLedgerSchemas-Bao0xMr-.js";
+import { ConfigurationError, init_configurationErrors } from "./errorSchemas-CTRmvMl3.js";
+import { z } from "zod";
+import pino from "pino";
+
+//#region dist/logger.js
+var logLevelSchema, parseLogLevel, createLogger, silentLogger;
+function init_logger() {
+	return (init_logger = __esmMin((() => {
+		init_configurationErrors();
+		init_result();
+		logLevelSchema = z.enum([
+			"trace",
+			"debug",
+			"info",
+			"warn",
+			"error",
+			"fatal",
+			"silent"
+		]).default("info");
+		parseLogLevel = (value) => {
+			const parsed = logLevelSchema.safeParse(value);
+			if (parsed.success) return ok(parsed.data);
+			return err(new ConfigurationError("Invalid REA environment configuration", {
+				cause: parsed.error,
+				settings: parsed.error.issues.map(({ message }) => ({
+					setting: "REA_LOG_LEVEL",
+					constraint: message
+				}))
+			}));
+		};
+		createLogger = (mode, level) => pino({
+			level,
+			base: {
+				application: "rea",
+				mode
+			}
+		}, pino.destination({
+			dest: 2,
+			sync: false
+		}));
+		silentLogger = pino({ level: "silent" });
+	})))();
+}
+
+//#endregion
+export { createLogger, init_logger, parseLogLevel, silentLogger };

package/dist/cli-runtime/machoContainer-C8BIkkq3.js

@@ -0,0 +1,172 @@
+import { __esmMin } from "./rolldown-runtime-DXoylpqc.js";
+
+//#region dist/domain/apple/machoContainer.js
+var FAT_MAGIC, FAT_MAGIC_64, FAT_CIGAM, FAT_CIGAM_64, MAX_FAT_ARCHITECTURES, KNOWN_MACHO_CPU_TYPES, MACHO_HEADER_MAGICS, readFatContainerHeader, classifyFatContainerIdentity, readFatSliceDeclarations, validateFatSlice, inspectFatSliceRange, validateFatSliceIdentity, safeNumber;
+function init_machoContainer() {
+	return (init_machoContainer = __esmMin((() => {
+		FAT_MAGIC = 3405691582;
+		FAT_MAGIC_64 = 3405691583;
+		FAT_CIGAM = 3199925962;
+		FAT_CIGAM_64 = 3216703178;
+		MAX_FAT_ARCHITECTURES = 128;
+		KNOWN_MACHO_CPU_TYPES = [
+			7,
+			16777223,
+			12,
+			16777228,
+			33554444,
+			18,
+			16777234
+		];
+		MACHO_HEADER_MAGICS = [
+			4277009102,
+			4277009103,
+			3472551422,
+			3489328638
+		];
+		readFatContainerHeader = (bytes, fileSize) => {
+			if (bytes.byteLength < 4) return { state: "not-fat" };
+			const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+			const magic = view.getUint32(0, false);
+			if (![
+				FAT_MAGIC,
+				FAT_MAGIC_64,
+				FAT_CIGAM,
+				FAT_CIGAM_64
+			].includes(magic)) return { state: "not-fat" };
+			if (!Number.isSafeInteger(fileSize) || fileSize < bytes.byteLength) return {
+				state: "malformed",
+				reason: "FAT file size is invalid or contradicts retained bytes"
+			};
+			if (bytes.byteLength < 8) {
+				return fileSize < 8 ? {
+					state: "malformed",
+					reason: "FAT header is truncated"
+				} : {
+					state: "needs-data",
+					requiredBytes: 8
+				};
+			}
+			const littleEndian = magic === FAT_CIGAM || magic === FAT_CIGAM_64;
+			const wide = magic === FAT_MAGIC_64 || magic === FAT_CIGAM_64;
+			const count = view.getUint32(4, littleEndian);
+			if (count === 0) return {
+				state: "malformed",
+				reason: "FAT header declares no architectures"
+			};
+			if (count > MAX_FAT_ARCHITECTURES) return { state: "not-fat" };
+			const tableEnd = 8 + count * (wide ? 32 : 20);
+			if (tableEnd > fileSize) return { state: "not-fat" };
+			if (tableEnd > bytes.byteLength) return {
+				state: "needs-data",
+				requiredBytes: tableEnd
+			};
+			const declarations = readFatSliceDeclarations(bytes.subarray(8, tableEnd), {
+				count,
+				wide,
+				littleEndian
+			});
+			return declarations.status === "parsed" ? {
+				state: "parsed",
+				magic,
+				count,
+				wide,
+				littleEndian,
+				tableEnd,
+				slices: declarations.slices,
+				rangeIssues: declarations.slices.map((slice) => inspectFatSliceRange(slice, fileSize, tableEnd))
+			} : {
+				state: "malformed",
+				reason: declarations.reason
+			};
+		};
+		classifyFatContainerIdentity = (header, sliceHeaderAt) => {
+			const hasKnownCpu = header.slices.some(({ cpuType }) => KNOWN_MACHO_CPU_TYPES.includes(cpuType));
+			const invalidRange = header.rangeIssues.find((issue) => issue !== null);
+			if (hasKnownCpu) return invalidRange === undefined ? { state: "mach-o" } : {
+				state: "malformed",
+				...invalidRange
+			};
+			const validRanges = header.slices.filter((_slice, index) => header.rangeIssues[index] === null);
+			const missingHeaders = [];
+			let observedMachO = false;
+			for (const slice of validRanges) {
+				const magic = sliceHeaderAt(slice.offset);
+				if (magic === undefined) missingHeaders.push(slice.offset);
+				else if (magic !== null && MACHO_HEADER_MAGICS.includes(magic)) observedMachO = true;
+			}
+			if (observedMachO) {
+				return invalidRange === undefined ? { state: "mach-o" } : {
+					state: "malformed",
+					...invalidRange
+				};
+			}
+			if (missingHeaders.length > 0) return {
+				state: "needs-slice-header",
+				offsets: missingHeaders
+			};
+			return { state: "not-mach-o" };
+		};
+		readFatSliceDeclarations = (tableBytes, options) => {
+			const { count, wide, littleEndian } = options;
+			const entrySize = wide ? 32 : 20;
+			if (tableBytes.byteLength < count * entrySize) return {
+				status: "malformed",
+				reason: "FAT table is truncated"
+			};
+			const view = new DataView(tableBytes.buffer, tableBytes.byteOffset, tableBytes.byteLength);
+			const slices = [];
+			for (let index = 0; index < count; index++) {
+				const base = index * entrySize;
+				const offset = wide ? safeNumber(view.getBigUint64(base + 8, littleEndian)) : view.getUint32(base + 8, littleEndian);
+				const size = wide ? safeNumber(view.getBigUint64(base + 16, littleEndian)) : view.getUint32(base + 12, littleEndian);
+				if (offset === null || size === null) return {
+					status: "malformed",
+					reason: "FAT offset or size exceeds the safe range"
+				};
+				slices.push({
+					index,
+					offset,
+					size,
+					alignmentExponent: view.getUint32(base + (wide ? 24 : 16), littleEndian),
+					cpuType: view.getUint32(base, littleEndian),
+					cpuSubtype: view.getUint32(base + 4, littleEndian)
+				});
+			}
+			return {
+				status: "parsed",
+				slices
+			};
+		};
+		validateFatSlice = (declaration, containerSize, tableEnd, embedded) => {
+			const rangeIssue = inspectFatSliceRange(declaration, containerSize, tableEnd);
+			if (rangeIssue !== null) return rangeIssue.reason;
+			return embedded === undefined ? null : validateFatSliceIdentity(declaration, embedded);
+		};
+		inspectFatSliceRange = (declaration, containerSize, tableEnd) => {
+			const { index, offset, size, alignmentExponent } = declaration;
+			if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(size) || size <= 0 || offset < tableEnd) return {
+				category: "malformed",
+				reason: `FAT architecture ${index} has an invalid slice range`
+			};
+			if (offset > containerSize || size > containerSize - offset) return {
+				category: "malformed",
+				reason: `FAT architecture ${index} slice range extends beyond the file`
+			};
+			if (!Number.isInteger(alignmentExponent) || alignmentExponent < 0 || alignmentExponent > 52) return {
+				category: "unsupported",
+				reason: `FAT architecture ${index} alignment exponent ${alignmentExponent} is unsupported`
+			};
+			if (offset % 2 ** alignmentExponent !== 0) return {
+				category: "malformed",
+				reason: `FAT architecture ${index} offset is not aligned to 2^${alignmentExponent}`
+			};
+			return null;
+		};
+		validateFatSliceIdentity = (declaration, embedded) => embedded.cpuType === declaration.cpuType && embedded.cpuSubtype === declaration.cpuSubtype ? null : `FAT architecture ${declaration.index} CPU type/subtype disagrees with its Mach-O header`;
+		safeNumber = (value) => value > BigInt(Number.MAX_SAFE_INTEGER) ? null : Number(value);
+	})))();
+}
+
+//#endregion
+export { classifyFatContainerIdentity, init_machoContainer, readFatContainerHeader, readFatSliceDeclarations, validateFatSlice, validateFatSliceIdentity };