linked-rolls 0.10.1 → 0.12.0

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". */
@@ -50,6 +51,10 @@ const gridOffsetOf = (holes, separation, stated) => {
         return readPx(stated);
     return px(median(holes.map(hole => readPx(hole.CENTROID_COL) - +hole.TRACKER_HOLE * separation)));
 };
+const chainsAmong = (holes) => holes
+    .filter(hole => hole.NOTE_ATTACK && hole.OFF_TIME)
+    .map(hole => ({ hole, attack: readPx(hole.NOTE_ATTACK), release: readPx(hole.OFF_TIME) }))
+    .sort((a, b) => a.attack - b.attack);
 const punchDiameterOf = (holes, dpi) => {
     const circular = holes
         .filter(hole => parseFloat(hole.CIRCULARITY) > 0.95)
@@ -78,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;
@@ -89,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),
@@ -97,31 +102,31 @@ export function readFromStanfordAton(atonString, { trackShift, bar = welteT100,
         shift
     };
     const punchDiameter = punchDiameterOf(holes, dpi);
-    const chains = [...holes, ...chainedBadHoles(listOf(json.ROLLINFO.BADHOLES?.HOLE), calibration)]
-        .filter(hole => hole.NOTE_ATTACK && hole.OFF_TIME)
-        .sort((a, b) => readPx(a.NOTE_ATTACK) - readPx(b.NOTE_ATTACK));
+    const chains = chainsAmong([...holes, ...chainedBadHoles(listOf(json.ROLLINFO.BADHOLES?.HOLE), calibration)]);
+    const onBar = translationBetween(system, bar);
     const features = chains
-        .map((hole) => {
-        const attack = readPx(hole.NOTE_ATTACK);
-        const release = readPx(hole.OFF_TIME);
+        .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/sorted.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The index at which a list partitioned by the predicate turns: it
+ * holds for every item before that index and for none from it on.
+ * Binary search, so the list is read in logarithmic time.
+ */
+export declare const partitionPoint: <T>(partitioned: readonly T[], holds: (item: T) => boolean) => number;

package/lib/sorted.js

@@ -0,0 +1,17 @@
+/**
+ * The index at which a list partitioned by the predicate turns: it
+ * holds for every item before that index and for none from it on.
+ * Binary search, so the list is read in logarithmic time.
+ */
+export const partitionPoint = (partitioned, holds) => {
+    let low = 0;
+    let high = partitioned.length;
+    while (low < high) {
+        const middle = (low + high) >>> 1;
+        if (holds(partitioned[middle]))
+            low = middle + 1;
+        else
+            high = middle;
+    }
+    return low;
+};

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/lib/systems/welteT100/system.js

@@ -1,6 +1,7 @@
 import { aperturePorts, CONSENSUS, DEFAULT_PUNCH_MM, geometryInMm, Grid, levelChanges, mezzoforteTravel, paperSeconds, pedalBrushing, pedalDefaults, pneumaticModel, PRESETS, ROWS_PER_MM, runPedals, TRACKER_BORE_MM, travelBetweenRails, WELTE_SPOOL, } from "welte-t100-emulator";
 import { welteT100 } from "./bar";
 import { add, inCentimeters, mm, seconds, track } from "../../Quantity";
+import { partitionPoint } from "../../sorted";
 /**
  * The instruments the emulator was fitted as: the consensus over the six
  * rolls with drawn nuance lines, and the setting that drew each of them,
@@ -113,7 +114,7 @@ const velocityOf = (travel, hook, map) => {
 const gridOver = (events, spool) => {
     const last = mm(events.reduce((furthest, event) => Math.max(furthest, event.horizontal.to), 0));
     const length = Math.ceil(rowOf(add(last, RUN_OUT))) + 1;
-    const times = Float64Array.from({ length }, (_, row) => secondsAt(spool, placeOfRow(row)));
+    const times = new Float64Array(length).map((_, row) => secondsAt(spool, placeOfRow(row)));
     return new Grid(0, times);
 };
 const nuanceCurves = (grid, ports, samples, options) => {
@@ -127,7 +128,7 @@ const nuanceCurves = (grid, ports, samples, options) => {
             name: half,
             kind: 'dynamics',
             travel,
-            velocity: Float64Array.from(travel, value => velocityOf(value, hook, options.velocity))
+            velocity: travel.map(value => velocityOf(value, hook, options.velocity))
         };
     };
     return { bass: curveOf('bass'), treble: curveOf('treble') };
@@ -158,7 +159,7 @@ const performPedal = (type, curve, grid, readings, mode) => {
     if (readings.length === 0)
         return [];
     const ordered = readings.toSorted((a, b) => a.punch.rowOn - b.punch.rowOn);
-    const causeOf = (row) => ordered[Math.max(ordered.findLastIndex(reading => reading.punch.rowOn <= row), 0)].event;
+    const causeOf = (row) => ordered[Math.max(partitionPoint(ordered, reading => reading.punch.rowOn <= row) - 1, 0)].event;
     return levelChanges(curve.travel, { mode })
         .filter(change => change.index > 0)
         .map(change => ({
@@ -182,7 +183,7 @@ const perform = (events, options, roll) => {
     const geometry = geometryInMm(roll.punchDiameter ?? options.punchDiameter, options.trackerBore);
     const ports = aperturePorts(grid, readings.map(reading => reading.punch), geometry);
     const samples = {
-        place: Float64Array.from(grid.seconds, (_, row) => placeOfRow(row)),
+        place: grid.seconds.map((_, row) => placeOfRow(row)),
         seconds: grid.seconds
     };
     const nuance = nuanceCurves(grid, ports, samples, options);

package/package.json

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

package/lib/readers/midiSpans.d.ts

@@ -1,25 +0,0 @@
-import { MidiFile } from "midifile-ts";
-import { Milliseconds } from "../Quantity";
-export declare function midiTickToMilliseconds(ticks: number, microsecondsPerBeat: number, ppq: number): Milliseconds;
-interface Span<T extends string> {
-    type: T;
-    id: string;
-    /** In ticks of the file. */
-    onset: number;
-    offset: number;
-    onsetMs: Milliseconds;
-    offsetMs: Milliseconds;
-    link?: string;
-}
-export interface NoteSpan extends Span<'note'> {
-    pitch: number;
-    velocity: number;
-    channel: number;
-}
-export interface SustainSpan extends Span<'sustain'> {
-}
-export interface SoftSpan extends Span<'soft'> {
-}
-export type AnySpan = NoteSpan | SustainSpan | SoftSpan;
-export declare const asSpans: (file: MidiFile, readLinks?: boolean) => AnySpan[];
-export {};

package/lib/readers/midiSpans.js

@@ -1,112 +0,0 @@
-import { MIDIControlEvents } from "midifile-ts";
-import { milliseconds } from "../Quantity";
-const isNoteOn = (event) => event.type === 'channel' && event.subtype === 'noteOn';
-const isNoteOff = (event) => event.type === 'channel' && event.subtype === 'noteOff';
-const isPedalOn = (event) => (event.type === 'channel'
-    && event.subtype === 'controller'
-    && event.controllerType === MIDIControlEvents.SUSTAIN
-    && event.value > 63);
-const isPedalOff = (event) => (event.type === 'channel'
-    && event.subtype === 'controller'
-    && event.controllerType === MIDIControlEvents.SUSTAIN
-    && event.value <= 63);
-const isSoftPedalOn = (event) => {
-    return event.type === 'channel'
-        && event.subtype === 'controller'
-        && event.controllerType === MIDIControlEvents.SOFT_PEDAL
-        && event.value > 63;
-};
-const isSoftPedalOff = (event) => {
-    return event.type === 'channel'
-        && event.subtype === 'controller'
-        && event.controllerType === MIDIControlEvents.SOFT_PEDAL
-        && event.value <= 63;
-};
-export function midiTickToMilliseconds(ticks, microsecondsPerBeat, ppq) {
-    const beats = ticks / ppq;
-    return milliseconds((beats * microsecondsPerBeat) / 1000);
-}
-export const asSpans = (file, readLinks = false) => {
-    const resultingSpans = [];
-    const tempoMap = [];
-    const currentSpans = [];
-    let bufferedMetaText;
-    for (let i = 0; i < file.tracks.length; i++) {
-        const track = file.tracks[i];
-        let currentTime = 0;
-        for (const event of track) {
-            currentTime += event.deltaTime;
-            if (event.type === 'meta' && event.subtype === 'setTempo') {
-                tempoMap.push({
-                    atTick: currentTime,
-                    microsecondsPerBeat: event.microsecondsPerBeat
-                });
-            }
-            if (readLinks && event.type === 'meta' && event.subtype === 'text') {
-                bufferedMetaText = event.text;
-            }
-            else if (isNoteOn(event) || isPedalOn(event) || isSoftPedalOn(event)) {
-                const type = isNoteOn(event) ? 'note' : isPedalOn(event) ? 'sustain' : 'soft';
-                const currentTempo = tempoMap.slice().reverse().find(tempo => tempo.atTick <= currentTime);
-                if (!currentTempo) {
-                    console.log('No tempo event found. Skipping');
-                    continue;
-                }
-                const onsetMs = midiTickToMilliseconds(currentTime, currentTempo.microsecondsPerBeat, file.header.ticksPerBeat);
-                const link = bufferedMetaText;
-                if (type === 'note') {
-                    const pitch = event.noteNumber;
-                    currentSpans.push({
-                        type,
-                        id: `${i}-${currentTime}-${pitch}`,
-                        onset: currentTime,
-                        offset: 0,
-                        velocity: event.velocity,
-                        pitch,
-                        channel: i,
-                        onsetMs,
-                        offsetMs: milliseconds(0),
-                        link
-                    });
-                }
-                else {
-                    currentSpans.push({
-                        type,
-                        id: `${i}-${currentTime}-${type}`,
-                        onset: currentTime,
-                        offset: 0,
-                        onsetMs,
-                        offsetMs: milliseconds(0),
-                        link
-                    });
-                }
-                bufferedMetaText = undefined;
-            }
-            else if (isNoteOff(event) || isPedalOff(event) || isSoftPedalOff(event)) {
-                const type = isNoteOff(event) ? 'note' : isPedalOff(event) ? 'sustain' : 'soft';
-                const currentTempo = tempoMap.slice().reverse().find(tempo => tempo.atTick <= currentTime);
-                if (!currentTempo) {
-                    console.log('No tempo event found. Skipping');
-                    continue;
-                }
-                const counterpart = isNoteOff(event)
-                    ? currentSpans.find(e => e.type === 'note' && e.pitch === event.noteNumber)
-                    : currentSpans.find(e => e.type === type);
-                if (!counterpart) {
-                    console.log('Found an off event of type', type, 'at', currentTime, 'without a previous on.', 'Event:', event, 'Current spans: ', currentSpans.map(span => span.type).join(' '));
-                    continue;
-                }
-                counterpart.offset = currentTime;
-                counterpart.offsetMs = midiTickToMilliseconds(currentTime, currentTempo.microsecondsPerBeat, file.header.ticksPerBeat);
-                if (bufferedMetaText && counterpart.link) {
-                    counterpart.link += ` ${bufferedMetaText}`;
-                }
-                resultingSpans.push(counterpart);
-                currentSpans.splice(currentSpans.indexOf(counterpart), 1);
-            }
-        }
-    }
-    return resultingSpans
-        .filter(span => span.offsetMs > span.onsetMs)
-        .sort((a, b) => a.onset - b.onset);
-};

package/lib/readers/spencerMidi.d.ts

@@ -1,27 +0,0 @@
-import { RollCopy } from "../RollCopy";
-import { FeetPerMinute, Millimeters, Seconds, Track } from "../Quantity";
-/**
- * How a MIDI key number in one of Spencer Chase's roll files names a
- * tracker bar track.
- *
- * The note block follows the obvious rule, `pitch - 13`, which puts
- * track 11 on MIDI 24 as the T100 compass requires. The bass expression
- * block does not: it reads two tracks high, and subtracting two is what
- * has made these files come out right so far.
- *
- * The boundary between the two rules is unresolved. Taken literally the
- * rules leave tracks 8 and 9 unreachable and jump from track 7 to track 10,
- * which no lateral offset can produce, so at least one of them is
- * approximate. Settling it needs a Spencer file whose expression holes
- * can be checked against the roll, hence the option to override.
- */
-export declare const spencerTrackOf: (pitch: number) => Track;
-/**
- * Spencer Chase's rolls seem to be scanned at a roll speed of
- * 83 (=8.3 feet per minute). A scanner feeds the paper at one
- * speed, so time in his files is proportional to place.
- */
-export declare const SPENCER_FEET_PER_MINUTE: import("..").Quantity<"ft/min">;
-/** Place on the roll after `time` at a constant `speed`. */
-export declare const atConstantSpeed: (speed: FeetPerMinute) => (time: Seconds) => Millimeters;
-export declare function readFromSpencerMIDI(midiBuffer: ArrayBuffer, placeAt?: (time: Seconds) => Millimeters, trackOf?: (pitch: number) => Track): RollCopy;

package/lib/readers/spencerMidi.js

@@ -1,60 +0,0 @@
-import { v4 } from "uuid";
-import { read } from "midifile-ts";
-import { asSpans } from "./midiSpans";
-import { feetPerMinute, inSeconds, mm, track } from "../Quantity";
-/**
- * How a MIDI key number in one of Spencer Chase's roll files names a
- * tracker bar track.
- *
- * The note block follows the obvious rule, `pitch - 13`, which puts
- * track 11 on MIDI 24 as the T100 compass requires. The bass expression
- * block does not: it reads two tracks high, and subtracting two is what
- * has made these files come out right so far.
- *
- * The boundary between the two rules is unresolved. Taken literally the
- * rules leave tracks 8 and 9 unreachable and jump from track 7 to track 10,
- * which no lateral offset can produce, so at least one of them is
- * approximate. Settling it needs a Spencer file whose expression holes
- * can be checked against the roll, hence the option to override.
- */
-export const spencerTrackOf = (pitch) => {
-    const position = pitch - 13;
-    return track(position < 10 ? position - 2 : position);
-};
-const MM_PER_FOOT = 304.8;
-const SECONDS_PER_MINUTE = 60;
-/**
- * Spencer Chase's rolls seem to be scanned at a roll speed of
- * 83 (=8.3 feet per minute). A scanner feeds the paper at one
- * speed, so time in his files is proportional to place.
- */
-export const SPENCER_FEET_PER_MINUTE = feetPerMinute(8.3);
-/** Place on the roll after `time` at a constant `speed`. */
-export const atConstantSpeed = (speed) => (time) => mm(speed * MM_PER_FOOT / SECONDS_PER_MINUTE * time);
-export function readFromSpencerMIDI(midiBuffer, placeAt = atConstantSpeed(SPENCER_FEET_PER_MINUTE), trackOf = spencerTrackOf) {
-    const features = asSpans(read(midiBuffer))
-        .filter(span => span.type === 'note')
-        .map((span) => ({
-        type: 'Hole',
-        id: v4(),
-        vertical: {
-            from: trackOf(span.pitch),
-            unit: 'track'
-        },
-        horizontal: {
-            from: placeAt(inSeconds(span.onsetMs)),
-            to: placeAt(inSeconds(span.offsetMs)),
-            unit: 'mm'
-        }
-    }));
-    return {
-        type: 'RollCopy',
-        id: v4(),
-        ops: [],
-        conditions: [],
-        keeper: { name: '', sameAs: [] },
-        measurements: {},
-        modifications: [],
-        features
-    };
-}