linked-rolls 0.20.0 → 0.22.0

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;

package/lib/systems/welteT98/bar.js

@@ -1,5 +1,5 @@
 import { describeTrackerBar } from "../../TrackerBar";
-import { mm } from "../../Quantity";
+import { metersPerMinute, mm } from "../../Quantity";
 /**
  * The commands of the Welte-Mignon T-98, as its tracker bar reads them.
  *
@@ -32,8 +32,21 @@ export const welteT98ExpressionTypes = [
  *
  * 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 const welteT98 = describeTrackerBar({
     id: 'welte-green',
@@ -41,7 +54,22 @@ export const welteT98 = describeTrackerBar({
     width: mm(286),
     trackCount: 98,
     notes: { from: 6, to: 93, lowestPitch: 21 },
+    paperSpeed: { value: metersPerMinute(2.2), unit: 'm/min' },
     rewindTrack: 1,
+    /**
+     * 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
+     * longer than the command that line usually carries. On the Monteurscala
+     * the rewind is a single continuous 103.8 mm perforation (Kontrolle 10, 40
+     * punches with gaps of 0.51–0.93 mm), where a commanded sforzando-piano
+     * runs a couple of millimetres — a median of 0.06 s against the rewind's
+     * 10.2 s on WM 184. Dyer's scan of the green 225 says the same a third time:
+     * of the 30 perforations its track 1 carries, exactly one reaches 40 mm and
+     * it is 386 mm long. So the threshold is not a fitted number and does not
+     * need to be — every measurement of it so far leaves an order of magnitude
+     * either side.
+     */
+    rewindHold: mm(40),
     expressions: new Map([
         [1, 'SforzandoPiano'],
         [2, 'Mezzoforte'],

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

@@ -0,0 +1,119 @@
+import { Half, Parameters, PedalMode, Spool } from "welte-mignon-emulator";
+import { instrumentT98Of, labelOf, nuanceOf, WelteT98InstrumentName } from "welte-mignon-emulator/t98";
+import { ReproducingSystem } from "../../ReproducingSystem";
+import { Millimeters, Seconds, Track } from "../../Quantity";
+import { type VelocityMap } from "../velocity";
+export type { VelocityMap } from "../velocity";
+export type { WelteT98Instrument, WelteT98InstrumentName } from "welte-mignon-emulator/t98";
+/**
+ * The instruments the emulator offers for the green Welte, in three groups that
+ * answer three different questions and must not be listed as one.
+ *
+ * A **genuine** instrument is fitted to the drawn nuance line of a green roll
+ * and says what a green Welte did. A **derived** instrument is fitted so that
+ * the green code of a recording reproduces what the fitted T-100 emulator makes
+ * of the *red* copy of the same recording, and says what Welte's editor meant
+ * the green roll to sound like; its provenance names the T-100 instrument it
+ * inherits, since it is only as good as the red reading behind it. The
+ * difference between the two, in the printed ordinate both scales share, is how
+ * far the transfer of a red reading onto the green mechanism succeeded.
+ *
+ * Neither has been fitted yet, so both groups are empty and what a playback runs
+ * on until then is the third group: the **unfitted** starting values, arithmetic
+ * from Welte's regulation controls and the T-100 consensus with no green roll
+ * behind any of it. A curve produced with them says so in its own `instrument`
+ * field, and nothing should be published from them.
+ */
+export declare const instruments: {
+    genuine: Readonly<Partial<Record<"consensus" | import("welte-mignon-emulator/t98").GenuineRoll, import("welte-mignon-emulator/t98").WelteT98Instrument>>>;
+    derived: Readonly<Partial<Record<"225", import("welte-mignon-emulator/t98").WelteT98Instrument>>>;
+    unfitted: {
+        'starting-values': import("welte-mignon-emulator/t98").WelteT98Instrument;
+    };
+};
+export declare const instrumentNames: readonly WelteT98InstrumentName[];
+/** The instrument a pair of nuancing constants belongs to, if it is one. */
+export declare const instrumentNameOf: (nuance: Record<Half, Parameters>) => WelteT98InstrumentName | undefined;
+export { instrumentT98Of, labelOf, nuanceOf };
+/**
+ * The two readings of the pedal mechanism, which is the T-100's below the
+ * command: Hagmann has the valves and bellows that carry out the movements "in
+ * beiden Systemen dieselbe" (p. 106), and only the Vorpneumatik differs.
+ */
+export declare const pedalPresets: {
+    damping: Readonly<Record<string, number>>;
+    brushing: Readonly<Record<string, number>>;
+};
+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. */
+    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
+     * paper bridges of about a millimetre, not as one slot, so a raw scan and an
+     * edition whose collation has already made one symbol of the chain see the
+     * 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
+     * always acts as a sforzando-piano; `stop` additionally ends the performance
+     * there, which is what the instrument does — during rewind the suction to
+     * the primary pneumatics is cut and the Hauptventil closes, so no note
+     * sounds and the expression apparatus is out of action (Betriebsanleitung
+     * p. 17). `ignore` is for an edition that is a fragment, or that carries a
+     * rewind in the middle for some reason of its own.
+     */
+    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
+ * built the same for both tracker scales (p. 96); what differs is in front of
+ * it. Each function is held for exactly as long as its own perforation runs
+ * over the glide block, four conduits stand on one bellows and their drives add
+ * as flows, the crescendo's ceiling is the balance of throttle 98 against the
+ * permanently open bore 100, 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 run, and what a playback runs
+ * on until then is the unfitted starting values, which every curve says.
+ */
+export declare const welteT98System: ReproducingSystem<WelteT98Options>;