linked-rolls 0.10.1 → 0.12.0

package/lib/constraints.js

@@ -25,9 +25,11 @@ const problemsIn = (version, perforations) => {
         .filter(p => p.pairedWith && idOf(p.pairedWith) === p.id)
         .map(p => report(p.id, 'paired-with-itself'));
     const pairs = pairsAmong(perforations);
-    const pairsOf = (p) => pairs.filter(pair => pair.includes(p));
+    const pairsPerId = pairs
+        .flatMap(([one, other]) => one === other ? [one] : [one, other])
+        .reduce((counts, p) => counts.set(p.id, (counts.get(p.id) ?? 0) + 1), new Map());
     const inSeveralPairs = perforations
-        .filter(p => pairsOf(p).length > 1)
+        .filter(p => (pairsPerId.get(p.id) ?? 0) > 1)
         .map(p => report(p.id, 'in-several-pairs'));
     const placedOnBothSides = pairs
         .filter(([one, other]) => placementsOf(one).length > 0 && placementsOf(other).length > 0)

package/lib/editionOps.d.ts

@@ -4,8 +4,8 @@ import { Edition } from "./Edition";
 import { AnySymbol, PlacementRelation } from "./Symbol";
 import { CollationTolerance } from "./Collation";
 import { Edit } from "./Edit";
-import { PaperStretch, RollCopy, Shift } from "./RollCopy";
-import { AnyArgumentation, Certainty, ObjectAssumption } from "./Assumption";
+import { RollCopy, ScaleReading, Shift } from "./RollCopy";
+import { AnyArgumentation, Certainty } from "./Assumption";
 /**
  * A change to an edition, written onto an immer draft of it. One
  * operation is one undo step, so an operation that has to read the
@@ -18,9 +18,17 @@ export type EditionOp = (draft: Draft<Edition>) => void;
  * inserts every symbol the tracker bar reads on the copy.
  */
 export declare const createVersion: (siglum: string, copy: RollCopy) => EditionOp;
-/** Shifts and then stretches the copy's features into line with another copy's. */
-export declare const alignCopy: (copyId: string, shift: Shift, stretch: ObjectAssumption<PaperStretch>) => EditionOp;
-/** Puts the copy's features back where they were measured. */
+/**
+ * Shifts and then scales the copy's features into line with another
+ * copy's, and puts the scale down to what the reading says: the paper,
+ * or the speed the copy was cut for.
+ */
+export declare const alignCopy: (copyId: string, shift: Shift, scale: number, reading?: ScaleReading) => EditionOp;
+/**
+ * Puts the copy's features back where they were measured. A paper
+ * stretch read off the alignment goes with it; a speed stated stays,
+ * being a fact about the copy.
+ */
 export declare const unalignCopy: (copyId: string) => EditionOp;
 /** The symbols of the versions that no other copy carries. */
 export declare const symbolsCarriedOnlyBy: (edition: Edition, copyId: string) => AnySymbol[];

package/lib/editionOps.js

@@ -1,9 +1,11 @@
+import { current, isDraft } from "immer";
 import { v4 } from "uuid";
 import { getAt } from "./EditionView";
 import { isPerforation, placementRelations } from "./Symbol";
 import { collationsOf, defaultCollationTolerance } from "./Collation";
+import { insertedBy } from "./Version";
 import { asSymbols } from "./RollCopy";
-import { applyShift, applyStretch, revertShift, revertStretch } from "./alignment";
+import { applyShift, applyScale, revertShift, revertScale } from "./alignment";
 import { assignReference, idOf } from "./Assumption";
 import { distance, mm, subtract } from "./Quantity";
 const noChange = () => undefined;
@@ -17,23 +19,36 @@ const onVersion = (versionId, op) => draft => {
     if (version)
         op(version, draft);
 };
+/**
+ * The state a draft stands at, as plain data. Reading a draft proxies
+ * everything it touches, so what is only read is read from this.
+ */
+const stateOf = (draft) => isDraft(draft) ? current(draft) : draft;
 /** The items that do not match, or the very same array when none does, so that a draft stays untouched. */
 const without = (items, matches) => items.some(matches) ? items.filter(item => !matches(item)) : items;
+/** The items each changed, or the very same array when the change left every one as it was. */
+const mapped = (items, change) => {
+    const changed = items.map(change);
+    return changed.every((item, i) => item === items[i]) ? items : changed;
+};
 const insertion = (symbol) => ({ type: 'edit', id: v4(), insert: [symbol] });
 const deletion = (symbolId) => ({ type: 'edit', id: v4(), delete: [symbolId] });
 const isEmpty = (edit) => !edit.insert?.length && !edit.delete?.length;
-const insertedIn = (versions) => versions.flatMap(version => version.edits).flatMap(edit => edit.insert ?? []);
-/** Runs the change over the version's edits and drops those it emptied, leaving edits that were empty before alone. */
-const editing = (version, change) => {
-    const emptyBefore = new Set(version.edits.filter(isEmpty).map(edit => edit.id));
-    version.edits.forEach(change);
-    version.edits = without(version.edits, edit => isEmpty(edit) && !emptyBefore.has(edit.id));
+const insertedIn = (versions) => versions.flatMap(insertedBy);
+/** The edits with the change applied, less those it emptied; the very same array where it changed none. */
+const edited = (edits, change) => {
+    const changed = mapped(edits, change);
+    return changed === edits ? edits : changed.filter((edit, i) => edit === edits[i] || !isEmpty(edit));
+};
+/** The edit without the symbols among its insertions, or the very same edit where it inserts none of them. */
+const droppingInsertions = (symbolIds) => (edit) => {
+    const insert = edit.insert && without(edit.insert, symbol => symbolIds.has(symbol.id));
+    return insert === edit.insert ? edit : { ...edit, insert };
+};
+/** Takes the symbols out of the version's own insertions, and the edits that had nothing else. */
+const dropInsertions = (version, symbolIds) => {
+    version.edits = edited(stateOf(version).edits, droppingInsertions(symbolIds));
 };
-/** Takes the symbols out of the version's own insertions. */
-const dropInsertions = (version, symbolIds) => editing(version, edit => {
-    if (edit.insert)
-        edit.insert = without(edit.insert, symbol => symbolIds.has(symbol.id));
-});
 /**
  * Puts the copy into the edition with a version of its own, which
  * inserts every symbol the tracker bar reads on the copy.
@@ -49,15 +64,37 @@ export const createVersion = (siglum, copy) => draft => {
         motivations: []
     });
 };
-/** Shifts and then stretches the copy's features into line with another copy's. */
-export const alignCopy = (copyId, shift, stretch) => onCopy(copyId, copy => {
+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') {
+        copy.conditions = [...copy.conditions.filter(condition => !isPaperStretch(condition)), reading.condition];
+        return;
+    }
+    if (!copy.production)
+        copy.production = {};
+    copy.production.speed = reading.speed;
+};
+/**
+ * Shifts and then scales the copy's features into line with another
+ * copy's, and puts the scale down to what the reading says: the paper,
+ * or the speed the copy was cut for.
+ */
+export const alignCopy = (copyId, shift, scale, reading) => onCopy(copyId, copy => {
     applyShift(shift, copy);
-    applyStretch(stretch, copy);
+    applyScale(scale, copy);
+    if (reading)
+        readScale(copy, reading);
 });
-/** Puts the copy's features back where they were measured. */
+/**
+ * Puts the copy's features back where they were measured. A paper
+ * stretch read off the alignment goes with it; a speed stated stays,
+ * being a fact about the copy.
+ */
 export const unalignCopy = (copyId) => onCopy(copyId, copy => {
-    revertStretch(copy);
+    revertScale(copy);
     revertShift(copy);
+    copy.conditions = without(copy.conditions, isPaperStretch);
 });
 const featureIdsOf = (copy) => new Set(copy.features.map(feature => feature.id));
 /**
@@ -72,25 +109,34 @@ export const symbolsCarriedOnlyBy = (edition, copyId) => {
     return copy ? insertedIn(edition.versions).filter(carriedOnlyOn(featureIdsOf(copy))) : [];
 };
 const references = [...placementRelations, 'pairedWith'];
-const forgetPerforations = (perforation, dropped) => references
-    .filter(relation => {
-    const reference = perforation[relation];
-    return reference && dropped.has(idOf(reference));
-})
-    .forEach(relation => { delete perforation[relation]; });
-const forgetCarriers = (symbol, features, dropped) => {
-    symbol.carriers = without(symbol.carriers, carrier => features.has(idOf(carrier)));
-    if (isPerforation(symbol))
-        forgetPerforations(symbol, dropped);
+/** The perforation without its references to the dropped symbols, or the very same one where it makes none. */
+const forgettingReferences = (perforation, dropped) => {
+    const stale = references.filter(relation => {
+        const reference = perforation[relation];
+        return reference !== undefined && dropped.has(idOf(reference));
+    });
+    if (stale.length === 0)
+        return perforation;
+    const kept = { ...perforation };
+    stale.forEach(relation => { delete kept[relation]; });
+    return kept;
 };
-const forgetFeaturesInEdit = (edit, features, dropped) => {
-    if (edit.insert) {
-        edit.insert = without(edit.insert, symbol => dropped.has(symbol.id));
-        edit.insert.forEach(symbol => forgetCarriers(symbol, features, dropped));
-    }
-    if (edit.delete) {
-        edit.delete = without(edit.delete, id => dropped.has(id));
-    }
+/** The symbol without the features among its carriers, and without references to what went with them. */
+const forgettingCarriers = (features, dropped) => (symbol) => {
+    const carriers = without(symbol.carriers, carrier => features.has(idOf(carrier)));
+    const relieved = carriers === symbol.carriers ? symbol : { ...symbol, carriers };
+    return isPerforation(relieved) ? forgettingReferences(relieved, dropped) : relieved;
+};
+/** The edit without the dropped symbols and the features, or the very same edit where it had none of them. */
+const forgettingFeatures = (features, dropped) => {
+    const forgetCarriers = forgettingCarriers(features, dropped);
+    return (edit) => {
+        const insert = edit.insert && mapped(without(edit.insert, symbol => dropped.has(symbol.id)), forgetCarriers);
+        const deleted = edit.delete && without(edit.delete, id => dropped.has(id));
+        if (insert === edit.insert && deleted === edit.delete)
+            return edit;
+        return { ...edit, ...(insert && { insert }), ...(deleted && { delete: deleted }) };
+    };
 };
 /**
  * Strikes the features from the versions: their carriers go, a symbol
@@ -98,8 +144,12 @@ const forgetFeaturesInEdit = (edit, features, dropped) => {
  * reference the versions made to such a symbol.
  */
 const forgetFeatures = (draft, features) => {
-    const dropped = new Set(insertedIn(draft.versions).filter(carriedOnlyOn(features)).map(symbol => symbol.id));
-    draft.versions.forEach(version => editing(version, edit => forgetFeaturesInEdit(edit, features, dropped)));
+    const versions = stateOf(draft.versions);
+    const dropped = new Set(insertedIn(versions).filter(carriedOnlyOn(features)).map(symbol => symbol.id));
+    const forget = forgettingFeatures(features, dropped);
+    draft.versions.forEach((version, i) => {
+        version.edits = edited(versions[i].edits, forget);
+    });
 };
 /** Takes the features off the copy, and out of the versions with what only they carried. */
 export const removeFeatures = (copyId, featureIds) => onCopy(copyId, (copy, draft) => {

package/lib/importJsonLd.d.ts

@@ -1,3 +1,5 @@
 import { Edition } from "./Edition";
 export declare const importDate: (str: string) => Date;
-export declare const importJsonLd: (json: any) => Edition;
+type Json = any;
+export declare const importJsonLd: (json: Json) => Edition;
+export {};

package/lib/importJsonLd.js

@@ -10,49 +10,29 @@ export const importDate = (str) => {
     }
     return new Date(y, m - 1, d);
 };
+/** A value as the edition holds it: a date read, an entity converted, anything else as it stands. */
+const fromJsonLdValue = (value) => {
+    if (typeof value === 'string')
+        return isDate(value) ? importDate(value) : value;
+    if (Array.isArray(value))
+        return value.map(fromJsonLdValue);
+    if (value !== null && typeof value === 'object')
+        return fromJsonLdEntity(value);
+    return 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.
+ */
 const fromJsonLdEntity = (json) => {
-    if (typeof json !== 'object') {
-        return json;
-    }
-    let result = json;
-    if ('@value' in json) {
-        // the datatype of a value object, not a class
-        delete result['@type'];
-    }
-    else if ('@type' in json) {
-        result['type'] = json['@type'];
-        delete result['@type'];
-    }
-    for (const [key, value] of Object.entries(json)) {
-        if (key === '@id') {
-            // console.log("deleting @id", value);
-            result['id'] = value;
-            delete result['@id'];
-        }
-        else if (typeof value === 'string' && isDate(value)) {
-            result[key] = importDate(value);
-        }
-        else if (Array.isArray(value)) {
-            result[key] = value.map(v => {
-                if (typeof v === 'string') {
-                    if (isDate(v)) {
-                        return importDate(v);
-                    }
-                    return v;
-                }
-                else {
-                    return fromJsonLdEntity(v);
-                }
-            });
-        }
-        else if (typeof value === 'object') {
-            result[key] = fromJsonLdEntity(value);
-        }
-        else {
-            result[key] = value;
-        }
-    }
-    return result;
+    const { '@type': type, '@id': id, ...rest } = json;
+    const entity = Object.fromEntries(Object.entries(rest).map(([key, value]) => [key, fromJsonLdValue(value)]));
+    if (type !== undefined && !('@value' in json))
+        entity.type = type;
+    if (id !== undefined)
+        entity.id = id;
+    return entity;
 };
 // The export prefixes copy identifiers with `copy/`; this is its inverse.
 const withPlainCopyIds = (json) => ({

package/lib/index.d.ts

@@ -11,6 +11,8 @@ export * from './Collation';
 export * from './TrackCalibration';
 export * from './TrackerBar';
 export * from './systems/welteT100/bar';
+export * from './systems/welteLicensee/bar';
+export * from './systems';
 export * from './ReproducingSystem';
 export * from './RollCopy';
 export * from './alignment';
@@ -24,4 +26,4 @@ export * from './context';
 export * from './asJsonLd';
 export * from './importJsonLd';
 export { readFromStanfordAton, type StanfordAtonOptions } from './readers/stanfordAton';
-export { readFromSpencerMIDI, atConstantSpeed, spencerTrackOf, SPENCER_FEET_PER_MINUTE } from './readers/spencerMidi';
+export { readFromSpencerBar, readSpencerAnn, paperSpeedOfSpencerAnn, SPENCER_ROWS_PER_INCH, type SpencerBarOptions } from './readers/spencerBar';

package/lib/index.js

@@ -11,6 +11,8 @@ export * from './Collation';
 export * from './TrackCalibration';
 export * from './TrackerBar';
 export * from './systems/welteT100/bar';
+export * from './systems/welteLicensee/bar';
+export * from './systems';
 export * from './ReproducingSystem';
 export * from './RollCopy';
 export * from './alignment';
@@ -24,4 +26,4 @@ export * from './context';
 export * from './asJsonLd';
 export * from './importJsonLd';
 export { readFromStanfordAton } from './readers/stanfordAton';
-export { readFromSpencerMIDI, atConstantSpeed, spencerTrackOf, SPENCER_FEET_PER_MINUTE } from './readers/spencerMidi';
+export { readFromSpencerBar, readSpencerAnn, paperSpeedOfSpencerAnn, SPENCER_ROWS_PER_INCH } from './readers/spencerBar';

package/lib/migrate.js

@@ -12,7 +12,9 @@ const renamedKeys = {
 };
 const referenceKeys = ['alignedWith', 'pairedWith', 'basedOn'];
 const named = (name) => ({ name, sameAs: [] });
-const withRenamedKeys = (node) => Object.fromEntries(Object.entries(node).map(([key, value]) => [renamedKeys[key] ?? key, value]));
+const withRenamedKeys = (node) => Object.keys(node).some(key => Object.hasOwn(renamedKeys, key))
+    ? Object.fromEntries(Object.entries(node).map(([key, value]) => [renamedKeys[key] ?? key, value]))
+    : node;
 const withTypology = (node) => {
     if (versionTypeValues.has(node['@type'])) {
         return { ...node, '@type': 'Version', versionType: node['@type'] };
@@ -47,17 +49,43 @@ const withProductionNodes = (node) => {
             ...rest,
             ...(typeof company === 'string' ? (company && { company: named(company) }) : { company }),
             ...(typeof paper === 'string' ? (paper && { paper: named(paper) }) : { paper }),
+            // a 0.1 file named the roll's system here as text; a copy's own system is a node
+            ...(system && typeof system === 'object' && { system })
         }
     };
 };
-const migrateNode = (node) => [withRenamedKeys, withTypology, withReferences, withKeeper, withProductionNodes]
+const isPaperStretch = (condition) => condition?.conditionType === 'paper-stretch' || condition?.['@type'] === 'paper-stretch';
+/**
+ * The scale of an aligned copy used to be recorded only as the factor
+ * of its paper-stretch condition. It is the alignment's own number
+ * now, and the condition stays as the reading of it. The conditions
+ * are still in their old shape here, since a node is migrated before
+ * its children are.
+ */
+const withScale = (node) => {
+    if (!Array.isArray(node.ops) || !node.ops.includes('stretched') || node.measurements?.scale !== undefined)
+        return node;
+    const factor = (node.conditions ?? []).find(isPaperStretch)?.factor;
+    return factor === undefined ? node : { ...node, measurements: { ...node.measurements, scale: factor } };
+};
+const migrateNode = (node) => [withRenamedKeys, withTypology, withReferences, withKeeper, withProductionNodes, withScale]
     .reduce((result, step) => step(result), node);
+/** The items each walked, or the very same list where the walk changed none. */
+const walked = (items) => {
+    const result = items.map(walk);
+    return result.every((item, i) => item === items[i]) ? items : result;
+};
+/** The node with each child walked, or the very same node where the walk changed none. */
+const withWalkedChildren = (node) => {
+    const entries = Object.entries(node);
+    const result = entries.map(([key, child]) => [key, walk(child)]);
+    return result.every(([, child], i) => child === entries[i][1]) ? node : Object.fromEntries(result);
+};
 const walk = (value) => {
     if (Array.isArray(value))
-        return value.map(walk);
-    if (value && typeof value === 'object') {
-        return Object.fromEntries(Object.entries(migrateNode(value)).map(([key, child]) => [key, walk(child)]));
-    }
+        return walked(value);
+    if (value && typeof value === 'object')
+        return withWalkedChildren(migrateNode(value));
     return value;
 };
 /**

package/lib/readers/spencerBar.d.ts

@@ -0,0 +1,34 @@
+import { PaperSpeed, RollCopy } from "../RollCopy";
+import { TrackerBar } from "../TrackerBar";
+/**
+ * Rows of the image on an inch of paper. The player reads eight rows a
+ * second per unit of roll tempo (tempo 80 comes with a sample rate of
+ * 640 Hz), and the tempo counts tenths of a foot per minute, which puts
+ * 400 rows on an inch. This is the file's own calibration; whether the
+ * scanner kept it is for an alignment with other copies to tell.
+ */
+export declare const SPENCER_ROWS_PER_INCH = 400;
+export interface SpencerBarOptions {
+    /** Rows of the image on an inch of paper. */
+    rowsPerInch?: number;
+    /**
+     * The bar the file numbers its positions by, which is the bar of
+     * 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.
+ */
+export declare function readFromSpencerBar(buffer: ArrayBuffer, { rowsPerInch, system, bar }?: 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
+ * number and class, and the tempo the roll is played at.
+ */
+export declare const readSpencerAnn: (text: string) => ReadonlyMap<string, string>;
+/** The paper speed a `.ann` states through its roll tempo, where it states one. */
+export declare const paperSpeedOfSpencerAnn: (ann: ReadonlyMap<string, string>) => PaperSpeed | undefined;

package/lib/readers/spencerBar.js

@@ -0,0 +1,141 @@
+import { v4 } from "uuid";
+import { systemOf, translationBetween } from "../TrackerBar";
+import { welteT100 } from "../systems/welteT100/bar";
+import { welteLicensee } from "../systems/welteLicensee/bar";
+import { feetPerMinute, inMillimeters, px, track } from "../Quantity";
+/**
+ * Spencer Chase's e-roll file (`.bar`, "eRoll Tracker Bar Image") holds
+ * a roll as a list of events: a distance in rows of the scanned image,
+ * then the tracker bar position whose hole begins or ends on that row.
+ *
+ * Layout, as read off W225E.bar: four bytes (00 01 00 00), the tag F4
+ * and a null-terminated text ("/oldtrackname:..."), then the events,
+ * each an unsigned LEB128 distance and one position byte. A position
+ * byte of FF closes the list. A hole ends when its position turns up
+ * a second time.
+ */
+const TEXT_AT = 4;
+const TEXT_TAG = 0xF4;
+const END_OF_EVENTS = 0xFF;
+/**
+ * Rows of the image on an inch of paper. The player reads eight rows a
+ * second per unit of roll tempo (tempo 80 comes with a sample rate of
+ * 640 Hz), and the tempo counts tenths of a foot per minute, which puts
+ * 400 rows on an inch. This is the file's own calibration; whether the
+ * scanner kept it is for an alignment with other copies to tell.
+ */
+export const SPENCER_ROWS_PER_INCH = 400;
+const byteAt = (bytes, at) => {
+    const byte = bytes[at];
+    if (byte === undefined)
+        throw new Error(`Spencer .bar file ends early at byte ${at}`);
+    return byte;
+};
+const leb128 = (bytes, at) => {
+    let value = 0;
+    let next = at;
+    for (let weight = 1;; weight *= 128) {
+        const byte = byteAt(bytes, next++);
+        value += (byte & 0x7F) * weight;
+        if (!(byte & 0x80))
+            return { value, next };
+    }
+};
+const endOfText = (bytes, from) => {
+    const end = bytes.indexOf(0, from);
+    if (end < 0)
+        throw new Error('Spencer .bar file: the text is not terminated');
+    return end + 1;
+};
+function* eventsIn(bytes, from) {
+    let row = 0;
+    let at = from;
+    while (true) {
+        const distance = leb128(bytes, at);
+        const position = byteAt(bytes, distance.next);
+        if (position === END_OF_EVENTS)
+            return;
+        row += distance.value;
+        yield { row, position };
+        at = distance.next + 1;
+    }
+}
+/** Pairs the events of each position into holes: the first opens one, the next closes it. */
+const holesOf = (events) => {
+    const open = new Map();
+    const holes = [];
+    for (const { row, position } of events) {
+        const from = open.get(position);
+        if (from === undefined) {
+            open.set(position, row);
+        }
+        else {
+            holes.push({ position, from, to: row });
+            open.delete(position);
+        }
+    }
+    if (open.size > 0) {
+        throw new Error(`Spencer .bar file: holes on positions ${[...open.keys()].join(', ')} never end`);
+    }
+    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.
+ */
+export function readFromSpencerBar(buffer, { rowsPerInch = SPENCER_ROWS_PER_INCH, system = welteLicensee, bar = welteT100 } = {}) {
+    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)
+            return [];
+        return [{
+                type: 'Hole',
+                id: v4(),
+                vertical: {
+                    from: position,
+                    unit: 'track'
+                },
+                horizontal: {
+                    unit: 'mm',
+                    from: placeOf(hole.from),
+                    to: placeOf(hole.to)
+                }
+            }];
+    });
+    return {
+        type: 'RollCopy',
+        id: v4(),
+        ops: [],
+        conditions: [],
+        keeper: { name: '', sameAs: [] },
+        measurements: {},
+        production: { system: systemOf(system) },
+        modifications: [],
+        features
+    };
+}
+/**
+ * The `.ann` file beside a `.bar` holds the player's settings for the
+ * roll as lines of "/key:   value": title, composer, pianist, roll
+ * number and class, and the tempo the roll is played at.
+ */
+export const readSpencerAnn = (text) => new Map(text.split(/\r?\n/)
+    .map(line => line.match(/^\/(\w+):\s*(.*?)\s*$/))
+    .filter((match) => match !== null)
+    .map(([, key, value]) => [key, value]));
+/** A roll tempo counts tenths of a foot per minute: tempo 83 runs the roll at 8.3 feet a minute. */
+const TEMPO_PER_FOOT_PER_MINUTE = 10;
+/** The paper speed a `.ann` states through its roll tempo, where it states one. */
+export const paperSpeedOfSpencerAnn = (ann) => {
+    const tempo = parseFloat(ann.get('roll_tempo') ?? '');
+    if (isNaN(tempo) || tempo <= 0)
+        return undefined;
+    return { value: feetPerMinute(tempo / TEMPO_PER_FOOT_PER_MINUTE), unit: 'ft/min' };
+};

package/lib/readers/stanfordAton.d.ts

@@ -8,7 +8,15 @@ 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.
+     */
+    system?: TrackerBar;
     /**
      * Where the scan the analysis was made from can be seen. Stanford's
      * files name their scan by DRUID, so this is only needed for an
@@ -16,4 +24,4 @@ export interface StanfordAtonOptions {
      */
     scan?: string;
 }
-export declare function readFromStanfordAton(atonString: string, { trackShift, bar, scan }?: StanfordAtonOptions): RollCopy;
+export declare function readFromStanfordAton(atonString: string, { trackShift, bar, system, scan }?: StanfordAtonOptions): RollCopy;