linked-rolls 0.7.0 → 0.9.0

package/lib/TrackCalibration.js

@@ -1,14 +1,15 @@
+import { px, subtract, track } from "./Quantity";
 /** Image column at the centre of a tracker bar track. */
-export const columnOf = (track, calibration) => calibration.offset + (track - calibration.shift) * calibration.separation;
+export const columnOf = (position, calibration) => px(calibration.offset + (position - calibration.shift) * calibration.separation);
 /** Tracker bar track covering an image column, unrounded. */
-export const trackAt = (column, calibration) => (column - calibration.offset) / calibration.separation + calibration.shift;
+export const trackAt = (column, calibration) => track((column - calibration.offset) / calibration.separation + calibration.shift);
 /**
  * The columns covered by a run of tracks, from the outer edge of the
  * first to the outer edge of the last.
  */
 export const columnsOf = (from, to, calibration) => {
     const [lower, upper] = from <= to ? [from, to] : [to, from];
-    const start = columnOf(lower, calibration) - calibration.separation / 2;
-    const end = columnOf(upper, calibration) + calibration.separation / 2;
-    return { from: start, to: end, width: end - start };
+    const start = px(columnOf(lower, calibration) - calibration.separation / 2);
+    const end = px(columnOf(upper, calibration) + calibration.separation / 2);
+    return { from: start, to: end, width: subtract(end, start) };
 };

package/lib/TrackerBar.d.ts

@@ -1,5 +1,6 @@
 import type { Concept } from "./Agent";
 import { Expression, Note } from "./Symbol";
+import { Millimeters, 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.
@@ -11,8 +12,8 @@ export type TrackRole = 'bass-expression' | 'note' | 'treble-expression';
  */
 export interface TrackArea {
     readonly role: TrackRole;
-    readonly from: number;
-    readonly to: number;
+    readonly from: Track;
+    readonly to: Track;
 }
 export type NoteMeaning = Pick<Note, 'type' | 'pitch'>;
 export type ExpressionMeaning = Pick<Expression, 'type' | 'expressionType' | 'scope'>;
@@ -35,8 +36,8 @@ export interface TrackerBar {
      */
     readonly id: string;
     readonly name: string;
-    /** Width of the roll the bar reads, in mm. */
-    readonly width: number;
+    /** Width of the roll the bar reads. */
+    readonly width: Millimeters;
     /** Number of positions on the bar. Tracks run from 1 to this. */
     readonly trackCount: number;
     /** The blocks of positions, from the bass edge upwards. */
@@ -48,20 +49,25 @@ export interface TrackerBar {
      * the very end of a roll and is the usual landmark for calibrating
      * a scan against the bar.
      */
-    readonly rewindTrack: number;
+    readonly rewindTrack: Track;
     /** `undefined` for a position the bar does not read. */
-    meaningOf(track: number): TrackMeaning | undefined;
+    meaningOf(position: Track): TrackMeaning | undefined;
     /** `undefined` for a position the bar does not read. */
-    roleOf(track: number): TrackRole | undefined;
+    roleOf(position: Track): TrackRole | undefined;
 }
 /** The roll system a tracker bar belongs to, as the roll metadata states it. */
 export declare const systemOf: (bar: TrackerBar) => Concept;
 /** The identifier of a system the type vocabulary knows, from its concept. */
 export declare const systemIdOf: (system: Concept | undefined) => string | undefined;
+/**
+ * A tracker bar as written down, with its positions as plain numbers
+ * in the bar's own 1-based numbering; `describeTrackerBar` gives them
+ * their type.
+ */
 export interface TrackerBarSpec {
     id: string;
     name: string;
-    width: number;
+    width: Millimeters;
     trackCount: number;
     /** The contiguous block of note positions. */
     notes: {

package/lib/TrackerBar.js

@@ -1,35 +1,36 @@
+import { track } from "./Quantity";
 const SYSTEM_IRI = 'https://w3id.org/reo/type/system/';
 /** The roll system a tracker bar belongs to, as the roll metadata states it. */
 export const systemOf = (bar) => ({ id: SYSTEM_IRI + bar.id, name: bar.name, sameAs: [] });
 /** The identifier of a system the type vocabulary knows, from its concept. */
 export const systemIdOf = (system) => system?.id?.startsWith(SYSTEM_IRI) ? system.id.slice(SYSTEM_IRI.length) : undefined;
 const areasOf = ({ notes, trackCount }) => [
-    { role: 'bass-expression', from: 1, to: notes.from - 1 },
-    { role: 'note', from: notes.from, to: notes.to },
-    { role: 'treble-expression', from: notes.to + 1, to: trackCount }
+    { role: 'bass-expression', from: track(1), to: track(notes.from - 1) },
+    { role: 'note', from: track(notes.from), to: track(notes.to) },
+    { role: 'treble-expression', from: track(notes.to + 1), to: track(trackCount) }
 ];
 const scopeOf = (role) => role === 'bass-expression' ? 'bass' : 'treble';
 export const describeTrackerBar = (spec) => {
     const areas = areasOf(spec);
-    const roleOf = (track) => areas.find(area => track >= area.from && track <= area.to)?.role;
-    const meaningOf = (track) => {
-        const role = roleOf(track);
+    const roleOf = (position) => areas.find(area => position >= area.from && position <= area.to)?.role;
+    const meaningOf = (position) => {
+        const role = roleOf(position);
         if (!role)
             return undefined;
         if (role === 'note') {
             return {
                 type: 'note',
-                pitch: track - spec.notes.from + spec.notes.lowestPitch
+                pitch: position - spec.notes.from + spec.notes.lowestPitch
             };
         }
-        const expressionType = spec.expressions.get(track);
+        const expressionType = spec.expressions.get(position);
         if (!expressionType)
             return undefined;
         return { type: 'expression', expressionType, scope: scopeOf(role) };
     };
-    const rewindTrack = [...spec.expressions]
+    const rewind = [...spec.expressions]
         .find(([, type]) => type === 'Rewind')?.[0];
-    if (rewindTrack === undefined) {
+    if (rewind === undefined) {
         throw new Error(`${spec.name} declares no rewind track`);
     }
     return {
@@ -39,7 +40,7 @@ export const describeTrackerBar = (spec) => {
         trackCount: spec.trackCount,
         areas,
         expressionTypes: [...new Set(spec.expressions.values())],
-        rewindTrack,
+        rewindTrack: track(rewind),
         meaningOf,
         roleOf
     };

package/lib/alignment.d.ts

@@ -2,6 +2,7 @@ import { ObjectAssumption } from "./Assumption";
 import { AnyFeature } from "./Feature";
 import { PaperStretch, 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;
 /** Takes the shift off the copy's features again, as far as one was applied. */
@@ -9,8 +10,8 @@ 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 = {
-    /** Shift in mm, applied before the stretch. */
-    shift: number;
+    /** Applied before the stretch. */
+    shift: Millimeters;
     stretch: number;
 };
 /**

package/lib/alignment.js

@@ -1,16 +1,24 @@
 import { welteT100 } from "./systems/welteT100/bar";
+import { add, mm, scale } from "./Quantity";
+/** Moves both ends of a span, the far end only where the span has one. */
+const move = (span, by) => {
+    span.from = add(span.from, by);
+    if (span.to !== undefined)
+        span.to = add(span.to, by);
+};
+/** Stretches both ends of a span away from the beginning of the roll. */
+const stretch = (span, factor) => {
+    span.from = scale(span.from, factor);
+    if (span.to !== undefined)
+        span.to = scale(span.to, factor);
+};
+const back = (shift) => ({ horizontal: scale(shift.horizontal, -1), vertical: scale(shift.vertical, -1) });
 export const applyShift = (shift, copy) => {
     if (copy.ops.includes('shifted'))
         return;
     copy.features.forEach(feature => {
-        feature.horizontal.from += shift.horizontal;
-        if (feature.horizontal.to) {
-            feature.horizontal.to += shift.horizontal;
-        }
-        feature.vertical.from += shift.vertical;
-        if (feature.vertical.to) {
-            feature.vertical.to += shift.vertical;
-        }
+        move(feature.horizontal, shift.horizontal);
+        move(feature.vertical, shift.vertical);
     });
     copy.ops = [...copy.ops, 'shifted'];
     copy.measurements.shift = shift;
@@ -18,13 +26,7 @@ export const applyShift = (shift, copy) => {
 export const applyStretch = (paperStretch, copy) => {
     if (copy.ops.includes('stretched'))
         return;
-    const stretch = paperStretch.factor;
-    copy.features.forEach(feature => {
-        feature.horizontal.from *= stretch;
-        if (feature.horizontal.to) {
-            feature.horizontal.to *= stretch;
-        }
-    });
+    copy.features.forEach(feature => stretch(feature.horizontal, paperStretch.factor));
     copy.ops = [...copy.ops, 'stretched'];
     copy.conditions.push(paperStretch);
 };
@@ -33,15 +35,10 @@ export const revertShift = (copy) => {
     const shift = copy.measurements.shift;
     if (!copy.ops.includes('shifted') || !shift)
         return;
+    const reversed = back(shift);
     copy.features.forEach(feature => {
-        feature.horizontal.from -= shift.horizontal;
-        if (feature.horizontal.to) {
-            feature.horizontal.to -= shift.horizontal;
-        }
-        feature.vertical.from -= shift.vertical;
-        if (feature.vertical.to) {
-            feature.vertical.to -= shift.vertical;
-        }
+        move(feature.horizontal, reversed.horizontal);
+        move(feature.vertical, reversed.vertical);
     });
     copy.ops = copy.ops.filter(op => op !== 'shifted');
     delete copy.measurements.shift;
@@ -49,15 +46,10 @@ export const revertShift = (copy) => {
 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 stretch = copy.conditions.find(isPaperStretch);
-    if (!copy.ops.includes('stretched') || !stretch)
+    const applied = copy.conditions.find(isPaperStretch);
+    if (!copy.ops.includes('stretched') || !applied)
         return;
-    copy.features.forEach(feature => {
-        feature.horizontal.from /= stretch.factor;
-        if (feature.horizontal.to) {
-            feature.horizontal.to /= stretch.factor;
-        }
-    });
+    copy.features.forEach(feature => stretch(feature.horizontal, 1 / applied.factor));
     copy.ops = copy.ops.filter(op => op !== 'stretched');
     copy.conditions = copy.conditions.filter(condition => !isPaperStretch(condition));
 };
@@ -112,6 +104,6 @@ export function alignFeatures(rollA, rollB, bar = welteT100) {
     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 = betaB / stretch - betaA;
+    const shift = mm(betaB / stretch - betaA);
     return { stretch, shift };
 }

package/lib/editionOps.js

@@ -5,6 +5,7 @@ import { collationsOf, defaultCollationTolerance } from "./Collation";
 import { asSymbols } from "./RollCopy";
 import { applyShift, applyStretch, revertShift, revertStretch } from "./alignment";
 import { assignReference, idOf } from "./Assumption";
+import { distance, mm, subtract } from "./Quantity";
 const noChange = () => undefined;
 const onCopy = (copyId, op) => draft => {
     const copy = draft.copies.find(c => c.id === copyId);
@@ -202,12 +203,14 @@ export const deriveVersion = (versionId, editIds) => onVersion(versionId, (versi
 const sameSequence = (a, b) => a.length === b.length && a.every((value, i) => value === b[i]);
 const expressionTypesOf = (symbols) => symbols.filter((symbol) => symbol.type === 'expression').map(symbol => symbol.expressionType);
 const accents = [['SlowCrescendoOn', 'SlowCrescendoOff'], ['ForzandoOn', 'ForzandoOff']];
-const lengthOf = (span) => span.to - span.from;
+const lengthOf = (span) => subtract(span.to, span.from);
+/** How far apart two onsets may lie for the one symbol to count as a replacement of the other. */
+const REPLACEMENT_TOLERANCE = mm(5);
 /** Shorten or prolong, where the inserted symbol starts about where the deleted one did. */
 const replacementType = (view, inserted, deleted) => {
     const after = view.dimensionOf(inserted)?.horizontal;
     const before = view.dimensionOf(deleted)?.horizontal;
-    if (!after || !before || Math.abs(after.from - before.from) >= 5)
+    if (!after || !before || distance(after.from, before.from) >= REPLACEMENT_TOLERANCE)
         return undefined;
     return lengthOf(after) < lengthOf(before) ? 'shorten' : 'prolong';
 };

package/lib/index.d.ts

@@ -1,4 +1,5 @@
 export * from './utils';
+export * from './Quantity';
 export * from './Agent';
 export * from './Assumption';
 export * from './ConditionState';

package/lib/index.js

@@ -1,4 +1,5 @@
 export * from './utils';
+export * from './Quantity';
 export * from './Agent';
 export * from './Assumption';
 export * from './ConditionState';

package/lib/migrate.js

@@ -75,4 +75,8 @@ const withRollSystem = (edition) => {
     const system = { '@id': id, ...concept, ...(stated && { name: stated }) };
     return { ...edition, roll: { ...edition.roll, system } };
 };
-export const migrate = (edition) => walk(withRollSystem(edition));
+/** An edition written before the editors were carried names none. */
+const withEditors = (edition) => !edition.creation || edition.creation.editors
+    ? edition
+    : { ...edition, creation: { ...edition.creation, editors: [] } };
+export const migrate = (edition) => walk(withRollSystem(withEditors(edition)));

package/lib/readers/midiSpans.d.ts

@@ -1,12 +1,14 @@
 import { MidiFile } from "midifile-ts";
-export declare function midiTickToMilliseconds(ticks: number, microsecondsPerBeat: number, ppq: number): number;
+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: number;
-    offsetMs: number;
+    onsetMs: Milliseconds;
+    offsetMs: Milliseconds;
     link?: string;
 }
 export interface NoteSpan extends Span<'note'> {

package/lib/readers/midiSpans.js

@@ -1,4 +1,5 @@
 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'
@@ -23,7 +24,7 @@ const isSoftPedalOff = (event) => {
 };
 export function midiTickToMilliseconds(ticks, microsecondsPerBeat, ppq) {
     const beats = ticks / ppq;
-    return (beats * microsecondsPerBeat) / 1000;
+    return milliseconds((beats * microsecondsPerBeat) / 1000);
 }
 export const asSpans = (file, readLinks = false) => {
     const resultingSpans = [];
@@ -64,7 +65,7 @@ export const asSpans = (file, readLinks = false) => {
                         pitch,
                         channel: i,
                         onsetMs,
-                        offsetMs: 0,
+                        offsetMs: milliseconds(0),
                         link
                     });
                 }
@@ -75,7 +76,7 @@ export const asSpans = (file, readLinks = false) => {
                         onset: currentTime,
                         offset: 0,
                         onsetMs,
-                        offsetMs: 0,
+                        offsetMs: milliseconds(0),
                         link
                     });
                 }

package/lib/readers/spencerMidi.d.ts

@@ -1,4 +1,5 @@
 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.
@@ -14,13 +15,13 @@ import { RollCopy } from "../RollCopy";
  * 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) => number;
+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 = 8.3;
-/** Place on the roll in mm after `seconds` at a constant `feetPerMinute`. */
-export declare const atConstantSpeed: (feetPerMinute: number) => (seconds: number) => number;
-export declare function readFromSpencerMIDI(midiBuffer: ArrayBuffer, placeAt?: (seconds: number) => number, trackOf?: (pitch: number) => number): RollCopy;
+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,6 +1,7 @@
 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.
@@ -17,18 +18,19 @@ import { asSpans } from "./midiSpans";
  * can be checked against the roll, hence the option to override.
  */
 export const spencerTrackOf = (pitch) => {
-    const track = pitch - 13;
-    return track < 10 ? track - 2 : track;
+    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 = 8.3;
-/** Place on the roll in mm after `seconds` at a constant `feetPerMinute`. */
-export const atConstantSpeed = (feetPerMinute) => (seconds) => feetPerMinute * MM_PER_FOOT / 60 * seconds;
+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')
@@ -40,8 +42,8 @@ export function readFromSpencerMIDI(midiBuffer, placeAt = atConstantSpeed(SPENCE
             unit: 'track'
         },
         horizontal: {
-            from: placeAt(span.onsetMs / 1000),
-            to: placeAt(span.offsetMs / 1000),
+            from: placeAt(inSeconds(span.onsetMs)),
+            to: placeAt(inSeconds(span.offsetMs)),
             unit: 'mm'
         }
     }));

package/lib/readers/stanfordAton.d.ts

@@ -1,12 +1,13 @@
 import { RollCopy } from "../RollCopy";
 import { TrackerBar } from "../TrackerBar";
+import { Track } from "../Quantity";
 export interface StanfordAtonOptions {
     /**
      * Added to the scanning software's hole numbering to reach the
      * tracker bar. Left out, it is inferred by putting the rewind
      * perforation on the bar's rewind track.
      */
-    trackShift?: number;
+    trackShift?: Track;
     bar?: TrackerBar;
     /**
      * Where the scan the analysis was made from can be seen. Stanford's

package/lib/readers/stanfordAton.js

@@ -1,8 +1,9 @@
 import { v4 } from "uuid";
 import { AtonParser } from "./AtonParser";
 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". */
-const px = (value) => parseFloat(value);
+const readPx = (value) => px(parseFloat(value));
 /** The parser writes one record as an object and several as an array. */
 const listOf = (value) => value === undefined ? [] : Array.isArray(value) ? value : [value];
 /**
@@ -16,9 +17,8 @@ const chainedBadHoles = (holes, calibration) => holes
     .filter(hole => hole.NOTE_ATTACK && hole.OFF_TIME)
     .map(hole => ({
     ...hole,
-    TRACKER_HOLE: `${Math.round((px(hole.CENTROID_COL) - calibration.offset) / calibration.separation)}`
+    TRACKER_HOLE: `${Math.round((readPx(hole.CENTROID_COL) - calibration.offset) / calibration.separation)}`
 }));
-const millimeters = (pixels, dpi) => pixels / dpi * 25.4;
 const median = (values) => {
     const sorted = [...values].sort((a, b) => a - b);
     const middle = Math.floor(sorted.length / 2);
@@ -32,7 +32,8 @@ const mostFrequent = (values) => {
  * Only the first hole of a chain carries an attack and an off time;
  * the rest continue it. The rewind perforation carries neither, and it
  * is the last thing punched on the roll, so whatever the holes past the
- * final musical attack sit on is the rewind track.
+ * final musical attack sit on is the rewind track, in the scanner's
+ * own numbering.
  */
 const rewindTrackIn = (holes) => {
     const lastMusical = holes.findLastIndex(hole => hole.NOTE_ATTACK);
@@ -46,16 +47,14 @@ const rewindTrackIn = (holes) => {
  */
 const gridOffsetOf = (holes, separation, stated) => {
     if (stated !== undefined)
-        return px(stated);
-    return median(holes.map(hole => px(hole.CENTROID_COL) - +hole.TRACKER_HOLE * separation));
+        return readPx(stated);
+    return px(median(holes.map(hole => readPx(hole.CENTROID_COL) - +hole.TRACKER_HOLE * separation)));
 };
 const punchDiameterOf = (holes, dpi) => {
     const circular = holes
-        .filter(hole => px(hole.CIRCULARITY) > 0.95)
-        .map(hole => millimeters(px(hole.PERIMETER), dpi) / Math.PI);
-    if (!circular.length)
-        return undefined;
-    return circular.reduce((sum, diameter) => sum + diameter, 0) / circular.length;
+        .filter(hole => parseFloat(hole.CIRCULARITY) > 0.95)
+        .map(hole => mm(inMillimeters(readPx(hole.PERIMETER), dpi) / Math.PI));
+    return circular.length > 0 ? mean(circular) : undefined;
 };
 /**
  * The image service Stanford keeps for a scan, and a crop of a
@@ -85,12 +84,12 @@ export function readFromStanfordAton(atonString, { trackShift, bar = welteT100,
     const holes = json.ROLLINFO.HOLES.HOLE;
     const druid = json.ROLLINFO.DRUID;
     const stanford = druid ? stanfordScan(druid) : undefined;
-    const separation = px(json.ROLLINFO.HOLE_SEPARATION);
+    const separation = readPx(json.ROLLINFO.HOLE_SEPARATION);
     const dpi = parseFloat(json.ROLLINFO.LENGTH_DPI);
     const measuredBy = measuredByOf(json.ROLLINFO);
     const rewindTrack = rewindTrackIn(holes);
     const shift = trackShift
-        ?? (rewindTrack === undefined ? 0 : bar.rewindTrack - rewindTrack);
+        ?? (rewindTrack === undefined ? track(0) : track(bar.rewindTrack - rewindTrack));
     const calibration = {
         unit: 'px',
         offset: gridOffsetOf(holes, separation, json.ROLLINFO.HOLE_OFFSET),
@@ -100,27 +99,27 @@ export function readFromStanfordAton(atonString, { trackShift, bar = welteT100,
     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) => px(a.NOTE_ATTACK) - px(b.NOTE_ATTACK));
+        .sort((a, b) => readPx(a.NOTE_ATTACK) - readPx(b.NOTE_ATTACK));
     const features = chains
         .map((hole) => {
-        const attack = px(hole.NOTE_ATTACK);
-        const release = px(hole.OFF_TIME);
-        const column = px(hole.ORIGIN_COL);
-        const columnWidth = px(hole.WIDTH_COL);
+        const attack = readPx(hole.NOTE_ATTACK);
+        const release = readPx(hole.OFF_TIME);
+        const column = readPx(hole.ORIGIN_COL);
+        const columnWidth = readPx(hole.WIDTH_COL);
         return {
             type: 'Hole',
             id: v4(),
             ...(stanford && {
-                depiction: stanford.depictionOf(column, attack, columnWidth, release - attack)
+                depiction: stanford.depictionOf(column, attack, columnWidth, subtract(release, attack))
             }),
             vertical: {
-                from: +hole.TRACKER_HOLE + shift,
+                from: track(+hole.TRACKER_HOLE + shift),
                 unit: 'track'
             },
             horizontal: {
                 unit: 'mm',
-                from: millimeters(attack, dpi),
-                to: millimeters(release, dpi)
+                from: inMillimeters(attack, dpi),
+                to: inMillimeters(release, dpi)
             }
         };
     });
@@ -134,8 +133,8 @@ export function readFromStanfordAton(atonString, { trackShift, bar = welteT100,
         ...((scan ?? stanford) && { scan: scan ?? stanford?.scan }),
         measurements: {
             dimensions: {
-                width: millimeters(px(json.ROLLINFO.ROLL_WIDTH), dpi),
-                height: millimeters(px(json.ROLLINFO.IMAGE_LENGTH), dpi),
+                width: inMillimeters(readPx(json.ROLLINFO.ROLL_WIDTH), dpi),
+                height: inMillimeters(readPx(json.ROLLINFO.IMAGE_LENGTH), dpi),
                 unit: 'mm'
             },
             ...(punchDiameter !== undefined && {
@@ -146,8 +145,8 @@ export function readFromStanfordAton(atonString, { trackShift, bar = welteT100,
                 unit: 'px'
             },
             margins: {
-                treble: px(json.ROLLINFO.HARD_MARGIN_TREBLE),
-                bass: px(json.ROLLINFO.HARD_MARGIN_BASS),
+                treble: readPx(json.ROLLINFO.HARD_MARGIN_TREBLE),
+                bass: readPx(json.ROLLINFO.HARD_MARGIN_BASS),
                 unit: 'px'
             },
             trackCalibration: calibration,