linked-rolls 0.11.0 → 0.13.0

package/lib/Quantity.d.ts

@@ -58,4 +58,8 @@ export declare const mean: <U extends Unit>(values: readonly Quantity<U>[]) => Q
 export declare const inMillimeters: (place: Pixels, dpi: number) => Millimeters;
 export declare const inCentimeters: (length: Millimeters) => Centimeters;
 export declare const inSeconds: (time: Milliseconds) => Seconds;
+/** A speed as a record states it, in feet or metres per minute. */
+export type SpeedMeasure = Measure<'ft/min'> | Measure<'m/min'>;
+/** A speed in metres per minute, whichever unit it was stated in. */
+export declare const inMetersPerMinute: (speed: SpeedMeasure) => MetersPerMinute;
 export {};

package/lib/Quantity.js

@@ -23,3 +23,6 @@ const MM_PER_INCH = 25.4;
 export const inMillimeters = (place, dpi) => mm(place / dpi * MM_PER_INCH);
 export const inCentimeters = (length) => cm(length / 10);
 export const inSeconds = (time) => seconds(time / 1000);
+const METERS_PER_FOOT = 0.3048;
+/** A speed in metres per minute, whichever unit it was stated in. */
+export const inMetersPerMinute = (speed) => speed.unit === 'm/min' ? speed.value : metersPerMinute(speed.value * METERS_PER_FOOT);

package/lib/RollCopy.d.ts

@@ -51,9 +51,28 @@ export interface Margins<U extends 'px' | 'mm'> {
     bass: Quantity<U>;
     unit: U;
 }
+/**
+ * A paper speed, as a roll's label, its catalogue or its format
+ * states it.
+ * @see crm:E54 Dimension
+ */
+export type PaperSpeed = Measure<'ft/min'> | Measure<'m/min'>;
+/**
+ * What the scale an alignment found is put down to: the paper of the
+ * copy having stretched or shrunk, or the copy having been cut for
+ * another paper speed than the roll it is aligned with.
+ */
+export type ScaleReading = {
+    cause: 'paper';
+    condition: ObjectAssumption<PaperStretch>;
+} | {
+    cause: 'speed';
+    speed: ObjectAssumption<PaperSpeed>;
+};
 /**
  * Describes the production of a roll copy: the manufacturer,
- * the paper used, and the date.
+ * the paper used, the date, and the system and paper speed the
+ * copy was cut for.
  * @see lrmoo:F32 Item Production Event
  */
 export interface ProductionEvent {
@@ -73,6 +92,22 @@ export interface ProductionEvent {
      * @see dcterms:date
      */
     date?: DateAssignment;
+    /**
+     * The reproducing system the copy was cut for. Left out, it is
+     * the roll's own; a Licensee re-cut of a T-100 roll names the
+     * Licensee here. A system the type vocabulary knows carries the
+     * IRI of its concept as `id`.
+     * @see crm:P32 used general technique
+     */
+    system?: Concept;
+    /**
+     * The paper speed the copy was cut for. A copy cut from the same
+     * master for another speed comes out longer or shorter than the
+     * roll it is aligned with by the ratio of the speeds, which is
+     * what the alignment then measures.
+     * @see reo:paperSpeed
+     */
+    speed?: ObjectAssumption<PaperSpeed>;
 }
 /**
  * This type denotes identifiable activities that modified
@@ -179,6 +214,13 @@ export interface RollCopy extends WithType<'RollCopy'>, WithId {
          * Not exported to RDF.
          */
         shift: Shift;
+        /**
+         * The factor this copy's features were scaled by to align them
+         * with the others. What it is put down to is stated apart: a
+         * paper-stretch condition, or the speed the copy was cut for.
+         * Not exported to RDF.
+         */
+        scale: number;
         /**
          * Relates this copy's scan to the tracker bar: how the scanning
          * software's hole numbering was shifted onto the bar, and where

package/lib/TrackerBar.d.ts

@@ -1,6 +1,6 @@
 import type { Concept } from "./Agent";
 import { Expression, Note } from "./Symbol";
-import { Millimeters, Track } from "./Quantity";
+import { Millimeters, SpeedMeasure, Track } from "./Quantity";
 /**
  * What a tracker bar position does: sound a note, or operate one of
  * the expression valves on the bass or the treble side.
@@ -50,6 +50,12 @@ export interface TrackerBar {
      * a scan against the bar.
      */
     readonly rewindTrack: Track;
+    /**
+     * The paper speed the system runs its rolls at, where the
+     * literature states one. A system whose rolls each carry a tempo
+     * of their own, as the Licensee's do, states none.
+     */
+    readonly paperSpeed?: SpeedMeasure;
     /** `undefined` for a position the bar does not read. */
     meaningOf(position: Track): TrackMeaning | undefined;
     /** `undefined` for a position the bar does not read. */
@@ -77,5 +83,14 @@ export interface TrackerBarSpec {
     };
     /** Every position outside the note block, keyed by track. */
     expressions: ReadonlyMap<number, string>;
+    /** The speed the system runs its rolls at, where the literature states one. */
+    paperSpeed?: SpeedMeasure;
 }
 export declare const describeTrackerBar: (spec: TrackerBarSpec) => TrackerBar;
+/**
+ * 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.
+ */
+export declare const translationBetween: (from: TrackerBar, to: TrackerBar) => (position: Track) => Track | undefined;

package/lib/TrackerBar.js

@@ -41,7 +41,28 @@ export const describeTrackerBar = (spec) => {
         areas,
         expressionTypes: [...new Set(spec.expressions.values())],
         rewindTrack: track(rewind),
+        ...(spec.paperSpeed && { paperSpeed: spec.paperSpeed }),
         meaningOf,
         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.
+ */
+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;
+    };
+};

package/lib/alignment.d.ts

@@ -1,22 +1,35 @@
-import { ObjectAssumption } from "./Assumption";
 import { AnyFeature } from "./Feature";
-import { PaperStretch, RollCopy, Shift } from "./RollCopy";
+import { RollCopy, Shift } from "./RollCopy";
 import { TrackerBar } from "./TrackerBar";
 import { Millimeters } from "./Quantity";
 export declare const applyShift: (shift: Shift, copy: RollCopy) => void;
-export declare const applyStretch: (paperStretch: ObjectAssumption<PaperStretch>, copy: RollCopy) => void;
+/** Scales the copy's features away from the beginning of the roll, and records the factor. */
+export declare const applyScale: (factor: number, copy: RollCopy) => void;
 /** Takes the shift off the copy's features again, as far as one was applied. */
 export declare const revertShift: (copy: RollCopy) => void;
-/** Takes the stretch off the copy's features again, as far as one was applied. */
-export declare const revertStretch: (copy: RollCopy) => void;
-type AlignmentResult = {
-    /** Applied before the stretch. */
+/** Takes the scale off the copy's features again, as far as one was applied. */
+export declare const revertScale: (copy: RollCopy) => void;
+/**
+ * How a copy's places are carried onto another copy's:
+ * `x_other = (x + shift) · scale`.
+ */
+export interface AlignmentResult {
+    /** Applied before the scale. */
     shift: Millimeters;
-    stretch: number;
-};
+    scale: number;
+    /** The notes of the copy that found their counterpart on the other. */
+    matched: number;
+    /** How far the counterparts still lie apart, as a root mean square in the other copy's millimetres. */
+    residual: Millimeters;
+}
 /**
- * Align two rolls by computing independent linear fits of each roll's note-onset positions
- * using only the first and last segments, then deriving a transform x2 = (x1 + shift) * stretch.
+ * Finds the shift and scale that carry the places of `rollA` onto those
+ * of `rollB`, reading both through the bar. Runs of pitches that occur
+ * once on each roll anchor a first line; then every note is paired with
+ * its nearest counterpart of the same pitch and the line refitted, the
+ * window closing each time. A copy cut for another paper speed, a scan
+ * with a calibration pattern, and holes the other copy lacks are all
+ * within reach of that. Nothing is found where the rolls share no run of
+ * pitches, as between two different pieces.
  */
-export declare function alignFeatures(rollA: AnyFeature[], rollB: AnyFeature[], bar?: TrackerBar): AlignmentResult;
-export {};
+export declare function alignFeatures(rollA: readonly AnyFeature[], rollB: readonly AnyFeature[], bar?: TrackerBar): AlignmentResult | undefined;

package/lib/alignment.js

@@ -23,12 +23,13 @@ export const applyShift = (shift, copy) => {
     copy.ops = [...copy.ops, 'shifted'];
     copy.measurements.shift = shift;
 };
-export const applyStretch = (paperStretch, copy) => {
+/** Scales the copy's features away from the beginning of the roll, and records the factor. */
+export const applyScale = (factor, copy) => {
     if (copy.ops.includes('stretched'))
         return;
-    copy.features.forEach(feature => stretch(feature.horizontal, paperStretch.factor));
+    copy.features.forEach(feature => stretch(feature.horizontal, factor));
     copy.ops = [...copy.ops, 'stretched'];
-    copy.conditions.push(paperStretch);
+    copy.measurements.scale = factor;
 };
 /** Takes the shift off the copy's features again, as far as one was applied. */
 export const revertShift = (copy) => {
@@ -43,67 +44,134 @@ export const revertShift = (copy) => {
     copy.ops = copy.ops.filter(op => op !== 'shifted');
     delete copy.measurements.shift;
 };
-const isPaperStretch = (condition) => condition.conditionType === 'paper-stretch';
-/** Takes the stretch off the copy's features again, as far as one was applied. */
-export const revertStretch = (copy) => {
-    const applied = copy.conditions.find(isPaperStretch);
-    if (!copy.ops.includes('stretched') || !applied)
+/** Takes the scale off the copy's features again, as far as one was applied. */
+export const revertScale = (copy) => {
+    const factor = copy.measurements.scale;
+    if (!copy.ops.includes('stretched') || factor === undefined)
         return;
-    copy.features.forEach(feature => stretch(feature.horizontal, 1 / applied.factor));
+    copy.features.forEach(feature => stretch(feature.horizontal, 1 / factor));
     copy.ops = copy.ops.filter(op => op !== 'stretched');
-    copy.conditions = copy.conditions.filter(condition => !isPaperStretch(condition));
+    delete copy.measurements.scale;
 };
-const isNoteOn = (bar) => (feature) => {
-    return feature.type === 'Hole' && bar.meaningOf(feature.vertical.from)?.type === 'note';
+const byPlace = (x, y) => x.at - y.at || x.pitch - y.pitch;
+/** The notes the bar reads off the features, in the order they pass it. */
+const noteOnsets = (features, bar) => features
+    .flatMap((feature) => {
+    if (feature.type !== 'Hole')
+        return [];
+    const meaning = bar.meaningOf(feature.vertical.from);
+    return meaning?.type === 'note' ? [{ pitch: meaning.pitch, at: feature.horizontal.from }] : [];
+})
+    .sort(byPlace);
+const median = (values) => {
+    const sorted = [...values].sort((x, y) => x - y);
+    return sorted[Math.floor(sorted.length / 2)] ?? 0;
 };
+/** The slope of the line through two matches, or nothing where they share a place on the copy. */
+const slopeBetween = (m, n) => n.a === m.a ? [] : [(n.b - m.b) / (n.a - m.a)];
+/** Matches beyond this are thinned before the slopes are taken, whose number grows with the square. */
+const SLOPE_SAMPLE = 1500;
 /**
- * Fit a line: position = alpha * index + beta via least squares.
+ * The line of the median slope and the median intercept, after Theil
+ * and Sen. A minority of matches at odds with the rest, as from a
+ * passage the copy retimes or from an anchor set by chance, leaves it
+ * unmoved, where a least-squares line would tilt towards them.
  */
-function fitIndexToPosition(indices, positions) {
-    const n = indices.length;
-    const meanIdx = indices.reduce((s, i) => s + i, 0) / n;
-    const meanPos = positions.reduce((s, p) => s + p, 0) / n;
-    let num = 0;
-    let den = 0;
-    for (let i = 0; i < n; i++) {
-        const d = indices[i] - meanIdx;
-        num += d * (positions[i] - meanPos);
-        den += d * d;
+const robustLine = (matches) => {
+    const step = Math.max(1, Math.ceil(matches.length / SLOPE_SAMPLE));
+    const sample = matches.filter((_, i) => i % step === 0);
+    const slopes = sample.flatMap((m, i) => sample.slice(i + 1).flatMap(n => slopeBetween(m, n)));
+    if (slopes.length === 0)
+        return undefined;
+    const slope = median(slopes);
+    return { slope, intercept: median(matches.map(m => m.b - slope * m.a)) };
+};
+const placed = (line, a) => line.slope * a + line.intercept;
+const residualOf = (line, match) => match.b - placed(line, match.a);
+/** Pitches in a row that pin down a place on a roll, provided the row occurs once. */
+const ANCHOR_LENGTH = 6;
+/** Every run of `length` pitches, keyed by the run, with the onsets it starts at. */
+const runsOf = (onsets, length) => {
+    const runs = new Map();
+    onsets.slice(0, Math.max(0, onsets.length - length + 1)).forEach((start, i) => {
+        const key = onsets.slice(i, i + length).map(onset => onset.pitch).join(',');
+        runs.set(key, [...(runs.get(key) ?? []), start]);
+    });
+    return runs;
+};
+/** The places a run of pitches found once on each roll ties together. */
+const anchors = (a, b) => {
+    const runsB = runsOf(b, ANCHOR_LENGTH);
+    return [...runsOf(a, ANCHOR_LENGTH)]
+        .flatMap(([key, starts]) => {
+        const others = runsB.get(key);
+        return starts.length === 1 && others?.length === 1
+            ? [{ a: starts[0].at, b: others[0].at }]
+            : [];
+    });
+};
+/** Takes the candidates nearest first, each onset going into one pair only. */
+const pairedNearestFirst = (candidates) => {
+    const taken = new Set();
+    const matches = [];
+    for (const candidate of [...candidates].sort((x, y) => x.distance - y.distance)) {
+        if (taken.has(candidate.a) || taken.has(candidate.b))
+            continue;
+        taken.add(candidate.a);
+        taken.add(candidate.b);
+        matches.push({ a: candidate.a.at, b: candidate.b.at });
     }
-    const alpha = den === 0 ? 1 : num / den;
-    const beta = meanPos - alpha * meanIdx;
-    return { alpha, beta };
-}
+    return matches;
+};
+/** Each onset of A paired with the nearest onset of B of its pitch within the window around where the line puts it. */
+const nearestMatches = (a, b, line, window) => {
+    const bByPitch = new Map();
+    b.forEach(onset => bByPitch.set(onset.pitch, [...(bByPitch.get(onset.pitch) ?? []), onset]));
+    const candidates = a.flatMap(onset => {
+        const expected = placed(line, onset.at);
+        return (bByPitch.get(onset.pitch) ?? [])
+            .map(other => ({ distance: Math.abs(other.at - expected), a: onset, b: other }))
+            .filter(candidate => candidate.distance <= window);
+    });
+    return pairedNearestFirst(candidates);
+};
 /**
- * Selects the first and last N elements of an array (or fewer if length is smaller).
+ * Windows, in the other roll's millimetres, narrowed as the line settles.
+ * The first is wide enough to catch what a line extrapolated from the
+ * anchors misses at the ends of a long roll; the last is narrow enough
+ * to leave out a passage the copy retimed.
  */
-function selectEnds(arr, count) {
-    const n = arr.length;
-    if (count * 2 >= n)
-        return arr.slice();
-    return arr.slice(0, count).concat(arr.slice(n - count, n));
-}
+const WINDOWS = [mm(40), mm(15), mm(6)];
+const settled = (a, b) => (fit, window) => {
+    const matches = nearestMatches(a, b, fit.line, window);
+    return { line: robustLine(matches) ?? fit.line, matches };
+};
+const resultOf = ({ line, matches }) => {
+    if (matches.length < 2 || line.slope <= 0)
+        return undefined;
+    const squares = matches.reduce((total, m) => total + residualOf(line, m) ** 2, 0);
+    return {
+        shift: mm(line.intercept / line.slope),
+        scale: line.slope,
+        matched: matches.length,
+        residual: mm(Math.sqrt(squares / matches.length))
+    };
+};
 /**
- * Align two rolls by computing independent linear fits of each roll's note-onset positions
- * using only the first and last segments, then deriving a transform x2 = (x1 + shift) * stretch.
+ * Finds the shift and scale that carry the places of `rollA` onto those
+ * of `rollB`, reading both through the bar. Runs of pitches that occur
+ * once on each roll anchor a first line; then every note is paired with
+ * its nearest counterpart of the same pitch and the line refitted, the
+ * window closing each time. A copy cut for another paper speed, a scan
+ * with a calibration pattern, and holes the other copy lacks are all
+ * within reach of that. Nothing is found where the rolls share no run of
+ * pitches, as between two different pieces.
  */
 export function alignFeatures(rollA, rollB, bar = welteT100) {
-    // 1. Extract note-onset positions
-    const isNote = isNoteOn(bar);
-    const allXA = rollA.filter(isNote).map(f => f.horizontal.from);
-    const allXB = rollB.filter(isNote).map(f => f.horizontal.from);
-    // 2. Determine segment size (e.g. 10% of notes, min 5)
-    const segCount = Math.max(5, Math.floor(allXA.length * 0.1));
-    // 3. Select only first and last segments
-    const XA = selectEnds(allXA, segCount);
-    const idxA = XA.map((_, i) => i);
-    const XB = selectEnds(allXB, segCount);
-    const idxB = XB.map((_, i) => i);
-    // 4. Fit index->position for each roll on selected ends
-    const { alpha: alphaA, beta: betaA } = fitIndexToPosition(idxA, XA);
-    const { alpha: alphaB, beta: betaB } = fitIndexToPosition(idxB, XB);
-    // 5. Derive stretch and shift such that x2 = (x1 + shift) * stretch
-    const stretch = alphaB / alphaA;
-    const shift = mm(betaB / stretch - betaA);
-    return { stretch, shift };
+    const a = noteOnsets(rollA, bar);
+    const b = noteOnsets(rollB, bar);
+    const coarse = robustLine(anchors(a, b));
+    if (!coarse)
+        return undefined;
+    return resultOf(WINDOWS.reduce(settled(a, b), { line: coarse, matches: [] }));
 }

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

@@ -5,7 +5,7 @@ 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;
@@ -64,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));
 /**

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 { readFromSpencerBar, licenseeOnT100, SPENCER_ROWS_PER_INCH, type SpencerBarOptions } from './readers/spencerBar';
+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 { readFromSpencerBar, licenseeOnT100, SPENCER_ROWS_PER_INCH } from './readers/spencerBar';
+export { readFromSpencerBar, readSpencerAnn, paperSpeedOfSpencerAnn, SPENCER_ROWS_PER_INCH } from './readers/spencerBar';

package/lib/migrate.js

@@ -49,10 +49,26 @@ 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) => {

package/lib/readers/spencerBar.d.ts

@@ -1,5 +1,5 @@
-import { RollCopy } from "../RollCopy";
-import { Track } from "../Quantity";
+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
@@ -8,11 +8,27 @@ import { Track } from "../Quantity";
  * scanner kept it is for an alignment with other copies to tell.
  */
 export declare const SPENCER_ROWS_PER_INCH = 400;
-export declare const licenseeOnT100: (position: number) => Track;
 export interface SpencerBarOptions {
     /** Rows of the image on an inch of paper. */
     rowsPerInch?: number;
-    /** Puts a position the file names onto the edition's bar. */
-    trackOf?: (position: number) => Track;
+    /**
+     * 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;
 }
-export declare function readFromSpencerBar(buffer: ArrayBuffer, { rowsPerInch, trackOf }?: SpencerBarOptions): RollCopy;
+/**
+ * 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

@@ -1,6 +1,8 @@
 import { v4 } from "uuid";
+import { systemOf, translationBetween } from "../TrackerBar";
 import { welteT100 } from "../systems/welteT100/bar";
-import { inMillimeters, px, track } from "../Quantity";
+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,
@@ -23,16 +25,6 @@ const END_OF_EVENTS = 0xFF;
  * scanner kept it is for an alignment with other copies to tell.
  */
 export const SPENCER_ROWS_PER_INCH = 400;
-/**
- * The file numbers positions as the 98-hole Welte Licensee bar does.
- * Its bass controls are the T-100's tracks 1 to 8, it has no motor
- * tracks, and its note block follows the controls at once, so from
- * there on every position lies two tracks lower than on the T-100 bar.
- * Checked valve by valve on roll 225 against the Stanford copies.
- */
-const LICENSEE_NOTES_FROM = 9;
-const T100_NOTES_FROM = welteT100.areas.find(area => area.role === 'note').from;
-export const licenseeOnT100 = (position) => track(position < LICENSEE_NOTES_FROM ? position : position + T100_NOTES_FROM - LICENSEE_NOTES_FROM);
 const byteAt = (bytes, at) => {
     const byte = bytes[at];
     if (byte === undefined)
@@ -87,26 +79,36 @@ const holesOf = (events) => {
     }
     return holes.sort((a, b) => a.from - b.from);
 };
-export function readFromSpencerBar(buffer, { rowsPerInch = SPENCER_ROWS_PER_INCH, trackOf = licenseeOnT100 } = {}) {
+/**
+ * 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)))
-        .map((hole) => ({
-        type: 'Hole',
-        id: v4(),
-        vertical: {
-            from: trackOf(hole.position),
-            unit: 'track'
-        },
-        horizontal: {
-            unit: 'mm',
-            from: placeOf(hole.from),
-            to: placeOf(hole.to)
-        }
-    }));
+        .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(),
@@ -114,7 +116,26 @@ export function readFromSpencerBar(buffer, { rowsPerInch = SPENCER_ROWS_PER_INCH
         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;

package/lib/readers/stanfordAton.js

@@ -1,5 +1,6 @@
 import { v4 } from "uuid";
 import { AtonParser } from "./AtonParser";
+import { systemOf, translationBetween } from "../TrackerBar";
 import { welteT100 } from "../systems/welteT100/bar";
 import { inMillimeters, mean, mm, px, subtract, track } from "../Quantity";
 /** Values in these files carry their unit as a suffix, e.g. "37.7646px". */
@@ -82,7 +83,7 @@ const measuredByOf = (rollinfo) => {
         date
     };
 };
-export function readFromStanfordAton(atonString, { trackShift, bar = welteT100, scan } = {}) {
+export function readFromStanfordAton(atonString, { trackShift, bar = welteT100, system = bar, scan } = {}) {
     const parser = new AtonParser();
     const json = parser.parse(atonString);
     const holes = json.ROLLINFO.HOLES.HOLE;
@@ -93,7 +94,7 @@ export function readFromStanfordAton(atonString, { trackShift, bar = welteT100,
     const measuredBy = measuredByOf(json.ROLLINFO);
     const rewindTrack = rewindTrackIn(holes);
     const shift = trackShift
-        ?? (rewindTrack === undefined ? track(0) : track(bar.rewindTrack - rewindTrack));
+        ?? (rewindTrack === undefined ? track(0) : track(system.rewindTrack - rewindTrack));
     const calibration = {
         unit: 'px',
         offset: gridOffsetOf(holes, separation, json.ROLLINFO.HOLE_OFFSET),
@@ -102,26 +103,30 @@ export function readFromStanfordAton(atonString, { trackShift, bar = welteT100,
     };
     const punchDiameter = punchDiameterOf(holes, dpi);
     const chains = chainsAmong([...holes, ...chainedBadHoles(listOf(json.ROLLINFO.BADHOLES?.HOLE), calibration)]);
+    const onBar = translationBetween(system, bar);
     const features = chains
-        .map(({ hole, attack, release }) => {
+        .flatMap(({ hole, attack, release }) => {
+        const position = onBar(track(+hole.TRACKER_HOLE + shift));
+        if (position === undefined)
+            return [];
         const column = readPx(hole.ORIGIN_COL);
         const columnWidth = readPx(hole.WIDTH_COL);
-        return {
-            type: 'Hole',
-            id: v4(),
-            ...(stanford && {
-                depiction: stanford.depictionOf(column, attack, columnWidth, subtract(release, attack))
-            }),
-            vertical: {
-                from: track(+hole.TRACKER_HOLE + shift),
-                unit: 'track'
-            },
-            horizontal: {
-                unit: 'mm',
-                from: inMillimeters(attack, dpi),
-                to: inMillimeters(release, dpi)
-            }
-        };
+        return [{
+                type: 'Hole',
+                id: v4(),
+                ...(stanford && {
+                    depiction: stanford.depictionOf(column, attack, columnWidth, subtract(release, attack))
+                }),
+                vertical: {
+                    from: position,
+                    unit: 'track'
+                },
+                horizontal: {
+                    unit: 'mm',
+                    from: inMillimeters(attack, dpi),
+                    to: inMillimeters(release, dpi)
+                }
+            }];
     });
     return {
         type: 'RollCopy',
@@ -129,6 +134,7 @@ export function readFromStanfordAton(atonString, { trackShift, bar = welteT100,
         ops: [],
         conditions: [],
         keeper: { name: '', sameAs: [] },
+        production: { system: systemOf(system) },
         modifications: [],
         ...((scan ?? stanford) && { scan: scan ?? stanford?.scan }),
         measurements: {

package/lib/schema.json

@@ -1239,6 +1239,83 @@
             ],
             "type": "object"
         },
+        "ObjectAssumption<PaperSpeed>": {
+            "anyOf": [
+                {
+                    "properties": {
+                        "@annotation": {
+                            "description": "An optional annotation expressing a belief about this assumption. Uses the JSON-LD-star `@annotation` mechanism to attach epistemic metadata (certainty and reasons) to any triple.",
+                            "properties": {
+                                "belief": {
+                                    "$ref": "#/definitions/Belief",
+                                    "description": "The belief held about the annotated statement. [ontology: crminf:J4i is subject of]"
+                                },
+                                "@id": {
+                                    "description": "A unique identifier for this object.",
+                                    "type": "string"
+                                }
+                            },
+                            "required": [
+                                "belief",
+                                "@id"
+                            ],
+                            "type": "object"
+                        },
+                        "unit": {
+                            "const": "ft/min",
+                            "description": "The unit of measurement. [ontology: crm:P91 has unit]",
+                            "type": "string"
+                        },
+                        "value": {
+                            "$ref": "#/definitions/Quantity%3C%22ft%2Fmin%22%3E",
+                            "description": "The measured value. [ontology: crm:P90 has value]"
+                        }
+                    },
+                    "required": [
+                        "unit",
+                        "value"
+                    ],
+                    "type": "object"
+                },
+                {
+                    "properties": {
+                        "@annotation": {
+                            "description": "An optional annotation expressing a belief about this assumption. Uses the JSON-LD-star `@annotation` mechanism to attach epistemic metadata (certainty and reasons) to any triple.",
+                            "properties": {
+                                "belief": {
+                                    "$ref": "#/definitions/Belief",
+                                    "description": "The belief held about the annotated statement. [ontology: crminf:J4i is subject of]"
+                                },
+                                "@id": {
+                                    "description": "A unique identifier for this object.",
+                                    "type": "string"
+                                }
+                            },
+                            "required": [
+                                "belief",
+                                "@id"
+                            ],
+                            "type": "object"
+                        },
+                        "unit": {
+                            "const": "m/min",
+                            "description": "The unit of measurement. [ontology: crm:P91 has unit]",
+                            "type": "string"
+                        },
+                        "value": {
+                            "$ref": "#/definitions/Quantity%3C%22m%2Fmin%22%3E",
+                            "description": "The measured value. [ontology: crm:P90 has value]"
+                        }
+                    },
+                    "required": [
+                        "unit",
+                        "value"
+                    ],
+                    "type": "object"
+                }
+            ],
+            "description": "An object assumption wraps a complex object with an optional annotation. Used for structured values (e.g. persons, conditions) whose properties may be uncertain."
+        },
         "ObjectAssumption<Person>": {
             "description": "An object assumption wraps a complex object with an optional annotation. Used for structured values (e.g. persons, conditions) whose properties may be uncertain.",
             "properties": {
@@ -1462,7 +1539,7 @@
             "type": "object"
         },
         "ProductionEvent": {
-            "description": "Describes the production of a roll copy: the manufacturer, the paper used, and the date. [ontology: lrmoo:F32 Item Production Event]",
+            "description": "Describes the production of a roll copy: the manufacturer, the paper used, the date, and the system and paper speed the copy was cut for. [ontology: lrmoo:F32 Item Production Event]",
             "properties": {
                 "company": {
                     "$ref": "#/definitions/Agent",
@@ -1475,6 +1552,14 @@
                 "paper": {
                     "$ref": "#/definitions/Concept",
                     "description": "The paper the roll copy was cut on. [ontology: crm:P126 employed]"
+                },
+                "speed": {
+                    "$ref": "#/definitions/ObjectAssumption%3CPaperSpeed%3E",
+                    "description": "The paper speed the copy was cut for. A copy cut from the same master for another speed comes out longer or shorter than the roll it is aligned with by the ratio of the speeds, which is what the alignment then measures. [ontology: reo:paperSpeed]"
+                },
+                "system": {
+                    "$ref": "#/definitions/Concept",
+                    "description": "The reproducing system the copy was cut for. Left out, it is the roll's own; a Licensee re-cut of a T-100 roll names the Licensee here. A system the type vocabulary knows carries the IRI of its concept as `id`. [ontology: crm:P32 used general technique]"
                 }
             },
             "type": "object"
@@ -1694,6 +1779,10 @@
                             "$ref": "#/definitions/Measure%3C%22mm%22%3E",
                             "description": "The average diameter of punched holes. [ontology: reo:punchDiameter]"
                         },
+                        "scale": {
+                            "description": "The factor this copy's features were scaled by to align them with the others. What it is put down to is stated apart: a paper-stretch condition, or the speed the copy was cut for. Not exported to RDF.",
+                            "type": "number"
+                        },
                         "shift": {
                             "$ref": "#/definitions/Shift",
                             "description": "The shift applied to align this copy with the others. Not exported to RDF."

package/lib/spec/context.json

@@ -123,6 +123,7 @@
             "@id": "crm:P39i_was_measured_by",
             "@context": {
                 "shift": null,
+                "scale": null,
                 "trackCalibration": null,
                 "margins": null,
                 "dimensions": "reo:dimensions",
@@ -136,7 +137,16 @@
                 "version": "owl:versionInfo"
             }
         },
-        "production": "lrmoo:R28i_was_produced_by",
+        "production": {
+            "@id": "lrmoo:R28i_was_produced_by",
+            "@context": {
+                "system": "crm:P32_used_general_technique",
+                "speed": {
+                    "@id": "reo:paperSpeed",
+                    "@context": { "value": "crm:P90_has_value" }
+                }
+            }
+        },
         "company": "crm:P14_carried_out_by",
         "paper": "crm:P126_employed",
         "conditions": "crm:P44_has_condition",

package/lib/systems/index.d.ts

@@ -0,0 +1,6 @@
+import { Concept } from "../Agent";
+import { TrackerBar } from "../TrackerBar";
+/** The tracker bars the library knows, the T-100 first as the usual one. */
+export declare const trackerBars: readonly TrackerBar[];
+/** The bar of a system the type vocabulary knows, from its concept. */
+export declare const trackerBarOf: (system: Concept | undefined) => TrackerBar | undefined;

package/lib/systems/index.js

@@ -0,0 +1,10 @@
+import { systemIdOf } from "../TrackerBar";
+import { welteT100 } from "./welteT100/bar";
+import { welteLicensee } from "./welteLicensee/bar";
+/** The tracker bars the library knows, the T-100 first as the usual one. */
+export const trackerBars = [welteT100, welteLicensee];
+/** The bar of a system the type vocabulary knows, from its concept. */
+export const trackerBarOf = (system) => {
+    const id = systemIdOf(system);
+    return trackerBars.find(bar => bar.id === id);
+};

package/lib/systems/welteLicensee/bar.d.ts

@@ -0,0 +1,11 @@
+import { TrackerBar } from "../../TrackerBar";
+/**
+ * Welte-Mignon (Licensee), the American re-cut of the T-100 rolls on
+ * a roll 11¼ inches wide with 98 positions at nine to the inch, cf.
+ * Hagmann, p. 40 f. and Phillips, p. 123. It reads the same commands
+ * as the T-100 and lays them out the same way, minus the two motor
+ * tracks, so the note block and the treble valves sit two positions
+ * lower. The layout is the one Stanford's midi2exp reads, checked
+ * valve by valve on roll 225 against the T-100 copies.
+ */
+export declare const welteLicensee: TrackerBar;

package/lib/systems/welteLicensee/bar.js

@@ -0,0 +1,38 @@
+import { describeTrackerBar } from "../../TrackerBar";
+import { mm } from "../../Quantity";
+/**
+ * Welte-Mignon (Licensee), the American re-cut of the T-100 rolls on
+ * a roll 11¼ inches wide with 98 positions at nine to the inch, cf.
+ * Hagmann, p. 40 f. and Phillips, p. 123. It reads the same commands
+ * as the T-100 and lays them out the same way, minus the two motor
+ * tracks, so the note block and the treble valves sit two positions
+ * lower. The layout is the one Stanford's midi2exp reads, checked
+ * valve by valve on roll 225 against the T-100 copies.
+ */
+export const welteLicensee = describeTrackerBar({
+    id: 'welte-licensee',
+    name: 'Welte-Mignon (Licensee)',
+    width: mm(285.75),
+    trackCount: 98,
+    notes: { from: 9, to: 88, lowestPitch: 24 },
+    expressions: new Map([
+        [1, 'MezzoforteOff'],
+        [2, 'MezzoforteOn'],
+        [3, 'SlowCrescendoOff'],
+        [4, 'SlowCrescendoOn'],
+        [5, 'ForzandoOff'],
+        [6, 'ForzandoOn'],
+        [7, 'SoftPedalOff'],
+        [8, 'SoftPedalOn'],
+        [89, 'Rewind'],
+        [90, 'ElectricCutOff'],
+        [91, 'SustainPedalOn'],
+        [92, 'SustainPedalOff'],
+        [93, 'ForzandoOn'],
+        [94, 'ForzandoOff'],
+        [95, 'SlowCrescendoOn'],
+        [96, 'SlowCrescendoOff'],
+        [97, 'MezzoforteOn'],
+        [98, 'MezzoforteOff']
+    ])
+});

package/lib/systems/welteT100/bar.d.ts

@@ -9,6 +9,7 @@ export type WelteT100ExpressionType = typeof welteT100ExpressionTypes[number];
  *
  * The note block spans 80 positions from C1 to g⁴, i.e. MIDI 24 to 103.
  * The expression valves are duplicated, bass below the note block and
- * treble above it, in mirrored order.
+ * treble above it, in mirrored order. The rolls run at three metres a
+ * minute (Phillips 2016, p. 113; Bärtsch 2020 gives 3 or 2.9).
  */
 export declare const welteT100: TrackerBar;

package/lib/systems/welteT100/bar.js

@@ -1,5 +1,5 @@
 import { describeTrackerBar } from "../../TrackerBar";
-import { mm } from "../../Quantity";
+import { metersPerMinute, mm } from "../../Quantity";
 /**
  * The commands of the Welte-Mignon T-100, as its tracker bar reads them.
  */
@@ -24,7 +24,8 @@ export const welteT100ExpressionTypes = [
  *
  * The note block spans 80 positions from C1 to g⁴, i.e. MIDI 24 to 103.
  * The expression valves are duplicated, bass below the note block and
- * treble above it, in mirrored order.
+ * treble above it, in mirrored order. The rolls run at three metres a
+ * minute (Phillips 2016, p. 113; Bärtsch 2020 gives 3 or 2.9).
  */
 export const welteT100 = describeTrackerBar({
     id: 'welte-t100',
@@ -32,6 +33,7 @@ export const welteT100 = describeTrackerBar({
     width: mm(328),
     trackCount: 100,
     notes: { from: 11, to: 90, lowestPitch: 24 },
+    paperSpeed: { value: metersPerMinute(3), unit: 'm/min' },
     expressions: new Map([
         [1, 'MezzoforteOff'],
         [2, 'MezzoforteOn'],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linked-rolls",
-  "version": "0.11.0",
+  "version": "0.13.0",
   "description": "Digital editions of piano rolls: import, collation, editorial assumptions, JSON-LD export, and emulation through a reproducing system",
   "license": "MIT",
   "repository": {