linked-rolls 0.19.1 → 0.20.0

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,10 @@
 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';

package/lib/context.js

@@ -1,3 +1,10 @@
 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';

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';

package/lib/migrate.js

@@ -1,6 +1,7 @@
 import { conditions } from "./Feature";
 import { rollConditions } from "./RollCopy";
-import { systemOf } from "./TrackerBar";
+import { systemIdIn, systemOf, translationBetween } from "./TrackerBar";
+import { trackerBars } from "./systems";
 import { welteT100 } from "./systems/welteT100/bar";
 import { versionTypes } from "./Version";
 const versionTypeValues = new Set(versionTypes);
@@ -88,20 +89,93 @@ const walk = (value) => {
         return withWalkedChildren(migrateNode(value));
     return value;
 };
+/** The production of a copy, under whichever of its two names it carries. */
+const productionKeyOf = (copy) => copy?.productionEvent && !copy?.production ? 'productionEvent' : 'production';
+/** The list under the key, or nothing where the document holds something else there. */
+const listAt = (edition, key) => Array.isArray(edition[key]) ? edition[key] : undefined;
+/** A file written while the system belonged to the roll rather than to each version. */
+const namesSystemOnTheRoll = (edition) => edition.roll?.system !== undefined
+    || (listAt(edition, 'versions') ?? []).some((version) => !version?.system);
+const barNamed = (system) => trackerBars.find(bar => bar.id === systemIdIn(system?.['@id']));
+const withSystem = (node, system) => node.system && typeof node.system === 'object' ? node : { ...node, system };
+/** A span on the other bar, or nothing where that bar does not read one of its ends. */
+const spanOnBar = (span, at) => {
+    const from = at(span.from);
+    if (from === undefined)
+        return undefined;
+    if (span.to === undefined)
+        return { ...span, from };
+    const to = at(span.to);
+    return to === undefined ? undefined : { ...span, from, to };
+};
+/** The features on the copy's own bar, those it does not read left out, patches and all. */
+const featuresOnBar = (features, at) => features.flatMap((feature) => {
+    const vertical = feature.vertical?.unit === 'track'
+        ? spanOnBar(feature.vertical, at)
+        : feature.vertical;
+    if (!vertical)
+        return [];
+    return [{
+            ...feature,
+            vertical,
+            ...(Array.isArray(feature.features) && { features: featuresOnBar(feature.features, at) })
+        }];
+});
+/**
+ * A copy cut for another system had its holes put onto the roll's bar
+ * as it was read, so they are numbered in the roll's system and not in
+ * its own. They go back onto the bar the copy names, which is the only
+ * numbering that means anything once each copy is read by its own bar.
+ * Between two Welte scales the difference is two tracks, which is a
+ * legal position a whole tone away rather than a visible error.
+ */
+const onOwnBar = (copy, rollSystem) => {
+    if (!copy || typeof copy !== 'object')
+        return copy;
+    const key = productionKeyOf(copy);
+    const own = copy[key]?.system;
+    const from = barNamed(rollSystem);
+    const to = own && typeof own === 'object' ? barNamed(own) : undefined;
+    if (!from || !to || from.id === to.id || !Array.isArray(copy.features))
+        return copy;
+    return { ...copy, features: featuresOnBar(copy.features, translationBetween(from, to)) };
+};
 /**
- * Every 0.1 edition was read with the T-100 tracker bar, so a roll
- * without a system is a T-100 roll. The text a copy's production
- * gave for the system is kept as the name.
+ * Systems belonged to the roll before they belonged to the versions
+ * and the copies. Every 0.1 edition was read with the T-100 bar, so a
+ * roll that named no system was a T-100 roll, and the text a copy's
+ * production gave for it is kept as the system's name.
  */
-const withRollSystem = (edition) => {
-    if (!edition.roll || edition.roll.system)
+const withSystems = (edition) => {
+    if (!edition.roll || !namesSystemOnTheRoll(edition))
         return edition;
-    const stated = (edition.copies ?? [])
-        .map((copy) => copy.production?.system ?? copy.productionEvent?.system)
+    const versions = listAt(edition, 'versions');
+    const copies = listAt(edition, 'copies');
+    const stated = (copies ?? [])
+        .map((copy) => copy?.[productionKeyOf(copy)]?.system)
         .find((system) => typeof system === 'string' && system !== '');
     const { id, ...concept } = systemOf(welteT100);
-    const system = { '@id': id, ...concept, ...(stated && { name: stated }) };
-    return { ...edition, roll: { ...edition.roll, system } };
+    const system = edition.roll.system ?? { '@id': id, ...concept, ...(stated && { name: stated }) };
+    const { system: _named, ...roll } = edition.roll;
+    const created = roll.recordingEvent?.created;
+    return {
+        ...edition,
+        roll: created
+            ? { ...roll, recordingEvent: { ...roll.recordingEvent, created: withSystem(created, system) } }
+            : roll,
+        ...(versions && {
+            versions: versions.map((version) => withSystem(version, system))
+        }),
+        ...(copies && {
+            copies: copies.map((copy) => {
+                if (!copy || typeof copy !== 'object')
+                    return copy;
+                const key = productionKeyOf(copy);
+                const onOwn = onOwnBar(copy, system);
+                return { ...onOwn, [key]: withSystem(onOwn[key] ?? {}, system) };
+            })
+        })
+    };
 };
 /** An edition written before the editors were carried names none. */
 const withEditors = (edition) => !edition.creation || edition.creation.editors
@@ -126,5 +200,5 @@ const withDerivationTolerance = (edition) => {
             : version)
     };
 };
-const editionSteps = [withRollSystem, withEditors, withDerivationTolerance];
+const editionSteps = [withSystems, withEditors, withDerivationTolerance];
 export const migrate = (edition) => walk(editionSteps.reduce((result, step) => step(result), edition));

package/lib/readers/phillipsEroll.d.ts

@@ -37,8 +37,6 @@ export interface PhillipsErollOptions {
      * the roll he read.
      */
     system?: TrackerBar;
-    /** The edition's bar, onto which the positions are put. */
-    bar?: TrackerBar;
     /**
      * How far above its position an expression number sits. Defaults to
      * what his samples show for that bar.
@@ -54,9 +52,9 @@ export interface PhillipsErollOptions {
 }
 /**
  * Reads one of his e-roll files as a copy of the roll, in millimetres
- * of paper. A position the edition's bar does not read is left out, as
- * the bar would leave it.
+ * of paper, on the bar it was cut for and in that bar's numbering. A
+ * position the bar does not read is left out, as the bar would leave it.
  */
-export declare function readFromPhillipsEroll(buffer: ArrayBuffer, { system, bar, controlOffset, placeAt }?: PhillipsErollOptions): RollCopy;
+export declare function readFromPhillipsEroll(buffer: ArrayBuffer, { system, controlOffset, placeAt }?: PhillipsErollOptions): RollCopy;
 /** The bars his files are known to be numbered by. */
 export declare const phillipsSystems: readonly TrackerBar[];

package/lib/readers/phillipsEroll.js

@@ -1,7 +1,7 @@
 import { read } from "midifile-ts";
 import { v4 } from "uuid";
 import { assignObject } from "../Assumption";
-import { systemOf, translationBetween } from "../TrackerBar";
+import { systemOf } from "../TrackerBar";
 import { welteT100 } from "../systems/welteT100/bar";
 import { welteLicensee } from "../systems/welteLicensee/bar";
 import { inMetersPerMinute, mm, seconds, track } from "../Quantity";
@@ -116,21 +116,20 @@ const positionsByPitch = (bar) => new Map(Array.from({ length: bar.trackCount },
 }));
 /**
  * Reads one of his e-roll files as a copy of the roll, in millimetres
- * of paper. A position the edition's bar does not read is left out, as
- * the bar would leave it.
+ * of paper, on the bar it was cut for and in that bar's numbering. A
+ * position the bar does not read is left out, as the bar would leave it.
  */
-export function readFromPhillipsEroll(buffer, { system = welteT100, bar = welteT100, controlOffset, placeAt } = {}) {
+export function readFromPhillipsEroll(buffer, { system = welteT100, controlOffset, placeAt } = {}) {
     const file = read(new Uint8Array(buffer));
     const timed = onOneClock(file.tracks);
     const elapsedAt = clockOf(temposIn(timed), file.header.ticksPerBeat);
     const place = placeAt ?? atStatedSpeed(system);
     const offset = controlOffsetOf(system, controlOffset);
     const notePositions = positionsByPitch(system);
-    const onBar = translationBetween(system, bar);
     const positionOf = (number) => notePositions.get(number) ?? track(number - offset);
     const features = notesIn(timed).flatMap((note) => {
-        const position = onBar(positionOf(note.pitch));
-        if (position === undefined)
+        const position = positionOf(note.pitch);
+        if (!system.meaningOf(position))
             return [];
         return [{
                 type: 'Hole',

package/lib/readers/spencerBar.d.ts

@@ -16,14 +16,13 @@ export interface SpencerBarOptions {
      * the roll it was scanned from. His Welte files are Licensee rolls.
      */
     system?: TrackerBar;
-    /** The edition's bar, onto which the positions are put. */
-    bar?: TrackerBar;
 }
 /**
- * Reads the copy onto the edition's bar. A hole on a position the
- * edition's bar does not read is left out, as the bar would leave it.
+ * Reads the copy on the bar it was cut for, whose numbering it keeps.
+ * A hole on a position that bar does not read is left out, as the bar
+ * would leave it.
  */
-export declare function readFromSpencerBar(buffer: ArrayBuffer, { rowsPerInch, system, bar }?: SpencerBarOptions): RollCopy;
+export declare function readFromSpencerBar(buffer: ArrayBuffer, { rowsPerInch, system }?: SpencerBarOptions): RollCopy;
 /**
  * The `.ann` file beside a `.bar` holds the player's settings for the
  * roll as lines of "/key:   value": title, composer, pianist, roll

package/lib/readers/spencerBar.js

@@ -1,6 +1,5 @@
 import { v4 } from "uuid";
-import { systemOf, translationBetween } from "../TrackerBar";
-import { welteT100 } from "../systems/welteT100/bar";
+import { systemOf } from "../TrackerBar";
 import { welteLicensee } from "../systems/welteLicensee/bar";
 import { feetPerMinute, inMillimeters, px, track } from "../Quantity";
 /**
@@ -80,20 +79,20 @@ const holesOf = (events) => {
     return holes.sort((a, b) => a.from - b.from);
 };
 /**
- * Reads the copy onto the edition's bar. A hole on a position the
- * edition's bar does not read is left out, as the bar would leave it.
+ * Reads the copy on the bar it was cut for, whose numbering it keeps.
+ * A hole on a position that bar does not read is left out, as the bar
+ * would leave it.
  */
-export function readFromSpencerBar(buffer, { rowsPerInch = SPENCER_ROWS_PER_INCH, system = welteLicensee, bar = welteT100 } = {}) {
+export function readFromSpencerBar(buffer, { rowsPerInch = SPENCER_ROWS_PER_INCH, system = welteLicensee } = {}) {
     const bytes = new Uint8Array(buffer);
     if (byteAt(bytes, TEXT_AT) !== TEXT_TAG) {
         throw new Error('Not a Spencer .bar file: no text after the header');
     }
     const placeOf = (row) => inMillimeters(px(row), rowsPerInch);
-    const onBar = translationBetween(system, bar);
     const features = holesOf(eventsIn(bytes, endOfText(bytes, TEXT_AT + 1)))
         .flatMap((hole) => {
-        const position = onBar(track(hole.position));
-        if (position === undefined)
+        const position = track(hole.position);
+        if (!system.meaningOf(position))
             return [];
         return [{
                 type: 'Hole',

package/lib/readers/stanfordAton.d.ts

@@ -8,13 +8,10 @@ export interface StanfordAtonOptions {
      * perforation on the bar's rewind track.
      */
     trackShift?: Track;
-    /** The edition's bar, onto which the holes are put. */
-    bar?: TrackerBar;
     /**
-     * The bar the scanned roll was cut for, where it is not the
-     * edition's. The scan is calibrated on it, and the holes are then
-     * put onto the edition's bar; one on a position that bar does not
-     * read is left out.
+     * The bar the scanned roll was cut for. The scan is calibrated on
+     * it and the holes keep its numbering, since a copy is read by the
+     * bar it was cut for and by no other.
      */
     system?: TrackerBar;
     /**
@@ -24,4 +21,4 @@ export interface StanfordAtonOptions {
      */
     scan?: string;
 }
-export declare function readFromStanfordAton(atonString: string, { trackShift, bar, system, scan }?: StanfordAtonOptions): RollCopy;
+export declare function readFromStanfordAton(atonString: string, { trackShift, system, scan }?: StanfordAtonOptions): RollCopy;