rea-agents 6.4.0 → 6.7.0

package/dist/mcp/canonicalDigest-Bi_0_zGi.js

@@ -0,0 +1,71 @@
+import { t as __esmMin } from "./rolldown-runtime-BjeaiXFo.js";
+import { createHash } from "node:crypto";
+
+//#region dist/domain/canonicalDigest.js
+var digestCanonicalValue, emitCanonical;
+function init_canonicalDigest() {
+	return (init_canonicalDigest = __esmMin((() => {
+		digestCanonicalValue = (value, context = "Comparison") => {
+			const hash = createHash("sha256");
+			let buffered = "";
+			const emit = (part) => {
+				buffered += part;
+				if (buffered.length >= 8192) {
+					hash.update(buffered);
+					buffered = "";
+				}
+			};
+			const encoded = emitCanonical(value, emit, new Set());
+			if (!encoded) throw new TypeError(`${context} could not canonicalize data`);
+			if (buffered) hash.update(buffered);
+			return hash.digest("hex");
+		};
+		emitCanonical = (value, emit, ancestors) => {
+			if (typeof value === "number" && !Number.isFinite(value)) throw new Error(Number.isNaN(value) ? "NaN is not allowed" : "Infinity is not allowed");
+			if (value === null || typeof value !== "object") {
+				const encoded = JSON.stringify(value);
+				if (encoded === undefined) return false;
+				emit(encoded);
+				return true;
+			}
+			if (ancestors.has(value)) throw new Error("Circular reference detected");
+			ancestors.add(value);
+			try {
+				if ("toJSON" in value && typeof value.toJSON === "function") {
+					const normalized = value.toJSON();
+					return emitCanonical(normalized, emit, ancestors);
+				}
+				if (Array.isArray(value)) {
+					emit("[");
+					const length = value.length;
+					for (let index = 0; index < length; index += 1) {
+						if (index > 0) emit(",");
+						if (!(index in value)) continue;
+						const item = value[index];
+						emitCanonical(item === undefined || typeof item === "symbol" ? null : item, emit, ancestors);
+					}
+					emit("]");
+				} else {
+					emit("{");
+					let first = true;
+					for (const key of Object.keys(value).sort()) {
+						if (Reflect.get(value, key) === undefined || typeof Reflect.get(value, key) === "symbol") continue;
+						const item = Reflect.get(value, key);
+						if (!first) emit(",");
+						first = false;
+						emit(JSON.stringify(key));
+						emit(":");
+						if (!emitCanonical(item, emit, ancestors)) emit("undefined");
+					}
+					emit("}");
+				}
+				return true;
+			} finally {
+				ancestors.delete(value);
+			}
+		};
+	})))();
+}
+
+//#endregion
+export { init_canonicalDigest as n, digestCanonicalValue as t };

package/dist/mcp/electronActiveObservation-DV0Ffy9X.js

@@ -0,0 +1,227 @@
+import { t as __esmMin } from "./rolldown-runtime-BjeaiXFo.js";
+import { r as localPathStringSchema, t as init_localPath } from "./localPath-AxvW9aPe.js";
+import { isAbsolute } from "node:path";
+import { z } from "zod";
+
+//#region dist/domain/javascript/electronActiveObservation.js
+var pathInputSchema, absolutePathSchema, windowIndexSchema, deepLinkUrlSchema, actionSchema, electronActiveObservationInputSchema, electronActiveTimelineEventSchema, ipcEventSchema, processMetricSchema, windowResultSchema, coverageSchema, actionResultContextShape, actionResultSchema, electronActiveObservationResultSchema;
+function init_electronActiveObservation() {
+	return (init_electronActiveObservation = __esmMin((() => {
+		init_localPath();
+		pathInputSchema = localPathStringSchema.refine(isAbsolute, { message: "Electron executable, application, and root paths must be absolute local filesystem paths (for example /Applications/Electron.app/Contents/MacOS/Electron)" });
+		absolutePathSchema = z.string().min(1).refine((value) => value.startsWith("/") || /^[A-Za-z]:[\\/]/u.test(value) || value.startsWith("\\\\"), "provider path must be absolute");
+		windowIndexSchema = z.number().int().min(0);
+		deepLinkUrlSchema = z.string().min(1).refine((value) => {
+			try {
+				return new URL(value).protocol.length > 0;
+			} catch (cause) {
+				void cause;
+				return false;
+			}
+		}, "deep-link url must be an absolute URL");
+		actionSchema = z.discriminatedUnion("kind", [
+			z.strictObject({
+				step_id: z.string().min(1),
+				kind: z.literal("click"),
+				selector: z.string().min(1),
+				window_index: windowIndexSchema.default(0)
+			}),
+			z.strictObject({
+				step_id: z.string().min(1),
+				kind: z.literal("wait"),
+				duration_ms: z.number().int().min(0),
+				window_index: windowIndexSchema.optional()
+			}),
+			z.strictObject({
+				step_id: z.string().min(1),
+				kind: z.literal("renderer-reload"),
+				window_index: windowIndexSchema.default(0)
+			}),
+			z.strictObject({
+				step_id: z.string().min(1),
+				kind: z.literal("renderer-crash"),
+				window_index: windowIndexSchema.default(0)
+			}),
+			z.strictObject({
+				step_id: z.string().min(1),
+				kind: z.literal("deep-link"),
+				delivery: z.enum(["open-url", "second-instance"]),
+				url: deepLinkUrlSchema
+			})
+		]);
+		electronActiveObservationInputSchema = z.strictObject({
+			executable_path: pathInputSchema.describe("Absolute local filesystem path for the Electron executable; relative paths are rejected."),
+			application_path: pathInputSchema.describe("Absolute local filesystem path for the Electron application; relative paths are rejected."),
+			application_root: pathInputSchema.optional().describe("Absolute local filesystem root for application-relative paths; omit to derive it from the application path. Relative paths are rejected."),
+			args: z.array(z.string().regex(/^[^\x00]*$/u, "Electron arguments must not contain NUL")).default([]),
+			actions: z.array(actionSchema).default([])
+		});
+		electronActiveTimelineEventSchema = z.strictObject({
+			sequence: z.number().int().min(1),
+			correlation_id: z.string().nullable(),
+			kind: z.enum([
+				"main-handler-invocation",
+				"main-event-invocation",
+				"ipc-observation-gap",
+				"utility-process-fork",
+				"utility-process-message",
+				"ipc-main-to-renderer",
+				"ipc-utility-to-main",
+				"ipc-renderer-send",
+				"ipc-renderer-invoke",
+				"ipc-renderer-post-message",
+				"app-lifecycle",
+				"window-lifecycle",
+				"web-contents-lifecycle",
+				"navigation",
+				"shell-attempt",
+				"process-lifecycle",
+				"permission",
+				"popup-attempt",
+				"download",
+				"protocol",
+				"preload",
+				"native-addon",
+				"updater",
+				"error"
+			]),
+			event: z.string().nullable(),
+			phase: z.enum([
+				"attempted",
+				"completed",
+				"blocked",
+				"failed",
+				"observed"
+			]),
+			channel: z.string().nullable(),
+			direction: z.enum([
+				"renderer-to-main",
+				"main-to-renderer",
+				"main-to-utility",
+				"utility-to-main"
+			]).nullable(),
+			sender: z.string().nullable(),
+			receiver: z.string().nullable(),
+			frame: z.string().nullable(),
+			target: z.string().nullable(),
+			argument_shapes: z.array(z.string()),
+			result_shape: z.string().nullable(),
+			process_type: z.string().nullable(),
+			source: z.string(),
+			capture_method: z.enum([
+				"api-wrapper",
+				"event-emitter",
+				"process-hook"
+			]),
+			artifact_path: z.string().nullable(),
+			artifact_sha256: z.string().regex(/^[a-f0-9]{64}$/u).nullable(),
+			error: z.boolean()
+		});
+		ipcEventSchema = electronActiveTimelineEventSchema.extend({ kind: z.enum([
+			"main-handler-invocation",
+			"main-event-invocation",
+			"utility-process-fork",
+			"utility-process-message",
+			"ipc-main-to-renderer",
+			"ipc-utility-to-main",
+			"ipc-renderer-send",
+			"ipc-renderer-invoke",
+			"ipc-renderer-post-message"
+		]) });
+		processMetricSchema = z.strictObject({
+			pid: z.number().int().min(1),
+			type: z.string().min(1),
+			name: z.string().nullable(),
+			service_name: z.string().nullable()
+		});
+		windowResultSchema = z.strictObject({
+			window_id: z.string(),
+			web_contents_id: z.string(),
+			url: z.string(),
+			title: z.string(),
+			visible: z.boolean().nullable(),
+			destroyed: z.boolean()
+		});
+		coverageSchema = z.strictObject({
+			status: z.enum([
+				"complete",
+				"partial_attach",
+				"hook_conflict",
+				"target_exited",
+				"cleanup_failed"
+			]),
+			observed_event_families: z.array(z.string()),
+			unavailable_event_families: z.array(z.string()),
+			observed_roles: z.array(z.string()),
+			pre_capture_activity: z.literal("unavailable")
+		});
+		actionResultContextShape = {
+			step_id: z.string().min(1),
+			kind: z.enum([
+				"click",
+				"wait",
+				"renderer-reload",
+				"renderer-crash",
+				"deep-link"
+			]),
+			window_index: windowIndexSchema.nullable(),
+			target: z.string().nullable(),
+			elapsed_ms: z.number().int().min(0)
+		};
+		actionResultSchema = z.discriminatedUnion("status", [z.strictObject({
+			...actionResultContextShape,
+			status: z.literal("completed"),
+			error: z.null()
+		}), z.strictObject({
+			...actionResultContextShape,
+			status: z.enum(["failed", "cancelled"]),
+			error: z.string()
+		})]);
+		electronActiveObservationResultSchema = z.strictObject({
+			application: z.strictObject({
+				executable_path: absolutePathSchema,
+				application_path: absolutePathSchema,
+				electron_version: z.string().min(1),
+				process_ownership: z.literal("provider-owned"),
+				cleanup: z.literal("terminated-owned-process")
+			}),
+			actions: z.array(actionResultSchema),
+			windows: z.array(windowResultSchema),
+			processes: z.strictObject({ items: z.array(processMetricSchema) }),
+			ipc: z.strictObject({
+				events: z.array(ipcEventSchema),
+				observed: z.number().int().min(0),
+				dropped: z.number().int().min(0)
+			}),
+			timeline: z.strictObject({
+				events: z.array(electronActiveTimelineEventSchema),
+				observed: z.number().int().min(0),
+				dropped: z.number().int().min(0)
+			}),
+			retention: z.strictObject({
+				budget_bytes: z.number().int().min(0),
+				estimated_retained_bytes: z.number().int().min(0),
+				event_serialized_byte_upper_bound: z.number().int().min(0),
+				retained: z.number().int().min(0),
+				dropped: z.number().int().min(0),
+				dropped_event_families: z.array(z.strictObject({
+					family: z.string().min(1),
+					count: z.number().int().min(1)
+				})),
+				dropped_event_roles: z.array(z.strictObject({
+					role: z.string().min(1),
+					count: z.number().int().min(1)
+				})),
+				observed_ipc: z.number().int().min(0),
+				dropped_ipc: z.number().int().min(0),
+				observed_runtime: z.number().int().min(0),
+				dropped_runtime: z.number().int().min(0)
+			}),
+			coverage: coverageSchema,
+			limitations: z.array(z.string())
+		});
+	})))();
+}
+
+//#endregion
+export { init_electronActiveObservation as i, electronActiveObservationResultSchema as n, electronActiveTimelineEventSchema as r, electronActiveObservationInputSchema as t };

package/dist/mcp/electronFuses-D5SS7XXw.js

@@ -0,0 +1,367 @@
+import { t as __esmMin } from "./rolldown-runtime-BjeaiXFo.js";
+import { m as init_digests, p as digestSchema } from "./analysisErrorCore-BIEP7tvF.js";
+import { r as localPathStringSchema, t as init_localPath } from "./localPath-AxvW9aPe.js";
+import { z } from "zod";
+
+//#region dist/domain/apple/machoCpuIdentity.js
+var CPU_SUBTYPE_CAPABILITY_MASK, machoCpuSubtypeBase;
+function init_machoCpuIdentity() {
+	return (init_machoCpuIdentity = __esmMin((() => {
+		CPU_SUBTYPE_CAPABILITY_MASK = 4278190080;
+		machoCpuSubtypeBase = (cpuSubtype) => cpuSubtype & ~CPU_SUBTYPE_CAPABILITY_MASK;
+	})))();
+}
+
+//#endregion
+//#region dist/domain/electron/electronFuses.js
+var ELECTRON_FUSE_SENTINEL, ELECTRON_FUSE_STATE_BYTES, ELECTRON_FUSE_V1_NAMES, FUSE_IMPLICATIONS, OTHER_MEANS_LIMITATION, MISSING_SENTINEL_LIMITATION, byteSchema, fuseStateSchema, electronFuseSchema, electronFuseSentinelSchema, electronFuseSliceSchema, implicationLocation, electronFuseImplicationSchema, electronFuseReportSchema, inspectElectronFusesInputSchema, electronFuseState, electronFuseName, describeElectronFuseFindings, embeddedAsarIntegrityApplies, describeSentinel, implicationFor, validateReportBounds, implicationKey, validateSentinel;
+function init_electronFuses() {
+	return (init_electronFuses = __esmMin((() => {
+		init_digests();
+		init_localPath();
+		ELECTRON_FUSE_SENTINEL = "dL7pKGdnNz796PbbjQWNKmHXBZaB9tsX";
+		ELECTRON_FUSE_STATE_BYTES = {
+			disabled: 48,
+			enabled: 49,
+			removed: 114
+		};
+		ELECTRON_FUSE_V1_NAMES = [
+			"RunAsNode",
+			"EnableCookieEncryption",
+			"EnableNodeOptionsEnvironmentVariable",
+			"EnableNodeCliInspectArguments",
+			"EnableEmbeddedAsarIntegrityValidation",
+			"OnlyLoadAppFromAsar",
+			"LoadBrowserProcessSpecificV8Snapshot",
+			"GrantFileProtocolExtraPrivileges",
+			"WasmTrapHandlers"
+		];
+		FUSE_IMPLICATIONS = [
+			{
+				subject: "node_cli_inspect_arguments",
+				fuseIndex: 3,
+				enabled: "honored",
+				inactive: "not_honored"
+			},
+			{
+				subject: "electron_run_as_node",
+				fuseIndex: 0,
+				enabled: "honored",
+				inactive: "not_honored"
+			},
+			{
+				subject: "embedded_asar_integrity_validation",
+				fuseIndex: 4,
+				enabled: "enforced",
+				inactive: "not_enforced"
+			},
+			{
+				subject: "only_load_app_from_asar",
+				fuseIndex: 5,
+				enabled: "restricted_to_app_asar",
+				inactive: "not_restricted_to_app_asar"
+			}
+		];
+		OTHER_MEANS_LIMITATION = "Fuse state does not prove the application enables Inspector through other means, such as app.commandLine or a remote-debugging switch in application code.";
+		MISSING_SENTINEL_LIMITATION = "A missing sentinel means fuse state is unknown, not that every fuse is disabled.";
+		byteSchema = z.number().int().min(0).max(255);
+		fuseStateSchema = z.enum([
+			"enabled",
+			"disabled",
+			"removed",
+			"unknown"
+		]);
+		electronFuseSchema = z.strictObject({
+			index: z.number().int().nonnegative(),
+			name: z.string().min(1).nullable(),
+			state: fuseStateSchema,
+			raw_byte: byteSchema
+		});
+		electronFuseSentinelSchema = z.strictObject({
+			sentinel_offset: z.number().int().nonnegative(),
+			wire_version: byteSchema.nullable(),
+			declared_length: byteSchema.nullable(),
+			fuses: z.array(electronFuseSchema),
+			complete: z.boolean()
+		});
+		electronFuseSliceSchema = z.strictObject({
+			index: z.number().int().nonnegative(),
+			file_offset: z.number().int().nonnegative(),
+			size: z.number().int().nonnegative(),
+			architecture: z.string().min(1).nullable(),
+			sentinel_count: z.number().int().nonnegative(),
+			sentinels: z.array(electronFuseSentinelSchema)
+		});
+		implicationLocation = {
+			relationship: z.literal("derivation"),
+			slice_index: z.number().int().nonnegative(),
+			sentinel_offset: z.number().int().nonnegative()
+		};
+		electronFuseImplicationSchema = z.discriminatedUnion("subject", [
+			z.strictObject({
+				...implicationLocation,
+				subject: z.literal("node_cli_inspect_arguments"),
+				fuse_index: z.literal(3),
+				outcome: z.enum([
+					"honored",
+					"not_honored",
+					"unknown"
+				])
+			}),
+			z.strictObject({
+				...implicationLocation,
+				subject: z.literal("electron_run_as_node"),
+				fuse_index: z.literal(0),
+				outcome: z.enum([
+					"honored",
+					"not_honored",
+					"unknown"
+				])
+			}),
+			z.strictObject({
+				...implicationLocation,
+				subject: z.literal("embedded_asar_integrity_validation"),
+				fuse_index: z.literal(4),
+				outcome: z.enum([
+					"enforced",
+					"not_enforced",
+					"unknown"
+				])
+			}),
+			z.strictObject({
+				...implicationLocation,
+				subject: z.literal("only_load_app_from_asar"),
+				fuse_index: z.literal(5),
+				outcome: z.enum([
+					"restricted_to_app_asar",
+					"not_restricted_to_app_asar",
+					"unknown"
+				])
+			})
+		]);
+		electronFuseReportSchema = z.strictObject({
+			artifact: z.strictObject({
+				selected_path: localPathStringSchema,
+				resolved_path: localPathStringSchema,
+				sha256: digestSchema,
+				bytes: z.number().int().nonnegative(),
+				format: z.enum([
+					"mach-o",
+					"mach-o-universal",
+					"pe",
+					"elf"
+				])
+			}).describe("Caller-selected path, resolved regular file, and the container that was read"),
+			slices: z.array(electronFuseSliceSchema).describe("One entry per universal Mach-O slice, or a single entry for a thin Mach-O, PE, or ELF file. Sentinel offsets are file-absolute."),
+			runtime_implications: z.array(electronFuseImplicationSchema).describe("Derivations from version-1 fuse bytes. Each entry names the fuse index it came from."),
+			limitations: z.array(z.string().min(1))
+		}).superRefine((report, context) => {
+			validateReportBounds(report, context);
+		});
+		inspectElectronFusesInputSchema = z.strictObject({ path: localPathStringSchema.describe("Absolute filesystem path to a macOS .app bundle, Electron Framework binary, Windows PE executable, or Linux ELF executable") });
+		electronFuseState = (byte) => {
+			if (byte === ELECTRON_FUSE_STATE_BYTES.disabled) return "disabled";
+			if (byte === ELECTRON_FUSE_STATE_BYTES.enabled) return "enabled";
+			if (byte === ELECTRON_FUSE_STATE_BYTES.removed) return "removed";
+			return "unknown";
+		};
+		electronFuseName = (wireVersion, index) => wireVersion === 1 ? ELECTRON_FUSE_V1_NAMES[index] ?? null : null;
+		describeElectronFuseFindings = (slices, container) => {
+			const runtime_implications = [];
+			const limitations = [OTHER_MEANS_LIMITATION, MISSING_SENTINEL_LIMITATION];
+			for (const slice of slices) {
+				if (slice.sentinel_count === 0) limitations.push(`Slice ${slice.index} at file offset ${slice.file_offset} contains no Electron fuse sentinel; fuse state for that slice is unknown, not disabled.`);
+				else if (slice.sentinel_count > 1) limitations.push(`Slice ${slice.index} at file offset ${slice.file_offset} contains ${slice.sentinel_count} Electron fuse sentinels; every sentinel is reported and none is selected.`);
+				for (const sentinel of slice.sentinels) describeSentinel(slice.index, sentinel, container, runtime_implications, limitations);
+			}
+			return {
+				runtime_implications,
+				limitations
+			};
+		};
+		embeddedAsarIntegrityApplies = (container) => container === "mach-o" || container === "mach-o-universal" || container === "pe";
+		describeSentinel = (sliceIndex, sentinel, container, implications, limitations) => {
+			if (!sentinel.complete) limitations.push(`Electron fuse wire at file offset ${sentinel.sentinel_offset} is truncated; fuse bytes past the slice stay unknown.`);
+			if (sentinel.wire_version === null) return;
+			if (sentinel.wire_version !== 1) {
+				limitations.push(`Electron fuse wire at file offset ${sentinel.sentinel_offset} uses wire version ${sentinel.wire_version}; version 1 is the only pinned name table, so runtime implications for this wire are unknown.`);
+				return;
+			}
+			for (const spec of FUSE_IMPLICATIONS) {
+				const fuse = sentinel.fuses.find((item) => item.index === spec.fuseIndex);
+				if (fuse === undefined) {
+					limitations.push(`Electron fuse wire at file offset ${sentinel.sentinel_offset} does not include fuse index ${spec.fuseIndex}; that runtime implication is unknown.`);
+					continue;
+				}
+				const applicabilityUnknown = spec.subject === "embedded_asar_integrity_validation" && !embeddedAsarIntegrityApplies(container);
+				if (applicabilityUnknown) limitations.push(`Electron compiles embedded ASAR integrity validation only on macOS and Windows; the observed fuse byte at file offset ${sentinel.sentinel_offset} does not establish enforcement.`);
+				implications.push(implicationFor(spec, applicabilityUnknown ? "unknown" : fuse.state, {
+					slice_index: sliceIndex,
+					sentinel_offset: sentinel.sentinel_offset
+				}));
+			}
+		};
+		implicationFor = (spec, state, location) => {
+			const outcome = state === "enabled" ? spec.enabled : state === "unknown" ? "unknown" : spec.inactive;
+			return {
+				relationship: "derivation",
+				subject: spec.subject,
+				fuse_index: spec.fuseIndex,
+				outcome,
+				...location
+			};
+		};
+		validateReportBounds = (report, context) => {
+			const size = report.artifact.bytes;
+			for (const [sliceIndex, slice] of report.slices.entries()) {
+				if (slice.index !== sliceIndex) context.addIssue({
+					code: "custom",
+					path: [
+						"slices",
+						sliceIndex,
+						"index"
+					],
+					message: "Slice index does not match its position in the report."
+				});
+				if (slice.sentinel_count !== slice.sentinels.length) context.addIssue({
+					code: "custom",
+					path: [
+						"slices",
+						sliceIndex,
+						"sentinel_count"
+					],
+					message: "Sentinel count does not match the reported sentinels."
+				});
+				if (slice.file_offset > size || slice.size > size - slice.file_offset) context.addIssue({
+					code: "custom",
+					path: ["slices", sliceIndex],
+					message: "Slice range extends outside the selected artifact."
+				});
+				for (const [sentinelIndex, sentinel] of slice.sentinels.entries()) validateSentinel(slice, sentinel, sliceIndex, sentinelIndex, context);
+			}
+			const expected = new Set(describeElectronFuseFindings(report.slices, report.artifact.format).runtime_implications.map(implicationKey));
+			for (const [index, implication] of report.runtime_implications.entries()) {
+				if (!expected.has(implicationKey(implication))) context.addIssue({
+					code: "custom",
+					path: ["runtime_implications", index],
+					message: "Runtime implication is not supported by the reported fuse bytes and applicability."
+				});
+				const slice = report.slices[implication.slice_index];
+				if (slice?.sentinels.some((sentinel) => sentinel.sentinel_offset === implication.sentinel_offset) !== true) context.addIssue({
+					code: "custom",
+					path: ["runtime_implications", index],
+					message: "Runtime implication does not reference a reported sentinel."
+				});
+			}
+		};
+		implicationKey = (fact) => JSON.stringify([
+			fact.slice_index,
+			fact.sentinel_offset,
+			fact.subject,
+			fact.fuse_index,
+			fact.outcome
+		]);
+		validateSentinel = (slice, sentinel, sliceIndex, sentinelIndex, context) => {
+			const sentinelEnd = sentinel.sentinel_offset + ELECTRON_FUSE_SENTINEL.length;
+			const wireEnd = sentinelEnd + (sentinel.wire_version === null ? 0 : 1) + (sentinel.declared_length === null ? 0 : 1) + sentinel.fuses.length;
+			if (wireEnd > slice.file_offset + slice.size) context.addIssue({
+				code: "custom",
+				path: [
+					"slices",
+					sliceIndex,
+					"sentinels",
+					sentinelIndex
+				],
+				message: "Reported wire header or fuse bytes extend outside the slice."
+			});
+			if (sentinel.sentinel_offset < slice.file_offset || sentinelEnd > slice.file_offset + slice.size) context.addIssue({
+				code: "custom",
+				path: [
+					"slices",
+					sliceIndex,
+					"sentinels",
+					sentinelIndex,
+					"sentinel_offset"
+				],
+				message: "Sentinel is outside its slice."
+			});
+			if (sentinel.wire_version === null && sentinel.declared_length !== null) context.addIssue({
+				code: "custom",
+				path: [
+					"slices",
+					sliceIndex,
+					"sentinels",
+					sentinelIndex,
+					"declared_length"
+				],
+				message: "A wire without a version byte cannot declare a fuse count."
+			});
+			if (sentinel.complete && (sentinel.declared_length === null || sentinel.fuses.length !== sentinel.declared_length)) context.addIssue({
+				code: "custom",
+				path: [
+					"slices",
+					sliceIndex,
+					"sentinels",
+					sentinelIndex,
+					"complete"
+				],
+				message: "A complete wire must contain every declared fuse byte."
+			});
+			if (!sentinel.complete && sentinel.declared_length !== null && sentinel.fuses.length >= sentinel.declared_length) context.addIssue({
+				code: "custom",
+				path: [
+					"slices",
+					sliceIndex,
+					"sentinels",
+					sentinelIndex,
+					"complete"
+				],
+				message: "An incomplete wire must omit at least one declared fuse byte."
+			});
+			for (const [fuseIndex, fuse] of sentinel.fuses.entries()) {
+				if (fuse.index !== fuseIndex) context.addIssue({
+					code: "custom",
+					path: [
+						"slices",
+						sliceIndex,
+						"sentinels",
+						sentinelIndex,
+						"fuses",
+						fuseIndex,
+						"index"
+					],
+					message: "Fuse index does not match its wire position."
+				});
+				if (fuse.state !== electronFuseState(fuse.raw_byte)) context.addIssue({
+					code: "custom",
+					path: [
+						"slices",
+						sliceIndex,
+						"sentinels",
+						sentinelIndex,
+						"fuses",
+						fuseIndex,
+						"state"
+					],
+					message: "Fuse state does not match its raw byte."
+				});
+				if (sentinel.wire_version !== null && fuse.name !== electronFuseName(sentinel.wire_version, fuse.index)) context.addIssue({
+					code: "custom",
+					path: [
+						"slices",
+						sliceIndex,
+						"sentinels",
+						sentinelIndex,
+						"fuses",
+						fuseIndex,
+						"name"
+					],
+					message: "Fuse name does not match the pinned version-1 table."
+				});
+			}
+		};
+	})))();
+}
+
+//#endregion
+export { electronFuseState as a, init_machoCpuIdentity as c, electronFuseReportSchema as i, machoCpuSubtypeBase as l, describeElectronFuseFindings as n, init_electronFuses as o, electronFuseName as r, inspectElectronFusesInputSchema as s, ELECTRON_FUSE_SENTINEL as t };