linked-rolls 0.19.1 → 0.21.0

package/lib/substitution.js

@@ -0,0 +1,175 @@
+import { defaultCollationTolerance } from "./Collation";
+import { distance, mm, track } from "./Quantity";
+/**
+ * What each Welte command operates.
+ *
+ * This cannot be read off the names. The T-100 latches a function on
+ * with one perforation and cancels it with a second, while the T-98
+ * holds it for as long as one perforation lasts (Hagmann pp. 89 f. and
+ * 100–103; Phillips p. 121), and Welte renamed two of the functions
+ * between the scales: the red `SlowCrescendo` is the green `Crescendo`,
+ * and the red's single `Forzando` valve answers to two green ones that
+ * name the end they pull towards. So the correspondence is stated here
+ * rather than derived, and only two commands that operate one function
+ * can stand for each other.
+ *
+ * The T-100's `MotorOn`/`MotorOff`, `Rewind` and `ElectricCutOff` are
+ * left out on purpose: the green scale has no word for any of them, its
+ * motor switch being an automatic mercury contact (Skala-Rolle 98 §12)
+ * and its rewind riding on the bass sforzando-piano line. A red command
+ * of those kinds has no counterpart and stays a plain deletion.
+ */
+const commands = {
+    MezzoforteOn: { operates: 'mezzoforte', spelling: 'on', sided: true },
+    MezzoforteOff: { operates: 'mezzoforte', spelling: 'off', sided: true },
+    SlowCrescendoOn: { operates: 'crescendo', spelling: 'on', sided: true },
+    SlowCrescendoOff: { operates: 'crescendo', spelling: 'off', sided: true },
+    ForzandoOn: { operates: 'sforzando', spelling: 'on', sided: true },
+    ForzandoOff: { operates: 'sforzando', spelling: 'off', sided: true },
+    SustainPedalOn: { operates: 'sustainPedal', spelling: 'on', sided: false },
+    SustainPedalOff: { operates: 'sustainPedal', spelling: 'off', sided: false },
+    SoftPedalOn: { operates: 'softPedal', spelling: 'on', sided: false },
+    SoftPedalOff: { operates: 'softPedal', spelling: 'off', sided: false },
+    Mezzoforte: { operates: 'mezzoforte', spelling: 'held', sided: true },
+    Crescendo: { operates: 'crescendo', spelling: 'held', sided: true },
+    SforzandoForte: { operates: 'sforzando', spelling: 'held', sided: true },
+    SforzandoPiano: { operates: 'sforzando', spelling: 'held', sided: true },
+    SustainPedal: { operates: 'sustainPedal', spelling: 'held', sided: false },
+    SoftPedal: { operates: 'softPedal', spelling: 'held', sided: false }
+};
+/** What a command operates, or nothing for a word no scale here knows. */
+export const commandOf = (expressionType) => commands[expressionType];
+/**
+ * How wide a paper bridge may be for two held perforations to be one
+ * command. The T-98 punches a hold as a chain of round holes on a
+ * 2.66 mm grid with bridges of about a millimetre, so a scan read hole
+ * by hole shows a run where the paper shows one command.
+ */
+export const defaultChainGap = mm(3);
+const isExpression = (symbol) => symbol.type === 'expression';
+/** The key a command is matched on: the function, and the side where the side counts. */
+const functionKey = (symbol, command) => command.sided ? `${command.operates} ${symbol.scope}` : command.operates;
+/**
+ * The position a bar reads its own command for the same function on,
+ * where it has no word for this one.
+ *
+ * A version keeps the perforations it does away with in its deletions,
+ * and those may be a scale the version is not coded for: a green
+ * version deletes the red `SlowCrescendoOn` it inherits. That has no
+ * position on the green bar, so drawing it as a perforation is out of
+ * the question, but an edit still has to be shown somewhere, and the
+ * lane the green scale gives the same function is where it belongs.
+ */
+export const positionOfSameFunction = (bar, symbol) => {
+    const wanted = commandOf(symbol.expressionType);
+    if (!wanted)
+        return undefined;
+    const positions = Array.from({ length: bar.trackCount }, (_, index) => track(index + 1));
+    return positions.find(position => {
+        const meaning = bar.meaningOf(position);
+        if (meaning?.type !== 'expression')
+            return false;
+        const command = commandOf(meaning.expressionType);
+        return command !== undefined
+            && command.operates === wanted.operates
+            && functionKey(meaning, command) === functionKey(symbol, wanted);
+    });
+};
+/**
+ * The intervals the older version latches: each perforation that turns
+ * a function on, with the one that cancels it next on the same line.
+ */
+const latchedIn = (symbols, locate) => {
+    const byFunction = new Map();
+    symbols.filter(isExpression).forEach(symbol => {
+        const command = commandOf(symbol.expressionType);
+        const at = locate(symbol)?.from;
+        if (!command || command.spelling === 'held' || at === undefined)
+            return;
+        const key = functionKey(symbol, command);
+        const group = byFunction.get(key) ?? [];
+        group.push({ symbol, at, spelling: command.spelling });
+        byFunction.set(key, group);
+    });
+    return [...byFunction.values()].flatMap(group => {
+        const inOrder = [...group].sort((a, b) => a.at - b.at);
+        return inOrder.reduce((state, entry) => {
+            // A second On while the function already stands is
+            // redundant, and the interval began at the first, which
+            // is how a red copy reads that reaches the end of the
+            // roll with two Ons and one Off.
+            if (entry.spelling === 'on') {
+                return state.open ? state : { ...state, open: { on: entry.symbol, from: entry.at } };
+            }
+            return state.open
+                ? {
+                    open: undefined,
+                    closed: [...state.closed, {
+                            on: state.open.on,
+                            off: entry.symbol,
+                            from: state.open.from,
+                            to: entry.at,
+                            key: functionKey(state.open.on, commandOf(state.open.on.expressionType))
+                        }]
+                }
+                : state;
+        }, { closed: [] }).closed;
+    });
+};
+/**
+ * The commands the newer version holds, a chain of punches counting as
+ * the one command the paper shows rather than as a run of them.
+ */
+const heldRunsIn = (symbols, locate, chainGap) => {
+    const byFunction = new Map();
+    symbols.filter(isExpression).forEach(symbol => {
+        const command = commandOf(symbol.expressionType);
+        const place = locate(symbol);
+        if (!command || command.spelling !== 'held' || !place)
+            return;
+        const key = functionKey(symbol, command);
+        const group = byFunction.get(key) ?? [];
+        group.push({ symbol, from: place.from, to: place.to });
+        byFunction.set(key, group);
+    });
+    return [...byFunction.entries()].flatMap(([key, group]) => [...group]
+        .sort((a, b) => a.from - b.from)
+        .reduce((runs, punch) => {
+        const open = runs[runs.length - 1];
+        if (open && punch.from - open.to <= chainGap) {
+            open.of.push(punch.symbol);
+            open.to = punch.to > open.to ? punch.to : open.to;
+            return runs;
+        }
+        return [...runs, { of: [punch.symbol], from: punch.from, to: punch.to, key }];
+    }, []));
+};
+/** The only item of the list, or nothing where there is none or a rival. */
+const theOnly = (items) => items.length === 1 ? items[0] : undefined;
+/**
+ * Where a held perforation of the newer version stands for a latched
+ * function of the older one: the same function, on the same side where
+ * the side counts, spanning the same stretch of the roll.
+ *
+ * Only unambiguous correspondences are reported. Where two held
+ * perforations answer one latched interval, or one answers two, none of
+ * them is reported and the editor is left to say what happened. Nothing
+ * is invented either: both sides are perforations somebody punched, and
+ * all this asserts is which stands for which.
+ */
+export const substitutionsBetween = (own, inherited, locate, tolerance = defaultCollationTolerance, chainGap = defaultChainGap) => {
+    const latched = latchedIn(inherited, locate);
+    const spans = (run, interval) => distance(run.from, interval.from) <= tolerance.toleranceStart
+        && distance(run.to, interval.to) <= tolerance.toleranceEnd;
+    const candidates = heldRunsIn(own, locate, chainGap).flatMap(run => {
+        const answered = latched.filter(interval => interval.key === run.key && spans(run, interval));
+        const only = theOnly(answered);
+        return only ? [{ run, interval: only }] : [];
+    });
+    // A latched interval two runs both answer is ambiguous from its side
+    // as well, so neither of them is reported.
+    const claims = candidates.reduce((counts, { interval }) => counts.set(interval.on.id, (counts.get(interval.on.id) ?? 0) + 1), new Map());
+    return candidates
+        .filter(({ interval }) => claims.get(interval.on.id) === 1)
+        .map(({ run, interval }) => ({ replaced: [interval.on, interval.off], by: run.of }));
+};

package/lib/systems/velocity.d.ts

@@ -0,0 +1,34 @@
+/**
+ * How bellows travel becomes a MIDI velocity.
+ *
+ * Shared by every Welte system rather than declared per system, and that is a
+ * decision about comparability rather than about accuracy. The point of running
+ * a red issue and a green issue of one recording through two emulators is to
+ * attribute the difference between them to the coding. If the two systems used
+ * two velocity maps, the difference between the maps would dominate and the
+ * comparison would measure the maps.
+ *
+ * Nothing in either mechanism determines the map. These three anchors are
+ * midi2exp's published velocities, joined linearly with the middle one at the
+ * Mezzoforte pin of the half in question, and they are what the T-100's
+ * published results were produced with. Two independent implementations
+ * disagree with them and may well be right: Stahnke gives `v_h = K_s √(w − W_s)`
+ * for vacuum to hammer velocity and `V_MIDI = round(52 + 25 log₂ v_h)` for
+ * velocity to MIDI, and Phillips and Gosden's *Rollmidi*, in the same volume,
+ * uses an explicitly logarithmic curve; Phillips's own bench measurement has the
+ * suction-to-velocity relation "essentially logarithmic" (pp. 215 f.). The
+ * default should change only once a red/green comparison has been run both ways
+ * and the difference measured, and then for both systems at once.
+ */
+export type VelocityMap = {
+    piano: number;
+    mezzoforte: number;
+    forte: number;
+};
+/** midi2exp's three velocities, which is what the T-100's published results used. */
+export declare const defaultVelocityMap: VelocityMap;
+/**
+ * The map joined linearly through its three anchors, with the middle one at the
+ * Mezzoforte pin of the half in question.
+ */
+export declare const velocityOf: (travel: number, hook: number, map: VelocityMap) => number;

package/lib/systems/velocity.js

@@ -0,0 +1,36 @@
+/**
+ * How bellows travel becomes a MIDI velocity.
+ *
+ * Shared by every Welte system rather than declared per system, and that is a
+ * decision about comparability rather than about accuracy. The point of running
+ * a red issue and a green issue of one recording through two emulators is to
+ * attribute the difference between them to the coding. If the two systems used
+ * two velocity maps, the difference between the maps would dominate and the
+ * comparison would measure the maps.
+ *
+ * Nothing in either mechanism determines the map. These three anchors are
+ * midi2exp's published velocities, joined linearly with the middle one at the
+ * Mezzoforte pin of the half in question, and they are what the T-100's
+ * published results were produced with. Two independent implementations
+ * disagree with them and may well be right: Stahnke gives `v_h = K_s √(w − W_s)`
+ * for vacuum to hammer velocity and `V_MIDI = round(52 + 25 log₂ v_h)` for
+ * velocity to MIDI, and Phillips and Gosden's *Rollmidi*, in the same volume,
+ * uses an explicitly logarithmic curve; Phillips's own bench measurement has the
+ * suction-to-velocity relation "essentially logarithmic" (pp. 215 f.). The
+ * default should change only once a red/green comparison has been run both ways
+ * and the difference measured, and then for both systems at once.
+ */
+/** midi2exp's three velocities, which is what the T-100's published results used. */
+export const defaultVelocityMap = { piano: 35, mezzoforte: 60, forte: 90 };
+const clamp = (value, low, high) => Math.min(Math.max(value, low), high);
+/**
+ * The map joined linearly through its three anchors, with the middle one at the
+ * Mezzoforte pin of the half in question.
+ */
+export const velocityOf = (travel, hook, map) => {
+    const position = clamp(travel, 0, 1);
+    if (position <= hook) {
+        return map.piano + (position / hook) * (map.mezzoforte - map.piano);
+    }
+    return map.mezzoforte + ((position - hook) / (1 - hook)) * (map.forte - map.mezzoforte);
+};

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

@@ -0,0 +1,46 @@
+import { ReproducingSystem } from "../../ReproducingSystem";
+import { type WelteT100Options } from "../welteT100/system";
+export type WelteLicenseeOptions = WelteT100Options;
+/**
+ * The one instrument on offer, and it is not a Licensee instrument.
+ *
+ * These are the T-100 consensus constants, fitted across the hand-drawn
+ * nuance lines of six rolls played on Freiburg instruments. Nothing here was
+ * measured on a Licensee: no Licensee roll is known to carry a drawn line, no
+ * Licensee instrument has been fitted, and the published prior art does not
+ * agree with itself — the same 186 ms is a part stroke in midi2exp and a whole
+ * stroke in pianolatron, a factor of 2.2.
+ *
+ * So a Licensee playback is a Freiburg reading of American paper, and the
+ * union has one arm to keep that visible. Nothing should be published from it.
+ */
+export declare const instruments: {
+    unfitted: {
+        'welte-t100-consensus': import("welte-mignon-emulator/t100").Instrument;
+    };
+};
+export type WelteLicenseeInstrumentName = {
+    unfitted: 'welte-t100-consensus';
+};
+export declare const instrumentNames: readonly WelteLicenseeInstrumentName[];
+/**
+ * Welte's own spool is carried over with the constants. Phillips (p. 181) says
+ * Licensee rolls "play at a range of paper speeds", so there is no one figure
+ * to put here and the red geometry is a placeholder rather than a reading.
+ * Where an edition states a tempo of its own it is the better authority, and
+ * the spool is better varied than trusted: it scales every conductance by k
+ * and every time constant by 1/k, and touches nothing dimensionless.
+ */
+export declare const defaultWelteLicenseeOptions: WelteLicenseeOptions;
+/**
+ * Welte-Mignon (Licensee), the American re-cut. It keeps the T-100's
+ * lock-and-cancel coding on 98 tracks — which is what separates it from the
+ * green, the coding rule rather than the track count (Phillips, Table 4.3) —
+ * so it reads the same commands and is played by the same mechanism.
+ *
+ * What it does not have is an instrument of its own. The constants are the
+ * T-100's, the spool is the T-100's, and neither has ever been checked against
+ * a Licensee. `instruments` therefore offers a single `unfitted` arm, and every
+ * curve produced here names itself as such.
+ */
+export declare const welteLicenseeSystem: ReproducingSystem<WelteLicenseeOptions>;

package/lib/systems/welteLicensee/system.js

@@ -0,0 +1,60 @@
+import { CONSENSUS } from "welte-mignon-emulator/t100";
+import { track } from "../../Quantity";
+import { welteLicensee } from "./bar";
+import { defaultWelteT100Options, instrumentNameOf, nuanceOf, performAs } from "../welteT100/system";
+/**
+ * The one instrument on offer, and it is not a Licensee instrument.
+ *
+ * These are the T-100 consensus constants, fitted across the hand-drawn
+ * nuance lines of six rolls played on Freiburg instruments. Nothing here was
+ * measured on a Licensee: no Licensee roll is known to carry a drawn line, no
+ * Licensee instrument has been fitted, and the published prior art does not
+ * agree with itself — the same 186 ms is a part stroke in midi2exp and a whole
+ * stroke in pianolatron, a factor of 2.2.
+ *
+ * So a Licensee playback is a Freiburg reading of American paper, and the
+ * union has one arm to keep that visible. Nothing should be published from it.
+ */
+export const instruments = { unfitted: { 'welte-t100-consensus': CONSENSUS } };
+export const instrumentNames = [
+    { unfitted: 'welte-t100-consensus' }
+];
+/**
+ * Welte's own spool is carried over with the constants. Phillips (p. 181) says
+ * Licensee rolls "play at a range of paper speeds", so there is no one figure
+ * to put here and the red geometry is a placeholder rather than a reading.
+ * Where an edition states a tempo of its own it is the better authority, and
+ * the spool is better varied than trusted: it scales every conductance by k
+ * and every time constant by 1/k, and touches nothing dimensionless.
+ */
+export const defaultWelteLicenseeOptions = {
+    ...defaultWelteT100Options,
+    nuance: nuanceOf(CONSENSUS),
+    /**
+     * Two positions lower than the T-100's 54: the Licensee drops the two
+     * motor tracks, so the note block and the treble valves sit two places in
+     * (Hagmann p. 40 f., Phillips p. 123).
+     */
+    division: track(52)
+};
+/** Never the bare name of a T-100 instrument: a curve from here has to say what it ran on. */
+const licenseeInstrument = (nuance) => instrumentNameOf(nuance) === 'consensus'
+    ? 'Welte-Mignon (Licensee), unfitted — Welte-Mignon T-100 consensus'
+    : 'Welte-Mignon (Licensee), custom';
+/**
+ * Welte-Mignon (Licensee), the American re-cut. It keeps the T-100's
+ * lock-and-cancel coding on 98 tracks — which is what separates it from the
+ * green, the coding rule rather than the track count (Phillips, Table 4.3) —
+ * so it reads the same commands and is played by the same mechanism.
+ *
+ * What it does not have is an instrument of its own. The constants are the
+ * T-100's, the spool is the T-100's, and neither has ever been checked against
+ * a Licensee. `instruments` therefore offers a single `unfitted` arm, and every
+ * curve produced here names itself as such.
+ */
+export const welteLicenseeSystem = {
+    name: 'Welte-Mignon (Licensee)',
+    trackerBar: welteLicensee,
+    defaultOptions: defaultWelteLicenseeOptions,
+    perform: performAs(licenseeInstrument)
+};

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

@@ -1,19 +1,10 @@
-import { Half, Instrument, Parameters, PedalMode, RollNumber, Spool } from "welte-t100-emulator";
-import { ReproducingSystem } from "../../ReproducingSystem";
+import { Half, Parameters, PedalMode, Spool } from "welte-mignon-emulator";
+import { Instrument, RollNumber } from "welte-mignon-emulator/t100";
+import { NegotiatedEvent, Performance, ReproducingSystem, RollProperties } from "../../ReproducingSystem";
 import { Millimeters, Seconds, Track } from "../../Quantity";
-/**
- * MIDI velocity at the open rail of the Nuancierbalg, at the Mezzoforte pin,
- * and at the closed rail, joined linearly in between. Nothing in the
- * mechanism determines how bellows travel maps onto hammer velocity, so
- * these are anchors rather than measurements; the three values are the
- * ones midi2exp publishes.
- */
-export type VelocityMap = {
-    piano: number;
-    mezzoforte: number;
-    forte: number;
-};
-export type { Instrument } from "welte-t100-emulator";
+import { type VelocityMap } from "../velocity";
+export type { VelocityMap } from "../velocity";
+export type { Instrument } from "welte-mignon-emulator/t100";
 export type InstrumentName = 'consensus' | RollNumber;
 /**
  * The instruments the emulator was fitted as: the consensus over the six
@@ -76,7 +67,19 @@ export declare const defaultWelteT100Options: WelteT100Options;
 /** When the spool brings a place on the roll to the tracker bar. */
 export declare const secondsAt: (spool: Spool, place: Millimeters) => Seconds;
 /**
- * The red Welte, as welte-t100-emulator models it: the take-up spool sets
+ * The mechanism, given a way of naming the instrument on the curves it
+ * produces. The Licensee reads the same commands and is played by the same
+ * valves, so it shares this; what it may not share is the name, since a
+ * Licensee playback runs on constants fitted to Freiburg instruments and the
+ * curve has to say so.
+ *
+ * The edition's tempo adjustment is left aside: it is stated as a paper
+ * speed, and what the spool holds constant is its rate of revolution, so
+ * the two are not the same quantity. The spool in the options sets the speed.
+ */
+export declare const performAs: (instrumentOf: (nuance: Record<Half, Parameters>) => string) => (events: readonly NegotiatedEvent[], options: WelteT100Options, roll: RollProperties) => Performance;
+/**
+ * The red Welte, as welte-mignon-emulator models it: 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 constants are the consensus fitted across the hand-drawn

package/lib/systems/welteT100/system.js

@@ -1,7 +1,9 @@
-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 { DEFAULT_PUNCH_MM, geometryInMm, Grid, levelChanges, paperSeconds, pedalBrushing, pedalDefaults, ROWS_PER_MM, TRACKER_BORE_MM, WELTE_SPOOL, } from "welte-mignon-emulator";
+import { aperturePorts, CONSENSUS, mezzoforteTravel, pneumaticModel, PRESETS, runPedals, travelBetweenRails, } from "welte-mignon-emulator/t100";
 import { welteT100 } from "./bar";
-import { add, inCentimeters, mm, seconds, track } from "../../Quantity";
+import { inCentimeters, mm, seconds, track } from "../../Quantity";
 import { partitionPoint } from "../../sorted";
+import { defaultVelocityMap, velocityOf } from "../velocity";
 /**
  * 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,
@@ -35,7 +37,7 @@ export const defaultWelteT100Options = {
     spool: WELTE_SPOOL,
     nuance: nuanceOf(instruments.consensus),
     pedals: pedalPresets.damping,
-    velocity: { piano: 35, mezzoforte: 60, forte: 90 },
+    velocity: defaultVelocityMap,
     pedalMode: 'continuous',
     trackerBore: mm(TRACKER_BORE_MM),
     punchDiameter: mm(DEFAULT_PUNCH_MM),
@@ -62,62 +64,47 @@ const isWelteT100ExpressionType = (type) => Object.hasOwn(CODES, type);
 const codeOf = (expressionType) => isWelteT100ExpressionType(expressionType) ? CODES[expressionType] : undefined;
 /** Paper the grid runs on past the last hole, so that a final pedal release completes. */
 const RUN_OUT = mm(100);
-/**
- * Which stack of valves an expression perforation belongs to. The symbol
- * usually says so, having been read off the tracker bar already; where it
- * does not, the bar is asked again, since sending a perforation to neither
- * side would quietly flatten the dynamics.
- */
-const scopeOf = (event) => {
-    if (event.scope)
-        return event.scope;
-    const meaning = welteT100.meaningOf(event.vertical.from);
-    return meaning?.type === 'expression' ? meaning.scope : undefined;
-};
 const isNote = (event) => event.type === 'note';
 const isExpression = (event) => event.type === 'expression';
-/** The row of the scan the constants were fitted on that a place on the roll falls in. */
-const rowOf = (place) => place * ROWS_PER_MM;
-const placeOfRow = (row) => mm(row / ROWS_PER_MM);
+const paperOf = (toOwnPaper) => ({
+    rowOf: place => place * toOwnPaper * ROWS_PER_MM,
+    placeOfRow: row => mm(row / (toOwnPaper * ROWS_PER_MM)),
+    paperOfRow: row => mm(row / ROWS_PER_MM)
+});
 /** When the spool brings a place on the roll to the tracker bar. */
 export const secondsAt = (spool, place) => seconds(paperSeconds(spool, inCentimeters(place)));
 const halfOf = (note, division) => note.vertical.from >= division ? 'treble' : 'bass';
-const readingOf = (event) => {
+const readingOf = (paper) => (event) => {
     const code = codeOf(event.expressionType);
-    const half = scopeOf(event);
-    if (!code || !half)
+    if (!code)
         return undefined;
+    const half = event.scope;
     const [control, action] = code;
     return {
         event,
-        punch: { half, control, action, rowOn: rowOf(event.horizontal.from), rowOff: rowOf(event.horizontal.to) }
+        punch: {
+            half,
+            control,
+            action,
+            rowOn: paper.rowOf(event.horizontal.from),
+            rowOff: paper.rowOf(event.horizontal.to)
+        }
     };
 };
 const clamp = (value, low, high) => Math.min(Math.max(value, low), high);
-/**
- * The velocity map joined linearly through its three anchors, with the
- * middle one at the Mezzoforte pin of the half in question.
- */
-const velocityOf = (travel, hook, map) => {
-    const position = clamp(travel, 0, 1);
-    if (position <= hook) {
-        return map.piano + (position / hook) * (map.mezzoforte - map.piano);
-    }
-    return map.mezzoforte + ((position - hook) / (1 - hook)) * (map.forte - map.mezzoforte);
-};
 /**
  * One sample per row of the scan the constants were fitted on, from the
  * beginning of the roll to a little past the last hole. The rows are
  * equally spaced on the paper and not in time, which is what the
  * emulator expects.
  */
-const gridOver = (events, spool) => {
+const gridOver = (events, spool, paper) => {
     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 = new Float64Array(length).map((_, row) => secondsAt(spool, placeOfRow(row)));
+    const length = Math.ceil(paper.rowOf(last) + RUN_OUT * ROWS_PER_MM) + 1;
+    const times = new Float64Array(length).map((_, row) => secondsAt(spool, paper.paperOfRow(row)));
     return new Grid(0, times);
 };
-const nuanceCurves = (grid, ports, samples, options) => {
+const nuanceCurves = (grid, ports, samples, options, instrument) => {
     const curveOf = (half) => {
         const params = options.nuance[half];
         const output = pneumaticModel.run({ grid, half, ports }, params);
@@ -127,6 +114,7 @@ const nuanceCurves = (grid, ports, samples, options) => {
             ...samples,
             name: half,
             kind: 'dynamics',
+            instrument,
             travel,
             velocity: travel.map(value => velocityOf(value, hook, options.velocity))
         };
@@ -140,11 +128,11 @@ const pedalCurves = (grid, ports, samples, options) => {
         hammerRail: { ...samples, name: 'hammerRail', kind: 'pedal', travel: travel.hammerRail }
     };
 };
-const performNotes = (events, grid, nuance, options) => events
+const performNotes = (events, grid, nuance, options, paper) => events
     .filter(isNote)
     .flatMap((note) => {
     const curve = nuance[halfOf(note, options.division)];
-    const velocity = curve.velocity[grid.indexOfRow(rowOf(note.horizontal.from))];
+    const velocity = curve.velocity[grid.indexOfRow(paper.rowOf(note.horizontal.from))];
     return [
         { type: 'noteOn', performs: note, pitch: note.pitch, velocity, at: secondsAt(options.spool, note.horizontal.from) },
         { type: 'noteOff', performs: note, pitch: note.pitch, velocity: 127, at: secondsAt(options.spool, note.horizontal.to) }
@@ -170,28 +158,35 @@ const performPedal = (type, curve, grid, readings, mode) => {
     }));
 };
 /**
+ * The mechanism, given a way of naming the instrument on the curves it
+ * produces. The Licensee reads the same commands and is played by the same
+ * valves, so it shares this; what it may not share is the name, since a
+ * Licensee playback runs on constants fitted to Freiburg instruments and the
+ * curve has to say so.
+ *
  * The edition's tempo adjustment is left aside: it is stated as a paper
  * speed, and what the spool holds constant is its rate of revolution, so
  * the two are not the same quantity. The spool in the options sets the speed.
  */
-const perform = (events, options, roll) => {
+export const performAs = (instrumentOf) => (events, options, roll) => {
+    const paper = paperOf(roll.toOwnPaper ?? 1);
     const readings = events
         .filter(isExpression)
-        .map(readingOf)
+        .map(readingOf(paper))
         .filter((reading) => reading !== undefined);
-    const grid = gridOver(events, options.spool);
+    const grid = gridOver(events, options.spool, paper);
     const geometry = geometryInMm(roll.punchDiameter ?? options.punchDiameter, options.trackerBore);
     const ports = aperturePorts(grid, readings.map(reading => reading.punch), geometry);
     const samples = {
-        place: grid.seconds.map((_, row) => placeOfRow(row)),
+        place: grid.seconds.map((_, row) => paper.placeOfRow(row)),
         seconds: grid.seconds
     };
-    const nuance = nuanceCurves(grid, ports, samples, options);
+    const nuance = nuanceCurves(grid, ports, samples, options, instrumentOf(options.nuance));
     const pedals = pedalCurves(grid, ports, samples, options);
     const readingsOf = (control) => readings.filter(reading => reading.punch.control === control);
     return {
         events: [
-            ...performNotes(events, grid, nuance, options),
+            ...performNotes(events, grid, nuance, options, paper),
             ...performPedal('damper', pedals.damper, grid, readingsOf('sustainPedal'), options.pedalMode),
             ...performPedal('hammerRail', pedals.hammerRail, grid, readingsOf('hammerRail'), options.pedalMode)
         ],
@@ -199,7 +194,7 @@ const perform = (events, options, roll) => {
     };
 };
 /**
- * The red Welte, as welte-t100-emulator models it: the take-up spool sets
+ * The red Welte, as welte-mignon-emulator models it: 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 constants are the consensus fitted across the hand-drawn
@@ -210,5 +205,5 @@ export const welteT100System = {
     name: 'Welte-Mignon T100',
     trackerBar: welteT100,
     defaultOptions: defaultWelteT100Options,
-    perform
+    perform: performAs(nuance => `Welte-Mignon T-100, ${instrumentNameOf(nuance) ?? 'custom'}`)
 };

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

@@ -25,7 +25,20 @@ export type WelteT98ExpressionType = typeof welteT98ExpressionTypes[number];
  *
  * Measured against Julian Dyer's scan of the T-98 copy of roll 225
  * (Grünfeld, Träumerei): 98 columns 2.818 mm apart on paper 285.6 mm
- * wide, notes on the middle 80 columns, the sustain valve punched 53
- * times where the T-100 copy latches its sustain on 53 times.
+ * wide, notes on the middle 80 columns, the sustain valve punched 52
+ * times in the music where the T-100 copy latches its sustain on 52
+ * times. A 53rd perforation on that track belongs to the test pattern
+ * after the rewind.
+ *
+ * The paper speed is the Deutsches Museum's figure for its Welte grün /
+ * T 98 rolls, 220 cm/min. Phillips gives 7 ft/min = 2.134 m/min (p. 121);
+ * midi2exp's and PlaySK's green defaults of 72.2 and 72.27, read as the
+ * Stanford convention of feet per minute times ten, are 2.201 m/min, which
+ * is the museum's figure; and the two copies of roll 225 last the same
+ * time if the green starts at about 7.30 ft/min. Welte's own booklets give
+ * no speed, only that the roll must run from the first "A" of the chromatic
+ * scale to the cross-line bearing the dial number in half a minute
+ * (Skala-Rolle 98 §1b). This is documentation; what sets the emulator's
+ * time axis is the spool.
  */
 export declare const welteT98: TrackerBar;