linked-rolls 0.8.0 → 0.9.0

package/lib/Collation.d.ts

@@ -1,19 +1,15 @@
 import { HorizontalSpan } from "./Feature";
 import { AnySymbol } from "./Symbol";
+import { Millimeters } from "./Quantity";
 /**
- * Tolerance used in collation of roll copies.
- * The start and end tolerances define the acceptable
- * deviation (in mm) when aligning features across copies.
+ * Tolerance used in collation of roll copies: the acceptable deviation
+ * at either end when aligning features across copies.
  */
 export interface CollationTolerance {
-    /**
-     * Tolerance at the start position of a feature (in mm).
-     */
-    toleranceStart: number;
-    /**
-     * Tolerance at the end position of a feature (in mm).
-     */
-    toleranceEnd: number;
+    /** Tolerance at the start position of a feature. */
+    toleranceStart: Millimeters;
+    /** Tolerance at the end position of a feature. */
+    toleranceEnd: Millimeters;
 }
 export declare const defaultCollationTolerance: CollationTolerance;
 /** Where a symbol lies along the roll, as its carriers put it, or nothing for a symbol without a place. */

package/lib/Collation.js

@@ -1,4 +1,5 @@
-export const defaultCollationTolerance = { toleranceStart: 5, toleranceEnd: 5 };
+import { distance, mm } from "./Quantity";
+export const defaultCollationTolerance = { toleranceStart: mm(5), toleranceEnd: mm(5) };
 /**
  * Two symbols collate when they are of one kind, say the same thing
  * (pitch, or expression type and scope), and lie at about the same
@@ -16,8 +17,8 @@ export const isCollatable = (a, b, locate, tolerance = defaultCollationTolerance
     const there = locate(b)?.horizontal;
     if (!here || !there)
         return false;
-    return Math.abs(here.from - there.from) <= tolerance.toleranceStart
-        && Math.abs(here.to - there.to) <= tolerance.toleranceEnd;
+    return distance(here.from, there.from) <= tolerance.toleranceStart
+        && distance(here.to, there.to) <= tolerance.toleranceEnd;
 };
 /** Each of the own symbols with every inherited symbol it collates with. */
 export const collationsOf = (own, inherited, locate, tolerance = defaultCollationTolerance) => own.flatMap(symbol => inherited

package/lib/EditionView.js

@@ -1,4 +1,5 @@
 import { idOf, idsOf } from "./Assumption";
+import { mean } from "./Quantity";
 export const getAt = (path, obj) => {
     let node = obj;
     for (const key of path) {
@@ -150,18 +151,18 @@ export class EditionView {
         if (carriers.length === 0) {
             return;
         }
-        const horizontalFrom = carriers.reduce((hAcc, h) => hAcc + h.horizontal.from, 0) / carriers.length;
-        const horizontalTo = carriers.reduce((hAcc, h) => hAcc + h.horizontal.to, 0) / carriers.length;
-        const verticalFrom = carriers.reduce((vAcc, v) => vAcc + v.vertical.from, 0) / carriers.length;
-        const definedVerticalTo = carriers.filter(v => v.vertical.to !== undefined);
-        let verticalTo = undefined;
-        if (definedVerticalTo.length > 0) {
-            verticalTo = definedVerticalTo
-                .reduce((vAcc, v) => vAcc + v.vertical.to, 0) / definedVerticalTo.length;
-        }
+        const farEnds = carriers.flatMap(carrier => carrier.vertical.to === undefined ? [] : [carrier.vertical.to]);
         return {
-            horizontal: { unit: 'mm', from: horizontalFrom, to: horizontalTo },
-            vertical: { unit: 'track', from: verticalFrom, to: verticalTo }
+            horizontal: {
+                unit: 'mm',
+                from: mean(carriers.map(carrier => carrier.horizontal.from)),
+                to: mean(carriers.map(carrier => carrier.horizontal.to))
+            },
+            vertical: {
+                unit: 'track',
+                from: mean(carriers.map(carrier => carrier.vertical.from)),
+                ...(farEnds.length > 0 && { to: mean(farEnds) })
+            }
         };
     }
     snapshot(versionId) {

package/lib/Emulation.d.ts

@@ -2,9 +2,10 @@ import { MidiFile } from "midifile-ts";
 import { EditionView } from "./EditionView";
 import { Version } from "./Version";
 import { AnyPerformedRollFeature, EmulatedCurve, NegotiatedEvent, ReproducingSystem } from "./ReproducingSystem";
+import { Millimeters } from "./Quantity";
 export type EmulationScope = {
-    /** Only notes whose onset lies within this span of the roll, in mm, are played. */
-    range?: [number, number];
+    /** Only notes whose onset lies within this span of the roll are played. */
+    range?: [Millimeters, Millimeters];
     /** Start the clock at the first note rather than at the beginning of the roll. */
     skipToFirstNote?: boolean;
 };

package/lib/Emulation.js

@@ -1,20 +1,18 @@
 import { MIDIControlEvents } from "midifile-ts";
 import { idOf } from "./Assumption";
 import { pairsAmong, placementsOf } from "./Symbol";
+import { add, mean, mm, seconds, subtract } from "./Quantity";
 /** The punch diameter the edition's copies report, where any of them does. */
 const punchDiameterOf = (view) => {
     const measured = view.edition.copies
         .map(copy => copy.measurements.punchDiameter?.value)
         .filter((value) => value !== undefined && value > 0);
-    if (measured.length === 0)
-        return undefined;
-    return measured.reduce((sum, value) => sum + value, 0) / measured.length;
+    return measured.length > 0 ? mean(measured) : undefined;
 };
 const propertiesOf = (view) => ({
     punchDiameter: punchDiameterOf(view),
     tempo: view.edition.tempoAdjustment
 });
-const mean = (values) => values.reduce((sum, value) => sum + value, 0) / values.length;
 /** The onset a symbol has on each copy carrying it, by the copy's index, as the mean of its holes there. */
 const onsetsByCopy = (view, symbolId) => {
     const symbol = view.get(symbolId);
@@ -36,7 +34,7 @@ const offsetsBetween = (view, followerId, referenceId) => {
     const references = onsetsByCopy(view, referenceId);
     return [...onsetsByCopy(view, followerId)].flatMap(([copy, onset]) => {
         const reference = references.get(copy);
-        return reference === undefined ? [] : [onset - reference];
+        return reference === undefined ? [] : [subtract(onset, reference)];
     });
 };
 /**
@@ -45,13 +43,11 @@ const offsetsBetween = (view, followerId, referenceId) => {
  * that agree with the statement put it, and one gap where none does.
  */
 const distanceOnSide = (side, offsets, gap) => {
-    const agreeing = offsets
-        .filter(offset => side === 'before' ? offset < 0 : offset > 0)
-        .map(Math.abs);
-    return agreeing.length > 0 ? mean(agreeing) : gap;
+    const agreeing = offsets.filter(offset => side === 'before' ? offset < 0 : offset > 0);
+    return agreeing.length > 0 ? mm(Math.abs(mean(agreeing))) : gap;
 };
 /**
- * How far each event has to move, in mm, for the placements to hold:
+ * How far each event has to move for the placements to hold:
  * an aligned event takes the onset of its reference, one placed before
  * or after its reference keeps its place where the measurement has it
  * on that side and is moved there where it does not, and a paired
@@ -71,12 +67,12 @@ const displacementsOf = (events, offsetsBetween, gap) => {
         const distance = (side) => distanceOnSide(side, offsetsBetween(event.id, reference.id), gap);
         switch (placement.relation) {
             case 'alignedWith': return referenceOnset;
-            case 'before': return measured < referenceOnset ? measured : referenceOnset - distance('before');
-            case 'after': return measured > referenceOnset ? measured : referenceOnset + distance('after');
+            case 'before': return measured < referenceOnset ? measured : subtract(referenceOnset, distance('before'));
+            case 'after': return measured > referenceOnset ? measured : add(referenceOnset, distance('after'));
         }
     };
     const displacements = new Map(events
-        .map((event) => [event, placedOnsetOf(event) - event.horizontal.from])
+        .map((event) => [event, subtract(placedOnsetOf(event), event.horizontal.from)])
         .filter(([, distance]) => distance !== 0));
     pairsAmong(events).forEach(([one, other]) => {
         const shared = displacements.get(one) ?? displacements.get(other);
@@ -142,11 +138,11 @@ export class Emulation {
      * diameter, or a millimetre, where no copy agrees with a statement.
      */
     applyConstraints(view) {
-        const gap = punchDiameterOf(view) ?? 1;
+        const gap = punchDiameterOf(view) ?? mm(1);
         const offsets = (follower, reference) => offsetsBetween(view, follower, reference);
         displacementsOf(this.negotiatedEvents, offsets, gap).forEach((distance, event) => {
-            event.horizontal.from += distance;
-            event.horizontal.to += distance;
+            event.horizontal.from = add(event.horizontal.from, distance);
+            event.horizontal.to = add(event.horizontal.to, distance);
         });
     }
     emulateVersion(version, view, { range, skipToFirstNote = false } = {}) {
@@ -176,9 +172,9 @@ export class Emulation {
         const performance = this.system.perform(this.negotiatedEvents, this.options, propertiesOf(view));
         this.curves = performance.curves;
         const onsets = performance.events.filter(event => event.type === 'noteOn').map(event => event.at);
-        const origin = skipToFirstNote && onsets.length > 0 ? Math.min(...onsets) : 0;
+        const origin = seconds(skipToFirstNote && onsets.length > 0 ? Math.min(...onsets) : 0);
         this.midiEvents = performance.events
-            .map(event => ({ ...event, at: event.at - origin }))
+            .map(event => ({ ...event, at: subtract(event.at, origin) }))
             .filter(event => event.at >= 0)
             .sort((a, b) => a.at - b.at);
         return this.midiEvents;

package/lib/Feature.d.ts

@@ -2,6 +2,7 @@ import { ObjectAssumption } from "./Assumption";
 import { ConditionState } from "./ConditionState";
 import { Text } from "./Symbol";
 import { PartialBy, WithId, WithType } from "./utils";
+import { Millimeters, Track } from "./Quantity";
 /**
  * Describes the horizontal extent of a feature on the roll,
  * measured in millimeters from the beginning of the roll.
@@ -20,13 +21,13 @@ export interface HorizontalSpan {
      * from the beginning of the roll.
      * @see reo:from
      */
-    from: number;
+    from: Millimeters;
     /**
      * The end position of the feature in millimeters
      * from the beginning of the roll.
      * @see reo:to
      */
-    to: number;
+    to: Millimeters;
 }
 /**
  * Describes the vertical extent of a feature on the roll,
@@ -44,13 +45,13 @@ export interface VerticalSpan {
      * The start track number of the feature.
      * @see reo:from
      */
-    from: number;
+    from: Track;
     /**
      * The end track number, if the feature spans multiple tracks.
      * If omitted, the feature occupies a single track.
      * @see reo:to
      */
-    to?: number;
+    to?: Track;
 }
 export declare const featureTypes: readonly ["Hole", "Writing", "Mark", "GluedOn"];
 export type FeatureType = typeof featureTypes[number];

package/lib/Quantity.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Numbers that carry their unit in the type. At runtime a quantity is
+ * the plain number it was made from, so it compares, sorts and prints
+ * as one and goes wherever a number is wanted. The other direction is
+ * closed: a number becomes a quantity only through the constructors
+ * here, and a quantity in one unit cannot stand in for one in another.
+ * The unit names are the ones the records state in their `unit` field.
+ */
+declare const unit: unique symbol;
+export type Unit = 'mm' | 'cm' | 'px' | 'track' | 's' | 'ms' | 'ft/min' | 'm/min';
+export type Quantity<U extends Unit> = number & {
+    readonly [unit]: U;
+};
+/** A place along the roll, or any length on the paper. */
+export type Millimeters = Quantity<'mm'>;
+export type Centimeters = Quantity<'cm'>;
+/** A place in a scan. Comparable within one scan only, since the resolution is the scan's. */
+export type Pixels = Quantity<'px'>;
+/** A position across the roll, numbered as the tracker bar does. */
+export type Track = Quantity<'track'>;
+export type Seconds = Quantity<'s'>;
+export type Milliseconds = Quantity<'ms'>;
+export type FeetPerMinute = Quantity<'ft/min'>;
+export type MetersPerMinute = Quantity<'m/min'>;
+export declare const mm: (value: number) => Quantity<"mm">;
+export declare const cm: (value: number) => Quantity<"cm">;
+export declare const px: (value: number) => Quantity<"px">;
+export declare const track: (value: number) => Quantity<"track">;
+export declare const seconds: (value: number) => Quantity<"s">;
+export declare const milliseconds: (value: number) => Quantity<"ms">;
+export declare const feetPerMinute: (value: number) => Quantity<"ft/min">;
+export declare const metersPerMinute: (value: number) => Quantity<"m/min">;
+/**
+ * A value together with the unit it was measured in, as a record
+ * states it.
+ * @see crm:E54 Dimension
+ */
+export interface Measure<U extends Unit> {
+    /**
+     * The measured value.
+     * @see crm:P90 has value
+     */
+    value: Quantity<U>;
+    /**
+     * The unit of measurement.
+     * @see crm:P91 has unit
+     */
+    unit: U;
+}
+export declare const add: <U extends Unit>(a: Quantity<U>, b: Quantity<NoInfer<U>>) => Quantity<U>;
+export declare const subtract: <U extends Unit>(a: Quantity<U>, b: Quantity<NoInfer<U>>) => Quantity<U>;
+export declare const distance: <U extends Unit>(a: Quantity<U>, b: Quantity<NoInfer<U>>) => Quantity<U>;
+/** A quantity times a plain factor, such as a stretch. */
+export declare const scale: <U extends Unit>(a: Quantity<U>, factor: number) => Quantity<U>;
+export declare const sum: <U extends Unit>(values: readonly Quantity<U>[]) => Quantity<U>;
+export declare const mean: <U extends Unit>(values: readonly Quantity<U>[]) => Quantity<U>;
+/** A place in a scan taken at `dpi` dots per inch, on the paper. */
+export declare const inMillimeters: (place: Pixels, dpi: number) => Millimeters;
+export declare const inCentimeters: (length: Millimeters) => Centimeters;
+export declare const inSeconds: (time: Milliseconds) => Seconds;
+export {};

package/lib/Quantity.js

@@ -0,0 +1,25 @@
+const quantity = (value) => value;
+export const mm = (quantity);
+export const cm = (quantity);
+export const px = (quantity);
+export const track = (quantity);
+export const seconds = (quantity);
+export const milliseconds = (quantity);
+export const feetPerMinute = (quantity);
+export const metersPerMinute = (quantity);
+// The second operand takes its unit from the first. Inferred from both,
+// TypeScript would unite two units rather than reject them.
+export const add = (a, b) => quantity(a + b);
+export const subtract = (a, b) => quantity(a - b);
+export const distance = (a, b) => quantity(Math.abs(a - b));
+/** A quantity times a plain factor, such as a stretch. */
+export const scale = (a, factor) => quantity(a * factor);
+// A list is taken at its element type, so one that mixes units yields a
+// union unit rather than an error; only the binary operations reject a mix.
+export const sum = (values) => quantity(values.reduce((total, value) => total + value, 0));
+export const mean = (values) => quantity(sum(values) / values.length);
+const MM_PER_INCH = 25.4;
+/** A place in a scan taken at `dpi` dots per inch, on the paper. */
+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);

package/lib/ReproducingSystem.d.ts

@@ -1,29 +1,32 @@
 import { Hole } from "./Feature";
 import { Expression, Note } from "./Symbol";
 import { TrackerBar } from "./TrackerBar";
+import { Millimeters, Quantity, Seconds } from "./Quantity";
+export type SpeedUnit = 'ft/min' | 'm/min';
 /**
- * The playback tempo of the roll, specified as a starting
- * and ending speed. The tempo may change over the course
- * of the roll due to acceleration effects.
+ * The playback tempo of the roll as a paper speed, stated at the
+ * beginning and at the end, since the speed may change over the
+ * course of the roll through acceleration.
  * @see crm:E54 Dimension
  */
-export interface RollTempo {
+export interface RollTempoIn<U extends SpeedUnit> {
     /**
      * The tempo at the beginning of the roll.
      * @see reo:from
      */
-    startsWith: number;
+    startsWith: Quantity<U>;
     /**
      * The tempo at the end of the roll.
      * @see reo:to
      */
-    endsWith: number;
+    endsWith: Quantity<U>;
     /**
-     * The unit of the tempo measurement (e.g. 'ft/min', 'm/min').
+     * The unit of the tempo measurement.
      * @see crm:P91 has unit
      */
-    unit: string;
+    unit: U;
 }
+export type RollTempo = RollTempoIn<'ft/min'> | RollTempoIn<'m/min'>;
 /**
  * A note or expression of a version with the dimensions of its carriers
  * averaged in and the editorial assumptions applied, which is all a
@@ -33,8 +36,8 @@ export type NegotiatedEvent = Omit<Note | Expression, 'carriers'> & Pick<Hole, '
 interface PerformedRollFeature<T> {
     type: T;
     performs: NegotiatedEvent;
-    /** Seconds from the beginning of the roll. */
-    at: number;
+    /** Time from the beginning of the roll. */
+    at: Seconds;
 }
 interface PerformedNoteEvent<T> extends PerformedRollFeature<T> {
     pitch: number;
@@ -76,8 +79,8 @@ export type PedalCurve = CurveSamples & {
 export type EmulatedCurve = DynamicsCurve | PedalCurve;
 /** What the edition records about the roll that a mechanism may want to know. */
 export type RollProperties = {
-    /** Diameter of the punches in mm, where the copies record it. */
-    punchDiameter?: number;
+    /** Diameter of the punches, where the copies record it. */
+    punchDiameter?: Millimeters;
     /** The tempo the edition adjusts the roll to, where it states one. */
     tempo?: RollTempo;
 };

package/lib/RollCopy.d.ts

@@ -6,6 +6,7 @@ import { AnyFeature } from "./Feature";
 import { ActorAssignment, DateAssignment, ObjectAssumption } from "./Assumption";
 import { WithId, WithType } from "./utils";
 import { Agent, Concept } from "./Agent";
+import { Measure, Millimeters, Quantity, Track } from "./Quantity";
 /**
  * This condition state is used to describe the roll's
  * paper shrinkage or stretching. It might be calculated
@@ -39,14 +40,16 @@ export declare const rollConditions: readonly ["general", "paper-stretch"];
  * (along the roll length, in mm) and vertical (across tracks).
  */
 export interface Shift {
-    /**
-     * Horizontal shift in millimeters (along the roll length).
-     */
-    horizontal: number;
-    /**
-     * Vertical shift in track numbers (across the tracker bar).
-     */
-    vertical: number;
+    /** Along the roll. */
+    horizontal: Millimeters;
+    /** Across the tracker bar. */
+    vertical: Track;
+}
+/** The margins on the treble and bass sides of the roll, in the unit the scan was measured in. */
+export interface Margins<U extends 'px' | 'mm'> {
+    treble: Quantity<U>;
+    bass: Quantity<U>;
+    unit: U;
 }
 /**
  * Describes the production of a roll copy: the manufacturer,
@@ -140,71 +143,37 @@ export interface RollCopy extends WithType<'RollCopy'>, WithId {
          */
         dimensions: {
             /**
-             * The width of the roll in the given unit.
+             * The width of the roll.
              * @see reo:width
              */
-            width: number;
+            width: Millimeters;
             /**
-             * The total height (length) of the roll in the given unit.
+             * The total height (length) of the roll.
              * @see reo:height
              */
-            height: number;
+            height: Millimeters;
             /**
-             * The unit of measurement (e.g. 'mm').
+             * The unit of measurement.
              * @see crm:P91 has unit
              */
-            unit: string;
+            unit: 'mm';
         };
         /**
          * The average diameter of punched holes.
          * @see reo:punchDiameter
          */
-        punchDiameter: {
-            /**
-             * The measured punch diameter value.
-             * @see crm:P90 has value
-             */
-            value: number;
-            /**
-             * The unit of measurement (e.g. 'mm').
-             * @see crm:P91 has unit
-             */
-            unit: string;
-        };
+        punchDiameter: Measure<'mm'>;
         /**
-         * The distance between adjacent tracker bar holes.
+         * The distance between adjacent tracker bar holes, in the
+         * unit the scan was measured in.
          * @see reo:holeSeparation
          */
-        holeSeparation: {
-            /**
-             * The measured hole separation value.
-             * @see crm:P90 has value
-             */
-            value: number;
-            /**
-             * The unit of measurement (e.g. 'px', 'mm').
-             * @see crm:P91 has unit
-             */
-            unit: string;
-        };
+        holeSeparation: Measure<'px'> | Measure<'mm'>;
         /**
          * The margins on the treble and bass sides of the roll.
          * Not exported to RDF.
          */
-        margins: {
-            /**
-             * The margin on the treble side.
-             */
-            treble: number;
-            /**
-             * The margin on the bass side.
-             */
-            bass: number;
-            /**
-             * The unit of measurement (e.g. 'px', 'mm').
-             */
-            unit: string;
-        };
+        margins: Margins<'px'> | Margins<'mm'>;
         /**
          * The shift applied to align this copy with the others.
          * Not exported to RDF.
@@ -282,7 +251,7 @@ export declare function asSymbols(features: AnyFeature[], bar?: TrackerBar): Any
  * The tracks a copy carries holes on that the tracker bar does not read.
  * A non-empty result usually means the scan is calibrated wrongly.
  */
-export declare function unreadTracks(features: AnyFeature[], bar?: TrackerBar): Map<number, number>;
+export declare function unreadTracks(features: AnyFeature[], bar?: TrackerBar): Map<Track, number>;
 /**
  * Falls back to the way the scan geometry was reconstructed before the
  * calibration was recorded: the bass hard margin stood in for the phase

package/lib/RollCopy.js

@@ -1,6 +1,7 @@
 import { v4 } from "uuid";
 import { welteT100 } from "./systems/welteT100/bar";
 import { assignReference } from "./Assumption";
+import { px, track } from "./Quantity";
 export const rollConditions = [
     'general',
     'paper-stretch'
@@ -34,8 +35,8 @@ export function unreadTracks(features, bar = welteT100) {
         .filter(feature => feature.type === 'Hole')
         .filter(feature => !bar.meaningOf(feature.vertical.from))
         .forEach(feature => {
-        const track = feature.vertical.from;
-        counts.set(track, (counts.get(track) || 0) + 1);
+        const position = feature.vertical.from;
+        counts.set(position, (counts.get(position) || 0) + 1);
     });
     return counts;
 }
@@ -53,14 +54,13 @@ export const calibrationOf = (copy) => {
     if (copy.measurements.trackCalibration) {
         return copy.measurements.trackCalibration;
     }
-    const separation = copy.measurements.holeSeparation?.value;
-    const bassMargin = copy.measurements.margins?.bass;
-    if (separation === undefined || bassMargin === undefined)
+    const { holeSeparation, margins } = copy.measurements;
+    if (holeSeparation?.unit !== 'px' || margins?.unit !== 'px')
         return undefined;
     return {
         unit: 'px',
-        offset: bassMargin + 1.5 * separation,
-        separation,
-        shift: 0
+        offset: px(margins.bass + 1.5 * holeSeparation.value),
+        separation: holeSeparation.value,
+        shift: track(0)
     };
 };

package/lib/TrackCalibration.d.ts

@@ -1,3 +1,4 @@
+import { Pixels, Track } from "./Quantity";
 /**
  * Relates a scan to the tracker bar it was read with.
  *
@@ -12,22 +13,22 @@
 export interface TrackCalibration {
     unit: 'px';
     /** Image column of the scanning software's track 0. */
-    offset: number;
+    offset: Pixels;
     /** Distance between the centres of adjacent tracks. */
-    separation: number;
+    separation: Pixels;
     /** Added to the scanning software's numbering to reach the tracker bar. */
-    shift: number;
+    shift: Track;
 }
 /** Image column at the centre of a tracker bar track. */
-export declare const columnOf: (track: number, calibration: TrackCalibration) => number;
+export declare const columnOf: (position: Track, calibration: TrackCalibration) => Pixels;
 /** Tracker bar track covering an image column, unrounded. */
-export declare const trackAt: (column: number, calibration: TrackCalibration) => number;
+export declare const trackAt: (column: Pixels, calibration: TrackCalibration) => Track;
 /**
  * The columns covered by a run of tracks, from the outer edge of the
  * first to the outer edge of the last.
  */
-export declare const columnsOf: (from: number, to: number, calibration: TrackCalibration) => {
-    from: number;
-    to: number;
-    width: number;
+export declare const columnsOf: (from: Track, to: Track, calibration: TrackCalibration) => {
+    from: Pixels;
+    to: Pixels;
+    width: Pixels;
 };

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) };
 };