@rsconcept/domain 2.2.0 → 3.0.0

package/dist/{diagnostics-Db1F7ruF.d.ts → diagnostics-DsEhmFh0.d.ts}

@@ -265,8 +265,10 @@ interface CstDiagnostic {
   /** Positional message arguments (per-code; homonyms/duplicates use `[aliases]`). */
   params?: readonly string[];
 }
-/** Whether a constituent has a schema/model diagnostic with the given code. */
-declare function hasCstDiagnostic(cst: Constituenta, code: RSDiagnosticCode): boolean;
+/** Whether an item has a schema/model diagnostic with the given code. */
+declare function hasCstDiagnostic(cst: {
+  diagnostics?: readonly CstDiagnostic[] | null;
+}, code: RSDiagnosticCode): boolean;
 /**
  * Populate `diagnostics` on each constituent (homonyms, duplicates, metadata, type mismatch, cycles).
  *
@@ -297,5 +299,5 @@ declare function detectDependencyCycleDiagnostics(graph: Graph, resolveAlias: (i
 /** Map a model evaluation status to a compact diagnostic, or `null` when not an issue. */
 declare function modelStatusCstDiagnostic(status: EvalStatus, cstType: CstType): CstDiagnostic | null;
 //#endregion
-export { RSFormStats as C, RSForm as S, TypeInfo as T, Attribution as _, detectDependencyCycleDiagnostics as a, CstStatus as b, modelStatusCstDiagnostic as c, DEFAULT_VALUE_TEXT as d, EvalStatus as f, ArgumentValue as g, TYPE_BASIC as h, assignSchemaDiagnostics as i, BasicBinding as l, RSModelStats as m, DiagnosticKind as n, formatDependencyCycle as o, RSModel as p, RSDiagnosticCode as r, hasCstDiagnostic as s, CstDiagnostic as t, BasicsContext as u, Constituenta as v, Substitution as w, CstType as x, CstClass as y };
-//# sourceMappingURL=diagnostics-Db1F7ruF.d.ts.map
+export { RSFormStats as C, TypeInfo as E, RSForm as S, TermForm as T, Attribution as _, detectDependencyCycleDiagnostics as a, CstStatus as b, modelStatusCstDiagnostic as c, DEFAULT_VALUE_TEXT as d, EvalStatus as f, ArgumentValue as g, TYPE_BASIC as h, assignSchemaDiagnostics as i, BasicBinding as l, RSModelStats as m, DiagnosticKind as n, formatDependencyCycle as o, RSModel as p, RSDiagnosticCode as r, hasCstDiagnostic as s, CstDiagnostic as t, BasicsContext as u, Constituenta as v, Substitution as w, CstType as x, CstClass as y };
+//# sourceMappingURL=diagnostics-DsEhmFh0.d.ts.map

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

@@ -1,14 +1,14 @@
 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 { applyEntityReferenceMapping, extractEntities, parseGrammemes, resolveTextReferences } from "./cctext/language-api.js";
 import { generateExpressionFromAst } from "./rslang/parser/expression-generator.js";
 import { applyAliasMapping, applyTypificationMapping, extractGlobals, isSimpleExpression, parseRSLangExpression, splitTemplateDefinition } from "./rslang/api.js";
+import { CstClass, CstStatus, CstType } from "./library/rsform.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/cst-type.ts
@@ -54,7 +54,7 @@ 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. */
+/** Check if item type 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;
 }
@@ -146,7 +146,7 @@ function typeClassForCstType(cstType) {
 		case CstType.STATEMENT: return TypeClass.logic;
 	}
 }
-/** Evaluate if {@link Constituenta} can be used produce structure. */
+/** Evaluate if an item can be used to produce structure. */
 function canProduceStructure(cst) {
 	switch (cst.cst_type) {
 		case CstType.NOMINAL:
@@ -222,6 +222,45 @@ function applyMappingToConstituents(items, mapping, changeAliases) {
 		cst.definition_raw = applyEntityReferenceMapping(cst.definition_raw, mapping);
 	}
 }
+/** Highest numeric alias suffix for {@link type} among {@link items} (0 when none). */
+function maxAliasIndex(items, type) {
+	const prefix = getCstTypePrefix(type);
+	return items.reduce((max, cst) => {
+		if (cst.cst_type !== type) return max;
+		const index = Number(cst.alias.slice(prefix.length));
+		return Number.isFinite(index) ? Math.max(max, index) : max;
+	}, 0);
+}
+/**
+* Build alias → new-alias mapping that renumbers each type sequentially in list order.
+* Matches backend {@code RSFormCached.reset_aliases}.
+*/
+function buildSequentialAliasMapping(items) {
+	const counts = {};
+	for (const value of Object.values(CstType)) counts[value] = 1;
+	const mapping = {};
+	for (const cst of items) {
+		const alias = `${getCstTypePrefix(cst.cst_type)}${counts[cst.cst_type]}`;
+		counts[cst.cst_type] += 1;
+		if (cst.alias !== alias) mapping[cst.alias] = alias;
+	}
+	return mapping;
+}
+/**
+* Allocate fresh aliases for {@link source} constituents being imported into a non-empty receiver.
+* Returns an empty mapping when the receiver has no items (aliases kept as-is).
+*/
+function allocateImportAliases(receiver, source) {
+	if (receiver.length === 0) return {};
+	const counts = {};
+	for (const value of Object.values(CstType)) counts[value] = maxAliasIndex(receiver, value);
+	const mapping = {};
+	for (const cst of source) {
+		counts[cst.cst_type] += 1;
+		mapping[cst.alias] = `${getCstTypePrefix(cst.cst_type)}${counts[cst.cst_type]}`;
+	}
+	return mapping;
+}
 /** Remove alias from expression. */
 function removeAliasReference(expression, alias) {
 	const escaped = alias.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -333,6 +372,66 @@ function resolveDependencyCycleText(schema, graph, currentId, missingId) {
 	return null;
 }
 //#endregion
+//#region src/library/rsform-api/attribution.ts
+function attributionKey(attr) {
+	return `${attr.container}:${attr.attribute}`;
+}
+/**
+* Remap attributions when constituents are substituted (original → replacement).
+* Drops self-loops and duplicates. Matches sandbox / backend substitute attribution rewrite.
+*/
+function remapAttributionsUnderSubstitution(attributions, origToSub) {
+	const result = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const attr of attributions) {
+		if (!origToSub.has(attr.container) && !origToSub.has(attr.attribute)) {
+			const key = attributionKey(attr);
+			if (!seen.has(key)) {
+				seen.add(key);
+				result.push({ ...attr });
+			}
+			continue;
+		}
+		const container = origToSub.get(attr.container) ?? attr.container;
+		const attribute = origToSub.get(attr.attribute) ?? attr.attribute;
+		if (container === attribute) continue;
+		const key = `${container}:${attribute}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		result.push({
+			container,
+			attribute
+		});
+	}
+	return result;
+}
+/**
+* Copy attributions whose both endpoints are in {@link sourceIdSet}, remapping ids via {@link idMap}.
+* Appends onto a clone of {@link existing} with dedupe. Used by schema embedding / insert.
+*/
+function importAttributions(sourceAttributions, sourceIdSet, idMap, existing = []) {
+	const result = existing.map((attr) => ({ ...attr }));
+	const seen = new Set(result.map(attributionKey));
+	for (const attr of sourceAttributions) {
+		if (!sourceIdSet.has(attr.container) || !sourceIdSet.has(attr.attribute)) continue;
+		const container = idMap[attr.container];
+		const attribute = idMap[attr.attribute];
+		if (container === void 0 || attribute === void 0 || container === attribute) continue;
+		const key = `${container}:${attribute}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		result.push({
+			container,
+			attribute
+		});
+	}
+	return result;
+}
+/** Drop attributions that reference any id in {@link deletedIds}. */
+function filterAttributions(attributions, deletedIds) {
+	return attributions.filter((attr) => !deletedIds.has(attr.container) && !deletedIds.has(attr.attribute));
+}
+//#endregion
 //#region src/library/rsform-api/expression.ts
 /** Infers the status of an expression based on parsing and value information. */
 function inferStatus(parse, value) {
@@ -367,7 +466,7 @@ function inferTemplate(expression) {
 	const match = expression.match(/R\d+/g);
 	return (match && match?.length > 0) ?? false;
 }
-/** Apply filter based on start {@link Constituenta} type. */
+/** Apply filter based on start item type within an ordered list. */
 function applyFilterCategory(start, items) {
 	const startIndex = items.indexOf(start);
 	if (startIndex === -1) return [];
@@ -551,7 +650,7 @@ function kernelPriority(items, graph, parentOf) {
 /**
 * Schema-level statistics and issue flags.
 */
-/** Checks if {@link Constituenta} is a schema issue. */
+/** Checks if an item is a schema issue. */
 function isSchemaIssue(cst) {
 	return (cst.diagnostics?.length ?? 0) > 0 || cst.status === CstStatus.INCORRECT || cst.status === CstStatus.INCALCULABLE;
 }
@@ -674,7 +773,7 @@ function inferNewSpawnPosition(schema, targetId) {
 	for (const cst of schema.items) if (cst.spawner === targetId) last = cst.id;
 	return last ?? targetId;
 }
-/** Finds {@link Constituenta} by structure path. */
+/** Finds schema item by absolute structure path under `targetId`. */
 function findCstByStructure(schema, target, path) {
 	const byId = schema.cstByID ?? new Map(schema.items.map((item) => [item.id, item]));
 	for (const cst of schema.items) {
@@ -684,7 +783,7 @@ function findCstByStructure(schema, target, path) {
 	}
 	return null;
 }
-/** Retrieves name for piece of target {@link Constituenta} structure. */
+/** Retrieves name for piece of target structure. */
 function getStructureName(schema, target, path) {
 	const representation = findCstByStructure(schema, target, path);
 	if (representation) return `${representation.alias}: ${representation.term_resolved}`;
@@ -714,16 +813,276 @@ function resolveAbsoluteSpawnerPath(cst, targetId, byId) {
 	return null;
 }
 //#endregion
+//#region src/library/rsform-api/substitution.ts
+/**
+* Apply constituenta substitutions: remap attributions, drop originals, rewrite aliases in survivors.
+* Does not resolve texts — call {@link resolveAllConstituentTexts} afterwards.
+*/
+function applyConstituentSubstitutions(items, attributions, substitutions) {
+	if (substitutions.length === 0) return {
+		items: [...items],
+		attributions: attributions.map((attr) => ({ ...attr })),
+		deletedIds: /* @__PURE__ */ new Set(),
+		replacementIds: []
+	};
+	const byId = new Map(items.map((cst) => [cst.id, cst]));
+	const mapping = {};
+	const deletedIds = /* @__PURE__ */ new Set();
+	const origToSub = /* @__PURE__ */ new Map();
+	const replacementIds = [];
+	for (const { original, substitution } of substitutions) {
+		const originalCst = byId.get(original);
+		const substitutionCst = byId.get(substitution);
+		if (!originalCst || !substitutionCst) throw new Error(`applyConstituentSubstitutions: unknown constituenta ${original} -> ${substitution}`);
+		mapping[originalCst.alias] = substitutionCst.alias;
+		deletedIds.add(original);
+		origToSub.set(original, substitution);
+		replacementIds.push(substitution);
+	}
+	const nextItems = items.filter((cst) => !deletedIds.has(cst.id));
+	applyMappingToConstituents(nextItems, mapping, false);
+	return {
+		items: nextItems,
+		attributions: remapAttributionsUnderSubstitution(attributions, origToSub),
+		deletedIds,
+		replacementIds
+	};
+}
+/**
+* Remap substitution endpoints after source constituents were inserted under new ids.
+* If {@link original} was imported, map it; otherwise map {@link substitution}.
+*/
+function remapSubstitutionsAfterImport(substitutions, sourceIdSet, idMap) {
+	return substitutions.map((sub) => {
+		if (sourceIdSet.has(sub.original)) return {
+			original: idMap[sub.original],
+			substitution: sub.substitution
+		};
+		return {
+			original: sub.original,
+			substitution: idMap[sub.substitution]
+		};
+	});
+}
+//#endregion
+//#region src/library/rsform-api/text-resolution.ts
+/** Build term-reference graph: referenced constituent → dependent (backend {@code graph_term}). */
+function buildTermReferenceGraph(items) {
+	return buildReferenceGraph(items, "term_raw");
+}
+/** Build definition-reference graph: referenced constituent → dependent (backend {@code graph_text}). */
+function buildDefinitionReferenceGraph(items) {
+	return buildReferenceGraph(items, "definition_raw");
+}
+/** Resolve all term and definition texts in topological order. Mutates items in place. */
+function resolveAllConstituentTexts(items) {
+	const graphTerm = buildTermReferenceGraph(items);
+	const idToItem = new Map(items.map((item) => [item.id, item]));
+	const context = buildTermContext(items);
+	for (const id of graphTerm.topologicalOrder()) {
+		const row = idToItem.get(id);
+		if (!row) continue;
+		const resolved = resolveTextReferences(row.term_raw, context);
+		if (resolved !== row.term_resolved) {
+			row.term_resolved = resolved;
+			row.term_forms = [];
+			context[row.alias] = {
+				nominal: row.term_resolved,
+				forms: []
+			};
+		}
+	}
+	for (const row of items) row.definition_resolved = resolveTextReferences(row.definition_raw, context);
+}
+/**
+* Resolve texts after a single constituent change, cascading dependents when the term changed.
+* Mutates items in place.
+*/
+function resolveConstituentTextChange(items, targetID, options) {
+	const idToItem = new Map(items.map((item) => [item.id, item]));
+	const target = idToItem.get(targetID);
+	if (!target) throw new Error(`resolveConstituentTextChange: unknown target ${targetID}`);
+	const context = buildTermContext(items);
+	if (options.termRawChanged) {
+		target.term_resolved = resolveTextReferences(target.term_raw, context);
+		if (options.clearTargetForms) target.term_forms = [];
+		context[target.alias] = toContextItem(target);
+	} else if (options.termChanged) context[target.alias] = toContextItem(target);
+	if (options.definitionRawChanged && !options.termChanged) target.definition_resolved = resolveTextReferences(target.definition_raw, context);
+	if (!options.termChanged) return;
+	const graphTerm = buildTermReferenceGraph(items);
+	const graphText = buildDefinitionReferenceGraph(items);
+	const expansion = graphTerm.expandAllOutputs([targetID]);
+	const expansionSet = new Set(expansion);
+	for (const id of graphTerm.topologicalOrder()) {
+		if (!expansionSet.has(id)) continue;
+		const expanded = idToItem.get(id);
+		if (!expanded) continue;
+		const resolved = resolveTextReferences(expanded.term_raw, context);
+		if (resolved !== expanded.term_resolved) {
+			expanded.term_resolved = resolved;
+			expanded.term_forms = [];
+			context[expanded.alias] = {
+				nominal: expanded.term_resolved,
+				forms: []
+			};
+		}
+	}
+	const updateDefs = /* @__PURE__ */ new Set([
+		targetID,
+		...expansion,
+		...graphText.expandAllOutputs([targetID, ...expansion])
+	]);
+	for (const item of items) if (updateDefs.has(item.id)) item.definition_resolved = resolveTextReferences(item.definition_raw, context);
+}
+function buildReferenceGraph(items, field) {
+	const graph = new Graph();
+	const idByAlias = new Map(items.map((row) => [row.alias, row.id]));
+	for (const row of items) graph.addNode(row.id);
+	for (const row of items) for (const entity of extractEntities(row[field])) {
+		const source = idByAlias.get(entity);
+		if (source !== void 0) graph.addEdge(source, row.id);
+	}
+	return graph;
+}
+function buildTermContext(items) {
+	const context = {};
+	for (const row of items) context[row.alias] = toContextItem(row);
+	return context;
+}
+function toContextItem(row) {
+	return {
+		nominal: row.term_resolved,
+		forms: row.term_forms.map((form) => ({
+			text: form.text,
+			grams: parseGrammemes(form.tags)
+		}))
+	};
+}
+//#endregion
 //#region src/library/rsform-api/synthesis.ts
-/** Sorts library items relevant for InlineSynthesis with specified {@link RSForm}. */
+/**
+* Embed {@link InlineSynthesisInput.sourceItems} into the receiver and apply substitutions.
+* Resolves term/definition entity references on the result.
+* Does not mutate inputs.
+*/
+function inlineSynthesis(input) {
+	const sourceItems = input.sourceItems;
+	if (sourceItems.length === 0) return {
+		items: input.receiverItems.map((item) => structuredClone(item)),
+		attributions: (input.receiverAttributions ?? []).map((attr) => ({ ...attr })),
+		nextId: input.nextId,
+		idMap: {},
+		aliasMapping: {},
+		deletedIds: /* @__PURE__ */ new Set(),
+		insertedIds: [],
+		replacementIds: []
+	};
+	const receiverItems = input.receiverItems.map((item) => structuredClone(item));
+	let attributions = (input.receiverAttributions ?? []).map((attr) => ({ ...attr }));
+	const aliasMapping = allocateImportAliases(receiverItems, sourceItems);
+	const idMap = {};
+	const inserted = [];
+	const sourceIdSet = new Set(sourceItems.map((cst) => cst.id));
+	let nextId = input.nextId;
+	for (const cst of sourceItems) {
+		const newId = nextId;
+		nextId += 1;
+		idMap[cst.id] = newId;
+		const cloned = structuredClone(cst);
+		cloned.id = newId;
+		if (Object.keys(aliasMapping).length > 0) {
+			cloned.alias = aliasMapping[cst.alias];
+			applyMappingToConstituents([cloned], aliasMapping, false);
+		}
+		inserted.push(cloned);
+	}
+	attributions = importAttributions(input.sourceAttributions ?? [], sourceIdSet, idMap, attributions);
+	const items = receiverItems.concat(inserted);
+	resolveAllConstituentTexts(items);
+	const substitutions = input.substitutions ?? [];
+	if (substitutions.length === 0) return {
+		items,
+		attributions,
+		nextId,
+		idMap,
+		aliasMapping,
+		deletedIds: /* @__PURE__ */ new Set(),
+		insertedIds: inserted.map((cst) => cst.id),
+		replacementIds: []
+	};
+	const remapped = remapSubstitutionsAfterImport(substitutions, sourceIdSet, idMap);
+	const substituted = applyConstituentSubstitutions(items, attributions, remapped);
+	resolveAllConstituentTexts(substituted.items);
+	return {
+		items: substituted.items,
+		attributions: substituted.attributions,
+		nextId,
+		idMap,
+		aliasMapping,
+		deletedIds: substituted.deletedIds,
+		insertedIds: inserted.map((cst) => cst.id),
+		replacementIds: substituted.replacementIds
+	};
+}
+/** Sorts library items relevant for schema embedding 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);
+	const included = new Set(result);
+	for (const item of items) if (item.visible && item.owner === receiver.owner && !included.has(item)) {
+		result.push(item);
+		included.add(item);
+	}
+	for (const item of items) if (item.visible && !included.has(item)) {
+		result.push(item);
+		included.add(item);
+	}
+	for (const item of items) if (!included.has(item)) {
+		result.push(item);
+		included.add(item);
+	}
 	return result;
 }
 //#endregion
+//#region src/library/rsform-api/transforms.ts
+/**
+* Pure constituenta list transforms: reorder, move, insert position.
+*/
+/** Rebuild an item list following {@link orderedIds}. Throws if an id is missing. */
+function reorderItemsByIds(items, orderedIds) {
+	const byId = new Map(items.map((item) => [item.id, item]));
+	return orderedIds.map((id) => {
+		const item = byId.get(id);
+		if (!item) throw new Error(`reorderItemsByIds: missing id ${id}`);
+		return item;
+	});
+}
+/**
+* Move a subset of ids within an ordered id list.
+* {@link moveTo} is clamped to `[0, rest.length]` (index among non-moving items).
+*/
+function moveIdsInOrder(ids, moving, moveTo) {
+	const movingSet = new Set(moving);
+	const rest = ids.filter((id) => !movingSet.has(id));
+	const movingItems = ids.filter((id) => movingSet.has(id));
+	const clamped = Math.max(0, Math.min(moveTo, rest.length));
+	return [
+		...rest.slice(0, clamped),
+		...movingItems,
+		...rest.slice(clamped)
+	];
+}
+/** Insert {@link item} after {@link insertAfter}, or append when null/undefined/missing. Mutates {@link items}. */
+function insertItemAfter(items, item, insertAfter) {
+	if (insertAfter === null || insertAfter === void 0) {
+		items.push(item);
+		return;
+	}
+	const idx = items.findIndex((row) => row.id === insertAfter);
+	const insertAt = idx === -1 ? items.length : idx + 1;
+	items.splice(insertAt, 0, item);
+}
+//#endregion
 //#region src/library/diagnostics.ts
 /** Origin of a diagnostic. */
 const DiagnosticKind = {
@@ -744,7 +1103,7 @@ const RSDiagnosticCode = {
 	modelInvalidData: 35090,
 	modelEvalFail: 35091
 };
-/** Whether a constituent has a schema/model diagnostic with the given code. */
+/** Whether an item has a schema/model diagnostic with the given code. */
 function hasCstDiagnostic(cst, code) {
 	return cst.diagnostics?.some((item) => item.code === code) ?? false;
 }
@@ -891,6 +1250,6 @@ function modelStatusToCode(status, cstType) {
 	}
 }
 //#endregion
-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 };
+export { isFunctional as $, normalizeExpression as A, buildSequentialAliasMapping as B, isSchemaIssue as C, inferStatus as D, applyFilterCategory as E, refineAnalysisForDependencyCycles as F, validateNewAlias as G, maxAliasIndex as H, addAliasReference as I, getCstTypePrefix as J, canHaveManualTypification as K, allocateImportAliases as L, importAttributions as M, remapAttributionsUnderSubstitution as N, inferTemplate as O, getAnalysisFor as P, isBasicConcept as Q, applyMappingToConstituents as R, calculateSchemaStats as S, restoreConstituentOrder as T, removeAliasReference as U, generateAlias as V, validateAliasFormat as W, inferClass as X, guessCstType as Y, isBaseSet as Z, applyConstituentSubstitutions as _, formatDependencyCycle as a, getStructureName as b, insertItemAfter as c, inlineSynthesis as d, isLogical as et, sortItemsForInlineSynthesis as f, resolveConstituentTextChange as g, resolveAllConstituentTexts as h, detectDependencyCycleDiagnostics as i, filterAttributions as j, inferTemplatedType as k, moveIdsInOrder as l, buildTermReferenceGraph as m, RSDiagnosticCode as n, typeClassForCstType as nt, hasCstDiagnostic as o, buildDefinitionReferenceGraph as p, canProduceStructure as q, assignSchemaDiagnostics as r, modelStatusCstDiagnostic as s, DiagnosticKind as t, isTemplateCst as tt, reorderItemsByIds as u, remapSubstitutionsAfterImport as v, buildFormalDependencyGraph as w, inferNewSpawnPosition as x, findCstByStructure as y, argumentValuesToMapping as z };
 
-//# sourceMappingURL=diagnostics-B1OfMra1.js.map
+//# sourceMappingURL=diagnostics-ndGYbvgh.js.map