@moldea.ai/core 5.0.1 → 7.0.0

package/dist/chunks/scope-AGMcHUE_.js

@@ -0,0 +1,1827 @@
+import { A as ACCEPTABLE_WARNING_CODES, C as isSimpleGlob, D as parseManifestPath, M as RECOGNIZED_RUNTIME_IDS, O as sortRepositoryReferences, S as isRuntimeGuidancePath, T as isVariableId, _ as isDecisionPath, a as escapeJsonPointerSegment, b as isRepositorySymbol, c as freezeRecursively, d as hasNonWhitespace, f as hasUnsupportedGlobMetacharacter, g as isContextPath, h as isCapabilityDescription, i as createCoreDiagnosticCollector, l as compareExactStrings, m as isCanonicalMoldeaPath, p as isCanonicalManifestPath, s as createNullPrototypeRecord, t as createCoreOperationOptionsSnapshot, u as countUnicodeScalars$1, v as isMirrorPath, w as isStableId, x as isReservedId, y as isNonEmptySingleLine } from "./options-5x9gu2Qb.js";
+import { n as CoreOperationException } from "./exceptions-IXsorE8t.js";
+import { parseRepositoryPath } from "@moldea.ai/repository";
+import { Parser, isAlias, isMap, isScalar, isSeq, parseAllDocuments } from "yaml";
+//#region src/text/index.ts
+var encoder = new TextEncoder();
+var decoder = new TextDecoder("utf-8", {
+	fatal: true,
+	ignoreBOM: true
+});
+var isRecord$1 = (value) => {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+/**
+* Measures valid scalar UTF-8 bytes and stops once the operation budget is exceeded.
+* @param value The decoded string to measure without lossy replacement.
+* @param maximumByteLength The threshold after which measurement may stop early.
+* @returns The measured bytes, a value above the threshold, or `null` for invalid Unicode.
+*/
+var measureScalarUtf8ByteLength = (value, maximumByteLength) => {
+	let byteLength = 0;
+	for (let index = 0; index < value.length; index += 1) {
+		const codeUnit = value.charCodeAt(index);
+		if (codeUnit >= 55296 && codeUnit <= 56319) {
+			if (index + 1 >= value.length) return null;
+			const nextCodeUnit = value.charCodeAt(index + 1);
+			if (nextCodeUnit < 56320 || nextCodeUnit > 57343) return null;
+			byteLength += 4;
+			if (byteLength > maximumByteLength) return byteLength;
+			index += 1;
+			continue;
+		}
+		if (codeUnit >= 56320 && codeUnit <= 57343) return null;
+		byteLength += codeUnit <= 127 ? 1 : codeUnit <= 2047 ? 2 : 3;
+		if (byteLength > maximumByteLength) return byteLength;
+	}
+	return byteLength;
+};
+var countUnicodeScalars = (value) => {
+	let count = 0;
+	for (let index = 0; index < value.length; count += 1) {
+		const codePoint = value.codePointAt(index);
+		if (codePoint === void 0) break;
+		index += codePoint > 65535 ? 2 : 1;
+	}
+	return count;
+};
+/**
+* Collects every normalized NUL location or rejects when the diagnostic budget is exhausted.
+* @param value The normalized scalar text to inspect.
+* @param path The logical document path attached to each diagnostic.
+* @param diagnostics The operation collector receiving every NUL diagnostic.
+* @throws
+* - RESOURCE_LIMIT_EXCEEDED: A Core resource limit was exceeded.
+*/
+var collectNulDiagnostics = (value, path, diagnostics) => {
+	let column = 1;
+	let line = 1;
+	let offset = 0;
+	for (const scalar of value) {
+		if (scalar === "\0") diagnostics.add({
+			code: "MOLDEA_TEXT_NUL_FORBIDDEN",
+			path,
+			range: {
+				end: {
+					column: column + 1,
+					line,
+					offset: offset + 1
+				},
+				start: {
+					column,
+					line,
+					offset
+				}
+			}
+		});
+		if (scalar === "\n") {
+			column = 1;
+			line += 1;
+		} else column += 1;
+		offset += 1;
+	}
+};
+var invalidArgument$1 = (operation) => {
+	throw new CoreOperationException({
+		code: "INVALID_ARGUMENT",
+		operation
+	});
+};
+var enforceFileLimit = (byteLength, limits, operation, limit) => {
+	if (byteLength <= limits[limit]) return;
+	throw new CoreOperationException({
+		code: "RESOURCE_LIMIT_EXCEEDED",
+		limit,
+		limitMaximum: limits[limit],
+		nextAction: "reduce-input-or-increase-limit",
+		observedUsage: byteLength,
+		operation
+	});
+};
+var invalidResult = (diagnostics) => {
+	return freezeRecursively({
+		diagnostics: [...diagnostics],
+		text: null,
+		valid: false
+	});
+};
+/**
+* Validates one public text input, enforces its source-byte budget, and decodes strict UTF-8.
+* @param input The untrusted public text-document input.
+* @param limits The immutable Core resource limits.
+* @param operation The public operation requesting the input.
+* @param limit The source-byte limit applied by the operation.
+* @param diagnostics The operation collector receiving text diagnostics.
+* @returns Decoded text or a frozen structural failure result.
+* @throws
+* - INVALID_REPOSITORY_PATH: The repository path is invalid.
+* - INVALID_ARGUMENT: The Core operation received an invalid argument.
+* - RESOURCE_LIMIT_EXCEEDED: A Core resource limit was exceeded.
+*/
+var readInput = (input, limits, operation, limit, diagnostics) => {
+	if (!isRecord$1(input)) return invalidArgument$1(operation);
+	const pathCandidate = input["path"];
+	const content = input["content"];
+	if (typeof pathCandidate !== "string" || typeof content !== "string" && !(content instanceof Uint8Array)) return invalidArgument$1(operation);
+	const path = parseRepositoryPath(pathCandidate);
+	if (typeof content === "string") {
+		const byteLength = measureScalarUtf8ByteLength(content, limits[limit]);
+		if (byteLength === null) {
+			diagnostics.add({
+				code: "MOLDEA_TEXT_INVALID_UNICODE",
+				path
+			});
+			return invalidResult(diagnostics.finalize());
+		}
+		enforceFileLimit(byteLength, limits, operation, limit);
+		return {
+			path,
+			value: content
+		};
+	}
+	enforceFileLimit(content.byteLength, limits, operation, limit);
+	const bytes = new Uint8Array(content);
+	try {
+		return {
+			path,
+			value: decoder.decode(bytes)
+		};
+	} catch {
+		diagnostics.add({
+			code: "MOLDEA_TEXT_INVALID_UTF8",
+			path
+		});
+		return invalidResult(diagnostics.finalize());
+	}
+};
+/**
+* Validates and normalizes one text document under an operation-specific resource budget.
+* @param input The logical path and decoded string or exact source bytes.
+* @param limits The immutable Core resource limits.
+* @param operation The public Core operation requesting normalization.
+* @param limit The source-byte limit applied by the operation.
+* @returns A frozen normalized result or structural text diagnostics.
+* @throws
+* - INVALID_REPOSITORY_PATH: The repository path is invalid.
+* - INVALID_ARGUMENT: The Core operation received an invalid argument.
+* - RESOURCE_LIMIT_EXCEEDED: A Core resource limit was exceeded.
+*/
+var normalizeTextDocument = (input, limits, operation, limit = "maxFileBytes") => {
+	const diagnostics = createCoreDiagnosticCollector(limits, operation);
+	const decoded = readInput(input, limits, operation, limit, diagnostics);
+	if ("valid" in decoded) return decoded;
+	const value = (decoded.value.startsWith("") ? decoded.value.slice(1) : decoded.value).replace(/\r\n?/gu, "\n");
+	collectNulDiagnostics(value, decoded.path, diagnostics);
+	if (diagnostics.size > 0) return invalidResult(diagnostics.finalize());
+	const text = freezeRecursively({
+		scalarLength: countUnicodeScalars(value),
+		utf8ByteLength: encoder.encode(value).byteLength,
+		value
+	});
+	return freezeRecursively({
+		diagnostics: [],
+		text,
+		valid: true
+	});
+};
+var toLowercaseHex = (bytes) => {
+	let value = "";
+	for (const byte of bytes) value += byte.toString(16).padStart(2, "0");
+	return value;
+};
+/**
+* Calculates the canonical digest for already-normalized text.
+* @param text The validated normalized text to encode and hash.
+* @returns A promise resolving to the canonical lowercase SHA-256 digest.
+*/
+var calculateNormalizedTextDigest = async (text) => {
+	const bytes = encoder.encode(text.value);
+	return `sha256:${toLowercaseHex(new Uint8Array(await globalThis.crypto.subtle.digest("SHA-256", bytes)))}`;
+};
+/**
+* Calculates the normalized SHA-256 digest for one text document.
+* @param input The logical path and decoded string or exact source bytes.
+* @param limits The immutable Core resource limits.
+* @returns A promise resolving to a frozen digest result or structural text diagnostics.
+* @throws
+* - INVALID_REPOSITORY_PATH: The repository path is invalid.
+* - INVALID_ARGUMENT: The Core operation received an invalid argument.
+* - RESOURCE_LIMIT_EXCEEDED: A Core resource limit was exceeded.
+*/
+var calculateContentDigest = async (input, limits) => {
+	const normalized = normalizeTextDocument(input, limits, "calculate-content-digest");
+	if (!normalized.valid || normalized.text === null) return freezeRecursively({
+		diagnostics: normalized.diagnostics,
+		digest: null,
+		text: null,
+		valid: false
+	});
+	const digest = await calculateNormalizedTextDigest(normalized.text);
+	return freezeRecursively({
+		diagnostics: [],
+		digest,
+		text: normalized.text,
+		valid: true
+	});
+};
+//#endregion
+//#region src/scope-matching/validations.ts
+var isRecord = (value) => {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+/** Throws the stable invalid-argument failure for malformed scope input. */
+var invalidArgument = () => {
+	throw new CoreOperationException({
+		code: "INVALID_ARGUMENT",
+		operation: "match-manifest-scope"
+	});
+};
+/** Throws the stable resource failure for an exhausted scope-input budget. */
+var resourceLimitExceeded = (limit, limitMaximum, observedUsage) => {
+	throw new CoreOperationException({
+		code: "RESOURCE_LIMIT_EXCEEDED",
+		limit,
+		limitMaximum,
+		nextAction: "reduce-input-or-increase-limit",
+		observedUsage,
+		operation: "match-manifest-scope"
+	});
+};
+/** Measures scalar UTF-8 bytes without allocating an encoded copy. */
+var measureUtf8ByteLength = (value) => {
+	let byteLength = 0;
+	for (const scalar of value) {
+		const codePoint = scalar.codePointAt(0) ?? 0;
+		byteLength += codePoint <= 127 ? 1 : codePoint <= 2047 ? 2 : codePoint <= 65535 ? 3 : 4;
+	}
+	return byteLength;
+};
+/**
+* Validates and snapshots one public manifest-scope input.
+* @param input The untrusted manifest document and changed logical paths.
+* @param limits The immutable Core resource limits.
+* @returns The detached manifest input and sorted unique repository paths.
+* @throws
+* - INVALID_REPOSITORY_PATH: A changed repository path is invalid.
+* - INVALID_ARGUMENT: The scope operation received an invalid argument.
+* - RESOURCE_LIMIT_EXCEEDED: The changed-path count or byte budget was exceeded.
+*/
+var normalizeManifestScopeInput = (input, limits) => {
+	if (!isRecord(input)) return invalidArgument();
+	const manifest = input["manifest"];
+	const pathCandidates = input["paths"];
+	if (!isRecord(manifest) || !Array.isArray(pathCandidates)) return invalidArgument();
+	if (pathCandidates.length > limits.maxEntries) return resourceLimitExceeded("maxEntries", limits.maxEntries, pathCandidates.length);
+	const uniquePaths = /* @__PURE__ */ new Set();
+	let totalBytes = 0;
+	for (const [index, candidate] of pathCandidates.entries()) {
+		if (typeof candidate !== "string") return invalidArgument();
+		const path = parseRepositoryPath(candidate);
+		totalBytes += measureUtf8ByteLength(path) + (index === 0 ? 0 : 1);
+		if (totalBytes > limits.maxTotalBytesRead) return resourceLimitExceeded("maxTotalBytesRead", limits.maxTotalBytesRead, totalBytes);
+		uniquePaths.add(path);
+	}
+	return {
+		manifest,
+		paths: [...uniquePaths].sort(compareExactStrings)
+	};
+};
+//#endregion
+//#region src/scope-matching/patterns.ts
+/** Tests a single-segment wildcard without regular-expression interpretation. */
+var matchesSegment = (pattern, value) => {
+	let patternIndex = 0;
+	let valueIndex = 0;
+	let starIndex = -1;
+	let starValueIndex = -1;
+	while (valueIndex < value.length) {
+		if (pattern[patternIndex] === value[valueIndex]) {
+			patternIndex += 1;
+			valueIndex += 1;
+			continue;
+		}
+		if (pattern[patternIndex] === "*") {
+			starIndex = patternIndex;
+			starValueIndex = valueIndex;
+			patternIndex += 1;
+			continue;
+		}
+		if (starIndex === -1) return false;
+		patternIndex = starIndex + 1;
+		starValueIndex += 1;
+		valueIndex = starValueIndex;
+	}
+	while (pattern[patternIndex] === "*") patternIndex += 1;
+	return patternIndex === pattern.length;
+};
+/** Matches validated simple-glob segments with zero-or-more-segment globstars. */
+var matchesRepositoryGlob = (patternSegments, path) => {
+	const pathSegments = path.slice(1).split("/");
+	let reachable = new Uint8Array(pathSegments.length + 1);
+	reachable[0] = 1;
+	for (const patternSegment of patternSegments) {
+		const next = new Uint8Array(pathSegments.length + 1);
+		if (patternSegment === "**") {
+			let canReach = false;
+			for (let index = 0; index < reachable.length; index += 1) {
+				canReach ||= reachable[index] === 1;
+				next[index] = canReach ? 1 : 0;
+			}
+		} else for (let index = 0; index < pathSegments.length; index += 1) if (reachable[index] === 1 && matchesSegment(patternSegment, pathSegments[index] ?? "")) next[index + 1] = 1;
+		reachable = next;
+	}
+	return reachable[pathSegments.length] === 1;
+};
+//#endregion
+//#region src/scope-matching/matching.ts
+var childPointer$1 = (pointer, segment) => {
+	return `${pointer}/${escapeJsonPointerSegment(segment)}`;
+};
+var createOwner = (kind, id, agentId = null) => ({
+	agentId,
+	id,
+	kind
+});
+var compareOwners = (left, right) => {
+	return compareExactStrings(left.kind, right.kind) || compareExactStrings(left.agentId ?? "", right.agentId ?? "") || compareExactStrings(left.id, right.id);
+};
+var getDeclarationValue = (declaration) => {
+	return declaration.kind === "exact" ? declaration.path : declaration.pattern;
+};
+var compareDeclarations = (left, right) => {
+	return compareOwners(left.owner, right.owner) || compareExactStrings(left.field, right.field) || compareExactStrings(getDeclarationValue(left.declaration), getDeclarationValue(right.declaration)) || compareExactStrings(left.pointer, right.pointer);
+};
+/** Adds one exact repository relationship to the normalized declaration collection. */
+var addExactDeclaration = (declarations, owner, field, pointer, reference) => {
+	declarations.push({
+		declaration: typeof reference === "string" ? {
+			kind: "exact",
+			path: reference,
+			symbol: null
+		} : {
+			kind: "exact",
+			path: reference.path,
+			symbol: reference.symbol ?? null
+		},
+		field,
+		owner,
+		pointer
+	});
+};
+/** Adds sorted repository references while preserving normalized declaration pointers. */
+var addReferenceDeclarations = (declarations, references, owner, field, pointer) => {
+	for (const [index, reference] of (references ?? []).entries()) addExactDeclaration(declarations, owner, field, childPointer$1(pointer, String(index)), reference);
+};
+/** Adds exact and simple-glob impact relationships in normalized array order. */
+var addAffectedByDeclarations = (declarations, affectedBy, owner, pointer) => {
+	for (const [index, pattern] of (affectedBy ?? []).entries()) declarations.push({
+		declaration: pattern.includes("*") ? {
+			kind: "glob",
+			pattern
+		} : {
+			kind: "exact",
+			path: pattern,
+			symbol: null
+		},
+		field: "affectedBy",
+		owner,
+		pointer: childPointer$1(pointer, String(index))
+	});
+};
+/** Adds project-level or agent-level unresolved requirement references. */
+var addUnresolvedDeclarations = (declarations, requirements, pointer, agentId) => {
+	for (const requirementId of Object.keys(requirements ?? {}).sort(compareExactStrings)) {
+		const requirement = requirements?.[requirementId];
+		if (requirement === void 0) continue;
+		const owner = createOwner("unresolved", requirementId, agentId);
+		addReferenceDeclarations(declarations, requirement.related, owner, "related", childPointer$1(childPointer$1(pointer, requirementId), "related"));
+	}
+};
+/** Adds exact and impact declarations owned by one tool or skill capability. */
+var addCapabilityDeclarations = (declarations, capabilityId, capability, agentId, pointer) => {
+	const owner = createOwner(capability.kind, capabilityId, agentId);
+	addExactDeclaration(declarations, owner, "implementation", childPointer$1(pointer, "implementation"), capability.value.implementation);
+	if (capability.value.registration !== void 0) addExactDeclaration(declarations, owner, "registration", childPointer$1(pointer, "registration"), capability.value.registration);
+	if (capability.kind === "tool") for (const field of ["inputSchema", "outputSchema"]) {
+		const reference = capability.value[field];
+		if (reference !== void 0) addExactDeclaration(declarations, owner, field, childPointer$1(pointer, field), reference);
+	}
+	addAffectedByDeclarations(declarations, capability.value.affectedBy, owner, childPointer$1(pointer, "affectedBy"));
+};
+/** Adds all exact and impact relationships owned by one registered agent. */
+var addAgentDeclarations = (declarations, agentId, agent) => {
+	const pointer = childPointer$1("/agents", agentId);
+	const owner = createOwner("agent", agentId, agentId);
+	const bindingsPointer = childPointer$1(pointer, "bindings");
+	for (const field of [
+		"runtimeAgent",
+		"inputSchema",
+		"outputSchema",
+		"instructionLoader"
+	]) {
+		const reference = agent.bindings?.[field];
+		if (reference !== void 0) addExactDeclaration(declarations, owner, field, childPointer$1(bindingsPointer, field), reference);
+	}
+	for (const variableId of Object.keys(agent.bindings?.variableProviders ?? {}).sort(compareExactStrings)) {
+		const reference = agent.bindings?.variableProviders?.[variableId];
+		if (reference !== void 0) addExactDeclaration(declarations, owner, "variableProvider", childPointer$1(childPointer$1(bindingsPointer, "variableProviders"), variableId), reference);
+	}
+	addAffectedByDeclarations(declarations, agent.affectedBy, owner, childPointer$1(pointer, "affectedBy"));
+	for (const capabilityId of Object.keys(agent.tools ?? {}).sort(compareExactStrings)) {
+		const tool = agent.tools?.[capabilityId];
+		if (tool !== void 0) addCapabilityDeclarations(declarations, capabilityId, {
+			kind: "tool",
+			value: tool
+		}, agentId, childPointer$1(childPointer$1(pointer, "tools"), capabilityId));
+	}
+	for (const capabilityId of Object.keys(agent.skills ?? {}).sort(compareExactStrings)) {
+		const skill = agent.skills?.[capabilityId];
+		if (skill !== void 0) addCapabilityDeclarations(declarations, capabilityId, {
+			kind: "skill",
+			value: skill
+		}, agentId, childPointer$1(childPointer$1(pointer, "skills"), capabilityId));
+	}
+	for (const [index, mirror] of (agent.mirrors ?? []).entries()) addExactDeclaration(declarations, owner, "mirrors", childPointer$1(childPointer$1(pointer, "mirrors"), String(index)), mirror);
+	addUnresolvedDeclarations(declarations, agent.unresolved, childPointer$1(pointer, "unresolved"), agentId);
+};
+/** Collects every version 1 declaration that can establish changed-path relevance. */
+var collectManifestScopeDeclarations = (manifest) => {
+	const declarations = [];
+	for (const kind of ["context", "decision"]) {
+		const relationships = kind === "context" ? manifest.context : manifest.decisions;
+		for (const ownerId of Object.keys(relationships ?? {}).sort(compareExactStrings)) {
+			const relationship = relationships?.[ownerId];
+			if (relationship === void 0) continue;
+			const owner = createOwner(kind, ownerId);
+			const pointer = childPointer$1(kind === "context" ? "/context" : "/decisions", ownerId);
+			addReferenceDeclarations(declarations, relationship.bindings, owner, "bindings", childPointer$1(pointer, "bindings"));
+			addAffectedByDeclarations(declarations, relationship.affectedBy, owner, childPointer$1(pointer, "affectedBy"));
+		}
+	}
+	addUnresolvedDeclarations(declarations, manifest.unresolved, "/unresolved", null);
+	for (const agentId of Object.keys(manifest.agents ?? {}).sort(compareExactStrings)) {
+		const agent = manifest.agents?.[agentId];
+		if (agent !== void 0) addAgentDeclarations(declarations, agentId, agent);
+	}
+	return declarations.sort(compareDeclarations);
+};
+/** Builds exact and first-segment glob indexes once for one parsed manifest. */
+var compileManifestScope = (manifest, limits) => {
+	const declarations = collectManifestScopeDeclarations(manifest);
+	if (declarations.length > limits.maxEntries) throw new CoreOperationException({
+		code: "RESOURCE_LIMIT_EXCEEDED",
+		limit: "maxEntries",
+		limitMaximum: limits.maxEntries,
+		nextAction: "reduce-input-or-increase-limit",
+		observedUsage: declarations.length,
+		operation: "match-manifest-scope"
+	});
+	const exact = /* @__PURE__ */ new Map();
+	const globalGlobs = [];
+	const globsByFirstSegment = /* @__PURE__ */ new Map();
+	for (const declaration of declarations) {
+		if (declaration.declaration.kind === "exact") {
+			const existing = exact.get(declaration.declaration.path) ?? [];
+			existing.push(declaration);
+			exact.set(declaration.declaration.path, existing);
+			continue;
+		}
+		const segments = declaration.declaration.pattern.slice(1).split("/");
+		const compiled = {
+			declaration,
+			segments
+		};
+		const firstSegment = segments[0] ?? "";
+		if (firstSegment === "**" || firstSegment.includes("*")) globalGlobs.push(compiled);
+		else {
+			const existing = globsByFirstSegment.get(firstSegment) ?? [];
+			existing.push(compiled);
+			globsByFirstSegment.set(firstSegment, existing);
+		}
+	}
+	return {
+		declarations,
+		exact,
+		globalGlobs,
+		globsByFirstSegment
+	};
+};
+var compareMatches = (left, right) => {
+	return compareOwners(left.owner, right.owner) || compareExactStrings(left.field, right.field) || compareExactStrings(getDeclarationValue(left.declaration), getDeclarationValue(right.declaration)) || compareExactStrings(left.inputPath, right.inputPath) || compareExactStrings(left.pointer, right.pointer);
+};
+var createMatch = (inputPath, relationship) => ({
+	declaration: relationship.declaration,
+	field: relationship.field,
+	inputPath,
+	owner: relationship.owner,
+	pointer: relationship.pointer
+});
+/** Adds one match without ever allocating beyond the operation entry budget. */
+var addMatch = (matches, inputPath, relationship, limits) => {
+	if (matches.length >= limits.maxEntries) throw new CoreOperationException({
+		code: "RESOURCE_LIMIT_EXCEEDED",
+		limit: "maxEntries",
+		limitMaximum: limits.maxEntries,
+		nextAction: "reduce-input-or-increase-limit",
+		observedUsage: matches.length + 1,
+		operation: "match-manifest-scope"
+	});
+	matches.push(createMatch(inputPath, relationship));
+};
+/** Appends matches from one precompiled glob bucket without copying the bucket. */
+var addGlobMatches = (matches, inputPath, declarations, limits) => {
+	for (const compiled of declarations) if (matchesRepositoryGlob(compiled.segments, inputPath)) addMatch(matches, inputPath, compiled.declaration, limits);
+};
+/** Creates the canonical digest of the sorted unique changed-path set. */
+var calculateManifestScopeInputDigest = async (paths) => {
+	const value = paths.join("\0");
+	return calculateNormalizedTextDigest({
+		scalarLength: countUnicodeScalars$1(value),
+		utf8ByteLength: measureUtf8ByteLength(value),
+		value
+	});
+};
+/**
+* Matches normalized changed paths against one valid version 1 manifest.
+* @param manifest The parsed and validated manifest value.
+* @param paths Sorted unique repository-logical changed paths.
+* @param limits The immutable Core operation limits.
+* @returns Frozen content-free matches and stable aggregate counts.
+* @throws
+* - RESOURCE_LIMIT_EXCEEDED: A Core resource limit was exceeded.
+*/
+var matchParsedManifestScope = (manifest, paths, limits) => {
+	const compiled = compileManifestScope(manifest, limits);
+	const matches = [];
+	const matchedOwners = /* @__PURE__ */ new Set();
+	const matchedPaths = /* @__PURE__ */ new Set();
+	for (const path of paths) {
+		const firstSegment = path.slice(1).split("/", 1)[0] ?? "";
+		const exactDeclarations = compiled.exact.get(path) ?? [];
+		for (const relationship of exactDeclarations) addMatch(matches, path, relationship, limits);
+		addGlobMatches(matches, path, compiled.globalGlobs, limits);
+		addGlobMatches(matches, path, compiled.globsByFirstSegment.get(firstSegment) ?? [], limits);
+	}
+	matches.sort(compareMatches);
+	for (const match of matches) {
+		matchedOwners.add(`${match.owner.kind}\0${match.owner.agentId ?? ""}\0${match.owner.id}`);
+		matchedPaths.add(match.inputPath);
+	}
+	return freezeRecursively({
+		counts: {
+			declarations: compiled.declarations.length,
+			inputPaths: paths.length,
+			matchedOwners: matchedOwners.size,
+			matchedPaths: matchedPaths.size,
+			matches: matches.length
+		},
+		matches
+	});
+};
+//#endregion
+//#region src/manifest-validation/index.ts
+var childPointer = (pointer, key) => {
+	return `${pointer}/${escapeJsonPointerSegment(key)}`;
+};
+var addInvalidValue = (context, pointer, range, reason, entity = null) => {
+	context.diagnostics.add({
+		code: "MOLDEA_MANIFEST_VALUE_INVALID",
+		details: { reason },
+		entity,
+		path: context.path,
+		pointer,
+		range
+	});
+};
+var readMapping = (node, pointer, allowedProperties, context, entity = null) => {
+	if (node.kind !== "mapping") {
+		addInvalidValue(context, pointer, node.range, "mapping-required", entity);
+		return null;
+	}
+	const entries = /* @__PURE__ */ new Map();
+	for (const entry of node.entries) {
+		if (entry.key.kind !== "scalar" || typeof entry.key.value !== "string") {
+			addInvalidValue(context, pointer, entry.key.range, "string-key-required", entity);
+			continue;
+		}
+		const key = entry.key.value;
+		if (allowedProperties !== null && !allowedProperties.has(key)) {
+			context.diagnostics.add({
+				code: "MOLDEA_MANIFEST_PROPERTY_UNKNOWN",
+				entity,
+				path: context.path,
+				pointer: childPointer(pointer, key),
+				range: entry.key.range
+			});
+			continue;
+		}
+		entries.set(key, {
+			key: entry.key,
+			value: entry.value
+		});
+	}
+	return entries;
+};
+var readString = (entry, pointer, context, options = {}) => {
+	if (entry === void 0) {
+		if (options.required === true) addInvalidValue(context, pointer, null, "required", options.entity ?? null);
+		return null;
+	}
+	if (entry.value.kind !== "scalar" || typeof entry.value.value !== "string") {
+		addInvalidValue(context, pointer, entry.value.range, "string-required", options.entity ?? null);
+		return null;
+	}
+	const value = entry.value.value;
+	if (!hasNonWhitespace(value) || options.singleLine === true && !isNonEmptySingleLine(value)) {
+		addInvalidValue(context, pointer, entry.value.range, "string-invalid", options.entity ?? null);
+		return null;
+	}
+	return value;
+};
+var validateStableId = (value, range, pointer, context, entity = null) => {
+	if (!isStableId(value)) {
+		context.diagnostics.add({
+			code: "MOLDEA_ID_INVALID",
+			entity,
+			path: context.path,
+			pointer,
+			range
+		});
+		return false;
+	}
+	if (isReservedId(value)) {
+		context.diagnostics.add({
+			code: "MOLDEA_ID_RESERVED",
+			entity,
+			path: context.path,
+			pointer,
+			range
+		});
+		return false;
+	}
+	return true;
+};
+var readReference = (node, pointer, context, entity = null) => {
+	const entries = readMapping(node, pointer, /* @__PURE__ */ new Set(["path", "symbol"]), context, entity);
+	if (entries === null) return null;
+	const pathEntry = entries.get("path");
+	if (pathEntry?.value.kind !== "scalar" || typeof pathEntry.value.value !== "string") {
+		context.diagnostics.add({
+			code: "MOLDEA_PATH_INVALID",
+			details: { reason: pathEntry === void 0 ? "missing" : "type" },
+			entity,
+			path: context.path,
+			pointer: childPointer(pointer, "path"),
+			range: pathEntry?.value.range ?? null
+		});
+		return null;
+	}
+	const path = parseManifestPath(pathEntry.value.value);
+	if (path === null) {
+		context.diagnostics.add({
+			code: "MOLDEA_PATH_INVALID",
+			entity,
+			path: context.path,
+			pointer: childPointer(pointer, "path"),
+			range: pathEntry.value.range
+		});
+		return null;
+	}
+	const symbolEntry = entries.get("symbol");
+	if (symbolEntry === void 0) return { path };
+	if (symbolEntry.value.kind !== "scalar" || typeof symbolEntry.value.value !== "string" || !isRepositorySymbol(symbolEntry.value.value)) {
+		context.diagnostics.add({
+			code: "MOLDEA_SYMBOL_INVALID",
+			entity,
+			path: context.path,
+			pointer: childPointer(pointer, "symbol"),
+			range: symbolEntry.value.range
+		});
+		return null;
+	}
+	if (isCanonicalMoldeaPath(path)) {
+		context.diagnostics.add({
+			code: "MOLDEA_SYMBOL_FORBIDDEN",
+			entity,
+			path: context.path,
+			pointer: childPointer(pointer, "symbol"),
+			range: symbolEntry.value.range
+		});
+		return null;
+	}
+	return {
+		path,
+		symbol: symbolEntry.value.value
+	};
+};
+var readReferenceList = (node, pointer, context, entity = null) => {
+	if (node.kind !== "sequence" || node.items.length === 0) {
+		addInvalidValue(context, pointer, node.range, "non-empty-sequence-required", entity);
+		return [];
+	}
+	const references = [];
+	const seen = /* @__PURE__ */ new Set();
+	node.items.forEach((item, index) => {
+		const reference = readReference(item, childPointer(pointer, String(index)), context, entity);
+		if (reference === null) return;
+		const key = `${reference.path}\0${reference.symbol ?? ""}`;
+		if (seen.has(key)) {
+			context.diagnostics.add({
+				code: "MOLDEA_PATH_DUPLICATE",
+				entity,
+				path: context.path,
+				pointer: childPointer(pointer, String(index)),
+				range: item.range
+			});
+			return;
+		}
+		seen.add(key);
+		references.push(reference);
+	});
+	return sortRepositoryReferences(references);
+};
+var readAffectedBy = (node, pointer, context, entity = null) => {
+	if (node.kind !== "sequence" || node.items.length === 0) {
+		addInvalidValue(context, pointer, node.range, "non-empty-sequence-required", entity);
+		return [];
+	}
+	const values = [];
+	const seen = /* @__PURE__ */ new Set();
+	node.items.forEach((item, index) => {
+		const itemPointer = childPointer(pointer, String(index));
+		if (item.kind !== "scalar" || typeof item.value !== "string") {
+			addInvalidValue(context, itemPointer, item.range, "string-required", entity);
+			return;
+		}
+		const isGlob = item.value.includes("*") || hasUnsupportedGlobMetacharacter(item.value);
+		if (!(isGlob ? isSimpleGlob(item.value) : parseManifestPath(item.value) !== null)) {
+			context.diagnostics.add({
+				code: isGlob ? "MOLDEA_GLOB_INVALID" : "MOLDEA_PATH_INVALID",
+				entity,
+				path: context.path,
+				pointer: itemPointer,
+				range: item.range
+			});
+			return;
+		}
+		if (seen.has(item.value)) {
+			context.diagnostics.add({
+				code: isGlob ? "MOLDEA_PATTERN_DUPLICATE" : "MOLDEA_PATH_DUPLICATE",
+				entity,
+				path: context.path,
+				pointer: itemPointer,
+				range: item.range
+			});
+			return;
+		}
+		seen.add(item.value);
+		values.push(item.value);
+	});
+	return values.sort(compareExactStrings);
+};
+var readRelationship = (node, pointer, context) => {
+	const entries = readMapping(node, pointer, /* @__PURE__ */ new Set(["affectedBy", "bindings"]), context);
+	if (entries === null) return null;
+	const bindingsEntry = entries.get("bindings");
+	const affectedByEntry = entries.get("affectedBy");
+	if (bindingsEntry === void 0 && affectedByEntry === void 0) context.diagnostics.add({
+		code: "MOLDEA_CONTEXT_RELATIONSHIP_EMPTY",
+		path: context.path,
+		pointer,
+		range: node.range
+	});
+	return {
+		...bindingsEntry === void 0 ? {} : { bindings: readReferenceList(bindingsEntry.value, childPointer(pointer, "bindings"), context) },
+		...affectedByEntry === void 0 ? {} : { affectedBy: readAffectedBy(affectedByEntry.value, childPointer(pointer, "affectedBy"), context) }
+	};
+};
+var readRelationshipRecord = (node, pointer, kind, context) => {
+	const entries = readMapping(node, pointer, null, context);
+	if (entries === null) return null;
+	const normalized = [];
+	for (const [key, entry] of [...entries].sort(([left], [right]) => compareExactStrings(left, right))) {
+		const path = parseManifestPath(key);
+		if (!(path !== null && (kind === "context" ? isContextPath(path, true) : isDecisionPath(path)))) {
+			context.diagnostics.add({
+				code: kind === "context" ? "MOLDEA_CONTEXT_PATH_INVALID" : "MOLDEA_DECISION_FILENAME_INVALID",
+				path: context.path,
+				pointer: childPointer(pointer, key),
+				range: entry.key.range
+			});
+			continue;
+		}
+		const relationship = readRelationship(entry.value, childPointer(pointer, key), context);
+		if (relationship !== null) normalized.push([key, relationship]);
+	}
+	return createNullPrototypeRecord(normalized);
+};
+var readPathList = (node, pointer, kind, context, entity) => {
+	if (node.kind !== "sequence") {
+		addInvalidValue(context, pointer, node.range, "sequence-required", entity);
+		return [];
+	}
+	const paths = [];
+	const seen = /* @__PURE__ */ new Set();
+	node.items.forEach((item, index) => {
+		const itemPointer = childPointer(pointer, String(index));
+		if (item.kind !== "scalar" || typeof item.value !== "string") {
+			addInvalidValue(context, itemPointer, item.range, "string-required", entity);
+			return;
+		}
+		const path = parseManifestPath(item.value);
+		if (!(path !== null && (kind === "context" ? isContextPath(path, false) : kind === "decision" ? isDecisionPath(path) : isMirrorPath(path))) || path === null) {
+			const code = kind === "context" ? "MOLDEA_CONTEXT_PATH_INVALID" : kind === "decision" ? "MOLDEA_DECISION_FILENAME_INVALID" : path !== null && !isMirrorPath(path) ? "MOLDEA_MIRROR_PATH_INSIDE_MOLDEA" : "MOLDEA_MIRROR_PATH_INVALID";
+			context.diagnostics.add({
+				code,
+				entity,
+				path: context.path,
+				pointer: itemPointer,
+				range: item.range
+			});
+			return;
+		}
+		if (seen.has(path)) {
+			context.diagnostics.add({
+				code: kind === "mirror" ? "MOLDEA_MIRROR_PATH_DUPLICATE" : "MOLDEA_PATH_DUPLICATE",
+				entity,
+				path: context.path,
+				pointer: itemPointer,
+				range: item.range
+			});
+			return;
+		}
+		if (kind === "mirror" && context.mirrorPaths.has(path)) {
+			context.diagnostics.add({
+				code: "MOLDEA_MIRROR_PATH_DUPLICATE",
+				entity,
+				path: context.path,
+				pointer: itemPointer,
+				range: item.range
+			});
+			return;
+		}
+		seen.add(path);
+		if (kind === "mirror") context.mirrorPaths.add(path);
+		paths.push(path);
+	});
+	return paths.sort(compareExactStrings);
+};
+var readRuntime = (node, pointer, context, agentId) => {
+	const entity = { agentId };
+	const entries = readMapping(node, pointer, /* @__PURE__ */ new Set(["guidance", "id"]), context, entity);
+	if (entries === null) return null;
+	const idEntry = entries.get("id");
+	if (idEntry?.value.kind !== "scalar" || typeof idEntry.value.value !== "string") {
+		context.diagnostics.add({
+			code: "MOLDEA_RUNTIME_ID_INVALID",
+			entity,
+			path: context.path,
+			pointer: childPointer(pointer, "id"),
+			range: idEntry?.value.range ?? null
+		});
+		return null;
+	}
+	const id = idEntry.value.value;
+	if (!isStableId(id) || isReservedId(id) || !RECOGNIZED_RUNTIME_IDS.includes(id)) context.diagnostics.add({
+		code: "MOLDEA_RUNTIME_ID_INVALID",
+		entity,
+		path: context.path,
+		pointer: childPointer(pointer, "id"),
+		range: idEntry.value.range
+	});
+	const guidanceEntry = entries.get("guidance");
+	let guidance = null;
+	if (guidanceEntry !== void 0) {
+		if (guidanceEntry.value.kind === "scalar" && typeof guidanceEntry.value.value === "string") {
+			const candidate = parseManifestPath(guidanceEntry.value.value);
+			if (candidate !== null && isRuntimeGuidancePath(candidate)) guidance = candidate;
+			else context.diagnostics.add({
+				code: "MOLDEA_PATH_INVALID",
+				details: { reason: "runtime-guidance" },
+				entity,
+				path: context.path,
+				pointer: childPointer(pointer, "guidance"),
+				range: guidanceEntry.value.range
+			});
+		} else context.diagnostics.add({
+			code: "MOLDEA_PATH_INVALID",
+			details: { reason: "runtime-guidance" },
+			entity,
+			path: context.path,
+			pointer: childPointer(pointer, "guidance"),
+			range: guidanceEntry.value.range
+		});
+	}
+	return {
+		id,
+		...guidance === null ? {} : { guidance }
+	};
+};
+var readVariables = (node, pointer, context, agentId) => {
+	const entries = readMapping(node, pointer, null, context, { agentId });
+	if (entries === null) return null;
+	const normalized = [];
+	for (const [variableId, entry] of [...entries].sort(([left], [right]) => compareExactStrings(left, right))) {
+		const entity = {
+			agentId,
+			variableId
+		};
+		if (!isVariableId(variableId)) context.diagnostics.add({
+			code: "MOLDEA_VARIABLE_ID_INVALID",
+			entity,
+			path: context.path,
+			pointer: childPointer(pointer, variableId),
+			range: entry.key.range
+		});
+		const variablePointer = childPointer(pointer, variableId);
+		const variableEntries = readMapping(entry.value, variablePointer, /* @__PURE__ */ new Set(["description"]), context, entity);
+		if (variableEntries === null) continue;
+		const description = readString(variableEntries.get("description"), childPointer(variablePointer, "description"), context, {
+			entity,
+			required: true
+		});
+		if (description !== null) normalized.push([variableId, { description }]);
+	}
+	return createNullPrototypeRecord(normalized);
+};
+var readBindings = (node, pointer, context, agentId, declaredVariables) => {
+	const entity = { agentId };
+	const entries = readMapping(node, pointer, /* @__PURE__ */ new Set([
+		"inputSchema",
+		"instructionLoader",
+		"outputSchema",
+		"runtimeAgent",
+		"variableProviders"
+	]), context, entity);
+	if (entries === null) return null;
+	const referenceProperty = (key) => {
+		const entry = entries.get(key);
+		return entry === void 0 ? null : readReference(entry.value, childPointer(pointer, key), context, entity);
+	};
+	const inputSchema = referenceProperty("inputSchema");
+	const instructionLoader = referenceProperty("instructionLoader");
+	const outputSchema = referenceProperty("outputSchema");
+	const runtimeAgent = referenceProperty("runtimeAgent");
+	const providersEntry = entries.get("variableProviders");
+	let variableProviders = null;
+	if (providersEntry !== void 0) {
+		const providers = readMapping(providersEntry.value, childPointer(pointer, "variableProviders"), null, context, entity);
+		if (providers !== null) {
+			const normalized = [];
+			for (const [variableId, providerEntry] of [...providers].sort(([left], [right]) => compareExactStrings(left, right))) {
+				const variableEntity = {
+					agentId,
+					variableId
+				};
+				const providerPointer = childPointer(childPointer(pointer, "variableProviders"), variableId);
+				if (!isVariableId(variableId)) context.diagnostics.add({
+					code: "MOLDEA_VARIABLE_ID_INVALID",
+					entity: variableEntity,
+					path: context.path,
+					pointer: providerPointer,
+					range: providerEntry.key.range
+				});
+				else if (!declaredVariables.has(variableId)) context.diagnostics.add({
+					code: "MOLDEA_VARIABLE_PROVIDER_UNDECLARED",
+					entity: variableEntity,
+					path: context.path,
+					pointer: providerPointer,
+					range: providerEntry.key.range
+				});
+				const reference = readReference(providerEntry.value, providerPointer, context, variableEntity);
+				if (reference !== null) normalized.push([variableId, reference]);
+			}
+			variableProviders = createNullPrototypeRecord(normalized);
+		}
+	}
+	return {
+		...runtimeAgent === null ? {} : { runtimeAgent },
+		...inputSchema === null ? {} : { inputSchema },
+		...outputSchema === null ? {} : { outputSchema },
+		...instructionLoader === null ? {} : { instructionLoader },
+		...variableProviders === null ? {} : { variableProviders }
+	};
+};
+var readCapability = (node, pointer, context, agentId, capabilityId, kind) => {
+	const entity = {
+		agentId,
+		capabilityId,
+		capabilityKind: kind
+	};
+	const entries = readMapping(node, pointer, kind === "tool" ? /* @__PURE__ */ new Set([
+		"affectedBy",
+		"description",
+		"implementation",
+		"inputSchema",
+		"name",
+		"outputSchema",
+		"registration"
+	]) : /* @__PURE__ */ new Set([
+		"affectedBy",
+		"description",
+		"implementation",
+		"name",
+		"registration"
+	]), context, entity);
+	if (entries === null) return null;
+	const name = readString(entries.get("name"), childPointer(pointer, "name"), context, {
+		entity,
+		required: true,
+		singleLine: true
+	});
+	const descriptionEntry = entries.get("description");
+	let description = null;
+	if (descriptionEntry === void 0) context.diagnostics.add({
+		code: "MOLDEA_CAPABILITY_DESCRIPTION_MISSING",
+		entity,
+		path: context.path,
+		pointer: childPointer(pointer, "description")
+	});
+	else if (descriptionEntry.value.kind !== "scalar" || typeof descriptionEntry.value.value !== "string" || !isCapabilityDescription(descriptionEntry.value.value)) context.diagnostics.add({
+		code: "MOLDEA_CAPABILITY_DESCRIPTION_INVALID",
+		entity,
+		path: context.path,
+		pointer: childPointer(pointer, "description"),
+		range: descriptionEntry.value.range
+	});
+	else description = descriptionEntry.value.value;
+	const implementationEntry = entries.get("implementation");
+	let implementation = null;
+	if (implementationEntry === void 0) context.diagnostics.add({
+		code: kind === "tool" ? "MOLDEA_TOOL_IMPLEMENTATION_MISSING" : "MOLDEA_SKILL_IMPLEMENTATION_MISSING",
+		entity,
+		path: context.path,
+		pointer: childPointer(pointer, "implementation")
+	});
+	else implementation = readReference(implementationEntry.value, childPointer(pointer, "implementation"), context, entity);
+	const optionalReference = (key) => {
+		const entry = entries.get(key);
+		return entry === void 0 ? null : readReference(entry.value, childPointer(pointer, key), context, entity);
+	};
+	const registration = optionalReference("registration");
+	const inputSchema = kind === "tool" ? optionalReference("inputSchema") : null;
+	const outputSchema = kind === "tool" ? optionalReference("outputSchema") : null;
+	const affectedByEntry = entries.get("affectedBy");
+	const affectedBy = affectedByEntry === void 0 ? null : readAffectedBy(affectedByEntry.value, childPointer(pointer, "affectedBy"), context, entity);
+	if (name === null || description === null || implementation === null) return null;
+	return {
+		name,
+		description,
+		implementation,
+		...registration === null ? {} : { registration },
+		...inputSchema === null ? {} : { inputSchema },
+		...outputSchema === null ? {} : { outputSchema },
+		...affectedBy === null ? {} : { affectedBy }
+	};
+};
+var readCapabilities = (node, pointer, context, agentId, kind) => {
+	const entries = readMapping(node, pointer, null, context, { agentId });
+	if (entries === null) return null;
+	const normalized = [];
+	for (const [capabilityId, entry] of [...entries].sort(([left], [right]) => compareExactStrings(left, right))) {
+		const entity = {
+			agentId,
+			capabilityId,
+			capabilityKind: kind
+		};
+		const capabilityPointer = childPointer(pointer, capabilityId);
+		validateStableId(capabilityId, entry.key.range, capabilityPointer, context, entity);
+		const capability = readCapability(entry.value, capabilityPointer, context, agentId, capabilityId, kind);
+		if (capability !== null) normalized.push([capabilityId, capability]);
+	}
+	return createNullPrototypeRecord(normalized);
+};
+var readUnresolved = (node, pointer, context, agentId) => {
+	const entries = readMapping(node, pointer, null, context, agentId === void 0 ? null : { agentId });
+	if (entries === null) return null;
+	const normalized = [];
+	for (const [requirementId, entry] of [...entries].sort(([left], [right]) => compareExactStrings(left, right))) {
+		const entity = agentId === void 0 ? null : { agentId };
+		const requirementPointer = childPointer(pointer, requirementId);
+		validateStableId(requirementId, entry.key.range, requirementPointer, context, entity);
+		const requirementEntries = readMapping(entry.value, requirementPointer, /* @__PURE__ */ new Set([
+			"category",
+			"description",
+			"effect",
+			"reference",
+			"related",
+			"resolution"
+		]), context, entity);
+		if (requirementEntries === null) continue;
+		const category = readString(requirementEntries.get("category"), childPointer(requirementPointer, "category"), context, {
+			...entity === null ? {} : { entity },
+			required: true
+		});
+		if (category !== null && !isStableId(category)) context.diagnostics.add({
+			code: "MOLDEA_ID_INVALID",
+			entity,
+			path: context.path,
+			pointer: childPointer(requirementPointer, "category"),
+			range: requirementEntries.get("category")?.value.range ?? null
+		});
+		const effectEntry = requirementEntries.get("effect");
+		let effect = null;
+		if (effectEntry?.value.kind === "scalar" && (effectEntry.value.value === "blocking" || effectEntry.value.value === "warning" || effectEntry.value.value === "informational")) effect = effectEntry.value.value;
+		else addInvalidValue(context, childPointer(requirementPointer, "effect"), effectEntry?.value.range ?? null, effectEntry === void 0 ? "required" : "enum", entity);
+		const description = readString(requirementEntries.get("description"), childPointer(requirementPointer, "description"), context, {
+			...entity === null ? {} : { entity },
+			required: true
+		});
+		const resolution = readString(requirementEntries.get("resolution"), childPointer(requirementPointer, "resolution"), context, {
+			...entity === null ? {} : { entity },
+			required: true
+		});
+		const relatedEntry = requirementEntries.get("related");
+		const related = relatedEntry === void 0 ? null : readReferenceList(relatedEntry.value, childPointer(requirementPointer, "related"), context, entity);
+		const reference = readString(requirementEntries.get("reference"), childPointer(requirementPointer, "reference"), context, {
+			...entity === null ? {} : { entity },
+			singleLine: true
+		});
+		if (category !== null && effect !== null && description !== null && resolution !== null) normalized.push([requirementId, {
+			category,
+			effect,
+			description,
+			resolution,
+			...related === null ? {} : { related },
+			...reference === null ? {} : { reference }
+		}]);
+	}
+	return createNullPrototypeRecord(normalized);
+};
+var findMappingProperty = (node, property) => {
+	if (node.kind !== "mapping") return null;
+	for (const entry of node.entries) if (entry.key.kind === "scalar" && entry.key.value === property) return entry.value;
+	return null;
+};
+/**
+* Detects a supported repository-format version without treating the remaining manifest as valid.
+* @param node The trustworthy strict-YAML manifest root.
+* @returns The supported parsed version when its declaration is independently unambiguous.
+*/
+var detectSupportedManifestVersion = (node) => {
+	if (node.kind !== "mapping") return null;
+	const versionNode = findMappingProperty(node, "version");
+	return versionNode?.kind === "scalar" && versionNode.value === 1n ? 1 : null;
+};
+var validateAgentOwnedIdUniqueness = (node, pointer, context, agentId) => {
+	const seen = /* @__PURE__ */ new Set();
+	for (const property of [
+		"tools",
+		"skills",
+		"unresolved"
+	]) {
+		const record = findMappingProperty(node, property);
+		if (record?.kind !== "mapping") continue;
+		for (const entry of record.entries) {
+			if (entry.key.kind !== "scalar" || typeof entry.key.value !== "string") continue;
+			if (seen.has(entry.key.value)) context.diagnostics.add({
+				code: "MOLDEA_ID_DUPLICATE",
+				entity: { agentId },
+				path: context.path,
+				pointer: childPointer(childPointer(pointer, property), entry.key.value),
+				range: entry.key.range
+			});
+			seen.add(entry.key.value);
+		}
+	}
+};
+var readAgent = (node, pointer, context, agentId) => {
+	const entity = { agentId };
+	const entries = readMapping(node, pointer, /* @__PURE__ */ new Set([
+		"affectedBy",
+		"bindings",
+		"context",
+		"decisions",
+		"runtime",
+		"mirrors",
+		"skills",
+		"tools",
+		"unresolved",
+		"variables"
+	]), context, entity);
+	if (entries === null) return null;
+	validateAgentOwnedIdUniqueness(node, pointer, context, agentId);
+	const runtimeEntry = entries.get("runtime");
+	let runtime = null;
+	if (runtimeEntry === void 0) addInvalidValue(context, childPointer(pointer, "runtime"), null, "required", entity);
+	else runtime = readRuntime(runtimeEntry.value, childPointer(pointer, "runtime"), context, agentId);
+	const variablesEntry = entries.get("variables");
+	const variables = variablesEntry === void 0 ? null : readVariables(variablesEntry.value, childPointer(pointer, "variables"), context, agentId);
+	const declaredVariables = new Set(Object.keys(variables ?? {}));
+	const bindingsEntry = entries.get("bindings");
+	const bindings = bindingsEntry === void 0 ? null : readBindings(bindingsEntry.value, childPointer(pointer, "bindings"), context, agentId, declaredVariables);
+	const contextEntry = entries.get("context");
+	const contextPaths = contextEntry === void 0 ? null : readPathList(contextEntry.value, childPointer(pointer, "context"), "context", context, entity);
+	const decisionsEntry = entries.get("decisions");
+	const decisions = decisionsEntry === void 0 ? null : readPathList(decisionsEntry.value, childPointer(pointer, "decisions"), "decision", context, entity);
+	const toolsEntry = entries.get("tools");
+	const tools = toolsEntry === void 0 ? null : readCapabilities(toolsEntry.value, childPointer(pointer, "tools"), context, agentId, "tool");
+	const skillsEntry = entries.get("skills");
+	const skills = skillsEntry === void 0 ? null : readCapabilities(skillsEntry.value, childPointer(pointer, "skills"), context, agentId, "skill");
+	const affectedByEntry = entries.get("affectedBy");
+	const affectedBy = affectedByEntry === void 0 ? null : readAffectedBy(affectedByEntry.value, childPointer(pointer, "affectedBy"), context, entity);
+	const mirrorsEntry = entries.get("mirrors");
+	const mirrors = mirrorsEntry === void 0 ? null : readPathList(mirrorsEntry.value, childPointer(pointer, "mirrors"), "mirror", context, entity);
+	const unresolvedEntry = entries.get("unresolved");
+	const unresolved = unresolvedEntry === void 0 ? null : readUnresolved(unresolvedEntry.value, childPointer(pointer, "unresolved"), context, agentId);
+	if (runtime === null) return null;
+	return {
+		runtime,
+		...contextPaths === null ? {} : { context: contextPaths },
+		...decisions === null ? {} : { decisions },
+		...variables === null ? {} : { variables },
+		...bindings === null ? {} : { bindings },
+		...tools === null ? {} : { tools },
+		...skills === null ? {} : { skills },
+		...affectedBy === null ? {} : { affectedBy },
+		...mirrors === null ? {} : { mirrors },
+		...unresolved === null ? {} : { unresolved }
+	};
+};
+var readAgents = (node, pointer, context) => {
+	const entries = readMapping(node, pointer, null, context);
+	if (entries === null) return null;
+	const normalized = [];
+	for (const [agentId, entry] of [...entries].sort(([left], [right]) => compareExactStrings(left, right))) {
+		const agentPointer = childPointer(pointer, agentId);
+		validateStableId(agentId, entry.key.range, agentPointer, context, { agentId });
+		const agent = readAgent(entry.value, agentPointer, context, agentId);
+		if (agent !== null) normalized.push([agentId, agent]);
+	}
+	return createNullPrototypeRecord(normalized);
+};
+/**
+* Validates the closed warning-acceptance contract with field-specific diagnostics.
+* @returns Valid acceptance entries; diagnostics invalidate the complete manifest on any bad entry.
+* @throws
+* - RESOURCE_LIMIT_EXCEEDED: A Core resource limit was exceeded.
+*/
+var readAcceptedWarnings = (node, context) => {
+	const report = (entry, field, range, reason) => {
+		context.diagnostics.add({
+			code: "MOLDEA_MANIFEST_VALUE_INVALID",
+			path: context.path,
+			pointer: entry === null ? "/acceptedWarnings" : `/acceptedWarnings/${entry}/${escapeJsonPointerSegment(field)}`,
+			range,
+			details: {
+				entry,
+				field,
+				reason
+			}
+		});
+	};
+	if (node.kind !== "sequence") {
+		report(null, "acceptedWarnings", node.range, "sequence-required");
+		return null;
+	}
+	if (node.items.length > context.limits.maxAcceptedWarnings) throw new CoreOperationException({
+		code: "RESOURCE_LIMIT_EXCEEDED",
+		operation: context.operation,
+		limit: "maxAcceptedWarnings",
+		limitMaximum: context.limits.maxAcceptedWarnings,
+		observedUsage: node.items.length,
+		nextAction: "reduce-input-or-increase-limit"
+	});
+	const accepted = [];
+	const identities = /* @__PURE__ */ new Set();
+	for (const [index, item] of node.items.entries()) {
+		if (item.kind !== "mapping") {
+			report(index, "entry", item.range, "mapping-required");
+			continue;
+		}
+		const fields = /* @__PURE__ */ new Map();
+		let isValid = true;
+		for (const entry of item.entries) if (entry.key.kind !== "scalar" || typeof entry.key.value !== "string" || ![
+			"code",
+			"subject",
+			"qualifier",
+			"reason"
+		].includes(entry.key.value)) {
+			report(index, entry.key.kind === "scalar" && typeof entry.key.value === "string" ? entry.key.value : "key", entry.key.range, "unknown-field");
+			isValid = false;
+		} else fields.set(entry.key.value, entry.value);
+		const scalar = (field) => {
+			const value = fields.get(field);
+			if (value?.kind !== "scalar" || typeof value.value !== "string" || !hasNonWhitespace(value.value)) {
+				report(index, field, value?.range ?? item.range, value === void 0 ? "required" : "non-empty-string-required");
+				isValid = false;
+				return null;
+			}
+			return value.value;
+		};
+		const code = scalar("code");
+		const subjectText = scalar("subject");
+		const reason = scalar("reason");
+		const subject = subjectText === null ? null : parseManifestPath(subjectText);
+		const qualifierNode = fields.get("qualifier");
+		let qualifier = null;
+		if (qualifierNode !== void 0 && !(qualifierNode.kind === "scalar" && qualifierNode.value === null)) {
+			qualifier = scalar("qualifier");
+			if (qualifier !== null && !isNonEmptySingleLine(qualifier)) {
+				report(index, "qualifier", qualifierNode.range, "single-line-required");
+				isValid = false;
+			}
+		}
+		const acceptedCode = ACCEPTABLE_WARNING_CODES.find((candidate) => candidate === code);
+		if (code !== null && acceptedCode === void 0) {
+			report(index, "code", fields.get("code").range, "code-not-acceptable");
+			isValid = false;
+		}
+		if (subjectText !== null && subject === null) {
+			report(index, "subject", fields.get("subject").range, "repository-path-required");
+			isValid = false;
+		}
+		if (reason !== null && countUnicodeScalars$1(reason) > 256) {
+			report(index, "reason", fields.get("reason").range, "maximum-256-characters");
+			isValid = false;
+		}
+		if (!isValid || acceptedCode === void 0 || subject === null || reason === null) continue;
+		const identity = JSON.stringify([
+			acceptedCode,
+			subject,
+			qualifier
+		]);
+		if (identities.has(identity)) {
+			report(index, "code", fields.get("code").range, "duplicate-identity");
+			continue;
+		}
+		identities.add(identity);
+		accepted.push({
+			code: acceptedCode,
+			subject,
+			...qualifierNode === void 0 ? {} : { qualifier },
+			reason
+		});
+	}
+	return accepted;
+};
+/**
+* Validates and normalizes a strict YAML document as a version 1 moldea manifest.
+* @param node The parser-neutral YAML root node.
+* @param path The canonical or caller-supplied logical manifest path.
+* @param diagnostics The operation diagnostic collector.
+* @param limits The immutable operation limits, including the acceptance-list bound.
+* @param operation The public operation receiving resource failures.
+* @returns The normalized manifest when its supported version can be interpreted.
+* @throws
+* - RESOURCE_LIMIT_EXCEEDED: A Core resource limit was exceeded.
+*/
+var validateManifest = (node, path, diagnostics, limits, operation) => {
+	const context = {
+		diagnostics,
+		operation,
+		limits,
+		mirrorPaths: /* @__PURE__ */ new Set(),
+		path
+	};
+	if (node.kind !== "mapping") {
+		diagnostics.add({
+			code: "MOLDEA_MANIFEST_ROOT_INVALID",
+			path,
+			range: node.range
+		});
+		return null;
+	}
+	const versionNode = findMappingProperty(node, "version");
+	if (versionNode === null) {
+		diagnostics.add({
+			code: "MOLDEA_MANIFEST_VERSION_MISSING",
+			path,
+			pointer: "/version"
+		});
+		return null;
+	}
+	if (!(versionNode.kind === "scalar" && typeof versionNode.value === "bigint") || versionNode.kind !== "scalar" || versionNode.value <= 0n) {
+		diagnostics.add({
+			code: "MOLDEA_MANIFEST_VERSION_INVALID",
+			path,
+			pointer: "/version",
+			range: versionNode.range
+		});
+		return null;
+	}
+	if (versionNode.value !== 1n) {
+		diagnostics.add({
+			code: "MOLDEA_MANIFEST_VERSION_UNSUPPORTED",
+			path,
+			pointer: "/version",
+			range: versionNode.range
+		});
+		return null;
+	}
+	const entries = readMapping(node, "", /* @__PURE__ */ new Set([
+		"acceptedWarnings",
+		"agents",
+		"context",
+		"decisions",
+		"unresolved",
+		"version"
+	]), context);
+	if (entries === null) return null;
+	const acceptedWarningsEntry = entries.get("acceptedWarnings");
+	const acceptedWarnings = acceptedWarningsEntry === void 0 ? null : readAcceptedWarnings(acceptedWarningsEntry.value, context);
+	const contextEntry = entries.get("context");
+	const contextRelationships = contextEntry === void 0 ? null : readRelationshipRecord(contextEntry.value, "/context", "context", context);
+	const decisionsEntry = entries.get("decisions");
+	const decisionRelationships = decisionsEntry === void 0 ? null : readRelationshipRecord(decisionsEntry.value, "/decisions", "decision", context);
+	const unresolvedEntry = entries.get("unresolved");
+	const unresolved = unresolvedEntry === void 0 ? null : readUnresolved(unresolvedEntry.value, "/unresolved", context);
+	const agentsEntry = entries.get("agents");
+	const agents = agentsEntry === void 0 ? null : readAgents(agentsEntry.value, "/agents", context);
+	return {
+		version: 1,
+		...acceptedWarnings === null ? {} : { acceptedWarnings },
+		...contextRelationships === null ? {} : { context: contextRelationships },
+		...decisionRelationships === null ? {} : { decisions: decisionRelationships },
+		...unresolved === null ? {} : { unresolved },
+		...agents === null ? {} : { agents }
+	};
+};
+//#endregion
+//#region src/source-location/index.ts
+var findLineIndex = (lineStarts, offset) => {
+	let lower = 0;
+	let upper = lineStarts.length - 1;
+	while (lower < upper) {
+		const middle = Math.ceil((lower + upper) / 2);
+		if ((lineStarts[middle] ?? 0) <= offset) lower = middle;
+		else upper = middle - 1;
+	}
+	return lower;
+};
+/**
+* Creates an efficient UTF-16-offset to Unicode-scalar source locator.
+* @param value The already-normalized valid Unicode scalar text.
+* @returns A locator producing one-based lines and columns with zero-based scalar offsets.
+*/
+var createSourceLocator = (value) => {
+	const scalarOffsets = new Uint32Array(value.length + 1);
+	const lineStarts = [0];
+	let scalarOffset = 0;
+	for (let codeUnitOffset = 0; codeUnitOffset < value.length;) {
+		const codePoint = value.codePointAt(codeUnitOffset);
+		const width = codePoint !== void 0 && codePoint > 65535 ? 2 : 1;
+		scalarOffsets[codeUnitOffset] = scalarOffset;
+		for (let interiorOffset = 1; interiorOffset < width; interiorOffset += 1) scalarOffsets[codeUnitOffset + interiorOffset] = scalarOffset;
+		codeUnitOffset += width;
+		scalarOffset += 1;
+		scalarOffsets[codeUnitOffset] = scalarOffset;
+		if (codePoint === 10) lineStarts.push(codeUnitOffset);
+	}
+	const locatePosition = (candidateOffset) => {
+		const codeUnitOffset = Math.max(0, Math.min(value.length, candidateOffset));
+		const lineIndex = findLineIndex(lineStarts, codeUnitOffset);
+		const lineStart = lineStarts[lineIndex] ?? 0;
+		const positionScalarOffset = scalarOffsets[codeUnitOffset] ?? 0;
+		return {
+			column: positionScalarOffset - (scalarOffsets[lineStart] ?? 0) + 1,
+			line: lineIndex + 1,
+			offset: positionScalarOffset
+		};
+	};
+	return Object.freeze({ locateRange: (startOffset, endOffset) => ({
+		end: locatePosition(endOffset),
+		start: locatePosition(startOffset)
+	}) });
+};
+//#endregion
+//#region src/yaml/index.ts
+var CORE_TAGS = /* @__PURE__ */ new Set([
+	"tag:yaml.org,2002:bool",
+	"tag:yaml.org,2002:float",
+	"tag:yaml.org,2002:int",
+	"tag:yaml.org,2002:map",
+	"tag:yaml.org,2002:null",
+	"tag:yaml.org,2002:seq",
+	"tag:yaml.org,2002:str"
+]);
+var toRange = (range, locator) => {
+	return locator.locateRange(range?.[0] ?? 0, range?.[1] ?? range?.[0] ?? 0);
+};
+var addUnsupportedFeature = (diagnostics, path, range, reason) => {
+	diagnostics.add({
+		code: "MOLDEA_YAML_FEATURE_UNSUPPORTED",
+		details: { reason },
+		path,
+		range
+	});
+};
+var isUnicodeScalarString = (value) => {
+	for (let index = 0; index < value.length; index += 1) {
+		const codeUnit = value.charCodeAt(index);
+		if (codeUnit >= 55296 && codeUnit <= 56319) {
+			const nextCodeUnit = value.charCodeAt(index + 1);
+			if (!(nextCodeUnit >= 56320 && nextCodeUnit <= 57343)) return false;
+			index += 1;
+		} else if (codeUnit >= 56320 && codeUnit <= 57343) return false;
+	}
+	return true;
+};
+var isCoreTagCompatible = (node) => {
+	switch (node.tag) {
+		case "tag:yaml.org,2002:bool": return isScalar(node) && typeof node.value === "boolean";
+		case "tag:yaml.org,2002:float": return isScalar(node) && typeof node.value === "number";
+		case "tag:yaml.org,2002:int": return isScalar(node) && typeof node.value === "bigint";
+		case "tag:yaml.org,2002:map": return isMap(node);
+		case "tag:yaml.org,2002:null": return isScalar(node) && node.value === null;
+		case "tag:yaml.org,2002:seq": return isSeq(node);
+		case "tag:yaml.org,2002:str": return isScalar(node) && typeof node.value === "string";
+		default: return false;
+	}
+};
+var convertNode = (node, path, locator, diagnostics) => {
+	const range = toRange(node.range, locator);
+	if (isAlias(node)) {
+		addUnsupportedFeature(diagnostics, path, range, "alias");
+		return null;
+	}
+	if ("anchor" in node && typeof node.anchor === "string") addUnsupportedFeature(diagnostics, path, range, "anchor");
+	if (node.tag !== void 0) {
+		if (!CORE_TAGS.has(node.tag)) {
+			addUnsupportedFeature(diagnostics, path, range, "custom-tag");
+			return null;
+		}
+		if (!isCoreTagCompatible(node)) {
+			diagnostics.add({
+				code: "MOLDEA_YAML_MALFORMED",
+				details: { reason: "tag-value" },
+				path,
+				range
+			});
+			return null;
+		}
+	}
+	if (isScalar(node)) {
+		const value = node.value;
+		if (value !== null && typeof value !== "string" && typeof value !== "number" && typeof value !== "bigint" && typeof value !== "boolean") {
+			diagnostics.add({
+				code: "MOLDEA_YAML_MALFORMED",
+				details: { reason: "scalar-type" },
+				path,
+				range
+			});
+			return null;
+		}
+		if (typeof value === "string" && !isUnicodeScalarString(value)) {
+			diagnostics.add({
+				code: "MOLDEA_YAML_MALFORMED",
+				details: { reason: "invalid-unicode" },
+				path,
+				range
+			});
+			return null;
+		}
+		return {
+			kind: "scalar",
+			range,
+			source: node.source,
+			style: node.type ?? null,
+			value
+		};
+	}
+	if (isSeq(node)) {
+		const items = [];
+		for (const item of node.items) {
+			if (item === null) {
+				items.push({
+					kind: "scalar",
+					range,
+					source: "",
+					style: null,
+					value: null
+				});
+				continue;
+			}
+			const converted = convertNode(item, path, locator, diagnostics);
+			if (converted !== null) items.push(converted);
+		}
+		return {
+			items,
+			kind: "sequence",
+			range
+		};
+	}
+	if (isMap(node)) {
+		const entries = [];
+		for (const pair of node.items) {
+			const key = convertNode(pair.key, path, locator, diagnostics);
+			const value = pair.value === null ? {
+				kind: "scalar",
+				range: key?.range ?? range,
+				source: "",
+				style: null,
+				value: null
+			} : convertNode(pair.value, path, locator, diagnostics);
+			if (key?.kind === "scalar" && key.value === "<<" && key.style === "PLAIN") addUnsupportedFeature(diagnostics, path, key.range, "merge-key");
+			if (key !== null && value !== null) entries.push({
+				key,
+				value
+			});
+		}
+		return {
+			entries,
+			kind: "mapping",
+			range
+		};
+	}
+	diagnostics.add({
+		code: "MOLDEA_YAML_MALFORMED",
+		details: { reason: "node-type" },
+		path,
+		range
+	});
+	return null;
+};
+var addParserDiagnostic = (code, start, end, path, locator, diagnostics) => {
+	if (code === "BAD_DIRECTIVE") return;
+	if (code === "DUPLICATE_KEY") {
+		diagnostics.add({
+			code: "MOLDEA_YAML_DUPLICATE_KEY",
+			path,
+			range: locator.locateRange(start, end)
+		});
+		return;
+	}
+	if (code === "TAG_RESOLVE_FAILED") return;
+	diagnostics.add({
+		code: "MOLDEA_YAML_MALFORMED",
+		details: { reason: code === "RESOURCE_EXHAUSTION" ? "resource-exhaustion" : "syntax" },
+		path,
+		range: locator.locateRange(start, end)
+	});
+};
+/**
+* Parses one normalized YAML 1.2 Core Schema document into parser-neutral nodes.
+* @param value The normalized manifest text.
+* @param path The logical source path used by diagnostics.
+* @param locator The scalar-aware source locator for the normalized text.
+* @param diagnostics The operation diagnostic collector.
+* @returns The private parsed tree only when the YAML substrate is trustworthy.
+*/
+var parseStrictYaml = (value, path, locator, diagnostics) => {
+	const initialDiagnosticCount = diagnostics.size;
+	for (const token of new Parser().parse(value)) if (token.type === "directive") addUnsupportedFeature(diagnostics, path, locator.locateRange(token.offset, token.offset + token.source.length), "directive");
+	const documents = parseAllDocuments(value, {
+		intAsBigInt: true,
+		keepSourceTokens: true,
+		logLevel: "silent",
+		merge: false,
+		prettyErrors: false,
+		resolveKnownTags: false,
+		schema: "core",
+		strict: true,
+		uniqueKeys: true,
+		version: "1.2"
+	});
+	if (documents.length > 1) {
+		const range = documents[1]?.range;
+		diagnostics.add({
+			code: "MOLDEA_YAML_MULTIPLE_DOCUMENTS",
+			path,
+			range: locator.locateRange(range?.[0] ?? 0, range?.[0] ?? 0)
+		});
+	}
+	for (const document of documents) for (const error of [...document.errors, ...document.warnings]) addParserDiagnostic(error.code, error.pos[0], error.pos[1], path, locator, diagnostics);
+	if (documents.length > 1 || diagnostics.size > initialDiagnosticCount) return {
+		valid: false,
+		value: null
+	};
+	const document = documents[0];
+	if (document === void 0 || document.contents === null) return {
+		valid: true,
+		value: {
+			kind: "scalar",
+			range: locator.locateRange(0, 0),
+			source: "",
+			style: null,
+			value: null
+		}
+	};
+	const parsedValue = convertNode(document.contents, path, locator, diagnostics);
+	return {
+		valid: parsedValue !== null && diagnostics.size === initialDiagnosticCount,
+		value: diagnostics.size === initialDiagnosticCount ? parsedValue : null
+	};
+};
+//#endregion
+//#region src/manifest/index.ts
+/**
+* Inspects one complete manifest while retaining an independently trustworthy supported version.
+* @param input The canonical logical path and exact manifest text or bytes.
+* @param options The immutable Core limit snapshot.
+* @param operation The owning public or repository-level operation for typed failures.
+* @returns Frozen inspection state with all-or-nothing manifest assets and values.
+* @throws
+* - INVALID_REPOSITORY_PATH: The repository path is invalid.
+* - INVALID_ARGUMENT: The Core operation received an invalid argument.
+* - RESOURCE_LIMIT_EXCEEDED: A Core resource limit was exceeded.
+*/
+var inspectManifestDocument = async (input, options, operation = "parse-manifest") => {
+	options = createCoreOperationOptionsSnapshot(options);
+	const normalized = normalizeTextDocument(input, options.limits, operation, "maxManifestBytes");
+	const path = parseRepositoryPath(input.path);
+	const diagnostics = createCoreDiagnosticCollector(options.limits, operation);
+	if (!isCanonicalManifestPath(path)) diagnostics.add({
+		code: "MOLDEA_MANIFEST_PATH_INVALID",
+		path
+	});
+	for (const diagnostic of normalized.diagnostics) diagnostics.merge(diagnostic);
+	if (!normalized.valid || normalized.text === null) return freezeRecursively({
+		asset: null,
+		diagnostics: diagnostics.finalize(),
+		formatVersion: null,
+		manifest: null,
+		valid: false
+	});
+	const locator = createSourceLocator(normalized.text.value);
+	const parsed = parseStrictYaml(normalized.text.value, path, locator, diagnostics);
+	const formatVersion = parsed.value === null ? null : detectSupportedManifestVersion(parsed.value);
+	const manifest = parsed.valid && parsed.value !== null ? validateManifest(parsed.value, path, diagnostics, options.limits, operation) : null;
+	if (manifest === null || diagnostics.size > 0) return freezeRecursively({
+		asset: null,
+		diagnostics: diagnostics.finalize(),
+		formatVersion,
+		manifest: null,
+		valid: false
+	});
+	const digest = await calculateNormalizedTextDigest(normalized.text);
+	const asset = {
+		content: normalized.text.value,
+		digest,
+		path,
+		scalarLength: normalized.text.scalarLength,
+		utf8ByteLength: normalized.text.utf8ByteLength
+	};
+	return freezeRecursively({
+		asset,
+		diagnostics: diagnostics.finalize(),
+		formatVersion,
+		manifest,
+		valid: true
+	});
+};
+/**
+* Parses and validates one complete version 1 manifest document.
+* @param input The canonical logical path and exact manifest text or bytes.
+* @param options The immutable Core limit snapshot.
+* @returns A frozen all-or-nothing manifest parse result.
+* @throws
+* - INVALID_REPOSITORY_PATH: The repository path is invalid.
+* - INVALID_ARGUMENT: The Core operation received an invalid argument.
+* - RESOURCE_LIMIT_EXCEEDED: A Core resource limit was exceeded.
+*/
+var parseManifestDocument = async (input, options, operation = "parse-manifest") => {
+	const inspection = await inspectManifestDocument(input, options, operation);
+	return freezeRecursively({
+		asset: inspection.asset,
+		diagnostics: inspection.diagnostics,
+		manifest: inspection.manifest,
+		valid: inspection.valid
+	});
+};
+//#endregion
+//#region src/scope-matching/scope.ts
+/**
+* Parses a manifest and matches its repository relationships against changed logical paths.
+* @param input The canonical manifest document and untrusted changed-path collection.
+* @param options The immutable Core operation options.
+* @returns A promise resolving to frozen content-free scope metadata and matches.
+* @throws
+* - INVALID_REPOSITORY_PATH: The manifest path or a changed repository path is invalid.
+* - INVALID_ARGUMENT: The scope operation received an invalid argument.
+* - RESOURCE_LIMIT_EXCEEDED: A Core resource limit was exceeded.
+*/
+var matchManifestScope = async (input, options) => {
+	const normalized = normalizeManifestScopeInput(input, options.limits);
+	const inputDigest = await calculateManifestScopeInputDigest(normalized.paths);
+	const parsed = await parseManifestDocument(normalized.manifest, options, "match-manifest-scope");
+	if (!parsed.valid || parsed.asset === null || parsed.manifest === null) return freezeRecursively({
+		counts: {
+			declarations: 0,
+			inputPaths: normalized.paths.length,
+			matchedOwners: 0,
+			matchedPaths: 0,
+			matches: 0
+		},
+		diagnostics: parsed.diagnostics,
+		inputDigest,
+		manifestDigest: null,
+		matches: [],
+		relevant: false,
+		valid: false
+	});
+	const matched = matchParsedManifestScope(parsed.manifest, normalized.paths, options.limits);
+	return freezeRecursively({
+		counts: matched.counts,
+		diagnostics: [],
+		inputDigest,
+		manifestDigest: parsed.asset.digest,
+		matches: matched.matches,
+		relevant: matched.matches.length > 0,
+		valid: true
+	});
+};
+//#endregion
+export { createSourceLocator as a, calculateContentDigest as c, parseStrictYaml as i, calculateNormalizedTextDigest as l, inspectManifestDocument as n, collectManifestScopeDeclarations as o, parseManifestDocument as r, matchesRepositoryGlob as s, matchManifestScope as t, normalizeTextDocument as u };
+
+//# sourceMappingURL=scope-AGMcHUE_.js.map