linked-rolls 0.19.1 → 0.21.0

package/lib/TrackerBar.js

@@ -1,9 +1,19 @@
-import { track } from "./Quantity";
+import { mm, track } from "./Quantity";
+/**
+ * What a position says, as a key. Two bars read the same thing exactly
+ * where their keys agree, which is what lets a symbol cross from one
+ * system to another and what decides whether two symbols collate.
+ */
+export const keyOf = (meaning) => meaning.type === 'note'
+    ? `note ${meaning.pitch}`
+    : `expression ${meaning.scope} ${meaning.expressionType}`;
 const SYSTEM_IRI = 'https://w3id.org/reo/type/system/';
 /** The roll system a tracker bar belongs to, as the roll metadata states it. */
 export const systemOf = (bar) => ({ id: SYSTEM_IRI + bar.id, name: bar.name, sameAs: [] });
+/** The identifier of a system the type vocabulary knows, from the IRI naming it. */
+export const systemIdIn = (id) => id?.startsWith(SYSTEM_IRI) ? id.slice(SYSTEM_IRI.length) : undefined;
 /** The identifier of a system the type vocabulary knows, from its concept. */
-export const systemIdOf = (system) => system?.id?.startsWith(SYSTEM_IRI) ? system.id.slice(SYSTEM_IRI.length) : undefined;
+export const systemIdOf = (system) => systemIdIn(system?.id);
 const areasOf = ({ notes, trackCount }) => [
     { role: 'bass-expression', from: track(1), to: track(notes.from - 1) },
     { role: 'note', from: track(notes.from), to: track(notes.to) },
@@ -28,41 +38,49 @@ export const describeTrackerBar = (spec) => {
             return undefined;
         return { type: 'expression', expressionType, scope: scopeOf(role) };
     };
+    const positions = new Map(Array.from({ length: spec.trackCount }, (_, i) => track(i + 1))
+        .flatMap(position => {
+        const meaning = meaningOf(position);
+        return meaning ? [[keyOf(meaning), position]] : [];
+    }));
     const rewind = spec.rewindTrack
         ?? [...spec.expressions].find(([, type]) => type === 'Rewind')?.[0];
     if (rewind === undefined) {
         throw new Error(`${spec.name} declares no rewind track`);
     }
+    // A rewind on a line of its own is unambiguous; one sharing a line is only
+    // the rewind when it is far longer than that line's usual command.
+    const shared = spec.rewindTrack !== undefined;
+    const endsAt = (features) => {
+        const hold = spec.rewindHold ?? mm(0);
+        const candidates = features
+            .filter(feature => feature.vertical.from === rewind)
+            .filter(feature => !shared || feature.horizontal.to - feature.horizontal.from >= hold)
+            .map(feature => feature.horizontal.from);
+        return candidates.length ? { at: mm(Math.min(...candidates)), because: 'rewind' } : undefined;
+    };
     return {
         id: spec.id,
         name: spec.name,
         width: spec.width,
         trackCount: spec.trackCount,
+        endsAt,
         areas,
         expressionTypes: [...new Set(spec.expressions.values())],
         rewindTrack: track(rewind),
         ...(spec.paperSpeed && { paperSpeed: spec.paperSpeed }),
         meaningOf,
+        positionOf: meaning => positions.get(keyOf(meaning)),
         roleOf
     };
 };
-const keyOf = (meaning) => meaning.type === 'note' ? `note ${meaning.pitch}` : `${meaning.scope} ${meaning.expressionType}`;
-const positionsOf = (bar) => Array.from({ length: bar.trackCount }, (_, i) => track(i + 1));
 /**
  * Puts a position of one bar onto the position of another that reads
  * the same thing, or nowhere when the other bar does not read it. This
- * is how a copy cut for one system takes its place in an edition of
- * another, as a Licensee re-cut does in an edition of a T-100 roll.
+ * is how a copy read in one system's numbering is put into another's,
+ * as the migration does for a Licensee copy stored on T-100 tracks.
  */
-export const translationBetween = (from, to) => {
-    const positions = new Map();
-    positionsOf(to).forEach(position => {
-        const meaning = to.meaningOf(position);
-        if (meaning)
-            positions.set(keyOf(meaning), position);
-    });
-    return position => {
-        const meaning = from.meaningOf(position);
-        return meaning ? positions.get(keyOf(meaning)) : undefined;
-    };
+export const translationBetween = (from, to) => (position) => {
+    const meaning = from.meaningOf(position);
+    return meaning && to.positionOf(meaning);
 };

package/lib/Version.d.ts

@@ -1,5 +1,6 @@
 import { Edit } from "./Edit";
-import { ReferenceAssumption } from "./Assumption";
+import { Concept } from "./Agent";
+import { ActorAssignment, DateAssignment, ReferenceAssumption } from "./Assumption";
 import { CollationTolerance } from "./Collation";
 import { AnySymbol } from "./Symbol";
 import { WithId, WithNote, WithType } from "./utils";
@@ -42,6 +43,37 @@ export type Derivation = ReferenceAssumption & {
 };
 /** The tolerance the derivation was collated at, or the default where it states none. */
 export declare const collationToleranceOf: (derivation: Readonly<Derivation>) => CollationTolerance;
+/**
+ * How a version was made, where that is known and worth stating.
+ *
+ * A roll issued for another system was re-punched by an editor of the
+ * publisher's, and that was an editorial act rather than a conversion:
+ * Lawson names Kähle as the man who corrected second masters for the
+ * green system. The rule he worked by is the procedure named here, and
+ * the version's edits carry it out, so the mechanical part of a
+ * transfer is stated once instead of being spelled out per note.
+ * @see lrmoo:F28 Expression Creation
+ */
+export interface VersionCreation {
+    /**
+     * Who carried the act out. An `ObjectAssumption`, so an attribution
+     * can carry the belief it rests on and the reasons for it.
+     * @see crm:P14 carried out by
+     */
+    actor?: ActorAssignment;
+    /**
+     * When it took place.
+     * @see dcterms:date
+     */
+    date?: DateAssignment;
+    /**
+     * The rule followed, as a term of the vocabulary: the notes stand
+     * at their pitch, the expression is re-spelled in the other
+     * system's words.
+     * @see crm:P33 used specific technique
+     */
+    procedure?: Concept;
+}
 /**
  * A version is defined by the sum of edits applied
  * to the version it is based on. For simple identification,
@@ -54,6 +86,16 @@ export interface Version extends WithId, WithType<'Version'> {
      * @see reo:siglum
      */
     siglum: string;
+    /**
+     * The reproducing system this version is coded for. One roll was
+     * often issued for several of them, and a version is a reading in
+     * one system's words: its expression types are that system's
+     * vocabulary and its notes sit on that bar's positions. A system
+     * the type vocabulary knows carries the IRI of its concept as
+     * `id`, from which the export takes the system's own context.
+     * @see crm:P2 has type
+     */
+    system: Concept;
     /**
      * Whether the version served as a master for reproductions
      * or exists on one copy only.
@@ -65,6 +107,12 @@ export interface Version extends WithId, WithType<'Version'> {
      * @see lrmoo:R76 is derivative of
      */
     basedOn?: Derivation;
+    /**
+     * The act that made this version, where it is known: who carried it
+     * out, when, and by what rule.
+     * @see lrmoo:R17i was created by
+     */
+    creation?: VersionCreation;
     /**
      * The list of edits that, applied to the base version, produce this version.
      * @see reo:involvedEdit

package/lib/asJsonLd.js

@@ -1,4 +1,4 @@
-import { systemIdOf } from "./TrackerBar";
+import { systemIdIn } from "./TrackerBar";
 export const exportDate = (date) => {
     const year = date.getFullYear();
     const month = String(date.getMonth() + 1).padStart(2, "0");
@@ -39,20 +39,35 @@ const asJsonLdEntity = (obj) => {
     return result;
 };
 /**
- * The context of the roll's reproducing system, which reads the
- * expression types as that system's terms.
+ * Gives every version the context of its own reproducing system, which
+ * reads its expression types as that system's terms.
+ *
+ * It sits on the version rather than on the edition because one edition
+ * may hold versions of several systems, and each system's context
+ * defines `expressionType` with its own `@vocab`. Two of them in one
+ * context array would leave every expression type in the document
+ * reading as whichever came last. An embedded context merges with the
+ * active one, so the shared prefixes survive.
  */
-const systemContextOf = (edition) => {
-    const system = systemIdOf(edition.roll?.system);
-    return system ? [`https://w3id.org/reo/${system}/context.jsonld`] : [];
+const withSystemContexts = (node) => {
+    if (Array.isArray(node))
+        return node.map(withSystemContexts);
+    if (node === null || typeof node !== 'object')
+        return node;
+    const walked = Object.fromEntries(Object.entries(node).map(([key, value]) => [key, withSystemContexts(value)]));
+    const system = node['@type'] === 'Version'
+        ? systemIdIn(node.system?.['@id'])
+        : undefined;
+    return system
+        ? { '@context': `https://w3id.org/reo/${system}/context.jsonld`, ...walked }
+        : walked;
 };
 export const asJsonLd = (edition) => {
     // The context is the export's own; one carried in from an import must not override it.
-    const { base, copies, '@context': carried, ...rest } = asJsonLdEntity(edition);
+    const { base, copies, '@context': carried, ...rest } = withSystemContexts(asJsonLdEntity(edition));
     return {
         '@context': [
             'https://w3id.org/reo/context.jsonld',
-            ...systemContextOf(edition),
             {
                 '@base': edition.base
             }

package/lib/constraints.d.ts

@@ -1,27 +1,16 @@
 import { EditionView } from "./EditionView";
-import { TrackerBar } from "./TrackerBar";
 export type ConstraintProblem = {
     version: string;
     symbol: string;
-    problem: 'alignment-reference-missing' | 'before-reference-missing' | 'after-reference-missing' | 'placed-relative-to-itself' | 'placed-several-ways' | 'partner-missing' | 'paired-with-itself' | 'in-several-pairs' | 'pair-placed-on-both-sides';
+    problem: 'alignment-reference-missing' | 'before-reference-missing' | 'after-reference-missing' | 'placed-relative-to-itself' | 'placed-several-ways' | 'partner-missing' | 'paired-with-itself' | 'in-several-pairs' | 'pair-placed-on-both-sides' | 'type-not-on-the-bar' | 'carrier-on-another-track' | 'copies-disagree-on-the-paper';
 };
 /**
- * Where the placements and pairings of the edition cannot hold as
- * stated, version by version: a reference or partner absent from the
- * version, a perforation placed relative to itself or in several ways
- * at once, one claimed by several pairs, or a pair whose members are
- * both placed and so cannot keep their distance and follow their
- * references at once.
+ * Where the edition cannot hold as stated, version by version: a
+ * placement or pairing reference absent from the version, a perforation
+ * placed relative to itself or in several ways at once, one claimed by
+ * several pairs, a pair whose members are both placed and so cannot
+ * keep their distance and follow their references at once, an
+ * expression the version's own bar cannot read, and a carrier sitting
+ * on a track that does not say what its symbol says.
  */
 export declare const constraintProblems: (view: EditionView) => ConstraintProblem[];
-export type UnknownExpressionType = {
-    version: string;
-    symbol: string;
-    expressionType: string;
-};
-/**
- * The expressions of the edition whose type the tracker bar does not
- * read, version by version. The roll names its system; a type from
- * another system, or a misspelt one, means nothing on it.
- */
-export declare const unknownExpressionTypes: (view: EditionView, bar: TrackerBar) => UnknownExpressionType[];

package/lib/constraints.js

@@ -1,5 +1,8 @@
 import { idOf } from "./Assumption";
 import { isPerforation, pairsAmong, placementsOf } from "./Symbol";
+import { keyOf } from "./TrackerBar";
+import { trackerBarOf } from "./systems";
+import { barOf } from "./RollCopy";
 const missingReference = {
     alignedWith: 'alignment-reference-missing',
     before: 'before-reference-missing',
@@ -39,25 +42,78 @@ const problemsIn = (version, perforations) => {
         ...missingPartners, ...selfPaired, ...inSeveralPairs, ...placedOnBothSides
     ];
 };
-/**
- * Where the placements and pairings of the edition cannot hold as
- * stated, version by version: a reference or partner absent from the
- * version, a perforation placed relative to itself or in several ways
- * at once, one claimed by several pairs, or a pair whose members are
- * both placed and so cannot keep their distance and follow their
- * references at once.
- */
-export const constraintProblems = (view) => view.edition.versions.flatMap(version => problemsIn(version.id, view.snapshot(version.id).filter(isPerforation)));
 const isExpression = (symbol) => symbol.type === 'expression';
 /**
- * The expressions of the edition whose type the tracker bar does not
- * read, version by version. The roll names its system; a type from
- * another system, or a misspelt one, means nothing on it.
+ * The expressions the version's own bar cannot read, its type belonging
+ * to another system or misspelt.
+ *
+ * This is what says a transfer between systems is unfinished. A green
+ * version connected to a red one inherits every red expression, and
+ * none of them means anything on a green machine, so each is reported
+ * until an edit deletes it and says what took its place. The list
+ * emptying is the proof that the transfer is complete.
  */
-export const unknownExpressionTypes = (view, bar) => {
+const typesNotOnTheBar = (version, snapshot) => {
+    const bar = trackerBarOf(version.system);
+    if (!bar)
+        return [];
     const known = new Set(bar.expressionTypes);
-    return view.edition.versions.flatMap(version => view.snapshot(version.id)
+    return snapshot
         .filter(isExpression)
         .filter(symbol => !known.has(symbol.expressionType))
-        .map(symbol => ({ version: version.id, symbol: symbol.id, expressionType: symbol.expressionType })));
+        .map(symbol => ({ version: version.id, symbol: symbol.id, problem: 'type-not-on-the-bar' }));
+};
+/**
+ * Carriers whose track does not say what the symbol they carry says.
+ *
+ * A carrier stands as evidence for its symbol, so the bar of the copy
+ * it sits on must read its track as the symbol's own meaning. Since a
+ * copy cut for another system numbers its tracks differently, this is
+ * what tells a transfer apart from a miscalibration: a red hole on 47
+ * and a green one on 45 both say pitch 60, while a green copy one track
+ * out says 59. Collation across systems consults only the place, so
+ * without this nothing checks the tracks at all.
+ */
+const carriersOffTheirMeaning = (view, version, perforations) => {
+    const misread = (carrier, symbol) => {
+        const copy = view.copyOf(carrier.id);
+        if (!copy)
+            return false;
+        const meaning = barOf(copy).meaningOf(carrier.vertical.from);
+        return !meaning || keyOf(meaning) !== keyOf(symbol);
+    };
+    return perforations
+        .filter(symbol => view.carriersOf(symbol).some(carrier => misread(carrier, symbol)))
+        .map(symbol => ({ version, symbol: symbol.id, problem: 'carrier-on-another-track' }));
 };
+/**
+ * Where the copies of the version's own system disagree about the scale
+ * that put them on the edition's shared axis.
+ *
+ * That scale is what takes a place back to the paper the version's roll
+ * ran on, so a performance needs one number. Copies disagreeing about it
+ * is evidence about the copies, and averaging it away would hide both
+ * the disagreement and the fact that the playback rests on a guess.
+ */
+const paperDisagreed = (view, version) => view.speedScalesIn(version).length > 1
+    ? [{ version: version.id, symbol: version.id, problem: 'copies-disagree-on-the-paper' }]
+    : [];
+/**
+ * Where the edition cannot hold as stated, version by version: a
+ * placement or pairing reference absent from the version, a perforation
+ * placed relative to itself or in several ways at once, one claimed by
+ * several pairs, a pair whose members are both placed and so cannot
+ * keep their distance and follow their references at once, an
+ * expression the version's own bar cannot read, and a carrier sitting
+ * on a track that does not say what its symbol says.
+ */
+export const constraintProblems = (view) => view.edition.versions.flatMap(version => {
+    const snapshot = view.snapshot(version.id);
+    const perforations = snapshot.filter(isPerforation);
+    return [
+        ...problemsIn(version.id, perforations),
+        ...typesNotOnTheBar(version, snapshot),
+        ...carriersOffTheirMeaning(view, version.id, perforations),
+        ...paperDisagreed(view, version)
+    ];
+});

package/lib/context.d.ts

@@ -1,3 +1,12 @@
 export { default as jsonLdContext } from './spec/context.json';
-/** The context of the Welte-Mignon T-100, added to an edition of a T-100 roll. */
+/** The context of the Welte-Mignon T-100, added to a version coded for it. */
 export { default as welteT100JsonLdContext } from './spec/welte-t100.context.json';
+/**
+ * The context of the Welte-Mignon Licensee. Its expression terms are
+ * the T-100's, the two systems differing in the tracker scale rather
+ * than in the coding, so it reads them out of the T-100's vocabulary
+ * rather than minting a second set of IRIs for the same commands.
+ */
+export { default as welteLicenseeJsonLdContext } from './spec/welte-licensee.context.json';
+/** The context of the Welte-Mignon T-98, added to an edition of a green roll. */
+export { default as welteT98JsonLdContext } from './spec/welte-t98.context.json';

package/lib/context.js

@@ -1,3 +1,12 @@
 export { default as jsonLdContext } from './spec/context.json';
-/** The context of the Welte-Mignon T-100, added to an edition of a T-100 roll. */
+/** The context of the Welte-Mignon T-100, added to a version coded for it. */
 export { default as welteT100JsonLdContext } from './spec/welte-t100.context.json';
+/**
+ * The context of the Welte-Mignon Licensee. Its expression terms are
+ * the T-100's, the two systems differing in the tracker scale rather
+ * than in the coding, so it reads them out of the T-100's vocabulary
+ * rather than minting a second set of IRIs for the same commands.
+ */
+export { default as welteLicenseeJsonLdContext } from './spec/welte-licensee.context.json';
+/** The context of the Welte-Mignon T-98, added to an edition of a green roll. */
+export { default as welteT98JsonLdContext } from './spec/welte-t98.context.json';

package/lib/editionOps.d.ts

@@ -17,7 +17,9 @@ import { AnyFeature, FeatureConditionAssignment } from "./Feature";
 export type EditionOp = (draft: Draft<Edition>) => void;
 /**
  * Puts the copy into the edition with a version of its own, which
- * inserts every symbol the tracker bar reads on the copy.
+ * inserts every symbol the copy's own tracker bar reads on it. The
+ * version is a reading in that system's words, so it is coded for the
+ * system the copy was cut for.
  */
 export declare const createVersion: (siglum: string, copy: RollCopy) => EditionOp;
 /**

package/lib/editionOps.js

@@ -4,7 +4,10 @@ import { getAt } from "./EditionView";
 import { isPerforation, placementRelations } from "./Symbol";
 import { collationsOf, defaultCollationTolerance } from "./Collation";
 import { collationToleranceOf, insertedBy } from "./Version";
-import { asSymbols } from "./RollCopy";
+import { asSymbols, barOf, isPaperStretch } from "./RollCopy";
+import { systemOf } from "./TrackerBar";
+import { substitutionsBetween } from "./substitution";
+import { trackerBarOf } from "./systems";
 import { applyShift, applyScale, revertShift, revertScale } from "./alignment";
 import { assignReference, idOf } from "./Assumption";
 import { conditions as conditionsAllowed, featuresBorneBy, isGluedOn, withBorneFeatures } from "./Feature";
@@ -66,20 +69,23 @@ const dropInsertions = (version, symbolIds) => {
 };
 /**
  * Puts the copy into the edition with a version of its own, which
- * inserts every symbol the tracker bar reads on the copy.
+ * inserts every symbol the copy's own tracker bar reads on it. The
+ * version is a reading in that system's words, so it is coded for the
+ * system the copy was cut for.
  */
 export const createVersion = (siglum, copy) => draft => {
+    const bar = barOf(copy);
     draft.copies.push(copy);
     draft.versions.push({
         type: 'Version',
         id: v4(),
         siglum,
+        system: systemOf(bar),
         versionType: 'edition',
-        edits: asSymbols(copy.features).map(insertion),
+        edits: asSymbols(copy.features, bar).map(insertion),
         motivations: []
     });
 };
-const isPaperStretch = (condition) => condition.conditionType === 'paper-stretch';
 /** States what the scale is put down to, in place of an earlier reading. */
 const readScale = (copy, reading) => {
     if (reading.cause === 'paper') {
@@ -451,6 +457,12 @@ const handOverCarriers = (view, draft, collations) => collations.forEach(({ symb
     const target = path && getAt(path, draft);
     target?.carriers.push(...symbol.carriers);
 });
+/** Whether the two versions are coded for different reproducing systems. */
+const differ = (child, parent) => {
+    const one = trackerBarOf(child?.system);
+    const other = trackerBarOf(parent?.system);
+    return one !== undefined && other !== undefined && one.id !== other.id;
+};
 /**
  * Bases the child on the parent. A symbol of the child that collates
  * with one the parent hands down adds its carriers to that symbol; the
@@ -461,12 +473,33 @@ const handOverCarriers = (view, draft, collations) => collations.forEach(({ symb
 export const connectVersions = (view, childId, parentId, tolerance = defaultCollationTolerance) => {
     const inherited = view.snapshot(parentId);
     const own = view.snapshot(childId);
-    const collations = collationsOf(own, inherited, symbol => view.dimensionOf(symbol), tolerance);
+    const locate = (symbol) => view.placeOf(symbol);
+    const collations = collationsOf(own, inherited, locate, tolerance);
     const collated = new Set(collations.map(({ symbol }) => symbol.id));
     const matched = new Set(collations.map(({ counterpart }) => counterpart.id));
+    /**
+     * Where the child is coded for another system, a held perforation of
+     * its own often stands for a latched pair of the parent's. Saying so
+     * as one edit is the transfer being carried out, and leaving the two
+     * apart would make the apparatus a list of unexplained losses beside
+     * a list of unexplained gains.
+     */
+    const substituted = differ(view.get(childId), view.get(parentId))
+        ? substitutionsBetween(own.filter(symbol => !collated.has(symbol.id)), inherited.filter(symbol => !matched.has(symbol.id)), locate, tolerance)
+        : [];
+    const paired = new Set(substituted.flatMap(({ replaced, by }) => [...by, ...replaced].map(symbol => symbol.id)));
     const edits = [
-        ...own.filter(symbol => !collated.has(symbol.id)).map(insertion),
-        ...inherited.filter(symbol => !matched.has(symbol.id)).map(symbol => deletion(symbol.id))
+        ...substituted.map(({ replaced, by }) => ({
+            type: 'edit',
+            id: v4(),
+            editType: 'replace-with-equivalent',
+            insert: [...by],
+            delete: replaced.map(symbol => symbol.id)
+        })),
+        ...own.filter(symbol => !collated.has(symbol.id) && !paired.has(symbol.id)).map(insertion),
+        ...inherited
+            .filter(symbol => !matched.has(symbol.id) && !paired.has(symbol.id))
+            .map(symbol => deletion(symbol.id))
     ];
     return onVersion(childId, (child, draft) => {
         handOverCarriers(view, draft, collations);
@@ -485,7 +518,7 @@ export const collateSymbols = (view, versionId, symbolIds, tolerance) => {
         return noChange;
     const chosen = new Set(symbolIds);
     const own = insertedIn([version]).filter(symbol => chosen.has(symbol.id));
-    const collations = collationsOf(own, view.snapshot(idOf(version.basedOn)), symbol => view.dimensionOf(symbol), tolerance ?? collationToleranceOf(version.basedOn));
+    const collations = collationsOf(own, view.snapshot(idOf(version.basedOn)), symbol => view.placeOf(symbol), tolerance ?? collationToleranceOf(version.basedOn));
     const collated = new Set(collations.map(({ symbol }) => symbol.id));
     return onVersion(versionId, (version, draft) => {
         handOverCarriers(view, draft, collations);
@@ -526,6 +559,7 @@ export const deriveVersion = (versionId, editIds) => onVersion(versionId, (versi
         type: 'Version',
         id: v4(),
         siglum: `${version.siglum}_derived`,
+        system: stateOf(version).system,
         versionType: 'unicum',
         basedOn: assignReference(versionId),
         edits: moved,
@@ -534,25 +568,53 @@ export const deriveVersion = (versionId, editIds) => onVersion(versionId, (versi
 });
 const sameSequence = (a, b) => a.length === b.length && a.every((value, i) => value === b[i]);
 const expressionTypesOf = (symbols) => symbols.filter((symbol) => symbol.type === 'expression').map(symbol => symbol.expressionType);
-const accents = [['SlowCrescendoOn', 'SlowCrescendoOff'], ['ForzandoOn', 'ForzandoOff']];
+/**
+ * How a single added accent is spelled. The red Welte latches a valve
+ * on and off again, the green holds one perforation for as long as the
+ * accent lasts, so the spelling is the system's and not the music's.
+ * Which of them a bar can spell decides which ones it is offered.
+ */
+const ACCENTS = [
+    ['SlowCrescendoOn', 'SlowCrescendoOff'],
+    ['ForzandoOn', 'ForzandoOff'],
+    ['Crescendo'],
+    ['SforzandoForte']
+];
+const accentsOn = (bar) => bar ? ACCENTS.filter(accent => accent.every(type => bar.expressionTypes.includes(type))) : [];
 const lengthOf = (span) => subtract(span.to, span.from);
 /** How far apart two onsets may lie for the one symbol to count as a replacement of the other. */
 const REPLACEMENT_TOLERANCE = mm(5);
 /** Shorten or prolong, where the inserted symbol starts about where the deleted one did. */
 const replacementType = (view, inserted, deleted) => {
-    const after = view.dimensionOf(inserted)?.horizontal;
-    const before = view.dimensionOf(deleted)?.horizontal;
+    const after = view.placeOf(inserted);
+    const before = view.placeOf(deleted);
     if (!after || !before || distance(after.from, before.from) >= REPLACEMENT_TOLERANCE)
         return undefined;
     return lengthOf(after) < lengthOf(before) ? 'shorten' : 'prolong';
 };
-/** A guess at what an edit does, from the symbols it exchanges. */
-const guessEditType = (view, edit) => {
+/**
+ * A guess at what an edit does, from the symbols it exchanges and from
+ * the systems the version and the one it is based on are coded for.
+ */
+const guessEditType = (view, versionId, edit) => {
     const inserts = edit.insert ?? [];
     const deletes = view.getAll(edit.delete ?? []);
     const inserted = expressionTypesOf(inserts);
     const deleted = expressionTypesOf(deletes);
-    if (deleted.length === 0 && accents.some(accent => sameSequence(inserted, accent)))
+    const bar = trackerBarOf(view.get(versionId)?.system);
+    const parentBar = trackerBarOf(view.predecessorOf(versionId)?.system);
+    /**
+     * Where the version is coded for another system than its parent, an
+     * exchange of expression matter is the transfer being carried out:
+     * a red ForzandoOn and ForzandoOff pair giving way to one held green
+     * SforzandoForte says the same thing in the other system's words,
+     * which is what 'replace-with-equivalent' is for. Calling it a
+     * corrected error would say the editor made a mistake.
+     */
+    if (bar && parentBar && bar.id !== parentBar.id && inserted.length > 0 && deleted.length > 0) {
+        return 'replace-with-equivalent';
+    }
+    if (deleted.length === 0 && accentsOn(bar).some(accent => sameSequence(inserted, accent)))
         return 'additional-accent';
     if (inserted.length > 1 && sameSequence(inserted, deleted))
         return 'shift';
@@ -575,7 +637,7 @@ export const mergeEdits = (view, versionId, toMerge) => {
         insert: toMerge.flatMap(edit => edit.insert ?? []),
         delete: toMerge.flatMap(edit => edit.delete ?? [])
     };
-    merged.editType = guessEditType(view, merged);
+    merged.editType = guessEditType(view, versionId, merged);
     const mergedIds = new Set(toMerge.map(edit => edit.id));
     return onVersion(versionId, version => {
         version.edits = [...version.edits.filter(edit => !mergedIds.has(edit.id)), merged];

package/lib/importJsonLd.js

@@ -23,10 +23,12 @@ const fromJsonLdValue = (value) => {
 /**
  * An entity with its keywords read as plain keys. The input is left as
  * it is. The `@type` of a value object names the datatype of the value,
- * not a class, and is dropped.
+ * not a class, and is dropped. So is a context: a version carries one
+ * naming its system's vocabulary, and it belongs to the serialisation
+ * rather than to the edition, which states the system as data.
  */
 const fromJsonLdEntity = (json) => {
-    const { '@type': type, '@id': id, ...rest } = json;
+    const { '@type': type, '@id': id, '@context': context, ...rest } = json;
     const entity = Object.fromEntries(Object.entries(rest).map(([key, value]) => [key, fromJsonLdValue(value)]));
     if (type !== undefined && !('@value' in json))
         entity.type = type;

package/lib/index.d.ts

@@ -25,6 +25,7 @@ export * from './editionOps';
 export * from './Emulation';
 export * from './validate';
 export * from './constraints';
+export * from './substitution';
 export * from './context';
 export * from './asJsonLd';
 export * from './importJsonLd';

package/lib/index.js

@@ -25,6 +25,7 @@ export * from './editionOps';
 export * from './Emulation';
 export * from './validate';
 export * from './constraints';
+export * from './substitution';
 export * from './context';
 export * from './asJsonLd';
 export * from './importJsonLd';