@rsconcept/domain 2.1.2 → 2.3.0

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

@@ -0,0 +1,126 @@
+import { describe, expect, it } from 'vitest';
+
+import { CstType } from '../rsform';
+
+import { inlineSynthesis } 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);
+  });
+});

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

@@ -0,0 +1,166 @@
+/**
+ * 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 Attribution, type CstType, type RSForm, type Substitution } from '../rsform';
+
+import { allocateImportAliases, applyMappingToConstituents, type ConstituentaMappableFields } from './alias';
+import { importAttributions } from './attribution';
+import { applyConstituentSubstitutions, remapSubstitutionsAfterImport } from './substitution';
+import { resolveAllConstituentTexts } from './text-resolution';
+import { type AliasTypedConstituenta, type ResolvableConstituenta } from './types';
+
+/** Constituent shape required for embedding / synthesis transforms. */
+export type SynthesizableConstituenta = ConstituentaMappableFields &
+  ResolvableConstituenta &
+  AliasTypedConstituenta & {
+    id: number;
+    alias: string;
+    cst_type: CstType;
+  };
+
+/** Input for {@link inlineSynthesis}. */
+export interface InlineSynthesisInput<T extends SynthesizableConstituenta> {
+  /** 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 SynthesizableConstituenta> {
+  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 SynthesizableConstituenta>(
+  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);
+  for (const item of items) {
+    if (item.visible && item.owner === receiver.owner && !result.includes(item)) {
+      result.push(item);
+    }
+  }
+  for (const item of items) {
+    if (item.visible && !result.includes(item)) {
+      result.push(item);
+    }
+  }
+  for (const item of items) {
+    if (!result.includes(item)) {
+      result.push(item);
+    }
+  }
+  return result;
+}

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

@@ -0,0 +1,86 @@
+import { describe, expect, it } from 'vitest';
+
+import { resolveConstituentTextChange } from './text-resolution';
+import { type ResolvableConstituenta } from './types';
+
+function row(
+  data: Partial<ResolvableConstituenta> & Pick<ResolvableConstituenta, 'alias' | 'id'>
+): ResolvableConstituenta {
+  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');
+  });
+});

package/src/library/rsform-api/text-resolution.ts

@@ -0,0 +1,152 @@
+/**
+ * Cascade resolution of constituenta term/definition entity references.
+ * Matches backend {@code RSForm.resolve_all_text} / {@code resolve_term_change}.
+ */
+
+import { type TermContext } from '../../cctext/language';
+import { extractEntities, parseGrammemes, resolveTextReferences } from '../../cctext/language-api';
+import { Graph } from '../../graph';
+
+import { type ResolvableConstituenta } from './types';
+
+/** Options controlling which texts to re-resolve after an edit. */
+export interface TextChangeOptions {
+  termChanged: boolean;
+  termRawChanged: boolean;
+  definitionRawChanged: boolean;
+  clearTargetForms: boolean;
+}
+
+/** Build term-reference graph: referenced constituent → dependent (backend {@code graph_term}). */
+export function buildTermReferenceGraph(items: readonly ResolvableConstituenta[]): Graph<number> {
+  return buildReferenceGraph(items, 'term_raw');
+}
+
+/** Build definition-reference graph: referenced constituent → dependent (backend {@code graph_text}). */
+export function buildDefinitionReferenceGraph(items: readonly ResolvableConstituenta[]): Graph<number> {
+  return buildReferenceGraph(items, 'definition_raw');
+}
+
+/** Resolve all term and definition texts in topological order. Mutates items in place. */
+export function resolveAllConstituentTexts(items: ResolvableConstituenta[]): void {
+  const graphTerm = buildTermReferenceGraph(items);
+  const idToItem = new Map(items.map(item => [item.id, item]));
+  const context = buildTermContext(items);
+
+  for (const id of graphTerm.topologicalOrder()) {
+    const row = idToItem.get(id);
+    if (!row) {
+      continue;
+    }
+    const resolved = resolveTextReferences(row.term_raw, context);
+    if (resolved !== row.term_resolved) {
+      row.term_resolved = resolved;
+      row.term_forms = [];
+      context[row.alias] = { nominal: row.term_resolved, forms: [] };
+    }
+  }
+
+  for (const row of items) {
+    row.definition_resolved = resolveTextReferences(row.definition_raw, context);
+  }
+}
+
+/**
+ * Resolve texts after a single constituent change, cascading dependents when the term changed.
+ * Mutates items in place.
+ */
+export function resolveConstituentTextChange(
+  items: ResolvableConstituenta[],
+  targetID: number,
+  options: TextChangeOptions
+): void {
+  const idToItem = new Map(items.map(item => [item.id, item]));
+  const target = idToItem.get(targetID);
+  if (!target) {
+    throw new Error(`resolveConstituentTextChange: unknown target ${targetID}`);
+  }
+
+  const context = buildTermContext(items);
+  if (options.termRawChanged) {
+    target.term_resolved = resolveTextReferences(target.term_raw, context);
+    if (options.clearTargetForms) {
+      target.term_forms = [];
+    }
+    context[target.alias] = toContextItem(target);
+  } else if (options.termChanged) {
+    context[target.alias] = toContextItem(target);
+  }
+
+  if (options.definitionRawChanged && !options.termChanged) {
+    target.definition_resolved = resolveTextReferences(target.definition_raw, context);
+  }
+
+  if (!options.termChanged) {
+    return;
+  }
+
+  const graphTerm = buildTermReferenceGraph(items);
+  const graphText = buildDefinitionReferenceGraph(items);
+  const expansion = graphTerm.expandAllOutputs([targetID]);
+  const expansionSet = new Set(expansion);
+
+  for (const id of graphTerm.topologicalOrder()) {
+    if (!expansionSet.has(id)) {
+      continue;
+    }
+    const expanded = idToItem.get(id);
+    if (!expanded) {
+      continue;
+    }
+    const resolved = resolveTextReferences(expanded.term_raw, context);
+    if (resolved !== expanded.term_resolved) {
+      expanded.term_resolved = resolved;
+      expanded.term_forms = [];
+      context[expanded.alias] = { nominal: expanded.term_resolved, forms: [] };
+    }
+  }
+
+  const updateDefs = new Set([targetID, ...expansion, ...graphText.expandAllOutputs([targetID, ...expansion])]);
+  for (const item of items) {
+    if (updateDefs.has(item.id)) {
+      item.definition_resolved = resolveTextReferences(item.definition_raw, context);
+    }
+  }
+}
+
+// ====== Internals =======
+
+function buildReferenceGraph(
+  items: readonly ResolvableConstituenta[],
+  field: 'definition_raw' | 'term_raw'
+): Graph<number> {
+  const graph = new Graph<number>();
+  const idByAlias = new Map(items.map(row => [row.alias, row.id]));
+  for (const row of items) {
+    graph.addNode(row.id);
+  }
+  for (const row of items) {
+    for (const entity of extractEntities(row[field])) {
+      const source = idByAlias.get(entity);
+      if (source !== undefined) {
+        graph.addEdge(source, row.id);
+      }
+    }
+  }
+  return graph;
+}
+
+function buildTermContext(items: readonly ResolvableConstituenta[]): TermContext {
+  const context: TermContext = {};
+  for (const row of items) {
+    context[row.alias] = toContextItem(row);
+  }
+  return context;
+}
+
+function toContextItem(row: ResolvableConstituenta): TermContext[string] {
+  return {
+    nominal: row.term_resolved,
+    forms: row.term_forms.map(form => ({ text: form.text, grams: parseGrammemes(form.tags) }))
+  };
+}

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

@@ -0,0 +1,161 @@
+import { describe, expect, it } from 'vitest';
+
+import { CstType } from '../rsform';
+
+import {
+  allocateImportAliases,
+  applyConstituentSubstitutions,
+  buildSequentialAliasMapping,
+  filterAttributions,
+  importAttributions,
+  insertItemAfter,
+  maxAliasIndex,
+  moveIdsInOrder,
+  remapAttributionsUnderSubstitution,
+  remapSubstitutionsAfterImport,
+  reorderItemsByIds
+} from './index';
+
+describe('maxAliasIndex / sequential and import aliases', () => {
+  it('finds max numeric suffix per type', () => {
+    expect(
+      maxAliasIndex(
+        [
+          { alias: 'X1', cst_type: CstType.BASE },
+          { alias: 'X4', cst_type: CstType.BASE }
+        ],
+        CstType.BASE
+      )
+    ).toBe(4);
+    expect(maxAliasIndex([{ alias: 'D2', cst_type: CstType.TERM }], CstType.BASE)).toBe(0);
+  });
+
+  it('builds sequential alias mapping in list order', () => {
+    const mapping = buildSequentialAliasMapping([
+      { alias: 'X9', cst_type: CstType.BASE },
+      { alias: 'X1', cst_type: CstType.BASE },
+      { alias: 'D5', cst_type: CstType.TERM }
+    ]);
+    expect(mapping).toEqual({ X9: 'X1', X1: 'X2', D5: 'D1' });
+  });
+
+  it('allocates import aliases only when receiver is non-empty', () => {
+    expect(allocateImportAliases([], [{ alias: 'X9', cst_type: CstType.BASE }])).toEqual({});
+    expect(
+      allocateImportAliases([{ alias: 'X2', cst_type: CstType.BASE }], [{ alias: 'X9', cst_type: CstType.BASE }])
+    ).toEqual({ X9: 'X3' });
+  });
+});
+
+describe('attribution remapping', () => {
+  it('remaps attributions under substitution and drops self-loops', () => {
+    const remapped = remapAttributionsUnderSubstitution(
+      [
+        { container: 1, attribute: 10 },
+        { container: 2, attribute: 20 },
+        { container: 1, attribute: 2 }
+      ],
+      new Map([
+        [1, 2],
+        [10, 20]
+      ])
+    );
+    expect(remapped).toEqual([{ container: 2, attribute: 20 }]);
+  });
+
+  it('imports attributions with id map and dedupe against existing', () => {
+    const imported = importAttributions(
+      [
+        { container: 10, attribute: 11 },
+        { container: 10, attribute: 99 }
+      ],
+      new Set([10, 11]),
+      { 10: 100, 11: 101 },
+      [{ container: 100, attribute: 101 }]
+    );
+    expect(imported).toEqual([{ container: 100, attribute: 101 }]);
+  });
+
+  it('filters attributions by deleted ids', () => {
+    expect(
+      filterAttributions(
+        [
+          { container: 1, attribute: 2 },
+          { container: 3, attribute: 4 }
+        ],
+        new Set([1])
+      )
+    ).toEqual([{ container: 3, attribute: 4 }]);
+  });
+});
+
+describe('transforms', () => {
+  it('moves ids within order', () => {
+    expect(moveIdsInOrder([1, 2, 3, 4], [2, 3], 0)).toEqual([2, 3, 1, 4]);
+    expect(moveIdsInOrder([1, 2, 3], [3], 99)).toEqual([1, 2, 3]);
+  });
+
+  it('reorders items by ids', () => {
+    const items = [
+      { id: 1, alias: 'a' },
+      { id: 2, alias: 'b' }
+    ];
+    expect(reorderItemsByIds(items, [2, 1]).map(i => i.alias)).toEqual(['b', 'a']);
+  });
+
+  it('inserts after id or appends', () => {
+    const items = [{ id: 1 }, { id: 2 }];
+    insertItemAfter(items, { id: 3 }, 1);
+    expect(items.map(i => i.id)).toEqual([1, 3, 2]);
+    insertItemAfter(items, { id: 4 }, null);
+    expect(items.map(i => i.id)).toEqual([1, 3, 2, 4]);
+  });
+});
+
+describe('substitution', () => {
+  it('applies alias mapping and drops originals', () => {
+    const items = [
+      {
+        id: 1,
+        alias: 'X1',
+        definition_formal: 'X1',
+        typification_manual: '',
+        term_raw: 'a',
+        definition_raw: '@{X1|nomn,sing}'
+      },
+      {
+        id: 2,
+        alias: 'X2',
+        definition_formal: 'X2',
+        typification_manual: '',
+        term_raw: 'b',
+        definition_raw: ''
+      }
+    ];
+    const result = applyConstituentSubstitutions(
+      items,
+      [{ container: 1, attribute: 2 }],
+      [{ original: 1, substitution: 2 }]
+    );
+    expect(result.deletedIds).toEqual(new Set([1]));
+    expect(result.items).toHaveLength(1);
+    expect(result.items[0].definition_raw).toBe('');
+    expect(result.attributions).toEqual([]);
+  });
+
+  it('remaps substitutions after import', () => {
+    expect(
+      remapSubstitutionsAfterImport(
+        [
+          { original: 10, substitution: 1 },
+          { original: 1, substitution: 10 }
+        ],
+        new Set([10]),
+        { 10: 100 }
+      )
+    ).toEqual([
+      { original: 100, substitution: 1 },
+      { original: 1, substitution: 100 }
+    ]);
+  });
+});