@rsconcept/domain 2.1.1 → 2.2.0

package/dist/{diagnostics-CY9sKggB.js → diagnostics-B1OfMra1.js}

@@ -1,17 +1,19 @@
+import { Graph } from "./graph/graph.js";
 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 { applyAliasMapping, applyTypificationMapping, extractGlobals, isSimpleExpression, parseRSLangExpression, splitTemplateDefinition } from "./rslang/api.js";
+import { RSErrorCode } from "./rslang/error.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 "./graph/index.js";
 import { EvalStatus } from "./library/rsmodel.js";
-//#region src/library/rsform-api.ts
+//#region src/library/rsform-api/cst-type.ts
 /**
-* Module: API for formal representation for systems of concepts.
+* CstType classification, prefixes, and capability predicates.
 */
 /** Record of {@link CstType} prefixes. */
 const CST_TYPE_PREFIX = {
@@ -37,48 +39,15 @@ const CST_TYPE_TO_CLASS = {
 	[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;
+/** Prefix for alias indicating {@link CstType}. */
+function getCstTypePrefix(type) {
+	return CST_TYPE_PREFIX[type];
 }
-/** Checks if given expression is a template. */
-function inferTemplate(expression) {
-	const match = expression.match(/R\d+/g);
-	return (match && match?.length > 0) ?? false;
+/** 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;
 }
 /** Infers the {@link CstClass} based on the provided {@link CstType} and template status. */
 function inferClass(type, isTemplate = false) {
@@ -89,23 +58,6 @@ function inferClass(type, isTemplate = false) {
 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) {
@@ -162,6 +114,38 @@ function isLogical(type) {
 		case CstType.PREDICATE: return false;
 	}
 }
+/** 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;
+	}
+}
+/** Checks whether a constituenta type supports formal definitions. */
+function canHaveFormalDefinition(cstType) {
+	return cstType !== CstType.BASE && cstType !== CstType.CONSTANT;
+}
+/** 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;
+	}
+}
 /** Evaluate if {@link Constituenta} can be used produce structure. */
 function canProduceStructure(cst) {
 	switch (cst.cst_type) {
@@ -180,19 +164,21 @@ function canProduceStructure(cst) {
 	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;
-	}
+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/rsform-api/alias.ts
+/**
+* Alias generation, validation, and remapping.
+*/
+/** 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;
 }
 /** Validate alias format for a given {@link CstType} (prefix + digits, min length 2). */
 function validateAliasFormat(alias, type) {
@@ -211,11 +197,10 @@ function validateNewAlias(alias, type, schema) {
 /** 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) => {
+	let index = schema.items.reduce((prev, cst) => {
 		if (cst.cst_type !== type) return prev;
-		index = Number(cst.alias.slice(1 - cst.alias.length)) + 1;
-		return Math.max(prev, index);
+		const next = Number(cst.alias.substring(prefix.length)) + 1;
+		return Math.max(prev, next);
 	}, 1);
 	let alias = `${prefix}${index}`;
 	while (takenAliases.includes(alias)) {
@@ -225,23 +210,6 @@ function generateAlias(type, schema, takenAliases = []) {
 	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.
 */
@@ -256,31 +224,15 @@ function applyMappingToConstituents(items, mapping, changeAliases) {
 }
 /** Remove alias from expression. */
 function removeAliasReference(expression, alias) {
-	const result = expression.replaceAll(new RegExp(`\\b${alias}\\b`, "g"), "DEL");
-	return result === "DEL" ? "" : result;
+	const escaped = alias.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	return expression.replaceAll(new RegExp(`\\b${escaped}\\b`, "g"), "").trim();
 }
 /** 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;
-}
+//#endregion
+//#region src/library/rsform-api/analysis.ts
 function getAnalysisFor(expression, cstType, schema, alias) {
 	if (!canHaveFormalDefinition(cstType)) {
 		if (expression.trim().length === 0) {
@@ -380,57 +332,305 @@ function resolveDependencyCycleText(schema, graph, currentId, missingId) {
 	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;
+//#endregion
+//#region src/library/rsform-api/expression.ts
+/** 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;
+}
+/**
+* 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;
+}
+/** 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));
+}
+//#endregion
+//#region src/library/rsform-api/semantic-relations.ts
+/**
+* Infer semantic parent/children used for clustering during restore order.
+* Port of backend {@code SemanticInfo}.
+*/
+function computeSemanticRelations(items, graph) {
+	const byId = new Map(items.map((cst) => [cst.id, cst]));
+	const byAlias = new Map(items.map((cst) => [cst.alias, cst]));
+	const isTemplate = /* @__PURE__ */ new Map();
+	const isSimple = /* @__PURE__ */ new Map();
+	const parentOf = /* @__PURE__ */ new Map();
+	const childrenOf = /* @__PURE__ */ new Map();
+	for (const cst of items) {
+		parentOf.set(cst.id, cst.id);
+		childrenOf.set(cst.id, []);
+	}
+	function needCheckHead(sources, head) {
+		if (sources.size === 0) return true;
+		if (sources.size !== 1) return false;
+		const base = byId.get([...sources][0]);
+		return !isFunctional(base.cst_type) || splitTemplateDefinition(base.definition_formal).head !== head;
+	}
+	function extractSources(target) {
+		const sources = /* @__PURE__ */ new Set();
+		if (!isFunctional(target.cst_type)) {
+			for (const parentId of graph.at(target.id)?.inputs ?? []) if (!(isTemplate.get(parentId) && isSimple.get(parentId))) sources.add(parentOf.get(parentId) ?? parentId);
+			return sources;
+		}
+		const expression = splitTemplateDefinition(target.definition_formal);
+		for (const alias of extractGlobals(expression.body)) {
+			const parent = byAlias.get(alias);
+			if (!parent) continue;
+			if (!(isTemplate.get(parent.id) && isSimple.get(parent.id))) sources.add(parentOf.get(parent.id) ?? parent.id);
+		}
+		if (needCheckHead(sources, expression.head)) for (const alias of extractGlobals(expression.head)) {
+			const parent = byAlias.get(alias);
+			if (!parent) continue;
+			if (!isBaseSet(parent.cst_type) && !(isTemplate.get(parent.id) && isSimple.get(parent.id))) sources.add(parentOf.get(parent.id) ?? parent.id);
+		}
+		return sources;
+	}
+	function inferSimple(target) {
+		if (target.cst_type === CstType.STRUCTURED || isBaseSet(target.cst_type)) return false;
+		if ((graph.at(target.id)?.inputs ?? []).some((id) => isTemplate.get(id) && !isSimple.get(id))) return false;
+		return isSimpleExpression(isFunctional(target.cst_type) ? splitTemplateDefinition(target.definition_formal).body : target.definition_formal);
+	}
+	for (const cstId of graph.topologicalOrder()) {
+		const cst = byId.get(cstId);
+		if (!cst) continue;
+		isTemplate.set(cstId, inferTemplate(cst.definition_formal));
+		isSimple.set(cstId, inferSimple(cst));
+		if (!isSimple.get(cstId) || cst.cst_type === CstType.STRUCTURED) continue;
+		const sources = extractSources(cst);
+		if (sources.size !== 1) continue;
+		const parentId = [...sources][0];
+		const parent = byId.get(parentId);
+		if (!parent || isBaseSet(parent.cst_type)) continue;
+		parentOf.set(cstId, parentId);
+		childrenOf.get(parentId).push(cstId);
+	}
 	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)
+		parentOf,
+		childrenOf
 	};
 }
-/** 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;
+//#endregion
+//#region src/library/rsform-api/formal-graph.ts
+/**
+* Formal dependency graph and declaration-order restore for RSForm constituents.
+*/
+/**
+* Build the formal dependency graph: supplier → dependent.
+* Matches backend {@code RSForm.graph_formal}.
+*/
+function buildFormalDependencyGraph(items) {
+	const graph = new Graph();
+	const byAlias = new Map(items.map((cst) => [cst.alias, cst]));
+	for (const cst of items) graph.addNode(cst.id);
+	for (const cst of items) for (const alias of extractGlobals(cst.definition_formal)) {
+		const supplier = byAlias.get(alias);
+		if (supplier) graph.addEdge(supplier.id, cst.id);
 	}
-	return null;
+	return graph;
 }
-/** 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}`;
+/**
+* Reorder constituents: formal topology hard, semantic children sticky when ready,
+* otherwise stable against type/kernel preferred ranks.
+*
+* One Kahn pass over the formal dependency graph.
+*/
+function restoreConstituentOrder(items, graph = buildFormalDependencyGraph(items), relations = computeSemanticRelations(items, graph)) {
+	if (items.length <= 1) return [...items];
+	const byId = new Map(items.map((cst) => [cst.id, cst]));
+	const preferred = kernelPriority(items, graph, relations.parentOf);
+	const rank = new Map(preferred.map((cst, index) => [cst.id, index]));
+	const remainingInputs = /* @__PURE__ */ new Map();
+	for (const cst of preferred) {
+		const inputs = graph.at(cst.id)?.inputs ?? [];
+		remainingInputs.set(cst.id, inputs.reduce((count, src) => count + (rank.has(src) ? 1 : 0), 0));
 	}
-	return "";
+	const ready = /* @__PURE__ */ new Set();
+	for (const cst of preferred) if ((remainingInputs.get(cst.id) ?? 0) === 0) ready.add(cst.id);
+	const children = /* @__PURE__ */ new Map();
+	for (const cst of preferred) children.set(cst.id, (relations.childrenOf.get(cst.id) ?? []).filter((childId) => rank.has(childId)));
+	const result = [];
+	const pendingChildren = [];
+	function enqueueSticky(candidateIds) {
+		const sticky = candidateIds.filter((childId) => ready.has(childId) && !pendingChildren.includes(childId));
+		sticky.sort((left, right) => (rank.get(left) ?? 0) - (rank.get(right) ?? 0));
+		pendingChildren.push(...sticky);
+	}
+	function pickReady() {
+		while (pendingChildren.length > 0) {
+			const childId = pendingChildren.shift();
+			if (ready.has(childId)) return childId;
+		}
+		let best = -1;
+		let bestRank = Number.POSITIVE_INFINITY;
+		for (const nodeId of ready) {
+			const nodeRank = rank.get(nodeId) ?? Number.POSITIVE_INFINITY;
+			if (nodeRank < bestRank) {
+				best = nodeId;
+				bestRank = nodeRank;
+			}
+		}
+		return best;
+	}
+	while (ready.size > 0 || pendingChildren.length > 0) {
+		if (ready.size === 0) {
+			pendingChildren.length = 0;
+			continue;
+		}
+		const nodeId = pickReady();
+		ready.delete(nodeId);
+		result.push(byId.get(nodeId));
+		for (const dependentId of graph.at(nodeId)?.outputs ?? []) {
+			if (!remainingInputs.has(dependentId)) continue;
+			const next = (remainingInputs.get(dependentId) ?? 0) - 1;
+			remainingInputs.set(dependentId, next);
+			if (next === 0) ready.add(dependentId);
+		}
+		enqueueSticky(children.get(nodeId) ?? []);
+	}
+	if (result.length < preferred.length) {
+		const placed = new Set(result.map((cst) => cst.id));
+		for (const cst of preferred) if (!placed.has(cst.id)) result.push(cst);
+	}
+	return result;
+}
+function kernelPriority(items, graph, parentOf) {
+	const byId = new Map(items.map((cst) => [cst.id, cst]));
+	const seen = /* @__PURE__ */ new Set();
+	const result = [];
+	function push(cst) {
+		if (seen.has(cst.id)) return;
+		seen.add(cst.id);
+		result.push(cst);
+	}
+	for (const cst of items) if (cst.cst_type === CstType.BASE) push(cst);
+	for (const cst of items) if (cst.cst_type === CstType.CONSTANT) push(cst);
+	for (const cst of items) if ((graph.at(cst.id)?.inputs.length ?? 0) === 0) push(cst);
+	const kernelSeeds = items.filter((cst) => {
+		const parentId = parentOf.get(cst.id) ?? cst.id;
+		const parent = byId.get(parentId);
+		return cst.cst_type === CstType.STRUCTURED || cst.cst_type === CstType.AXIOM || parent?.cst_type === CstType.STRUCTURED;
+	}).map((cst) => cst.id);
+	const kernel = /* @__PURE__ */ new Set([...kernelSeeds, ...graph.expandAllInputs(kernelSeeds)]);
+	for (const cst of items) if (kernel.has(cst.id)) push(cst);
+	for (const cst of items) push(cst);
+	return result;
+}
+//#endregion
+//#region src/library/rsform-api/stats.ts
+/**
+* Schema-level statistics and issue flags.
+*/
+/** 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;
+}
+/** Calculate statistics for {@link RSForm}. */
+function calculateSchemaStats(target) {
+	const stats = {
+		count_all: target.items.length,
+		count_crucial: 0,
+		step_complexity: 0,
+		count_problematic: 0,
+		count_homonyms: 0,
+		count_formal_duplicates: 0,
+		count_missing_basic_text: 0,
+		count_type_mismatch: 0,
+		count_incorrect: 0,
+		count_property: 0,
+		count_incalculable: 0,
+		count_inherited: 0,
+		count_text_term: 0,
+		count_definition: 0,
+		count_convention: 0,
+		count_comment: 0,
+		count_base: 0,
+		count_constant: 0,
+		count_structured: 0,
+		count_axiom: 0,
+		count_term: 0,
+		count_function: 0,
+		count_predicate: 0,
+		count_statement: 0,
+		count_nominal: 0
+	};
+	for (const cst of target.items) {
+		if (cst.crucial) stats.count_crucial += 1;
+		stats.step_complexity += calculateStepComplexity(cst);
+		if (isSchemaIssue(cst)) stats.count_problematic += 1;
+		if (hasCstDiagnostic(cst, RSDiagnosticCode.schemaHomonym)) stats.count_homonyms += 1;
+		if (hasCstDiagnostic(cst, RSDiagnosticCode.schemaFormalDuplicate)) stats.count_formal_duplicates += 1;
+		if (isMissingBasicText(cst)) stats.count_missing_basic_text += 1;
+		if (cst.is_type_mismatch) stats.count_type_mismatch += 1;
+		if (cst.status === CstStatus.INCORRECT) stats.count_incorrect += 1;
+		if (cst.analysis?.valueClass === ValueClass.PROPERTY) stats.count_property += 1;
+		if (cst.analysis?.success && cst.analysis.valueClass === null) stats.count_incalculable += 1;
+		if (cst.is_inherited) stats.count_inherited += 1;
+		if (cst.term_raw) stats.count_text_term += 1;
+		if (cst.definition_raw) stats.count_definition += 1;
+		if (isBasicConcept(cst.cst_type) && cst.convention) stats.count_convention += 1;
+		if (!isBasicConcept(cst.cst_type) && !cst.convention) stats.count_comment += 1;
+		switch (cst.cst_type) {
+			case CstType.BASE:
+				stats.count_base += 1;
+				break;
+			case CstType.CONSTANT:
+				stats.count_constant += 1;
+				break;
+			case CstType.STRUCTURED:
+				stats.count_structured += 1;
+				break;
+			case CstType.AXIOM:
+				stats.count_axiom += 1;
+				break;
+			case CstType.TERM:
+				stats.count_term += 1;
+				break;
+			case CstType.FUNCTION:
+				stats.count_function += 1;
+				break;
+			case CstType.PREDICATE:
+				stats.count_predicate += 1;
+				break;
+			case CstType.STATEMENT:
+				stats.count_statement += 1;
+				break;
+			case CstType.NOMINAL:
+				stats.count_nominal += 1;
+				break;
+		}
+	}
+	return stats;
 }
 function calculateStepComplexity(cst) {
 	if (cst.cst_type === CstType.AXIOM || cst.cst_type === CstType.NOMINAL || !isBasicConcept(cst.cst_type)) return 0;
@@ -455,16 +655,50 @@ function calculateTypificationComplexity(type) {
 			return 0;
 	}
 }
-function isMissingConvention(cst) {
-	if (isBasicConcept(cst.cst_type) && !isLogical(cst.cst_type)) {
-		if (!cst.convention || !cst.term_resolved) return true;
+/** Non-logical basic concept missing convention and/or resolved term (trimmed). */
+function isMissingBasicText(cst) {
+	if (!isBasicConcept(cst.cst_type) || isLogical(cst.cst_type)) return false;
+	return !cst.convention.trim() || !cst.term_resolved.trim();
+}
+//#endregion
+//#region src/library/rsform-api/structure.ts
+/**
+* Structure-path helpers for spawned constituents.
+*/
+/**
+* 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;
+}
+/** Finds {@link Constituenta} by structure path. */
+function findCstByStructure(schema, target, path) {
+	const byId = schema.cstByID ?? new Map(schema.items.map((item) => [item.id, item]));
+	for (const cst of schema.items) {
+		if (!cst.spawner_path) continue;
+		const absolutePath = resolveAbsoluteSpawnerPath(cst, target.id, byId);
+		if (absolutePath?.length === path.length && absolutePath.every((v, i) => v === path[i])) return cst;
 	}
-	return false;
+	return null;
 }
-function resolveAbsoluteSpawnerPath(schema, cst, targetId) {
+/** 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 resolveAbsoluteSpawnerPath(cst, targetId, byId) {
 	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;
@@ -479,11 +713,15 @@ function resolveAbsoluteSpawnerPath(schema, cst, targetId) {
 	}
 	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/rsform-api/synthesis.ts
+/** 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 === receiver.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;
 }
 //#endregion
 //#region src/library/diagnostics.ts
@@ -653,6 +891,6 @@ function modelStatusToCode(status, cstType) {
 	}
 }
 //#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 };
+export { canProduceStructure as A, applyMappingToConstituents as C, validateAliasFormat as D, removeAliasReference as E, isBasicConcept as F, isFunctional as I, isLogical as L, guessCstType as M, inferClass as N, validateNewAlias as O, isBaseSet as P, isTemplateCst as R, addAliasReference as S, generateAlias as T, inferTemplate as _, formatDependencyCycle as a, getAnalysisFor as b, sortItemsForInlineSynthesis as c, inferNewSpawnPosition as d, calculateSchemaStats as f, inferStatus as g, applyFilterCategory as h, detectDependencyCycleDiagnostics as i, getCstTypePrefix as j, canHaveManualTypification as k, findCstByStructure as l, restoreConstituentOrder as m, RSDiagnosticCode as n, hasCstDiagnostic as o, isSchemaIssue as p, assignSchemaDiagnostics as r, modelStatusCstDiagnostic as s, DiagnosticKind as t, getStructureName as u, inferTemplatedType as v, argumentValuesToMapping as w, refineAnalysisForDependencyCycles as x, normalizeExpression as y, typeClassForCstType as z };
 
-//# sourceMappingURL=diagnostics-CY9sKggB.js.map
+//# sourceMappingURL=diagnostics-B1OfMra1.js.map