rea-agents 6.5.0 → 6.7.0

package/dist/mcp/ProcedureAddressResolution-H6Qwpb_Y.js

@@ -0,0 +1,59 @@
+import { t as __esmMin } from "./rolldown-runtime-BjeaiXFo.js";
+import { A as err, M as ok, f as init_analysisErrorCore, j as init_result, s as AnalysisOutputError } from "./analysisErrorCore-BIEP7tvF.js";
+import { l as init_unicodeCodePointOrder, s as compareUnicodeCodePoints } from "./providerOperationHealth-9DRSGM8N.js";
+
+//#region dist/application/SourceLimitations.js
+var sourceLimitationKey, renderSourceLimitations;
+function init_SourceLimitations() {
+	return (init_SourceLimitations = __esmMin((() => {
+		init_unicodeCodePointOrder();
+		sourceLimitationKey = ({ provider, operation, limitation }) => JSON.stringify([
+			provider.id,
+			provider.name,
+			provider.version,
+			operation,
+			limitation
+		]);
+		renderSourceLimitations = (limitations) => {
+			const groups = new Map();
+			for (const { provider, operation, limitation } of limitations) {
+				const key = JSON.stringify([
+					provider.id,
+					provider.name,
+					provider.version,
+					limitation
+				]);
+				const group = groups.get(key) ?? {
+					provider,
+					limitation,
+					operations: new Set()
+				};
+				group.operations.add(operation);
+				groups.set(key, group);
+			}
+			return [...groups.values()].map(({ provider, limitation, operations }) => {
+				const version = provider.version === null ? "" : ` ${provider.version}`;
+				const operationList = [...operations].sort(compareUnicodeCodePoints);
+				return `${provider.name} (${provider.id}${version}) ${operationList.join(", ")}: ${limitation}`;
+			}).sort(compareUnicodeCodePoints);
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/application/ProcedureAddressResolution.js
+var resolveProcedureAddress;
+function init_ProcedureAddressResolution() {
+	return (init_ProcedureAddressResolution = __esmMin((() => {
+		init_analysisErrorCore();
+		init_result();
+		resolveProcedureAddress = async (call, procedure, signal) => {
+			const result = await call("procedure_address", { procedure }, signal);
+			if (!result.ok) return result;
+			return typeof result.value === "string" && result.value.length > 0 ? ok(result.value) : err(new AnalysisOutputError("procedure_address", "provider returned no canonical procedure address"));
+		};
+	})))();
+}
+
+//#endregion
+export { sourceLimitationKey as a, renderSourceLimitations as i, resolveProcedureAddress as n, init_SourceLimitations as r, init_ProcedureAddressResolution as t };

package/dist/mcp/{WorkflowEvidence-umWrB_wm.js → WorkflowEvidence-CO4C7ALz.js}

@@ -1,9 +1,9 @@
 import { t as __esmMin } from "./rolldown-runtime-BjeaiXFo.js";
-import { _ as ok, g as init_result } from "./analysisErrorCore-DXRTvF_m.js";
-import { i as init_unknownRegistryError, r as UnknownRegistryError } from "./analysisErrorProjection-BN0EPM-3.js";
-import { Jt as committedProviderSchema, Kt as analysisProfileSchema, Xt as init_analysisProfile, it as createEvidence, lt as init_evidence } from "./nativeValueTrace-DR9UE62L.js";
-import { r as init_unicodeCodePointOrder, t as compareUnicodeCodePoints } from "./unicodeCodePointOrder-BezCbTpg.js";
-import { A as REA_WORKFLOW_PROVIDER, F as workflowAnalysisProfile, P as init_InvestigationProviders } from "./InterfaceBuilderDecodeBudget-5F2AkxJT.js";
+import { M as ok, j as init_result } from "./analysisErrorCore-BIEP7tvF.js";
+import { i as init_unknownRegistryError, r as UnknownRegistryError } from "./analysisErrorProjection-B8teQwwD.js";
+import { Wt as init_evidence, an as init_analysisProfile, rn as committedProviderSchema, tn as analysisProfileSchema, zt as createEvidence } from "./nativeValueTrace-BEZbDieM.js";
+import { A as REA_WORKFLOW_PROVIDER, F as workflowAnalysisProfile, P as init_InvestigationProviders } from "./callerPath-CpPnMZyN.js";
+import { a as sourceLimitationKey, i as renderSourceLimitations, r as init_SourceLimitations } from "./ProcedureAddressResolution-H6Qwpb_Y.js";
 
 //#region dist/application/WorkflowEvidence.js
 var executeComposedWorkflow, createWorkflowEvidence, batchProcedureLocations, workflowSnapshotRecord, recordWorkflowUnknowns;
@@ -14,18 +14,25 @@ function init_WorkflowEvidence() {
 		init_analysisProfile();
 		init_evidence();
 		init_unknownRegistryError();
-		init_unicodeCodePointOrder();
+		init_SourceLimitations();
 		executeComposedWorkflow = async (analysis, execute) => {
-			const limitations = new Set();
+			const limitations = new Map();
 			const result = await execute({ execute: async (operation, parameters, options) => {
 				const execution = await analysis.execute(operation, parameters, options);
-				if (execution.ok) execution.value.limitations.forEach((limitation) => limitations.add(limitation));
+				if (execution.ok) for (const limitation of execution.value.limitations) {
+					const fact = {
+						provider: execution.value.provider,
+						operation,
+						limitation
+					};
+					limitations.set(sourceLimitationKey(fact), fact);
+				}
 				return execution;
 			} });
 			if (!result.ok) return result;
 			return ok({
 				result: result.value,
-				limitations: [...limitations].sort(compareUnicodeCodePoints)
+				limitations: renderSourceLimitations([...limitations.values()])
 			});
 		};
 		createWorkflowEvidence = (input) => createEvidence(input.target, REA_WORKFLOW_PROVIDER, {

package/dist/mcp/analysisErrorCleanup-Q344SnTO.js

@@ -0,0 +1,34 @@
+import { t as __esmMin } from "./rolldown-runtime-BjeaiXFo.js";
+import { n as projectAnalysisError, t as init_analysisErrorProjection } from "./analysisErrorProjection-B8teQwwD.js";
+import { i as init_providerAdapterError, r as ProviderAdapterError } from "./browserObservationError-C5okJ5el.js";
+
+//#region dist/domain/analysisErrorCleanup.js
+var analysisErrorWithCleanupFailure;
+function init_analysisErrorCleanup() {
+	return (init_analysisErrorCleanup = __esmMin((() => {
+		init_providerAdapterError();
+		init_analysisErrorProjection();
+		analysisErrorWithCleanupFailure = (primary, cleanup, operation = "close_binary") => {
+			const projected = projectAnalysisError(cleanup);
+			return new ProviderAdapterError(cleanup instanceof ProviderAdapterError ? cleanup.providerId : "rea", operation, {
+				cleanupPrimary: primary,
+				cause: new AggregateError([primary, cleanup], "Analysis failed and cleanup remains incomplete.", { cause: primary }),
+				userMessage: projectAnalysisError(primary).message,
+				remediationAction: projected.remediation.action,
+				...primary.capturedOutput === undefined ? {} : { capturedOutput: primary.capturedOutput },
+				...primary.partialObservation === undefined ? {} : { partialObservation: primary.partialObservation },
+				cleanup: {
+					reason: projected.message,
+					resources: [...new Set([...primary.cleanupIncomplete ? primary.cleanupResources : [], ...cleanup.cleanupResources])]
+				},
+				diagnostics: {
+					primary_error: projectAnalysisError(primary),
+					cleanup_error: projected
+				}
+			});
+		};
+	})))();
+}
+
+//#endregion
+export { init_analysisErrorCleanup as n, analysisErrorWithCleanupFailure as t };

package/dist/mcp/analysisErrorCore-BIEP7tvF.js

@@ -0,0 +1,509 @@
+import { t as __esmMin } from "./rolldown-runtime-BjeaiXFo.js";
+import { z } from "zod";
+import { types } from "node:util";
+
+//#region dist/domain/result.js
+var ok, err;
+function init_result() {
+	return (init_result = __esmMin((() => {
+		ok = (value) => ({
+			ok: true,
+			value
+		});
+		err = (error) => ({
+			ok: false,
+			error
+		});
+	})))();
+}
+
+//#endregion
+//#region dist/domain/analysisErrorBase.js
+var ANALYSIS_ERROR_TAGS, AnalysisError, resolvedAnalysisError;
+function init_analysisErrorBase() {
+	return (init_analysisErrorBase = __esmMin((() => {
+		ANALYSIS_ERROR_TAGS = [
+			"AnalysisProtocolError",
+			"AnalysisInputError",
+			"AnalysisAccessDeniedError",
+			"AnalysisArtifactChangedError",
+			"AnalysisOutputError",
+			"AnalysisCapabilityUnavailableError",
+			"AnalysisUnsupportedTargetError",
+			"AnalysisCancelledError",
+			"AnalysisTimeoutError",
+			"AnalysisResourceConstraintError",
+			"ProviderSelectionError",
+			"ProviderAdapterError",
+			"BrowserObservationError",
+			"ArtifactOperationError",
+			"ProcessCaptureError",
+			"EvidenceIntegrityError",
+			"EvidenceFileError",
+			"UnknownRegistryError",
+			"HopperTimeoutError",
+			"HopperCancelledError",
+			"HopperProtocolError",
+			"HopperRemoteError",
+			"HopperProcessError",
+			"HopperStartError",
+			"ConfigurationError",
+			"NoBinaryOpenError",
+			"BinaryTargetError"
+		];
+		AnalysisError = class extends Error {
+			#cleanupPrimary;
+			#cleanupDependencies;
+			#cleanupDependents = [];
+			diagnostics;
+			capturedOutput;
+			cleanup;
+			cleanupIncomplete;
+			#ownedCleanupResources;
+			#cleanupResourceOwner;
+			constructor(message, options) {
+				super(message, options);
+				this.#cleanupPrimary = options?.cleanupPrimary;
+				this.diagnostics = options?.diagnostics === undefined ? undefined : structuredClone(options.diagnostics);
+				this.capturedOutput = options?.capturedOutput === undefined ? undefined : { ...options.capturedOutput };
+				this.cleanup = options?.cleanup;
+				this.cleanupIncomplete = options?.cleanup !== undefined;
+				this.#ownedCleanupResources = [...options?.cleanup?.resources ?? []];
+				this.partialObservation = options?.partialObservation;
+			}
+			userMessage = undefined;
+			userCategory = undefined;
+			executionFailure = undefined;
+			partialObservation;
+			get cleanupPrimary() {
+				return this.#cleanupPrimary;
+			}
+			cleanupReport = undefined;
+			/** Live dependencies own current resource attribution; cleanup keeps history. */
+			get cleanupResources() {
+				if (this.#cleanupDependencies === undefined) return this.#cleanupResourceOwner?.cleanupResources ?? this.#ownedCleanupResources;
+				return [...new Set([...this.#cleanupDependencies].filter((dependency) => dependency.cleanupIncomplete).flatMap((dependency) => dependency.cleanupResources))];
+			}
+			/** Bind attribution only to the producer that owns the complete cleanup set. */
+			bindCleanupResourceOwner(owner) {
+				this.#cleanupResourceOwner = owner;
+				return this;
+			}
+			/** Initialize resource facts supplied by a more specific error producer. */
+			setCleanupResources(resources) {
+				this.#ownedCleanupResources = [...resources];
+			}
+			/** Retain a later lifecycle failure without replacing the original typed error. */
+			retainSecondaryFailure(failure, diagnostics) {
+				Object.assign(this, {
+					diagnostics: structuredClone({
+						...this.diagnostics,
+						...diagnostics
+					}),
+					cause: new AggregateError(this.cause === undefined ? [failure] : [this.cause, failure], "Analysis failed and a later lifecycle operation also failed.", { cause: this.cause })
+				});
+				return this;
+			}
+			/** Keep a composed error incomplete until all explicitly owned source errors resolve. */
+			bindCleanupDependencies(dependencies) {
+				const pending = this.#cleanupDependencies ??= new Set();
+				for (const dependency of dependencies) {
+					if (!dependency.cleanupIncomplete || pending.has(dependency)) continue;
+					pending.add(dependency);
+					dependency.#cleanupDependents = [...dependency.#cleanupDependents.filter((reference) => reference.deref() !== undefined), new WeakRef(this)];
+				}
+				if (pending.size === 0) this.resolveCleanup();
+				return this;
+			}
+			/** Clear live cleanup status only after its owning resource confirms retry success. */
+			resolveCleanup() {
+				if ([...this.#cleanupDependencies ?? []].some((dependency) => dependency.cleanupIncomplete)) return this;
+				this.#cleanupDependencies?.clear();
+				this.cleanupIncomplete = false;
+				for (const reference of this.#cleanupDependents) reference.deref()?.resolveCleanup();
+				this.#cleanupDependents = [];
+				return this;
+			}
+			/** Retain a completed observation when a later step fails. */
+			retainPartialObservation(observation) {
+				this.partialObservation ??= observation;
+				return this;
+			}
+		};
+		resolvedAnalysisError = (error) => {
+			while (!error.cleanupIncomplete && error.cleanupPrimary !== undefined) error = error.cleanupPrimary;
+			return error;
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/domain/immutableJson.js
+/**
+* Seal exclusively owned JSON in bounded steps, authenticating only completion.
+* Abandonment or failure can leave the provisional input partly frozen.
+*/
+function* freezeOwnedJsonSnapshotSteps(value) {
+	const pending = [{
+		value,
+		exiting: false
+	}];
+	const visited = new Set();
+	const ancestors = new Set();
+	let examined = 0;
+	try {
+		while (pending.length > 0) {
+			if (examined++ === 4096) {
+				examined = 0;
+				yield;
+			}
+			const entry = pending.pop();
+			if (entry === undefined) break;
+			const item = entry.value;
+			if (entry.exiting && typeof item === "object" && item !== null) {
+				ancestors.delete(item);
+				visited.add(item);
+				continue;
+			}
+			if (isImmutableJsonSnapshot(item)) continue;
+			if (typeof item !== "object" || item === null) throw new TypeError("Immutable JSON snapshots require JSON values");
+			if (ancestors.has(item)) throw new TypeError("Immutable JSON snapshots cannot contain circular references");
+			if (visited.has(item)) continue;
+			ancestors.add(item);
+			pending.push({
+				value: item,
+				exiting: true
+			});
+			pushSnapshotChildren(item, pending);
+			Object.freeze(item);
+		}
+		if (typeof value === "object" && value !== null) immutableSnapshots.add(value);
+		return value;
+	} finally {
+		pending.length = 0;
+		visited.clear();
+		ancestors.clear();
+	}
+}
+var immutableSnapshots, isImmutableJsonSnapshot, freezeJsonSnapshot, pushSnapshotChildren;
+function init_immutableJson() {
+	return (init_immutableJson = __esmMin((() => {
+		immutableSnapshots = new WeakSet();
+		isImmutableJsonSnapshot = (value) => value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value) || typeof value === "object" && immutableSnapshots.has(value);
+		freezeJsonSnapshot = (value) => {
+			const pending = [{
+				value,
+				exiting: false
+			}];
+			const visited = new Set();
+			const ancestors = new Set();
+			const objects = [];
+			while (pending.length > 0) {
+				const entry = pending.pop();
+				if (entry === undefined) break;
+				const item = entry.value;
+				if (entry.exiting && typeof item === "object" && item !== null) {
+					ancestors.delete(item);
+					visited.add(item);
+					objects.push(item);
+					continue;
+				}
+				if (isImmutableJsonSnapshot(item)) continue;
+				if (typeof item !== "object" || item === null) throw new TypeError("Immutable JSON snapshots require JSON values");
+				if (ancestors.has(item)) throw new TypeError("Immutable JSON snapshots cannot contain circular references");
+				if (visited.has(item)) continue;
+				ancestors.add(item);
+				pending.push({
+					value: item,
+					exiting: true
+				});
+				pushSnapshotChildren(item, pending);
+			}
+			for (const item of objects) Object.freeze(item);
+			if (typeof value === "object" && value !== null) immutableSnapshots.add(value);
+			return value;
+		};
+		pushSnapshotChildren = (item, pending) => {
+			const prototype = Object.getPrototypeOf(item);
+			if (!Array.isArray(item) && prototype !== Object.prototype && prototype !== null) throw new TypeError("Immutable JSON snapshots require ordinary objects");
+			if (Array.isArray(item)) {
+				for (let index = 0; index < item.length; index += 1) if (!Object.hasOwn(item, index)) throw new TypeError("Immutable JSON snapshots cannot contain sparse arrays");
+			}
+			for (const key of Object.getOwnPropertyNames(item)) {
+				const descriptor = Object.getOwnPropertyDescriptor(item, key);
+				if (descriptor === undefined || !Object.hasOwn(descriptor, "value")) throw new TypeError("Immutable JSON snapshots cannot contain accessors");
+				const child = descriptor.value;
+				pending.push({
+					value: child,
+					exiting: false
+				});
+			}
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/domain/jsonValue.js
+/** Validate JSON in bounded steps; cache only authenticated immutable roots. */
+function* jsonValueValidationSteps(root) {
+	const immutable = typeof root === "object" && root !== null && isImmutableJsonSnapshot(root) ? root : undefined;
+	if (immutable !== undefined && immutableValidation.has(immutable)) return immutableValidation.get(immutable);
+	const finish = (issue) => {
+		if (immutable !== undefined) immutableValidation.set(immutable, issue);
+		return issue;
+	};
+	const pending = [{
+		value: root,
+		depth: 0
+	}];
+	let examined = 0;
+	while (pending.length > 0) {
+		if (examined++ === 4096) {
+			examined = 0;
+			yield;
+		}
+		const item = pending.pop();
+		if (item === undefined) break;
+		if (item.depth > 1e3) return finish(`JSON value exceeds maximum nesting depth of ${MAX_JSON_DEPTH}`);
+		const value = item.value;
+		if (typeof value === "object" && value !== null && types.isProxy(value)) return finish("JSON values cannot contain proxies");
+		if (value === null || typeof value === "string" || typeof value === "boolean") continue;
+		if (typeof value === "number") {
+			if (!Number.isFinite(value)) return finish("JSON numbers must be finite");
+		} else if (Array.isArray(value)) {
+			for (let index = 0; index < value.length; index += 1) {
+				const descriptor = Object.getOwnPropertyDescriptor(value, index);
+				if (descriptor === undefined || !Object.hasOwn(descriptor, "value")) return finish("JSON arrays require dense data properties without accessors");
+				pending.push({
+					value: descriptor.value,
+					depth: item.depth + 1
+				});
+			}
+		} else if (isRecord(value)) {
+			const prototype = Object.getPrototypeOf(value);
+			if (prototype !== Object.prototype && prototype !== null) return finish("JSON objects require ordinary data properties");
+			for (const key of Reflect.ownKeys(value)) {
+				const descriptor = Object.getOwnPropertyDescriptor(value, key);
+				if (descriptor?.enumerable !== true) continue;
+				if (typeof key !== "string") return finish("JSON object keys must be strings");
+				if (!Object.hasOwn(descriptor, "value")) return finish("JSON objects cannot contain accessors");
+				pending.push({
+					value: descriptor.value,
+					depth: item.depth + 1
+				});
+			}
+		} else return finish("Invalid JSON value");
+	}
+	return finish(undefined);
+}
+var MAX_JSON_DEPTH, isRecord, immutableValidation, jsonValueValidationIssue, preserveJsonValue, validatedJsonValue, jsonValueSchema, objectValidation, objectProjection, jsonObjectSchema;
+function init_jsonValue() {
+	return (init_jsonValue = __esmMin((() => {
+		init_immutableJson();
+		MAX_JSON_DEPTH = 1e3;
+		isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+		immutableValidation = new WeakMap();
+		jsonValueValidationIssue = (root) => {
+			const steps = jsonValueValidationSteps(root);
+			for (;;) {
+				const step = steps.next();
+				if (step.done) return step.value;
+			}
+		};
+		preserveJsonValue = (value) => {
+			const immutableCandidate = value;
+			if (isImmutableJsonSnapshot(immutableCandidate)) return value;
+			if (Array.isArray(value)) {
+				const copy = [];
+				for (let index = 0; index < value.length; index += 1) copy.push(preserveJsonValue(value[index]));
+				return copy;
+			}
+			if (value !== null && typeof value === "object") return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, preserveJsonValue(child)]));
+			return value;
+		};
+		validatedJsonValue = z.unknown().superRefine((value, context) => {
+			const issue = jsonValueValidationIssue(value);
+			if (issue !== undefined) context.addIssue({
+				code: "custom",
+				message: issue,
+				continue: false
+			});
+		}).transform((value) => value);
+		validatedJsonValue._zod.toJSONSchema = () => ({});
+		jsonValueSchema = z.unknown().nonoptional().pipe(validatedJsonValue).transform(preserveJsonValue);
+		jsonValueSchema._zod.toJSONSchema = () => ({});
+		objectValidation = z.custom(isRecord, "Expected JSON object");
+		objectProjection = () => ({
+			type: "object",
+			additionalProperties: {}
+		});
+		objectValidation._zod.toJSONSchema = objectProjection;
+		jsonObjectSchema = jsonValueSchema.pipe(objectValidation);
+		jsonObjectSchema._zod.toJSONSchema = objectProjection;
+	})))();
+}
+
+//#endregion
+//#region dist/domain/digests.js
+var SHA256_PATTERN, digestSchema, prefixedDigestSchema, isDigest;
+function init_digests() {
+	return (init_digests = __esmMin((() => {
+		SHA256_PATTERN = /^[a-f0-9]{64}$/u;
+		digestSchema = z.string().regex(SHA256_PATTERN);
+		prefixedDigestSchema = (prefix) => z.string().regex(new RegExp(`^${prefix}_[a-f0-9]{64}$`, "u"), `Expected a ${prefix}_ prefixed lowercase sha256 digest`);
+		isDigest = (value) => typeof value === "string" && SHA256_PATTERN.test(value);
+	})))();
+}
+
+//#endregion
+//#region dist/domain/analysisErrorCore.js
+var AnalysisUnsupportedTargetError, ANALYSIS_RESOURCE_KINDS, AnalysisResourceConstraintError, AnalysisProtocolError, AnalysisInputError, AnalysisOutputError, AnalysisCapabilityUnavailableError, AnalysisCancelledError, AnalysisTimeoutError, AnalysisAccessDeniedError, AnalysisArtifactChangedError;
+function init_analysisErrorCore() {
+	return (init_analysisErrorCore = __esmMin((() => {
+		init_analysisErrorBase();
+		AnalysisUnsupportedTargetError = class extends AnalysisError {
+			operation;
+			path;
+			reason;
+			_tag = "AnalysisUnsupportedTargetError";
+			/** Refusal-specific recovery, when the producer knows an available workflow. */
+			remediationAction;
+			constructor(operation, path, reason, options) {
+				super(`Unsupported target for ${operation} at ${path}: ${reason}`, options);
+				this.operation = operation;
+				this.path = path;
+				this.reason = reason;
+				this.remediationAction = options?.remediationAction;
+			}
+		};
+		ANALYSIS_RESOURCE_KINDS = [
+			"memory",
+			"cpu",
+			"file-size",
+			"transport",
+			"capacity"
+		];
+		AnalysisResourceConstraintError = class extends AnalysisError {
+			operation;
+			resource;
+			reason;
+			reportedLimits;
+			_tag = "AnalysisResourceConstraintError";
+			remediationAction;
+			/**
+			* Whether retrying the same request can succeed. A caller-selected bound is
+			* deterministic for the same input, so it is not retryable even when its
+			* resource kind would otherwise be treated as admission capacity.
+			*/
+			retryable;
+			constructor(operation, resource, reason, reportedLimits, options) {
+				super(`Resource constraint during ${operation}: ${reason}`, options);
+				this.operation = operation;
+				this.resource = resource;
+				this.reason = reason;
+				this.reportedLimits = reportedLimits;
+				this.remediationAction = options?.remediationAction;
+				this.retryable = options?.retryable;
+			}
+		};
+		AnalysisProtocolError = class extends AnalysisError {
+			_tag = "AnalysisProtocolError";
+		};
+		AnalysisInputError = class extends AnalysisError {
+			operation;
+			issues;
+			_tag = "AnalysisInputError";
+			userMessage;
+			constructor(operation, options, issues = []) {
+				super(`Invalid analysis input for ${operation}`, options);
+				this.operation = operation;
+				this.issues = issues;
+				this.userMessage = options?.userMessage;
+			}
+		};
+		AnalysisOutputError = class extends AnalysisError {
+			operation;
+			reason;
+			_tag = "AnalysisOutputError";
+			userMessage;
+			remediationAction;
+			cleanupOnly;
+			constructor(operation, reason, options) {
+				super(`Invalid analysis output for ${operation}: ${reason}`, options);
+				this.operation = operation;
+				this.reason = reason;
+				this.userMessage = options?.userMessage;
+				this.remediationAction = options?.remediationAction;
+				this.cleanupOnly = options?.cleanupOnly ?? false;
+			}
+		};
+		AnalysisCapabilityUnavailableError = class extends AnalysisError {
+			providerId;
+			operation;
+			reason;
+			_tag = "AnalysisCapabilityUnavailableError";
+			userMessage;
+			remediationAction;
+			/** Incomplete cleanup must settle before the operation can be retried. */
+			retryable;
+			constructor(providerId, operation, reason, options) {
+				super(`Provider ${providerId} cannot execute ${operation}: ${reason}`, options);
+				this.providerId = providerId;
+				this.operation = operation;
+				this.reason = reason;
+				this.userMessage = options?.userMessage;
+				this.remediationAction = options?.remediationAction;
+				this.retryable = options?.retryable === true && !this.cleanupIncomplete;
+			}
+		};
+		AnalysisCancelledError = class extends AnalysisError {
+			operation;
+			_tag = "AnalysisCancelledError";
+			constructor(operation, options) {
+				super(`Analysis operation was cancelled: ${operation}`, options);
+				this.operation = operation;
+			}
+		};
+		AnalysisTimeoutError = class extends AnalysisError {
+			operation;
+			timeoutMs;
+			_tag = "AnalysisTimeoutError";
+			userMessage;
+			remediationAction;
+			constructor(operation, timeoutMs, options) {
+				super(`Analysis operation timed out after ${String(timeoutMs)}ms: ${operation}`, options);
+				this.operation = operation;
+				this.timeoutMs = timeoutMs;
+				this.userMessage = options?.userMessage;
+				this.remediationAction = options?.remediationAction;
+			}
+		};
+		AnalysisAccessDeniedError = class extends AnalysisError {
+			operation;
+			path;
+			systemCode;
+			_tag = "AnalysisAccessDeniedError";
+			constructor(operation, path, systemCode, options) {
+				super(`Host filesystem read access denied (${systemCode}) for ${path} during ${operation}`, options);
+				this.operation = operation;
+				this.path = path;
+				this.systemCode = systemCode;
+			}
+		};
+		AnalysisArtifactChangedError = class extends AnalysisError {
+			operation;
+			path;
+			reason;
+			_tag = "AnalysisArtifactChangedError";
+			constructor(operation, path, reason, options) {
+				super(`Selected artifact changed during acquisition: ${reason}`, options);
+				this.operation = operation;
+				this.path = path;
+				this.reason = reason;
+			}
+		};
+	})))();
+}
+
+//#endregion
+export { err as A, freezeJsonSnapshot as C, AnalysisError as D, isImmutableJsonSnapshot as E, ok as M, init_analysisErrorBase as O, jsonValueValidationSteps as S, init_immutableJson as T, MAX_JSON_DEPTH as _, AnalysisCapabilityUnavailableError as a, jsonValueSchema as b, AnalysisProtocolError as c, AnalysisUnsupportedTargetError as d, init_analysisErrorCore as f, prefixedDigestSchema as g, isDigest as h, AnalysisCancelledError as i, init_result as j, resolvedAnalysisError as k, AnalysisResourceConstraintError as l, init_digests as m, AnalysisAccessDeniedError as n, AnalysisInputError as o, digestSchema as p, AnalysisArtifactChangedError as r, AnalysisOutputError as s, ANALYSIS_RESOURCE_KINDS as t, AnalysisTimeoutError as u, init_jsonValue as v, freezeOwnedJsonSnapshotSteps as w, jsonValueValidationIssue as x, jsonObjectSchema as y };