rea-agents 6.4.0 → 6.7.0

package/dist/mcp/javascriptRuntimeObservation-Cu0Yedqq.js

@@ -0,0 +1,121 @@
+import { t as __esmMin } from "./rolldown-runtime-BjeaiXFo.js";
+import { g as prefixedDigestSchema, m as init_digests } from "./analysisErrorCore-BIEP7tvF.js";
+import { a as browserEndpointSchema, c as init_browserObservation } from "./webContentArtifact-DfGkgDcI.js";
+import { z } from "zod";
+
+//#region dist/domain/javascript/javascriptRuntimeObservation.js
+var observationTextSchema, runtimeEndpoint, listJavaScriptRuntimeTargetsInputSchema, javascriptRuntimeKindSchema, observedJavaScriptRuntimeKindSchema, observeJavaScriptRuntimeInputSchema, javascriptRuntimeVersionSchema, javascriptRuntimeLocationSchema, javascriptRuntimeUnresolvedLocationSchema, javascriptRuntimeTargetLocationSchema, javascriptRuntimeTargetSchema, javascriptRuntimeTargetListSchema, javascriptRuntimeScriptSchema, javascriptRuntimeContextSchema, javascriptRuntimeObservationSchema;
+function init_javascriptRuntimeObservation() {
+	return (init_javascriptRuntimeObservation = __esmMin((() => {
+		init_browserObservation();
+		init_digests();
+		observationTextSchema = z.string().min(1);
+		runtimeEndpoint = { inspector_endpoint: browserEndpointSchema };
+		listJavaScriptRuntimeTargetsInputSchema = z.strictObject({ ...runtimeEndpoint });
+		javascriptRuntimeKindSchema = z.enum([
+			"node",
+			"electron-main",
+			"electron-preload",
+			"electron-renderer"
+		]);
+		observedJavaScriptRuntimeKindSchema = javascriptRuntimeKindSchema.or(z.literal("unknown"));
+		observeJavaScriptRuntimeInputSchema = z.strictObject({
+			...runtimeEndpoint,
+			target_id: z.string().trim().min(1),
+			runtime_kind: javascriptRuntimeKindSchema.optional(),
+			observation_ms: z.number().int().min(0).default(100)
+		});
+		javascriptRuntimeVersionSchema = z.strictObject({
+			product: z.string().min(1),
+			protocol_version: z.string().min(1),
+			v8_version: z.string().nullable()
+		});
+		javascriptRuntimeLocationSchema = z.discriminatedUnion("kind", [
+			z.strictObject({
+				kind: z.literal("file"),
+				file_path: z.string().min(1)
+			}),
+			z.strictObject({
+				kind: z.literal("url"),
+				origin: z.string().min(1),
+				sanitized_url: z.string().min(1)
+			}),
+			z.strictObject({
+				kind: z.literal("builtin"),
+				specifier: z.string().min(1)
+			})
+		]);
+		javascriptRuntimeUnresolvedLocationSchema = z.strictObject({
+			kind: z.literal("unresolved"),
+			reported_url: z.string().describe("Raw Inspector URL, which may be empty for anonymous or evaluated code."),
+			reason: z.enum(["unverifiable-file-location", "location-authorization-not-attempted"])
+		});
+		javascriptRuntimeTargetLocationSchema = z.union([javascriptRuntimeLocationSchema, javascriptRuntimeUnresolvedLocationSchema]);
+		javascriptRuntimeTargetSchema = z.strictObject({
+			target_id: z.string().min(1),
+			protocol_type: z.string().min(1),
+			attached: z.boolean().nullable().describe("Discovery-reported debugger attachment state; null means unknown"),
+			location: javascriptRuntimeTargetLocationSchema
+		});
+		javascriptRuntimeTargetListSchema = z.strictObject({
+			runtime: javascriptRuntimeVersionSchema,
+			targets: z.array(javascriptRuntimeTargetSchema),
+			excluded: z.strictObject({
+				unsupported_location: z.number().int().min(0),
+				unconnectable: z.number().int().min(0)
+			}),
+			limitations: z.array(observationTextSchema)
+		});
+		javascriptRuntimeScriptSchema = z.strictObject({
+			script_key: prefixedDigestSchema("v8_script"),
+			location: javascriptRuntimeTargetLocationSchema,
+			execution_context_key: z.string().nullable(),
+			cdp_hash: z.string().nullable(),
+			length: z.number().int().min(0).nullable().describe("Producer-reported script length; null when unavailable."),
+			is_module: z.boolean().nullable().describe("Producer-reported module classification; null when unavailable."),
+			status: z.literal("observed-loaded")
+		});
+		javascriptRuntimeContextSchema = z.strictObject({
+			context_key: z.string().min(1),
+			state: z.enum([
+				"created",
+				"destroyed",
+				"cleared"
+			]),
+			name: z.string().nullable(),
+			origin: z.string().nullable()
+		});
+		javascriptRuntimeObservationSchema = z.strictObject({
+			runtime: javascriptRuntimeVersionSchema,
+			target: javascriptRuntimeTargetSchema.extend({
+				runtime_kind: observedJavaScriptRuntimeKindSchema,
+				runtime_kind_authority: z.enum(["caller-declared-unverified", "not-declared"])
+			}),
+			capture: z.strictObject({
+				observation_ms: z.number().int().min(0),
+				events_observed: z.number().int().min(0),
+				events_retained: z.number().int().min(0),
+				events_dropped: z.number().int().min(0),
+				metadata_bytes_retained: z.number().int().min(0),
+				truncated: z.boolean(),
+				truncation_reasons: z.array(observationTextSchema)
+			}),
+			scripts: z.strictObject({
+				items: z.array(javascriptRuntimeScriptSchema),
+				observed_total: z.number().int().min(0),
+				excluded: z.strictObject({
+					unsupported_location: z.number().int().min(0),
+					invalid_protocol_value: z.number().int().min(0)
+				})
+			}),
+			execution_contexts: z.array(javascriptRuntimeContextSchema),
+			directly_observed: z.array(observationTextSchema),
+			unavailable_without_instrumentation: z.array(observationTextSchema),
+			unknowns: z.array(observationTextSchema),
+			limitations: z.array(observationTextSchema)
+		});
+	})))();
+}
+
+//#endregion
+export { javascriptRuntimeUnresolvedLocationSchema as a, javascriptRuntimeTargetListSchema as i, javascriptRuntimeKindSchema as n, listJavaScriptRuntimeTargetsInputSchema as o, javascriptRuntimeObservationSchema as r, observeJavaScriptRuntimeInputSchema as s, init_javascriptRuntimeObservation as t };

package/dist/mcp/jsonSerialization-V-wWiFRE.js

@@ -0,0 +1,152 @@
+import { t as __esmMin } from "./rolldown-runtime-BjeaiXFo.js";
+
+//#region dist/domain/jsonSerialization.js
+/** Encode ordinary JSON as bounded string parts without a document-sized allocation. */
+function* jsonParts(value, pretty = false) {
+	yield* encodeValue(value, pretty, false);
+}
+/** Encode validated JSON with canonical key ordering without allocating the whole document. */
+function* canonicalJsonParts(value) {
+	yield* encodeValue(value, false, true);
+}
+/** Buffer JSON parts while preserving complete UTF-16 surrogate pairs. */
+function* bufferedJsonParts(parts) {
+	let buffer = "";
+	for (const part of parts) {
+		if (buffer.length + part.length > 64 * 1024 && buffer !== "") {
+			yield buffer;
+			buffer = "";
+		}
+		buffer += part;
+	}
+	if (buffer !== "") yield buffer;
+}
+function* encodeString(value) {
+	if (value.length <= 8192) {
+		yield JSON.stringify(value);
+		return;
+	}
+	yield "\"";
+	for (let start = 0; start < value.length;) {
+		let end = Math.min(start + 8192, value.length);
+		const last = value.charCodeAt(end - 1);
+		const next = value.charCodeAt(end);
+		if (end < value.length && last >= 55296 && last <= 56319 && next >= 56320 && next <= 57343) end -= 1;
+		yield JSON.stringify(value.slice(start, end)).slice(1, -1);
+		start = end;
+	}
+	yield "\"";
+}
+/**
+* Encode iteratively into bounded parts. Recursive `yield*` delegation passed
+* every token through one generator frame per nesting level, which dominated
+* the cost of writing large nested results.
+*/
+function* encodeValue(root, pretty, canonical) {
+	const ancestors = new Set();
+	const stack = [];
+	let buffer = "";
+	let pending = root;
+	let hasPending = true;
+	while (true) {
+		if (hasPending) {
+			hasPending = false;
+			const text = scalarText(pending);
+			if (text !== undefined) buffer += text;
+			else if (typeof pending === "string") {
+				if (buffer !== "") yield buffer;
+				buffer = "";
+				yield* encodeString(pending);
+			} else {
+				const frame = openContainer(pending, stack.length, ancestors, canonical);
+				stack.push(frame);
+				buffer += frame.array ? "[" : "{";
+			}
+		}
+		if (buffer.length >= PART_CHARACTERS) {
+			yield buffer;
+			buffer = "";
+		}
+		const frame = stack.at(-1);
+		if (frame === undefined) break;
+		const member = nextMember(frame);
+		if (member === undefined) {
+			if (pretty && frame.written > 0) buffer += indent(frame.depth);
+			buffer += frame.array ? "]" : "}";
+			ancestors.delete(frame.value);
+			stack.pop();
+			continue;
+		}
+		if (frame.written > 0) buffer += ",";
+		if (pretty) buffer += indent(frame.depth + 1);
+		if (member.key !== undefined) {
+			const key = scalarText(member.key);
+			if (key !== undefined) buffer += key;
+			else {
+				if (buffer !== "") yield buffer;
+				buffer = "";
+				yield* encodeString(member.key);
+			}
+			buffer += pretty ? ": " : ":";
+		}
+		frame.written += 1;
+		pending = member.item;
+		hasPending = true;
+	}
+	if (buffer !== "") yield buffer;
+}
+var PART_CHARACTERS, indentation, indent, scalarText, openContainer, nextMember;
+function init_jsonSerialization() {
+	return (init_jsonSerialization = __esmMin((() => {
+		PART_CHARACTERS = 16 * 1024;
+		indentation = [];
+		indent = (depth) => indentation[depth] ??= `\n${"  ".repeat(depth)}`;
+		scalarText = (value) => {
+			if (typeof value === "string") return value.length <= 8192 ? JSON.stringify(value) : undefined;
+			if (value === null) return "null";
+			if (typeof value === "boolean") return String(value);
+			if (typeof value === "number" && Number.isFinite(value)) return String(value);
+			return undefined;
+		};
+		openContainer = (value, depth, ancestors, canonical) => {
+			if (typeof value !== "object" || value === null) throw new TypeError("JSON output requires ordinary JSON values");
+			if (ancestors.has(value)) throw new TypeError("JSON output contains a circular reference");
+			const array = Array.isArray(value);
+			if (!array && Object.prototype.toString.call(value) !== "[object Object]") throw new TypeError("JSON output requires ordinary JSON objects");
+			ancestors.add(value);
+			const keys = array ? undefined : Object.keys(value);
+			if (canonical) keys?.sort();
+			const count = array ? value.length : keys?.length ?? 0;
+			return {
+				value,
+				array,
+				keys,
+				count,
+				depth,
+				index: 0,
+				written: 0
+			};
+		};
+		nextMember = (frame) => {
+			while (frame.index < frame.count) {
+				const index = frame.index;
+				frame.index += 1;
+				if (frame.array) return {
+					key: undefined,
+					item: Reflect.get(frame.value, index)
+				};
+				const key = frame.keys?.[index];
+				if (key === undefined) throw new TypeError("JSON object changed during serialization");
+				const item = Reflect.get(frame.value, key);
+				if (item !== undefined && typeof item !== "function" && typeof item !== "symbol") return {
+					key,
+					item
+				};
+			}
+			return undefined;
+		};
+	})))();
+}
+
+//#endregion
+export { jsonParts as i, canonicalJsonParts as n, init_jsonSerialization as r, bufferedJsonParts as t };

package/dist/mcp/lipo-DSTgUqL1.js

@@ -0,0 +1,395 @@
+import { t as __esmMin } from "./rolldown-runtime-BjeaiXFo.js";
+import { a as runOwnedCommand, b as init_snapshotEnvironment, n as init_OwnedCommand, t as OwnedCommandFailure, x as snapshotEnvironment } from "./OwnedCommand-BW1jBSt9.js";
+import { A as err, M as ok, j as init_result } from "./analysisErrorCore-BIEP7tvF.js";
+import { D as init_DarwinProcessRunTokenReader, O as boundedUtf8Text, T as DarwinProcessOwnershipInspectionError, k as init_boundedUtf8Text } from "./ArtifactFileOperation-64cQKI7B.js";
+import { c as init_machoCpuIdentity, l as machoCpuSubtypeBase } from "./electronFuses-D5SS7XXw.js";
+import { createReadStream } from "node:fs";
+import { z } from "zod";
+import { realpath } from "node:fs/promises";
+import { createHash, randomUUID } from "node:crypto";
+
+//#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 NativeCommandFailure extends Error {
+			tool;
+			reason;
+			exitCode;
+			capture;
+			cleanupFailure;
+			cleanupResources;
+			cleanupOwner;
+			cleanupFailures;
+			detail;
+			preparationFailure;
+			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.preparationFailure = options?.cause instanceof DarwinProcessOwnershipInspectionError ? options.cause : options?.cause instanceof NativeCommandFailure || options?.cause instanceof OwnedCommandFailure ? options.cause.preparationFailure : undefined;
+				this.detail = options?.detail ?? this.preparationFailure?.message ?? 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, cause instanceof DarwinProcessOwnershipInspectionError && cause.cancellation !== undefined ? "cancelled" : "io", null, { cause }));
+			}
+		};
+		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 { NativeCommandFailure as a, init_CommandRunner as c, NATIVE_COMMAND_TIMEOUT_MS as i, resolveXcrunTool as l, parseLipoOutput as n, XcrunCommandRunner as o, NATIVE_COMMAND_OUTPUT_BUDGET_BYTES as r, failureCapture as s, init_lipo as t };

package/dist/mcp/localPath-AxvW9aPe.js

@@ -0,0 +1,19 @@
+import { t as __esmMin } from "./rolldown-runtime-BjeaiXFo.js";
+import { isAbsolute, relative, sep } from "node:path";
+import { z } from "zod";
+
+//#region dist/domain/localPath.js
+var nulFreeStringSchema, localPathStringSchema, isPathWithinRoot;
+function init_localPath() {
+	return (init_localPath = __esmMin((() => {
+		nulFreeStringSchema = z.string().regex(/^[^\x00]*$/u, "Local filesystem paths cannot contain NUL");
+		localPathStringSchema = nulFreeStringSchema.min(1);
+		isPathWithinRoot = (root, path) => {
+			const value = relative(root, path);
+			return value === "" || value !== ".." && !value.startsWith(`..${sep}`) && !isAbsolute(value);
+		};
+	})))();
+}
+
+//#endregion
+export { nulFreeStringSchema as i, isPathWithinRoot as n, localPathStringSchema as r, init_localPath as t };