linked-rolls 0.20.0 → 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/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) => {
@@ -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

@@ -320,6 +320,14 @@ export declare const barOf: (copy: Pick<RollCopy, 'production'>) => TrackerBar;
  *
  * 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[];
 /**

package/lib/RollCopy.js

@@ -26,10 +26,20 @@ export const barOf = (copy) => trackerBarOf(copy.production?.system) ?? welteT10
  *
  * 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) {
-    return features
-        .filter(feature => feature.type === 'Hole')
+    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)

package/lib/TrackerBar.d.ts

@@ -56,6 +56,17 @@ 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;
     /**
@@ -85,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;
@@ -107,6 +140,13 @@ 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;
 /**

package/lib/TrackerBar.js

@@ -1,4 +1,4 @@
-import { track } from "./Quantity";
+import { mm, track } from "./Quantity";
 /**
  * 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
@@ -48,11 +48,23 @@ export const describeTrackerBar = (spec) => {
     if (rewind === undefined) {
         throw new Error(`${spec.name} declares no rewind track`);
     }
+    // A rewind on a line of its own is unambiguous; one sharing a line is only
+    // the rewind when it is far longer than that line's usual command.
+    const shared = spec.rewindTrack !== undefined;
+    const endsAt = (features) => {
+        const hold = spec.rewindHold ?? mm(0);
+        const candidates = features
+            .filter(feature => feature.vertical.from === rewind)
+            .filter(feature => !shared || feature.horizontal.to - feature.horizontal.from >= hold)
+            .map(feature => feature.horizontal.from);
+        return candidates.length ? { at: mm(Math.min(...candidates)), because: 'rewind' } : undefined;
+    };
     return {
         id: spec.id,
         name: spec.name,
         width: spec.width,
         trackCount: spec.trackCount,
+        endsAt,
         areas,
         expressionTypes: [...new Set(spec.expressions.values())],
         rewindTrack: track(rewind),

package/lib/context.d.ts

@@ -8,3 +8,5 @@ export { default as welteT100JsonLdContext } from './spec/welte-t100.context.jso
  * rather than minting a second set of IRIs for the same commands.
  */
 export { default as welteLicenseeJsonLdContext } from './spec/welte-licensee.context.json';
+/** The context of the Welte-Mignon T-98, added to an edition of a green roll. */
+export { default as welteT98JsonLdContext } from './spec/welte-t98.context.json';

package/lib/context.js

@@ -8,3 +8,5 @@ export { default as welteT100JsonLdContext } from './spec/welte-t100.context.jso
  * rather than minting a second set of IRIs for the same commands.
  */
 export { default as welteLicenseeJsonLdContext } from './spec/welte-licensee.context.json';
+/** The context of the Welte-Mignon T-98, added to an edition of a green roll. */
+export { default as welteT98JsonLdContext } from './spec/welte-t98.context.json';

package/lib/readers/phillipsEroll.d.ts

@@ -45,7 +45,7 @@ export interface PhillipsErollOptions {
     /**
      * Where on the paper the roll had run after so many seconds. The
      * default is the constant speed the system states, which ignores
-     * the take-up spool; pass `paperAt` of welte-t100-emulator to
+     * the take-up spool; pass `paperAt` of welte-mignon-emulator to
      * account for it.
      */
     placeAt?: (elapsed: Seconds) => Millimeters;

package/lib/spec/welte-t98.context.json

@@ -0,0 +1,10 @@
+{
+    "@context": {
+        "@version": 1.1,
+        "expressionType": {
+            "@id": "http://www.cidoc-crm.org/cidoc-crm/P2_has_type",
+            "@type": "@vocab",
+            "@context": { "@vocab": "https://w3id.org/reo/type/welte-green/" }
+        }
+    }
+}

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;

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

package/lib/systems/welteT98/system.js

@@ -0,0 +1,245 @@
+import { geometryInMm, Grid, levelChanges, mezzoforteTravel, paperSeconds, pedalBrushing, pedalDefaults, ROWS_PER_MM, travelBetweenRails, WELTE_T98_SPOOL, } from "welte-mignon-emulator";
+import { aperturePorts, CHAIN_GAP_MM, DERIVED, GENUINE, instrumentT98Of, labelOf, nuanceOf, PUNCH_T98_MM, pneumaticT98Model, rewindAt, runPedals, sforzandoPianoLift, STARTING_VALUES, TRACKER_BORE_T98_MM, } from "welte-mignon-emulator/t98";
+import { welteT98 } from "./bar";
+import { inCentimeters, mm, seconds, track } from "../../Quantity";
+import { partitionPoint } from "../../sorted";
+import { defaultVelocityMap, velocityOf } from "../velocity";
+/**
+ * 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 const instruments = { genuine: GENUINE, derived: DERIVED, unfitted: { 'starting-values': STARTING_VALUES } };
+export const instrumentNames = [
+    ...Object.keys(GENUINE).map(genuine => ({ genuine })),
+    ...Object.keys(DERIVED).map(derived => ({ derived })),
+    { unfitted: 'starting-values' }
+];
+const sameParameters = (a, b) => Object.keys(a).length === Object.keys(b).length
+    && Object.entries(a).every(([name, value]) => b[name] === value);
+/** The instrument a pair of nuancing constants belongs to, if it is one. */
+export const instrumentNameOf = (nuance) => instrumentNames.find(name => {
+    const instrument = instrumentT98Of(name);
+    return instrument !== undefined
+        && sameParameters(instrument.bass, nuance.bass)
+        && sameParameters(instrument.treble, nuance.treble);
+});
+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 const pedalPresets = {
+    damping: pedalDefaults,
+    brushing: pedalBrushing
+};
+export const pedalPresetOf = (pedals) => Object.keys(pedalPresets).find(name => sameParameters(pedalPresets[name], pedals));
+export const defaultWelteT98Options = {
+    spool: WELTE_T98_SPOOL,
+    nuance: nuanceOf(STARTING_VALUES),
+    instrument: { unfitted: 'starting-values' },
+    pedals: pedalPresets.damping,
+    velocity: defaultVelocityMap,
+    pedalMode: 'continuous',
+    trackerBore: mm(TRACKER_BORE_T98_MM),
+    punchDiameter: mm(PUNCH_T98_MM),
+    chainGap: mm(CHAIN_GAP_MM),
+    division: track(52),
+    rewind: 'stop'
+};
+/**
+ * What each expression code operates, in the emulator's terms. There is no
+ * action: a T-98 function lasts exactly as long as its perforation, so a symbol
+ * carries its own extent and nothing cancels it. `SoftPedal` maps to the
+ * emulator's `hammerRail`, which keeps Hagmann's part name rather than the
+ * roll's function name.
+ */
+const CODES = {
+    SforzandoPiano: 'sforzandoPiano',
+    SforzandoForte: 'sforzandoForte',
+    Mezzoforte: 'mezzoforte',
+    Crescendo: 'crescendo',
+    SustainPedal: 'sustainPedal',
+    SoftPedal: 'hammerRail'
+};
+const isWelteT98ExpressionType = (type) => Object.hasOwn(CODES, type);
+const codeOf = (expressionType) => isWelteT98ExpressionType(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 control = codeOf(event.expressionType);
+    if (!control)
+        return undefined;
+    const half = event.scope;
+    return {
+        event,
+        punch: {
+            half,
+            control,
+            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.
+ */
+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) => {
+    const instrument = `Welte-Mignon T-98, ${labelOf(options.instrument)}`;
+    const curveOf = (half) => {
+        const params = options.nuance[half];
+        const output = pneumaticT98Model.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 attributed to the last
+ * perforation of that pedal the tracker bar has reached.
+ */
+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])
+    }));
+};
+/**
+ * The row at which the Abstellbalg trips and the roll goes back, or the end of
+ * the grid where it never does. The shut-off hangs on the bass sforzando-piano
+ * valve and reads the same perforations the dynamic does, so this asks the
+ * emulator for that valve's lift and integrates it.
+ */
+const rewindRow = (grid, ports, options) => {
+    if (options.rewind === 'ignore')
+        return grid.length;
+    const lift = sforzandoPianoLift({ grid, half: 'bass', ports }, options.nuance.bass);
+    return rewindAt(lift, grid.dt) ?? grid.length;
+};
+const truncated = (events, until) => events.filter(event => event.at <= until);
+const cutCurve = (curve, rows) => ({
+    ...curve,
+    place: curve.place.slice(0, rows),
+    seconds: curve.seconds.slice(0, rows),
+    travel: curve.travel.slice(0, rows),
+    ...(curve.kind === 'dynamics' ? { velocity: curve.velocity.slice(0, rows) } : {})
+});
+/**
+ * The edition's tempo adjustment is left aside, as on the T-100: it is stated as
+ * a paper speed, and what the spool holds constant is its rate of revolution.
+ */
+const perform = (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 gap = options.chainGap * ROWS_PER_MM;
+    const ports = aperturePorts(grid, readings.map(reading => reading.punch), geometry, gap);
+    const samples = {
+        place: grid.seconds.map((_, row) => paper.placeOfRow(row)),
+        seconds: grid.seconds
+    };
+    const nuance = nuanceCurves(grid, ports, samples, options);
+    const pedals = pedalCurves(grid, ports, samples, options);
+    const readingsOf = (control) => readings.filter(reading => reading.punch.control === control);
+    const stops = rewindRow(grid, ports, options);
+    const until = seconds(grid.seconds[Math.min(stops, grid.length - 1)]);
+    const rows = Math.min(stops + 1, grid.length);
+    return {
+        events: truncated([
+            ...performNotes(events, grid, nuance, options, paper),
+            ...performPedal('damper', pedals.damper, grid, readingsOf('sustainPedal'), options.pedalMode),
+            ...performPedal('hammerRail', pedals.hammerRail, grid, readingsOf('hammerRail'), options.pedalMode)
+        ], until),
+        curves: [nuance.bass, nuance.treble, pedals.damper, pedals.hammerRail].map(curve => cutCurve(curve, rows))
+    };
+};
+/**
+ * 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 const welteT98System = {
+    name: 'Welte-Mignon T98',
+    trackerBar: welteT98,
+    defaultOptions: defaultWelteT98Options,
+    perform
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linked-rolls",
-  "version": "0.20.0",
+  "version": "0.21.0",
   "description": "Digital editions of piano rolls: import, collation, editorial assumptions, JSON-LD export, and emulation through a reproducing system",
   "license": "MIT",
   "repository": {
@@ -20,6 +20,14 @@
       "types": "./lib/systems/welteT100/system.d.ts",
       "default": "./lib/systems/welteT100/system.js"
     },
+    "./welte-t98": {
+      "types": "./lib/systems/welteT98/system.d.ts",
+      "default": "./lib/systems/welteT98/system.js"
+    },
+    "./welte-licensee": {
+      "types": "./lib/systems/welteLicensee/system.d.ts",
+      "default": "./lib/systems/welteLicensee/system.js"
+    },
     "./lib/*": "./lib/*",
     "./package.json": "./package.json"
   },
@@ -40,13 +48,13 @@
     "typescript": "^7.0.2",
     "vite": "^8.2.2",
     "vitest": "^5.0.0",
-    "welte-t100-emulator": "^0.4.0"
+    "welte-mignon-emulator": "^1.0.0"
   },
   "peerDependencies": {
-    "welte-t100-emulator": "^0.4.0"
+    "welte-mignon-emulator": "^1.0.0"
   },
   "peerDependenciesMeta": {
-    "welte-t100-emulator": {
+    "welte-mignon-emulator": {
       "optional": true
     }
   },