@rsconcept/domain 1.7.7 → 1.8.1

package/dist/{analyzer-DqjdciC5.d.ts → analyzer-iqAXyROE.d.ts}

@@ -1,5 +1,5 @@
 import { t as AstNode } from "./ast-C8sIpKdL.js";
-import { f as ExpressionType, g as TypeClass } from "./typification-DDuv88ir.js";
+import { f as ExpressionType, g as TypeClass } from "./typification-9lNu9R4k.js";
 import { i as RSErrorDescription } from "./error-CzIbnP-N.js";
 import { t as ValueClass } from "./value-class-CNI-lqXJ.js";
 
@@ -32,8 +32,7 @@ declare class RSLangAnalyzer {
   getType(alias: string): ExpressionType | null;
   checkFast(expression: string, options?: AnalysisOptions): AnalysisFast;
   checkFull(expression: string, options?: AnalysisOptions): AnalysisFull;
-  private parse;
 }
 //#endregion
 export { RSLangAnalyzer as a, AnalysisOptions as i, AnalysisFast as n, AnalysisFull as r, AnalysisBase as t };
-//# sourceMappingURL=analyzer-DqjdciC5.d.ts.map
+//# sourceMappingURL=analyzer-iqAXyROE.d.ts.map

package/dist/{arguments-extractor-Dd1lFom9.d.ts → arguments-extractor-ngatANBI.d.ts}

@@ -1,5 +1,5 @@
 import { t as AstNode } from "./ast-C8sIpKdL.js";
-import { f as ExpressionType } from "./typification-DDuv88ir.js";
+import { f as ExpressionType } from "./typification-9lNu9R4k.js";
 
 //#region src/rslang/semantic/arguments-extractor.d.ts
 /** Represents function argument definition. */
@@ -35,4 +35,4 @@ declare class ArgumentsExtractor {
 }
 //#endregion
 export { ArgumentsType as n, ArgumentsExtractor as t };
-//# sourceMappingURL=arguments-extractor-Dd1lFom9.d.ts.map
+//# sourceMappingURL=arguments-extractor-ngatANBI.d.ts.map

package/dist/{ast-annotations-CZCzs9Uk.d.ts → ast-annotations-D6KZDu12.d.ts}

@@ -1,5 +1,5 @@
 import { t as AstNode } from "./ast-C8sIpKdL.js";
-import { f as ExpressionType } from "./typification-DDuv88ir.js";
+import { f as ExpressionType } from "./typification-9lNu9R4k.js";
 import { a as RSErrorInfo, r as RSErrorCode } from "./error-CzIbnP-N.js";
 
 //#region src/rslang/ast-annotations.d.ts
@@ -13,4 +13,4 @@ declare function annotateError(node: AstNode, code: RSErrorCode, params?: readon
 declare function readErrorAnnotation(node: AstNode): RSErrorInfo | null;
 //#endregion
 export { readTypeAnnotation as i, annotateType as n, readErrorAnnotation as r, annotateError as t };
-//# sourceMappingURL=ast-annotations-CZCzs9Uk.d.ts.map
+//# sourceMappingURL=ast-annotations-D6KZDu12.d.ts.map

package/dist/{calculator-Dt03dsnd.d.ts → calculator-k8BGIKmj.d.ts}

@@ -1,5 +1,5 @@
 import { t as AstNode } from "./ast-C8sIpKdL.js";
-import { f as ExpressionType } from "./typification-DDuv88ir.js";
+import { f as ExpressionType } from "./typification-9lNu9R4k.js";
 import { i as RSErrorDescription } from "./error-CzIbnP-N.js";
 import { l as Value } from "./value-BduA_ZGp.js";
 
@@ -36,4 +36,4 @@ declare class RSCalculator {
 }
 //#endregion
 export { CalculatorResult as n, RSCalculator as r, CalculatorEvaluateOptions as t };
-//# sourceMappingURL=calculator-Dt03dsnd.d.ts.map
+//# sourceMappingURL=calculator-k8BGIKmj.d.ts.map

package/dist/index.d.ts

@@ -8,19 +8,19 @@ import { r as printTree, t as CMSyntaxNode } from "./lezer-tree-iS7LpLBJ.js";
 import { a as TOKEN_ERROR, c as flattenAst, d as printAst, f as visitAstDFS, i as FlatAstNode, l as getNodeIndices, n as AstNodeBase, o as buildTree, r as FlatAST, s as findByUid, t as AstNode, u as getNodeText } from "./ast-C8sIpKdL.js";
 import { t as Branded } from "./branded-ZlzIcxzu.js";
 import { n as generateStub, t as applyHash_fnv1a } from "./hash-Y8I4c6Al.js";
-import { b as Typification, d as EmptySetT, f as ExpressionType, g as TypeClass, k as makeTypePath, m as LogicT, t as AnyTypificationT, v as TypeID, y as TypePath } from "./typification-DDuv88ir.js";
+import { A as makeTypePath, b as Typification, d as EmptySetT, f as ExpressionType, g as TypeClass, m as LogicT, t as AnyTypificationT, v as TypeID, y as TypePath } from "./typification-9lNu9R4k.js";
 import { i as RSErrorDescription, r as RSErrorCode } from "./error-CzIbnP-N.js";
-import { i as readTypeAnnotation, r as readErrorAnnotation } from "./ast-annotations-CZCzs9Uk.js";
+import { i as readTypeAnnotation, r as readErrorAnnotation } from "./ast-annotations-D6KZDu12.js";
 import { d as ValuePath, l as Value, o as TUPLE_ID, p as makeValuePath } from "./value-BduA_ZGp.js";
-import { n as CalculatorResult, r as RSCalculator, t as CalculatorEvaluateOptions } from "./calculator-Dt03dsnd.js";
-import { d as printValue } from "./value-api-C2X4Pom5.js";
+import { n as CalculatorResult, r as RSCalculator, t as CalculatorEvaluateOptions } from "./calculator-k8BGIKmj.js";
+import { d as printValue } from "./value-api-CXLl_zg0.js";
 import { t as parser } from "./parser-Bwd8LxJ1.js";
 import { t as TokenID } from "./token-DeXAmzwr.js";
 import { t as ValueClass } from "./value-class-CNI-lqXJ.js";
-import { a as RSLangAnalyzer, n as AnalysisFast, r as AnalysisFull, t as AnalysisBase } from "./analyzer-DqjdciC5.js";
-import { n as ArgumentsType } from "./arguments-extractor-Dd1lFom9.js";
-import { n as applyAsciiTypeSubstitutions, r as parseTypeText } from "./typification-parser-DHO42ZRc.js";
-import { n as TypificationNodeData, t as TypificationGraph } from "./typification-graph-8VdK6_Fh.js";
+import { a as RSLangAnalyzer, n as AnalysisFast, r as AnalysisFull, t as AnalysisBase } from "./analyzer-iqAXyROE.js";
+import { n as ArgumentsType } from "./arguments-extractor-ngatANBI.js";
+import { n as applyAsciiTypeSubstitutions, r as parseTypeText } from "./typification-parser-Dytsv9CI.js";
+import { n as TypificationNodeData, t as TypificationGraph } from "./typification-graph-BY_oGT82.js";
 import { ArgumentValue, Attribution, Constituenta, CstClass, CstStatus, CstType, RSForm, RSFormStats, Substitution, TypeInfo } from "./library/rsform.js";
 import { BasicBinding, BasicsContext, DEFAULT_VALUE_TEXT, EvalStatus, RSModel, RSModelStats } from "./library/rsmodel.js";
 import { RSEngine } from "./library/rsengine.js";

package/dist/library/index.d.ts

@@ -5,4 +5,100 @@ import { Block, CstSubstituteInfo, NodeType, Operation, OperationInput, Operatio
 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";
-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 TypeInfo, type VersionInfo };
+
+//#region src/library/template-instantiation.d.ts
+/**
+ * Payload for one {@link Constituenta} to create when instantiating an expression-bank template.
+ *
+ * Aliases are generated for the target schema. Formal definitions and typifications already
+ * reflect user argument substitution and remapping of bank aliases to those new aliases.
+ */
+interface TemplateInstantiationItem {
+  /** Alias to assign in the target schema. */
+  alias: string;
+  /** Inferred type after argument substitution (function/predicate may become term/axiom). */
+  cst_type: CstType;
+  crucial: boolean;
+  convention: string;
+  definition_formal: string;
+  definition_raw: string;
+  term_raw: string;
+  term_forms: Constituenta['term_forms'];
+  typification_manual: string;
+  value_is_property: boolean;
+}
+/** Conflicting argument bindings inferred for the same template dependency. */
+interface TemplateBindingConflict {
+  templateAlias: string;
+  paramAlias: string;
+  existing: string;
+  incoming: string;
+}
+/**
+ * Batch create plan: dependencies first, selected template constituent last.
+ *
+ * Reuses constituents whose substituted formal definition already exists in the target schema
+ * (normalized comparison), even when the bank alias differs from the matched target alias.
+ * {@link TemplateInstantiationPlan.mainDuplicateAlias} reports when the selected template is a duplicate.
+ * Does not set `insert_after`; the caller supplies insertion on the batch DTO.
+ */
+interface TemplateInstantiationPlan {
+  items: TemplateInstantiationItem[];
+  /** Set when the selected template expression already exists in the target schema. */
+  mainDuplicateAlias: string | null;
+  /** Set when nested template calls bind the same parameter to different global aliases. */
+  bindingConflict: TemplateBindingConflict | null;
+}
+/**
+ * Input for planning template instantiation into a conceptual schema.
+ */
+interface TemplateInstantiationInput {
+  /** Schema that will receive new constituents. */
+  targetSchema: RSForm;
+  /** All constituents of the selected expression-bank RSForm (not only the prototype). */
+  templateItems: Constituenta[];
+  /** Template constituent chosen in the UI (main expression to add). */
+  prototype: Constituenta;
+  /** User bindings from template parameter aliases to target-schema global aliases. */
+  userArgs: ArgumentValue[];
+  /**
+   * Main constituent attributes from the create dialog (alias, labels, flags).
+   * `definition_formal` and `cst_type` may be overridden from `prototype` and `userArgs`.
+   */
+  mainItem: TemplateInstantiationItem;
+}
+/**
+ * Build a batch create plan for a template expression and its bank dependencies.
+ *
+ * Walks nested `F#` / `P#` calls in the substituted expression, collects missing term-functions
+ * and predicate-functions from `templateItems`, propagates argument bindings into nested calls,
+ * topologically orders dependencies, and remaps bank aliases to freshly generated target aliases.
+ */
+declare function planTemplateInstantiation(input: TemplateInstantiationInput): TemplateInstantiationPlan;
+/**
+ * Stateful planner for {@link planTemplateInstantiation}.
+ *
+ * Prefer the function wrapper unless you need to hold or reuse planner state between calls.
+ */
+declare class TemplateInstantiationPlanner {
+  private readonly targetSchema;
+  private readonly prototype;
+  private readonly userArgs;
+  private readonly mainItemTemplate;
+  private readonly templateByAlias;
+  private readonly userMapping;
+  private readonly depBindings;
+  private readonly depRefs;
+  private bindingConflict;
+  /** @param input - See {@link TemplateInstantiationInput}. */
+  constructor(input: TemplateInstantiationInput);
+  /** @returns Dependency items in topological order, then the main template item when it is not a duplicate. */
+  plan(): TemplateInstantiationPlan;
+  private buildDependencyItems;
+  private buildMainItem;
+  private ensureDep;
+  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 };
+//# sourceMappingURL=index.d.ts.map

package/dist/library/index.js

@@ -1,7 +1,289 @@
 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";
+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 { DEFAULT_VALUE_TEXT, EvalStatus } from "./rsmodel.js";
 import { RSEngine } from "./rsengine.js";
-export { AccessPolicy, CstClass, CstStatus, CstType, DEFAULT_VALUE_TEXT, EvalStatus, FolderNode, FolderTree, LibraryItemType, LocationHead, NodeType, OperationType, RSEngine, SubstitutionErrorType };
+//#region src/library/template-instantiation.ts
+/**
+* Module: template instantiation from the expression bank into a target {@link RSForm}.
+*/
+/**
+* Build a batch create plan for a template expression and its bank dependencies.
+*
+* Walks nested `F#` / `P#` calls in the substituted expression, collects missing term-functions
+* and predicate-functions from `templateItems`, propagates argument bindings into nested calls,
+* topologically orders dependencies, and remaps bank aliases to freshly generated target aliases.
+*/
+function planTemplateInstantiation(input) {
+	return new TemplateInstantiationPlanner(input).plan();
+}
+/**
+* Stateful planner for {@link planTemplateInstantiation}.
+*
+* Prefer the function wrapper unless you need to hold or reuse planner state between calls.
+*/
+var TemplateInstantiationPlanner = class {
+	targetSchema;
+	prototype;
+	userArgs;
+	mainItemTemplate;
+	templateByAlias;
+	userMapping;
+	depBindings = /* @__PURE__ */ new Map();
+	depRefs = /* @__PURE__ */ new Map();
+	bindingConflict = null;
+	/** @param input - See {@link TemplateInstantiationInput}. */
+	constructor(input) {
+		this.targetSchema = input.targetSchema;
+		this.prototype = input.prototype;
+		this.userArgs = input.userArgs;
+		this.mainItemTemplate = input.mainItem;
+		this.templateByAlias = new Map(input.templateItems.filter((cst) => isFunctional(cst.cst_type)).map((cst) => [cst.alias, cst]));
+		this.userMapping = argumentValuesToMapping(input.userArgs);
+	}
+	/** @returns Dependency items in topological order, then the main template item when it is not a duplicate. */
+	plan() {
+		const mainDefinition = substituteTemplateArgs(this.prototype.definition_formal, this.userMapping);
+		this.collectDependencies(mainDefinition, this.userMapping);
+		if (this.bindingConflict) return {
+			items: [],
+			mainDuplicateAlias: null,
+			bindingConflict: this.bindingConflict
+		};
+		const definitionIndex = createFormalDefinitionIndex(this.targetSchema);
+		const dependencyItems = this.buildDependencyItems(definitionIndex);
+		const { item: mainItem, duplicateAlias: mainDuplicateAlias } = this.buildMainItem(mainDefinition, dependencyItems.takenAliases, dependencyItems.aliasMapping, definitionIndex);
+		return {
+			items: mainItem ? [...dependencyItems.items, mainItem] : dependencyItems.items,
+			mainDuplicateAlias,
+			bindingConflict: null
+		};
+	}
+	buildDependencyItems(definitionIndex) {
+		const dependencyAliases = topologicalSort([...this.depBindings.keys()], this.depRefs);
+		const aliasMapping = {};
+		const takenAliases = [];
+		const reservedAliases = [this.mainItemTemplate.alias];
+		const items = [];
+		for (const templateAlias of dependencyAliases) {
+			const template = this.templateByAlias.get(templateAlias);
+			const bindings = this.depBindings.get(templateAlias);
+			const args = bindingMapToArgs(getTemplateParams(template), bindings);
+			const cst_type = inferTemplatedType(template.cst_type, args);
+			const definition = applyAliasMapping(substituteTemplateArgs(template.definition_formal, argumentValuesToMapping(args)), aliasMapping);
+			const existingAlias = definitionIndex.find(cst_type, definition);
+			if (existingAlias) {
+				aliasMapping[templateAlias] = existingAlias;
+				continue;
+			}
+			const alias = generateAlias(template.cst_type, this.targetSchema, [...reservedAliases, ...takenAliases]);
+			takenAliases.push(alias);
+			aliasMapping[templateAlias] = alias;
+			const item = instantiateTemplateItem(template, args, alias);
+			item.definition_formal = definition;
+			applyMappingToConstituents([item], aliasMapping, false);
+			definitionIndex.register(cst_type, item.definition_formal, alias);
+			items.push(item);
+		}
+		return {
+			items,
+			aliasMapping,
+			takenAliases
+		};
+	}
+	buildMainItem(mainDefinition, takenAliases, aliasMapping, definitionIndex) {
+		const mappedDefinition = applyAliasMapping(mainDefinition, aliasMapping);
+		const cst_type = inferTemplatedType(this.prototype.cst_type, this.userArgs);
+		const duplicateAlias = definitionIndex.find(cst_type, mappedDefinition);
+		if (duplicateAlias) return {
+			item: null,
+			duplicateAlias
+		};
+		const mainItem = {
+			...this.mainItemTemplate,
+			definition_formal: mappedDefinition,
+			cst_type
+		};
+		applyMappingToConstituents([mainItem], aliasMapping, false);
+		if (takenAliases.includes(mainItem.alias)) mainItem.alias = generateAlias(mainItem.cst_type, this.targetSchema, [...takenAliases, this.mainItemTemplate.alias]);
+		return {
+			item: mainItem,
+			duplicateAlias: null
+		};
+	}
+	ensureDep(templateAlias, bindings, referrer) {
+		if (this.bindingConflict) return;
+		if (!this.templateByAlias.has(templateAlias)) return;
+		if (referrer && this.depBindings.has(referrer)) {
+			const refs = this.depRefs.get(referrer) ?? /* @__PURE__ */ new Set();
+			refs.add(templateAlias);
+			this.depRefs.set(referrer, refs);
+		}
+		const mergeResult = mergeBindings(this.depBindings.get(templateAlias), bindings);
+		if (!mergeResult.ok) {
+			this.bindingConflict = {
+				templateAlias,
+				...mergeResult.conflict
+			};
+			return;
+		}
+		const merged = mergeResult.bindings;
+		const changed = !this.depBindings.has(templateAlias) || merged.size !== (this.depBindings.get(templateAlias)?.size ?? 0);
+		this.depBindings.set(templateAlias, merged);
+		if (!changed && referrer) return;
+		const template = this.templateByAlias.get(templateAlias);
+		const args = bindingMapToArgs(getTemplateParams(template), merged);
+		const definition = substituteTemplateArgs(template.definition_formal, argumentValuesToMapping(args));
+		this.collectDependencies(definition, argumentValuesToMapping(args), templateAlias);
+	}
+	collectDependencies(expression, scope, referrer) {
+		if (this.bindingConflict) return;
+		const ast = parseRSLangExpression(expression);
+		if (!ast) return;
+		for (const call of extractFuncCalls(ast, expression)) {
+			const template = this.templateByAlias.get(call.callee);
+			if (!template) continue;
+			const scopedArgs = call.args.map((arg) => substituteLocalAliases(arg, scope));
+			const bindings = bindingsFromCall(getTemplateParams(template), scopedArgs, scope);
+			this.ensureDep(call.callee, bindings, referrer);
+		}
+	}
+};
+/** Normalized formal definitions in the target schema and in the current plan. */
+var FormalDefinitionIndex = class {
+	byKey = /* @__PURE__ */ new Map();
+	register(cst_type, definition_formal, alias) {
+		const normalized = normalizeExpression(definition_formal, cst_type);
+		if (!normalized) return;
+		this.byKey.set(formalDefinitionKey(cst_type, normalized), alias);
+	}
+	find(cst_type, definition_formal) {
+		const normalized = normalizeExpression(definition_formal, cst_type);
+		if (!normalized) return null;
+		return this.byKey.get(formalDefinitionKey(cst_type, normalized)) ?? null;
+	}
+};
+function createFormalDefinitionIndex(schema) {
+	const index = new FormalDefinitionIndex();
+	for (const cst of schema.items) index.register(cst.cst_type, cst.definition_formal, cst.alias);
+	return index;
+}
+function formalDefinitionKey(cst_type, normalized) {
+	return `${cst_type}\0${normalized}`;
+}
+function instantiateTemplateItem(template, args, alias) {
+	return {
+		alias,
+		cst_type: inferTemplatedType(template.cst_type, args),
+		crucial: template.crucial,
+		convention: template.convention,
+		definition_formal: substituteTemplateArgs(template.definition_formal, argumentValuesToMapping(args)),
+		definition_raw: template.definition_raw,
+		term_raw: template.term_raw,
+		term_forms: [...template.term_forms],
+		typification_manual: template.typification_manual,
+		value_is_property: template.value_is_property
+	};
+}
+function bindingsFromCall(params, callArgs, scope) {
+	const bindings = /* @__PURE__ */ new Map();
+	params.forEach((param, index) => {
+		const value = resolveArgBinding(callArgs[index] ?? "", scope);
+		if (value) bindings.set(param.alias, value);
+	});
+	return bindings;
+}
+function resolveArgBinding(argExpr, scope) {
+	const scoped = substituteLocalAliases(argExpr, scope).trim();
+	if (isGlobalAlias(scoped)) return scoped;
+}
+function mergeBindings(existing, incoming) {
+	const result = new Map(existing);
+	for (const [alias, value] of incoming) {
+		const existingValue = result.get(alias);
+		if (existingValue === void 0) result.set(alias, value);
+		else if (existingValue !== value) return {
+			ok: false,
+			conflict: {
+				paramAlias: alias,
+				existing: existingValue,
+				incoming: value
+			}
+		};
+	}
+	return {
+		ok: true,
+		bindings: result
+	};
+}
+function bindingMapToArgs(params, bindings) {
+	return params.map((param) => ({
+		alias: param.alias,
+		typification: param.typification,
+		value: bindings.get(param.alias)
+	}));
+}
+function getTemplateParams(template) {
+	const effectiveType = template.effectiveType;
+	if (effectiveType && (effectiveType.typeID === TypeID.function || effectiveType.typeID === TypeID.predicate)) return effectiveType.args.map((arg) => ({
+		alias: arg.alias,
+		typification: labelType(arg.type)
+	}));
+	const { head } = splitTemplateDefinition(template.definition_formal);
+	if (!head) return [];
+	return head.split(",").map((part) => {
+		const trimmed = part.trim();
+		const separator = trimmed.indexOf("∈");
+		if (separator === -1) return {
+			alias: trimmed,
+			typification: ""
+		};
+		return {
+			alias: trimmed.slice(0, separator).trim(),
+			typification: trimmed.slice(separator + 1).trim()
+		};
+	});
+}
+function extractFuncCalls(ast, expression) {
+	const result = [];
+	visitAstDFS(ast, (node) => {
+		if (node.typeID !== TokenID.NT_FUNC_CALL || node.children.length < 1) return;
+		const calleeNode = node.children[0];
+		if (calleeNode.typeID !== TokenID.ID_FUNCTION && calleeNode.typeID !== TokenID.ID_PREDICATE && calleeNode.typeID !== TokenID.ID_GLOBAL) return;
+		const callee = expression.slice(calleeNode.from, calleeNode.to);
+		if (!/^[FP]\d+$/.test(callee)) return;
+		result.push({
+			callee,
+			args: node.children.slice(1).map((child) => expression.slice(child.from, child.to).trim())
+		});
+	});
+	return result;
+}
+function topologicalSort(aliases, refs) {
+	const remaining = new Set(aliases);
+	const sorted = [];
+	while (remaining.size > 0) {
+		const ready = [...remaining].filter((alias) => {
+			return [...refs.get(alias) ?? /* @__PURE__ */ new Set()].every((dep) => !remaining.has(dep));
+		});
+		if (ready.length === 0) return [...remaining, ...sorted].reverse();
+		ready.sort();
+		for (const alias of ready) {
+			sorted.push(alias);
+			remaining.delete(alias);
+		}
+	}
+	return sorted;
+}
+//#endregion
+export { AccessPolicy, CstClass, CstStatus, CstType, DEFAULT_VALUE_TEXT, EvalStatus, FolderNode, FolderTree, LibraryItemType, LocationHead, NodeType, OperationType, RSEngine, SubstitutionErrorType, TemplateInstantiationPlanner, planTemplateInstantiation };
+
+//# sourceMappingURL=index.js.map

package/dist/library/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/library/template-instantiation.ts"],"sourcesContent":["/**\n * Module: template instantiation from the expression bank into a target {@link RSForm}.\n */\n\nimport { type AstNode, visitAstDFS } from '../parsing';\nimport {\n  type AliasMapping,\n  applyAliasMapping,\n  isGlobalAlias,\n  parseRSLangExpression,\n  splitTemplateDefinition,\n  substituteLocalAliases,\n  substituteTemplateArgs\n} from '../rslang/api';\nimport { labelType } from '../rslang/labels';\nimport { TokenID } from '../rslang/parser/token';\nimport { TypeID } from '../rslang/semantic/typification';\n\nimport { type ArgumentValue, type Constituenta, type CstType, type RSForm } from './rsform';\nimport {\n  applyMappingToConstituents,\n  argumentValuesToMapping,\n  generateAlias,\n  inferTemplatedType,\n  isFunctional,\n  normalizeExpression\n} from './rsform-api';\n\n/**\n * Payload for one {@link Constituenta} to create when instantiating an expression-bank template.\n *\n * Aliases are generated for the target schema. Formal definitions and typifications already\n * reflect user argument substitution and remapping of bank aliases to those new aliases.\n */\nexport interface TemplateInstantiationItem {\n  /** Alias to assign in the target schema. */\n  alias: string;\n  /** Inferred type after argument substitution (function/predicate may become term/axiom). */\n  cst_type: CstType;\n  crucial: boolean;\n  convention: string;\n  definition_formal: string;\n  definition_raw: string;\n  term_raw: string;\n  term_forms: Constituenta['term_forms'];\n  typification_manual: string;\n  value_is_property: boolean;\n}\n\n/** Conflicting argument bindings inferred for the same template dependency. */\nexport interface TemplateBindingConflict {\n  templateAlias: string;\n  paramAlias: string;\n  existing: string;\n  incoming: string;\n}\n\n/**\n * Batch create plan: dependencies first, selected template constituent last.\n *\n * Reuses constituents whose substituted formal definition already exists in the target schema\n * (normalized comparison), even when the bank alias differs from the matched target alias.\n * {@link TemplateInstantiationPlan.mainDuplicateAlias} reports when the selected template is a duplicate.\n * Does not set `insert_after`; the caller supplies insertion on the batch DTO.\n */\nexport interface TemplateInstantiationPlan {\n  items: TemplateInstantiationItem[];\n  /** Set when the selected template expression already exists in the target schema. */\n  mainDuplicateAlias: string | null;\n  /** Set when nested template calls bind the same parameter to different global aliases. */\n  bindingConflict: TemplateBindingConflict | null;\n}\n\n/**\n * Input for planning template instantiation into a conceptual schema.\n */\nexport interface TemplateInstantiationInput {\n  /** Schema that will receive new constituents. */\n  targetSchema: RSForm;\n  /** All constituents of the selected expression-bank RSForm (not only the prototype). */\n  templateItems: Constituenta[];\n  /** Template constituent chosen in the UI (main expression to add). */\n  prototype: Constituenta;\n  /** User bindings from template parameter aliases to target-schema global aliases. */\n  userArgs: ArgumentValue[];\n  /**\n   * Main constituent attributes from the create dialog (alias, labels, flags).\n   * `definition_formal` and `cst_type` may be overridden from `prototype` and `userArgs`.\n   */\n  mainItem: TemplateInstantiationItem;\n}\n\ninterface FuncCallRef {\n  callee: string;\n  args: string[];\n}\n\ninterface TemplateParam {\n  alias: string;\n  typification: string;\n}\n\n/**\n * Build a batch create plan for a template expression and its bank dependencies.\n *\n * Walks nested `F#` / `P#` calls in the substituted expression, collects missing term-functions\n * and predicate-functions from `templateItems`, propagates argument bindings into nested calls,\n * topologically orders dependencies, and remaps bank aliases to freshly generated target aliases.\n */\nexport function planTemplateInstantiation(input: TemplateInstantiationInput): TemplateInstantiationPlan {\n  return new TemplateInstantiationPlanner(input).plan();\n}\n\n/**\n * Stateful planner for {@link planTemplateInstantiation}.\n *\n * Prefer the function wrapper unless you need to hold or reuse planner state between calls.\n */\nexport class TemplateInstantiationPlanner {\n  private readonly targetSchema: RSForm;\n  private readonly prototype: Constituenta;\n  private readonly userArgs: ArgumentValue[];\n  private readonly mainItemTemplate: TemplateInstantiationItem;\n  private readonly templateByAlias: Map<string, Constituenta>;\n  private readonly userMapping: AliasMapping;\n  private readonly depBindings = new Map<string, Map<string, string>>();\n  private readonly depRefs = new Map<string, Set<string>>();\n  private bindingConflict: TemplateBindingConflict | null = null;\n\n  /** @param input - See {@link TemplateInstantiationInput}. */\n  constructor(input: TemplateInstantiationInput) {\n    this.targetSchema = input.targetSchema;\n    this.prototype = input.prototype;\n    this.userArgs = input.userArgs;\n    this.mainItemTemplate = input.mainItem;\n    this.templateByAlias = new Map(\n      input.templateItems.filter(cst => isFunctional(cst.cst_type)).map(cst => [cst.alias, cst])\n    );\n    this.userMapping = argumentValuesToMapping(input.userArgs);\n  }\n\n  /** @returns Dependency items in topological order, then the main template item when it is not a duplicate. */\n  plan(): TemplateInstantiationPlan {\n    const mainDefinition = substituteTemplateArgs(this.prototype.definition_formal, this.userMapping);\n    this.collectDependencies(mainDefinition, this.userMapping);\n\n    if (this.bindingConflict) {\n      return { items: [], mainDuplicateAlias: null, bindingConflict: this.bindingConflict };\n    }\n\n    const definitionIndex = createFormalDefinitionIndex(this.targetSchema);\n    const dependencyItems = this.buildDependencyItems(definitionIndex);\n    const { item: mainItem, duplicateAlias: mainDuplicateAlias } = this.buildMainItem(\n      mainDefinition,\n      dependencyItems.takenAliases,\n      dependencyItems.aliasMapping,\n      definitionIndex\n    );\n\n    return {\n      items: mainItem ? [...dependencyItems.items, mainItem] : dependencyItems.items,\n      mainDuplicateAlias,\n      bindingConflict: null\n    };\n  }\n\n  private buildDependencyItems(definitionIndex: FormalDefinitionIndex): {\n    items: TemplateInstantiationItem[];\n    aliasMapping: AliasMapping;\n    takenAliases: string[];\n  } {\n    const dependencyAliases = topologicalSort([...this.depBindings.keys()], this.depRefs);\n    const aliasMapping: AliasMapping = {};\n    const takenAliases: string[] = [];\n    const reservedAliases = [this.mainItemTemplate.alias];\n    const items: TemplateInstantiationItem[] = [];\n\n    for (const templateAlias of dependencyAliases) {\n      const template = this.templateByAlias.get(templateAlias)!;\n      const bindings = this.depBindings.get(templateAlias)!;\n      const args = bindingMapToArgs(getTemplateParams(template), bindings);\n      const cst_type = inferTemplatedType(template.cst_type, args);\n      const definition = applyAliasMapping(\n        substituteTemplateArgs(template.definition_formal, argumentValuesToMapping(args)),\n        aliasMapping\n      );\n\n      const existingAlias = definitionIndex.find(cst_type, definition);\n      if (existingAlias) {\n        aliasMapping[templateAlias] = existingAlias;\n        continue;\n      }\n\n      const alias = generateAlias(template.cst_type, this.targetSchema, [...reservedAliases, ...takenAliases]);\n      takenAliases.push(alias);\n      aliasMapping[templateAlias] = alias;\n\n      const item = instantiateTemplateItem(template, args, alias);\n      item.definition_formal = definition;\n      applyMappingToConstituents([item], aliasMapping, false);\n      definitionIndex.register(cst_type, item.definition_formal, alias);\n      items.push(item);\n    }\n\n    return { items, aliasMapping, takenAliases };\n  }\n\n  private buildMainItem(\n    mainDefinition: string,\n    takenAliases: string[],\n    aliasMapping: AliasMapping,\n    definitionIndex: FormalDefinitionIndex\n  ): { item: TemplateInstantiationItem | null; duplicateAlias: string | null } {\n    const mappedDefinition = applyAliasMapping(mainDefinition, aliasMapping);\n    const cst_type = inferTemplatedType(this.prototype.cst_type, this.userArgs);\n\n    const duplicateAlias = definitionIndex.find(cst_type, mappedDefinition);\n    if (duplicateAlias) {\n      return { item: null, duplicateAlias };\n    }\n\n    const mainItem: TemplateInstantiationItem = {\n      ...this.mainItemTemplate,\n      definition_formal: mappedDefinition,\n      cst_type\n    };\n    applyMappingToConstituents([mainItem], aliasMapping, false);\n\n    if (takenAliases.includes(mainItem.alias)) {\n      mainItem.alias = generateAlias(mainItem.cst_type, this.targetSchema, [\n        ...takenAliases,\n        this.mainItemTemplate.alias\n      ]);\n    }\n\n    return { item: mainItem, duplicateAlias: null };\n  }\n\n  private ensureDep(templateAlias: string, bindings: Map<string, string>, referrer?: string): void {\n    if (this.bindingConflict) {\n      return;\n    }\n    if (!this.templateByAlias.has(templateAlias)) {\n      return;\n    }\n    if (referrer && this.depBindings.has(referrer)) {\n      const refs = this.depRefs.get(referrer) ?? new Set<string>();\n      refs.add(templateAlias);\n      this.depRefs.set(referrer, refs);\n    }\n    const mergeResult = mergeBindings(this.depBindings.get(templateAlias), bindings);\n    if (!mergeResult.ok) {\n      this.bindingConflict = { templateAlias, ...mergeResult.conflict };\n      return;\n    }\n    const merged = mergeResult.bindings;\n    const changed =\n      !this.depBindings.has(templateAlias) || merged.size !== (this.depBindings.get(templateAlias)?.size ?? 0);\n    this.depBindings.set(templateAlias, merged);\n    if (!changed && referrer) {\n      return;\n    }\n    const template = this.templateByAlias.get(templateAlias)!;\n    const args = bindingMapToArgs(getTemplateParams(template), merged);\n    const definition = substituteTemplateArgs(template.definition_formal, argumentValuesToMapping(args));\n    this.collectDependencies(definition, argumentValuesToMapping(args), templateAlias);\n  }\n\n  private collectDependencies(expression: string, scope: AliasMapping, referrer?: string): void {\n    if (this.bindingConflict) {\n      return;\n    }\n    const ast = parseRSLangExpression(expression);\n    if (!ast) {\n      return;\n    }\n    for (const call of extractFuncCalls(ast, expression)) {\n      const template = this.templateByAlias.get(call.callee);\n      if (!template) {\n        continue;\n      }\n      const scopedArgs = call.args.map(arg => substituteLocalAliases(arg, scope));\n      const bindings = bindingsFromCall(getTemplateParams(template), scopedArgs, scope);\n      this.ensureDep(call.callee, bindings, referrer);\n    }\n  }\n}\n\n// ======= Internals ========\n\n/** Normalized formal definitions in the target schema and in the current plan. */\nclass FormalDefinitionIndex {\n  private readonly byKey = new Map<string, string>();\n\n  register(cst_type: CstType, definition_formal: string, alias: string): void {\n    const normalized = normalizeExpression(definition_formal, cst_type);\n    if (!normalized) {\n      return;\n    }\n    this.byKey.set(formalDefinitionKey(cst_type, normalized), alias);\n  }\n\n  find(cst_type: CstType, definition_formal: string): string | null {\n    const normalized = normalizeExpression(definition_formal, cst_type);\n    if (!normalized) {\n      return null;\n    }\n    return this.byKey.get(formalDefinitionKey(cst_type, normalized)) ?? null;\n  }\n}\n\nfunction createFormalDefinitionIndex(schema: RSForm): FormalDefinitionIndex {\n  const index = new FormalDefinitionIndex();\n  for (const cst of schema.items) {\n    index.register(cst.cst_type, cst.definition_formal, cst.alias);\n  }\n  return index;\n}\n\nfunction formalDefinitionKey(cst_type: CstType, normalized: string): string {\n  return `${cst_type}\\0${normalized}`;\n}\n\nfunction instantiateTemplateItem(\n  template: Constituenta,\n  args: ArgumentValue[],\n  alias: string\n): TemplateInstantiationItem {\n  return {\n    alias,\n    cst_type: inferTemplatedType(template.cst_type, args),\n    crucial: template.crucial,\n    convention: template.convention,\n    definition_formal: substituteTemplateArgs(template.definition_formal, argumentValuesToMapping(args)),\n    definition_raw: template.definition_raw,\n    term_raw: template.term_raw,\n    term_forms: [...template.term_forms],\n    typification_manual: template.typification_manual,\n    value_is_property: template.value_is_property\n  };\n}\n\nfunction bindingsFromCall(params: TemplateParam[], callArgs: string[], scope: AliasMapping): Map<string, string> {\n  const bindings = new Map<string, string>();\n  params.forEach((param, index) => {\n    const value = resolveArgBinding(callArgs[index] ?? '', scope);\n    if (value) {\n      bindings.set(param.alias, value);\n    }\n  });\n  return bindings;\n}\n\nfunction resolveArgBinding(argExpr: string, scope: AliasMapping): string | undefined {\n  const scoped = substituteLocalAliases(argExpr, scope).trim();\n  if (isGlobalAlias(scoped)) {\n    return scoped;\n  }\n  return undefined;\n}\n\ntype MergeBindingsResult =\n  | { ok: true; bindings: Map<string, string> }\n  | { ok: false; conflict: { paramAlias: string; existing: string; incoming: string } };\n\nfunction mergeBindings(existing: Map<string, string> | undefined, incoming: Map<string, string>): MergeBindingsResult {\n  const result = new Map(existing);\n  for (const [alias, value] of incoming) {\n    const existingValue = result.get(alias);\n    if (existingValue === undefined) {\n      result.set(alias, value);\n    } else if (existingValue !== value) {\n      return { ok: false, conflict: { paramAlias: alias, existing: existingValue, incoming: value } };\n    }\n  }\n  return { ok: true, bindings: result };\n}\n\nfunction bindingMapToArgs(params: TemplateParam[], bindings: Map<string, string>): ArgumentValue[] {\n  return params.map(param => ({\n    alias: param.alias,\n    typification: param.typification,\n    value: bindings.get(param.alias)\n  }));\n}\n\nfunction getTemplateParams(template: Constituenta): TemplateParam[] {\n  const effectiveType = template.effectiveType;\n  if (effectiveType && (effectiveType.typeID === TypeID.function || effectiveType.typeID === TypeID.predicate)) {\n    return effectiveType.args.map(arg => ({\n      alias: arg.alias,\n      typification: labelType(arg.type)\n    }));\n  }\n  const { head } = splitTemplateDefinition(template.definition_formal);\n  if (!head) {\n    return [];\n  }\n  return head.split(',').map(part => {\n    const trimmed = part.trim();\n    const separator = trimmed.indexOf('∈');\n    if (separator === -1) {\n      return { alias: trimmed, typification: '' };\n    }\n    return {\n      alias: trimmed.slice(0, separator).trim(),\n      typification: trimmed.slice(separator + 1).trim()\n    };\n  });\n}\n\nfunction extractFuncCalls(ast: AstNode, expression: string): FuncCallRef[] {\n  const result: FuncCallRef[] = [];\n  visitAstDFS(ast, node => {\n    if (node.typeID !== TokenID.NT_FUNC_CALL || node.children.length < 1) {\n      return;\n    }\n    const calleeNode = node.children[0];\n    if (\n      calleeNode.typeID !== TokenID.ID_FUNCTION &&\n      calleeNode.typeID !== TokenID.ID_PREDICATE &&\n      calleeNode.typeID !== TokenID.ID_GLOBAL\n    ) {\n      return;\n    }\n    const callee = expression.slice(calleeNode.from, calleeNode.to);\n    if (!/^[FP]\\d+$/.test(callee)) {\n      return;\n    }\n    result.push({\n      callee,\n      args: node.children.slice(1).map(child => expression.slice(child.from, child.to).trim())\n    });\n  });\n  return result;\n}\n\nfunction topologicalSort(aliases: string[], refs: Map<string, Set<string>>): string[] {\n  const remaining = new Set(aliases);\n  const sorted: string[] = [];\n  while (remaining.size > 0) {\n    const ready = [...remaining].filter(alias => {\n      const deps = refs.get(alias) ?? new Set<string>();\n      return [...deps].every(dep => !remaining.has(dep));\n    });\n    if (ready.length === 0) {\n      return [...remaining, ...sorted].reverse();\n    }\n    ready.sort();\n    for (const alias of ready) {\n      sorted.push(alias);\n      remaining.delete(alias);\n    }\n  }\n  return sorted;\n}\n"],"mappings":"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"}

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 { applyAliasMapping, applyTypificationMapping, isSetTypification } from "../rslang/api.js";
 import "../graph/index.js";
 //#region src/library/oss-api.ts
 /**

package/dist/library/rsengine.d.ts

@@ -1,6 +1,6 @@
 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-Dt03dsnd.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";
 

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

@@ -1,7 +1,8 @@
 import { r as LibraryItem } from "../library-CYun28Xz.js";
-import { g as TypeClass, y as TypePath } from "../typification-DDuv88ir.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-DqjdciC5.js";
+import { r as AnalysisFull } from "../analyzer-iqAXyROE.js";
 import { ArgumentValue, Constituenta, CstClass, CstStatus, CstType, RSForm, RSFormStats } from "./rsform.js";
 import { AliasMapping } from "../rslang/api.js";
 
@@ -12,6 +13,15 @@ declare function isSchemaIssue(cst: Constituenta): boolean;
 declare function inferStatus(parse: boolean, value?: ValueClass | null): CstStatus;
 /** Infers type of constituent for a given template and arguments. */
 declare function inferTemplatedType(templateType: CstType, args: ArgumentValue[]): CstType;
+/** Build alias mapping from template argument bindings. */
+declare function argumentValuesToMapping(args: ArgumentValue[]): AliasMapping;
+/**
+ * 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.
+ */
+declare function normalizeExpression(expression: string, cst_type: CstType, ast?: AstNode | null): string | null;
 /** Checks if given expression is a template. */
 declare function inferTemplate(expression: string): boolean;
 /** Infers the {@link CstClass} based on the provided {@link CstType} and template status. */
@@ -79,5 +89,5 @@ declare function findCstByStructure(schema: RSForm, target: Constituenta, path:
 /** Retrieves name for piece of target {@link Constituenta} structure. */
 declare function getStructureName(schema: RSForm, target: Constituenta, path: TypePath): string;
 //#endregion
-export { ConstituentaMappableFields, addAliasReference, applyFilterCategory, applyMappingToConstituents, calculateSchemaStats, canHaveFormalDefinition, canHaveManualTypification, canProduceStructure, findCstByStructure, generateAlias, getAnalysisFor, getCstTypePrefix, getStructureName, guessCstType, inferClass, inferNewSpawnPosition, inferStatus, inferTemplate, inferTemplatedType, isBaseSet, isBasicConcept, isFunctional, isLogical, isSchemaIssue, isTemplateCst, removeAliasReference, sortItemsForInlineSynthesis, typeClassForCstType, validateAliasFormat, validateNewAlias };
+export { ConstituentaMappableFields, 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.d.ts.map

package/dist/library/rsform-api.js

@@ -1,11 +1,12 @@
 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";
-import { applyAliasMapping, applyTypificationMapping } from "../rslang/api.js";
 //#region src/library/rsform-api.ts
 /**
 * Module: API for formal representation for systems of concepts.
@@ -55,6 +56,27 @@ function inferTemplatedType(templateType, args) {
 	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);
@@ -378,6 +400,6 @@ function typeCanProduceStructure(type) {
 	else return type.base.typeID !== TypeID.basic && type.base.typeID !== TypeID.integer && type.base.typeID !== TypeID.anyTypification;
 }
 //#endregion
-export { addAliasReference, applyFilterCategory, applyMappingToConstituents, calculateSchemaStats, canHaveFormalDefinition, canHaveManualTypification, canProduceStructure, findCstByStructure, generateAlias, getAnalysisFor, getCstTypePrefix, getStructureName, guessCstType, inferClass, inferNewSpawnPosition, inferStatus, inferTemplate, inferTemplatedType, isBaseSet, isBasicConcept, isFunctional, isLogical, isSchemaIssue, isTemplateCst, removeAliasReference, sortItemsForInlineSynthesis, typeClassForCstType, validateAliasFormat, validateNewAlias };
+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