linked-rolls 0.19.1 → 0.21.0

package/README.md

@@ -79,7 +79,7 @@ tracker bar and a `perform` function; the core does not depend on any one
 instrument's model.
 
 The first system is the red Welte, `linked-rolls/welte-t100`, built on
-[welte-t100-emulator](https://github.com/pfefferniels/welte-t100): the
+[welte-mignon-emulator](https://github.com/pfefferniels/welte-t100): the
 take-up spool sets the time axis, the Nuancierbälge fill through their
 conduits and are arrested by the Mezzoforte pin, and the two pedals travel
 rather than switch. The nuancing constants come as `instruments`: the
@@ -103,11 +103,36 @@ emulation.emulateVersion(version, view)
 const midi = emulation.asMIDI()
 ```
 
-The emulator is an optional peer dependency: an application that uses the
-T-100 system installs `welte-t100-emulator` itself, and one that only
-reads editions does not need it. For development on both at once, `npm
-link` a checkout of [welte-t100](https://github.com/pfefferniels/welte-t100)
-into this repository.
+The second is the green Welte, `linked-rolls/welte-t98`. Everything
+downstream of the relay is the same mechanism — Hagmann has the nuancing
+unit built the same for both tracker scales (p. 96) — and what differs is
+in front of it: each function lasts exactly as long as its own perforation
+runs over the glide block rather than latching until a cancel line is read,
+four conduits stand on one bellows and their drives add as flows, the
+crescendo's ceiling is the balance of its throttle against a permanently
+open bleed rather than a cap, the two pedals sit on the opposite edges of
+the paper, and a long perforation on the bass sforzando-piano line sends
+the roll back. Its constants are **not fitted**: `instruments.genuine` and
+`instruments.derived` are empty until their fits are run, and until then a
+playback runs on unfitted starting values, which every curve says in its
+own `instrument` field.
+
+Both systems share one velocity map, and `DynamicsCurve.travel` means the
+same thing on both: the position on the printed ordinate of Welte's own
+ruled band, 0 at that half's P.P. gridline and 1 at the shared F.F. line.
+That is what lets a red issue and a green issue of one recording be
+compared at all, since the band is ruled the same way on both.
+
+```ts
+import { welteT98System } from 'linked-rolls/welte-t98'
+```
+
+The emulator is an optional peer dependency: an application that uses one
+of the Welte systems installs `welte-mignon-emulator` itself, and one that
+only reads editions does not need it. For development on both at once,
+`npm link` a checkout of
+[welte-t100](https://github.com/pfefferniels/welte-t100) into this
+repository.
 
 ### Alignment, order and pairing
 

package/lib/Collation.d.ts

@@ -13,9 +13,7 @@ export interface CollationTolerance {
 }
 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. */
-export type Locate = (symbol: AnySymbol) => Readonly<{
-    horizontal: HorizontalSpan;
-}> | undefined;
+export type Locate = (symbol: AnySymbol) => Readonly<HorizontalSpan> | undefined;
 /**
  * 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

package/lib/Collation.js

@@ -1,17 +1,15 @@
+import { keyOf } from "./TrackerBar";
 import { distance, mm } from "./Quantity";
 import { partitionPoint } from "./sorted";
 export const defaultCollationTolerance = { toleranceStart: mm(5), toleranceEnd: mm(5) };
 /**
  * What a symbol says, as a key: the pitch of a note, the type and scope
- * of an expression. Symbols collate within one key only.
+ * of an expression. Symbols collate within one key only. This is the
+ * same key the tracker bars are indexed by, so two symbols collate
+ * exactly where two bars would read them as the same thing, which is
+ * what carries a note across a transfer between systems.
  */
-const kindOf = (symbol) => {
-    switch (symbol.type) {
-        case 'note': return `note ${symbol.pitch}`;
-        case 'expression': return `expression ${symbol.scope} ${symbol.expressionType}`;
-        case 'text': return 'text';
-    }
-};
+const kindOf = (symbol) => symbol.type === 'text' ? 'text' : keyOf(symbol);
 const nearby = (here, there, tolerance) => distance(here.from, there.from) <= tolerance.toleranceStart
     && distance(here.to, there.to) <= tolerance.toleranceEnd;
 /**
@@ -22,12 +20,12 @@ const nearby = (here, there, tolerance) => distance(here.from, there.from) <= to
 export const isCollatable = (a, b, locate, tolerance = defaultCollationTolerance) => {
     if (kindOf(a) !== kindOf(b))
         return false;
-    const here = locate(a)?.horizontal;
-    const there = locate(b)?.horizontal;
+    const here = locate(a);
+    const there = locate(b);
     return here !== undefined && there !== undefined && nearby(here, there, tolerance);
 };
 const placed = (symbols, locate) => symbols.flatMap((symbol, index) => {
-    const horizontal = locate(symbol)?.horizontal;
+    const horizontal = locate(symbol);
     return horizontal ? [{ symbol, index, horizontal }] : [];
 });
 const groupBy = (items, keyOf) => items.reduce((groups, item) => {

package/lib/Edition.d.ts

@@ -2,7 +2,7 @@ import { RollCopy } from "./RollCopy";
 import { Version } from "./Version";
 import { CollationTolerance } from "./Collation";
 import { DateAssignment, ObjectAssumption } from "./Assumption";
-import { Concept, Editor, Person, Place } from "./Agent";
+import { Editor, Person, Place } from "./Agent";
 import { RollTempo } from "./ReproducingSystem";
 /**
  * This type describes the creation of an edition,
@@ -91,14 +91,6 @@ export interface Roll {
      * @see dcterms:identifier
      */
     catalogueNumber: string;
-    /**
-     * The reproducing system the roll was cut for. A system the
-     * type vocabulary knows carries the IRI of its concept as `id`,
-     * from which the export takes the system's own context, so that
-     * the expression types are read as that system's.
-     * @see crm:P2 has type
-     */
-    system: Concept;
     /**
      * @see lrmoo:R19i was realised through
      */

package/lib/EditionView.d.ts

@@ -1,8 +1,10 @@
 import { Edition } from "./Edition";
-import { HorizontalSpan, VerticalSpan, AnyFeature } from "./Feature";
+import { HorizontalSpan, AnyFeature } from "./Feature";
 import { AnySymbol, Expression, Note } from "./Symbol";
 import { Version } from "./Version";
 import { NegotiatedEvent } from "./ReproducingSystem";
+import { TrackerBar } from "./TrackerBar";
+import { RollCopy } from "./RollCopy";
 import { Millimeters } from "./Quantity";
 export type Path = (string | number)[];
 export declare const getAt: <T>(path: Path, obj: unknown) => T | undefined;
@@ -20,6 +22,8 @@ export declare class EditionView {
      * Map from id to paths where it is referenced
      */
     private readonly links;
+    /** Built when a copy is first asked for, the walk not recording it. */
+    private copiesByFeature?;
     constructor(edition: Edition);
     atPath<T>(path: Path): T | null;
     indexObjects(): void;
@@ -31,11 +35,46 @@ export declare class EditionView {
     /** The version and its ancestors, from the version up to the root. */
     private lineageOf;
     carriersOf(symbol: AnySymbol): Readonly<AnyFeature>[];
+    /** The copy a feature sits on, a patch and everything it bears included. */
+    copyOf(featureId: string): Readonly<RollCopy> | undefined;
+    /**
+     * How a place on the edition's shared axis relates to the paper of
+     * this version: place × factor = millimetres of its own paper.
+     *
+     * Copies cut for different systems are scaled onto one axis so that
+     * they can be collated at all, which leaves a version of another
+     * system carrying places in the axis copy's millimetres. A
+     * performance needs the paper the roll actually ran on, and the
+     * factor is the inverse of the scale `alignCopy` recorded.
+     *
+     * It is read only from the copies of the version's own system, since
+     * under the shared axis a green version's notes are carried by red
+     * copies too and those say nothing about green paper. A copy whose
+     * scale is put down to its own paper having stretched is left out as
+     * well: that is a fact about the one exemplar, not about the speed
+     * the system's rolls were cut at. Where what remains disagrees,
+     * `constraintProblems` reports it rather than averaging it away.
+     */
+    toOwnPaperOf(version: Readonly<Version>): number | undefined;
+    /** The scales of the version's own copies that are not their own paper stretch. */
+    speedScalesIn(version: Readonly<Version>): number[];
+    /** The copies of the version's own system that carry any of its symbols. */
+    copiesOwning(version: Readonly<Version>): Readonly<RollCopy>[];
     predecessorOf(versionId: string): Readonly<Version> | undefined;
-    dimensionOf(symbol: AnySymbol): Readonly<{
-        horizontal: HorizontalSpan;
-        vertical: VerticalSpan;
-    }> | undefined;
+    /**
+     * Where along the roll the symbol lies, as its carriers put it, or
+     * nothing for a symbol no copy carries.
+     *
+     * Only the place is measured. Which track the symbol sits on is not
+     * a measurement but a question for a tracker bar, since a note of
+     * one pitch sits on exactly one position of a given bar: ask
+     * `bar.positionOf`. The carriers cannot answer it, because a copy
+     * cut for another system numbers its tracks differently, and one
+     * symbol may be carried by copies of both — averaging a red carrier
+     * on track 47 with a green one on 45 would give 46, a legal
+     * position a semitone away on either bar.
+     */
+    placeOf(symbol: AnySymbol): Readonly<HorizontalSpan> | undefined;
     /** Where the symbol begins, as the mean onset of its carriers, or nothing for a symbol without a place. */
     onsetOf(symbol: AnySymbol): Millimeters | undefined;
     /** The symbols by onset, those without a place first; symbols at one place keep their order. */
@@ -51,5 +90,14 @@ export declare class EditionView {
     withGenerations(): Array<Version & {
         generation: number;
     }>;
-    simplifySymbol(symbol: Note | Expression): NegotiatedEvent | null;
+    /**
+     * The symbol as a performance needs it: where it lies, and the
+     * position the performing bar reads it on.
+     *
+     * Nothing where that bar reads nothing of it, which is the case a
+     * transfer between systems leaves behind: a red `ForzandoOn` a
+     * green version still inherits cannot be performed on a green
+     * machine, and an edit has yet to say what took its place.
+     */
+    simplifySymbol(symbol: Note | Expression, bar: TrackerBar): NegotiatedEvent | null;
 }

package/lib/EditionView.js

@@ -1,4 +1,7 @@
+import { withBorneFeatures } from "./Feature";
 import { deletedBy, insertedBy } from "./Version";
+import { systemIdOf } from "./TrackerBar";
+import { isPaperStretch } from "./RollCopy";
 import { idOf, idsOf } from "./Assumption";
 import { mean } from "./Quantity";
 export const getAt = (path, obj) => {
@@ -58,6 +61,13 @@ export class EditionView {
             writable: true,
             value: new Map()
         });
+        /** Built when a copy is first asked for, the walk not recording it. */
+        Object.defineProperty(this, "copiesByFeature", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.edition = edition;
         this.indexObjects();
     }
@@ -141,35 +151,87 @@ export class EditionView {
     carriersOf(symbol) {
         return this.getAll(idsOf(symbol.carriers));
     }
+    /** The copy a feature sits on, a patch and everything it bears included. */
+    copyOf(featureId) {
+        if (!this.copiesByFeature) {
+            this.copiesByFeature = new Map(this.edition.copies.flatMap(copy => copy.features
+                .flatMap(withBorneFeatures)
+                .map(feature => [feature.id, copy])));
+        }
+        return this.copiesByFeature.get(featureId);
+    }
+    /**
+     * How a place on the edition's shared axis relates to the paper of
+     * this version: place × factor = millimetres of its own paper.
+     *
+     * Copies cut for different systems are scaled onto one axis so that
+     * they can be collated at all, which leaves a version of another
+     * system carrying places in the axis copy's millimetres. A
+     * performance needs the paper the roll actually ran on, and the
+     * factor is the inverse of the scale `alignCopy` recorded.
+     *
+     * It is read only from the copies of the version's own system, since
+     * under the shared axis a green version's notes are carried by red
+     * copies too and those say nothing about green paper. A copy whose
+     * scale is put down to its own paper having stretched is left out as
+     * well: that is a fact about the one exemplar, not about the speed
+     * the system's rolls were cut at. Where what remains disagrees,
+     * `constraintProblems` reports it rather than averaging it away.
+     */
+    toOwnPaperOf(version) {
+        const scales = this.speedScalesIn(version);
+        return scales.length === 1 ? 1 / scales[0] : undefined;
+    }
+    /** The scales of the version's own copies that are not their own paper stretch. */
+    speedScalesIn(version) {
+        return [...new Set(this.copiesOwning(version)
+                .filter(copy => !copy.conditions.some(isPaperStretch))
+                .map(copy => copy.measurements.scale)
+                .filter((scale) => scale !== undefined && scale > 0))];
+    }
+    /** The copies of the version's own system that carry any of its symbols. */
+    copiesOwning(version) {
+        const system = systemIdOf(version.system);
+        const carrying = new Set(this.snapshot(version.id)
+            .flatMap(symbol => idsOf(symbol.carriers))
+            .flatMap(id => {
+            const copy = this.copyOf(id);
+            return copy ? [copy.id] : [];
+        }));
+        return this.edition.copies.filter(copy => carrying.has(copy.id) && systemIdOf(copy.production?.system) === system);
+    }
     predecessorOf(versionId) {
         const v = this.get(versionId);
         if (!v?.basedOn)
             return;
         return this.get(idOf(v.basedOn));
     }
-    dimensionOf(symbol) {
+    /**
+     * Where along the roll the symbol lies, as its carriers put it, or
+     * nothing for a symbol no copy carries.
+     *
+     * Only the place is measured. Which track the symbol sits on is not
+     * a measurement but a question for a tracker bar, since a note of
+     * one pitch sits on exactly one position of a given bar: ask
+     * `bar.positionOf`. The carriers cannot answer it, because a copy
+     * cut for another system numbers its tracks differently, and one
+     * symbol may be carried by copies of both — averaging a red carrier
+     * on track 47 with a green one on 45 would give 46, a legal
+     * position a semitone away on either bar.
+     */
+    placeOf(symbol) {
         const carriers = this.getAll(idsOf(symbol.carriers));
-        if (carriers.length === 0) {
+        if (carriers.length === 0)
             return;
-        }
-        const farEnds = carriers.flatMap(carrier => carrier.vertical.to === undefined ? [] : [carrier.vertical.to]);
         return {
-            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) })
-            }
+            unit: 'mm',
+            from: mean(carriers.map(carrier => carrier.horizontal.from)),
+            to: mean(carriers.map(carrier => carrier.horizontal.to))
         };
     }
     /** Where the symbol begins, as the mean onset of its carriers, or nothing for a symbol without a place. */
     onsetOf(symbol) {
-        const carriers = this.carriersOf(symbol);
-        return carriers.length > 0 ? mean(carriers.map(carrier => carrier.horizontal.from)) : undefined;
+        return this.placeOf(symbol)?.from;
     }
     /** The symbols by onset, those without a place first; symbols at one place keep their order. */
     inOrderOfPlace(symbols) {
@@ -231,13 +293,24 @@ export class EditionView {
         }));
         return withGen;
     }
-    simplifySymbol(symbol) {
-        const dim = this.dimensionOf(symbol);
-        if (!symbol.carriers.length || !dim)
+    /**
+     * The symbol as a performance needs it: where it lies, and the
+     * position the performing bar reads it on.
+     *
+     * Nothing where that bar reads nothing of it, which is the case a
+     * transfer between systems leaves behind: a red `ForzandoOn` a
+     * green version still inherits cannot be performed on a green
+     * machine, and an edit has yet to say what took its place.
+     */
+    simplifySymbol(symbol, bar) {
+        const horizontal = this.placeOf(symbol);
+        const position = bar.positionOf(symbol);
+        if (!horizontal || position === undefined)
             return null;
         return {
             ...symbol,
-            ...dim
+            horizontal,
+            vertical: { unit: 'track', from: position }
         };
     }
 }

package/lib/Emulation.js

@@ -9,9 +9,10 @@ const punchDiameterOf = (view) => {
         .filter((value) => value !== undefined && value > 0);
     return measured.length > 0 ? mean(measured) : undefined;
 };
-const propertiesOf = (view) => ({
+const propertiesOf = (view, version) => ({
     punchDiameter: punchDiameterOf(view),
-    tempo: view.edition.tempoAdjustment
+    tempo: view.edition.tempoAdjustment,
+    toOwnPaper: view.toOwnPaperOf(version)
 });
 /** 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) => {
@@ -154,7 +155,7 @@ export class Emulation {
         this.negotiatedEvents =
             view.snapshot(version.id)
                 .filter(isPerforation)
-                .map(symbol => view.simplifySymbol(symbol))
+                .map(symbol => view.simplifySymbol(symbol, this.system.trackerBar))
                 .filter(event => event !== null)
                 .filter(inScope);
         if (this.negotiatedEvents.length === 0) {
@@ -163,7 +164,7 @@ export class Emulation {
             return this.midiEvents;
         }
         this.applyConstraints(view);
-        const performance = this.system.perform(this.negotiatedEvents, this.options, propertiesOf(view));
+        const performance = this.system.perform(this.negotiatedEvents, this.options, propertiesOf(view, version));
         this.curves = performance.curves;
         const onsets = performance.events.filter(event => event.type === 'noteOn').map(event => event.at);
         const origin = skipToFirstNote ? earliestOf(onsets) : seconds(0);

package/lib/ReproducingSystem.d.ts

@@ -63,8 +63,18 @@ interface CurveSamples {
     readonly place: Float64Array;
     readonly seconds: Float64Array;
     /**
-     * Position between the two ends of a travel: 0 with a bellows open and
-     * 1 with it closed, 0 with a pedal up and 1 with it down.
+     * Position on the printed ordinate of the roll's own ruled band: 0 at that
+     * half's P.P. gridline, 1 at the shared F.F. line, with M.F. at 0.5. For a
+     * pedal, 0 with it up and 1 with it down.
+     *
+     * Both Welte scales rule that band the same way — five rails, "P.P. M.F.
+     * F.F. M.F. P.P.", three named levels a side with the centre F.F. shared,
+     * measuring 20.0 mm between rails on red 3309 and on green Welte 184 alike —
+     * so a curve from one system and a curve from the other are in one unit, on
+     * Welte's authority rather than on ours. That is what lets a red issue and a
+     * green issue of one recording be compared at all. It is a unit of *drawn
+     * deflection*: whether the deflection is linear in the bellows' own travel is
+     * open, and is what the emulator's `scaleWarp` exists to answer.
      */
     readonly travel: Float64Array;
 }
@@ -72,6 +82,14 @@ interface CurveSamples {
 export type DynamicsCurve = CurveSamples & {
     readonly kind: 'dynamics';
     readonly velocity: Float64Array;
+    /**
+     * The instrument whose constants produced it, by name. A comparison plot
+     * must not be able to put two curves side by side without saying which
+     * instrument each came from: a T-98 fitted to a green roll's drawn line and
+     * a T-98 fitted to a red copy's curve answer different questions, and their
+     * difference is the point of the comparison.
+     */
+    readonly instrument: string;
 };
 export type PedalCurve = CurveSamples & {
     readonly kind: 'pedal';
@@ -83,6 +101,24 @@ export type RollProperties = {
     punchDiameter?: Millimeters;
     /** The tempo the edition adjusts the roll to, where it states one. */
     tempo?: RollTempo;
+    /**
+     * Place on the edition's shared axis × this = millimetres of the version's
+     * own paper. About 0.775 for a green issue of a red recording, 1 for a
+     * version on the axis it was measured on, which is the default.
+     *
+     * Versions of several systems share one place axis, so a green version's
+     * places are in red millimetres and would play about 29 % long if the
+     * spool read them as green paper. The factor is the inverse of the scale
+     * `alignCopy` recorded when it put the copy on the shared axis, taken from
+     * the copies of the version's own system: red copies carry a green
+     * version's notes too and say nothing about green paper.
+     *
+     * It scales **places only**. Punch diameter, the chain gap and the tracker
+     * bore are measured on the version's own paper already, and scaling them
+     * as well would put the aperture model out by the factor with nothing
+     * failing loudly.
+     */
+    toOwnPaper?: number;
 };
 export type Performance = {
     readonly events: readonly AnyPerformedRollFeature[];

package/lib/RollCopy.d.ts

@@ -301,17 +301,40 @@ export interface RollCopy extends WithType<'RollCopy'>, WithId {
      */
     readFrom?: FeatureSource;
 }
+/**
+ * Whether the condition is the stretch or shrinkage of the paper. A
+ * scale put down to this belongs to the one exemplar and says nothing
+ * about the speed its system's rolls were cut at.
+ */
+export declare const isPaperStretch: (condition: RollConditionAssignment) => boolean;
+/**
+ * The bar a copy is read by, which is the one it was cut for. A copy
+ * that names no system falls back to the T-100, as every copy was read
+ * before the systems were told apart; `reservationsAbout` says so.
+ */
+export declare const barOf: (copy: Pick<RollCopy, 'production'>) => TrackerBar;
 /**
  * Reads the features of a copy as the tracker bar would read them.
  * Holes on a position the bar does not read carry no symbol and are
  * dropped, which is what happens physically as well.
+ *
+ * The bar is named rather than defaulted: a copy is read by its own
+ * bar, and reading a green copy with the red one is a silent semitone.
+ *
+ * Reading stops where the bar says the roll's content ends. What a
+ * scanner punched past the rewind is not the roll speaking: Julian
+ * Dyer's scan of the green 225 carries a staircase of test punches
+ * across nearly every track after its rewind, which read on as symbols
+ * would be 318 notes nobody played. The features stay on the copy,
+ * since they are really on the paper and are his calibration of his own
+ * scan; it is the reading that stops.
  */
-export declare function asSymbols(features: AnyFeature[], bar?: TrackerBar): AnySymbol[];
+export declare function asSymbols(features: AnyFeature[], bar: TrackerBar): AnySymbol[];
 /**
  * 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<Track, 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,19 +1,45 @@
 import { v4 } from "uuid";
 import { welteT100 } from "./systems/welteT100/bar";
+import { trackerBarOf } from "./systems";
 import { assignReference } from "./Assumption";
 import { px, track } from "./Quantity";
 export const rollConditions = [
     'general',
     'paper-stretch'
 ];
+/**
+ * Whether the condition is the stretch or shrinkage of the paper. A
+ * scale put down to this belongs to the one exemplar and says nothing
+ * about the speed its system's rolls were cut at.
+ */
+export const isPaperStretch = (condition) => condition.conditionType === 'paper-stretch';
+/**
+ * The bar a copy is read by, which is the one it was cut for. A copy
+ * that names no system falls back to the T-100, as every copy was read
+ * before the systems were told apart; `reservationsAbout` says so.
+ */
+export const barOf = (copy) => trackerBarOf(copy.production?.system) ?? welteT100;
 /**
  * Reads the features of a copy as the tracker bar would read them.
  * Holes on a position the bar does not read carry no symbol and are
  * dropped, which is what happens physically as well.
+ *
+ * The bar is named rather than defaulted: a copy is read by its own
+ * bar, and reading a green copy with the red one is a silent semitone.
+ *
+ * Reading stops where the bar says the roll's content ends. What a
+ * scanner punched past the rewind is not the roll speaking: Julian
+ * Dyer's scan of the green 225 carries a staircase of test punches
+ * across nearly every track after its rewind, which read on as symbols
+ * would be 318 notes nobody played. The features stay on the copy,
+ * since they are really on the paper and are his calibration of his own
+ * scan; it is the reading that stops.
  */
-export function asSymbols(features, bar = welteT100) {
-    return features
-        .filter(feature => feature.type === 'Hole')
+export function asSymbols(features, bar) {
+    const holes = features.filter(feature => feature.type === 'Hole');
+    const end = bar.endsAt(holes);
+    return holes
+        .filter(feature => end === undefined || feature.horizontal.from <= end.at)
         .flatMap((feature) => {
         const meaning = bar.meaningOf(feature.vertical.from);
         if (!meaning)
@@ -29,7 +55,7 @@ export function asSymbols(features, bar = welteT100) {
  * 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 function unreadTracks(features, bar = welteT100) {
+export function unreadTracks(features, bar) {
     const counts = new Map();
     features
         .filter(feature => feature.type === 'Hole')

package/lib/TrackerBar.d.ts

@@ -56,13 +56,39 @@ export interface TrackerBar {
      * of their own, as the Licensee's do, states none.
      */
     readonly paperSpeed?: SpeedMeasure;
+    /**
+     * Where the roll's own content ends, from its perforations alone, or
+     * `undefined` where nothing on the paper says. A copy that reads
+     * `undefined` runs to the end of whatever was scanned, which is a fact
+     * about the scan rather than about the roll and should be reported as one.
+     *
+     * Takes anything with a place and a position, so a reader can ask it of a
+     * copy's features before there are symbols, and a collation can ask it of
+     * the symbols afterwards.
+     */
+    endsAt(features: readonly PlacedOnBar[]): RollEnd | undefined;
     /** `undefined` for a position the bar does not read. */
     meaningOf(position: Track): TrackMeaning | undefined;
+    /**
+     * `meaningOf` inverted: the position this bar reads the meaning on,
+     * or `undefined` where it does not read it at all. A symbol's track
+     * is this rather than anything measured, since a note of one pitch
+     * sits on exactly one position of a given bar.
+     */
+    positionOf(meaning: TrackMeaning): Track | undefined;
     /** `undefined` for a position the bar does not read. */
     roleOf(position: Track): TrackRole | undefined;
 }
+/**
+ * What a position says, as a key. Two bars read the same thing exactly
+ * where their keys agree, which is what lets a symbol cross from one
+ * system to another and what decides whether two symbols collate.
+ */
+export declare const keyOf: (meaning: TrackMeaning) => string;
 /** 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 the IRI naming it. */
+export declare const systemIdIn: (id: string | undefined) => string | undefined;
 /** The identifier of a system the type vocabulary knows, from its concept. */
 export declare const systemIdOf: (system: Concept | undefined) => string | undefined;
 /**
@@ -70,6 +96,28 @@ export declare const systemIdOf: (system: Concept | undefined) => string | undef
  * in the bar's own 1-based numbering; `describeTrackerBar` gives them
  * their type.
  */
+/**
+ * Where a roll's own content ends, as far as its perforations say.
+ *
+ * This is a question about the paper, not about the mechanism: it asks where
+ * the rewind is *punched*, not when the rewind pneumatic takes hold. The second
+ * is a matter of valve lift and belongs to whatever performs the roll. Keeping
+ * them apart is what lets collation and counting ask this without an emulator.
+ */
+export type RollEnd = {
+    readonly at: Millimeters;
+    readonly because: 'rewind';
+};
+/** Anything carrying a place on the roll and a position on the bar. */
+export type PlacedOnBar = {
+    readonly horizontal: {
+        readonly from: Millimeters;
+        readonly to: Millimeters;
+    };
+    readonly vertical: {
+        readonly from: Track;
+    };
+};
 export interface TrackerBarSpec {
     id: string;
     name: string;
@@ -92,12 +140,19 @@ export interface TrackerBarSpec {
     rewindTrack?: number;
     /** The speed the system runs its rolls at, where the literature states one. */
     paperSpeed?: SpeedMeasure;
+    /**
+     * How long a perforation on a *shared* rewind position has to be before it
+     * is the rewind rather than the command the position usually carries. Only
+     * meaningful with `rewindTrack`: a system that gives the rewind a line of
+     * its own needs no threshold, since anything there is the rewind.
+     */
+    rewindHold?: Millimeters;
 }
 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.
+ * is how a copy read in one system's numbering is put into another's,
+ * as the migration does for a Licensee copy stored on T-100 tracks.
  */
 export declare const translationBetween: (from: TrackerBar, to: TrackerBar) => (position: Track) => Track | undefined;