@moldea.ai/core 5.0.1 → 7.0.0

package/dist/chunks/lifecycle-D_RvxhDC.js

@@ -0,0 +1,67 @@
+import { a as encodeInspectionMessage, r as createInspectionProcessFailure, u as NODE_INSPECTION_TERMINATION_GRACE_MS } from "./errors-BE4DS3Ak.js";
+import process from "node:process";
+//#region src/node-inspection/lifecycle.ts
+/** Serializes bounded IPC sends and waits for Node's send callback before admitting the next. */
+var createInspectionSender = (send) => {
+	let queued = 0;
+	let tail = Promise.resolve();
+	return async (message) => {
+		if (queued >= 4) throw createInspectionProcessFailure();
+		queued++;
+		const operation = tail.then(() => new Promise((resolve, reject) => {
+			try {
+				send(encodeInspectionMessage(message), (error) => {
+					if (error !== null) reject(createInspectionProcessFailure(error));
+					else resolve();
+				});
+			} catch (cause) {
+				reject(cause instanceof Error ? cause : createInspectionProcessFailure(cause));
+			}
+		}));
+		tail = operation.catch(() => {});
+		try {
+			await operation;
+		} finally {
+			queued--;
+		}
+	};
+};
+/** Keeps only operating-system bootstrap variables; no credentials or Node overrides cross. */
+var createInspectionEnvironment = () => {
+	const names = /* @__PURE__ */ new Set([
+		"systemroot",
+		"windir",
+		"temp",
+		"tmp",
+		"tmpdir"
+	]);
+	return Object.fromEntries(Object.entries(process.env).filter(([name]) => names.has(name.toLowerCase())));
+};
+/**
+* Supervises one owned child without PID polling, shell commands, or process-group killing.
+* @returns Idempotent termination and actual close notification.
+*/
+var superviseInspectionChild = (child, requestStop) => {
+	let hasClosed = false;
+	let forceTimer;
+	return {
+		closed: new Promise((resolve) => {
+			child.once("close", () => {
+				hasClosed = true;
+				clearTimeout(forceTimer);
+				resolve();
+			});
+		}),
+		terminate: () => {
+			if (hasClosed || forceTimer !== void 0) return;
+			forceTimer = setTimeout(() => {
+				if (!hasClosed) child.kill("SIGKILL");
+			}, NODE_INSPECTION_TERMINATION_GRACE_MS);
+			requestStop();
+		}
+	};
+};
+//#endregion
+export { createInspectionSender as n, superviseInspectionChild as r, createInspectionEnvironment as t };
+
+//# sourceMappingURL=lifecycle-D_RvxhDC.js.map

package/dist/chunks/lifecycle-D_RvxhDC.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle-D_RvxhDC.js","names":[],"sources":["../../src/node-inspection/lifecycle.ts"],"sourcesContent":["import type { ChildProcess } from 'node:child_process';\nimport process from 'node:process';\n\nimport { NODE_INSPECTION_TERMINATION_GRACE_MS } from './constants.js';\nimport { NODE_INSPECTION_MAX_REQUESTS } from './constants.js';\nimport { createInspectionProcessFailure, encodeInspectionMessage } from './protocol.js';\nimport type { INodeInspectionMessage } from './types.js';\n\n/** Serializes bounded IPC sends and waits for Node's send callback before admitting the next. */\nexport const createInspectionSender = (\n  send: (frame: string, callback: (error: Error | null) => void) => void,\n): ((message: INodeInspectionMessage) => Promise<void>) => {\n  let queued = 0;\n  let tail = Promise.resolve();\n  return async (message) => {\n    if (queued >= NODE_INSPECTION_MAX_REQUESTS) throw createInspectionProcessFailure();\n    queued++;\n    const operation = tail.then(\n      () =>\n        new Promise<void>((resolve, reject) => {\n          try {\n            send(encodeInspectionMessage(message), (error) => {\n              if (error !== null) reject(createInspectionProcessFailure(error));\n              else resolve();\n            });\n          } catch (cause) {\n            reject(cause instanceof Error ? cause : createInspectionProcessFailure(cause));\n          }\n        }),\n    );\n    tail = operation.catch(() => {});\n    try {\n      await operation;\n    } finally {\n      queued--;\n    }\n  };\n};\n\n/** Keeps only operating-system bootstrap variables; no credentials or Node overrides cross. */\nexport const createInspectionEnvironment = (): NodeJS.ProcessEnv => {\n  const names = new Set(['systemroot', 'windir', 'temp', 'tmp', 'tmpdir']);\n  return Object.fromEntries(\n    Object.entries(process.env).filter(([name]) => names.has(name.toLowerCase())),\n  );\n};\n\n/**\n * Supervises one owned child without PID polling, shell commands, or process-group killing.\n * @returns Idempotent termination and actual close notification.\n */\nexport const superviseInspectionChild = (\n  child: ChildProcess,\n  requestStop: () => void,\n): {\n  closed: Promise<void>;\n  terminate: () => void;\n} => {\n  let hasClosed = false;\n  let forceTimer: NodeJS.Timeout | undefined;\n  const closed = new Promise<void>((resolve) => {\n    child.once('close', () => {\n      hasClosed = true;\n      clearTimeout(forceTimer);\n      resolve();\n    });\n  });\n  return {\n    closed,\n    terminate: (): void => {\n      if (hasClosed || forceTimer !== undefined) return;\n      // Let the child close IPC. Local disconnect can suppress ChildProcess's close event.\n      forceTimer = setTimeout(() => {\n        if (!hasClosed) child.kill('SIGKILL');\n      }, NODE_INSPECTION_TERMINATION_GRACE_MS);\n      requestStop();\n    },\n  };\n};\n"],"mappings":";;;;AASA,IAAa,0BACX,SACyD;CACzD,IAAI,SAAS;CACb,IAAI,OAAO,QAAQ,QAAQ;CAC3B,OAAO,OAAO,YAAY;EACxB,IAAI,UAAA,GAAwC,MAAM,+BAA+B;EACjF;EACA,MAAM,YAAY,KAAK,WAEnB,IAAI,SAAe,SAAS,WAAW;GACrC,IAAI;IACF,KAAK,wBAAwB,OAAO,IAAI,UAAU;KAChD,IAAI,UAAU,MAAM,OAAO,+BAA+B,KAAK,CAAC;UAC3D,QAAQ;IACf,CAAC;GACH,SAAS,OAAO;IACd,OAAO,iBAAiB,QAAQ,QAAQ,+BAA+B,KAAK,CAAC;GAC/E;EACF,CAAC,CACL;EACA,OAAO,UAAU,YAAY,CAAC,CAAC;EAC/B,IAAI;GACF,MAAM;EACR,UAAU;GACR;EACF;CACF;AACF;;AAGA,IAAa,oCAAuD;CAClE,MAAM,wBAAQ,IAAI,IAAI;EAAC;EAAc;EAAU;EAAQ;EAAO;CAAQ,CAAC;CACvE,OAAO,OAAO,YACZ,OAAO,QAAQ,QAAQ,GAAG,CAAC,CAAC,QAAQ,CAAC,UAAU,MAAM,IAAI,KAAK,YAAY,CAAC,CAAC,CAC9E;AACF;;;;;AAMA,IAAa,4BACX,OACA,gBAIG;CACH,IAAI,YAAY;CAChB,IAAI;CAQJ,OAAO;EACL,QAAA,IARiB,SAAe,YAAY;GAC5C,MAAM,KAAK,eAAe;IACxB,YAAY;IACZ,aAAa,UAAU;IACvB,QAAQ;GACV,CAAC;EACH,CAEE;EACA,iBAAuB;GACrB,IAAI,aAAa,eAAe,KAAA,GAAW;GAE3C,aAAa,iBAAiB;IAC5B,IAAI,CAAC,WAAW,MAAM,KAAK,SAAS;GACtC,GAAG,oCAAoC;GACvC,YAAY;EACd;CACF;AACF"}

package/dist/chunks/options-5x9gu2Qb.js

@@ -0,0 +1,604 @@
+import { n as CoreOperationException, t as CoreConfigurationException } from "./exceptions-IXsorE8t.js";
+import { isRepositoryPath, parseRepositoryPath } from "@moldea.ai/repository";
+//#region src/constants/index.ts
+var ACCEPTABLE_WARNING_CODES = Object.freeze([
+	"MOLDEA_IMPACT_PATTERN_UNMATCHED",
+	"MOLDEA_INTEGRATION_BLOCK_MISSING",
+	"MOLDEA_INTEGRATION_SKILL_MISSING",
+	"MOLDEA_INTEGRATION_BLOCK_STALE"
+]);
+var RECOGNIZED_RUNTIME_IDS = Object.freeze([
+	"amazon-bedrock",
+	"anthropic",
+	"cerebras",
+	"claude-agent-sdk",
+	"cloudflare-agents",
+	"cohere",
+	"convex-agent",
+	"cursor-sdk",
+	"custom",
+	"deep-agents",
+	"eve",
+	"genkit",
+	"github-copilot-sdk",
+	"google-adk",
+	"google-genai",
+	"groq",
+	"hugging-face",
+	"ibm-watsonx-ai",
+	"langchain",
+	"langgraph",
+	"livekit-agents",
+	"mastra",
+	"microsoft-foundry",
+	"mistral",
+	"node-llama-cpp",
+	"ollama",
+	"openai",
+	"openai-agents-sdk",
+	"openai-codex",
+	"opencode-sdk",
+	"openrouter",
+	"pi-agent",
+	"strands-agents",
+	"tanstack-ai",
+	"vercel-ai-sdk",
+	"voltagent"
+]);
+var SUPPORTED_REPOSITORY_FORMAT_VERSIONS = Object.freeze([1]);
+var DEFAULT_CORE_RESOURCE_LIMITS = Object.freeze({
+	maxDiagnostics: 1e4,
+	maxEntries: 1e5,
+	maxCoverage: 1e4,
+	maxAcceptedWarnings: 256,
+	maxFileBytes: 8388608,
+	maxManifestBytes: 2097152,
+	maxRetainedBytes: 536870912,
+	maxTotalBytesRead: 134217728
+});
+//#endregion
+//#region src/format-validation/index.ts
+var STABLE_ID_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
+var VARIABLE_ID_PATTERN = /^[A-Z][A-Z0-9_]*$/u;
+var WINDOWS_RESERVED_ID_PATTERN = /^(?: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 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 = (value) => {
+	return value.length <= 64 && STABLE_ID_PATTERN.test(value);
+};
+/** Determines whether an otherwise valid stable ID is filesystem-reserved. */
+var isReservedId = (value) => WINDOWS_RESERVED_ID_PATTERN.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(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/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/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_ID_INVALID: "The runtime 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_INTEGRATION_BLOCK_MISSING: "The AGENTS.md moldea block is missing.",
+	MOLDEA_INTEGRATION_SKILL_MISSING: "The skill installation referenced by the AGENTS.md moldea block was not found.",
+	MOLDEA_INTEGRATION_BLOCK_STALE: "The AGENTS.md moldea block differs from its skill installation.",
+	MOLDEA_IMPACT_PATTERN_UNMATCHED: "The impact pattern matches no files.",
+	MOLDEA_ACCEPTANCE_UNMATCHED: "The warning acceptance matches no reported warning.",
+	MOLDEA_REFERENCE_EXPORT_MISSING: "The referenced export 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",
+	"contextPath",
+	"integrationPath"
+];
+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) => {
+	const budget = limits[CORE_DIAGNOSTIC_BUDGET];
+	const currentCount = budget?.count ?? fallbackCount;
+	if (amount > limits.maxDiagnostics - currentCount) throw new CoreOperationException({
+		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,
+		diagnostic.severity === "warning" ? [
+			diagnostic.subject,
+			diagnostic.qualifier,
+			diagnostic.accepted ?? false,
+			diagnostic.reason ?? null
+		] : null,
+		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(left.severity === "warning" ? JSON.stringify([
+		left.subject,
+		left.qualifier,
+		left.accepted ?? false,
+		left.reason ?? null
+	]) : "", right.severity === "warning" ? JSON.stringify([
+		right.subject,
+		right.qualifier,
+		right.accepted ?? false,
+		right.reason ?? null
+	]) : "") || 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, "contextPath"), readEntityValue(right.entity, "contextPath")) || compareExactStrings(readEntityValue(left.entity, "integrationPath"), readEntityValue(right.entity, "integrationPath")) || compareExactStrings(serializeDiagnosticDetails(left.details), serializeDiagnosticDetails(right.details)) || compareExactStrings(left.message, right.message);
+};
+/** Classifies every catalog code by its documented validation responsibility. */
+var getDiagnosticGroup = (code) => {
+	if (code.startsWith("MOLDEA_INTEGRATION_")) return "integration";
+	if (code.startsWith("MOLDEA_MIRROR_")) return "mirrors";
+	if (/^MOLDEA_(REFERENCE|IMPACT|SYMBOL|CONTEXT|DECISION|RUNTIME_GUIDANCE)_/.test(code)) return "references";
+	if (code === "MOLDEA_VARIABLE_ID_INVALID") return "manifest";
+	if (/^MOLDEA_(AGENT|VARIABLE|CAPABILITY|TOOL|SKILL|RUNTIME)_/.test(code)) return "agents";
+	if (/^MOLDEA_(MANIFEST_MISSING|PROJECT_FILE|ENTRY_TYPE|CANONICAL|TEXT)_/.test(code)) return "discovery";
+	return "manifest";
+};
+/**
+* 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.");
+	const base = {
+		code: input.code,
+		details: normalizeDiagnosticDetails(input.details),
+		entity: normalizeDiagnosticEntity(input.entity),
+		message,
+		path: input.path,
+		pointer: input.pointer ?? null,
+		range: input.range ?? null,
+		group: getDiagnosticGroup(input.code),
+		source: "core"
+	};
+	if (input.code === "MOLDEA_IMPACT_PATTERN_UNMATCHED" || input.code === "MOLDEA_ACCEPTANCE_UNMATCHED" || input.code === "MOLDEA_INTEGRATION_BLOCK_MISSING" || input.code === "MOLDEA_INTEGRATION_SKILL_MISSING" || input.code === "MOLDEA_INTEGRATION_BLOCK_STALE") {
+		if (input.subject === void 0) throw new TypeError("A warning subject is required.");
+		return freezeRecursively({
+			...base,
+			code: input.code,
+			severity: "warning",
+			subject: input.subject,
+			qualifier: input.qualifier ?? null,
+			acceptable: ACCEPTABLE_WARNING_CODES.some((code) => code === input.code)
+		});
+	}
+	return freezeRecursively({
+		...base,
+		code: input.code,
+		severity: "error"
+	});
+};
+/**
+* Deduplicates and sorts already-normalized Core 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;
+	let acceptedWarningCount = 0;
+	for (const diagnostic of diagnostics) if (diagnostic.severity === "error") errorCount += 1;
+	else if (diagnostic.accepted === true) acceptedWarningCount += 1;
+	else warningCount += 1;
+	return {
+		errorCount,
+		warningCount,
+		acceptedWarningCount,
+		diagnosticCount: diagnostics.length
+	};
+};
+/**
+* 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({ limits: createCoreOperationResourceLimits(options.limits) });
+};
+var RESOURCE_LIMIT_KEYS = [
+	"maxEntries",
+	"maxTotalBytesRead",
+	"maxFileBytes",
+	"maxManifestBytes",
+	"maxRetainedBytes",
+	"maxDiagnostics",
+	"maxCoverage",
+	"maxAcceptedWarnings"
+];
+var isRecord = (value) => {
+	return typeof value === "object" && value !== null && !Array.isArray(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);
+};
+/**
+* Validates and snapshots caller-owned Core resource limits.
+* @returns A deeply frozen configuration snapshot.
+* @throws
+* - INVALID_RESOURCE_LIMIT: A Core resource limit is invalid.
+*/
+var normalizeCoreOptions = (options) => {
+	if (options !== void 0 && (!isRecord(options) || Reflect.ownKeys(options).some((key) => key !== "limits"))) throw new CoreConfigurationException({
+		code: "INVALID_RESOURCE_LIMIT",
+		operation: "create-core"
+	});
+	return freezeRecursively({ limits: normalizeLimits(options?.["limits"]) });
+};
+//#endregion
+export { ACCEPTABLE_WARNING_CODES as A, isSimpleGlob as C, parseManifestPath as D, parseDecisionIdFromPath as E, RECOGNIZED_RUNTIME_IDS as M, SUPPORTED_REPOSITORY_FORMAT_VERSIONS as N, sortRepositoryReferences as O, isRuntimeGuidancePath as S, isVariableId as T, isDecisionPath as _, escapeJsonPointerSegment as a, isRepositorySymbol as b, freezeRecursively as c, hasNonWhitespace as d, hasUnsupportedGlobMetacharacter as f, isContextPath as g, isCapabilityDescription as h, createCoreDiagnosticCollector as i, DEFAULT_CORE_RESOURCE_LIMITS as j, trimRepositoryFormatWhitespace as k, compareExactStrings as l, isCanonicalMoldeaPath as m, normalizeCoreOptions as n, normalizeDiagnostics as o, isCanonicalManifestPath as p, countDiagnosticsBySeverity as r, createNullPrototypeRecord as s, createCoreOperationOptionsSnapshot as t, countUnicodeScalars as u, isMirrorPath as v, isStableId as w, isReservedId as x, isNonEmptySingleLine as y };
+
+//# sourceMappingURL=options-5x9gu2Qb.js.map