linked-rolls 0.56.0 → 0.58.0

package/lib/systems/welte.js

@@ -0,0 +1,119 @@
+import { clamp, geometryInMm, Grid, levelChanges, mezzoforteTravel, paperSeconds, ROWS_PER_MM, travelBetweenRails, } from "welte-mignon-emulator";
+import { inCentimeters, mm, seconds } from "../model/Quantity.js";
+import { partitionPoint } from "../shared/sorted.js";
+import { velocityOf } from "./velocity.js";
+/** Whether two sets of constants are the same, value for value. */
+export const sameParameters = (a, b) => Object.keys(a).length === Object.keys(b).length
+    && Object.entries(a).every(([name, value]) => b[name] === value);
+/** Paper the grid runs on past the last hole, so that a final pedal release completes. */
+const RUN_OUT = mm(100);
+const isNote = (event) => event.type === 'note';
+const isExpression = (event) => event.type === 'expression';
+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';
+/**
+ * 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, paper) => {
+    const last = mm(events.reduce((furthest, event) => Math.max(furthest, event.horizontal.to), 0));
+    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, model, instrument) => {
+    const curveOf = (half) => {
+        const params = options.nuance[half];
+        const output = model.run({ grid, half, ports }, params);
+        const travel = travelBetweenRails(output, params);
+        const hook = clamp(mezzoforteTravel(params), 0.01, 0.99);
+        return {
+            ...samples,
+            name: half,
+            kind: 'dynamics',
+            instrument,
+            travel,
+            velocity: travel.map(value => velocityOf(value, hook, options.velocity))
+        };
+    };
+    return { bass: curveOf('bass'), treble: curveOf('treble') };
+};
+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(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) }
+    ];
+});
+/**
+ * The travel of one pedal as controller steps. Each step is attributed to
+ * the last perforation of that pedal the tracker bar has reached, which is
+ * the one whose reading it follows from.
+ */
+const performPedal = (type, curve, grid, readings, mode) => {
+    if (readings.length === 0)
+        return [];
+    const ordered = readings.toSorted((a, b) => a.punch.rowOn - b.punch.rowOn);
+    const causeOf = (row) => ordered[Math.max(partitionPoint(ordered, reading => reading.punch.rowOn <= row) - 1, 0)].event;
+    return levelChanges(curve.travel, { mode })
+        .filter(change => change.index > 0)
+        .map(change => ({
+        type,
+        performs: causeOf(grid.rowAt(change.index)),
+        value: change.value,
+        at: seconds(curve.seconds[change.index])
+    }));
+};
+/**
+ * Plays the events on a Welte mechanism: notes at the velocity of their half's
+ * bellows, and the two pedals as the travel of theirs.
+ *
+ * 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 const performWelte = (events, options, roll, mechanism) => {
+    const paper = paperOf(roll.toOwnPaper ?? 1);
+    const readings = events
+        .filter(isExpression)
+        .flatMap((event) => {
+        const punch = mechanism.punchOf(event, {
+            rowOn: paper.rowOf(event.horizontal.from),
+            rowOff: paper.rowOf(event.horizontal.to)
+        });
+        return punch ? [{ event, punch }] : [];
+    });
+    const grid = gridOver(events, options.spool, paper);
+    const geometry = geometryInMm(roll.punchDiameter ?? options.punchDiameter, options.trackerBore);
+    const ports = mechanism.portsOf(grid, readings.map(reading => reading.punch), geometry);
+    const samples = {
+        place: grid.seconds.map((_, row) => paper.placeOfRow(row)),
+        seconds: grid.seconds
+    };
+    const nuance = nuanceCurves(grid, ports, samples, options, mechanism.model, mechanism.instrument);
+    const travel = mechanism.runPedals({ grid, ports }, options.pedals);
+    const damper = { ...samples, name: 'damper', kind: 'pedal', travel: travel.damper };
+    const hammerRail = { ...samples, name: 'hammerRail', kind: 'pedal', travel: travel.hammerRail };
+    const readingsOf = (control) => readings.filter(reading => reading.punch.control === control);
+    return {
+        grid,
+        ports,
+        events: [
+            ...performNotes(events, grid, nuance, options, paper),
+            ...performPedal('damper', damper, grid, readingsOf('sustainPedal'), options.pedalMode),
+            ...performPedal('hammerRail', hammerRail, grid, readingsOf('hammerRail'), options.pedalMode)
+        ],
+        curves: [nuance.bass, nuance.treble, damper, hammerRail]
+    };
+};

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

@@ -1,4 +1,4 @@
-import { TrackerBar } from "../../TrackerBar.js";
+import { TrackerBar } from "../TrackerBar.js";
 /**
  * Welte-Mignon (Licensee), the American re-cut of the T-100 rolls on
  * a roll 11¼ inches wide with 98 positions at nine to the inch, cf.

package/lib/systems/welteLicensee/bar.js

@@ -1,5 +1,6 @@
-import { describeTrackerBar } from "../../TrackerBar.js";
-import { mm } from "../../Quantity.js";
+import { describeTrackerBar } from "../TrackerBar.js";
+import { mm } from "../../model/Quantity.js";
+import { welteT100Accents, welteT100Operations } from "../welteT100/bar.js";
 /**
  * Welte-Mignon (Licensee), the American re-cut of the T-100 rolls on
  * a roll 11¼ inches wide with 98 positions at nine to the inch, cf.
@@ -15,6 +16,8 @@ export const welteLicensee = describeTrackerBar({
     width: mm(285.75),
     trackCount: 98,
     notes: { from: 9, to: 88, lowestPitch: 24 },
+    operations: welteT100Operations,
+    accents: welteT100Accents,
     expressions: new Map([
         [1, 'MezzoforteOff'],
         [2, 'MezzoforteOn'],

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

@@ -1,4 +1,4 @@
-import { ReproducingSystem } from "../../ReproducingSystem.js";
+import { ReproducingSystem } from "../ReproducingSystem.js";
 import { type WelteT100Options } from "../welteT100/system.js";
 export type WelteLicenseeOptions = WelteT100Options;
 /**

package/lib/systems/welteLicensee/system.js

@@ -1,5 +1,5 @@
 import { CONSENSUS } from "welte-mignon-emulator/t100";
-import { track } from "../../Quantity.js";
+import { track } from "../../model/Quantity.js";
 import { welteLicensee } from "./bar.js";
 import { defaultWelteT100Options, instrumentNameOf, nuanceOf, performAs } from "../welteT100/system.js";
 /**

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

@@ -1,9 +1,35 @@
-import { TrackerBar } from "../../TrackerBar.js";
+import { Operation, TrackerBar } from "../TrackerBar.js";
 /**
  * The commands of the Welte-Mignon T-100, as its tracker bar reads them.
  */
 export declare const welteT100ExpressionTypes: readonly ['SustainPedalOn', 'SustainPedalOff', 'SoftPedalOn', 'SoftPedalOff', 'MezzoforteOff', 'MezzoforteOn', 'SlowCrescendoOn', 'SlowCrescendoOff', 'ForzandoOn', 'ForzandoOff', 'MotorOff', 'MotorOn', 'Rewind', 'ElectricCutOff'];
 export type WelteT100ExpressionType = typeof welteT100ExpressionTypes[number];
+/**
+ * What each T-100 command operates, so that it can be set against the
+ * T-98's words for the same function.
+ *
+ * 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 types that operate one function can
+ * stand for each other.
+ *
+ * `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.
+ */
+export declare const welteT100Operations: Readonly<Partial<Record<WelteT100ExpressionType, Operation>>>;
+/**
+ * A single added accent on the T-100: a valve latched on and off again
+ * straight away.
+ */
+export declare const welteT100Accents: readonly (readonly WelteT100ExpressionType[])[];
 /**
  * Welte-Mignon T-100 ("red Welte"), cf. Hagmann, pp. 75 and 178.
  *

package/lib/systems/welteT100/bar.js

@@ -1,5 +1,5 @@
-import { describeTrackerBar } from "../../TrackerBar.js";
-import { metersPerMinute, mm } from "../../Quantity.js";
+import { describeTrackerBar } from "../TrackerBar.js";
+import { metersPerMinute, mm } from "../../model/Quantity.js";
 /**
  * The commands of the Welte-Mignon T-100, as its tracker bar reads them.
  */
@@ -19,6 +19,46 @@ export const welteT100ExpressionTypes = [
     'Rewind',
     'ElectricCutOff'
 ];
+/**
+ * What each T-100 command operates, so that it can be set against the
+ * T-98's words for the same function.
+ *
+ * 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 types that operate one function can
+ * stand for each other.
+ *
+ * `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.
+ */
+export const welteT100Operations = {
+    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 }
+};
+/**
+ * A single added accent on the T-100: a valve latched on and off again
+ * straight away.
+ */
+export const welteT100Accents = [
+    ['SlowCrescendoOn', 'SlowCrescendoOff'],
+    ['ForzandoOn', 'ForzandoOff']
+];
 /**
  * Welte-Mignon T-100 ("red Welte"), cf. Hagmann, pp. 75 and 178.
  *
@@ -34,6 +74,8 @@ export const welteT100 = describeTrackerBar({
     trackCount: 100,
     notes: { from: 11, to: 90, lowestPitch: 24 },
     paperSpeed: { value: metersPerMinute(3), unit: 'm/min' },
+    operations: welteT100Operations,
+    accents: welteT100Accents,
     expressions: new Map([
         [1, 'MezzoforteOff'],
         [2, 'MezzoforteOn'],

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

@@ -1,9 +1,9 @@
-import { Half, Parameters, PedalMode, Spool } from "welte-mignon-emulator";
+import { Half, Parameters } from "welte-mignon-emulator";
 import { Instrument, RollNumber } from "welte-mignon-emulator/t100";
-import { NegotiatedEvent, Performance, ReproducingSystem, RollProperties } from "../../ReproducingSystem.js";
-import { Millimeters, Seconds, Track } from "../../Quantity.js";
-import { type VelocityMap } from "../velocity.js";
+import { NegotiatedEvent, Performance, ReproducingSystem, RollProperties } from "../ReproducingSystem.js";
+import { type WelteOptions } from "../welte.js";
 export type { VelocityMap } from "../velocity.js";
+export { secondsAt } from "../welte.js";
 export type { Instrument } from "welte-mignon-emulator/t100";
 export type InstrumentName = 'consensus' | RollNumber;
 /**
@@ -34,48 +34,15 @@ export declare const pedalPresets: {
 export type PedalPreset = keyof typeof pedalPresets;
 /** The preset a set of pedal constants is, if it is one. */
 export declare const pedalPresetOf: (pedals: Parameters) => PedalPreset | undefined;
-export type WelteT100Options = {
-    /**
-     * The take-up spool, which sets the time axis: it is held at a constant
-     * rate of revolution, so the paper runs faster as the spool fills.
-     */
-    spool: Spool;
-    /** Constants of the nuancing mechanism, one set for each half of the keyboard: `nuanceOf` an instrument, or a set of one's own. */
-    nuance: Record<Half, Parameters>;
-    /** Constants of the two pedal actions, one of `pedalPresets` or a set of one's own. */
-    pedals: Parameters;
-    velocity: VelocityMap;
-    /**
-     * How the pedals go out: as a continuous controller carrying the travel
-     * of the bellows, or thresholded to the two values a switching renderer
-     * understands.
-     */
-    pedalMode: PedalMode;
-    /** Diameter of the tracker-bar bore. */
-    trackerBore: Millimeters;
-    /** Punch diameter for an edition whose copies record none. */
-    punchDiameter: Millimeters;
-    /**
-     * The track at which the keyboard is divided, so that notes from
-     * here upwards follow the treble expression and the ones below it
-     * the bass. Which side an expression perforation itself belongs to
-     * is not decided here but read off the tracker bar.
-     */
-    division: Track;
-};
+/** The T-100 takes the options every Welte system does; see `WelteOptions`. */
+export type WelteT100Options = WelteOptions;
 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 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;
 /**

package/lib/systems/welteT100/system.js

@@ -1,9 +1,10 @@
-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 { DEFAULT_PUNCH_MM, pedalBrushing, pedalDefaults, TRACKER_BORE_MM, WELTE_SPOOL, } from "welte-mignon-emulator";
+import { aperturePorts, CONSENSUS, pneumaticModel, PRESETS, runPedals, } from "welte-mignon-emulator/t100";
 import { welteT100 } from "./bar.js";
-import { inCentimeters, mm, seconds, track } from "../../Quantity.js";
-import { partitionPoint } from "../../sorted.js";
-import { defaultVelocityMap, velocityOf } from "../velocity.js";
+import { mm, track } from "../../model/Quantity.js";
+import { defaultVelocityMap } from "../velocity.js";
+import { performWelte, sameParameters } from "../welte.js";
+export { secondsAt } from "../welte.js";
 /**
  * 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,
@@ -13,8 +14,6 @@ import { defaultVelocityMap, velocityOf } from "../velocity.js";
 export const instruments = { consensus: CONSENSUS, ...PRESETS };
 /** The instruments by name, the consensus first. */
 export const instrumentNames = ['consensus', ...Object.keys(PRESETS)];
-const sameParameters = (a, b) => Object.keys(a).length === Object.keys(b).length
-    && Object.entries(a).every(([name, value]) => b[name] === value);
 /** The nuancing constants of an instrument, one set for each half of the keyboard. */
 export const nuanceOf = (instrument) => ({ bass: instrument.bass, treble: instrument.treble });
 /** The instrument a pair of nuancing constants belongs to, if it is one. */
@@ -61,101 +60,12 @@ const CODES = {
     ElectricCutOff: ['electricCutoff', 'on']
 };
 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);
-const isNote = (event) => event.type === 'note';
-const isExpression = (event) => event.type === 'expression';
-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 = (paper) => (event) => {
-    const code = codeOf(event.expressionType);
-    if (!code)
+/** The punch a T-100 expression is read as: its control, latched on or off. */
+const punchOf = (event, rows) => {
+    if (!isWelteT100ExpressionType(event.expressionType))
         return undefined;
-    const half = event.scope;
-    const [control, action] = code;
-    return {
-        event,
-        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);
-/**
- * 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, paper) => {
-    const last = mm(events.reduce((furthest, event) => Math.max(furthest, event.horizontal.to), 0));
-    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, instrument) => {
-    const curveOf = (half) => {
-        const params = options.nuance[half];
-        const output = pneumaticModel.run({ grid, half, ports }, params);
-        const travel = travelBetweenRails(output, params);
-        const hook = clamp(mezzoforteTravel(params), 0.01, 0.99);
-        return {
-            ...samples,
-            name: half,
-            kind: 'dynamics',
-            instrument,
-            travel,
-            velocity: travel.map(value => velocityOf(value, hook, options.velocity))
-        };
-    };
-    return { bass: curveOf('bass'), treble: curveOf('treble') };
-};
-const pedalCurves = (grid, ports, samples, options) => {
-    const travel = runPedals({ grid, ports }, options.pedals);
-    return {
-        damper: { ...samples, name: 'damper', kind: 'pedal', travel: travel.damper },
-        hammerRail: { ...samples, name: 'hammerRail', kind: 'pedal', travel: travel.hammerRail }
-    };
-};
-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(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) }
-    ];
-});
-/**
- * The travel of one pedal as controller steps. Each step is attributed to
- * the last perforation of that pedal the tracker bar has reached, which is
- * the one whose reading it follows from.
- */
-const performPedal = (type, curve, grid, readings, mode) => {
-    if (readings.length === 0)
-        return [];
-    const ordered = readings.toSorted((a, b) => a.punch.rowOn - b.punch.rowOn);
-    const causeOf = (row) => ordered[Math.max(partitionPoint(ordered, reading => reading.punch.rowOn <= row) - 1, 0)].event;
-    return levelChanges(curve.travel, { mode })
-        .filter(change => change.index > 0)
-        .map(change => ({
-        type,
-        performs: causeOf(grid.rowAt(change.index)),
-        value: change.value,
-        at: seconds(curve.seconds[change.index])
-    }));
+    const [control, action] = CODES[event.expressionType];
+    return { half: event.scope, control, action, ...rows };
 };
 /**
  * The mechanism, given a way of naming the instrument on the curves it
@@ -163,35 +73,16 @@ const performPedal = (type, curve, grid, readings, mode) => {
  * 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 const performAs = (instrumentOf) => (events, options, roll) => {
-    const paper = paperOf(roll.toOwnPaper ?? 1);
-    const readings = events
-        .filter(isExpression)
-        .map(readingOf(paper))
-        .filter((reading) => reading !== undefined);
-    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) => paper.placeOfRow(row)),
-        seconds: grid.seconds
-    };
-    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, paper),
-            ...performPedal('damper', pedals.damper, grid, readingsOf('sustainPedal'), options.pedalMode),
-            ...performPedal('hammerRail', pedals.hammerRail, grid, readingsOf('hammerRail'), options.pedalMode)
-        ],
-        curves: [nuance.bass, nuance.treble, pedals.damper, pedals.hammerRail]
-    };
+    const { events: performed, curves } = performWelte(events, options, roll, {
+        punchOf,
+        portsOf: aperturePorts,
+        model: pneumaticModel,
+        runPedals,
+        instrument: instrumentOf(options.nuance)
+    });
+    return { events: performed, curves };
 };
 /**
  * The red Welte, as welte-mignon-emulator models it: the take-up spool sets

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

@@ -1,4 +1,4 @@
-import { TrackerBar } from "../../TrackerBar.js";
+import { TrackerBar } from "../TrackerBar.js";
 /**
  * The commands of the Welte-Mignon T-98, as its tracker bar reads them.
  *

package/lib/systems/welteT98/bar.js

@@ -1,5 +1,5 @@
-import { describeTrackerBar } from "../../TrackerBar.js";
-import { metersPerMinute, mm } from "../../Quantity.js";
+import { describeTrackerBar } from "../TrackerBar.js";
+import { metersPerMinute, mm } from "../../model/Quantity.js";
 /**
  * The commands of the Welte-Mignon T-98, as its tracker bar reads them.
  *
@@ -17,6 +17,19 @@ export const welteT98ExpressionTypes = [
     'SustainPedal',
     'SoftPedal'
 ];
+/**
+ * What each T-98 command operates. Every one of them holds its function
+ * for as long as its perforation lasts; see `welteT100Operations` for
+ * how the functions answer to the T-100's.
+ */
+const welteT98Operations = {
+    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 }
+};
 /**
  * Welte-Mignon T-98 ("green Welte"), cf. Hagmann, Anhang 11 (p. 179)
  * and Phillips, p. 121.
@@ -56,6 +69,9 @@ export const welteT98 = describeTrackerBar({
     notes: { from: 6, to: 93, lowestPitch: 21 },
     paperSpeed: { value: metersPerMinute(2.2), unit: 'm/min' },
     rewindTrack: 1,
+    operations: welteT98Operations,
+    /** A single added accent on the T-98 is one held perforation. */
+    accents: [['Crescendo'], ['SforzandoForte']],
     /**
      * The T-98 gives the rewind no line of its own — Welte's Forzando P line
      * doubles as it — so a perforation there is the rewind only when it is far

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

@@ -1,9 +1,10 @@
-import { Half, Parameters, PedalMode, Spool } from "welte-mignon-emulator";
+import { Half, Parameters } from "welte-mignon-emulator";
 import { instrumentT98Of, labelOf, nuanceOf, WelteT98InstrumentName } from "welte-mignon-emulator/t98";
-import { ReproducingSystem } from "../../ReproducingSystem.js";
-import { Millimeters, Seconds, Track } from "../../Quantity.js";
-import { type VelocityMap } from "../velocity.js";
+import { ReproducingSystem } from "../ReproducingSystem.js";
+import { Millimeters } from "../../model/Quantity.js";
+import { type WelteOptions } from "../welte.js";
 export type { VelocityMap } from "../velocity.js";
+export { secondsAt } from "../welte.js";
 export type { WelteT98Instrument, WelteT98InstrumentName } from "welte-mignon-emulator/t98";
 /**
  * The instruments the emulator offers for the green Welte, in three groups that
@@ -54,27 +55,22 @@ export declare const pedalPresets: {
 };
 export type PedalPreset = keyof typeof pedalPresets;
 export declare const pedalPresetOf: (pedals: Parameters) => PedalPreset | undefined;
-export type WelteT98Options = {
-    /**
-     * The take-up spool, which sets the time axis. No source states a T-98
-     * spool geometry, so the default keeps the red circumference and layer and
-     * sets the revolution to make the initial paper speed 220 cm/min. It is
-     * better varied than trusted: it scales every conductance by k and every
-     * time constant by 1/k, and touches nothing dimensionless.
-     */
-    spool: Spool;
-    /** Constants of the nuancing mechanism, one set for each half of the keyboard. */
-    nuance: Record<Half, Parameters>;
-    /** Which instrument those constants are, so that a curve can say so. */
+/**
+ * The options every Welte system takes (see `WelteOptions`), with what the
+ * T-98 adds. No source states a T-98 spool geometry, so the default keeps the
+ * red circumference and layer and sets the revolution to make the initial
+ * paper speed 220 cm/min; it is better varied than trusted, since it scales
+ * every conductance by k and every time constant by 1/k and touches nothing
+ * dimensionless. No source gives the T-98's tracker bore either, and the red
+ * figure is carried over. Welte puts the division between f♯ and g
+ * (Betriebsanleitung p. 7), which on this bar is track 52; PlaySK's green
+ * configuration independently gives the last bass note as MIDI 66. A green
+ * roll re-cut from a Mignon master uses only the middle 80 of the 88 note
+ * positions, so the division falls inside the used compass either way.
+ */
+export type WelteT98Options = WelteOptions & {
+    /** Which instrument the nuancing constants are, so that a curve can say so. */
     instrument: WelteT98InstrumentName;
-    /** Constants of the two pedal actions, one of `pedalPresets` or a set of one's own. */
-    pedals: Parameters;
-    velocity: VelocityMap;
-    pedalMode: PedalMode;
-    /** Diameter of the tracker-bar bore. No source gives the T-98's; the red figure is carried over. */
-    trackerBore: Millimeters;
-    /** Punch diameter for an edition whose copies record none. */
-    punchDiameter: Millimeters;
     /**
      * Chained punches whose gap is shorter than this are one perforation. A held
      * T-98 command is punched as a chain of round holes on a 2.66 mm grid with
@@ -83,18 +79,6 @@ export type WelteT98Options = {
      * same port only if the chain is merged.
      */
     chainGap: Millimeters;
-    /**
-     * The track at which the keyboard is divided, so that notes from here
-     * upwards follow the treble expression and the ones below it the bass.
-     * Welte puts the division between f♯ and g (Betriebsanleitung p. 7), which
-     * on this bar is track 52; PlaySK's green configuration independently gives
-     * the last bass note as MIDI 66. Which side an expression perforation
-     * belongs to is not decided here but read off the tracker bar.
-     *
-     * A green roll re-cut from a Mignon master uses only the middle 80 of the 88
-     * note positions, so the division falls inside the used compass either way.
-     */
-    division: Track;
     /**
      * What a long perforation on the bass sforzando-piano line does. It is the
      * same valve and the same hole as the dynamic (Skala-Rolle §10), so it
@@ -108,8 +92,6 @@ export type WelteT98Options = {
     rewind: 'stop' | 'ignore';
 };
 export declare const defaultWelteT98Options: WelteT98Options;
-/** When the spool brings a place on the roll to the tracker bar. */
-export declare const secondsAt: (spool: Spool, place: Millimeters) => Seconds;
 /**
  * The green Welte, as welte-mignon-emulator models it. Everything downstream of
  * the relay is the T-100's, on Hagmann's authority that the nuancing unit is