@moldea.ai/core 5.0.1 → 6.0.0

package/dist/chunks/options-CxCT3dZU.js

@@ -0,0 +1,617 @@
+import { n as CoreOperationException, t as CoreConfigurationException } from "./exceptions-lzD3buFw.js";
+import { isRepositoryPath, parseRepositoryPath } from "@moldea.ai/repository";
+//#region src/constants/index.ts
+var RECOGNIZED_RUNTIME_ADAPTER_IDS = Object.freeze([
+	"anthropic",
+	"claude-agent-sdk",
+	"cloudflare-agents",
+	"custom",
+	"eve",
+	"google-genai",
+	"langchain",
+	"langgraph",
+	"openai",
+	"openai-agents-sdk",
+	"vercel-ai-sdk"
+]);
+var SUPPORTED_REPOSITORY_FORMAT_VERSIONS = Object.freeze([1]);
+var DEFAULT_CORE_RESOURCE_LIMITS = Object.freeze({
+	maxDiagnostics: 1e4,
+	maxEntries: 1e5,
+	maxEvidence: 1e4,
+	maxFileBytes: 8388608,
+	maxManifestBytes: 2097152,
+	maxRetainedBytes: 536870912,
+	maxTotalBytesRead: 134217728
+});
+//#endregion
+//#region src/immutable/index.ts
+/**
+* Recursively freezes a Core-owned value without cloning it.
+* @param value The detached acyclic value whose already-frozen objects are deeply frozen.
+* @returns The same value with every mutable reachable object frozen.
+*/
+var freezeRecursively = (value) => {
+	if (typeof value !== "object" || value === null || Object.isFrozen(value)) return value;
+	for (const key of Reflect.ownKeys(value)) {
+		const child = value[key];
+		freezeRecursively(child);
+	}
+	return Object.freeze(value);
+};
+/**
+* Creates a record that cannot collide with prototype-chain properties.
+* @param entries The own string-keyed entries to assign.
+* @returns A mutable null-prototype record for later normalization and freezing.
+*/
+var createNullPrototypeRecord = (entries) => {
+	const record = Object.create(null);
+	for (const [key, value] of entries) record[key] = value;
+	return record;
+};
+//#endregion
+//#region src/format-validation/index.ts
+var STABLE_ID_PATTERN$1 = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
+var VARIABLE_ID_PATTERN = /^[A-Z][A-Z0-9_]*$/u;
+var WINDOWS_RESERVED_ID_PATTERN$1 = /^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])$/u;
+var LINE_BREAK_CHARACTERS = [
+	"\n",
+	"\r",
+	"…",
+	"\u2028",
+	"\u2029"
+];
+var UNSUPPORTED_GLOB_PATTERN = /[!?[\]{}]/u;
+var hasLineBreak = (value) => {
+	return LINE_BREAK_CHARACTERS.some((lineBreak) => value.includes(lineBreak));
+};
+/** Determines whether a code point belongs to the Repository Format version 1 whitespace set. */
+var isRepositoryFormatWhitespace = (codePoint) => {
+	return codePoint >= 9 && codePoint <= 13 || codePoint === 32 || codePoint === 133 || codePoint === 160 || codePoint === 5760 || codePoint >= 8192 && codePoint <= 8202 || codePoint === 8232 || codePoint === 8233 || codePoint === 8239 || codePoint === 8287 || codePoint === 12288;
+};
+/** Compares strings by exact Unicode code-point order without locale behavior. */
+var compareExactStrings = (left, right) => {
+	const leftScalars = left[Symbol.iterator]();
+	const rightScalars = right[Symbol.iterator]();
+	while (true) {
+		const leftScalar = leftScalars.next();
+		const rightScalar = rightScalars.next();
+		if (leftScalar.done === true) return rightScalar.done === true ? 0 : -1;
+		if (rightScalar.done === true) return 1;
+		const leftCodePoint = leftScalar.value.codePointAt(0) ?? 0;
+		const rightCodePoint = rightScalar.value.codePointAt(0) ?? 0;
+		if (leftCodePoint !== rightCodePoint) return leftCodePoint < rightCodePoint ? -1 : 1;
+	}
+};
+/** Counts Unicode scalar values in valid JavaScript text. */
+var countUnicodeScalars = (value) => {
+	const scalars = value[Symbol.iterator]();
+	let count = 0;
+	while (scalars.next().done !== true) count += 1;
+	return count;
+};
+/** Determines whether a JavaScript string contains only Unicode scalar values. */
+var isUnicodeScalarText = (value) => {
+	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 false;
+			const nextCodeUnit = value.charCodeAt(index + 1);
+			if (nextCodeUnit < 56320 || nextCodeUnit > 57343) return false;
+			index += 1;
+			continue;
+		}
+		if (codeUnit >= 56320 && codeUnit <= 57343) return false;
+	}
+	return true;
+};
+/** Determines whether a value contains at least one non-whitespace scalar. */
+var hasNonWhitespace = (value) => {
+	for (const scalar of value) if (!isRepositoryFormatWhitespace(scalar.codePointAt(0) ?? 0)) return true;
+	return false;
+};
+/** Determines whether a value begins or ends with version 1 whitespace. */
+var hasSurroundingWhitespace = (value) => {
+	const firstCodePoint = value.codePointAt(0);
+	const lastCodePoint = value.codePointAt(value.length - 1);
+	return firstCodePoint !== void 0 && isRepositoryFormatWhitespace(firstCodePoint) || lastCodePoint !== void 0 && isRepositoryFormatWhitespace(lastCodePoint);
+};
+/** Removes only Repository Format version 1 whitespace from both edges. */
+var trimRepositoryFormatWhitespace = (value) => {
+	let start = 0;
+	let end = value.length;
+	while (start < end) {
+		const codePoint = value.codePointAt(start);
+		if (codePoint === void 0 || !isRepositoryFormatWhitespace(codePoint)) break;
+		start += codePoint > 65535 ? 2 : 1;
+	}
+	while (end > start) {
+		const codePoint = value.codePointAt(end - 1);
+		if (codePoint === void 0 || !isRepositoryFormatWhitespace(codePoint)) break;
+		end -= 1;
+	}
+	return value.slice(start, end);
+};
+/** Determines whether a string is non-empty and contains no line break. */
+var isNonEmptySingleLine = (value) => {
+	return value.length > 0 && !hasLineBreak(value);
+};
+/** Determines whether a value satisfies stable moldea ID syntax. */
+var isStableId$1 = (value) => {
+	return value.length <= 64 && STABLE_ID_PATTERN$1.test(value);
+};
+/** Determines whether an otherwise valid stable ID is filesystem-reserved. */
+var isReservedId = (value) => WINDOWS_RESERVED_ID_PATTERN$1.test(value);
+/** Determines whether a value satisfies runtime-variable ID syntax. */
+var isVariableId = (value) => {
+	return value.length <= 64 && VARIABLE_ID_PATTERN.test(value);
+};
+/** Determines whether a parsed capability description satisfies version 1 limits. */
+var isCapabilityDescription = (value) => {
+	const scalarLength = countUnicodeScalars(value);
+	return scalarLength >= 1 && scalarLength <= 1e3 && !hasSurroundingWhitespace(value) && !hasLineBreak(value) && !value.includes("\0") && !value.includes("{{") && !value.includes("}}");
+};
+/** Parses a non-root repository-format logical path without throwing. */
+var parseManifestPath = (value) => {
+	return value !== "/" && isRepositoryPath(value) ? parseRepositoryPath(value) : null;
+};
+/** Determines whether a path is the canonical manifest path. */
+var isCanonicalManifestPath = (path) => {
+	return path === "/moldea/moldea.yaml";
+};
+/** Extracts the stable millisecond ID from one canonical immediate decision path. */
+var parseDecisionIdFromPath = (path) => {
+	const match = /^\/moldea\/decisions\/(\d{13})-([a-z0-9]+(?:-[a-z0-9]+)*)\.md$/u.exec(path);
+	const id = match?.[1];
+	const slug = match?.[2];
+	return id !== void 0 && slug !== void 0 && isStableId$1(slug) ? id : null;
+};
+/** Determines whether a path is an allowed focused-context relationship key. */
+var isContextPath = (path, allowProject) => {
+	if (allowProject && path === "/moldea/project.md") return true;
+	return path.startsWith("/moldea/context/") && path.endsWith(".md");
+};
+/** Determines whether a path has the canonical immediate decision filename shape. */
+var isDecisionPath = (path) => {
+	return parseDecisionIdFromPath(path) !== null;
+};
+/** Determines whether a path is canonical runtime guidance. */
+var isRuntimeGuidancePath = (path) => {
+	return path.startsWith("/moldea/runtimes/") && path.endsWith(".md");
+};
+/** Determines whether a mirror path is outside canonical moldea content. */
+var isMirrorPath = (path) => {
+	return path !== "/moldea" && !path.startsWith("/moldea/");
+};
+/** Determines whether an impact path contains prohibited glob metacharacters. */
+var hasUnsupportedGlobMetacharacter = (value) => {
+	return UNSUPPORTED_GLOB_PATTERN.test(value);
+};
+/** Determines whether a string satisfies the version 1 simple-glob grammar. */
+var isSimpleGlob = (value) => {
+	if (hasUnsupportedGlobMetacharacter(value) || value.includes("***")) return false;
+	if (value.slice(1).split("/").some((segment) => segment.includes("**") && segment !== "**")) return false;
+	return value.includes("*") && isRepositoryPath(value.replaceAll("*", "x"));
+};
+/** Determines whether a repository-reference symbol has the common safe shape. */
+var isRepositorySymbol = (value) => {
+	return isNonEmptySingleLine(value) && !value.includes("\0");
+};
+/** Determines whether a canonical moldea reference incorrectly carries a symbol. */
+var isCanonicalMoldeaPath = (path) => {
+	return path === "/moldea" || path.startsWith("/moldea/");
+};
+/** Sorts repository references by path and then optional symbol. */
+var sortRepositoryReferences = (references) => {
+	return [...references].sort((left, right) => {
+		return compareExactStrings(left.path, right.path) || compareExactStrings(left.symbol ?? "", right.symbol ?? "");
+	});
+};
+//#endregion
+//#region src/diagnostic-utilities/index.ts
+var CORE_DIAGNOSTIC_MESSAGES = {
+	MOLDEA_AGENT_DESCRIPTION_INVALID: "The agent description is invalid.",
+	MOLDEA_AGENT_DESCRIPTION_MISSING: "The agent description is missing.",
+	MOLDEA_AGENT_DIRECTORY_MISSING: "The registered agent directory is missing.",
+	MOLDEA_AGENT_DIRECTORY_UNREGISTERED: "The agent directory is not registered.",
+	MOLDEA_AGENT_HANDOFF_DESCRIPTION_INVALID: "The agent handoff description is invalid.",
+	MOLDEA_AGENT_IDENTITY_INVALID: "The agent instruction identity is invalid.",
+	MOLDEA_AGENT_INSTRUCTION_EMPTY: "The agent instruction is empty.",
+	MOLDEA_AGENT_INSTRUCTION_MISSING: "The agent instruction is missing.",
+	MOLDEA_CANONICAL_ASSET_SYMLINK: "The canonical asset is a symlink.",
+	MOLDEA_CANONICAL_PATH_UNRECOGNIZED: "The canonical path is unrecognized.",
+	MOLDEA_CAPABILITY_DESCRIPTION_INVALID: "The capability description is invalid.",
+	MOLDEA_CAPABILITY_DESCRIPTION_MISSING: "The capability description is missing.",
+	MOLDEA_CONTEXT_FILE_EMPTY: "The focused context file is empty.",
+	MOLDEA_CONTEXT_PATH_INVALID: "The context relationship path is invalid.",
+	MOLDEA_CONTEXT_RELATIONSHIP_EMPTY: "The declared relationship has no bindings or impact paths.",
+	MOLDEA_DECISION_BODY_EMPTY: "The decision Markdown body is empty.",
+	MOLDEA_DECISION_CREATED_AT_INVALID: "The decision createdAt value is invalid.",
+	MOLDEA_DECISION_FILENAME_INVALID: "The decision path or filename is invalid.",
+	MOLDEA_DECISION_FRONTMATTER_INVALID: "The decision frontmatter is invalid.",
+	MOLDEA_DECISION_FRONTMATTER_MISSING: "The decision frontmatter or its delimiters are missing.",
+	MOLDEA_DECISION_ID_DUPLICATE: "The decision ID is duplicated.",
+	MOLDEA_DECISION_PROPERTY_UNKNOWN: "The decision frontmatter contains an unknown property.",
+	MOLDEA_DECISION_REFERENCE_MISSING: "The referenced decision does not exist.",
+	MOLDEA_DECISION_RELATIONSHIP_INACTIVE: "The referenced decision is not accepted.",
+	MOLDEA_DECISION_SELF_SUPERSESSION: "The decision supersedes itself.",
+	MOLDEA_DECISION_STATUS_INVALID: "The decision status is invalid.",
+	MOLDEA_DECISION_SUPERSEDED_ORPHAN: "The superseded decision has no active supersession relationship.",
+	MOLDEA_DECISION_SUPERSESSION_CYCLE: "The decision supersession graph contains a cycle.",
+	MOLDEA_DECISION_SUPERSESSION_STATUS_INVALID: "The decision supersession relationship has inconsistent statuses.",
+	MOLDEA_DECISION_TIMESTAMP_MISMATCH: "The decision filename timestamp and createdAt value do not match.",
+	MOLDEA_ENTRY_TYPE_INVALID: "The repository entry type is invalid.",
+	MOLDEA_RUNTIME_ADAPTER_FORMAT_UNSUPPORTED: "The configured runtime adapter does not support the repository format version.",
+	MOLDEA_RUNTIME_ADAPTER_UNAVAILABLE: "The declared runtime adapter is unavailable.",
+	MOLDEA_RUNTIME_ID_INVALID: "The runtime adapter ID is invalid.",
+	MOLDEA_GLOB_INVALID: "The impact pattern is invalid.",
+	MOLDEA_ID_DUPLICATE: "An ID is duplicated within its required scope.",
+	MOLDEA_ID_INVALID: "The ID is invalid.",
+	MOLDEA_ID_RESERVED: "The ID uses a reserved filesystem name.",
+	MOLDEA_IMPACT_PATH_MISSING: "The exact impact path does not exist.",
+	MOLDEA_IMPACT_PATH_NOT_FILE: "The exact impact path is not a regular file.",
+	MOLDEA_MANIFEST_MISSING: "The project manifest is missing.",
+	MOLDEA_MANIFEST_PATH_INVALID: "The manifest path is not the canonical manifest path.",
+	MOLDEA_MANIFEST_PROPERTY_UNKNOWN: "The manifest contains an unknown property.",
+	MOLDEA_MANIFEST_ROOT_INVALID: "The manifest root is not a mapping.",
+	MOLDEA_MANIFEST_VALUE_INVALID: "The manifest value is invalid.",
+	MOLDEA_MANIFEST_VERSION_INVALID: "The manifest version is not a valid integer major version.",
+	MOLDEA_MANIFEST_VERSION_MISSING: "The manifest version is missing.",
+	MOLDEA_MANIFEST_VERSION_UNSUPPORTED: "The manifest version is unsupported.",
+	MOLDEA_MIRROR_PATH_DUPLICATE: "The mirror path is assigned more than once.",
+	MOLDEA_MIRROR_PATH_INSIDE_MOLDEA: "The mirror path is inside /moldea.",
+	MOLDEA_MIRROR_PATH_INVALID: "The mirror path is invalid.",
+	MOLDEA_MIRROR_MISSING: "The declared mirror does not exist.",
+	MOLDEA_MIRROR_NOT_FILE: "The declared mirror is not a regular file.",
+	MOLDEA_MIRROR_STALE: "The declared mirror differs from its canonical instruction.",
+	MOLDEA_MIRROR_SYMLINK: "The declared mirror is a symlink.",
+	MOLDEA_PATH_DUPLICATE: "The path is duplicated.",
+	MOLDEA_PATH_INVALID: "The manifest logical path is invalid.",
+	MOLDEA_PATTERN_DUPLICATE: "The impact pattern is duplicated.",
+	MOLDEA_PROJECT_FILE_EMPTY: "The project file is empty.",
+	MOLDEA_PROJECT_FILE_MISSING: "The project file is missing.",
+	MOLDEA_REFERENCE_MISSING: "The referenced repository path does not exist.",
+	MOLDEA_REFERENCE_NOT_FILE: "The referenced repository path is not a regular file.",
+	MOLDEA_REFERENCE_SYMLINK: "The referenced repository path is a symlink.",
+	MOLDEA_RUNTIME_GUIDANCE_EMPTY: "The runtime guidance is empty.",
+	MOLDEA_RUNTIME_GUIDANCE_MISSING: "The referenced runtime guidance does not exist.",
+	MOLDEA_SKILL_IMPLEMENTATION_MISSING: "The registered skill implementation is missing.",
+	MOLDEA_SYMBOL_FORBIDDEN: "A canonical moldea reference must not include a symbol.",
+	MOLDEA_SYMBOL_INVALID: "The repository-reference symbol is invalid.",
+	MOLDEA_TEXT_EMPTY: "The required text document is empty.",
+	MOLDEA_TEXT_INVALID_UNICODE: "The text document contains an invalid Unicode scalar representation.",
+	MOLDEA_TEXT_INVALID_UTF8: "The text document is not valid UTF-8.",
+	MOLDEA_TEXT_NUL_FORBIDDEN: "The text document contains a forbidden NUL character.",
+	MOLDEA_TOOL_IMPLEMENTATION_MISSING: "The registered tool implementation is missing.",
+	MOLDEA_VARIABLE_ID_INVALID: "The runtime-variable ID is invalid.",
+	MOLDEA_VARIABLE_PLACEHOLDER_MALFORMED: "The agent instruction contains a malformed runtime-variable placeholder.",
+	MOLDEA_VARIABLE_PROVIDER_UNDECLARED: "A variable-provider binding exists for an undeclared variable.",
+	MOLDEA_VARIABLE_UNDECLARED: "The agent instruction references an undeclared runtime variable.",
+	MOLDEA_VARIABLE_UNUSED: "The declared runtime variable is unused by the agent instruction.",
+	MOLDEA_YAML_DUPLICATE_KEY: "The YAML document contains a duplicate mapping key.",
+	MOLDEA_YAML_FEATURE_UNSUPPORTED: "The YAML document uses an unsupported feature.",
+	MOLDEA_YAML_MALFORMED: "The YAML document is malformed.",
+	MOLDEA_YAML_MULTIPLE_DOCUMENTS: "The YAML stream contains more than one document."
+};
+var ENTITY_KEYS = [
+	"agentId",
+	"capabilityKind",
+	"capabilityId",
+	"decisionId",
+	"variableId",
+	"adapterId"
+];
+var CORE_DIAGNOSTIC_BUDGET = Symbol("core-diagnostic-budget");
+/** Creates a detached limits view with one diagnostic budget for a complete Core operation. */
+var createCoreOperationResourceLimits = (limits) => {
+	if (limits[CORE_DIAGNOSTIC_BUDGET] !== void 0) return limits;
+	return Object.freeze({
+		...limits,
+		[CORE_DIAGNOSTIC_BUDGET]: { count: 0 }
+	});
+};
+/** Registers raw diagnostics against the shared operation budget before normalization. */
+var registerCoreDiagnosticCandidates = (limits, amount, operation, fallbackCount = 0, adapterId) => {
+	const budget = limits[CORE_DIAGNOSTIC_BUDGET];
+	const currentCount = budget?.count ?? fallbackCount;
+	if (amount > limits.maxDiagnostics - currentCount) throw new CoreOperationException({
+		...adapterId === void 0 ? {} : { adapterId },
+		code: "RESOURCE_LIMIT_EXCEEDED",
+		limit: "maxDiagnostics",
+		limitMaximum: limits.maxDiagnostics,
+		nextAction: "reduce-input-or-increase-limit",
+		observedUsage: currentCount + amount,
+		operation
+	});
+	if (budget !== void 0) budget.count += amount;
+	return fallbackCount + amount;
+};
+var compareNullableStrings = (left, right) => {
+	if (left === null) return right === null ? 0 : -1;
+	return right === null ? 1 : compareExactStrings(left, right);
+};
+/**
+* Normalizes trusted JSON-scalar diagnostic metadata.
+* @param details The optional detached metadata record.
+* @returns A frozen null-prototype record with canonical key order.
+*/
+var normalizeDiagnosticDetails = (details) => {
+	return freezeRecursively(createNullPrototypeRecord(Object.entries(details ?? {}).sort(([left], [right]) => compareExactStrings(left, right)).map(([key, value]) => [key, typeof value === "number" && Object.is(value, -0) ? 0 : value])));
+};
+/**
+* Normalizes a trusted diagnostic entity into canonical key order.
+* @param entity The optional diagnostic entity.
+* @returns The frozen normalized entity or `null`.
+*/
+var normalizeDiagnosticEntity = (entity) => {
+	if (entity === void 0 || entity === null) return null;
+	return freezeRecursively(createNullPrototypeRecord(ENTITY_KEYS.flatMap((key) => {
+		const value = entity[key];
+		return value === void 0 ? [] : [[key, value]];
+	})));
+};
+/** Serializes unordered diagnostic details with explicit exact-code-point key ordering. */
+var serializeDiagnosticDetails = (details) => {
+	const entries = Object.entries(details).sort(([left], [right]) => compareExactStrings(left, right));
+	return JSON.stringify(entries);
+};
+var serializeDiagnostic = (diagnostic) => {
+	const entity = diagnostic.entity === null ? null : ENTITY_KEYS.map((key) => [key, diagnostic.entity?.[key] ?? null]);
+	const range = diagnostic.range === null ? null : [
+		diagnostic.range.start.line,
+		diagnostic.range.start.column,
+		diagnostic.range.start.offset,
+		diagnostic.range.end.line,
+		diagnostic.range.end.column,
+		diagnostic.range.end.offset
+	];
+	return JSON.stringify([
+		diagnostic.code,
+		diagnostic.severity,
+		serializeDiagnosticDetails(diagnostic.details),
+		entity,
+		diagnostic.message,
+		diagnostic.path,
+		diagnostic.pointer,
+		range,
+		diagnostic.source
+	]);
+};
+var compareRanges = (left, right) => {
+	if (left === null) return right === null ? 0 : -1;
+	if (right === null) return 1;
+	return left.start.line - right.start.line || left.start.column - right.start.column || left.start.offset - right.start.offset || left.end.line - right.end.line || left.end.column - right.end.column || left.end.offset - right.end.offset;
+};
+var readEntityValue = (entity, key) => {
+	return entity?.[key] ?? "";
+};
+var compareDiagnostics = (left, right) => {
+	return compareNullableStrings(left.path, right.path) || compareRanges(left.range, right.range) || compareNullableStrings(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.
+* @param input The trusted Core-owned diagnostic fields to normalize.
+* @returns A deeply immutable public diagnostic value.
+*/
+var createCoreDiagnostic = (input) => {
+	const message = CORE_DIAGNOSTIC_MESSAGES[input.code];
+	if (message === void 0) throw new TypeError("The requested Core diagnostic is not implemented.");
+	return freezeRecursively({
+		code: input.code,
+		details: normalizeDiagnosticDetails(input.details),
+		entity: normalizeDiagnosticEntity(input.entity),
+		message,
+		path: input.path,
+		pointer: input.pointer ?? null,
+		range: input.range ?? null,
+		severity: "error",
+		source: "core"
+	});
+};
+/**
+* Deduplicates and sorts already-normalized Core and adapter diagnostics.
+* @param candidates The immutable diagnostics to combine.
+* @returns A frozen deterministic diagnostic collection.
+*/
+var normalizeDiagnostics = (candidates) => {
+	const diagnostics = /* @__PURE__ */ new Map();
+	for (const diagnostic of candidates) {
+		const key = serializeDiagnostic(diagnostic);
+		if (diagnostics.has(key)) continue;
+		diagnostics.set(key, diagnostic);
+	}
+	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.
+* @param operation The operation reported by resource failures.
+* @returns A collector that freezes and sorts its final diagnostic array.
+*/
+var createCoreDiagnosticCollector = (limits, operation) => {
+	const diagnostics = /* @__PURE__ */ new Map();
+	let proposalCount = 0;
+	let fallbackRawCount = 0;
+	const retain = (input) => {
+		const diagnostic = createCoreDiagnostic(input);
+		const key = serializeDiagnostic(diagnostic);
+		proposalCount += 1;
+		if (!diagnostics.has(key)) diagnostics.set(key, diagnostic);
+	};
+	return {
+		add: (input) => {
+			fallbackRawCount = registerCoreDiagnosticCandidates(limits, 1, operation, fallbackRawCount);
+			retain(input);
+		},
+		merge: retain,
+		finalize: () => normalizeDiagnostics([...diagnostics.values()]),
+		get size() {
+			return proposalCount;
+		}
+	};
+};
+/**
+* Escapes one JSON Pointer reference token.
+* @param value The decoded mapping key or array index token.
+* @returns The RFC 6901 escaped token.
+*/
+var escapeJsonPointerSegment = (value) => {
+	return value.replaceAll("~", "~0").replaceAll("/", "~1");
+};
+//#endregion
+//#region src/options/index.ts
+/** Creates an operation-local options view with one shared raw-diagnostic budget. */
+var createCoreOperationOptionsSnapshot = (options) => {
+	return Object.freeze({
+		adapters: options.adapters,
+		limits: createCoreOperationResourceLimits(options.limits)
+	});
+};
+var RESOURCE_LIMIT_KEYS = [
+	"maxEntries",
+	"maxTotalBytesRead",
+	"maxFileBytes",
+	"maxManifestBytes",
+	"maxRetainedBytes",
+	"maxDiagnostics",
+	"maxEvidence"
+];
+var STABLE_ID_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
+var WINDOWS_RESERVED_ID_PATTERN = /^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])$/u;
+var compareStrings = (left, right) => {
+	if (left < right) return -1;
+	if (left > right) return 1;
+	return 0;
+};
+var invalidAdapter = (adapterId) => {
+	throw new CoreConfigurationException({
+		...adapterId === void 0 ? {} : { adapterId },
+		code: "INVALID_ADAPTER_DEFINITION",
+		operation: "create-core"
+	});
+};
+var isRecord = (value) => {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+var isStableId = (value) => {
+	return value.length >= 1 && value.length <= 64 && STABLE_ID_PATTERN.test(value);
+};
+/**
+* Validates, copies, fills, and freezes all configured resource limits.
+* @param candidate The untrusted optional limit overrides.
+* @returns The complete frozen resource limits.
+* @throws
+* - INVALID_RESOURCE_LIMIT: A Core resource limit is invalid.
+*/
+var normalizeLimits = (candidate) => {
+	if (candidate === void 0) return DEFAULT_CORE_RESOURCE_LIMITS;
+	if (!isRecord(candidate)) throw new CoreConfigurationException({
+		code: "INVALID_RESOURCE_LIMIT",
+		operation: "create-core"
+	});
+	const knownKeys = new Set(RESOURCE_LIMIT_KEYS);
+	if (Object.keys(candidate).some((key) => !knownKeys.has(key))) throw new CoreConfigurationException({
+		code: "INVALID_RESOURCE_LIMIT",
+		operation: "create-core"
+	});
+	const normalized = { ...DEFAULT_CORE_RESOURCE_LIMITS };
+	for (const key of RESOURCE_LIMIT_KEYS) {
+		const value = candidate[key];
+		if (value === void 0) continue;
+		if (!Number.isSafeInteger(value) || value <= 0) throw new CoreConfigurationException({
+			code: "INVALID_RESOURCE_LIMIT",
+			operation: "create-core"
+		});
+		normalized[key] = value;
+	}
+	return freezeRecursively(normalized);
+};
+/**
+* Snapshots one adapter definition without freezing caller-owned state.
+* @param candidate The untrusted adapter definition.
+* @returns A frozen detached adapter snapshot.
+* @throws
+* - RESERVED_ADAPTER_ID: A reserved runtime adapter ID was supplied.
+* - INVALID_ADAPTER_DEFINITION: A runtime adapter definition is invalid.
+*/
+var normalizeAdapter = (candidate) => {
+	if (!isRecord(candidate)) return invalidAdapter();
+	const id = candidate["id"];
+	if (typeof id !== "string" || !isStableId(id) || WINDOWS_RESERVED_ID_PATTERN.test(id)) return invalidAdapter();
+	if (id === "custom") throw new CoreConfigurationException({
+		adapterId: id,
+		code: "RESERVED_ADAPTER_ID",
+		operation: "create-core"
+	});
+	if (!RECOGNIZED_RUNTIME_ADAPTER_IDS.includes(id)) return invalidAdapter(id);
+	const versions = candidate["supportedRepositoryFormatVersions"];
+	const inspect = candidate["inspect"];
+	if (!Array.isArray(versions) || versions.length === 0 || typeof inspect !== "function") return invalidAdapter(id);
+	const supportedVersions = /* @__PURE__ */ new Set();
+	for (const version of versions) {
+		if (!SUPPORTED_REPOSITORY_FORMAT_VERSIONS.includes(version) || supportedVersions.has(version)) return invalidAdapter(id);
+		supportedVersions.add(version);
+	}
+	const inspectReference = inspect;
+	return freezeRecursively({
+		id,
+		inspect: async (context) => inspectReference.call(candidate, context),
+		supportedRepositoryFormatVersions: [...supportedVersions].sort((left, right) => left - right)
+	});
+};
+/**
+* Validates, snapshots, and deterministically sorts the configured adapter registry.
+* @param candidate The untrusted optional adapter definitions.
+* @returns The frozen adapter snapshots in canonical ID order.
+* @throws
+* - DUPLICATE_ADAPTER_ID: A runtime adapter ID is registered more than once.
+* - RESERVED_ADAPTER_ID: A reserved runtime adapter ID was supplied.
+* - INVALID_ADAPTER_DEFINITION: A runtime adapter definition is invalid.
+*/
+var normalizeAdapters = (candidate) => {
+	if (candidate === void 0) return Object.freeze([]);
+	if (!Array.isArray(candidate)) return invalidAdapter();
+	const adapters = Array.from(candidate, (adapter) => normalizeAdapter(adapter));
+	const ids = /* @__PURE__ */ new Set();
+	for (const adapter of adapters) {
+		if (ids.has(adapter.id)) throw new CoreConfigurationException({
+			adapterId: adapter.id,
+			code: "DUPLICATE_ADAPTER_ID",
+			operation: "create-core"
+		});
+		ids.add(adapter.id);
+	}
+	return freezeRecursively(adapters.sort((left, right) => compareStrings(left.id, right.id)));
+};
+/**
+* Validates and snapshots caller-owned Core construction options.
+* @param options The optional adapters and resource-limit overrides.
+* @returns A deeply frozen, deterministically ordered configuration snapshot.
+* @throws
+* - DUPLICATE_ADAPTER_ID: A runtime adapter ID is registered more than once.
+* - RESERVED_ADAPTER_ID: A reserved runtime adapter ID was supplied.
+* - INVALID_ADAPTER_DEFINITION: A runtime adapter definition is invalid.
+* - INVALID_RESOURCE_LIMIT: A Core resource limit is invalid.
+*/
+var normalizeCoreOptions = (options) => {
+	if (options !== void 0 && !isRecord(options)) return invalidAdapter();
+	return freezeRecursively({
+		adapters: normalizeAdapters(options?.["adapters"]),
+		limits: normalizeLimits(options?.["limits"])
+	});
+};
+//#endregion
+export { parseDecisionIdFromPath as A, isRepositorySymbol as C, isStableId$1 as D, isSimpleGlob as E, freezeRecursively as F, DEFAULT_CORE_RESOURCE_LIMITS as I, RECOGNIZED_RUNTIME_ADAPTER_IDS as L, sortRepositoryReferences as M, trimRepositoryFormatWhitespace as N, isUnicodeScalarText as O, createNullPrototypeRecord as P, SUPPORTED_REPOSITORY_FORMAT_VERSIONS as R, isNonEmptySingleLine as S, isRuntimeGuidancePath as T, isCanonicalMoldeaPath as _, escapeJsonPointerSegment as a, isDecisionPath as b, normalizeDiagnostics as c, compareExactStrings as d, countUnicodeScalars as f, isCanonicalManifestPath as g, hasUnsupportedGlobMetacharacter as h, createCoreDiagnosticCollector as i, parseManifestPath as j, isVariableId as k, registerCoreDiagnosticCandidates as l, hasSurroundingWhitespace as m, normalizeCoreOptions as n, normalizeDiagnosticDetails as o, hasNonWhitespace as p, countDiagnosticsBySeverity as r, normalizeDiagnosticEntity as s, createCoreOperationOptionsSnapshot as t, serializeDiagnosticDetails as u, isCapabilityDescription as v, isReservedId as w, isMirrorPath as x, isContextPath as y };
+
+//# sourceMappingURL=options-CxCT3dZU.js.map