@rsconcept/domain 3.0.0 → 3.0.1

package/src/library/oss-api.test.ts

@@ -2,14 +2,16 @@ import { describe, expect, it } from 'vitest';
 
 import { Graph } from '../graph';
 
+import { SubstitutionErrorType } from './oss';
 import { SubstitutionValidator } from './oss-api';
 import { type Constituenta, CstClass, CstType, type RSForm } from './rsform';
 
 function mockConstituenta(
-  partial: Pick<Constituenta, 'id' | 'alias' | 'definition_formal' | 'cst_class' | 'cst_type'>
+  partial: Pick<Constituenta, 'id' | 'alias' | 'definition_formal' | 'cst_class' | 'cst_type'> &
+    Partial<Pick<Constituenta, 'schema'>>
 ): Constituenta {
   return {
-    schema: 790,
+    schema: partial.schema ?? 790,
     crucial: false,
     convention: '',
     definition_raw: '',
@@ -37,11 +39,16 @@ function mockConstituenta(
   };
 }
 
-function mockSchema(items: Constituenta[]): RSForm {
+function mockSchema(items: Constituenta[], edges: number[][] = [], id = 790, alias = 'S1'): RSForm {
   const graph = new Graph(items.map(item => [item.id]));
+  for (const edge of edges) {
+    if (edge.length === 2) {
+      graph.addEdge(edge[0], edge[1]);
+    }
+  }
   return {
-    id: 790,
-    alias: 'S1',
+    id,
+    alias,
     items,
     graph,
     cstByAlias: new Map(items.map(item => [item.alias, item]))
@@ -72,4 +79,92 @@ describe('SubstitutionValidator', () => {
     expect(() => validator.validate()).not.toThrow();
     expect(validator.validate()).toBe(true);
   });
+
+  it('reports definitionCycle when identification closes a formal dependency loop', () => {
+    // D16 := F2[D15]  ⇒ edge D15 → D16; identifying D15 → D16 yields D16 := F2[D16]
+    const schema = mockSchema(
+      [
+        mockConstituenta({
+          id: 1,
+          alias: 'X1',
+          cst_class: CstClass.BASIC,
+          cst_type: CstType.BASE,
+          definition_formal: ''
+        }),
+        mockConstituenta({
+          id: 2,
+          alias: 'F2',
+          cst_class: CstClass.DERIVED,
+          cst_type: CstType.FUNCTION,
+          definition_formal: '[α∈X1] α'
+        }),
+        mockConstituenta({
+          id: 3,
+          alias: 'D15',
+          cst_class: CstClass.DERIVED,
+          cst_type: CstType.TERM,
+          definition_formal: 'X1'
+        }),
+        mockConstituenta({
+          id: 4,
+          alias: 'D16',
+          cst_class: CstClass.DERIVED,
+          cst_type: CstType.TERM,
+          definition_formal: 'F2[D15]'
+        })
+      ],
+      [
+        [2, 4],
+        [3, 4]
+      ]
+    );
+
+    const validator = new SubstitutionValidator([schema], [{ original: 3, substitution: 4 }]);
+
+    expect(validator.validate()).toBe(false);
+    expect(validator.errors).toEqual([
+      {
+        code: SubstitutionErrorType.definitionCycle,
+        params: ['D16 → D16']
+      }
+    ]);
+    expect(SubstitutionErrorType.definitionCycle).toBe(0x8906);
+  });
+
+  it('allows identification that does not create a definition cycle', () => {
+    const schema = mockSchema(
+      [
+        mockConstituenta({
+          id: 1,
+          alias: 'X1',
+          cst_class: CstClass.BASIC,
+          cst_type: CstType.BASE,
+          definition_formal: ''
+        }),
+        mockConstituenta({
+          id: 2,
+          alias: 'D1',
+          cst_class: CstClass.DERIVED,
+          cst_type: CstType.TERM,
+          definition_formal: 'X1'
+        }),
+        mockConstituenta({
+          id: 3,
+          alias: 'D2',
+          cst_class: CstClass.DERIVED,
+          cst_type: CstType.TERM,
+          definition_formal: 'X1'
+        })
+      ],
+      [
+        [1, 2],
+        [1, 3]
+      ]
+    );
+
+    const validator = new SubstitutionValidator([schema], [{ original: 2, substitution: 3 }]);
+
+    expect(validator.validate()).toBe(true);
+    expect(validator.errors.every(error => error.code !== SubstitutionErrorType.definitionCycle)).toBe(true);
+  });
 });

package/src/library/oss-api.ts

@@ -7,6 +7,7 @@ import { type AliasMapping, applyAliasMapping, applyTypificationMapping, isSetTy
 import { labelType } from '../rslang/labels';
 import { extractBases } from '../rslang/semantic/typification-api';
 
+import { formatDependencyCycle } from './diagnostics';
 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';
@@ -101,7 +102,10 @@ export class SubstitutionValidator {
     if (!this.checkTypes()) {
       return false;
     }
-    if (!this.checkCycles()) {
+    if (!this.checkTypificationCycles()) {
+      return false;
+    }
+    if (!this.checkDefinitionCycles()) {
       return false;
     }
     if (!this.checkSubstitutions()) {
@@ -238,7 +242,11 @@ export class SubstitutionValidator {
     return true;
   }
 
-  private checkCycles(): boolean {
+  /**
+   * Detect cycles among base/constant sets implied by typifications of non-base
+   * constituents under the substitution table.
+   */
+  private checkTypificationCycles(): boolean {
     const graph = new Graph();
     for (const schema of this.schemas) {
       for (const cst of schema.items) {
@@ -286,6 +294,64 @@ export class SubstitutionValidator {
     return true;
   }
 
+  /**
+   * Detect logical cycles in formal definitions after applying the substitution table
+   * (e.g. D16 := F2[D15] with identification D15 → D16 yields D16 := F2[D16]).
+   */
+  private checkDefinitionCycles(): boolean {
+    const graph = new Graph();
+    for (const schema of this.schemas) {
+      for (const [id, node] of schema.graph.nodes) {
+        graph.addNode(id);
+        for (const output of node.outputs) {
+          graph.addEdge(id, output);
+        }
+      }
+    }
+
+    const deleted = new Map<number, number>();
+    for (const item of this.substitutions) {
+      deleted.set(item.original, item.substitution);
+    }
+    const resolve = (id: number): number => deleted.get(id) ?? id;
+
+    const result = new Graph();
+    for (const id of graph.nodes.keys()) {
+      if (!deleted.has(id)) {
+        result.addNode(id);
+      }
+    }
+    for (const substitutionId of deleted.values()) {
+      result.addNode(substitutionId);
+    }
+
+    for (const [id, node] of graph.nodes) {
+      for (const output of node.outputs) {
+        if (deleted.has(output)) {
+          continue;
+        }
+        result.addEdge(resolve(id), output);
+      }
+    }
+
+    const cycle = result.findCycle();
+    if (cycle !== null) {
+      const aliases = cycle.map(id => {
+        const cst = this.cstByID.get(id);
+        if (!cst) {
+          return String(id);
+        }
+        if (this.schemas.length > 1) {
+          const schema = this.schemaByID.get(cst.schema);
+          return schema ? `[${schema.alias}]-${cst.alias}` : cst.alias;
+        }
+        return cst.alias;
+      });
+      return this.reportError(SubstitutionErrorType.definitionCycle, [formatDependencyCycle(aliases)]);
+    }
+    return true;
+  }
+
   private checkSubstitutions(): boolean {
     const baseMappings = this.prepareBaseMappings();
     const typeMappings = this.calculateSubstituteMappings(baseMappings);
@@ -407,10 +473,10 @@ export class SubstitutionValidator {
     return expression1.replace(/\s+/g, '') === expression2.replace(/\s+/g, '');
   }
 
-  private reportError(errorType: SubstitutionErrorType, params: string[]): boolean {
+  private reportError(code: SubstitutionErrorType, params: string[]): boolean {
     this.errors.push({
-      errorType: errorType,
-      params: params
+      code,
+      params
     });
     return false;
   }

package/src/library/oss.ts

@@ -4,6 +4,7 @@
 
 import { type Graph } from '../graph';
 
+import { RSDiagnosticCode } from './diagnostics';
 import { type LibraryItem } from './library';
 import { type NodePosition, type OssLayout } from './oss-layout';
 
@@ -126,25 +127,30 @@ export interface OperationSchema extends LibraryItem {
   itemByNodeID: Map<string, OssItem>;
 }
 
-/** Represents substitution error description. */
+/** Represents substitution error description (same code space as {@link RSDiagnosticCode}). */
 export interface SubstitutionErrorDescription {
-  errorType: SubstitutionErrorType;
+  code: SubstitutionErrorType;
   params: string[];
 }
 
-/** Represents Substitution table error types. */
+/**
+ * Substitution-table error codes — aliases into {@link RSDiagnosticCode}.
+ * Logical definition cycles reuse {@link RSDiagnosticCode.schemaDependencyCycle}.
+ */
 export const SubstitutionErrorType = {
-  invalidIDs: 0,
-  incorrectCst: 1,
-  invalidClasses: 2,
-  invalidBasic: 3,
-  invalidConstant: 4,
-  typificationCycle: 5,
-  baseSubstitutionNotSet: 6,
-  unequalTypification: 7,
-  unequalExpressions: 8,
-  unequalArgsCount: 9,
-  unequalArgs: 10,
-  invalidNominal: 11
-} as const;
+  invalidIDs: RSDiagnosticCode.substitutionInvalidIDs,
+  incorrectCst: RSDiagnosticCode.substitutionIncorrectCst,
+  invalidClasses: RSDiagnosticCode.substitutionInvalidClasses,
+  invalidBasic: RSDiagnosticCode.substitutionInvalidBasic,
+  invalidConstant: RSDiagnosticCode.substitutionInvalidConstant,
+  typificationCycle: RSDiagnosticCode.substitutionTypificationCycle,
+  baseSubstitutionNotSet: RSDiagnosticCode.substitutionBaseNotSet,
+  unequalTypification: RSDiagnosticCode.substitutionUnequalTypification,
+  unequalExpressions: RSDiagnosticCode.substitutionUnequalExpressions,
+  unequalArgsCount: RSDiagnosticCode.substitutionUnequalArgsCount,
+  unequalArgs: RSDiagnosticCode.substitutionUnequalArgs,
+  invalidNominal: RSDiagnosticCode.substitutionInvalidNominal,
+  /** Same code as constituent schema dependency cycle. */
+  definitionCycle: RSDiagnosticCode.schemaDependencyCycle
+} as const satisfies Record<string, (typeof RSDiagnosticCode)[keyof typeof RSDiagnosticCode]>;
 export type SubstitutionErrorType = (typeof SubstitutionErrorType)[keyof typeof SubstitutionErrorType];

package/dist/index-BKZ67WMa.d.ts

@@ -1 +0,0 @@
-export { };

package/dist/index-BVVgDSdq.d.ts

@@ -1 +0,0 @@
-export { };

package/dist/index-DmtQKWjk.d.ts

@@ -1 +0,0 @@
-export { };

package/dist/index-_6s0AX1B.d.ts

@@ -1 +0,0 @@
-export { };