@rsconcept/domain 3.0.0 → 3.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsconcept/domain",
-  "version": "3.0.0",
+  "version": "3.0.2",
   "description": "Shared TypeScript domain for RS language, RSForm, RSModel, RSEngine, OSS, and concept-text helpers.",
   "license": "MIT",
   "author": "IRBorisov",
@@ -154,37 +154,36 @@
     "README.md",
     "LICENSE"
   ],
-  "scripts": {
-    "generate": "lezer-generator src/rslang/parser/rslang.grammar -o src/rslang/parser/parser.ts",
-    "build": "tsdown",
-    "dev": "tsdown --watch",
-    "typecheck": "tsc -p tsconfig.json --noEmit",
-    "test": "vitest run",
-    "lint": "eslint . --report-unused-disable-directives --max-warnings 0",
-    "lintFix": "eslint . --report-unused-disable-directives --max-warnings 0 --fix",
-    "format": "prettier --write \"src/**/*.ts\" \"*.{ts,js}\"",
-    "format:check": "prettier --check \"src/**/*.ts\" \"*.{ts,js}\"",
-    "prepublishOnly": "pnpm run build"
-  },
   "dependencies": {
     "@lezer/common": "^1.5.2",
     "@lezer/lr": "^1.4.10"
   },
   "devDependencies": {
     "@lezer/generator": "^1.8.0",
-    "@types/node": "^26.1.0",
-    "@typescript-eslint/parser": "^8.0.1",
-    "eslint": "^9.39.4",
+    "@types/node": "^26.1.1",
+    "@typescript-eslint/parser": "^8.63.0",
+    "eslint": "^9.39.5",
     "eslint-plugin-simple-import-sort": "^13.0.0",
     "globals": "^17.7.0",
-    "prettier": "^3.9.4",
-    "tsdown": "^0.22.3",
+    "prettier": "^3.9.5",
+    "tsdown": "^0.22.4",
     "typescript": "^6.0.3",
-    "typescript-eslint": "^8.62.1",
+    "typescript-eslint": "^8.63.0",
     "unrun": "^0.3.1",
-    "vitest": "^4.1.9"
+    "vitest": "^4.1.10"
   },
   "publishConfig": {
     "access": "public"
+  },
+  "scripts": {
+    "generate": "lezer-generator src/rslang/parser/rslang.grammar -o src/rslang/parser/parser.ts",
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run",
+    "lint": "eslint . --report-unused-disable-directives --max-warnings 0",
+    "lintFix": "eslint . --report-unused-disable-directives --max-warnings 0 --fix",
+    "format": "prettier --write \"src/**/*.ts\" \"*.{ts,js}\"",
+    "format:check": "prettier --check \"src/**/*.ts\" \"*.{ts,js}\""
   }
-}
+}

package/src/library/diagnostics.ts

@@ -19,7 +19,7 @@ export const DiagnosticKind = {
 } as const;
 export type DiagnosticKind = (typeof DiagnosticKind)[keyof typeof DiagnosticKind];
 
-/** Schema and model diagnostic codes (same numeric format as {@link RSErrorCode}). */
+/** Schema, model, and substitution-table diagnostic codes (same numeric format as {@link RSErrorCode}). */
 export const RSDiagnosticCode = {
   schemaHomonym: 0x8901,
   schemaFormalDuplicate: 0x8902,
@@ -31,7 +31,21 @@ export const RSDiagnosticCode = {
   modelEmpty: 0x8910,
   modelAxiomFalse: 0x8911,
   modelInvalidData: 0x8912,
-  modelEvalFail: 0x8913
+  modelEvalFail: 0x8913,
+
+  substitutionInvalidIDs: 0x8920,
+  substitutionIncorrectCst: 0x8921,
+  substitutionInvalidClasses: 0x8922,
+  substitutionInvalidBasic: 0x8923,
+  substitutionInvalidConstant: 0x8924,
+  substitutionTypificationCycle: 0x8925,
+  substitutionBaseNotSet: 0x8926,
+  substitutionUnequalTypification: 0x8927,
+  /** Non-blocking warning: formal definitions differ after mapping. */
+  substitutionUnequalExpressions: 0x2928,
+  substitutionUnequalArgsCount: 0x8929,
+  substitutionUnequalArgs: 0x892a,
+  substitutionInvalidNominal: 0x892b
 } as const;
 export type RSDiagnosticCode = (typeof RSDiagnosticCode)[keyof typeof RSDiagnosticCode];
 

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/src/library/rsmodel-api.test.ts

@@ -0,0 +1,79 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import { type Value } from '../rslang';
+import { compare, TUPLE_ID } from '../rslang/eval/value';
+import { isTupleValue } from '../rslang/eval/value-api';
+import { basic, bool, IntegerT, tuple } from '../rslang/semantic/typification';
+
+import { type BasicBinding } from './rsmodel';
+import { generateRandomValue } from './rsmodel-api';
+
+function hasUniqueElements(value: Value[]): boolean {
+  const sorted = [...value].sort(compare);
+  for (let i = 1; i < sorted.length; i++) {
+    if (compare(sorted[i - 1], sorted[i]) === 0) {
+      return false;
+    }
+  }
+  return true;
+}
+
+describe('generateRandomValue', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('returns unique elements for collections even when samples collide', () => {
+    const basics = new Map<number, BasicBinding>([[10, { 1: 'x1', 2: 'x2' }]]);
+    const cstByAlias = new Map([['X1', { id: 10 }]]);
+    const collectionType = bool(basic('X1'));
+
+    // Force: size=5, then always pick the same base element id=1.
+    const random = vi.spyOn(Math, 'random');
+    random
+      .mockReturnValueOnce(0.99) // -> 5 elements
+      .mockReturnValue(0); // -> always ids[0] === 1
+
+    const value = generateRandomValue(collectionType, basics, cstByAlias, 5);
+    expect(Array.isArray(value)).toBe(true);
+    expect(value).toEqual([1]);
+    expect(hasUniqueElements(value as Value[])).toBe(true);
+  });
+
+  it('returns unique nested sets for tuple of collections ℬ(X1)×ℬ(C1)', () => {
+    const basics = new Map<number, BasicBinding>([
+      [10, { 1: 'x1', 2: 'x2' }],
+      [20, { 0: 'c0', 1: 'c1', 2: 'c2' }]
+    ]);
+    const cstByAlias = new Map([
+      ['X1', { id: 10 }],
+      ['C1', { id: 20 }]
+    ]);
+    const type = tuple([bool(basic('X1')), bool(basic('C1'))]);
+
+    for (let attempt = 0; attempt < 30; attempt++) {
+      const value = generateRandomValue(type, basics, cstByAlias, 10);
+      expect(isTupleValue(value)).toBe(true);
+      const tupleValue = value as Value[];
+      expect(tupleValue[0]).toBe(TUPLE_ID);
+      expect(Array.isArray(tupleValue[1])).toBe(true);
+      expect(Array.isArray(tupleValue[2])).toBe(true);
+      expect(hasUniqueElements(tupleValue[1] as Value[])).toBe(true);
+      expect(hasUniqueElements(tupleValue[2] as Value[])).toBe(true);
+    }
+  });
+
+  it('returns null when a basic domain is empty', () => {
+    const basics = new Map<number, BasicBinding>();
+    const cstByAlias = new Map([['X1', { id: 10 }]]);
+    expect(generateRandomValue(basic('X1'), basics, cstByAlias)).toBeNull();
+    expect(generateRandomValue(bool(basic('X1')), basics, cstByAlias)).toBeNull();
+  });
+
+  it('generates integers in range', () => {
+    const value = generateRandomValue(IntegerT, new Map(), new Map());
+    expect(typeof value).toBe('number');
+    expect(value as number).toBeGreaterThanOrEqual(-100);
+    expect(value as number).toBeLessThanOrEqual(100);
+  });
+});

package/src/library/rsmodel-api.ts

@@ -1,5 +1,5 @@
 import { type ExpressionType, TypeID, type Typification, type Value } from '../rslang';
-import { compare, tuple, TUPLE_ID, VALUE_TRUE, type ValuePath } from '../rslang/eval/value';
+import { compare, set, tuple, TUPLE_ID, VALUE_TRUE, type ValuePath } from '../rslang/eval/value';
 import { extractValue, isTupleValue, makeDefaultValue, setNestedValue } from '../rslang/eval/value-api';
 import { type EchelonCollection } from '../rslang/semantic/typification';
 
@@ -80,7 +80,8 @@ export function generateRandomValue(
         }
         result.push(sample);
       }
-      return result;
+      // Sets must be unique; sampling with replacement can produce duplicates.
+      return set(result);
     }
     case TypeID.anyTypification:
       return null;

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 { };