@rsconcept/domain 3.1.0 → 3.2.0

package/src/index.ts

@@ -80,8 +80,9 @@ export {
   visitAstDFS
 } from './parsing/ast';
 export { type CMSyntaxNode, printTree } from './parsing/lezer-tree';
+export { DELETED_ALIAS } from './rslang/api';
 export { readErrorAnnotation, readTypeAnnotation } from './rslang/ast-annotations';
-export { type EvalStackFrame, formatEvalCallStack,RSErrorCode, type RSErrorDescription } from './rslang/error';
+export { type EvalStackFrame, formatEvalCallStack, RSErrorCode, type RSErrorDescription } from './rslang/error';
 export { type CalculatorEvaluateOptions, type CalculatorResult, RSCalculator } from './rslang/eval/calculator';
 export { makeValuePath, TUPLE_ID, type Value, type ValuePath } from './rslang/eval/value';
 export { printValue } from './rslang/eval/value-api';

package/src/library/rsengine.test.ts

@@ -0,0 +1,164 @@
+import { describe, expect, it } from 'vitest';
+
+import { Graph } from '../graph';
+import { RSLangAnalyzer } from '../rslang/semantic/analyzer';
+import { basic } from '../rslang/semantic/typification';
+
+import { RSEngine } from './rsengine';
+import { type Constituenta, CstClass, CstType, type RSForm } from './rsform';
+import { EvalStatus, type RSModel, TYPE_BASIC } from './rsmodel';
+
+function mockConstituenta(
+  partial: Pick<Constituenta, 'id' | 'alias' | 'cst_type'> & Partial<Constituenta>
+): Constituenta {
+  return {
+    schema: 1,
+    crucial: false,
+    convention: '',
+    definition_formal: '',
+    definition_raw: '',
+    definition_resolved: '',
+    term_raw: '',
+    term_resolved: '',
+    term_forms: [],
+    typification_manual: '',
+    value_is_property: false,
+    diagnostics: [],
+    analysis: { success: true } as Constituenta['analysis'],
+    effectiveType: null,
+    is_type_mismatch: false,
+    status: 'verified',
+    is_template: false,
+    is_simple_expression: true,
+    parent_schema_index: 0,
+    parent_schema: null,
+    is_inherited: false,
+    has_inherited_children: false,
+    attributes: [],
+    spawn: [],
+    spawn_alias: [],
+    cst_class: CstClass.BASIC,
+    ...partial
+  };
+}
+
+function mockSchema(items: Constituenta[]): RSForm {
+  const analyzer = new RSLangAnalyzer();
+  for (const item of items) {
+    if (item.cst_type === CstType.BASE) {
+      analyzer.addBase(item.alias);
+    }
+  }
+  return {
+    id: 1,
+    items,
+    analyzer,
+    graph: new Graph(items.map(item => [item.id])),
+    cstByAlias: new Map(items.map(item => [item.alias, item])),
+    cstByID: new Map(items.map(item => [item.id, item]))
+  } as RSForm;
+}
+
+function mockModel(items: RSModel['items']): RSModel {
+  return { id: 10, schema: 1, items } as RSModel;
+}
+
+function createEngine(): RSEngine {
+  return new RSEngine(10, {
+    setCstValue: () => Promise.resolve(),
+    clearValues: () => Promise.resolve()
+  });
+}
+
+describe('RSEngine.setBasicValue', () => {
+  it('awaits setCstValue before clearValues when dependents must reset', async () => {
+    const x1 = mockConstituenta({ id: 1, alias: 'X1', cst_type: CstType.BASE });
+    const s1 = mockConstituenta({
+      id: 2,
+      alias: 'S1',
+      cst_type: CstType.STRUCTURED,
+      cst_class: CstClass.BASIC,
+      // Non-number value cannot be reconciled with a basic domain shrink, so it must be cleared.
+      effectiveType: basic('X1')
+    });
+    const order: string[] = [];
+    let releaseSet!: () => void;
+    const setGate = new Promise<void>(resolve => {
+      releaseSet = resolve;
+    });
+    const engine = new RSEngine(10, {
+      setCstValue: async () => {
+        order.push('set-start');
+        await setGate;
+        order.push('set-end');
+      },
+      clearValues: () => {
+        order.push('clear');
+        return Promise.resolve();
+      }
+    });
+    const schema = mockSchema([x1, s1]);
+    schema.graph = new Graph([[1], [2], [1, 2]]);
+    engine.loadData(
+      schema,
+      mockModel([
+        { id: 1, type: TYPE_BASIC, value: { 1: 'a', 2: 'b' } },
+        { id: 2, type: 'X1', value: [1, 2] }
+      ])
+    );
+
+    const pending = engine.setBasicValue(1, { 9: 'only-new' });
+    expect(order).toEqual(['set-start']);
+    releaseSet();
+    await pending;
+    expect(order).toEqual(['set-start', 'set-end', 'clear']);
+  });
+});
+
+describe('RSEngine.loadData', () => {
+  it('applies basic bindings for constituents that exist in the schema', () => {
+    const x1 = mockConstituenta({ id: 1, alias: 'X1', cst_type: CstType.BASE });
+    const engine = createEngine();
+
+    engine.loadData(mockSchema([x1]), mockModel([{ id: 1, type: TYPE_BASIC, value: { 1: 'a', 2: 'b' } }]));
+
+    expect(engine.basics.get(1)).toEqual({ 1: 'a', 2: 'b' });
+    expect(engine.getCstValue(1)).toEqual([1, 2]);
+  });
+
+  it('skips value items whose constituent is missing from the schema', () => {
+    const x1 = mockConstituenta({ id: 1, alias: 'X1', cst_type: CstType.BASE });
+    const engine = createEngine();
+
+    expect(() =>
+      engine.loadData(
+        mockSchema([x1]),
+        mockModel([
+          { id: 1, type: TYPE_BASIC, value: { 1: 'a' } },
+          { id: 35772, type: 'ℬ(X1)', value: [1] }
+        ])
+      )
+    ).not.toThrow();
+
+    expect(engine.basics.get(1)).toEqual({ 1: 'a' });
+    expect(engine.getCstValue(1)).toEqual([1]);
+    expect(engine.getCstValue(35772)).toBeNull();
+  });
+
+  it('skips basic bindings attached to a non-base constituent', () => {
+    const s1 = mockConstituenta({
+      id: 2,
+      alias: 'S1',
+      cst_type: CstType.STRUCTURED,
+      cst_class: CstClass.BASIC
+    });
+    const engine = createEngine();
+
+    expect(() =>
+      engine.loadData(mockSchema([s1]), mockModel([{ id: 2, type: TYPE_BASIC, value: { 1: 'a' } }]))
+    ).not.toThrow();
+
+    expect(engine.basics.size).toBe(0);
+    expect(engine.getCstStatus(2)).toBe(EvalStatus.INVALID_DATA);
+  });
+});

package/src/library/rsengine.ts

@@ -62,8 +62,8 @@ export class RSEngine {
       this.onChangeDefinitions(changedCst);
     }
     if (this.data !== model) {
+      this.prepareValues(model);
       this.data = model;
-      this.prepareValues();
     }
     this.notifyAll();
   }
@@ -225,13 +225,11 @@ export class RSEngine {
       }
     }
 
+    // Sequential writes: both endpoints share the model concurrency token.
+    // A parallel pair would send the same expected time_update and the second would 409.
+    await this.services.setCstValue({ itemID: this.modelID, data: updateList });
     if (resetList.length > 0) {
-      await Promise.all([
-        this.services.setCstValue({ itemID: this.modelID, data: updateList }),
-        this.services.clearValues({ itemID: this.modelID, data: { items: resetList } })
-      ]);
-    } else {
-      await this.services.setCstValue({ itemID: this.modelID, data: updateList });
+      await this.services.clearValues({ itemID: this.modelID, data: { items: resetList } });
     }
     const changed = [...resetList, ...updateList.map(item => item.target)];
 
@@ -386,29 +384,32 @@ export class RSEngine {
     }
   }
 
-  private prepareValues(): void {
+  private prepareValues(model: RSModel): void {
     this.basics.clear();
     this.invalidData.clear();
     this.calculatedSet.clear();
 
-    for (const item of this.data!.items) {
-      const cst = this.schema!.cstByID.get(item.id)!;
-      if (item.type === TYPE_BASIC) {
-        if (cst.cst_type !== CstType.BASE && cst.cst_type !== CstType.CONSTANT) {
-          throw new Error(`Invalid data for ${cst.alias}`);
-        }
-        const data = item.value as BasicBinding;
-        this.basics.set(cst.id, data);
-        this.calculator.setValue(cst.alias, Object.keys(data).map(Number));
+    for (const item of model.items) {
+      const cst = this.schema?.cstByID.get(item.id);
+      if (!cst || item.type !== TYPE_BASIC) {
+        continue;
+      }
+      if (!isBaseSet(cst.cst_type)) {
+        this.invalidData.add(item.id);
+        continue;
       }
+      const data = item.value as BasicBinding;
+      this.basics.set(cst.id, data);
+      this.calculator.setValue(cst.alias, Object.keys(data).map(Number));
     }
-    for (const item of this.data!.items) {
-      const cst = this.schema!.cstByID.get(item.id)!;
-      if (item.type !== TYPE_BASIC) {
-        this.calculator.setValue(cst.alias, item.value as Value);
-        if (!cst.effectiveType || !this.calculator.validate(item.value as Value, cst.effectiveType)) {
-          this.invalidData.add(item.id);
-        }
+    for (const item of model.items) {
+      const cst = this.schema?.cstByID.get(item.id);
+      if (!cst || item.type === TYPE_BASIC) {
+        continue;
+      }
+      this.calculator.setValue(cst.alias, item.value as Value);
+      if (!cst.effectiveType || !this.calculator.validate(item.value as Value, cst.effectiveType)) {
+        this.invalidData.add(item.id);
       }
     }
     this.setupEmptySets();

package/src/rslang/api.ts

@@ -8,6 +8,9 @@ import { parser as rslangParser } from './parser/parser';
 import { ArgumentsExtractor, type ArgumentsType } from './semantic/arguments-extractor';
 export { generateExpressionFromAst } from './parser/expression-generator';
 
+/** Placeholder alias written into expressions in place of references to deleted constituents. */
+export const DELETED_ALIAS = 'DEL';
+
 /** Represents alias mapping. */
 export type AliasMapping = Record<string, string>;
 

package/src/rslang/error.ts

@@ -105,6 +105,7 @@ export const RSErrorCode = {
   invalidCard: 0x8808, // 34824
   invalidDebool: 0x8809, // 34825
   globalFuncWithoutArgs: 0x880b, // 34827
+  globalDeleted: 0x880c, // 34828
   invalidReduce: 0x8810, // 34832
   invalidEnumeration: 0x8813, // 34835
   projectionSetArgumentNotSet: 0x8830, // 34864

package/src/rslang/index.ts

@@ -1,5 +1,6 @@
+export { DELETED_ALIAS } from './api';
 export { readErrorAnnotation, readTypeAnnotation } from './ast-annotations';
-export { type EvalStackFrame, formatEvalCallStack,RSErrorCode, type RSErrorDescription } from './error';
+export { type EvalStackFrame, formatEvalCallStack, RSErrorCode, type RSErrorDescription } from './error';
 export { type CalculatorEvaluateOptions, type CalculatorResult, RSCalculator } from './eval/calculator';
 export { makeValuePath, type Value, type ValuePath } from './eval/value';
 export { printValue } from './eval/value-api';

package/src/rslang/parser/parser.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, it } from 'vitest';
 
 import { buildTree, printTree } from '../../parsing';
+import { DELETED_ALIAS } from '../api';
 import { RSErrorCode, type RSErrorDescription } from '../error';
 import { TypeClass } from '../semantic/typification';
 
@@ -68,6 +69,10 @@ const testError = [
   ['!', '[Expression[⚠]]']
 ];
 
+function deletedReferenceAt(from: number): RSErrorDescription {
+  return { code: RSErrorCode.globalDeleted, from, to: from + DELETED_ALIAS.length, params: [DELETED_ALIAS] };
+}
+
 const testErrorData = [
   ['(', { code: RSErrorCode.missingCloseBracket, from: 0, to: 1, params: ['('] }],
   ['{X1', { code: RSErrorCode.missingCloseBracket, from: 0, to: 1, params: ['{'] }],
@@ -86,6 +91,10 @@ const testErrorData = [
   ['?', { code: RSErrorCode.forbiddenCharacter, from: 0, to: 1, params: ['?'] }],
   ['16=2^4', { code: RSErrorCode.forbiddenCharacter, from: 4, to: 5, params: ['^'] }],
   ['16=2/4', { code: RSErrorCode.forbiddenCharacter, from: 4, to: 5, params: ['/'] }],
+  [DELETED_ALIAS, deletedReferenceAt(0)],
+  [`X1∪${DELETED_ALIAS}`, deletedReferenceAt(3)],
+  [`F1[${DELETED_ALIAS}]`, deletedReferenceAt(3)],
+  [`∀ξ∈${DELETED_ALIAS} ξ∈X1`, deletedReferenceAt(3)],
   ['Fi1(S1)', { code: RSErrorCode.invalidFilterSyntax, from: 0, to: 4 }],
   ['[α∈ℬ(X1×X1)]', { code: RSErrorCode.expectedFunctionBody, from: 12, to: 12 }]
 ];
@@ -283,6 +292,35 @@ describe('Testing RSParser error data', () => {
     });
   });
 
+  it('Reports every reference to a deleted constituent instead of syntax errors', () => {
+    const input = `${DELETED_ALIAS}∪X1 = ${DELETED_ALIAS}^2`;
+    const tree = parser.parse(input);
+    const ast = buildTree(tree.cursor());
+    const errors: RSErrorDescription[] = [];
+    extractSyntaxErrors(ast, input, error => errors.push(error));
+
+    expect(errors).toEqual([
+      deletedReferenceAt(0),
+      deletedReferenceAt(input.lastIndexOf(DELETED_ALIAS)),
+      {
+        code: RSErrorCode.forbiddenCharacter,
+        from: input.indexOf('^'),
+        to: input.indexOf('^') + 1,
+        params: ['^']
+      }
+    ]);
+  });
+
+  it('Does not treat identifiers containing the deleted alias as deleted references', () => {
+    const input = `${DELETED_ALIAS}X1`;
+    const tree = parser.parse(input);
+    const ast = buildTree(tree.cursor());
+    const errors: RSErrorDescription[] = [];
+    extractSyntaxErrors(ast, input, error => errors.push(error));
+
+    expect(errors.some(error => error.code === RSErrorCode.globalDeleted)).toBe(false);
+  });
+
   it('Reports a single forbidden-character error for exponentiation', () => {
     const input = '[σ∈S2]I{γ | ξ:∈ℬ(σ); γ:=(ξ×{1})∪((σ\\ξ)×{0}); 16=2^4}';
     const tree = parser.parse(input);

package/src/rslang/parser/syntax-errors/README.md

@@ -8,7 +8,7 @@ Classifiers must handle both grammar terms (`parser.terms`) and `TokenID` values
 
 ## Pipeline (`index.ts`)
 
-1. **Forbidden characters** — scan the source string; if any illegal symbol is found, report only those errors and stop.
+1. **Text-level checks** — scan the source string for references to deleted constituents (`DELETED_ALIAS`, semantic code `globalDeleted`) and forbidden characters; if any are found, report only those errors and stop.
 2. **AST walk** — for each `ERROR` node, run classifiers (`classify.ts`) or fall back to `unknownSyntax` / `expectedLocal`.
 3. **Bracket pass** — one expression-level bracket diagnostic (`missingCloseBracket`, `bracketMismatch`, …), unless an incomplete D/I/R body was already reported (generator may legally end with `}` while brackets look wrong).
 4. **Deduplication** — drop overlaps; prefer specific codes over `unknownSyntax`; keep a single `unknownSyntax` when several ERROR nodes fire.
@@ -54,7 +54,7 @@ Fallback: `expectedLocal` under `Variable`; otherwise `unknownSyntax` (`0x8400`)
 | `trailing-slot.ts`       | Reusable incomplete-trailing-body detector                  |
 | `ast-utils.ts`           | Tree navigation, node predicates, bracket matching          |
 | `error-builders.ts`      | `errorAt`, text-token helpers                               |
-| `expression-errors.ts`   | Forbidden chars, brackets, dedup                            |
+| `expression-errors.ts`   | Deleted references, forbidden chars, brackets, dedup        |
 | `incomplete-formal.ts`   | `[…]` declarations, quantifiers                             |
 | `incomplete-operands.ts` | Operators, `ℬ()`, bracket argument lists                    |
 | `generators.ts`          | D{…}, I{…}, R{…} incomplete bodies                          |

package/src/rslang/parser/syntax-errors/expression-errors.ts

@@ -2,6 +2,7 @@
  * Expression-level diagnostics (no AST required) and error deduplication.
  */
 
+import { DELETED_ALIAS } from '../../api';
 import { RSErrorCode, type RSErrorDescription } from '../../error';
 
 type OpenBracket = '(' | '[' | '{';
@@ -64,6 +65,23 @@ export function extractForbiddenCharacterErrors(expression: string): RSErrorDesc
   return errors;
 }
 
+/** Matches {@link DELETED_ALIAS} as a standalone identifier (not a part of a longer name). */
+const DELETED_ALIAS_REGEXP = new RegExp(`(?<![\\p{L}\\p{N}_])${DELETED_ALIAS}(?![\\p{L}\\p{N}_])`, 'gu');
+
+/** Reports every reference to a deleted constituent ({@link DELETED_ALIAS}) in the expression. */
+export function extractDeletedReferenceErrors(expression: string): RSErrorDescription[] {
+  const errors: RSErrorDescription[] = [];
+  for (const match of expression.matchAll(DELETED_ALIAS_REGEXP)) {
+    errors.push({
+      code: RSErrorCode.globalDeleted,
+      from: match.index,
+      to: match.index + match[0].length,
+      params: [match[0]]
+    });
+  }
+  return errors;
+}
+
 export function extractBracketErrors(expression: string): RSErrorDescription | null {
   const stack: BracketFrame[] = [];
 

package/src/rslang/parser/syntax-errors/index.ts

@@ -14,7 +14,12 @@ import { type TypeClass } from '../../semantic/typification';
 import { TokenID } from '../token';
 
 import { classifyFallbackError, classifyParseError } from './classify';
-import { deduplicateErrors, extractBracketErrors, extractForbiddenCharacterErrors } from './expression-errors';
+import {
+  deduplicateErrors,
+  extractBracketErrors,
+  extractDeletedReferenceErrors,
+  extractForbiddenCharacterErrors
+} from './expression-errors';
 import { isIncompleteGeneratorBodyCode } from './generators';
 
 /** When set, refines incomplete formal headers (`[α∈…]`, quantifiers). */
@@ -38,9 +43,11 @@ export function extractSyntaxErrors(
   annotateErrors: boolean = false,
   options?: SyntaxErrorOptions
 ) {
-  const forbiddenErrors = extractForbiddenCharacterErrors(expression);
-  if (forbiddenErrors.length > 0) {
-    for (const error of forbiddenErrors) {
+  // Deleted references and forbidden characters make the AST meaningless: report only them.
+  const textErrors = [...extractDeletedReferenceErrors(expression), ...extractForbiddenCharacterErrors(expression)];
+  if (textErrors.length > 0) {
+    textErrors.sort((left, right) => left.from - right.from);
+    for (const error of textErrors) {
       reporter(error);
       if (annotateErrors) {
         annotateError(ast, error.code, error.params);