@rsconcept/domain 2.1.2 → 2.3.0

package/dist/diagnostics-CY9sKggB.js

@@ -1,658 +0,0 @@
-import { TypeClass, TypeID, basic, bool, constant, isTypification } from "./rslang/semantic/typification.js";
-import { labelType } from "./rslang/labels.js";
-import { applyEntityReferenceMapping } from "./cctext/language-api.js";
-import { RSErrorCode } from "./rslang/error.js";
-import { generateExpressionFromAst } from "./rslang/parser/expression-generator.js";
-import { applyAliasMapping, applyTypificationMapping, extractGlobals, parseRSLangExpression } from "./rslang/api.js";
-import { applyPath } from "./rslang/semantic/typification-api.js";
-import { ValueClass } from "./rslang/semantic/value-class.js";
-import "./rslang/index.js";
-import { CstClass, CstStatus, CstType } from "./library/rsform.js";
-import { EvalStatus } from "./library/rsmodel.js";
-//#region src/library/rsform-api.ts
-/**
-* Module: API for formal representation for systems of concepts.
-*/
-/** Record of {@link CstType} prefixes. */
-const CST_TYPE_PREFIX = {
-	[CstType.NOMINAL]: "N",
-	[CstType.BASE]: "X",
-	[CstType.CONSTANT]: "C",
-	[CstType.STRUCTURED]: "S",
-	[CstType.AXIOM]: "A",
-	[CstType.TERM]: "D",
-	[CstType.FUNCTION]: "F",
-	[CstType.PREDICATE]: "P",
-	[CstType.STATEMENT]: "T"
-};
-/** Record of {@link CstType} to {@link CstClass} mapping. */
-const CST_TYPE_TO_CLASS = {
-	[CstType.NOMINAL]: CstClass.NOMINAL,
-	[CstType.BASE]: CstClass.BASIC,
-	[CstType.CONSTANT]: CstClass.BASIC,
-	[CstType.STRUCTURED]: CstClass.BASIC,
-	[CstType.TERM]: CstClass.DERIVED,
-	[CstType.FUNCTION]: CstClass.DERIVED,
-	[CstType.AXIOM]: CstClass.STATEMENT,
-	[CstType.PREDICATE]: CstClass.DERIVED,
-	[CstType.STATEMENT]: CstClass.STATEMENT
-};
-/** Checks if {@link Constituenta} is a schema issue. */
-function isSchemaIssue(cst) {
-	return (cst.diagnostics?.length ?? 0) > 0 || cst.status === CstStatus.INCORRECT || cst.status === CstStatus.INCALCULABLE;
-}
-/** Infers the status of an expression based on parsing and value information. */
-function inferStatus(parse, value) {
-	if (!parse) return CstStatus.INCORRECT;
-	if (value === null) return CstStatus.INCALCULABLE;
-	if (value === ValueClass.PROPERTY) return CstStatus.PROPERTY;
-	return CstStatus.VERIFIED;
-}
-/** Infers type of constituent for a given template and arguments. */
-function inferTemplatedType(templateType, args) {
-	if (args.length === 0 || args.some((arg) => !arg.value)) return templateType;
-	else if (templateType === CstType.PREDICATE) return CstType.AXIOM;
-	else return CstType.TERM;
-}
-/** Build alias mapping from template argument bindings. */
-function argumentValuesToMapping(args) {
-	const mapping = {};
-	for (const arg of args) if (arg.value) mapping[arg.alias] = arg.value;
-	return mapping;
-}
-/**
-* Normalize a RSLang expression for duplicate comparison.
-*
-* Returns `null` for basic concepts without formal definitions. Pass a pre-parsed `ast`
-* when the expression was already analyzed to avoid re-parsing.
-*/
-function normalizeExpression(expression, cst_type, ast) {
-	if (isBasicConcept(cst_type) && cst_type !== CstType.AXIOM) return null;
-	const parsed = ast ?? parseRSLangExpression(expression);
-	let normalized = "";
-	if (parsed && !parsed.hasError) normalized = generateExpressionFromAst(parsed, { normalize: true });
-	else normalized = expression;
-	normalized = normalized.replace(/\s+/g, "");
-	return normalized === "" ? null : normalized;
-}
-/** Checks if given expression is a template. */
-function inferTemplate(expression) {
-	const match = expression.match(/R\d+/g);
-	return (match && match?.length > 0) ?? false;
-}
-/** Infers the {@link CstClass} based on the provided {@link CstType} and template status. */
-function inferClass(type, isTemplate = false) {
-	if (isTemplate) return CstClass.TEMPLATE;
-	return CST_TYPE_TO_CLASS[type];
-}
-/** Check if {@link Constituenta} is a template or a category. */
-function isTemplateCst(cst) {
-	return cst.cst_type === CstType.FUNCTION || cst.cst_type === CstType.PREDICATE || cst.cst_type === CstType.STATEMENT;
-}
-/** Apply filter based on start {@link Constituenta} type. */
-function applyFilterCategory(start, items) {
-	const startIndex = items.indexOf(start);
-	if (startIndex === -1) return [];
-	const nextCategoryIndex = items.findIndex((cst, index) => index > startIndex && cst.cst_type === CstType.STATEMENT);
-	return items.filter((_, index) => index >= startIndex && (nextCategoryIndex === -1 || index < nextCategoryIndex));
-}
-/** Prefix for alias indicating {@link CstType}. */
-function getCstTypePrefix(type) {
-	return CST_TYPE_PREFIX[type];
-}
-/** Guess {@link CstType} from user input hint. */
-function guessCstType(hint) {
-	if (hint.length !== 1) return null;
-	for (const [type, prefix] of Object.entries(CST_TYPE_PREFIX)) if (hint === prefix) return type;
-	return null;
-}
-/** Evaluate if {@link CstType} is basic concept. */
-function isBasicConcept(type) {
-	switch (type) {
-		case CstType.NOMINAL:
-		case CstType.BASE:
-		case CstType.CONSTANT:
-		case CstType.STRUCTURED:
-		case CstType.AXIOM: return true;
-		case CstType.TERM:
-		case CstType.FUNCTION:
-		case CstType.PREDICATE:
-		case CstType.STATEMENT: return false;
-	}
-}
-/** Evaluate if {@link CstType} is base set or constant set. */
-function isBaseSet(type) {
-	switch (type) {
-		case CstType.BASE:
-		case CstType.CONSTANT: return true;
-		case CstType.NOMINAL:
-		case CstType.STRUCTURED:
-		case CstType.AXIOM:
-		case CstType.TERM:
-		case CstType.FUNCTION:
-		case CstType.PREDICATE:
-		case CstType.STATEMENT: return false;
-	}
-}
-/** Evaluate if {@link CstType} is a function. */
-function isFunctional(type) {
-	switch (type) {
-		case CstType.FUNCTION:
-		case CstType.PREDICATE: return true;
-		case CstType.NOMINAL:
-		case CstType.BASE:
-		case CstType.CONSTANT:
-		case CstType.STRUCTURED:
-		case CstType.AXIOM:
-		case CstType.TERM:
-		case CstType.STATEMENT: return false;
-	}
-}
-/** Evaluate if {@link CstType} is logical. */
-function isLogical(type) {
-	switch (type) {
-		case CstType.AXIOM:
-		case CstType.STATEMENT: return true;
-		case CstType.NOMINAL:
-		case CstType.BASE:
-		case CstType.CONSTANT:
-		case CstType.STRUCTURED:
-		case CstType.TERM:
-		case CstType.FUNCTION:
-		case CstType.PREDICATE: return false;
-	}
-}
-/** Evaluate if {@link Constituenta} can be used produce structure. */
-function canProduceStructure(cst) {
-	switch (cst.cst_type) {
-		case CstType.NOMINAL:
-		case CstType.BASE:
-		case CstType.CONSTANT:
-		case CstType.AXIOM:
-		case CstType.STATEMENT:
-		case CstType.PREDICATE: return false;
-	}
-	if (!cst.effectiveType) return false;
-	if (cst.cst_type === CstType.FUNCTION) {
-		const result = cst.effectiveType.result;
-		return typeCanProduceStructure(result);
-	}
-	if (!isTypification(cst.effectiveType)) return false;
-	return typeCanProduceStructure(cst.effectiveType);
-}
-/** Evaluate if {@link CstType} can have manual typification. */
-function canHaveManualTypification(type) {
-	switch (type) {
-		case CstType.STRUCTURED:
-		case CstType.TERM:
-		case CstType.FUNCTION:
-		case CstType.PREDICATE: return true;
-		case CstType.NOMINAL:
-		case CstType.BASE:
-		case CstType.CONSTANT:
-		case CstType.AXIOM:
-		case CstType.STATEMENT: return false;
-	}
-}
-/** Validate alias format for a given {@link CstType} (prefix + digits, min length 2). */
-function validateAliasFormat(alias, type) {
-	if (alias.length < 2) return false;
-	const prefix = getCstTypePrefix(type);
-	if (!alias.startsWith(prefix)) return false;
-	if (!/^\d+$/.exec(alias.substring(prefix.length))) return false;
-	return true;
-}
-/** Validate new alias against {@link CstType} and {@link RSForm}. */
-function validateNewAlias(alias, type, schema) {
-	if (!validateAliasFormat(alias, type)) return false;
-	if (schema.cstByAlias.has(alias)) return false;
-	return true;
-}
-/** Generate alias for new {@link Constituenta} of a given {@link CstType} for current {@link RSForm}. */
-function generateAlias(type, schema, takenAliases = []) {
-	const prefix = getCstTypePrefix(type);
-	if (schema.items.length <= 0) return `${prefix}1`;
-	let index = schema.items.reduce((prev, cst, index) => {
-		if (cst.cst_type !== type) return prev;
-		index = Number(cst.alias.slice(1 - cst.alias.length)) + 1;
-		return Math.max(prev, index);
-	}, 1);
-	let alias = `${prefix}${index}`;
-	while (takenAliases.includes(alias)) {
-		index = index + 1;
-		alias = `${prefix}${index}`;
-	}
-	return alias;
-}
-/**
-* Id to pass as `insert_after` when creating a new {@link Constituenta} spawned by `targetId`:
-* after the last existing child of that spawner, or after the spawner itself if none.
-*/
-function inferNewSpawnPosition(schema, targetId) {
-	let last = null;
-	for (const cst of schema.items) if (cst.spawner === targetId) last = cst.id;
-	return last ?? targetId;
-}
-/** Sorts library items relevant for InlineSynthesis with specified {@link RSForm}. */
-function sortItemsForInlineSynthesis(receiver, items) {
-	const result = items.filter((item) => item.location === receiver.location);
-	for (const item of items) if (item.visible && item.owner === item.owner && !result.includes(item)) result.push(item);
-	for (const item of items) if (item.visible && !result.includes(item)) result.push(item);
-	for (const item of items) if (!result.includes(item)) result.push(item);
-	return result;
-}
-/**
-* Remap formal expressions and terminological entity references in constituent fields.
-* Mutates each element of `items` in place; pass owned or cloned data only.
-*/
-function applyMappingToConstituents(items, mapping, changeAliases) {
-	for (const cst of items) {
-		if (changeAliases && cst.alias in mapping) cst.alias = mapping[cst.alias];
-		cst.definition_formal = applyAliasMapping(cst.definition_formal, mapping);
-		cst.typification_manual = applyTypificationMapping(cst.typification_manual, mapping);
-		cst.term_raw = applyEntityReferenceMapping(cst.term_raw, mapping);
-		cst.definition_raw = applyEntityReferenceMapping(cst.definition_raw, mapping);
-	}
-}
-/** Remove alias from expression. */
-function removeAliasReference(expression, alias) {
-	const result = expression.replaceAll(new RegExp(`\\b${alias}\\b`, "g"), "DEL");
-	return result === "DEL" ? "" : result;
-}
-/** Add alias to expression. */
-function addAliasReference(expression, alias) {
-	return expression + " " + alias;
-}
-/** Returns expected {@link TypeClass} of formal definition for {@link CstType}. */
-function typeClassForCstType(cstType) {
-	switch (cstType) {
-		case CstType.NOMINAL:
-		case CstType.BASE:
-		case CstType.CONSTANT:
-		case CstType.STRUCTURED:
-		case CstType.TERM: return TypeClass.typification;
-		case CstType.FUNCTION: return TypeClass.function;
-		case CstType.PREDICATE: return TypeClass.predicate;
-		case CstType.AXIOM:
-		case CstType.STATEMENT: return TypeClass.logic;
-	}
-}
-/** Checks whether a constituenta type supports formal definitions. */
-function canHaveFormalDefinition(cstType) {
-	return cstType !== CstType.BASE && cstType !== CstType.CONSTANT;
-}
-function getAnalysisFor(expression, cstType, schema, alias) {
-	if (!canHaveFormalDefinition(cstType)) {
-		if (expression.trim().length === 0) {
-			const fallbackAlias = alias && alias.length > 0 ? alias : "X0";
-			return {
-				success: true,
-				type: cstType === CstType.BASE ? bool(basic(fallbackAlias)) : bool(constant(fallbackAlias)),
-				valueClass: ValueClass.VALUE,
-				errors: [],
-				ast: null
-			};
-		}
-		return {
-			success: false,
-			type: null,
-			valueClass: null,
-			errors: [{
-				code: RSErrorCode.definitionNotAllowed,
-				from: 0,
-				to: Math.max(expression.length, 1),
-				params: [cstType, alias ?? ""]
-			}],
-			ast: null
-		};
-	}
-	return refineAnalysisForDependencyCycles(schema.analyzer.checkFull(expression, {
-		expected: typeClassForCstType(cstType),
-		isDomain: cstType === CstType.STRUCTURED
-	}), expression, schema, alias);
-}
-/**
-* When an untyped / bare F·P reference names a constituent on a definition cycle with the
-* current expression, replace that error with {@link RSDiagnosticCode.schemaDependencyCycle}.
-*
-* Covers both semantic `globalNotTyped` (e.g. `F3[σ]`) and parser `globalFuncWithoutArgs`
-* (bare `P1` / `F1` treated as a call without arguments).
-*
-* Uses a draft dependency graph: incoming edges of the edited constituent are taken from
-* `expression`, so Check works before Save.
-*/
-function refineAnalysisForDependencyCycles(analysis, expression, schema, alias) {
-	if (analysis.errors.length === 0 || !schema.graph) return analysis;
-	const currentId = alias ? schema.cstByAlias.get(alias)?.id : void 0;
-	const expressionGlobals = extractGlobals(expression);
-	const draftGraph = currentId !== void 0 ? buildDraftDependencyGraph(schema, currentId, expressionGlobals) : schema.graph;
-	let changed = false;
-	const errors = analysis.errors.map((error) => {
-		if (error.code !== RSErrorCode.globalNotTyped && error.code !== RSErrorCode.globalFuncWithoutArgs) return error;
-		const missingAlias = error.params?.[0];
-		if (!missingAlias) return error;
-		const missing = schema.cstByAlias.get(missingAlias);
-		if (!missing) return error;
-		const cycleText = resolveDependencyCycleText(schema, draftGraph, currentId, missing.id);
-		if (!cycleText) return error;
-		changed = true;
-		return {
-			...error,
-			code: RSErrorCode.schemaDependencyCycle,
-			params: [cycleText]
-		};
-	});
-	return changed ? {
-		...analysis,
-		errors
-	} : analysis;
-}
-/**
-* Clone the schema graph and replace dependencies of `currentId` with globals from the
-* expression under check (unsaved draft).
-*/
-function buildDraftDependencyGraph(schema, currentId, expressionGlobals) {
-	const graph = schema.graph.clone();
-	const node = graph.at(currentId);
-	if (node) for (const parentId of [...node.inputs]) graph.removeEdge(parentId, currentId);
-	else graph.addNode(currentId);
-	for (const globalAlias of expressionGlobals) {
-		const source = schema.cstByAlias.get(globalAlias);
-		if (source) graph.addEdge(source.id, currentId);
-	}
-	return graph;
-}
-/**
-* Resolve formatted cycle text for an untyped global reference in analysis.
-*
-* Uses `graph` (often a draft graph built from the expression under check). When
-* `currentId` is omitted, falls back to schema diagnostics on `missingId`.
-*
-* @returns Closed alias path such as `F3 → P1 → F3`, or `null` when no shared cycle exists.
-*/
-function resolveDependencyCycleText(schema, graph, currentId, missingId) {
-	for (const cycle of graph.findCycles()) {
-		const members = new Set(cycle);
-		if (!members.has(missingId)) continue;
-		if (currentId !== void 0 && !members.has(currentId)) continue;
-		return formatDependencyCycle(cycle.map((id) => schema.cstByID.get(id)?.alias ?? String(id)));
-	}
-	if (currentId === void 0) return (schema.cstByID.get(missingId)?.diagnostics.find((item) => item.code === RSDiagnosticCode.schemaDependencyCycle))?.params?.[0] ?? null;
-	return null;
-}
-/** Calculate statistics for {@link RSForm}. */
-function calculateSchemaStats(target) {
-	const items = target.items;
-	return {
-		count_all: items.length,
-		count_crucial: items.reduce((sum, cst) => sum + (cst.crucial ? 1 : 0), 0),
-		step_complexity: items.reduce((sum, cst) => sum + calculateStepComplexity(cst), 0),
-		count_problematic: items.reduce((sum, cst) => sum + (isSchemaIssue(cst) ? 1 : 0), 0),
-		count_homonyms: items.reduce((sum, cst) => sum + (hasCstDiagnostic(cst, RSDiagnosticCode.schemaHomonym) ? 1 : 0), 0),
-		count_formal_duplicates: items.reduce((sum, cst) => sum + (hasCstDiagnostic(cst, RSDiagnosticCode.schemaFormalDuplicate) ? 1 : 0), 0),
-		count_missing_convention: items.reduce((sum, cst) => sum + (isMissingConvention(cst) ? 1 : 0), 0),
-		count_type_mismatch: items.reduce((sum, cst) => sum + (cst.is_type_mismatch ? 1 : 0), 0),
-		count_incorrect: items.reduce((sum, cst) => sum + (cst.status === CstStatus.INCORRECT ? 1 : 0), 0),
-		count_property: items.reduce((sum, cst) => sum + (cst.analysis?.valueClass === ValueClass.PROPERTY ? 1 : 0), 0),
-		count_incalculable: items.reduce((sum, cst) => sum + (cst.analysis?.success && cst.analysis.valueClass === null ? 1 : 0), 0),
-		count_inherited: items.reduce((sum, cst) => sum + (cst.is_inherited ? 1 : 0), 0),
-		count_text_term: items.reduce((sum, cst) => sum + (cst.term_raw ? 1 : 0), 0),
-		count_definition: items.reduce((sum, cst) => sum + (cst.definition_raw ? 1 : 0), 0),
-		count_convention: items.reduce((sum, cst) => sum + (isBasicConcept(cst.cst_type) && cst.convention ? 1 : 0), 0),
-		count_comment: items.reduce((sum, cst) => sum + (!isBasicConcept(cst.cst_type) && !cst.convention ? 1 : 0), 0),
-		count_base: items.reduce((sum, cst) => sum + (cst.cst_type === CstType.BASE ? 1 : 0), 0),
-		count_constant: items.reduce((sum, cst) => sum + (cst.cst_type === CstType.CONSTANT ? 1 : 0), 0),
-		count_structured: items.reduce((sum, cst) => sum + (cst.cst_type === CstType.STRUCTURED ? 1 : 0), 0),
-		count_axiom: items.reduce((sum, cst) => sum + (cst.cst_type === CstType.AXIOM ? 1 : 0), 0),
-		count_term: items.reduce((sum, cst) => sum + (cst.cst_type === CstType.TERM ? 1 : 0), 0),
-		count_function: items.reduce((sum, cst) => sum + (cst.cst_type === CstType.FUNCTION ? 1 : 0), 0),
-		count_predicate: items.reduce((sum, cst) => sum + (cst.cst_type === CstType.PREDICATE ? 1 : 0), 0),
-		count_statement: items.reduce((sum, cst) => sum + (cst.cst_type === CstType.STATEMENT ? 1 : 0), 0),
-		count_nominal: items.reduce((sum, cst) => sum + (cst.cst_type === CstType.NOMINAL ? 1 : 0), 0)
-	};
-}
-/** Finds {@link Constituenta} by structure path. */
-function findCstByStructure(schema, target, path) {
-	for (const cst of schema.items) {
-		if (!cst.spawner_path) continue;
-		const absolutePath = resolveAbsoluteSpawnerPath(schema, cst, target.id);
-		if (absolutePath?.length === path.length && absolutePath.every((v, i) => v === path[i])) return cst;
-	}
-	return null;
-}
-/** Retrieves name for piece of target {@link Constituenta} structure. */
-function getStructureName(schema, target, path) {
-	const representation = findCstByStructure(schema, target, path);
-	if (representation) return `${representation.alias}: ${representation.term_resolved}`;
-	if (!isTypification(target.effectiveType)) return "";
-	const type = applyPath(target.effectiveType, path);
-	if (type?.typeID === TypeID.basic) {
-		const cst = schema.cstByAlias.get(type.baseID);
-		if (cst?.term_resolved) return `${cst.alias}: ${cst.term_resolved}`;
-	}
-	return "";
-}
-function calculateStepComplexity(cst) {
-	if (cst.cst_type === CstType.AXIOM || cst.cst_type === CstType.NOMINAL || !isBasicConcept(cst.cst_type)) return 0;
-	if (cst.cst_type === CstType.BASE || cst.cst_type === CstType.CONSTANT || !cst.effectiveType) return 1;
-	const type = cst.effectiveType;
-	return calculateTypificationComplexity(type) + 1;
-}
-function calculateTypificationComplexity(type) {
-	switch (type.typeID) {
-		case TypeID.basic:
-		case TypeID.integer:
-		case TypeID.anyTypification: return 0;
-		case TypeID.tuple: return type.factors.length + type.factors.reduce((sum, factor) => sum + calculateTypificationComplexity(factor), 0);
-		case TypeID.collection:
-			if (type.base.typeID === TypeID.tuple) {
-				let sum = 0;
-				type.base.factors.forEach((factor) => {
-					sum += calculateTypificationComplexity(factor);
-				});
-				return sum + type.base.factors.length;
-			} else if (type.base.typeID === TypeID.collection) return calculateTypificationComplexity(type.base) + 1;
-			return 0;
-	}
-}
-function isMissingConvention(cst) {
-	if (isBasicConcept(cst.cst_type) && !isLogical(cst.cst_type)) {
-		if (!cst.convention || !cst.term_resolved) return true;
-	}
-	return false;
-}
-function resolveAbsoluteSpawnerPath(schema, cst, targetId) {
-	if (!cst.spawner_path || cst.spawner == null) return null;
-	if (cst.spawner === targetId) return cst.spawner_path;
-	const byId = schema.cstByID ?? new Map(schema.items.map((item) => [item.id, item]));
-	const visited = /* @__PURE__ */ new Set([cst.id]);
-	let currentPath = [...cst.spawner_path];
-	let currentSpawnerId = cst.spawner;
-	while (currentSpawnerId != null) {
-		if (currentSpawnerId === targetId) return currentPath;
-		if (visited.has(currentSpawnerId)) return null;
-		visited.add(currentSpawnerId);
-		const parent = byId.get(currentSpawnerId);
-		if (!parent?.spawner_path || parent.spawner == null) return null;
-		currentPath = [...parent.spawner_path, ...currentPath];
-		currentSpawnerId = parent.spawner;
-	}
-	return null;
-}
-/** Evaluate if {@link Typification} can be used to produce structure. */
-function typeCanProduceStructure(type) {
-	if (type.typeID === TypeID.basic || type.typeID === TypeID.integer || type.typeID === TypeID.anyTypification) return false;
-	else if (type.typeID === TypeID.tuple) return true;
-	else return type.base.typeID !== TypeID.basic && type.base.typeID !== TypeID.integer && type.base.typeID !== TypeID.anyTypification;
-}
-//#endregion
-//#region src/library/diagnostics.ts
-/** Origin of a diagnostic. */
-const DiagnosticKind = {
-	EXPRESSION: "expression",
-	SCHEMA: "schema",
-	MODEL: "model"
-};
-/** Schema and model diagnostic codes (same numeric format as {@link RSErrorCode}). */
-const RSDiagnosticCode = {
-	schemaHomonym: 35073,
-	schemaFormalDuplicate: 35074,
-	schemaMissingConvention: 35075,
-	schemaMissingTerm: 35076,
-	schemaTypeMismatch: 35077,
-	schemaDependencyCycle: 35078,
-	modelEmpty: 35088,
-	modelAxiomFalse: 35089,
-	modelInvalidData: 35090,
-	modelEvalFail: 35091
-};
-/** Whether a constituent has a schema/model diagnostic with the given code. */
-function hasCstDiagnostic(cst, code) {
-	return cst.diagnostics?.some((item) => item.code === code) ?? false;
-}
-/**
-* Populate `diagnostics` on each constituent (homonyms, duplicates, metadata, type mismatch, cycles).
-*
-* Requires normalized formal definitions for duplicate detection (same as Portal loader).
-* When `graph` is provided, dependency cycles are reported as {@link RSDiagnosticCode.schemaDependencyCycle}.
-*/
-function assignSchemaDiagnostics(items, resolveAlias, normalizedDefinitions, graph) {
-	const homonymById = detectHomonymDiagnostics(items, resolveAlias);
-	const duplicateById = detectFormalDuplicateDiagnostics(items, resolveAlias, normalizedDefinitions);
-	const cycleById = graph ? detectDependencyCycleDiagnostics(graph, resolveAlias) : /* @__PURE__ */ new Map();
-	for (const cst of items) {
-		const diagnostics = [];
-		const cycle = cycleById.get(cst.id);
-		if (cycle) diagnostics.push(cycle);
-		const homonym = homonymById.get(cst.id);
-		if (homonym) diagnostics.push(homonym);
-		const duplicate = duplicateById.get(cst.id);
-		if (duplicate) diagnostics.push(duplicate);
-		diagnostics.push(...collectLocalSchemaDiagnostics(cst));
-		cst.diagnostics = diagnostics;
-	}
-}
-/**
-* Format a closed dependency cycle as `A → B → A`.
-*
-* Rotates the path to start at the lexicographically smallest alias so the same
-* cycle always renders identically regardless of graph traversal order.
-*
-* @param aliases Closed or open alias path from {@link Graph.findCycles}.
-* @returns Human-readable cycle text joined with ` → `.
-*/
-function formatDependencyCycle(aliases) {
-	if (aliases.length < 2) return aliases.join(" → ");
-	const closed = aliases[0] === aliases[aliases.length - 1];
-	const open = closed ? aliases.slice(0, -1) : [...aliases];
-	if (open.length === 0) return aliases.join(" → ");
-	let bestStart = 0;
-	for (let index = 1; index < open.length; index++) {
-		const alias = open[index];
-		const bestAlias = open[bestStart];
-		if (alias !== void 0 && bestAlias !== void 0 && alias < bestAlias) bestStart = index;
-	}
-	const rotated = [...open.slice(bestStart), ...open.slice(0, bestStart)];
-	if (closed) {
-		const first = rotated[0];
-		if (first !== void 0) rotated.push(first);
-	}
-	return rotated.join(" → ");
-}
-/**
-* Map each node id that participates in a dependency cycle to a schema diagnostic.
-*
-* `params[0]` is the closed cycle path (`F3 → P1 → F3`).
-*
-* @param graph Constituent dependency graph (provider → dependent edges).
-* @param resolveAlias Maps node id to display alias for cycle formatting.
-* @returns One {@link CstDiagnostic} per node on each cyclic SCC.
-*/
-function detectDependencyCycleDiagnostics(graph, resolveAlias) {
-	const result = /* @__PURE__ */ new Map();
-	for (const cycle of graph.findCycles()) {
-		if (cycle.length < 2) continue;
-		const cycleText = formatDependencyCycle(cycle.map((id) => resolveAlias(id)));
-		const memberIds = new Set(cycle);
-		for (const id of memberIds) result.set(id, {
-			kind: DiagnosticKind.SCHEMA,
-			code: RSDiagnosticCode.schemaDependencyCycle,
-			params: [cycleText]
-		});
-	}
-	return result;
-}
-/** Map a model evaluation status to a compact diagnostic, or `null` when not an issue. */
-function modelStatusCstDiagnostic(status, cstType) {
-	const code = modelStatusToCode(status, cstType);
-	if (code === null) return null;
-	return {
-		kind: DiagnosticKind.MODEL,
-		code,
-		params: [String(status)]
-	};
-}
-function collectLocalSchemaDiagnostics(cst) {
-	const result = [];
-	if (cst.is_type_mismatch) result.push({
-		kind: DiagnosticKind.SCHEMA,
-		code: RSDiagnosticCode.schemaTypeMismatch,
-		params: [cst.typification_manual, labelType(cst.analysis.type)]
-	});
-	if (isBasicConcept(cst.cst_type) && !isLogical(cst.cst_type)) {
-		if (!cst.convention.trim()) result.push({
-			kind: DiagnosticKind.SCHEMA,
-			code: RSDiagnosticCode.schemaMissingConvention
-		});
-		if (!cst.term_resolved.trim()) result.push({
-			kind: DiagnosticKind.SCHEMA,
-			code: RSDiagnosticCode.schemaMissingTerm
-		});
-	}
-	return result;
-}
-function detectGroupedAliasDiagnostics(items, resolveAlias, groupKey, code) {
-	const groups = /* @__PURE__ */ new Map();
-	for (const cst of items) {
-		const key = groupKey(cst);
-		if (!key) continue;
-		const group = groups.get(key) ?? [];
-		group.push(cst);
-		groups.set(key, group);
-	}
-	const result = /* @__PURE__ */ new Map();
-	for (const group of groups.values()) {
-		if (group.length <= 1) continue;
-		for (const cst of group) {
-			const aliases = group.filter((other) => other.id !== cst.id).map((other) => resolveAlias(other.id)).join(", ");
-			result.set(cst.id, {
-				kind: DiagnosticKind.SCHEMA,
-				code,
-				params: [aliases]
-			});
-		}
-	}
-	return result;
-}
-function detectHomonymDiagnostics(items, resolveAlias) {
-	return detectGroupedAliasDiagnostics(items, resolveAlias, (cst) => {
-		const key = cst.term_resolved.trim().toLocaleLowerCase();
-		return key === "" ? void 0 : key;
-	}, RSDiagnosticCode.schemaHomonym);
-}
-function detectFormalDuplicateDiagnostics(items, resolveAlias, normalizedDefinitions) {
-	return detectGroupedAliasDiagnostics(items, resolveAlias, (cst) => normalizedDefinitions.get(cst.id), RSDiagnosticCode.schemaFormalDuplicate);
-}
-function modelStatusToCode(status, cstType) {
-	switch (status) {
-		case EvalStatus.EMPTY: return isBasicConcept(cstType) ? RSDiagnosticCode.modelEmpty : null;
-		case EvalStatus.AXIOM_FALSE: return RSDiagnosticCode.modelAxiomFalse;
-		case EvalStatus.INVALID_DATA: return RSDiagnosticCode.modelInvalidData;
-		case EvalStatus.EVAL_FAIL: return RSDiagnosticCode.modelEvalFail;
-		default: return null;
-	}
-}
-//#endregion
-export { isLogical as A, inferNewSpawnPosition as C, isBaseSet as D, inferTemplatedType as E, removeAliasReference as F, sortItemsForInlineSynthesis as I, typeClassForCstType as L, isTemplateCst as M, normalizeExpression as N, isBasicConcept as O, refineAnalysisForDependencyCycles as P, validateAliasFormat as R, inferClass as S, inferTemplate as T, generateAlias as _, formatDependencyCycle as a, getStructureName as b, addAliasReference as c, argumentValuesToMapping as d, calculateSchemaStats as f, findCstByStructure as g, canProduceStructure as h, detectDependencyCycleDiagnostics as i, isSchemaIssue as j, isFunctional as k, applyFilterCategory as l, canHaveManualTypification as m, RSDiagnosticCode as n, hasCstDiagnostic as o, canHaveFormalDefinition as p, assignSchemaDiagnostics as r, modelStatusCstDiagnostic as s, DiagnosticKind as t, applyMappingToConstituents as u, getAnalysisFor as v, inferStatus as w, guessCstType as x, getCstTypePrefix as y, validateNewAlias as z };
-
-//# sourceMappingURL=diagnostics-CY9sKggB.js.map