@rsconcept/domain 1.8.1 → 2.0.2

package/dist/index.js

@@ -1,14 +1,11 @@
 import { Grammeme, ReferenceType, supportedGrammemes } from "./cctext/language.js";
 import { Graph } from "./graph/graph.js";
-import { FolderNode, FolderTree } from "./library/folder-tree.js";
-import { AccessPolicy, LibraryItemType, LocationHead } from "./library/library.js";
-import { NodeType, OperationType, SubstitutionErrorType } from "./library/oss.js";
-import { readErrorAnnotation, readTypeAnnotation } from "./rslang/ast-annotations.js";
-import { RSErrorCode } from "./rslang/error.js";
 import { TOKEN_ERROR, buildTree, findByUid, flattenAst, getNodeIndices, getNodeText, printAst, visitAstDFS } from "./parsing/ast.js";
 import { printTree } from "./parsing/lezer-tree.js";
 import { TokenID } from "./rslang/parser/token.js";
 import { AnyTypificationT, EmptySetT, LogicT, TypeClass, TypeID, makeTypePath } from "./rslang/semantic/typification.js";
+import { readErrorAnnotation, readTypeAnnotation } from "./rslang/ast-annotations.js";
+import { RSErrorCode } from "./rslang/error.js";
 import { applyHash_fnv1a, generateStub } from "./shared/hash.js";
 import { C as printValue, o as TUPLE_ID, u as makeValuePath } from "./value-COprb2Je.js";
 import { RSCalculator } from "./rslang/eval/calculator.js";
@@ -18,6 +15,10 @@ import { RSLangAnalyzer } from "./rslang/semantic/analyzer.js";
 import { applyAsciiTypeSubstitutions, parseTypeText } from "./rslang/semantic/typification-parser.js";
 import { TypificationGraph } from "./rslang/typification-graph.js";
 import { CstClass, CstStatus, CstType } from "./library/rsform.js";
+import { a as modelStatusCstDiagnostic, i as hasCstDiagnostic, n as RSDiagnosticCode, r as assignSchemaDiagnostics, t as DiagnosticKind } from "./diagnostics-D7SiHAwW.js";
 import { DEFAULT_VALUE_TEXT, EvalStatus } from "./library/rsmodel.js";
+import { FolderNode, FolderTree } from "./library/folder-tree.js";
+import { AccessPolicy, LibraryItemType, LocationHead } from "./library/library.js";
+import { NodeType, OperationType, SubstitutionErrorType } from "./library/oss.js";
 import { RSEngine } from "./library/rsengine.js";
-export { AccessPolicy, AnyTypificationT, CstClass, CstStatus, CstType, DEFAULT_VALUE_TEXT, EmptySetT, EvalStatus, FolderNode, FolderTree, Grammeme, Graph, LibraryItemType, LocationHead, LogicT, NodeType, OperationType, RSCalculator, RSEngine, RSErrorCode, RSLangAnalyzer, ReferenceType, SubstitutionErrorType, TOKEN_ERROR, TUPLE_ID, TokenID, TypeClass, TypeID, TypificationGraph, ValueClass, applyAsciiTypeSubstitutions, applyHash_fnv1a, buildTree, findByUid, flattenAst, generateStub, getNodeIndices, getNodeText, makeTypePath, makeValuePath, parseTypeText, printAst, printTree, printValue, readErrorAnnotation, readTypeAnnotation, parser as rslangParser, supportedGrammemes, visitAstDFS };
+export { AccessPolicy, AnyTypificationT, CstClass, CstStatus, CstType, DEFAULT_VALUE_TEXT, DiagnosticKind, EmptySetT, EvalStatus, FolderNode, FolderTree, Grammeme, Graph, LibraryItemType, LocationHead, LogicT, NodeType, OperationType, RSCalculator, RSDiagnosticCode, RSEngine, RSErrorCode, RSLangAnalyzer, ReferenceType, SubstitutionErrorType, TOKEN_ERROR, TUPLE_ID, TokenID, TypeClass, TypeID, TypificationGraph, ValueClass, applyAsciiTypeSubstitutions, applyHash_fnv1a, assignSchemaDiagnostics, buildTree, findByUid, flattenAst, generateStub, getNodeIndices, getNodeText, hasCstDiagnostic, makeTypePath, makeValuePath, modelStatusCstDiagnostic, parseTypeText, printAst, printTree, printValue, readErrorAnnotation, readTypeAnnotation, parser as rslangParser, supportedGrammemes, visitAstDFS };

package/dist/library/diagnostics.d.ts

@@ -0,0 +1,2 @@
+import { a as hasCstDiagnostic, i as assignSchemaDiagnostics, n as DiagnosticKind, o as modelStatusCstDiagnostic, r as RSDiagnosticCode, t as CstDiagnostic } from "../diagnostics-Clo3mkba.js";
+export { CstDiagnostic, DiagnosticKind, RSDiagnosticCode, assignSchemaDiagnostics, hasCstDiagnostic, modelStatusCstDiagnostic };

package/dist/library/diagnostics.js

@@ -0,0 +1,2 @@
+import { a as modelStatusCstDiagnostic, i as hasCstDiagnostic, n as RSDiagnosticCode, r as assignSchemaDiagnostics, t as DiagnosticKind } from "../diagnostics-D7SiHAwW.js";
+export { DiagnosticKind, RSDiagnosticCode, assignSchemaDiagnostics, hasCstDiagnostic, modelStatusCstDiagnostic };

package/dist/library/index.d.ts

@@ -1,9 +1,8 @@
-import { FolderNode, FolderTree } from "./folder-tree.js";
 import { a as LibraryItemType, i as LibraryItemReference, n as CurrentVersion, o as LocationHead, r as LibraryItem, s as VersionInfo, t as AccessPolicy } from "../library-CYun28Xz.js";
+import { C as TypeInfo, S as Substitution, _ as CstClass, a as hasCstDiagnostic, b as RSForm, c as BasicsContext, d as RSModel, f as RSModelStats, g as Constituenta, h as Attribution, i as assignSchemaDiagnostics, l as DEFAULT_VALUE_TEXT, m as ArgumentValue, n as DiagnosticKind, o as modelStatusCstDiagnostic, r as RSDiagnosticCode, s as BasicBinding, t as CstDiagnostic, u as EvalStatus, v as CstStatus, x as RSFormStats, y as CstType } from "../diagnostics-Clo3mkba.js";
+import { FolderNode, FolderTree } from "./folder-tree.js";
 import { n as OssLayout, r as Position2D } from "../oss-layout-3glgAqfn.js";
 import { Block, CstSubstituteInfo, NodeType, Operation, OperationInput, OperationSchema, OperationSchemaStats, OperationSynthesis, OperationType, OssItem, SubstitutionErrorDescription, SubstitutionErrorType } from "./oss.js";
-import { ArgumentValue, Attribution, Constituenta, CstClass, CstStatus, CstType, RSForm, RSFormStats, Substitution, TypeInfo } from "./rsform.js";
-import { BasicBinding, BasicsContext, DEFAULT_VALUE_TEXT, EvalStatus, RSModel, RSModelStats } from "./rsmodel.js";
 import { RSEngine } from "./rsengine.js";
 
 //#region src/library/template-instantiation.d.ts
@@ -100,5 +99,5 @@ declare class TemplateInstantiationPlanner {
   private collectDependencies;
 }
 //#endregion
-export { AccessPolicy, type ArgumentValue, type Attribution, type BasicBinding, type BasicsContext, type Block, type Constituenta, CstClass, CstStatus, type CstSubstituteInfo, CstType, type CurrentVersion, DEFAULT_VALUE_TEXT, EvalStatus, FolderNode, FolderTree, type LibraryItem, type LibraryItemReference, LibraryItemType, LocationHead, NodeType, type Operation, type OperationInput, type OperationSchema, type OperationSchemaStats, type OperationSynthesis, OperationType, type OssItem, type OssLayout, type Position2D, RSEngine, type RSForm, type RSFormStats, type RSModel, type RSModelStats, type Substitution, type SubstitutionErrorDescription, SubstitutionErrorType, type TemplateBindingConflict, type TemplateInstantiationInput, type TemplateInstantiationItem, type TemplateInstantiationPlan, TemplateInstantiationPlanner, type TypeInfo, type VersionInfo, planTemplateInstantiation };
+export { AccessPolicy, type ArgumentValue, type Attribution, type BasicBinding, type BasicsContext, type Block, type Constituenta, CstClass, type CstDiagnostic, CstStatus, type CstSubstituteInfo, CstType, type CurrentVersion, DEFAULT_VALUE_TEXT, DiagnosticKind, EvalStatus, FolderNode, FolderTree, type LibraryItem, type LibraryItemReference, LibraryItemType, LocationHead, NodeType, type Operation, type OperationInput, type OperationSchema, type OperationSchemaStats, type OperationSynthesis, OperationType, type OssItem, type OssLayout, type Position2D, RSDiagnosticCode, RSEngine, type RSForm, type RSFormStats, type RSModel, type RSModelStats, type Substitution, type SubstitutionErrorDescription, SubstitutionErrorType, type TemplateBindingConflict, type TemplateInstantiationInput, type TemplateInstantiationItem, type TemplateInstantiationPlan, TemplateInstantiationPlanner, type TypeInfo, type VersionInfo, assignSchemaDiagnostics, hasCstDiagnostic, modelStatusCstDiagnostic, planTemplateInstantiation };
 //# sourceMappingURL=index.d.ts.map

package/dist/library/index.js

@@ -1,6 +1,3 @@
-import { FolderNode, FolderTree } from "./folder-tree.js";
-import { AccessPolicy, LibraryItemType, LocationHead } from "./library.js";
-import { NodeType, OperationType, SubstitutionErrorType } from "./oss.js";
 import { visitAstDFS } from "../parsing/ast.js";
 import "../parsing/index.js";
 import { TokenID } from "../rslang/parser/token.js";
@@ -8,8 +5,11 @@ import { TypeID } from "../rslang/semantic/typification.js";
 import { labelType } from "../rslang/labels.js";
 import { applyAliasMapping, isGlobalAlias, parseRSLangExpression, splitTemplateDefinition, substituteLocalAliases, substituteTemplateArgs } from "../rslang/api.js";
 import { CstClass, CstStatus, CstType } from "./rsform.js";
-import { applyMappingToConstituents, argumentValuesToMapping, generateAlias, inferTemplatedType, isFunctional, normalizeExpression } from "./rsform-api.js";
+import { D as isFunctional, a as modelStatusCstDiagnostic, c as applyMappingToConstituents, h as generateAlias, i as hasCstDiagnostic, j as normalizeExpression, l as argumentValuesToMapping, n as RSDiagnosticCode, r as assignSchemaDiagnostics, t as DiagnosticKind, w as inferTemplatedType } from "../diagnostics-D7SiHAwW.js";
 import { DEFAULT_VALUE_TEXT, EvalStatus } from "./rsmodel.js";
+import { FolderNode, FolderTree } from "./folder-tree.js";
+import { AccessPolicy, LibraryItemType, LocationHead } from "./library.js";
+import { NodeType, OperationType, SubstitutionErrorType } from "./oss.js";
 import { RSEngine } from "./rsengine.js";
 //#region src/library/template-instantiation.ts
 /**
@@ -284,6 +284,6 @@ function topologicalSort(aliases, refs) {
 	return sorted;
 }
 //#endregion
-export { AccessPolicy, CstClass, CstStatus, CstType, DEFAULT_VALUE_TEXT, EvalStatus, FolderNode, FolderTree, LibraryItemType, LocationHead, NodeType, OperationType, RSEngine, SubstitutionErrorType, TemplateInstantiationPlanner, planTemplateInstantiation };
+export { AccessPolicy, CstClass, CstStatus, CstType, DEFAULT_VALUE_TEXT, DiagnosticKind, EvalStatus, FolderNode, FolderTree, LibraryItemType, LocationHead, NodeType, OperationType, RSDiagnosticCode, RSEngine, SubstitutionErrorType, TemplateInstantiationPlanner, assignSchemaDiagnostics, hasCstDiagnostic, modelStatusCstDiagnostic, planTemplateInstantiation };
 
 //# sourceMappingURL=index.js.map

package/dist/library/oss-api.d.ts

@@ -1,6 +1,6 @@
 import { r as LibraryItem } from "../library-CYun28Xz.js";
+import { S as Substitution, b as RSForm, g as Constituenta } from "../diagnostics-Clo3mkba.js";
 import { NodeType, OperationSchema, SubstitutionErrorDescription } from "./oss.js";
-import { Constituenta, RSForm, Substitution } from "./rsform.js";
 
 //#region src/library/oss-api.d.ts
 declare function constructNodeID(type: NodeType, itemID: number): string;

package/dist/library/oss-api.js

@@ -1,9 +1,9 @@
 import { Graph } from "../graph/graph.js";
-import { NodeType, SubstitutionErrorType } from "./oss.js";
 import { labelType } from "../rslang/labels.js";
 import { applyAliasMapping, applyTypificationMapping, isSetTypification } from "../rslang/api.js";
 import { extractBases } from "../rslang/semantic/typification-api.js";
 import { CstClass, CstType } from "./rsform.js";
+import { NodeType, SubstitutionErrorType } from "./oss.js";
 import "../graph/index.js";
 //#region src/library/oss-api.ts
 /**

package/dist/library/rsengine.d.ts

@@ -1,8 +1,7 @@
 import { t as AstNode } from "../ast-C8sIpKdL.js";
 import { l as Value } from "../value-BduA_ZGp.js";
 import { n as CalculatorResult, r as RSCalculator, t as CalculatorEvaluateOptions } from "../calculator-k8BGIKmj.js";
-import { CstType, RSForm } from "./rsform.js";
-import { BasicBinding, BasicsContext, EvalStatus, RSModel } from "./rsmodel.js";
+import { b as RSForm, c as BasicsContext, d as RSModel, s as BasicBinding, u as EvalStatus, y as CstType } from "../diagnostics-Clo3mkba.js";
 
 //#region src/library/rsengine.d.ts
 /** Services for {@link RSEngine}. */

package/dist/library/rsengine.js

@@ -4,7 +4,7 @@ import { l as compare } from "../value-COprb2Je.js";
 import { RSCalculator } from "../rslang/eval/calculator.js";
 import "../rslang/index.js";
 import { CstType } from "./rsform.js";
-import { getAnalysisFor, isBaseSet, isBasicConcept, isFunctional } from "./rsform-api.js";
+import { D as isFunctional, E as isBasicConcept, T as isBaseSet, g as getAnalysisFor } from "../diagnostics-D7SiHAwW.js";
 import { TYPE_BASIC } from "./rsmodel.js";
 import { inferEvalStatus, isInferrable, tryFixValue } from "./rsmodel-api.js";
 //#region src/library/rsengine.ts

package/dist/library/rsform-api.d.ts

@@ -1,9 +1,9 @@
-import { r as LibraryItem } from "../library-CYun28Xz.js";
 import { t as AstNode } from "../ast-C8sIpKdL.js";
 import { g as TypeClass, y as TypePath } from "../typification-9lNu9R4k.js";
 import { t as ValueClass } from "../value-class-CNI-lqXJ.js";
 import { r as AnalysisFull } from "../analyzer-iqAXyROE.js";
-import { ArgumentValue, Constituenta, CstClass, CstStatus, CstType, RSForm, RSFormStats } from "./rsform.js";
+import { r as LibraryItem } from "../library-CYun28Xz.js";
+import { _ as CstClass, b as RSForm, g as Constituenta, m as ArgumentValue, v as CstStatus, x as RSFormStats, y as CstType } from "../diagnostics-Clo3mkba.js";
 import { AliasMapping } from "../rslang/api.js";
 
 //#region src/library/rsform-api.d.ts

package/dist/library/rsform-api.js

@@ -1,405 +1,2 @@
-import { RSErrorCode } from "../rslang/error.js";
-import { TypeClass, TypeID, basic, bool, constant, isTypification } from "../rslang/semantic/typification.js";
-import { generateExpressionFromAst } from "../rslang/parser/expression-generator.js";
-import { applyAliasMapping, applyTypificationMapping, 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 "./rsform.js";
-import { applyEntityReferenceMapping } from "../cctext/language-api.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) {
-	if (cst.homonyms.length > 0 || cst.formalDuplicates.length > 0 || cst.status === CstStatus.INCORRECT || cst.status === CstStatus.INCALCULABLE || cst.is_type_mismatch) return true;
-	if (isBasicConcept(cst.cst_type) && !isLogical(cst.cst_type)) {
-		if (!cst.convention || !cst.term_resolved) return true;
-	}
-	return false;
-}
-/** 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;
-}
-/** Analyze expression for {@link RSForm}. */
-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 schema.analyzer.checkFull(expression, {
-		expected: typeClassForCstType(cstType),
-		isDomain: cstType === CstType.STRUCTURED
-	});
-}
-/** 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 + (cst.homonyms.length > 0 ? 1 : 0), 0),
-		count_formal_duplicates: items.reduce((sum, cst) => sum + (cst.formalDuplicates.length > 0 ? 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 === target.id && cst.spawner_path) {
-		if (cst.spawner_path.length === path.length && cst.spawner_path.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;
-}
-/** 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
+import { A as isTemplateCst, C as inferTemplate, D as isFunctional, E as isBasicConcept, F as validateAliasFormat, I as validateNewAlias, M as removeAliasReference, N as sortItemsForInlineSynthesis, O as isLogical, P as typeClassForCstType, S as inferStatus, T as isBaseSet, _ as getCstTypePrefix, b as inferClass, c as applyMappingToConstituents, d as canHaveFormalDefinition, f as canHaveManualTypification, g as getAnalysisFor, h as generateAlias, j as normalizeExpression, k as isSchemaIssue, l as argumentValuesToMapping, m as findCstByStructure, o as addAliasReference, p as canProduceStructure, s as applyFilterCategory, u as calculateSchemaStats, v as getStructureName, w as inferTemplatedType, x as inferNewSpawnPosition, y as guessCstType } from "../diagnostics-D7SiHAwW.js";
 export { addAliasReference, applyFilterCategory, applyMappingToConstituents, argumentValuesToMapping, calculateSchemaStats, canHaveFormalDefinition, canHaveManualTypification, canProduceStructure, findCstByStructure, generateAlias, getAnalysisFor, getCstTypePrefix, getStructureName, guessCstType, inferClass, inferNewSpawnPosition, inferStatus, inferTemplate, inferTemplatedType, isBaseSet, isBasicConcept, isFunctional, isLogical, isSchemaIssue, isTemplateCst, normalizeExpression, removeAliasReference, sortItemsForInlineSynthesis, typeClassForCstType, validateAliasFormat, validateNewAlias };
-
-//# sourceMappingURL=rsform-api.js.map