@rsconcept/domain 2.0.2 → 2.1.1

package/dist/rslang/index.d.ts

@@ -1,13 +1,13 @@
 import { A as makeTypePath, b as Typification, d as EmptySetT, f as ExpressionType, g as TypeClass, m as LogicT, t as AnyTypificationT, v as TypeID, y as TypePath } from "../typification-9lNu9R4k.js";
-import { i as RSErrorDescription, r as RSErrorCode } from "../error-CzIbnP-N.js";
-import { i as readTypeAnnotation, r as readErrorAnnotation } from "../ast-annotations-D6KZDu12.js";
+import { i as RSErrorDescription, r as RSErrorCode } from "../error-B0EkIx4K.js";
+import { i as readTypeAnnotation, r as readErrorAnnotation } from "../ast-annotations-CiIx8qBM.js";
 import { d as ValuePath, l as Value, p as makeValuePath } from "../value-BduA_ZGp.js";
-import { n as CalculatorResult, r as RSCalculator, t as CalculatorEvaluateOptions } from "../calculator-k8BGIKmj.js";
+import { n as CalculatorResult, r as RSCalculator, t as CalculatorEvaluateOptions } from "../calculator-DE89LtIM.js";
 import { d as printValue } from "../value-api-CXLl_zg0.js";
 import { t as parser } from "../parser-Bwd8LxJ1.js";
 import { t as TokenID } from "../token-DeXAmzwr.js";
 import { t as ValueClass } from "../value-class-CNI-lqXJ.js";
-import { a as RSLangAnalyzer, n as AnalysisFast, r as AnalysisFull, t as AnalysisBase } from "../analyzer-iqAXyROE.js";
+import { a as RSLangAnalyzer, n as AnalysisFast, r as AnalysisFull, t as AnalysisBase } from "../analyzer-fNhkwO-6.js";
 import { n as ArgumentsType } from "../arguments-extractor-ngatANBI.js";
 import { n as applyAsciiTypeSubstitutions, r as parseTypeText } from "../typification-parser-Dytsv9CI.js";
 import { n as TypificationNodeData, t as TypificationGraph } from "../typification-graph-BY_oGT82.js";

package/dist/rslang/parser/syntax-errors/index.d.ts

@@ -1,6 +1,6 @@
 import { t as AstNode } from "../../../ast-C8sIpKdL.js";
 import { g as TypeClass } from "../../../typification-9lNu9R4k.js";
-import { t as ErrorReporter } from "../../../error-CzIbnP-N.js";
+import { t as ErrorReporter } from "../../../error-B0EkIx4K.js";
 
 //#region src/rslang/parser/syntax-errors/index.d.ts
 /** When set, refines incomplete formal headers (`[α∈…]`, quantifiers). */

package/dist/rslang/semantic/analyzer.d.ts

@@ -1,2 +1,2 @@
-import { a as RSLangAnalyzer, i as AnalysisOptions, n as AnalysisFast, r as AnalysisFull, t as AnalysisBase } from "../../analyzer-iqAXyROE.js";
+import { a as RSLangAnalyzer, i as AnalysisOptions, n as AnalysisFast, r as AnalysisFull, t as AnalysisBase } from "../../analyzer-fNhkwO-6.js";
 export { AnalysisBase, AnalysisFast, AnalysisFull, AnalysisOptions, RSLangAnalyzer };

package/dist/rslang/semantic/type-auditor.d.ts

@@ -1,6 +1,6 @@
 import { t as AstNode } from "../../ast-C8sIpKdL.js";
 import { _ as TypeContext, f as ExpressionType } from "../../typification-9lNu9R4k.js";
-import { t as ErrorReporter } from "../../error-CzIbnP-N.js";
+import { t as ErrorReporter } from "../../error-B0EkIx4K.js";
 
 //#region src/rslang/semantic/type-auditor.d.ts
 /** Type auditor for AST type checking. */

package/dist/rslang/semantic/value-auditor.d.ts

@@ -1,5 +1,5 @@
 import { t as AstNode } from "../../ast-C8sIpKdL.js";
-import { t as ErrorReporter } from "../../error-CzIbnP-N.js";
+import { t as ErrorReporter } from "../../error-B0EkIx4K.js";
 import { n as ValueClassContext, t as ValueClass } from "../../value-class-CNI-lqXJ.js";
 
 //#region src/rslang/semantic/value-auditor.d.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsconcept/domain",
-  "version": "2.0.2",
+  "version": "2.1.1",
   "description": "Shared TypeScript domain for RS language, RSForm, RSModel, RSEngine, OSS, and concept-text helpers.",
   "license": "MIT",
   "author": "IRBorisov",
@@ -154,6 +154,18 @@
     "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"
@@ -174,16 +186,5 @@
   },
   "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/cctext/language-api.test.ts

@@ -112,6 +112,11 @@ describe('Testing reference parsing', () => {
     expect(parseReference('@{0|derived term}')).toBeNull();
     expect(parseReference('@{-0|derived term}')).toBeNull();
     expect(parseReference('@{1|}')).toBeNull();
+    // Cyrillic А (U+0410) is not a syntactic offset; treat as entity alias
+    expect(parseReference('@{А55|sing,datv}')).toStrictEqual({
+      type: 'entity',
+      data: { entity: 'А55', tags: ['sing', 'datv'] }
+    });
   });
 });
 

package/src/cctext/language-api.ts

@@ -81,7 +81,7 @@ export function parseEntityReference(text: string): EntityReference {
   if (ref?.type !== ReferenceType.ENTITY) {
     throw new Error(`Invalid entity reference: ${text}`);
   }
-  return ref.data as EntityReference;
+  return ref.data;
 }
 
 /**
@@ -94,7 +94,7 @@ export function parseSyntacticReference(text: string): SyntacticReference {
   if (ref?.type !== ReferenceType.SYNTACTIC) {
     throw new Error(`Invalid syntactic reference: ${text}`);
   }
-  return ref.data as SyntacticReference;
+  return ref.data;
 }
 
 /** Extracts a validated reference from string representation. */
@@ -172,12 +172,12 @@ export function resolveTextReferences(text: string, context: TermContext): strin
 
   for (const ref of references) {
     if (ref.ref.type === ReferenceType.ENTITY) {
-      ref.resolved = resolveEntity(ref.ref.data as EntityReference, context);
+      ref.resolved = resolveEntity(ref.ref.data, context);
     }
   }
   references.forEach((ref, index) => {
     if (ref.ref.type === ReferenceType.SYNTACTIC) {
-      ref.resolved = resolveSyntactic(ref.ref.data as SyntacticReference, index, references);
+      ref.resolved = resolveSyntactic(ref.ref.data, index, references);
     }
   });
 
@@ -196,11 +196,11 @@ export function resolveTextReferences(text: string, context: TermContext): strin
 export function referenceToString(ref: IReference): string {
   switch (ref.type) {
     case ReferenceType.ENTITY: {
-      const entity = ref.data as EntityReference;
+      const entity = ref.data;
       return `@{${entity.entity}|${entity.tags.join(',')}}`;
     }
     case ReferenceType.SYNTACTIC: {
-      const syntactic = ref.data as SyntacticReference;
+      const syntactic = ref.data;
       return `@{${syntactic.offset}|${syntactic.nominal}}`;
     }
   }

package/src/cctext/language.ts

@@ -74,7 +74,6 @@ export interface SyntacticReference {
 }
 
 /** Represents abstract reference data. */
-export interface IReference {
-  type: ReferenceType;
-  data: EntityReference | SyntacticReference;
-}
+export type IReference =
+  | { type: typeof ReferenceType.ENTITY; data: EntityReference }
+  | { type: typeof ReferenceType.SYNTACTIC; data: SyntacticReference };

package/src/graph/graph.test.ts

@@ -374,6 +374,28 @@ describe('Testing Graph queries', () => {
     expect(graph.findCycle()).toStrictEqual(null);
   });
 
+  it('findCycles returns one closed path per cyclic SCC', () => {
+    const graph = new Graph([[1, 2], [2, 1], [3, 4], [4, 3], [5]]);
+    const cycles = graph.findCycles();
+    expect(cycles).toHaveLength(2);
+    expect(cycles.some(cycle => cycle[0] === cycle[cycle.length - 1] && cycle.includes(1) && cycle.includes(2))).toBe(
+      true
+    );
+    expect(cycles.some(cycle => cycle[0] === cycle[cycle.length - 1] && cycle.includes(3) && cycle.includes(4))).toBe(
+      true
+    );
+  });
+
+  it('findCycles reports self-loop', () => {
+    const graph = new Graph([[1, 1], [2]]);
+    expect(graph.findCycles()).toStrictEqual([[1, 1]]);
+  });
+
+  it('findCycles returns empty for acyclic graph', () => {
+    const graph = new Graph([[1, 2], [2, 3], [3]]);
+    expect(graph.findCycles()).toStrictEqual([]);
+  });
+
   it('sortStable should stably reorder node ids according to topological order', () => {
     const graph = new Graph([
       [1, 2],

package/src/graph/graph.ts

@@ -379,7 +379,7 @@ export class Graph<NodeID = number> {
    * Finds a cycle in the graph.
    *
    * @returns {NodeID[] | null} The cycle if found, otherwise `null`.
-   * Uses non-recursive DFS.
+   * Uses non-recursive DFS. The returned path is closed (first id equals last).
    */
   findCycle(): NodeID[] | null {
     const visited = new Set<NodeID>();
@@ -430,4 +430,118 @@ export class Graph<NodeID = number> {
     }
     return null;
   }
+
+  /**
+   * Finds one closed cycle path per cyclic strongly connected component.
+   *
+   * @returns Closed paths (first id equals last). Empty when the graph is acyclic.
+   */
+  findCycles(): NodeID[][] {
+    const components = this.stronglyConnectedComponents();
+    const result: NodeID[][] = [];
+    for (const component of components) {
+      if (component.length === 1) {
+        const id = component[0];
+        if (this.hasEdge(id, id)) {
+          result.push([id, id]);
+        }
+        continue;
+      }
+      const subgraph = new Graph<NodeID>();
+      const memberIds = new Set(component);
+      for (const id of component) {
+        subgraph.addNode(id);
+        const node = this.nodes.get(id);
+        if (!node) {
+          continue;
+        }
+        for (const child of node.outputs) {
+          if (memberIds.has(child)) {
+            subgraph.addEdge(id, child);
+          }
+        }
+      }
+      const cycle = subgraph.findCycle();
+      if (cycle) {
+        result.push(cycle);
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Tarjan strongly connected components (iterative).
+   *
+   * @returns Node-id arrays; multi-node components are cyclic SCCs, single-node
+   *   components are acyclic unless the node has a self-loop.
+   */
+  stronglyConnectedComponents(): NodeID[][] {
+    let index = 0;
+    const indices = new Map<NodeID, number>();
+    const lowlink = new Map<NodeID, number>();
+    const onStack = new Set<NodeID>();
+    const stack: NodeID[] = [];
+    const components: NodeID[][] = [];
+
+    /** Tarjan stack frame for iterative {@link Graph.stronglyConnectedComponents}. */
+    interface Frame {
+      nodeId: NodeID;
+      edgeIndex: number;
+      entered: boolean;
+    }
+    for (const startId of this.nodes.keys()) {
+      if (indices.has(startId)) {
+        continue;
+      }
+      const callStack: Frame[] = [{ nodeId: startId, edgeIndex: 0, entered: false }];
+      while (callStack.length > 0) {
+        const frame = callStack[callStack.length - 1];
+        const node = this.nodes.get(frame.nodeId);
+        if (!node) {
+          callStack.pop();
+          continue;
+        }
+
+        if (!frame.entered) {
+          frame.entered = true;
+          indices.set(frame.nodeId, index);
+          lowlink.set(frame.nodeId, index);
+          index += 1;
+          stack.push(frame.nodeId);
+          onStack.add(frame.nodeId);
+        }
+
+        if (frame.edgeIndex < node.outputs.length) {
+          const child = node.outputs[frame.edgeIndex];
+          frame.edgeIndex += 1;
+          if (!indices.has(child)) {
+            callStack.push({ nodeId: child, edgeIndex: 0, entered: false });
+          } else if (onStack.has(child)) {
+            lowlink.set(frame.nodeId, Math.min(lowlink.get(frame.nodeId)!, indices.get(child)!));
+          }
+          continue;
+        }
+
+        callStack.pop();
+        if (callStack.length > 0) {
+          const parentId = callStack[callStack.length - 1].nodeId;
+          lowlink.set(parentId, Math.min(lowlink.get(parentId)!, lowlink.get(frame.nodeId)!));
+        }
+
+        if (lowlink.get(frame.nodeId) === indices.get(frame.nodeId)) {
+          const component: NodeID[] = [];
+          while (stack.length > 0) {
+            const id = stack.pop()!;
+            onStack.delete(id);
+            component.push(id);
+            if (id === frame.nodeId) {
+              break;
+            }
+          }
+          components.push(component);
+        }
+      }
+    }
+    return components;
+  }
 }

package/src/index.ts

@@ -11,7 +11,9 @@ export { Graph } from './graph/graph';
 export {
   assignSchemaDiagnostics,
   type CstDiagnostic,
+  detectDependencyCycleDiagnostics,
   DiagnosticKind,
+  formatDependencyCycle,
   hasCstDiagnostic,
   modelStatusCstDiagnostic,
   RSDiagnosticCode

package/src/library/diagnostics.test.ts

@@ -1,8 +1,11 @@
 import { describe, expect, it } from 'vitest';
 
+import { Graph } from '../graph';
+
 import {
   assignSchemaDiagnostics,
   DiagnosticKind,
+  formatDependencyCycle,
   hasCstDiagnostic,
   modelStatusCstDiagnostic,
   RSDiagnosticCode
@@ -82,4 +85,35 @@ describe('assignSchemaDiagnostics', () => {
       'D2'
     );
   });
+
+  it('detects dependency cycles when graph is provided', () => {
+    const items = [
+      stubCst(1, 'F3', { cst_type: CstType.TERM, definition_formal: 'P1' }),
+      stubCst(2, 'P1', { cst_type: CstType.AXIOM, definition_formal: 'F3' }),
+      stubCst(3, 'X1', { convention: 'base', term_resolved: 'base' })
+    ];
+    const graph = new Graph([[1, 2], [2, 1], [3]]);
+    const resolveAlias = (id: number) => items.find(item => item.id === id)!.alias;
+
+    assignSchemaDiagnostics(items, resolveAlias, new Map(), graph);
+
+    expect(hasCstDiagnostic(items[0], RSDiagnosticCode.schemaDependencyCycle)).toBe(true);
+    expect(hasCstDiagnostic(items[1], RSDiagnosticCode.schemaDependencyCycle)).toBe(true);
+    expect(hasCstDiagnostic(items[2], RSDiagnosticCode.schemaDependencyCycle)).toBe(false);
+    const cycle = items[0].diagnostics.find(item => item.code === RSDiagnosticCode.schemaDependencyCycle)?.params?.[0];
+    expect(cycle).toBeDefined();
+    expect(cycle!.includes('F3')).toBe(true);
+    expect(cycle!.includes('P1')).toBe(true);
+    expect(cycle!.startsWith(cycle!.split(' → ').at(-1)!)).toBe(true);
+  });
+});
+
+describe('formatDependencyCycle', () => {
+  it('joins aliases with arrows', () => {
+    expect(formatDependencyCycle(['F3', 'P1', 'F3'])).toBe('F3 → P1 → F3');
+  });
+
+  it('uses the same text regardless of cycle rotation', () => {
+    expect(formatDependencyCycle(['P1', 'F3', 'P1'])).toBe('F3 → P1 → F3');
+  });
 });

package/src/library/diagnostics.ts

@@ -2,6 +2,7 @@
  * Module: Compact diagnostics for constituents (schema and model issue codes).
  */
 
+import { type Graph } from '../graph';
 import { labelType } from '../rslang/labels';
 
 import { type Constituenta, type CstType } from './rsform';
@@ -23,6 +24,7 @@ export const RSDiagnosticCode = {
   schemaMissingConvention: 0x8903,
   schemaMissingTerm: 0x8904,
   schemaTypeMismatch: 0x8905,
+  schemaDependencyCycle: 0x8906,
 
   modelEmpty: 0x8910,
   modelAxiomFalse: 0x8911,
@@ -45,20 +47,27 @@ export function hasCstDiagnostic(cst: Constituenta, code: RSDiagnosticCode): boo
 }
 
 /**
- * Populate `diagnostics` on each constituent (homonyms, duplicates, metadata, type mismatch).
+ * Populate `diagnostics` on each constituent (homonyms, duplicates, metadata, type mismatch, cycles).
  *
  * Requires normalized formal definitions for duplicate detection (same as Portal loader).
+ * When `graph` is provided, dependency cycles are reported as {@link RSDiagnosticCode.schemaDependencyCycle}.
  */
 export function assignSchemaDiagnostics(
   items: Constituenta[],
   resolveAlias: (id: number) => string,
-  normalizedDefinitions: ReadonlyMap<number, string>
+  normalizedDefinitions: ReadonlyMap<number, string>,
+  graph?: Graph
 ): void {
   const homonymById = detectHomonymDiagnostics(items, resolveAlias);
   const duplicateById = detectFormalDuplicateDiagnostics(items, resolveAlias, normalizedDefinitions);
+  const cycleById = graph ? detectDependencyCycleDiagnostics(graph, resolveAlias) : new Map<number, CstDiagnostic>();
 
   for (const cst of items) {
     const diagnostics: CstDiagnostic[] = [];
+    const cycle = cycleById.get(cst.id);
+    if (cycle) {
+      diagnostics.push(cycle);
+    }
     const homonym = homonymById.get(cst.id);
     if (homonym) {
       diagnostics.push(homonym);
@@ -72,6 +81,76 @@ export function assignSchemaDiagnostics(
   }
 }
 
+/**
+ * Format a closed dependency cycle as `A → B → A`.
+ *
+ * Rotates the path to start at the lexicographically smallest alias so the same
+ * cycle always renders identically regardless of graph traversal order.
+ *
+ * @param aliases Closed or open alias path from {@link Graph.findCycles}.
+ * @returns Human-readable cycle text joined with ` → `.
+ */
+export function formatDependencyCycle(aliases: readonly string[]): string {
+  if (aliases.length < 2) {
+    return aliases.join(' → ');
+  }
+
+  const closed = aliases[0] === aliases[aliases.length - 1];
+  const open = closed ? aliases.slice(0, -1) : [...aliases];
+  if (open.length === 0) {
+    return aliases.join(' → ');
+  }
+
+  let bestStart = 0;
+  for (let index = 1; index < open.length; index++) {
+    const alias = open[index];
+    const bestAlias = open[bestStart];
+    if (alias !== undefined && bestAlias !== undefined && alias < bestAlias) {
+      bestStart = index;
+    }
+  }
+  const rotated = [...open.slice(bestStart), ...open.slice(0, bestStart)];
+  if (closed) {
+    const first = rotated[0];
+    if (first !== undefined) {
+      rotated.push(first);
+    }
+  }
+  return rotated.join(' → ');
+}
+
+/**
+ * Map each node id that participates in a dependency cycle to a schema diagnostic.
+ *
+ * `params[0]` is the closed cycle path (`F3 → P1 → F3`).
+ *
+ * @param graph Constituent dependency graph (provider → dependent edges).
+ * @param resolveAlias Maps node id to display alias for cycle formatting.
+ * @returns One {@link CstDiagnostic} per node on each cyclic SCC.
+ */
+export function detectDependencyCycleDiagnostics(
+  graph: Graph,
+  resolveAlias: (id: number) => string
+): Map<number, CstDiagnostic> {
+  const result = new Map<number, CstDiagnostic>();
+  for (const cycle of graph.findCycles()) {
+    if (cycle.length < 2) {
+      continue;
+    }
+    const aliases = cycle.map(id => resolveAlias(id));
+    const cycleText = formatDependencyCycle(aliases);
+    const memberIds = new Set(cycle);
+    for (const id of memberIds) {
+      result.set(id, {
+        kind: DiagnosticKind.SCHEMA,
+        code: RSDiagnosticCode.schemaDependencyCycle,
+        params: [cycleText]
+      });
+    }
+  }
+  return result;
+}
+
 /** Map a model evaluation status to a compact diagnostic, or `null` when not an issue. */
 export function modelStatusCstDiagnostic(status: EvalStatus, cstType: CstType): CstDiagnostic | null {
   const code = modelStatusToCode(status, cstType);

package/src/library/index.ts

@@ -1,7 +1,9 @@
 export {
   assignSchemaDiagnostics,
   type CstDiagnostic,
+  detectDependencyCycleDiagnostics,
   DiagnosticKind,
+  formatDependencyCycle,
   hasCstDiagnostic,
   modelStatusCstDiagnostic,
   RSDiagnosticCode

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

@@ -1,9 +1,18 @@
 import { describe, expect, it } from 'vitest';
 
+import { Graph } from '../graph';
 import { RSErrorCode } from '../rslang/error';
-
-import { CstType, type RSForm } from './rsform';
-import { applyMappingToConstituents, getAnalysisFor, normalizeExpression, validateAliasFormat } from './rsform-api';
+import { RSLangAnalyzer } from '../rslang/semantic/analyzer';
+
+import { RSDiagnosticCode } from './diagnostics';
+import { type Constituenta, CstType, type RSForm } from './rsform';
+import {
+  applyMappingToConstituents,
+  findCstByStructure,
+  getAnalysisFor,
+  normalizeExpression,
+  validateAliasFormat
+} from './rsform-api';
 
 const emptySchema = {} as RSForm;
 
@@ -49,6 +58,56 @@ describe('getAnalysisFor', () => {
       params: [CstType.CONSTANT, 'C1']
     });
   });
+
+  it('upgrades to dependency cycle for unsaved draft that closes a cycle', () => {
+    // Saved graph: F3 → P1 only (P1 does not yet reference F3).
+    // Draft for P1 introduces F3, closing F3 ↔ P1 before Save.
+    const analyzer = new RSLangAnalyzer();
+    analyzer.addBase('X1');
+    // F3 is untyped in the analyzer (as after a failed cycle parse), so P1's call fails.
+    const items = [
+      {
+        id: 1,
+        alias: 'X1',
+        cst_type: CstType.BASE,
+        definition_formal: '',
+        diagnostics: []
+      },
+      {
+        id: 2,
+        alias: 'F3',
+        cst_type: CstType.FUNCTION,
+        definition_formal: '[σ∈X1] P1[σ]',
+        diagnostics: []
+      },
+      {
+        id: 3,
+        alias: 'P1',
+        cst_type: CstType.PREDICATE,
+        definition_formal: '[σ∈X1] σ=σ',
+        diagnostics: []
+      }
+    ] as unknown as Constituenta[];
+    const graph = new Graph([
+      [1, 2],
+      [1, 3],
+      [3, 2] // P1 → F3 from saved F3 definition
+    ]);
+    const schema = {
+      items,
+      graph,
+      analyzer,
+      cstByAlias: new Map(items.map(item => [item.alias, item])),
+      cstByID: new Map(items.map(item => [item.id, item]))
+    } as unknown as RSForm;
+
+    const draft = '[σ∈X1] F3[σ]=F3[σ]';
+    const result = getAnalysisFor(draft, CstType.PREDICATE, schema, 'P1');
+    const cycleError = result.errors.find(error => error.code === RSDiagnosticCode.schemaDependencyCycle);
+    expect(cycleError).toBeDefined();
+    expect(cycleError!.params?.[0]).toContain('F3');
+    expect(cycleError!.params?.[0]).toContain('P1');
+  });
 });
 
 describe('applyMappingToConstituents', () => {
@@ -98,3 +157,40 @@ describe('normalizeExpression', () => {
     expect(normalizeExpression('ℬ(X1)', CstType.STRUCTURED)).toBeNull();
   });
 });
+
+describe('findCstByStructure', () => {
+  function makeProjectionChainSchema() {
+    const s1 = { id: 1, alias: 'S1' };
+    const d1 = { id: 2, alias: 'D1', spawner: 1, spawner_path: [0, 1] };
+    const d2 = { id: 3, alias: 'D2', spawner: 2, spawner_path: [2] };
+    const d3 = { id: 4, alias: 'D3', spawner: 3, spawner_path: [1] };
+    const d4 = { id: 5, alias: 'D4', spawner: 4, spawner_path: [2] };
+    const schema = {
+      items: [s1, d1, d2, d3, d4],
+      cstByID: new Map([
+        [1, s1],
+        [2, d1],
+        [3, d2],
+        [4, d3],
+        [5, d4]
+      ])
+    } as unknown as RSForm;
+    return { schema, s1, d1, d2, d3, d4 };
+  }
+
+  it('resolves chain of relative projection paths to root target', () => {
+    const { schema, s1, d2 } = makeProjectionChainSchema();
+
+    expect(findCstByStructure(schema, s1 as never, [0, 1, 2] as never)).toBe(d2);
+  });
+
+  it('resolves a four-step projection chain from the root structure', () => {
+    const { schema, s1, d1, d2, d3, d4 } = makeProjectionChainSchema();
+
+    expect(findCstByStructure(schema, s1 as never, [0, 1] as never)).toBe(d1);
+    expect(findCstByStructure(schema, s1 as never, [0, 1, 2] as never)).toBe(d2);
+    expect(findCstByStructure(schema, s1 as never, [0, 1, 2, 1] as never)).toBe(d3);
+    expect(findCstByStructure(schema, s1 as never, [0, 1, 2, 1, 2] as never)).toBe(d4);
+    expect(findCstByStructure(schema, s1 as never, [0, 1, 2, 2] as never)).toBeNull();
+  });
+});