@rsconcept/domain 2.3.0 → 3.0.0

package/dist/library/structure-planner.js

@@ -3,7 +3,7 @@ import { labelType } from "../rslang/labels.js";
 import { splitTemplateDefinition } from "../rslang/api.js";
 import { CstType } from "./rsform.js";
 import "../rslang/index.js";
-import { y as findCstByStructure } from "../diagnostics-CljEzVBV.js";
+import { y as findCstByStructure } from "../diagnostics-ndGYbvgh.js";
 //#region src/library/structure-planner.ts
 /** Structure planner for {@link Constituenta}. */
 var StructurePlanner = class {

package/dist/library/structure-planner.js.map

@@ -1 +1 @@
-{"version":3,"file":"structure-planner.js","names":[],"sources":["../../src/library/structure-planner.ts"],"sourcesContent":["import { makeTypePath, TypeID, type TypePath, type Typification } from '../rslang';\nimport { splitTemplateDefinition } from '../rslang/api';\nimport { labelType } from '../rslang/labels';\nimport { bool, type EchelonFunctional, isTypification } from '../rslang/semantic/typification';\n\nimport { type Constituenta, CstType, type RSForm } from './rsform';\nimport { findCstByStructure } from './rsform-api';\n\n/** Represents a node in the structure planner. */\nexport interface SPNode {\n  key: string;\n  path: TypePath;\n  type: Typification;\n  parent: number | null;\n  definition: string;\n  existing: Constituenta | null;\n}\n\n/** Structure planner for {@link Constituenta}. */\nexport class StructurePlanner {\n  private items: SPNode[] = [];\n  private schema: RSForm;\n  private target: Constituenta;\n  private rootType: Typification;\n\n  constructor(schema: RSForm, target: Constituenta) {\n    const eff = target.effectiveType;\n    if (eff == null) {\n      throw new Error('Invalid typification for target');\n    }\n    this.schema = schema;\n    this.target = target;\n    if (target.cst_type === CstType.FUNCTION && !isTypification(eff)) {\n      this.rootType = (eff as EchelonFunctional).result;\n    } else if (isTypification(eff)) {\n      this.rootType = eff as Typification;\n    } else {\n      throw new Error('Invalid typification for target');\n    }\n  }\n\n  public build(): SPNode[] {\n    this.items.push({\n      key: 'root',\n      path: makeTypePath([]),\n      type: this.rootType,\n      parent: null,\n      definition: labelType(this.target.effectiveType),\n      existing: this.target\n    });\n    this.visit(this.rootType, this.rootType.typeID === TypeID.collection ? [0] : [], 0);\n    return this.items;\n  }\n\n  private visit(type: Typification, path: number[], parent: number) {\n    switch (type.typeID) {\n      case TypeID.collection:\n        if (type.base.typeID === TypeID.tuple) {\n          type.base.factors.forEach((factor, index) => {\n            const nextPath = [...path, index + 1];\n            const nextType = bool(factor);\n            const nextNode = this.pushNode(nextPath, nextType, parent);\n            this.visit(nextType, nextPath, nextNode);\n          });\n        } else if (type.base.typeID === TypeID.collection) {\n          const nextPath = [...path, 0];\n          const nextNode = this.pushNode(nextPath, type.base, parent);\n          this.visit(type.base, nextPath, nextNode);\n        }\n        return;\n      case TypeID.tuple:\n        type.factors.forEach((factor, index) => {\n          const nextPath = [...path, index + 1];\n          const nextNode = this.pushNode(nextPath, factor, parent);\n          this.visit(factor, nextPath, nextNode);\n        });\n        return;\n      default:\n        return;\n    }\n  }\n\n  private pushNode(path: number[], type: Typification, parent: number) {\n    const typePath = makeTypePath(path);\n    this.items.push({\n      key: formatPathText(typePath),\n      path: typePath,\n      type: type,\n      parent: parent,\n      definition: produceDefinition(this.target, this.rootType, typePath),\n      existing: findCstByStructure(this.schema, this.target, typePath)\n    });\n    return this.items.length - 1;\n  }\n}\n\n// ======= Internals =======\nfunction produceDefinition(target: Constituenta, rootType: Typification, path: TypePath): string {\n  let current = rootType;\n  let expression = target.alias;\n  let index = rootType.typeID === TypeID.collection ? 1 : 0;\n  let prefix = '';\n  if (target.cst_type === CstType.FUNCTION) {\n    prefix = `[${splitTemplateDefinition(target.definition_formal).head}] `;\n    const funcType =\n      target.effectiveType && !isTypification(target.effectiveType)\n        ? (target.effectiveType as EchelonFunctional)\n        : null;\n    if (funcType) {\n      expression = `${expression}[${funcType.args.map(arg => arg.alias).join(', ')}]`;\n    }\n  }\n\n  while (index < path.length) {\n    const step = path[index];\n    switch (current.typeID) {\n      case TypeID.collection:\n        if (current.base.typeID === TypeID.tuple) {\n          expression = `Pr${step}(${expression})`;\n          current = bool(current.base.factors[step - 1]);\n          index += 1;\n        } else {\n          expression = `red(${expression})`;\n          current = current.base;\n          index += 1;\n        }\n        break;\n      case TypeID.tuple:\n        expression = `pr${step}(${expression})`;\n        current = current.factors[step - 1];\n        index += 1;\n        break;\n      default:\n        return prefix + expression;\n    }\n  }\n\n  return prefix + expression;\n}\n\nfunction formatPathText(path: TypePath): string {\n  return path.map(step => String(step)).join('.');\n}\n"],"mappings":"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"}
+{"version":3,"file":"structure-planner.js","names":[],"sources":["../../src/library/structure-planner.ts"],"sourcesContent":["import { makeTypePath, TypeID, type TypePath, type Typification } from '../rslang';\nimport { splitTemplateDefinition } from '../rslang/api';\nimport { labelType } from '../rslang/labels';\nimport { bool, type EchelonFunctional, isTypification } from '../rslang/semantic/typification';\n\nimport { type Constituenta, CstType, type RSForm } from './rsform';\nimport { findCstByStructure, type FormalOrderFields, type StructureCapableFields } from './rsform-api';\n\n/** Represents a node in the structure planner. */\nexport interface SPNode {\n  key: string;\n  path: TypePath;\n  type: Typification;\n  parent: number | null;\n  definition: string;\n  existing: Constituenta | null;\n}\n\n/** Structure planner for {@link Constituenta}. */\nexport class StructurePlanner {\n  private items: SPNode[] = [];\n  private schema: RSForm;\n  private target: Constituenta;\n  private rootType: Typification;\n\n  constructor(schema: RSForm, target: Constituenta) {\n    const eff = target.effectiveType;\n    if (eff == null) {\n      throw new Error('Invalid typification for target');\n    }\n    this.schema = schema;\n    this.target = target;\n    if (target.cst_type === CstType.FUNCTION && !isTypification(eff)) {\n      this.rootType = (eff as EchelonFunctional).result;\n    } else if (isTypification(eff)) {\n      this.rootType = eff as Typification;\n    } else {\n      throw new Error('Invalid typification for target');\n    }\n  }\n\n  public build(): SPNode[] {\n    this.items.push({\n      key: 'root',\n      path: makeTypePath([]),\n      type: this.rootType,\n      parent: null,\n      definition: labelType(this.target.effectiveType),\n      existing: this.target\n    });\n    this.visit(this.rootType, this.rootType.typeID === TypeID.collection ? [0] : [], 0);\n    return this.items;\n  }\n\n  private visit(type: Typification, path: number[], parent: number) {\n    switch (type.typeID) {\n      case TypeID.collection:\n        if (type.base.typeID === TypeID.tuple) {\n          type.base.factors.forEach((factor, index) => {\n            const nextPath = [...path, index + 1];\n            const nextType = bool(factor);\n            const nextNode = this.pushNode(nextPath, nextType, parent);\n            this.visit(nextType, nextPath, nextNode);\n          });\n        } else if (type.base.typeID === TypeID.collection) {\n          const nextPath = [...path, 0];\n          const nextNode = this.pushNode(nextPath, type.base, parent);\n          this.visit(type.base, nextPath, nextNode);\n        }\n        return;\n      case TypeID.tuple:\n        type.factors.forEach((factor, index) => {\n          const nextPath = [...path, index + 1];\n          const nextNode = this.pushNode(nextPath, factor, parent);\n          this.visit(factor, nextPath, nextNode);\n        });\n        return;\n      default:\n        return;\n    }\n  }\n\n  private pushNode(path: number[], type: Typification, parent: number) {\n    const typePath = makeTypePath(path);\n    this.items.push({\n      key: formatPathText(typePath),\n      path: typePath,\n      type: type,\n      parent: parent,\n      definition: produceDefinition(this.target, this.rootType, typePath),\n      existing: findCstByStructure(this.schema, this.target, typePath)\n    });\n    return this.items.length - 1;\n  }\n}\n\n// ======= Internals =======\nfunction produceDefinition(\n  target: FormalOrderFields & StructureCapableFields,\n  rootType: Typification,\n  path: TypePath\n): string {\n  let current = rootType;\n  let expression = target.alias;\n  let index = rootType.typeID === TypeID.collection ? 1 : 0;\n  let prefix = '';\n  if (target.cst_type === CstType.FUNCTION) {\n    prefix = `[${splitTemplateDefinition(target.definition_formal).head}] `;\n    const funcType =\n      target.effectiveType && !isTypification(target.effectiveType)\n        ? (target.effectiveType as EchelonFunctional)\n        : null;\n    if (funcType) {\n      expression = `${expression}[${funcType.args.map(arg => arg.alias).join(', ')}]`;\n    }\n  }\n\n  while (index < path.length) {\n    const step = path[index];\n    switch (current.typeID) {\n      case TypeID.collection:\n        if (current.base.typeID === TypeID.tuple) {\n          expression = `Pr${step}(${expression})`;\n          current = bool(current.base.factors[step - 1]);\n          index += 1;\n        } else {\n          expression = `red(${expression})`;\n          current = current.base;\n          index += 1;\n        }\n        break;\n      case TypeID.tuple:\n        expression = `pr${step}(${expression})`;\n        current = current.factors[step - 1];\n        index += 1;\n        break;\n      default:\n        return prefix + expression;\n    }\n  }\n\n  return prefix + expression;\n}\n\nfunction formatPathText(path: TypePath): string {\n  return path.map(step => String(step)).join('.');\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsconcept/domain",
-  "version": "2.3.0",
+  "version": "3.0.0",
   "description": "Shared TypeScript domain for RS language, RSForm, RSModel, RSEngine, OSS, and concept-text helpers.",
   "license": "MIT",
   "author": "IRBorisov",

package/src/library/diagnostics.ts

@@ -3,8 +3,10 @@
  */
 
 import { type Graph } from '../graph';
+import { type ExpressionType } from '../rslang';
 import { labelType } from '../rslang/labels';
 
+import { type BasicTextCheckFields } from './rsform-api/types';
 import { type Constituenta, type CstType } from './rsform';
 import { isBasicConcept, isLogical } from './rsform-api';
 import { EvalStatus } from './rsmodel';
@@ -41,8 +43,11 @@ export interface CstDiagnostic {
   params?: readonly string[];
 }
 
-/** Whether a constituent has a schema/model diagnostic with the given code. */
-export function hasCstDiagnostic(cst: Constituenta, code: RSDiagnosticCode): boolean {
+/** Whether an item has a schema/model diagnostic with the given code. */
+export function hasCstDiagnostic(
+  cst: { diagnostics?: readonly CstDiagnostic[] | null },
+  code: RSDiagnosticCode
+): boolean {
   return cst.diagnostics?.some(item => item.code === code) ?? false;
 }
 
@@ -160,7 +165,13 @@ export function modelStatusCstDiagnostic(status: EvalStatus, cstType: CstType):
   return { kind: DiagnosticKind.MODEL, code, params: [String(status)] };
 }
 
-function collectLocalSchemaDiagnostics(cst: Constituenta): CstDiagnostic[] {
+function collectLocalSchemaDiagnostics(
+  cst: BasicTextCheckFields & {
+    is_type_mismatch: boolean;
+    typification_manual: string;
+    analysis: { type: ExpressionType | null };
+  }
+): CstDiagnostic[] {
   const result: CstDiagnostic[] = [];
   if (cst.is_type_mismatch) {
     result.push({
@@ -180,13 +191,13 @@ function collectLocalSchemaDiagnostics(cst: Constituenta): CstDiagnostic[] {
   return result;
 }
 
-function detectGroupedAliasDiagnostics(
-  items: Constituenta[],
+function detectGroupedAliasDiagnostics<T extends { id: number }>(
+  items: readonly T[],
   resolveAlias: (id: number) => string,
-  groupKey: (cst: Constituenta) => string | undefined,
+  groupKey: (cst: T) => string | undefined,
   code: RSDiagnosticCode
 ): Map<number, CstDiagnostic> {
-  const groups = new Map<string, Constituenta[]>();
+  const groups = new Map<string, T[]>();
   for (const cst of items) {
     const key = groupKey(cst);
     if (!key) {
@@ -218,7 +229,7 @@ function detectGroupedAliasDiagnostics(
 }
 
 function detectHomonymDiagnostics(
-  items: Constituenta[],
+  items: readonly { id: number; term_resolved: string }[],
   resolveAlias: (id: number) => string
 ): Map<number, CstDiagnostic> {
   return detectGroupedAliasDiagnostics(
@@ -233,7 +244,7 @@ function detectHomonymDiagnostics(
 }
 
 function detectFormalDuplicateDiagnostics(
-  items: Constituenta[],
+  items: readonly { id: number }[],
   resolveAlias: (id: number) => string,
   normalizedDefinitions: ReadonlyMap<number, string>
 ): Map<number, CstDiagnostic> {

package/src/library/oss-api.ts

@@ -10,6 +10,7 @@ import { extractBases } from '../rslang/semantic/typification-api';
 import { type LibraryItem } from './library';
 import { NodeType, type OperationSchema, type SubstitutionErrorDescription, SubstitutionErrorType } from './oss';
 import { type Constituenta, CstClass, CstType, type RSForm, type Substitution } from './rsform';
+import { type FormalOrderFields } from './rsform-api';
 
 const STARTING_SUB_INDEX = 900; // max semantic index for starting substitution
 
@@ -387,7 +388,10 @@ export class SubstitutionValidator {
     return result;
   }
 
-  private checkEqual(left: Constituenta, right: Constituenta): boolean {
+  private checkEqual(
+    left: FormalOrderFields & { schema: number },
+    right: FormalOrderFields & { schema: number }
+  ): boolean {
     const schema1 = this.schemaByID.get(left.schema)!;
     const inputs1 = schema1.graph.at(left.id)!.inputs;
     if (inputs1.some(id => !this.constituents.has(id))) {

package/src/library/rsform-api/alias.ts

@@ -7,10 +7,10 @@ import { type AliasMapping, applyAliasMapping, applyTypificationMapping } from '
 import { type ArgumentValue, CstType, type RSForm } from '../rsform';
 
 import { getCstTypePrefix } from './cst-type';
-import { type AliasTypedConstituenta } from './types';
+import { type AliasTypedFields } from './types';
 
-/** Fields of {@link Constituenta} updated in place by alias mapping. */
-export interface ConstituentaMappableFields {
+/** Fields updated in place by alias mapping. */
+export interface MappableFields {
   alias: string;
   definition_formal: string;
   typification_manual: string;
@@ -77,7 +77,7 @@ export function generateAlias(type: CstType, schema: RSForm, takenAliases: strin
  * Remap formal expressions and terminological entity references in constituent fields.
  * Mutates each element of `items` in place; pass owned or cloned data only.
  */
-export function applyMappingToConstituents<T extends ConstituentaMappableFields>(
+export function applyMappingToConstituents<T extends MappableFields>(
   items: T[],
   mapping: AliasMapping,
   changeAliases: boolean
@@ -94,7 +94,7 @@ export function applyMappingToConstituents<T extends ConstituentaMappableFields>
 }
 
 /** Highest numeric alias suffix for {@link type} among {@link items} (0 when none). */
-export function maxAliasIndex(items: readonly AliasTypedConstituenta[], type: CstType): number {
+export function maxAliasIndex(items: readonly AliasTypedFields[], type: CstType): number {
   const prefix = getCstTypePrefix(type);
   return items.reduce((max, cst) => {
     if (cst.cst_type !== type) {
@@ -109,7 +109,7 @@ export function maxAliasIndex(items: readonly AliasTypedConstituenta[], type: Cs
  * Build alias → new-alias mapping that renumbers each type sequentially in list order.
  * Matches backend {@code RSFormCached.reset_aliases}.
  */
-export function buildSequentialAliasMapping(items: readonly AliasTypedConstituenta[]): AliasMapping {
+export function buildSequentialAliasMapping(items: readonly AliasTypedFields[]): AliasMapping {
   const counts: Record<string, number> = {};
   for (const value of Object.values(CstType)) {
     counts[value] = 1;
@@ -130,8 +130,8 @@ export function buildSequentialAliasMapping(items: readonly AliasTypedConstituen
  * Returns an empty mapping when the receiver has no items (aliases kept as-is).
  */
 export function allocateImportAliases(
-  receiver: readonly AliasTypedConstituenta[],
-  source: readonly AliasTypedConstituenta[]
+  receiver: readonly AliasTypedFields[],
+  source: readonly AliasTypedFields[]
 ): AliasMapping {
   if (receiver.length === 0) {
     return {};

package/src/library/rsform-api/cst-type.ts

@@ -4,7 +4,9 @@
 
 import { TypeClass, TypeID, type Typification } from '../../rslang';
 import { type EchelonFunctional, isTypification } from '../../rslang/semantic/typification';
-import { type Constituenta, CstClass, CstType } from '../rsform';
+import { CstClass, CstType } from '../rsform';
+
+import { type StructureCapableFields } from './types';
 
 /** Record of {@link CstType} prefixes. */
 const CST_TYPE_PREFIX: Record<CstType, string> = {
@@ -58,8 +60,8 @@ export function inferClass(type: CstType, isTemplate: boolean = false): CstClass
   return CST_TYPE_TO_CLASS[type];
 }
 
-/** Check if {@link Constituenta} is a template or a category. */
-export function isTemplateCst(cst: Constituenta): boolean {
+/** Check if item type is a template or a category. */
+export function isTemplateCst(cst: { cst_type: CstType }): boolean {
   return cst.cst_type === CstType.FUNCTION || cst.cst_type === CstType.PREDICATE || cst.cst_type === CstType.STATEMENT;
 }
 
@@ -177,8 +179,8 @@ export function typeClassForCstType(cstType: CstType): TypeClass {
   }
 }
 
-/** Evaluate if {@link Constituenta} can be used produce structure. */
-export function canProduceStructure(cst: Constituenta): boolean {
+/** Evaluate if an item can be used to produce structure. */
+export function canProduceStructure(cst: StructureCapableFields): boolean {
   switch (cst.cst_type) {
     case CstType.NOMINAL:
     case CstType.BASE:

package/src/library/rsform-api/expression.ts

@@ -5,7 +5,7 @@
 import { type AstNode } from '../../parsing';
 import { ValueClass } from '../../rslang';
 import { generateExpressionFromAst, parseRSLangExpression } from '../../rslang/api';
-import { type ArgumentValue, type Constituenta, CstStatus, CstType } from '../rsform';
+import { type ArgumentValue, CstStatus, CstType } from '../rsform';
 
 import { isBasicConcept } from './cst-type';
 
@@ -61,8 +61,8 @@ export function inferTemplate(expression: string): boolean {
   return (match && match?.length > 0) ?? false;
 }
 
-/** Apply filter based on start {@link Constituenta} type. */
-export function applyFilterCategory(start: Constituenta, items: Constituenta[]): Constituenta[] {
+/** Apply filter based on start item type within an ordered list. */
+export function applyFilterCategory<T extends { cst_type: CstType }>(start: T, items: readonly T[]): T[] {
   const startIndex = items.indexOf(start);
   if (startIndex === -1) {
     return [];

package/src/library/rsform-api/formal-graph.test.ts

@@ -4,9 +4,9 @@ import { CstType } from '../rsform';
 
 import { buildFormalDependencyGraph, restoreConstituentOrder } from './formal-graph';
 import { computeSemanticRelations } from './semantic-relations';
-import { type OrderableConstituenta } from './types';
+import { type FormalOrderFields } from './types';
 
-function cst(id: number, alias: string, cst_type: CstType, definition_formal = ''): OrderableConstituenta {
+function cst(id: number, alias: string, cst_type: CstType, definition_formal = ''): FormalOrderFields {
   return { id, alias, cst_type, definition_formal };
 }
 

package/src/library/rsform-api/formal-graph.ts

@@ -7,13 +7,13 @@ import { extractGlobals } from '../../rslang/api';
 import { CstType } from '../rsform';
 
 import { computeSemanticRelations } from './semantic-relations';
-import { type OrderableConstituenta, type SemanticRelations } from './types';
+import { type FormalOrderFields, type SemanticRelations } from './types';
 
 /**
  * Build the formal dependency graph: supplier → dependent.
  * Matches backend {@code RSForm.graph_formal}.
  */
-export function buildFormalDependencyGraph(items: readonly OrderableConstituenta[]): Graph<number> {
+export function buildFormalDependencyGraph(items: readonly FormalOrderFields[]): Graph<number> {
   const graph = new Graph<number>();
   const byAlias = new Map(items.map(cst => [cst.alias, cst]));
   for (const cst of items) {
@@ -36,7 +36,7 @@ export function buildFormalDependencyGraph(items: readonly OrderableConstituenta
  *
  * One Kahn pass over the formal dependency graph.
  */
-export function restoreConstituentOrder<T extends OrderableConstituenta>(
+export function restoreConstituentOrder<T extends FormalOrderFields>(
   items: readonly T[],
   graph: Graph<number> = buildFormalDependencyGraph(items),
   relations: SemanticRelations = computeSemanticRelations(items, graph)
@@ -77,9 +77,7 @@ export function restoreConstituentOrder<T extends OrderableConstituenta>(
   const pendingChildren: number[] = [];
 
   function enqueueSticky(candidateIds: readonly number[]): void {
-    const sticky = candidateIds.filter(
-      childId => ready.has(childId) && !pendingChildren.includes(childId)
-    );
+    const sticky = candidateIds.filter(childId => ready.has(childId) && !pendingChildren.includes(childId));
     sticky.sort((left, right) => (rank.get(left) ?? 0) - (rank.get(right) ?? 0));
     pendingChildren.push(...sticky);
   }
@@ -138,7 +136,7 @@ export function restoreConstituentOrder<T extends OrderableConstituenta>(
   return result;
 }
 
-function kernelPriority<T extends OrderableConstituenta>(
+function kernelPriority<T extends FormalOrderFields>(
   items: readonly T[],
   graph: Graph<number>,
   parentOf: Map<number, number>
@@ -176,9 +174,7 @@ function kernelPriority<T extends OrderableConstituenta>(
       const parentId = parentOf.get(cst.id) ?? cst.id;
       const parent = byId.get(parentId);
       return (
-        cst.cst_type === CstType.STRUCTURED ||
-        cst.cst_type === CstType.AXIOM ||
-        parent?.cst_type === CstType.STRUCTURED
+        cst.cst_type === CstType.STRUCTURED || cst.cst_type === CstType.AXIOM || parent?.cst_type === CstType.STRUCTURED
       );
     })
     .map(cst => cst.id);

package/src/library/rsform-api/index.ts

@@ -8,8 +8,8 @@ export {
   applyMappingToConstituents,
   argumentValuesToMapping,
   buildSequentialAliasMapping,
-  type ConstituentaMappableFields,
   generateAlias,
+  type MappableFields,
   maxAliasIndex,
   removeAliasReference,
   validateAliasFormat,
@@ -40,7 +40,7 @@ export {
   type InlineSynthesisInput,
   type InlineSynthesisResult,
   sortItemsForInlineSynthesis,
-  type SynthesizableConstituenta
+  type SynthesizableFields
 } from './synthesis';
 export {
   buildDefinitionReferenceGraph,
@@ -50,4 +50,19 @@ export {
   type TextChangeOptions
 } from './text-resolution';
 export { insertItemAfter, moveIdsInOrder, reorderItemsByIds } from './transforms';
-export type { AliasTypedConstituenta, OrderableConstituenta, ResolvableConstituenta, SemanticRelations } from './types';
+export type {
+  AliasTypedFields,
+  BasicTextCheckFields,
+  DescribableFields,
+  DiagnosticSourceFields,
+  FormalOrderFields,
+  ModelEvalFields,
+  SchemaIssueFields,
+  SearchableFields,
+  SemanticRelations,
+  SpawnPathFields,
+  StructureCapableFields,
+  TemplateParamSourceFields,
+  TemplateSourceFields,
+  TextResolvableFields
+} from './types';

package/src/library/rsform-api/semantic-relations.ts

@@ -8,16 +8,13 @@ import { CstType } from '../rsform';
 
 import { isBaseSet, isFunctional } from './cst-type';
 import { inferTemplate } from './expression';
-import { type OrderableConstituenta, type SemanticRelations } from './types';
+import { type FormalOrderFields, type SemanticRelations } from './types';
 
 /**
  * Infer semantic parent/children used for clustering during restore order.
  * Port of backend {@code SemanticInfo}.
  */
-export function computeSemanticRelations(
-  items: readonly OrderableConstituenta[],
-  graph: Graph<number>
-): SemanticRelations {
+export function computeSemanticRelations(items: readonly FormalOrderFields[], graph: Graph<number>): SemanticRelations {
   const byId = new Map(items.map(cst => [cst.id, cst]));
   const byAlias = new Map(items.map(cst => [cst.alias, cst]));
   const isTemplate = new Map<number, boolean>();
@@ -41,7 +38,7 @@ export function computeSemanticRelations(
     return !isFunctional(base.cst_type) || splitTemplateDefinition(base.definition_formal).head !== head;
   }
 
-  function extractSources(target: OrderableConstituenta): Set<number> {
+  function extractSources(target: FormalOrderFields): Set<number> {
     const sources = new Set<number>();
     if (!isFunctional(target.cst_type)) {
       for (const parentId of graph.at(target.id)?.inputs ?? []) {
@@ -76,7 +73,7 @@ export function computeSemanticRelations(
     return sources;
   }
 
-  function inferSimple(target: OrderableConstituenta): boolean {
+  function inferSimple(target: FormalOrderFields): boolean {
     if (target.cst_type === CstType.STRUCTURED || isBaseSet(target.cst_type)) {
       return false;
     }

package/src/library/rsform-api/stats.ts

@@ -4,12 +4,13 @@
 
 import { TypeID, type Typification, ValueClass } from '../../rslang';
 import { hasCstDiagnostic, RSDiagnosticCode } from '../diagnostics';
-import { type Constituenta, CstStatus, CstType, type RSForm, type RSFormStats } from '../rsform';
+import { CstStatus, CstType, type RSForm, type RSFormStats } from '../rsform';
 
 import { isBasicConcept, isLogical } from './cst-type';
+import { type BasicTextCheckFields, type SchemaIssueFields, type StructureCapableFields } from './types';
 
-/** Checks if {@link Constituenta} is a schema issue. */
-export function isSchemaIssue(cst: Constituenta): boolean {
+/** Checks if an item is a schema issue. */
+export function isSchemaIssue(cst: SchemaIssueFields): boolean {
   return (
     (cst.diagnostics?.length ?? 0) > 0 || cst.status === CstStatus.INCORRECT || cst.status === CstStatus.INCALCULABLE
   );
@@ -125,7 +126,7 @@ export function calculateSchemaStats(target: RSForm): RSFormStats {
   return stats;
 }
 
-function calculateStepComplexity(cst: Constituenta): number {
+function calculateStepComplexity(cst: StructureCapableFields): number {
   if (cst.cst_type === CstType.AXIOM || cst.cst_type === CstType.NOMINAL || !isBasicConcept(cst.cst_type)) {
     return 0;
   }
@@ -162,7 +163,7 @@ function calculateTypificationComplexity(type: Typification): number {
 }
 
 /** Non-logical basic concept missing convention and/or resolved term (trimmed). */
-function isMissingBasicText(cst: Constituenta): boolean {
+function isMissingBasicText(cst: BasicTextCheckFields): boolean {
   if (!isBasicConcept(cst.cst_type) || isLogical(cst.cst_type)) {
     return false;
   }

package/src/library/rsform-api/structure.ts

@@ -7,6 +7,8 @@ import { isTypification } from '../../rslang/semantic/typification';
 import { applyPath } from '../../rslang/semantic/typification-api';
 import { type Constituenta, type RSForm } from '../rsform';
 
+import { type SpawnPathFields, type StructureCapableFields } from './types';
+
 /**
  * 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.
@@ -21,8 +23,8 @@ export function inferNewSpawnPosition(schema: RSForm, targetId: number): number
   return last ?? targetId;
 }
 
-/** Finds {@link Constituenta} by structure path. */
-export function findCstByStructure(schema: RSForm, target: Constituenta, path: TypePath): Constituenta | null {
+/** Finds schema item by absolute structure path under `targetId`. */
+export function findCstByStructure(schema: RSForm, target: { id: number }, path: TypePath): Constituenta | null {
   const byId = schema.cstByID ?? new Map(schema.items.map(item => [item.id, item]));
   for (const cst of schema.items) {
     if (!cst.spawner_path) {
@@ -36,8 +38,12 @@ export function findCstByStructure(schema: RSForm, target: Constituenta, path: T
   return null;
 }
 
-/** Retrieves name for piece of target {@link Constituenta} structure. */
-export function getStructureName(schema: RSForm, target: Constituenta, path: TypePath): string {
+/** Retrieves name for piece of target structure. */
+export function getStructureName(
+  schema: RSForm,
+  target: StructureCapableFields & { id: number },
+  path: TypePath
+): string {
   const representation = findCstByStructure(schema, target, path);
   if (representation) {
     return `${representation.alias}: ${representation.term_resolved}`;
@@ -56,9 +62,9 @@ export function getStructureName(schema: RSForm, target: Constituenta, path: Typ
 }
 
 function resolveAbsoluteSpawnerPath(
-  cst: Constituenta,
+  cst: SpawnPathFields,
   targetId: number,
-  byId: Map<number, Constituenta>
+  byId: Map<number, SpawnPathFields>
 ): TypePath | null {
   if (!cst.spawner_path || cst.spawner == null) {
     return null;

package/src/library/rsform-api/substitution.ts

@@ -5,7 +5,7 @@
 import { type AliasMapping } from '../../rslang/api';
 import { type Attribution, type Substitution } from '../rsform';
 
-import { applyMappingToConstituents, type ConstituentaMappableFields } from './alias';
+import { applyMappingToConstituents, type MappableFields } from './alias';
 import { remapAttributionsUnderSubstitution } from './attribution';
 
 /** Result of applying substitutions to a schema fragment. */
@@ -21,7 +21,7 @@ export interface SubstitutionResult<T> {
  * Apply constituenta substitutions: remap attributions, drop originals, rewrite aliases in survivors.
  * Does not resolve texts — call {@link resolveAllConstituentTexts} afterwards.
  */
-export function applyConstituentSubstitutions<T extends ConstituentaMappableFields & { id: number; alias: string }>(
+export function applyConstituentSubstitutions<T extends MappableFields & { id: number; alias: string }>(
   items: readonly T[],
   attributions: readonly Attribution[],
   substitutions: readonly Substitution[]

package/src/library/rsform-api/synthesis.test.ts

@@ -1,8 +1,9 @@
 import { describe, expect, it } from 'vitest';
 
-import { CstType } from '../rsform';
+import { LibraryItemType } from '../library';
+import { CstType, type RSForm } from '../rsform';
 
-import { inlineSynthesis } from './synthesis';
+import { inlineSynthesis, sortItemsForInlineSynthesis } from './synthesis';
 
 function item(partial: {
   id: number;
@@ -124,3 +125,33 @@ describe('inlineSynthesis', () => {
     expect(result.items).not.toBe(receiver);
   });
 });
+
+describe('sortItemsForInlineSynthesis', () => {
+  function libraryItem(partial: { id: number; location: string; owner: number | null; visible: boolean }) {
+    return {
+      id: partial.id,
+      item_type: LibraryItemType.RSFORM,
+      alias: `S${partial.id}`,
+      title: `Item ${partial.id}`,
+      description: '',
+      visible: partial.visible,
+      read_only: false,
+      location: partial.location,
+      access_policy: 'public' as const,
+      time_create: '',
+      time_update: '',
+      owner: partial.owner
+    };
+  }
+
+  it('orders by location, then owner+visible, then visible, then rest', () => {
+    const receiver = { location: '/a', owner: 1 } as RSForm;
+    const sameLocation = libraryItem({ id: 1, location: '/a', owner: 99, visible: false });
+    const sameOwnerVisible = libraryItem({ id: 2, location: '/b', owner: 1, visible: true });
+    const otherVisible = libraryItem({ id: 3, location: '/c', owner: 2, visible: true });
+    const hidden = libraryItem({ id: 4, location: '/d', owner: 2, visible: false });
+
+    const sorted = sortItemsForInlineSynthesis(receiver, [hidden, otherVisible, sameOwnerVisible, sameLocation]);
+    expect(sorted.map(item => item.id)).toEqual([1, 2, 3, 4]);
+  });
+});

package/src/library/rsform-api/synthesis.ts

@@ -10,23 +10,23 @@ import { type AliasMapping } from '../../rslang/api';
 import { type LibraryItem } from '../library';
 import { type Attribution, type CstType, type RSForm, type Substitution } from '../rsform';
 
-import { allocateImportAliases, applyMappingToConstituents, type ConstituentaMappableFields } from './alias';
+import { allocateImportAliases, applyMappingToConstituents, type MappableFields } from './alias';
 import { importAttributions } from './attribution';
 import { applyConstituentSubstitutions, remapSubstitutionsAfterImport } from './substitution';
 import { resolveAllConstituentTexts } from './text-resolution';
-import { type AliasTypedConstituenta, type ResolvableConstituenta } from './types';
+import { type AliasTypedFields, type TextResolvableFields } from './types';
 
-/** Constituent shape required for embedding / synthesis transforms. */
-export type SynthesizableConstituenta = ConstituentaMappableFields &
-  ResolvableConstituenta &
-  AliasTypedConstituenta & {
+/** Field intersection required for embedding / synthesis transforms. */
+export type SynthesizableFields = MappableFields &
+  TextResolvableFields &
+  AliasTypedFields & {
     id: number;
     alias: string;
     cst_type: CstType;
   };
 
 /** Input for {@link inlineSynthesis}. */
-export interface InlineSynthesisInput<T extends SynthesizableConstituenta> {
+export interface InlineSynthesisInput<T extends SynthesizableFields> {
   /** Receiver schema constituents (order preserved; imports append). */
   receiverItems: readonly T[];
   /** Receiver attributions (default empty). */
@@ -49,7 +49,7 @@ export interface InlineSynthesisInput<T extends SynthesizableConstituenta> {
 }
 
 /** Result of {@link inlineSynthesis}. */
-export interface InlineSynthesisResult<T extends SynthesizableConstituenta> {
+export interface InlineSynthesisResult<T extends SynthesizableFields> {
   items: T[];
   attributions: Attribution[];
   /** Updated next-id after inserts. */
@@ -71,7 +71,7 @@ export interface InlineSynthesisResult<T extends SynthesizableConstituenta> {
  * Resolves term/definition entity references on the result.
  * Does not mutate inputs.
  */
-export function inlineSynthesis<T extends SynthesizableConstituenta>(
+export function inlineSynthesis<T extends SynthesizableFields>(
   input: InlineSynthesisInput<T>
 ): InlineSynthesisResult<T> {
   const sourceItems = input.sourceItems;
@@ -147,19 +147,23 @@ export function inlineSynthesis<T extends SynthesizableConstituenta>(
 /** Sorts library items relevant for schema embedding with specified {@link RSForm}. */
 export function sortItemsForInlineSynthesis(receiver: RSForm, items: readonly LibraryItem[]): LibraryItem[] {
   const result = items.filter(item => item.location === receiver.location);
+  const included = new Set(result);
   for (const item of items) {
-    if (item.visible && item.owner === receiver.owner && !result.includes(item)) {
+    if (item.visible && item.owner === receiver.owner && !included.has(item)) {
       result.push(item);
+      included.add(item);
     }
   }
   for (const item of items) {
-    if (item.visible && !result.includes(item)) {
+    if (item.visible && !included.has(item)) {
       result.push(item);
+      included.add(item);
     }
   }
   for (const item of items) {
-    if (!result.includes(item)) {
+    if (!included.has(item)) {
       result.push(item);
+      included.add(item);
     }
   }
   return result;

package/src/library/rsform-api/text-resolution.test.ts

@@ -1,11 +1,9 @@
 import { describe, expect, it } from 'vitest';
 
 import { resolveConstituentTextChange } from './text-resolution';
-import { type ResolvableConstituenta } from './types';
+import { type TextResolvableFields } from './types';
 
-function row(
-  data: Partial<ResolvableConstituenta> & Pick<ResolvableConstituenta, 'alias' | 'id'>
-): ResolvableConstituenta {
+function row(data: Partial<TextResolvableFields> & Pick<TextResolvableFields, 'alias' | 'id'>): TextResolvableFields {
   return {
     id: data.id,
     alias: data.alias,