@moldea.ai/core 4.0.0 → 5.0.0

package/dist/index.js

@@ -1,4 +1,4 @@
-import { n as CoreOperationException, t as CoreConfigurationException } from "./chunks/exceptions-C_KfCIjE.js";
+import { n as CoreOperationException, r as registerRuntimeAdapterRetainedByteReservation, t as CoreConfigurationException } from "./chunks/exceptions-HS9ofVy2.js";
 import { REPOSITORY_ROOT, RepositoryPathException, RepositorySourceException, compareRepositoryPaths, createRepositoryIdentity, isRepositoryPath, parseRepositoryPath } from "@moldea.ai/repository";
 import { Parser, isAlias, isMap, isScalar, isSeq, parseAllDocuments } from "yaml";
 //#region src/constants/index.ts
@@ -496,6 +496,7 @@ var serializeDiagnostic = (diagnostic) => {
 	];
 	return JSON.stringify([
 		diagnostic.code,
+		diagnostic.severity,
 		serializeDiagnosticDetails(diagnostic.details),
 		entity,
 		diagnostic.message,
@@ -514,7 +515,7 @@ var readEntityValue = (entity, key) => {
 	return entity?.[key] ?? "";
 };
 var compareDiagnostics = (left, right) => {
-	return compareNullableStrings$2(left.path, right.path) || compareRanges(left.range, right.range) || compareNullableStrings$2(left.pointer, right.pointer) || compareExactStrings(left.source, right.source) || compareExactStrings(left.code, right.code) || compareExactStrings(readEntityValue(left.entity, "agentId"), readEntityValue(right.entity, "agentId")) || compareExactStrings(readEntityValue(left.entity, "capabilityKind"), readEntityValue(right.entity, "capabilityKind")) || compareExactStrings(readEntityValue(left.entity, "capabilityId"), readEntityValue(right.entity, "capabilityId")) || compareExactStrings(readEntityValue(left.entity, "decisionId"), readEntityValue(right.entity, "decisionId")) || compareExactStrings(readEntityValue(left.entity, "variableId"), readEntityValue(right.entity, "variableId")) || compareExactStrings(readEntityValue(left.entity, "adapterId"), readEntityValue(right.entity, "adapterId")) || compareExactStrings(serializeDiagnosticDetails(left.details), serializeDiagnosticDetails(right.details)) || compareExactStrings(left.message, right.message);
+	return compareNullableStrings$2(left.path, right.path) || compareRanges(left.range, right.range) || compareNullableStrings$2(left.pointer, right.pointer) || compareExactStrings(left.source, right.source) || compareExactStrings(left.code, right.code) || compareExactStrings(left.severity, right.severity) || compareExactStrings(readEntityValue(left.entity, "agentId"), readEntityValue(right.entity, "agentId")) || compareExactStrings(readEntityValue(left.entity, "capabilityKind"), readEntityValue(right.entity, "capabilityKind")) || compareExactStrings(readEntityValue(left.entity, "capabilityId"), readEntityValue(right.entity, "capabilityId")) || compareExactStrings(readEntityValue(left.entity, "decisionId"), readEntityValue(right.entity, "decisionId")) || compareExactStrings(readEntityValue(left.entity, "variableId"), readEntityValue(right.entity, "variableId")) || compareExactStrings(readEntityValue(left.entity, "adapterId"), readEntityValue(right.entity, "adapterId")) || compareExactStrings(serializeDiagnosticDetails(left.details), serializeDiagnosticDetails(right.details)) || compareExactStrings(left.message, right.message);
 };
 /**
 * Creates one normalized, immutable Core diagnostic.
@@ -532,6 +533,7 @@ var createCoreDiagnostic = (input) => {
 		path: input.path,
 		pointer: input.pointer ?? null,
 		range: input.range ?? null,
+		severity: "error",
 		source: "core"
 	});
 };
@@ -549,6 +551,17 @@ var normalizeDiagnostics = (candidates) => {
 	}
 	return freezeRecursively([...diagnostics.values()].sort(compareDiagnostics));
 };
+/** Counts the complete normalized diagnostic result by severity once. */
+var countDiagnosticsBySeverity = (diagnostics) => {
+	let errorCount = 0;
+	let warningCount = 0;
+	for (const diagnostic of diagnostics) if (diagnostic.severity === "error") errorCount += 1;
+	else warningCount += 1;
+	return {
+		errorCount,
+		warningCount
+	};
+};
 /**
 * Creates a deterministic, deduplicating diagnostic collector for one operation.
 * @param limits The Core resource limits governing diagnostic output.
@@ -2312,11 +2325,13 @@ var parseManifestDocument = async (input, options, operation = "parse-manifest")
 };
 //#endregion
 //#region src/project-agent-assignments/index.ts
-/** Collects deterministic content-free agent-to-runtime assignments from a validated project. */
-var collectProjectAgentAssignments = (project) => project.agents.map((agent) => ({
-	agentId: agent.id,
-	runtimeId: agent.declaration.runtime.id
-})).sort((left, right) => compareExactStrings(left.agentId, right.agentId) || compareExactStrings(left.runtimeId, right.runtimeId));
+/** Iterates content-free agent-to-runtime assignments without retaining an intermediate array. */
+var iterateProjectAgentAssignments = function* (project) {
+	for (const agent of project.agents) yield {
+		agentId: agent.id,
+		runtimeId: agent.declaration.runtime.id
+	};
+};
 //#endregion
 //#region src/project-metadata/index.ts
 var createAssetItem = (asset, kind, agentId = null, decisionId = null) => ({
@@ -2329,18 +2344,18 @@ var createAssetItem = (asset, kind, agentId = null, decisionId = null) => ({
 	path: asset.path,
 	scalarLength: asset.scalarLength
 });
-var compareMetadataItems = (left, right) => compareExactStrings(left.path, right.path) || compareExactStrings(left.kind, right.kind) || compareExactStrings(left.agentId ?? "", right.agentId ?? "");
-/** Collects deterministic content-free asset metadata from one validated project. */
-var collectProjectMetadata = (project) => {
-	const items = [createAssetItem(project.manifest.asset, "manifest"), createAssetItem(project.project, "project")];
-	for (const context of project.context) items.push(createAssetItem(context.asset, "context"));
-	for (const { decision } of project.decisions) items.push(createAssetItem(decision.asset, "decision", null, decision.id));
-	for (const runtime of project.runtimes) items.push(createAssetItem(runtime.asset, "runtime-guidance"));
+/** Iterates content-free asset metadata without retaining a second project-sized collection. */
+var iterateProjectMetadata = function* (project) {
+	yield createAssetItem(project.manifest.asset, "manifest");
+	yield createAssetItem(project.project, "project");
+	for (const context of project.context) yield createAssetItem(context.asset, "context");
+	for (const { decision } of project.decisions) yield createAssetItem(decision.asset, "decision", null, decision.id);
+	for (const runtime of project.runtimes) yield createAssetItem(runtime.asset, "runtime-guidance");
 	for (const agent of project.agents) {
-		items.push(createAssetItem(agent.description.asset, "agent-description", agent.id));
-		items.push(createAssetItem(agent.instruction, "agent-instruction", agent.id));
-		if (agent.handoffDescription !== null) items.push(createAssetItem(agent.handoffDescription.asset, "agent-handoff-description", agent.id));
-		for (const mirror of agent.mirrors) items.push({
+		yield createAssetItem(agent.description.asset, "agent-description", agent.id);
+		yield createAssetItem(agent.instruction, "agent-instruction", agent.id);
+		if (agent.handoffDescription !== null) yield createAssetItem(agent.handoffDescription.asset, "agent-handoff-description", agent.id);
+		for (const mirror of agent.mirrors) yield {
 			agentId: agent.id,
 			byteLength: mirror.byteLength,
 			canonicalDigest: mirror.canonicalDigest,
@@ -2349,9 +2364,8 @@ var collectProjectMetadata = (project) => {
 			kind: "mirror",
 			path: mirror.path,
 			scalarLength: mirror.scalarLength
-		});
+		};
 	}
-	return items.sort(compareMetadataItems);
 };
 /** Creates the content-free summary for one validated project snapshot. */
 var createProjectSummary = (project) => ({
@@ -2452,6 +2466,7 @@ var EVIDENCE_KEYS = /* @__PURE__ */ new Set([
 ]);
 var DIAGNOSTIC_KEYS = /* @__PURE__ */ new Set([
 	"source",
+	"severity",
 	"code",
 	"message",
 	"path",
@@ -2462,6 +2477,33 @@ var DIAGNOSTIC_KEYS = /* @__PURE__ */ new Set([
 ]);
 var ADAPTER_RESULT_KEYS = /* @__PURE__ */ new Set(["evidence", "diagnostics"]);
 var ADAPTER_CODE_PATTERN = /^[A-Z][A-Z0-9_]*$/u;
+var UNVERIFIED_MESSAGE = "The declared runtime relationship could not be verified.";
+var UNVERIFIED_RELATIONSHIPS = /* @__PURE__ */ new Set([
+	"runtime-agent",
+	"instruction-loader",
+	"agent-input-schema",
+	"agent-output-schema",
+	"tool-implementation",
+	"tool-registration",
+	"tool-input-schema",
+	"tool-output-schema",
+	"skill-implementation",
+	"skill-registration",
+	"handoff-registration",
+	"routing-description",
+	"variable-provider"
+]);
+var SIMPLE_WARNING_KEYS = /* @__PURE__ */ new Set(["relationship", "reason"]);
+var VERSION_WARNING_KEYS = /* @__PURE__ */ new Set([
+	"relationship",
+	"reason",
+	"packageName",
+	"declaredRange",
+	"boundaryVersion"
+]);
+var PACKAGE_NAME_PATTERN = /^(?:@[a-z0-9][a-z0-9._~-]*\/)?[a-z0-9][a-z0-9._~-]*$/u;
+var BOUNDARY_VERSION_PATTERN = /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)$/u;
+var RANGE_COMPARATOR_PATTERN = new RegExp(`^(?:<=|>=|<|>|=)?(?:0|[1-9]\\d*)\\.(?:0|[1-9]\\d*)\\.(?:0|[1-9]\\d*)(?:-[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*)?(?:\\+[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*)?$`, "u");
 var isRecord$2 = (candidate) => {
 	return typeof candidate === "object" && candidate !== null && !Array.isArray(candidate);
 };
@@ -2491,7 +2533,11 @@ var registerRawOutput = (outputCounts, key, amount, context) => {
 	outputCounts[key] += amount;
 };
 var hasOnlyKeys = (candidate, keys) => {
-	return Reflect.ownKeys(candidate).every((key) => typeof key === "string" && keys.has(key));
+	return Reflect.ownKeys(candidate).every((key) => {
+		if (typeof key !== "string" || !keys.has(key)) return false;
+		const descriptor = Object.getOwnPropertyDescriptor(candidate, key);
+		return descriptor !== void 0 && descriptor.enumerable && "value" in descriptor;
+	});
 };
 var isSafeString = (candidate) => {
 	return typeof candidate === "string" && isUnicodeScalarText(candidate) && !candidate.includes("\0");
@@ -2558,6 +2604,58 @@ var normalizeEntity = (candidate, context) => {
 	if (decisionId !== void 0 && !context.decisionIds.has(decisionId)) return invalidAdapterResult(context.adapterId);
 	return normalizeDiagnosticEntity(entity);
 };
+/** Checks only the safe wire grammar; adapters own SemVer meaning and normalization. */
+var isNormalizedRangeWire = (candidate) => {
+	if (candidate === "*") return true;
+	return candidate.split(" || ").every((set) => {
+		const comparators = set.split(" ");
+		return comparators.length > 0 && comparators.every((part) => RANGE_COMPARATOR_PATTERN.test(part));
+	});
+};
+var isValidWarningSubject = (relationship, entity, context) => {
+	if (entity?.agentId === void 0 || entity.decisionId !== void 0) return false;
+	const agent = context.agentsById.get(entity.agentId);
+	if (agent === void 0) return false;
+	if (relationship === "variable-provider") return entity.capabilityKind === void 0 && entity.capabilityId === void 0 && entity.variableId !== void 0 && agent.declaration.bindings?.variableProviders?.[entity.variableId] !== void 0;
+	if (entity.variableId !== void 0) return false;
+	if (relationship.startsWith("tool-")) {
+		if (entity.capabilityKind !== "tool" || entity.capabilityId === void 0) return false;
+		const tool = agent.declaration.tools?.[entity.capabilityId];
+		return tool !== void 0 && (relationship !== "tool-input-schema" || tool.inputSchema !== void 0) && (relationship !== "tool-output-schema" || tool.outputSchema !== void 0);
+	}
+	if (relationship.startsWith("skill-")) return entity.capabilityKind === "skill" && entity.capabilityId !== void 0 && agent.declaration.skills?.[entity.capabilityId] !== void 0;
+	if (entity.capabilityKind !== void 0 || entity.capabilityId !== void 0) return false;
+	if (relationship === "runtime-agent") return agent.declaration.bindings?.runtimeAgent !== void 0;
+	if (relationship === "instruction-loader") return agent.declaration.bindings?.instructionLoader !== void 0;
+	if (relationship === "agent-input-schema") return agent.declaration.bindings?.inputSchema !== void 0;
+	if (relationship === "agent-output-schema") return agent.declaration.bindings?.outputSchema !== void 0;
+	return relationship === "handoff-registration" || relationship === "routing-description";
+};
+var normalizeWarningDetails = (candidate, entity, context) => {
+	const details = normalizeDetails(candidate, context.adapterId);
+	const relationship = details["relationship"];
+	const reason = details["reason"];
+	if (typeof relationship !== "string" || !UNVERIFIED_RELATIONSHIPS.has(relationship) || !isValidWarningSubject(relationship, entity, context)) return invalidAdapterResult(context.adapterId);
+	if (reason === "unsupported-source-pattern" || reason === "dynamic-source-pattern") {
+		if (!hasOnlyKeys(details, SIMPLE_WARNING_KEYS)) return invalidAdapterResult(context.adapterId);
+		return freezeRecursively({
+			relationship,
+			reason
+		});
+	}
+	if (reason !== "version-dependent-behavior" || !hasOnlyKeys(details, VERSION_WARNING_KEYS)) return invalidAdapterResult(context.adapterId);
+	const packageName = details["packageName"];
+	const declaredRange = details["declaredRange"];
+	const boundaryVersion = details["boundaryVersion"];
+	if (typeof packageName !== "string" || !PACKAGE_NAME_PATTERN.test(packageName) || declaredRange !== null && (typeof declaredRange !== "string" || !isNormalizedRangeWire(declaredRange)) || typeof boundaryVersion !== "string" || !BOUNDARY_VERSION_PATTERN.test(boundaryVersion)) return invalidAdapterResult(context.adapterId);
+	return freezeRecursively({
+		boundaryVersion,
+		declaredRange,
+		packageName,
+		reason,
+		relationship
+	});
+};
 var normalizeReference = (candidate, adapterId) => {
 	if (!isRecord$2(candidate) || !hasOnlyKeys(candidate, REFERENCE_KEYS)) return invalidAdapterResult(adapterId);
 	const pathCandidate = candidate["path"];
@@ -2618,23 +2716,41 @@ var validateEvidenceReferences = async (evidence, context) => {
 var normalizeDiagnostic = (candidate, context) => {
 	if (!isRecord$2(candidate) || !hasOnlyKeys(candidate, DIAGNOSTIC_KEYS)) return invalidAdapterResult(context.adapterId);
 	const source = candidate["source"];
+	const severity = candidate["severity"];
 	const code = candidate["code"];
 	const message = candidate["message"];
 	const pathCandidate = candidate["path"];
 	const pointer = candidate["pointer"];
 	const namespace = `${context.adapterId.toUpperCase().replaceAll("-", "_")}_`;
-	if (source !== context.adapterId || !isSafeString(code) || !ADAPTER_CODE_PATTERN.test(code) || !code.startsWith(namespace) || code.length === namespace.length || !isSafeString(message) || message.length === 0 || pathCandidate !== null && (typeof pathCandidate !== "string" || !isRepositoryPath(pathCandidate)) || pointer !== null && (typeof pointer !== "string" || !isJsonPointer(pointer))) return invalidAdapterResult(context.adapterId);
+	const isUnverified = code === `${namespace}RUNTIME_RELATIONSHIP_UNVERIFIED`;
+	if (source !== context.adapterId || !isSafeString(code) || !ADAPTER_CODE_PATTERN.test(code) || !code.startsWith(namespace) || code.length === namespace.length || (isUnverified ? severity !== "warning" || message !== UNVERIFIED_MESSAGE : severity !== "error") || !isSafeString(message) || message.length === 0 || pathCandidate !== null && (typeof pathCandidate !== "string" || !isRepositoryPath(pathCandidate)) || pointer !== null && (typeof pointer !== "string" || !isJsonPointer(pointer))) return invalidAdapterResult(context.adapterId);
 	const path = pathCandidate === null ? null : parseRepositoryPath(pathCandidate);
 	const range = normalizeRange(candidate["range"], context.adapterId);
+	const entity = normalizeEntity(candidate["entity"], context);
 	if (path === null && (pointer !== null || range !== null)) return invalidAdapterResult(context.adapterId);
+	if (isUnverified) {
+		if (path === null) return invalidAdapterResult(context.adapterId);
+		return freezeRecursively({
+			code,
+			details: normalizeWarningDetails(candidate["details"], entity, context),
+			entity,
+			message,
+			path,
+			pointer,
+			range,
+			severity: "warning",
+			source
+		});
+	}
 	return freezeRecursively({
 		code,
 		details: normalizeDetails(candidate["details"], context.adapterId),
-		entity: normalizeEntity(candidate["entity"], context),
+		entity,
 		message,
 		path,
 		pointer,
 		range,
+		severity: "error",
 		source
 	});
 };
@@ -3148,6 +3264,7 @@ var createRepositoryInspectionSession = (repository, limits, signal) => {
 		readFilePage: readAdapterFilePage,
 		snapshot: repository.snapshot
 	});
+	registerRuntimeAdapterRetainedByteReservation(adapterRepository, reserveRetainedBytes);
 	return Object.freeze({
 		adapterRepository,
 		getResourceUsage: () => Object.freeze({
@@ -4899,39 +5016,49 @@ var validateProjectState = async (input, options) => {
 		session,
 		...validatedInput.signal === void 0 ? {} : { signal: validatedInput.signal }
 	}, operationOptions);
-	if (universal.project === null) return freezeRecursively({
-		project: null,
-		resourceUsage: session.getResourceUsage(),
-		result: {
-			diagnostics: universal.diagnostics,
-			evidence: [],
-			formatVersion: universal.formatVersion,
-			source: validatedInput.repository.snapshot,
-			summary: null,
-			valid: false
-		}
-	});
+	if (universal.project === null) {
+		const counts = countDiagnosticsBySeverity(universal.diagnostics);
+		return freezeRecursively({
+			project: null,
+			resourceUsage: session.getResourceUsage(),
+			result: {
+				diagnostics: universal.diagnostics,
+				...counts,
+				evidence: [],
+				formatVersion: universal.formatVersion,
+				source: validatedInput.repository.snapshot,
+				summary: null,
+				valid: false
+			}
+		});
+	}
 	const projectSummary = createProjectSummary(universal.project);
 	const availabilityDiagnostics = validateRuntimeAdapterAvailability(universal.runtimeLocations, universal.project.formatVersion, operationOptions);
-	if (availabilityDiagnostics.length > 0) return freezeRecursively({
-		project: universal.project,
-		resourceUsage: session.getResourceUsage(),
-		result: {
-			diagnostics: availabilityDiagnostics,
-			evidence: [],
-			formatVersion: universal.formatVersion,
-			source: validatedInput.repository.snapshot,
-			summary: projectSummary,
-			valid: false
-		}
-	});
+	if (availabilityDiagnostics.length > 0) {
+		const counts = countDiagnosticsBySeverity(availabilityDiagnostics);
+		return freezeRecursively({
+			project: universal.project,
+			resourceUsage: session.getResourceUsage(),
+			result: {
+				diagnostics: availabilityDiagnostics,
+				...counts,
+				evidence: [],
+				formatVersion: universal.formatVersion,
+				source: validatedInput.repository.snapshot,
+				summary: projectSummary,
+				valid: false
+			}
+		});
+	}
 	const adapterInspection = await inspectRuntimeAdapters(universal.project, session, operationOptions, validatedInput.signal);
-	const valid = adapterInspection.diagnostics.length === 0;
+	const counts = countDiagnosticsBySeverity(adapterInspection.diagnostics);
+	const valid = counts.errorCount === 0;
 	return freezeRecursively({
 		project: universal.project,
 		resourceUsage: session.getResourceUsage(),
 		result: {
 			diagnostics: adapterInspection.diagnostics,
+			...counts,
 			evidence: adapterInspection.evidence,
 			formatVersion: universal.formatVersion,
 			source: validatedInput.repository.snapshot,
@@ -4944,7 +5071,7 @@ var validateProjectState = async (input, options) => {
 var validateProject = async (input, options) => (await validateProjectState(input, options)).result;
 //#endregion
 //#region src/project-inspection/index.ts
-var CURSOR_PREFIX = "core4";
+var CURSOR_PREFIX = "core5";
 var PREPARED_FIXED_BYTES = 512;
 var PREPARED_ITEM_FIXED_BYTES = 64;
 var PREPARED_TEXT_BYTE_MULTIPLIER = 2;
@@ -4975,7 +5102,9 @@ var serializeDeterministically = (candidate) => {
 	if (Array.isArray(candidate)) return `[${candidate.map((item) => serializeDeterministically(item)).join(",")}]`;
 	return `{${Object.entries(candidate).filter(([, value]) => value !== void 0).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([key, value]) => `${JSON.stringify(key)}:${serializeDeterministically(value)}`).join(",")}}`;
 };
-var createIdentity = (parts) => createRepositoryIdentity(parts.map((part) => encoder.encode(part)));
+var createIdentity = (parts) => createRepositoryIdentity((function* () {
+	for (const part of parts) yield encoder.encode(part);
+})());
 var createItemBaseKey = (item) => {
 	if (item.kind === "agent") return [
 		"3",
@@ -5007,19 +5136,19 @@ var createItemBaseKey = (item) => {
 };
 /** Assigns stable unique keys once without relying on collection offsets. */
 var createKeyedItems = (items) => {
-	const sorted = items.map((item) => ({
-		baseKey: createItemBaseKey(item),
-		item
-	})).sort((left, right) => left.baseKey < right.baseKey ? -1 : left.baseKey > right.baseKey ? 1 : 0);
-	const occurrences = /* @__PURE__ */ new Map();
-	return sorted.map(({ baseKey, item }) => {
-		const occurrence = occurrences.get(baseKey) ?? 0;
-		occurrences.set(baseKey, occurrence + 1);
-		return {
-			item,
-			key: `${baseKey}:${String(occurrence).padStart(10, "0")}`
-		};
-	});
+	const sorted = Array.from(items, (item) => ({
+		item,
+		key: createItemBaseKey(item)
+	})).sort((left, right) => left.key < right.key ? -1 : left.key > right.key ? 1 : 0);
+	let previousBaseKey = null;
+	let occurrence = 0;
+	for (const item of sorted) {
+		const baseKey = item.key;
+		occurrence = baseKey === previousBaseKey ? occurrence + 1 : 0;
+		previousBaseKey = baseKey;
+		item.key = `${baseKey}:${String(occurrence).padStart(10, "0")}`;
+	}
+	return sorted;
 };
 var createCursorChecksum = (inspectionDigest, lastKey, view) => createIdentity([
 	CURSOR_PREFIX,
@@ -5036,7 +5165,7 @@ var encodeCursor = (inspectionDigest, view, lastKey) => [
 ].join(":");
 var decodeCursor = (cursor, inspectionDigest, view) => {
 	if (cursor === void 0) return null;
-	const match = /^core4:(all|diagnostics|evidence|metadata):([^:]+):(sha256:[0-9a-f]{64}):(sha256:[0-9a-f]{64})$/u.exec(cursor);
+	const match = /^core5:(all|diagnostics|evidence|metadata):([^:]+):(sha256:[0-9a-f]{64}):(sha256:[0-9a-f]{64})$/u.exec(cursor);
 	if (match === null || match[1] !== view || match[3] !== inspectionDigest) return invalidArgument$1();
 	let lastKey;
 	try {
@@ -5058,17 +5187,73 @@ var addRetainedBytes = (current, additional, retainedBeforePreparation, maximum)
 	if (!Number.isSafeInteger(additional) || additional < 0 || !Number.isSafeInteger(projectedUsage) || projectedUsage > maximum) return resourceLimitExceeded$1(maximum, Number.isSafeInteger(projectedUsage) ? projectedUsage : Number.MAX_SAFE_INTEGER);
 	return current + additional;
 };
-/** Calculates deterministic logical bytes retained by prepared records and view indexes. */
-var calculatePreparedBytes = (items, views, header, retainedBeforePreparation, maximum) => {
+/** Iterates every content-free inspection item without retaining preparation state. */
+var iterateProjectInspectionItems = function* (state) {
+	if (state.project !== null) for (const metadata of iterateProjectMetadata(state.project)) yield {
+		kind: "metadata",
+		metadata
+	};
+	for (const diagnostic of state.result.diagnostics) yield {
+		diagnostic,
+		kind: "diagnostic"
+	};
+	for (const evidence of state.result.evidence) yield {
+		evidence,
+		kind: "evidence"
+	};
+	if (state.project !== null) for (const agent of iterateProjectAgentAssignments(state.project)) yield {
+		agent,
+		kind: "agent"
+	};
+};
+/** Preflights the complete logical prepared-state cost before retaining its collections. */
+var estimatePreparedProjectInspection = (state, baseCounts, maximum) => {
+	const retainedBeforePreparation = state.resourceUsage.retainedBytes;
 	let bytes = addRetainedBytes(0, PREPARED_FIXED_BYTES, retainedBeforePreparation, maximum);
-	for (const { item, key } of items) {
+	let metadataCount = 0;
+	for (const item of iterateProjectInspectionItems(state)) {
+		const key = `${createItemBaseKey(item)}:0000000000`;
 		const encodedBytes = encoder.encode(key).byteLength + encoder.encode(serializeDeterministically(item)).byteLength;
-		bytes = addRetainedBytes(bytes, PREPARED_ITEM_FIXED_BYTES + encodedBytes * PREPARED_TEXT_BYTE_MULTIPLIER, retainedBeforePreparation, maximum);
-	}
-	bytes = addRetainedBytes(bytes, encoder.encode(serializeDeterministically(header)).byteLength * PREPARED_TEXT_BYTE_MULTIPLIER, retainedBeforePreparation, maximum);
-	bytes = addRetainedBytes(bytes, (views.diagnostics.length + views.evidence.length + views.metadata.length) * PREPARED_VIEW_REFERENCE_BYTES, retainedBeforePreparation, maximum);
-	return bytes;
+		bytes = addRetainedBytes(bytes, PREPARED_ITEM_FIXED_BYTES + encodedBytes * PREPARED_TEXT_BYTE_MULTIPLIER + PREPARED_VIEW_REFERENCE_BYTES, retainedBeforePreparation, maximum);
+		if (item.kind === "metadata") metadataCount += 1;
+	}
+	const counts = {
+		agents: baseCounts.agents,
+		context: baseCounts.context,
+		decisions: baseCounts.decisions,
+		diagnostics: baseCounts.diagnostics,
+		errors: baseCounts.errors,
+		evidence: baseCounts.evidence,
+		metadata: metadataCount,
+		mirrors: baseCounts.mirrors,
+		runtimes: baseCounts.runtimes,
+		unresolved: baseCounts.unresolved,
+		warnings: baseCounts.warnings
+	};
+	bytes = addRetainedBytes(bytes, encoder.encode(serializeDeterministically({
+		counts,
+		formatVersion: state.result.formatVersion,
+		inspectionDigest: "sha256:0000000000000000000000000000000000000000000000000000000000000000",
+		source: state.result.source,
+		summary: state.result.summary,
+		valid: state.result.valid
+	})).byteLength * PREPARED_TEXT_BYTE_MULTIPLIER, retainedBeforePreparation, maximum);
+	return {
+		counts,
+		preparedBytes: bytes
+	};
 };
+/** Creates the inspection digest without materializing a project-sized key projection. */
+var createInspectionDigest = (counts, formatVersion, items, summary, valid) => createIdentity((function* () {
+	yield "core5-prepared-inspection";
+	yield serializeDeterministically({
+		counts,
+		formatVersion,
+		summary,
+		valid
+	});
+	for (const { key } of items) yield key;
+})());
 var findStartIndex = (items, lastKey) => {
 	if (lastKey === null) return 0;
 	let lower = 0;
@@ -5085,23 +5270,9 @@ var findStartIndex = (items, lastKey) => {
 };
 /** Creates the returned inspection from content-free state only. */
 var createPreparedProjectInspection = (input) => {
-	const { counts, formatVersion, items, maxEntries, maxRetainedBytes, resourceUsage: validationUsage, source, summary, valid } = input;
+	const { counts, formatVersion, items, maxEntries, preparedBytes, resourceUsage: validationUsage, source, summary, valid } = input;
 	const views = createViews(items);
-	const inspectionDigest = createIdentity([serializeDeterministically({
-		counts,
-		formatVersion,
-		itemKeys: items.map(({ key }) => key),
-		summary,
-		valid
-	})]);
-	const preparedBytes = calculatePreparedBytes(items, views, {
-		counts,
-		formatVersion,
-		inspectionDigest,
-		source,
-		summary,
-		valid
-	}, validationUsage.retainedBytes, maxRetainedBytes);
+	const inspectionDigest = createInspectionDigest(counts, formatVersion, items, summary, valid);
 	const resourceUsage = freezeRecursively({
 		canonicalBytes: validationUsage.canonicalBytes,
 		peakRetainedBytes: Math.max(validationUsage.peakRetainedBytes, validationUsage.retainedBytes + preparedBytes),
@@ -5150,42 +5321,26 @@ var createPreparedProjectInspection = (input) => {
 /** Prepares one immutable content-free inspection for synchronous bounded page reads. */
 var createProjectInspection = async (input, options) => {
 	const state = await validateProjectState(input, options);
-	const metadata = state.project === null ? [] : collectProjectMetadata(state.project);
-	const agentAssignments = state.project === null ? [] : collectProjectAgentAssignments(state.project);
-	const items = freezeRecursively(createKeyedItems([
-		...metadata.map((metadataItem) => ({
-			kind: "metadata",
-			metadata: metadataItem
-		})),
-		...state.result.diagnostics.map((diagnostic) => ({
-			diagnostic,
-			kind: "diagnostic"
-		})),
-		...state.result.evidence.map((evidence) => ({
-			evidence,
-			kind: "evidence"
-		})),
-		...agentAssignments.map((agent) => ({
-			agent,
-			kind: "agent"
-		}))
-	]));
+	const estimate = estimatePreparedProjectInspection(state, {
+		agents: state.result.summary?.counts.agents ?? 0,
+		context: state.result.summary?.counts.context ?? 0,
+		decisions: state.result.summary?.counts.decisions ?? 0,
+		diagnostics: state.result.diagnostics.length,
+		errors: state.result.errorCount,
+		evidence: state.result.evidence.length,
+		mirrors: state.result.summary?.counts.mirrors ?? 0,
+		runtimes: state.result.summary?.counts.runtimes ?? 0,
+		unresolved: state.result.summary?.counts.unresolved ?? 0,
+		warnings: state.result.warningCount
+	}, options.limits.maxRetainedBytes);
+	const counts = freezeRecursively(estimate.counts);
+	const items = freezeRecursively(createKeyedItems(iterateProjectInspectionItems(state)));
 	return createPreparedProjectInspection({
-		counts: freezeRecursively({
-			agents: state.result.summary?.counts.agents ?? 0,
-			context: state.result.summary?.counts.context ?? 0,
-			decisions: state.result.summary?.counts.decisions ?? 0,
-			diagnostics: state.result.diagnostics.length,
-			evidence: state.result.evidence.length,
-			metadata: metadata.length,
-			mirrors: state.result.summary?.counts.mirrors ?? 0,
-			runtimes: state.result.summary?.counts.runtimes ?? 0,
-			unresolved: state.result.summary?.counts.unresolved ?? 0
-		}),
+		counts,
 		formatVersion: state.result.formatVersion,
 		items,
 		maxEntries: options.limits.maxEntries,
-		maxRetainedBytes: options.limits.maxRetainedBytes,
+		preparedBytes: estimate.preparedBytes,
 		resourceUsage: state.resourceUsage,
 		source: state.result.source,
 		summary: state.result.summary,