linked-rolls 0.57.0 → 0.59.0

package/lib/readers/AtonParser.js

@@ -70,13 +70,13 @@ export class AtonParser {
             // Ignore unassociated text.
             return;
         }
-        else if (matches = line.match(/^@@[^@ ]/)) {
+        else if ((matches = line.match(/^@@[^@ ]/))) {
             // Control message.
             // End current property.
             this.cleanParameter(state);
             state.curkey = undefined;
             state.ocurkey = undefined;
-            if (matches = line.match(/^@@(BEGIN|START)\s*:\s*(.*)\s*$/i)) {
+            if ((matches = line.match(/^@@(BEGIN|START)\s*:\s*(.*)\s*$/i))) {
                 state.label = matches[2];
                 //console.log(state.label)
                 if (typeof state.curobj[state.label] === 'undefined') {
@@ -107,7 +107,7 @@ export class AtonParser {
                     state.curobj = state.curobj[state.label][state.curobj[state.label].length - 1];
                 }
             }
-            else if (matches = line.match(/^@@(END|STOP)\s*:?\s*(.*)\s*$/i)) {
+            else if ((matches = line.match(/^@@(END|STOP)\s*:?\s*(.*)\s*$/i))) {
                 // End an object, so go back to the parent.
                 if (typeof state.curkey !== 'undefined') {
                     // clean whitespace of last read property:
@@ -121,8 +121,6 @@ export class AtonParser {
                 if (typeof state.node[state.node.length - 1].startline === 'undefined') {
                     throw new Error('No start for ' + state.action + ' tag on line '
                         + state.node[state.node.length - 1].startline + ': ' + line);
-                    state.output = {};
-                    // return v.output;
                 }
                 if (typeof state.labelend !== 'undefined') {
                     // ensure that the v.label begin/end tags match
@@ -144,12 +142,12 @@ export class AtonParser {
                         obj[x.label][x.index] : obj[x.label];
                 }, state.output);
             }
-            else if (matches = line.match(/^@@TYPE\s*:\s*([^:]+)\s*:\s*(.*)\s*$/i)) {
+            else if ((matches = line.match(/^@@TYPE\s*:\s*([^:]+)\s*:\s*(.*)\s*$/i))) {
                 // Automatic property value conversion.
                 state.typer[matches[1]] = matches[2];
             }
         }
-        else if (matches = line.match(/^@([^\s:@][^:]*)\s*:\s*(.*)\s*$/)) {
+        else if ((matches = line.match(/^@([^\s:@][^:]*)\s*:\s*(.*)\s*$/))) {
             // New property
             state.newkey = matches[1];
             state.onewkey = state.newkey;

package/lib/readers/phillipsEroll.d.ts

@@ -1,6 +1,6 @@
-import { RollCopy } from "../RollCopy.js";
-import { TrackerBar } from "../TrackerBar.js";
-import { Millimeters, Seconds } from "../Quantity.js";
+import { RollCopy } from "../model/RollCopy.js";
+import { TrackerBar } from "../systems/TrackerBar.js";
+import { Millimeters, Seconds } from "../model/Quantity.js";
 /**
  * Peter Phillips's "e-roll" file, the unprocessed output of his
  * pneumatic roll reader (thesis pp. 182–196): the roll runs over a

package/lib/readers/phillipsEroll.js

@@ -1,11 +1,11 @@
 import { read } from "midifile-ts";
 import { v4 } from "uuid";
-import { assignObject } from "../Assumption.js";
-import { systemOf } from "../TrackerBar.js";
-import { shortenChains } from "../alignment.js";
+import { assignObject } from "../model/Assumption.js";
+import { systemOf } from "../systems/TrackerBar.js";
+import { shortenChains } from "../collation/alignment.js";
 import { welteT100 } from "../systems/welteT100/bar.js";
 import { welteLicensee } from "../systems/welteLicensee/bar.js";
-import { inMetersPerMinute, mm, seconds, track } from "../Quantity.js";
+import { inMetersPerMinute, mm, seconds, track } from "../model/Quantity.js";
 /**
  * Peter Phillips's "e-roll" file, the unprocessed output of his
  * pneumatic roll reader (thesis pp. 182–196): the roll runs over a
@@ -166,7 +166,6 @@ export function readFromPhillipsEroll(buffer, { system = welteT100, controlOffse
     const copy = {
         type: 'RollCopy',
         id: v4(),
-        ops: [],
         conditions: [],
         measurements: {},
         production: { system: systemOf(system), produced: features },

package/lib/readers/spencerBar.d.ts

@@ -1,5 +1,5 @@
-import { PaperSpeed, RollCopy } from "../RollCopy.js";
-import { TrackerBar } from "../TrackerBar.js";
+import { PaperSpeed, RollCopy } from "../model/RollCopy.js";
+import { TrackerBar } from "../systems/TrackerBar.js";
 /**
  * Rows of the image on an inch of paper. The player reads eight rows a
  * second per unit of roll tempo (tempo 80 comes with a sample rate of

package/lib/readers/spencerBar.js

@@ -1,7 +1,7 @@
 import { v4 } from "uuid";
-import { systemOf } from "../TrackerBar.js";
+import { systemOf } from "../systems/TrackerBar.js";
 import { welteLicensee } from "../systems/welteLicensee/bar.js";
-import { feetPerMinute, inMillimeters, px, track } from "../Quantity.js";
+import { feetPerMinute, inMillimeters, px, track } from "../model/Quantity.js";
 /**
  * Spencer Chase's e-roll file (`.bar`, "eRoll Tracker Bar Image") holds
  * a roll as a list of events: a distance in rows of the scanned image,
@@ -111,7 +111,6 @@ export function readFromSpencerBar(buffer, { rowsPerInch = SPENCER_ROWS_PER_INCH
     return {
         type: 'RollCopy',
         id: v4(),
-        ops: [],
         conditions: [],
         measurements: {},
         production: { system: systemOf(system), produced: features },

package/lib/readers/stanfordAton.d.ts

@@ -1,6 +1,6 @@
-import { RollCopy } from "../RollCopy.js";
-import { TrackerBar } from "../TrackerBar.js";
-import { Track } from "../Quantity.js";
+import { RollCopy } from "../model/RollCopy.js";
+import { TrackerBar } from "../systems/TrackerBar.js";
+import { Track } from "../model/Quantity.js";
 export interface StanfordAtonOptions {
     /**
      * Added to the scanning software's hole numbering to reach the

package/lib/readers/stanfordAton.js

@@ -1,8 +1,8 @@
 import { v4 } from "uuid";
 import { AtonParser } from "./AtonParser.js";
-import { systemOf } from "../TrackerBar.js";
+import { systemOf } from "../systems/TrackerBar.js";
 import { welteT100 } from "../systems/welteT100/bar.js";
-import { inMillimeters, mean, mm, pixelsPerInch, px, subtract, track } from "../Quantity.js";
+import { inMillimeters, mean, mm, pixelsPerInch, px, subtract, track } from "../model/Quantity.js";
 /** Values in these files carry their unit as a suffix, e.g. "37.7646px". */
 const readPx = (value) => px(parseFloat(value));
 /** The parser writes one record as an object and several as an array. */
@@ -155,7 +155,6 @@ export function readFromStanfordAton(atonString, { trackShift, system = welteT10
     return {
         type: 'RollCopy',
         id: v4(),
-        ops: [],
         conditions: [],
         production: {
             system: systemOf(system),

package/lib/schema.json

@@ -3023,18 +3023,6 @@
                     "type": "array",
                     "ontology": "crm:P31i was modified by"
                 },
-                "ops": {
-                    "description": "A list of operations that have been applied to this copy's features (e.g. 'shifted', 'stretched') to normalize measurements for comparison with other copies. Not exported to RDF.",
-                    "items": {
-                        "enum": [
-                            "shifted",
-                            "stretched",
-                            "shortened"
-                        ],
-                        "type": "string"
-                    },
-                    "type": "array"
-                },
                 "production": {
                     "$ref": "#/definitions/ProductionEvent",
                     "description": "The production event that created this roll copy.",
@@ -3071,7 +3059,6 @@
                 "@id",
                 "measurements",
                 "modifications",
-                "ops",
                 "@type"
             ],
             "type": "object",

package/lib/{ReproducingSystem.d.ts → systems/ReproducingSystem.d.ts}

@@ -1,7 +1,7 @@
-import { HoleChain } from "./Feature.js";
-import { Expression, Note } from "./Symbol.js";
+import { HoleChain } from "../model/Feature.js";
+import { Expression, Note } from "../model/Symbol.js";
 import { TrackerBar } from "./TrackerBar.js";
-import { Millimeters, Quantity, Seconds } from "./Quantity.js";
+import { Millimeters, Quantity, Seconds } from "../model/Quantity.js";
 export type SpeedUnit = 'ft/min' | 'm/min';
 /**
  * The playback tempo of the roll as a paper speed, stated at the

package/lib/{TrackerBar.d.ts → systems/TrackerBar.d.ts}

@@ -1,6 +1,6 @@
-import type { Concept } from "./Agent.js";
-import { Expression, Note } from "./Symbol.js";
-import { Millimeters, SpeedMeasure, Track } from "./Quantity.js";
+import type { Concept } from "../model/Agent.js";
+import { Expression, Note } from "../model/Symbol.js";
+import { Millimeters, SpeedMeasure, Track } from "../model/Quantity.js";
 /**
  * What a tracker bar position does: sound a note, or operate one of
  * the expression valves on the bass or the treble side.
@@ -15,6 +15,27 @@ export interface TrackArea {
     readonly from: Track;
     readonly to: Track;
 }
+/**
+ * How a scale words a function: as a command that turns it on, one that
+ * cancels it, or one that holds it for as long as it lasts.
+ */
+export type Spelling = 'on' | 'off' | 'held';
+/**
+ * What a word of a scale operates, rather than the word itself, so that
+ * two scales can be compared at all.
+ */
+export interface Operation {
+    /** The function operated, named the same wherever a scale has it. */
+    operates: string;
+    spelling: Spelling;
+    /**
+     * Whether the half of the keyboard the valve serves is part of the
+     * function operated. The dynamics are per half; the pedals are not,
+     * and the two Welte scales put them on opposite edges of the paper,
+     * so a rule that compared sides would leave every pedal unpaired.
+     */
+    sided: boolean;
+}
 export type NoteMeaning = Pick<Note, 'type' | 'pitch'>;
 export type ExpressionMeaning = Pick<Expression, 'type' | 'expressionType' | 'scope'>;
 export type TrackMeaning = NoteMeaning | ExpressionMeaning;
@@ -44,6 +65,12 @@ export interface TrackerBar {
     readonly areas: readonly TrackArea[];
     /** The expression types the bar reads, each a term of the system. */
     readonly expressionTypes: readonly string[];
+    /**
+     * How the system spells a single added accent, each spelling a
+     * sequence of its expression types: a latched system turns a valve on
+     * and off again, a held one holds one perforation for the accent.
+     */
+    readonly accents: readonly (readonly string[])[];
     /**
      * The position carrying the rewind perforation, which runs at
      * the very end of a roll and is the usual landmark for calibrating
@@ -90,6 +117,11 @@ export interface TrackerBar {
     positionOf(meaning: TrackMeaning): Track | undefined;
     /** `undefined` for a position the bar does not read; snapped as `meaningOf` is. */
     roleOf(position: Track): TrackRole | undefined;
+    /**
+     * What the expression type operates, or `undefined` for one the bar
+     * does not read or whose function has no counterpart in another scale.
+     */
+    operationOf(expressionType: string): Operation | undefined;
     /** The positions a feature lies across, snapped to the grid. */
     positionsIn(span: OnBar): readonly Track[];
 }
@@ -105,11 +137,6 @@ export declare const systemOf: (bar: TrackerBar) => Concept;
 export declare const systemIdIn: (id: string | undefined) => string | undefined;
 /** The identifier of a system the type vocabulary knows, from its concept. */
 export declare const systemIdOf: (system: Concept | undefined) => string | undefined;
-/**
- * A tracker bar as written down, with its positions as plain numbers
- * 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.
  *
@@ -141,6 +168,11 @@ export type OnBar = {
     readonly from: Track;
     readonly to?: Track;
 };
+/**
+ * A tracker bar as written down, with its positions as plain numbers
+ * in the bar's own 1-based numbering; `describeTrackerBar` gives them
+ * their type.
+ */
 export interface TrackerBarSpec {
     id: string;
     name: string;
@@ -170,6 +202,14 @@ export interface TrackerBarSpec {
      * its own needs no threshold, since anything there is the rewind.
      */
     rewindHold?: Millimeters;
+    /**
+     * What each expression type operates, keyed by type. A type left out
+     * operates a function no other scale has a word for, and a transfer
+     * leaves it a plain deletion.
+     */
+    operations?: Readonly<Record<string, Operation>>;
+    /** How the system spells a single added accent; see `TrackerBar.accents`. */
+    accents?: readonly (readonly string[])[];
 }
 export declare const describeTrackerBar: (spec: TrackerBarSpec) => TrackerBar;
 /**

package/lib/{TrackerBar.js → systems/TrackerBar.js}

@@ -1,4 +1,4 @@
-import { mm, track } from "./Quantity.js";
+import { mm, track } from "../model/Quantity.js";
 /**
  * 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
@@ -66,6 +66,13 @@ export const describeTrackerBar = (spec) => {
     if (rewind === undefined) {
         throw new Error(`${spec.name} declares no rewind track`);
     }
+    const expressionTypes = [...new Set(spec.expressions.values())];
+    const operations = spec.operations ?? {};
+    const accents = spec.accents ?? [];
+    const unread = [...Object.keys(operations), ...accents.flat()].filter(type => !expressionTypes.includes(type));
+    if (unread.length > 0) {
+        throw new Error(`${spec.name} names expression types its bar does not read: ${[...new Set(unread)].join(', ')}`);
+    }
     // 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;
@@ -84,13 +91,15 @@ export const describeTrackerBar = (spec) => {
         trackCount: spec.trackCount,
         endsAt,
         areas,
-        expressionTypes: [...new Set(spec.expressions.values())],
+        expressionTypes,
+        accents,
         rewindTrack: track(rewind),
         ...(spec.paperSpeed && { paperSpeed: spec.paperSpeed }),
         meaningOf,
         meaningsOf,
         positionOf: meaning => positions.get(keyOf(meaning)),
         roleOf,
+        operationOf: expressionType => Object.hasOwn(operations, expressionType) ? operations[expressionType] : undefined,
         positionsIn: positionsBetween
     };
 };

package/lib/systems/index.d.ts

@@ -1,6 +1,12 @@
-import { Concept } from "../Agent.js";
-import { TrackerBar } from "../TrackerBar.js";
+import { Concept } from "../model/Agent.js";
+import { TrackerBar } from "./TrackerBar.js";
 /** The tracker bars the library knows, the T-100 first as the usual one. */
 export declare const trackerBars: readonly TrackerBar[];
 /** The bar of a system the type vocabulary knows, from its concept. */
 export declare const trackerBarOf: (system: Concept | undefined) => TrackerBar | undefined;
+/**
+ * The bar a copy is read by where it names no system of its own: every
+ * copy was read by the T-100's before the systems were told apart, and
+ * `reservationsAbout` reports a copy that still relies on this.
+ */
+export declare const defaultTrackerBar: TrackerBar;

package/lib/systems/index.js

@@ -1,4 +1,4 @@
-import { systemIdOf } from "../TrackerBar.js";
+import { systemIdOf } from "./TrackerBar.js";
 import { welteT100 } from "./welteT100/bar.js";
 import { welteLicensee } from "./welteLicensee/bar.js";
 import { welteT98 } from "./welteT98/bar.js";
@@ -9,3 +9,9 @@ export const trackerBarOf = (system) => {
     const id = systemIdOf(system);
     return trackerBars.find(bar => bar.id === id);
 };
+/**
+ * The bar a copy is read by where it names no system of its own: every
+ * copy was read by the T-100's before the systems were told apart, and
+ * `reservationsAbout` reports a copy that still relies on this.
+ */
+export const defaultTrackerBar = welteT100;

package/lib/systems/welte.d.ts

@@ -0,0 +1,100 @@
+import { Grid, Half, Model, ModelInput, Parameters, PedalInput, PedalMode, PedalTravel, PortGeometry, Spool } from "welte-mignon-emulator";
+import { Expression } from "../model/Symbol.js";
+import { NegotiatedEvent, Performance, RollProperties } from "./ReproducingSystem.js";
+import { Millimeters, Seconds, Track } from "../model/Quantity.js";
+import { type VelocityMap } from "./velocity.js";
+/**
+ * What the Welte systems share downstream of the relay. Hagmann has the
+ * nuancing unit built the same for both tracker scales (p. 96) and the valves
+ * and bellows that move the pedals the same in both (p. 106), so the way a
+ * performance is read off the emulator is one; what differs is in front of it,
+ * and each system says that in the `Mechanism` it hands to `performWelte`.
+ */
+/** The options every Welte system takes. */
+export type WelteOptions = {
+    /**
+     * 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. */
+    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;
+};
+/** Whether two sets of constants are the same, value for value. */
+export declare const sameParameters: (a: Parameters, b: Parameters) => boolean;
+/**
+ * Between the edition's shared place axis and this version's own paper.
+ * `toOwnPaper` is 1 for a version on the axis it was measured on, and about
+ * 0.775 for a green version whose places are in the red axis; see
+ * `RollProperties`.
+ *
+ * Rows are rows of the version's own paper, so the spool is asked in
+ * `paperOfRow` and never in `placeOfRow`: one is the paper that passes the
+ * tracker bar, the other is the coordinate the edition states.
+ */
+export type Paper = {
+    readonly rowOf: (place: Millimeters) => number;
+    readonly placeOfRow: (row: number) => Millimeters;
+    readonly paperOfRow: (row: number) => Millimeters;
+};
+/** When the spool brings a place on the roll to the tracker bar. */
+export declare const secondsAt: (spool: Spool, place: Millimeters) => Seconds;
+/** A perforation as the emulator reads it: the control it operates and the rows it spans. */
+export type WeltePunch = {
+    readonly half: Half;
+    readonly control: string;
+    readonly rowOn: number;
+    readonly rowOff: number;
+};
+export type Ports = ModelInput['ports'];
+/**
+ * What a Welte system puts in front of the shared nuancing unit and pedals:
+ * how it reads a perforation, how it opens the ports, which pneumatic model
+ * drives the bellows, and which the pedals.
+ */
+export type Mechanism<P extends WeltePunch> = {
+    /** The punch the expression is read as, or nothing for one the mechanism does not read. */
+    readonly punchOf: (event: NegotiatedEvent & Expression, rows: {
+        rowOn: number;
+        rowOff: number;
+    }) => P | undefined;
+    readonly portsOf: (grid: Grid, punches: readonly P[], geometry: PortGeometry) => Ports;
+    readonly model: Model;
+    readonly runPedals: (input: PedalInput, params: Parameters) => PedalTravel;
+    /** The name of the instrument the curves say they came from. */
+    readonly instrument: string;
+};
+/** A performance, with the grid and ports it was read off, for a system that has more to ask of them. */
+export type WeltePerformance = Performance & {
+    readonly grid: Grid;
+    readonly ports: Ports;
+};
+/**
+ * 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 declare const performWelte: <P extends WeltePunch>(events: readonly NegotiatedEvent[], options: WelteOptions, roll: RollProperties, mechanism: Mechanism<P>) => WeltePerformance;

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.
  *