@rsconcept/domain 2.2.0 → 3.0.0

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

@@ -4,14 +4,19 @@
 
 export {
   addAliasReference,
+  allocateImportAliases,
   applyMappingToConstituents,
   argumentValuesToMapping,
+  buildSequentialAliasMapping,
   generateAlias,
+  type MappableFields,
+  maxAliasIndex,
   removeAliasReference,
   validateAliasFormat,
   validateNewAlias
 } from './alias';
 export { getAnalysisFor, refineAnalysisForDependencyCycles } from './analysis';
+export { filterAttributions, importAttributions, remapAttributionsUnderSubstitution } from './attribution';
 export {
   canHaveManualTypification,
   canProduceStructure,
@@ -26,7 +31,38 @@ export {
   typeClassForCstType
 } from './cst-type';
 export { applyFilterCategory, inferStatus, inferTemplate, inferTemplatedType, normalizeExpression } from './expression';
-export { restoreConstituentOrder } from './formal-graph';
+export { buildFormalDependencyGraph, restoreConstituentOrder } from './formal-graph';
 export { calculateSchemaStats, isSchemaIssue } from './stats';
 export { findCstByStructure, getStructureName, inferNewSpawnPosition } from './structure';
-export { sortItemsForInlineSynthesis } from './synthesis';
+export { applyConstituentSubstitutions, remapSubstitutionsAfterImport, type SubstitutionResult } from './substitution';
+export {
+  inlineSynthesis,
+  type InlineSynthesisInput,
+  type InlineSynthesisResult,
+  sortItemsForInlineSynthesis,
+  type SynthesizableFields
+} from './synthesis';
+export {
+  buildDefinitionReferenceGraph,
+  buildTermReferenceGraph,
+  resolveAllConstituentTexts,
+  resolveConstituentTextChange,
+  type TextChangeOptions
+} from './text-resolution';
+export { insertItemAfter, moveIdsInOrder, reorderItemsByIds } from './transforms';
+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

@@ -0,0 +1,82 @@
+/**
+ * Constituenta substitution and post-import substitution remapping.
+ */
+
+import { type AliasMapping } from '../../rslang/api';
+import { type Attribution, type Substitution } from '../rsform';
+
+import { applyMappingToConstituents, type MappableFields } from './alias';
+import { remapAttributionsUnderSubstitution } from './attribution';
+
+/** Result of applying substitutions to a schema fragment. */
+export interface SubstitutionResult<T> {
+  items: T[];
+  attributions: Attribution[];
+  deletedIds: Set<number>;
+  /** Replacement constituent ids (survivors referenced by substitutions). */
+  replacementIds: number[];
+}
+
+/**
+ * Apply constituenta substitutions: remap attributions, drop originals, rewrite aliases in survivors.
+ * Does not resolve texts — call {@link resolveAllConstituentTexts} afterwards.
+ */
+export function applyConstituentSubstitutions<T extends MappableFields & { id: number; alias: string }>(
+  items: readonly T[],
+  attributions: readonly Attribution[],
+  substitutions: readonly Substitution[]
+): SubstitutionResult<T> {
+  if (substitutions.length === 0) {
+    return {
+      items: [...items],
+      attributions: attributions.map(attr => ({ ...attr })),
+      deletedIds: new Set(),
+      replacementIds: []
+    };
+  }
+
+  const byId = new Map(items.map(cst => [cst.id, cst]));
+  const mapping: AliasMapping = {};
+  const deletedIds = new Set<number>();
+  const origToSub = new Map<number, number>();
+  const replacementIds: number[] = [];
+
+  for (const { original, substitution } of substitutions) {
+    const originalCst = byId.get(original);
+    const substitutionCst = byId.get(substitution);
+    if (!originalCst || !substitutionCst) {
+      throw new Error(`applyConstituentSubstitutions: unknown constituenta ${original} -> ${substitution}`);
+    }
+    mapping[originalCst.alias] = substitutionCst.alias;
+    deletedIds.add(original);
+    origToSub.set(original, substitution);
+    replacementIds.push(substitution);
+  }
+
+  const nextItems = items.filter(cst => !deletedIds.has(cst.id));
+  applyMappingToConstituents(nextItems, mapping, false);
+
+  return {
+    items: nextItems,
+    attributions: remapAttributionsUnderSubstitution(attributions, origToSub),
+    deletedIds,
+    replacementIds
+  };
+}
+
+/**
+ * Remap substitution endpoints after source constituents were inserted under new ids.
+ * If {@link original} was imported, map it; otherwise map {@link substitution}.
+ */
+export function remapSubstitutionsAfterImport(
+  substitutions: readonly Substitution[],
+  sourceIdSet: ReadonlySet<number>,
+  idMap: Readonly<Record<number, number>>
+): Substitution[] {
+  return substitutions.map(sub => {
+    if (sourceIdSet.has(sub.original)) {
+      return { original: idMap[sub.original], substitution: sub.substitution };
+    }
+    return { original: sub.original, substitution: idMap[sub.substitution] };
+  });
+}

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

@@ -0,0 +1,157 @@
+import { describe, expect, it } from 'vitest';
+
+import { LibraryItemType } from '../library';
+import { CstType, type RSForm } from '../rsform';
+
+import { inlineSynthesis, sortItemsForInlineSynthesis } from './synthesis';
+
+function item(partial: {
+  id: number;
+  alias: string;
+  cst_type: CstType;
+  definition_formal?: string;
+  term_raw?: string;
+  definition_raw?: string;
+}) {
+  return {
+    id: partial.id,
+    alias: partial.alias,
+    cst_type: partial.cst_type,
+    definition_formal: partial.definition_formal ?? '',
+    typification_manual: '',
+    term_raw: partial.term_raw ?? '',
+    term_resolved: partial.term_raw ?? '',
+    term_forms: [] as { text: string; tags: string }[],
+    definition_raw: partial.definition_raw ?? '',
+    definition_resolved: partial.definition_raw ?? ''
+  };
+}
+
+describe('inlineSynthesis', () => {
+  it('keeps source aliases when receiver is empty', () => {
+    const result = inlineSynthesis({
+      receiverItems: [],
+      sourceItems: [item({ id: 10, alias: 'X9', cst_type: CstType.BASE, term_raw: 'person' })],
+      nextId: 1
+    });
+
+    expect(result.items).toHaveLength(1);
+    expect(result.items[0].alias).toBe('X9');
+    expect(result.items[0].id).toBe(1);
+    expect(result.idMap).toEqual({ 10: 1 });
+    expect(result.nextId).toBe(2);
+    expect(result.aliasMapping).toEqual({});
+  });
+
+  it('allocates fresh aliases when receiver is non-empty', () => {
+    const result = inlineSynthesis({
+      receiverItems: [item({ id: 1, alias: 'X2', cst_type: CstType.BASE })],
+      sourceItems: [item({ id: 10, alias: 'X9', cst_type: CstType.BASE, term_raw: 'source' })],
+      nextId: 100
+    });
+
+    expect(result.items).toHaveLength(2);
+    expect(result.items[1].alias).toBe('X3');
+    expect(result.items[1].id).toBe(100);
+    expect(result.aliasMapping).toEqual({ X9: 'X3' });
+  });
+
+  it('applies substitutions after import (source original → receiver survivor)', () => {
+    const result = inlineSynthesis({
+      receiverItems: [item({ id: 1, alias: 'X1', cst_type: CstType.BASE, term_raw: 'keep' })],
+      sourceItems: [
+        item({
+          id: 20,
+          alias: 'X1',
+          cst_type: CstType.BASE,
+          term_raw: 'drop',
+          definition_formal: ''
+        })
+      ],
+      substitutions: [{ original: 20, substitution: 1 }],
+      nextId: 50
+    });
+
+    expect(result.items).toHaveLength(1);
+    expect(result.items[0].id).toBe(1);
+    expect(result.items[0].term_raw).toBe('keep');
+    expect(result.deletedIds).toEqual(new Set([50]));
+    expect(result.replacementIds).toEqual([1]);
+  });
+
+  it('remaps formal references when importing into non-empty receiver', () => {
+    const result = inlineSynthesis({
+      receiverItems: [item({ id: 1, alias: 'X1', cst_type: CstType.BASE })],
+      sourceItems: [
+        item({ id: 10, alias: 'X1', cst_type: CstType.BASE }),
+        item({
+          id: 11,
+          alias: 'S1',
+          cst_type: CstType.STRUCTURED,
+          definition_formal: 'ℬ(X1)'
+        })
+      ],
+      nextId: 2
+    });
+
+    const structured = result.items.find(cst => cst.cst_type === CstType.STRUCTURED)!;
+    expect(structured.alias).toBe('S1');
+    expect(structured.definition_formal).toBe('ℬ(X2)');
+  });
+
+  it('imports attributions with id remapping', () => {
+    const result = inlineSynthesis({
+      receiverItems: [item({ id: 1, alias: 'X1', cst_type: CstType.BASE })],
+      receiverAttributions: [],
+      sourceItems: [
+        item({ id: 10, alias: 'X1', cst_type: CstType.BASE }),
+        item({ id: 11, alias: 'S1', cst_type: CstType.STRUCTURED })
+      ],
+      sourceAttributions: [{ container: 10, attribute: 11 }],
+      nextId: 2
+    });
+
+    expect(result.attributions).toEqual([{ container: 2, attribute: 3 }]);
+  });
+
+  it('returns a clone when source is empty', () => {
+    const receiver = [item({ id: 1, alias: 'X1', cst_type: CstType.BASE })];
+    const result = inlineSynthesis({
+      receiverItems: receiver,
+      sourceItems: [],
+      nextId: 2
+    });
+    expect(result.items).toEqual(receiver);
+    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

@@ -1,26 +1,169 @@
 /**
- * Inline synthesis helpers for library item selection.
+ * Schema embedding (synthesis): insert constituents from a source schema into a receiver,
+ * then apply an identification (substitution) table.
+ *
+ * Mirrors backend `inline_synthesis` / `insert_from` + `substitute`
+ * (Portal UI: «Встраивание схемы»).
  */
 
+import { type AliasMapping } from '../../rslang/api';
 import { type LibraryItem } from '../library';
-import { type RSForm } from '../rsform';
+import { type Attribution, type CstType, type RSForm, type Substitution } from '../rsform';
 
-/** Sorts library items relevant for InlineSynthesis with specified {@link RSForm}. */
+import { allocateImportAliases, applyMappingToConstituents, type MappableFields } from './alias';
+import { importAttributions } from './attribution';
+import { applyConstituentSubstitutions, remapSubstitutionsAfterImport } from './substitution';
+import { resolveAllConstituentTexts } from './text-resolution';
+import { type AliasTypedFields, type TextResolvableFields } from './types';
+
+/** 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 SynthesizableFields> {
+  /** Receiver schema constituents (order preserved; imports append). */
+  receiverItems: readonly T[];
+  /** Receiver attributions (default empty). */
+  receiverAttributions?: readonly Attribution[];
+  /**
+   * Source constituents to insert (already filtered to the desired subset).
+   * Cloned; originals are not mutated.
+   */
+  sourceItems: readonly T[];
+  /** Source attributions whose both endpoints are among {@link sourceItems}. */
+  sourceAttributions?: readonly Attribution[];
+  /**
+   * Identification table using pre-import ids:
+   * one endpoint is a source id, the other a receiver id
+   * (same rules as backend embedding / InlineSynthesis).
+   */
+  substitutions?: readonly Substitution[];
+  /** Next free numeric id for inserted constituents. */
+  nextId: number;
+}
+
+/** Result of {@link inlineSynthesis}. */
+export interface InlineSynthesisResult<T extends SynthesizableFields> {
+  items: T[];
+  attributions: Attribution[];
+  /** Updated next-id after inserts. */
+  nextId: number;
+  /** Source id → inserted id. */
+  idMap: Record<number, number>;
+  /** Alias remapping applied to imported constituents (empty when receiver was empty). */
+  aliasMapping: AliasMapping;
+  /** Ids removed by substitutions. */
+  deletedIds: Set<number>;
+  /** Ids of newly inserted constituents (before any were deleted by substitutions). */
+  insertedIds: number[];
+  /** Survivor ids referenced by applied substitutions. */
+  replacementIds: number[];
+}
+
+/**
+ * Embed {@link InlineSynthesisInput.sourceItems} into the receiver and apply substitutions.
+ * Resolves term/definition entity references on the result.
+ * Does not mutate inputs.
+ */
+export function inlineSynthesis<T extends SynthesizableFields>(
+  input: InlineSynthesisInput<T>
+): InlineSynthesisResult<T> {
+  const sourceItems = input.sourceItems;
+  if (sourceItems.length === 0) {
+    return {
+      items: input.receiverItems.map(item => structuredClone(item)),
+      attributions: (input.receiverAttributions ?? []).map(attr => ({ ...attr })),
+      nextId: input.nextId,
+      idMap: {},
+      aliasMapping: {},
+      deletedIds: new Set(),
+      insertedIds: [],
+      replacementIds: []
+    };
+  }
+
+  const receiverItems = input.receiverItems.map(item => structuredClone(item));
+  let attributions = (input.receiverAttributions ?? []).map(attr => ({ ...attr }));
+  const aliasMapping = allocateImportAliases(receiverItems, sourceItems);
+  const idMap: Record<number, number> = {};
+  const inserted: T[] = [];
+  const sourceIdSet = new Set(sourceItems.map(cst => cst.id));
+  let nextId = input.nextId;
+
+  for (const cst of sourceItems) {
+    const newId = nextId;
+    nextId += 1;
+    idMap[cst.id] = newId;
+
+    const cloned = structuredClone(cst);
+    cloned.id = newId;
+    if (Object.keys(aliasMapping).length > 0) {
+      cloned.alias = aliasMapping[cst.alias];
+      applyMappingToConstituents([cloned], aliasMapping, false);
+    }
+    inserted.push(cloned);
+  }
+
+  attributions = importAttributions(input.sourceAttributions ?? [], sourceIdSet, idMap, attributions);
+  const items = receiverItems.concat(inserted);
+  resolveAllConstituentTexts(items);
+
+  const substitutions = input.substitutions ?? [];
+  if (substitutions.length === 0) {
+    return {
+      items,
+      attributions,
+      nextId,
+      idMap,
+      aliasMapping,
+      deletedIds: new Set(),
+      insertedIds: inserted.map(cst => cst.id),
+      replacementIds: []
+    };
+  }
+
+  const remapped = remapSubstitutionsAfterImport(substitutions, sourceIdSet, idMap);
+  const substituted = applyConstituentSubstitutions(items, attributions, remapped);
+  resolveAllConstituentTexts(substituted.items);
+
+  return {
+    items: substituted.items,
+    attributions: substituted.attributions,
+    nextId,
+    idMap,
+    aliasMapping,
+    deletedIds: substituted.deletedIds,
+    insertedIds: inserted.map(cst => cst.id),
+    replacementIds: substituted.replacementIds
+  };
+}
+
+/** 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

@@ -0,0 +1,84 @@
+import { describe, expect, it } from 'vitest';
+
+import { resolveConstituentTextChange } from './text-resolution';
+import { type TextResolvableFields } from './types';
+
+function row(data: Partial<TextResolvableFields> & Pick<TextResolvableFields, 'alias' | 'id'>): TextResolvableFields {
+  return {
+    id: data.id,
+    alias: data.alias,
+    definition_raw: data.definition_raw ?? '',
+    definition_resolved: data.definition_resolved ?? '',
+    term_raw: data.term_raw ?? data.alias,
+    term_resolved: data.term_resolved ?? data.term_raw ?? data.alias,
+    term_forms: data.term_forms ?? []
+  };
+}
+
+describe('resolveConstituentTextChange', () => {
+  it('cascades term changes into dependent terms and definitions', () => {
+    const items = [
+      row({ id: 1, alias: 'T1', term_raw: 'base concept', term_resolved: 'base concept' }),
+      row({
+        id: 2,
+        alias: 'T2',
+        term_raw: '@{T1|nomn,sing}',
+        term_resolved: 'base concept',
+        definition_raw: '@{T1|nomn,sing}',
+        definition_resolved: 'base concept',
+        term_forms: [{ text: 'stale manual form', tags: 'gent,sing' }]
+      }),
+      row({ id: 3, alias: 'T3', definition_raw: '@{T2|nomn,sing}', definition_resolved: 'base concept' })
+    ];
+
+    items[0].term_raw = 'updated concept';
+    resolveConstituentTextChange(items, 1, {
+      termChanged: true,
+      termRawChanged: true,
+      definitionRawChanged: false,
+      clearTargetForms: true
+    });
+
+    expect(items[0].term_resolved).toBe('updated concept');
+    expect(items[1].term_resolved).toBe('updated concept');
+    expect(items[1].term_forms).toStrictEqual([]);
+    expect(items[1].definition_resolved).toBe('updated concept');
+    expect(items[2].definition_resolved).toBe('updated concept');
+  });
+
+  it('uses updated manual forms as a term change trigger', () => {
+    const items = [
+      row({ id: 1, alias: 'T1', term_raw: 'base concept', term_resolved: 'base concept' }),
+      row({ id: 2, alias: 'T2', term_raw: '@{T1|gent,sing}', term_resolved: 'base concept' })
+    ];
+
+    items[0].term_forms = [{ text: 'manual genitive singular', tags: 'gent,sing' }];
+    resolveConstituentTextChange(items, 1, {
+      termChanged: true,
+      termRawChanged: false,
+      definitionRawChanged: false,
+      clearTargetForms: false
+    });
+
+    expect(items[1].term_resolved).toBe('manual genitive singular');
+  });
+
+  it('does not cascade definition-only edits', () => {
+    const items = [
+      row({ id: 1, alias: 'T1', term_raw: 'base concept', term_resolved: 'base concept' }),
+      row({ id: 2, alias: 'T2', definition_raw: '@{T1|nomn,sing}', definition_resolved: 'base concept' }),
+      row({ id: 3, alias: 'T3', definition_raw: '@{T2|nomn,sing}', definition_resolved: 'old T2' })
+    ];
+
+    items[1].definition_raw = 'Only @{T1|nomn,sing}';
+    resolveConstituentTextChange(items, 2, {
+      termChanged: false,
+      termRawChanged: false,
+      definitionRawChanged: true,
+      clearTargetForms: false
+    });
+
+    expect(items[1].definition_resolved).toBe('Only base concept');
+    expect(items[2].definition_resolved).toBe('old T2');
+  });
+});