linked-rolls 0.57.0 → 0.59.0

package/lib/{Collation.js → collation/Collation.js}

@@ -1,7 +1,7 @@
-import { keyOf } from "./TrackerBar.js";
-import { distance, mm } from "./Quantity.js";
-import { partitionPoint } from "./sorted.js";
-import { groupBy } from "./utils.js";
+import { keyOf } from "../systems/TrackerBar.js";
+import { distance, mm } from "../model/Quantity.js";
+import { partitionPoint } from "../shared/sorted.js";
+import { groupBy } from "../shared/utils.js";
 export const defaultCollationTolerance = { toleranceStart: mm(5), toleranceEnd: mm(5) };
 /** Where the window is centred at the start of a feature, on nothing where it names no offset. */
 export const offsetStartOf = (tolerance) => tolerance.offsetStart ?? mm(0);

package/lib/{alignment.d.ts → collation/alignment.d.ts}

@@ -1,7 +1,7 @@
-import { FeatureOrPatch } from "./Feature.js";
-import { RollCopy, Shift } from "./RollCopy.js";
-import { TrackerBar } from "./TrackerBar.js";
-import { Millimeters } from "./Quantity.js";
+import { FeatureOrPatch } from "../model/Feature.js";
+import { RollCopy, Shift } from "../model/RollCopy.js";
+import { TrackerBar } from "../systems/TrackerBar.js";
+import { Millimeters } from "../model/Quantity.js";
 export declare const applyShift: (shift: Shift, copy: RollCopy) => void;
 /** Scales the copy's features away from the beginning of the roll, and records the factor. */
 export declare const applyScale: (factor: number, copy: RollCopy) => void;

package/lib/{alignment.js → collation/alignment.js}

@@ -1,6 +1,6 @@
-import { featuresOf } from "./RollCopy.js";
-import { welteT100 } from "./systems/welteT100/bar.js";
-import { add, mm, scale, subtract } from "./Quantity.js";
+import { featuresOf } from "../model/RollCopy.js";
+import { defaultTrackerBar } from "../systems/index.js";
+import { add, mm, scale, subtract } from "../model/Quantity.js";
 /** Moves both ends of a span, the far end only where the span has one. */
 const move = (span, by) => {
     span.from = add(span.from, by);
@@ -15,43 +15,39 @@ const stretch = (span, factor) => {
 };
 const back = (shift) => ({ horizontal: scale(shift.horizontal, -1), vertical: scale(shift.vertical, -1) });
 export const applyShift = (shift, copy) => {
-    if (copy.ops.includes('shifted'))
+    if (copy.measurements.shift)
         return;
     featuresOf(copy).forEach(feature => {
         move(feature.horizontal, shift.horizontal);
         move(feature.vertical, shift.vertical);
     });
-    copy.ops = [...copy.ops, 'shifted'];
     copy.measurements.shift = shift;
 };
 /** Scales the copy's features away from the beginning of the roll, and records the factor. */
 export const applyScale = (factor, copy) => {
-    if (copy.ops.includes('stretched'))
+    if (copy.measurements.scale !== undefined)
         return;
     featuresOf(copy).forEach(feature => stretch(feature.horizontal, factor));
-    copy.ops = [...copy.ops, 'stretched'];
     copy.measurements.scale = factor;
 };
 /** Takes the shift off the copy's features again, as far as one was applied. */
 export const revertShift = (copy) => {
     const shift = copy.measurements.shift;
-    if (!copy.ops.includes('shifted') || !shift)
+    if (!shift)
         return;
     const reversed = back(shift);
     featuresOf(copy).forEach(feature => {
         move(feature.horizontal, reversed.horizontal);
         move(feature.vertical, reversed.vertical);
     });
-    copy.ops = copy.ops.filter(op => op !== 'shifted');
     delete copy.measurements.shift;
 };
 /** Takes the scale off the copy's features again, as far as one was applied. */
 export const revertScale = (copy) => {
     const factor = copy.measurements.scale;
-    if (!copy.ops.includes('stretched') || factor === undefined)
+    if (factor === undefined)
         return;
     featuresOf(copy).forEach(feature => stretch(feature.horizontal, 1 / factor));
-    copy.ops = copy.ops.filter(op => op !== 'stretched');
     delete copy.measurements.scale;
 };
 const chainsOf = (copy) => featuresOf(copy).filter(feature => feature.type === 'HoleChain');
@@ -103,7 +99,7 @@ export const tooShortToShorten = (extension, copy, leaving = new Set()) => chain
  * extension, `tooShortToShorten` saying beforehand which those are.
  */
 export const shortenChains = (extension, copy, leaving = new Set()) => {
-    if (copy.ops.includes('shortened'))
+    if (copy.measurements.readerExtension)
         return;
     const tooShort = tooShortToShorten(extension, copy, leaving);
     if (tooShort.length > 0) {
@@ -115,19 +111,17 @@ export const shortenChains = (extension, copy, leaving = new Set()) => {
     chainsOf(copy)
         .filter(chain => !leaving.has(chain.id))
         .forEach(chain => { chain.horizontal.to = subtract(chain.horizontal.to, extension); });
-    copy.ops = [...copy.ops, 'shortened'];
     copy.measurements.readerExtension = { length: extension, ...(left.length > 0 && { leaving: left }) };
 };
 /** Puts the reader's extension back on the chains it was taken off, as far as one was taken off. */
 export const revertShortening = (copy) => {
     const taken = copy.measurements.readerExtension;
-    if (!copy.ops.includes('shortened') || taken === undefined)
+    if (taken === undefined)
         return;
     const left = new Set(taken.leaving ?? []);
     chainsOf(copy)
         .filter(chain => !left.has(chain.id))
         .forEach(chain => { chain.horizontal.to = add(chain.horizontal.to, taken.length); });
-    copy.ops = copy.ops.filter(op => op !== 'shortened');
     delete copy.measurements.readerExtension;
 };
 const byPlace = (x, y) => x.at - y.at || x.pitch - y.pitch;
@@ -251,7 +245,7 @@ const resultOf = ({ line, matches }) => {
  * sounds, and it is the pitches that are matched. Where a copy's holes
  * have already been put onto the edition's bar, that bar reads it.
  */
-export function alignFeatures(rollA, rollB, barA = welteT100, barB = barA) {
+export function alignFeatures(rollA, rollB, barA = defaultTrackerBar, barB = barA) {
     const a = noteOnsets(rollA, barA);
     const b = noteOnsets(rollB, barB);
     const coarse = robustLine(anchors(a, b));

package/lib/{scatter.d.ts → collation/scatter.d.ts}

@@ -1,9 +1,9 @@
-import { Belief } from "./Assumption.js";
+import { Belief } from "../model/Assumption.js";
 import { BothEnds, CollationTolerance, Displacement } from "./Collation.js";
-import { EditionView } from "./EditionView.js";
-import { Millimeters } from "./Quantity.js";
+import { EditionView } from "../view/EditionView.js";
+import { Millimeters } from "../model/Quantity.js";
 import { Histogram, Spread, Tail } from "./statistics.js";
-import { AnySymbol } from "./Symbol.js";
+import { AnySymbol } from "../model/Symbol.js";
 /**
  * How far the copies of a roll disagree about where a symbol lies, and
  * the collation tolerance that follows from it.

package/lib/{scatter.js → collation/scatter.js}

@@ -1,9 +1,9 @@
 import { v4 } from "uuid";
 import { admits, offsetEndOf, offsetStartOf } from "./Collation.js";
-import { mean, mm } from "./Quantity.js";
+import { mean, mm } from "../model/Quantity.js";
 import { excessKurtosisOf, histogramOf, normalQuantile, spreadOf, standardise, tailOf } from "./statistics.js";
-import { groupBy } from "./utils.js";
-import { deletedBy, insertedBy } from "./Version.js";
+import { groupBy } from "../shared/utils.js";
+import { deletedBy, insertedBy } from "../model/Version.js";
 const placeOf = (carriers) => ({
     from: mean(carriers.map(carrier => carrier.horizontal.from)),
     to: mean(carriers.map(carrier => carrier.horizontal.to))

package/lib/{statistics.d.ts → collation/statistics.d.ts}

@@ -1,4 +1,4 @@
-import { Quantity } from "./Quantity.js";
+import { Quantity } from "../model/Quantity.js";
 /**
  * The statistics a sample of measurements is described with.
  *

package/lib/{statistics.js → collation/statistics.js}

@@ -1,4 +1,4 @@
-import { quantity } from "./Quantity.js";
+import { quantity } from "../model/Quantity.js";
 /**
  * The statistics a sample of measurements is described with.
  *
@@ -116,6 +116,6 @@ export const histogramOf = (values, binWidth) => {
         counts: values.reduce((tally, value) => {
             tally[Math.min(bins - 1, Math.floor((value - first) / binWidth))] += 1;
             return tally;
-        }, new Array(bins).fill(0))
+        }, Array.from({ length: bins }, () => 0))
     };
 };

package/lib/{substitution.d.ts → collation/substitution.d.ts}

@@ -1,29 +1,14 @@
 import { CollationTolerance, Locate } from "./Collation.js";
-import { AnySymbol, Expression } from "./Symbol.js";
-import { Millimeters, Track } from "./Quantity.js";
-import { TrackerBar } from "./TrackerBar.js";
+import { AnySymbol, Expression } from "../model/Symbol.js";
+import { Millimeters, Track } from "../model/Quantity.js";
+import { Operation, TrackerBar } from "../systems/TrackerBar.js";
+export type { Operation, Spelling } from "../systems/TrackerBar.js";
 /**
- * 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.
+ * What an expression type operates, as the bar that reads it says, or
+ * nothing for a word no bar here knows or one without a counterpart in
+ * another scale. The bars share their words where they share a scale,
+ * as the Licensee does the T-100's, so the first that reads it answers.
  */
-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;
-}
-/** What an expression type operates, or nothing for a word no scale here knows. */
 export declare const operationOf: (expressionType: string) => Operation | undefined;
 /**
  * A latched function of the older version and the held command of the
@@ -46,7 +31,7 @@ export interface Substitution {
  * 2.66 mm grid with bridges of about a millimetre, so a scan read hole
  * by hole shows a run where the paper shows one command.
  */
-export declare const defaultChainGap: import("./Quantity.js").Quantity<"mm">;
+export declare const defaultChainGap: import("../index.js").Quantity<"mm">;
 /**
  * The position a bar reads its own command for the same function on,
  * where it has no word for this one.

package/lib/{substitution.js → collation/substitution.js}

@@ -1,44 +1,20 @@
 import { defaultCollationTolerance } from "./Collation.js";
-import { distance, mm, track } from "./Quantity.js";
+import { distance, mm, track } from "../model/Quantity.js";
+import { trackerBars } from "../systems/index.js";
 /**
- * What each Welte expression type operates.
- *
- * This cannot be read off the names. The T-100 latches a function on
- * with one perforation and cancels it with a second, while the T-98
- * holds it for as long as one perforation lasts (Hagmann pp. 89 f. and
- * 100–103; Phillips p. 121), and Welte renamed two of the functions
- * between the scales: the red `SlowCrescendo` is the green `Crescendo`,
- * and the red's single `Forzando` valve answers to two green ones that
- * name the end they pull towards. So the correspondence is stated here
- * rather than derived, and only two types that operate one function can
- * stand for each other.
- *
- * The T-100's `MotorOn`/`MotorOff`, `Rewind` and `ElectricCutOff` are
- * left out on purpose: the green scale has no word for any of them, its
- * motor switch being an automatic mercury contact (Skala-Rolle 98 §12)
- * and its rewind riding on the bass sforzando-piano line. A red command
- * of those kinds has no counterpart and stays a plain deletion.
+ * What an expression type operates, as the bar that reads it says, or
+ * nothing for a word no bar here knows or one without a counterpart in
+ * another scale. The bars share their words where they share a scale,
+ * as the Licensee does the T-100's, so the first that reads it answers.
  */
-const operations = {
-    MezzoforteOn: { operates: 'mezzoforte', spelling: 'on', sided: true },
-    MezzoforteOff: { operates: 'mezzoforte', spelling: 'off', sided: true },
-    SlowCrescendoOn: { operates: 'crescendo', spelling: 'on', sided: true },
-    SlowCrescendoOff: { operates: 'crescendo', spelling: 'off', sided: true },
-    ForzandoOn: { operates: 'sforzando', spelling: 'on', sided: true },
-    ForzandoOff: { operates: 'sforzando', spelling: 'off', sided: true },
-    SustainPedalOn: { operates: 'sustainPedal', spelling: 'on', sided: false },
-    SustainPedalOff: { operates: 'sustainPedal', spelling: 'off', sided: false },
-    SoftPedalOn: { operates: 'softPedal', spelling: 'on', sided: false },
-    SoftPedalOff: { operates: 'softPedal', spelling: 'off', sided: false },
-    Mezzoforte: { operates: 'mezzoforte', spelling: 'held', sided: true },
-    Crescendo: { operates: 'crescendo', spelling: 'held', sided: true },
-    SforzandoForte: { operates: 'sforzando', spelling: 'held', sided: true },
-    SforzandoPiano: { operates: 'sforzando', spelling: 'held', sided: true },
-    SustainPedal: { operates: 'sustainPedal', spelling: 'held', sided: false },
-    SoftPedal: { operates: 'softPedal', spelling: 'held', sided: false }
+export const operationOf = (expressionType) => {
+    for (const bar of trackerBars) {
+        const operation = bar.operationOf(expressionType);
+        if (operation)
+            return operation;
+    }
+    return undefined;
 };
-/** What an expression type operates, or nothing for a word no scale here knows. */
-export const operationOf = (expressionType) => operations[expressionType];
 /**
  * How wide a paper bridge may be for two held perforations to be one
  * command. The T-98 punches a hold as a chain of round holes on a

package/lib/emulation/Emulation.d.ts

@@ -0,0 +1,64 @@
+import { MidiFile } from "midifile-ts";
+import { EditionView } from "../view/EditionView.js";
+import type { TrackerBar } from "../systems/TrackerBar.js";
+import { Version } from "../model/Version.js";
+import { AnyPerformedRollFeature, EmulatedCurve, NegotiatedEvent, ReproducingSystem } from "../systems/ReproducingSystem.js";
+import { Millimeters } from "../model/Quantity.js";
+export type EmulationScope = {
+    /** Only notes whose onset lies within this span of the roll are played. */
+    range?: [Millimeters, Millimeters];
+    /** Start the clock at the first note rather than at the beginning of the roll. */
+    skipToFirstNote?: boolean;
+};
+/**
+ * The events moved to where their statements put them, the events given
+ * left as they were. The view supplies the copies, whose measurements
+ * decide how far before or after its reference a command goes, and a
+ * punch diameter, or a millimetre, where no copy agrees with a statement.
+ */
+export declare const withPlacementsApplied: (view: EditionView, events: readonly NegotiatedEvent[]) => NegotiatedEvent[];
+/**
+ * The commands of a version as the bar performs them, in order of place,
+ * within the scope and with the placements applied. A note plays only
+ * where its onset falls in the range; expressions play throughout.
+ */
+export declare const negotiatedEventsOf: (view: EditionView, version: Readonly<Version>, bar: TrackerBar, { range }?: Pick<EmulationScope, 'range'>) => NegotiatedEvent[];
+/** A version performed: what was negotiated, and what the system made of it. */
+export interface Emulated {
+    /** The id of the version performed. */
+    readonly source: string;
+    readonly negotiated: readonly NegotiatedEvent[];
+    /** The performed events in order of time, from the origin the scope sets. */
+    readonly events: readonly AnyPerformedRollFeature[];
+    readonly curves: readonly EmulatedCurve[];
+}
+/**
+ * Performs a version on a reproducing system: the symbols are negotiated
+ * into placed events and the system plays them. Nothing given is changed.
+ */
+export declare const emulate: <Options extends object>(system: ReproducingSystem<Options>, version: Readonly<Version>, view: EditionView, options?: Options, { range, skipToFirstNote }?: EmulationScope) => Emulated;
+/**
+ * The performed events as a MIDI file, in which every note and pedal step
+ * is labelled with the symbol it performs. The file names the system, the
+ * version and the options it was played with.
+ */
+export declare const midiOf: (events: readonly AnyPerformedRollFeature[], systemName: string, options: object, source?: string) => MidiFile;
+/**
+ * A version of the edition, performed and kept: `emulate` and `midiOf`
+ * with the result held on the object between the two calls. Prefer the
+ * functions where nothing needs holding.
+ */
+export declare class Emulation<Options extends object> {
+    readonly system: ReproducingSystem<Options>;
+    options: Options;
+    midiEvents: AnyPerformedRollFeature[];
+    negotiatedEvents: NegotiatedEvent[];
+    curves: readonly EmulatedCurve[];
+    source?: string;
+    constructor(system: ReproducingSystem<Options>, options?: Options);
+    /** Moves the negotiated events to where their statements put them; see `withPlacementsApplied`. */
+    applyConstraints(view: EditionView): void;
+    emulateVersion(version: Version, view: EditionView, scope?: EmulationScope): AnyPerformedRollFeature[];
+    findEventsPerforming(id: string): AnyPerformedRollFeature[];
+    asMIDI(): MidiFile;
+}

package/lib/emulation/Emulation.js

@@ -0,0 +1,282 @@
+import { MIDIControlEvents } from "midifile-ts";
+import { idOf } from "../model/Assumption.js";
+import { isCommand, pairsAmong, placementsOf } from "../model/Symbol.js";
+import { add, mean, mm, seconds, subtract } from "../model/Quantity.js";
+import { punchDiameterOf } from "../model/RollCopy.js";
+import { toOwnPaperOf } from "../analysis/ownPaper.js";
+import { negotiatedEventOf } from "./negotiation.js";
+/** The punch diameter the edition's copies report, where any of them does. */
+const meanPunchDiameterOf = (view) => {
+    const measured = view.edition.copies
+        .map(punchDiameterOf)
+        .filter(value => value !== undefined);
+    return measured.length > 0 ? mean(measured) : undefined;
+};
+const propertiesOf = (view, version) => ({
+    punchDiameter: meanPunchDiameterOf(view),
+    tempo: view.edition.tempoAdjustment,
+    toOwnPaper: toOwnPaperOf(view, version)
+});
+/** The onset a symbol has on each copy carrying it, by the copy's id, as the mean of its chains there. */
+const onsetsByCopy = (view, symbolId) => {
+    const symbol = view.symbol(symbolId);
+    if (!symbol)
+        return new Map();
+    const onsets = view.placedCarriersOf(symbol).flatMap((carrier) => {
+        const copy = view.copyOf(carrier.id);
+        return copy ? [[copy.id, carrier.horizontal.from]] : [];
+    });
+    const copies = new Set(onsets.map(([copy]) => copy));
+    return new Map([...copies].map(copy => [copy, mean(onsets.filter(([at]) => at === copy).map(([, onset]) => onset))]));
+};
+/**
+ * The measured distance from the onset of the reference to the onset of
+ * the follower on each copy carrying both, negative where the follower
+ * comes first there.
+ */
+const offsetsBetween = (view, followerId, referenceId) => {
+    const references = onsetsByCopy(view, referenceId);
+    return [...onsetsByCopy(view, followerId)].flatMap(([copy, onset]) => {
+        const reference = references.get(copy);
+        return reference === undefined ? [] : [subtract(onset, reference)];
+    });
+};
+/**
+ * How far before or after its reference a follower is put when the
+ * measurement does not already have it there: as far as the copies
+ * that agree with the statement put it, and one gap where none does.
+ */
+const distanceOnSide = (side, offsets, gap) => {
+    const agreeing = offsets.filter(offset => side === 'before' ? offset < 0 : offset > 0);
+    return agreeing.length > 0 ? mm(Math.abs(mean(agreeing))) : gap;
+};
+/**
+ * How far each event has to move for the placements to hold:
+ * an aligned event takes the onset of its reference, one placed before
+ * or after its reference keeps its place where the measurement has it
+ * on that side and is moved there where it does not, and a paired
+ * event follows its partner so that the distance between the two is
+ * kept. Events that stay where they are do not appear.
+ */
+const displacementsOf = (events, offsetsBetween, gap) => {
+    const byId = new Map(events.map(event => [event.id, event]));
+    /** Where an event comes to lie once its statement and those of its references hold. */
+    const placedOnsetOf = (event, visited = new Set()) => {
+        const measured = event.horizontal.from;
+        const placement = placementsOf(event)[0];
+        const reference = placement && byId.get(idOf(placement.reference));
+        if (!placement || !reference || reference.id === event.id || visited.has(event.id))
+            return measured;
+        const referenceOnset = placedOnsetOf(reference, new Set([...visited, event.id]));
+        const distance = (side) => distanceOnSide(side, offsetsBetween(event.id, reference.id), gap);
+        switch (placement.relation) {
+            case 'alignedWith': return referenceOnset;
+            case 'before': return measured < referenceOnset ? measured : subtract(referenceOnset, distance('before'));
+            case 'after': return measured > referenceOnset ? measured : add(referenceOnset, distance('after'));
+        }
+    };
+    const displacements = new Map(events
+        .map((event) => [event, subtract(placedOnsetOf(event), event.horizontal.from)])
+        .filter(([, distance]) => distance !== 0));
+    pairsAmong(events).forEach(([one, other]) => {
+        const shared = displacements.get(one) ?? displacements.get(other);
+        if (shared === undefined)
+            return;
+        displacements.set(one, shared);
+        displacements.set(other, shared);
+    });
+    return displacements;
+};
+/** The earliest of the times, or the beginning of the roll where there are none. */
+const earliestOf = (times) => times.length === 0 ? seconds(0) : times.reduce((soonest, at) => at < soonest ? at : soonest);
+/**
+ * The events moved to where their statements put them, the events given
+ * left as they were. The view supplies the copies, whose measurements
+ * decide how far before or after its reference a command goes, and a
+ * punch diameter, or a millimetre, where no copy agrees with a statement.
+ */
+export const withPlacementsApplied = (view, events) => {
+    const gap = meanPunchDiameterOf(view) ?? mm(1);
+    const offsets = (follower, reference) => offsetsBetween(view, follower, reference);
+    const displacements = displacementsOf(events, offsets, gap);
+    return events.map(event => {
+        const distance = displacements.get(event);
+        return distance === undefined ? event : {
+            ...event,
+            horizontal: { ...event.horizontal, from: add(event.horizontal.from, distance), to: add(event.horizontal.to, distance) }
+        };
+    });
+};
+/**
+ * The commands of a version as the bar performs them, in order of place,
+ * within the scope and with the placements applied. A note plays only
+ * where its onset falls in the range; expressions play throughout.
+ */
+export const negotiatedEventsOf = (view, version, bar, { range } = {}) => {
+    const inScope = (event) => !range || event.type !== 'note' || (event.horizontal.from > range[0] && event.horizontal.from < range[1]);
+    return withPlacementsApplied(view, view.snapshot(version.id)
+        .filter(isCommand)
+        .map(symbol => negotiatedEventOf(view, symbol, bar))
+        .filter(event => event !== null)
+        .filter(inScope));
+};
+/**
+ * Performs a version on a reproducing system: the symbols are negotiated
+ * into placed events and the system plays them. Nothing given is changed.
+ */
+export const emulate = (system, version, view, options = system.defaultOptions, { range, skipToFirstNote = false } = {}) => {
+    const negotiated = negotiatedEventsOf(view, version, system.trackerBar, { range });
+    if (negotiated.length === 0)
+        return { source: version.id, negotiated, events: [], curves: [] };
+    const performance = system.perform(negotiated, options, propertiesOf(view, version));
+    const onsets = performance.events.filter(event => event.type === 'noteOn').map(event => event.at);
+    const origin = skipToFirstNote ? earliestOf(onsets) : seconds(0);
+    return {
+        source: version.id,
+        negotiated,
+        curves: performance.curves,
+        events: performance.events
+            .map(event => ({ ...event, at: subtract(event.at, origin) }))
+            .filter(event => event.at >= 0)
+            .sort((a, b) => a.at - b.at)
+    };
+};
+/**
+ * The performed events as a MIDI file, in which every note and pedal step
+ * is labelled with the symbol it performs. The file names the system, the
+ * version and the options it was played with.
+ */
+export const midiOf = (events, systemName, options, source) => {
+    const TICKS_PER_SECOND = 1000;
+    const midi = [];
+    const text = (text, deltaTime = 0) => ({ type: 'meta', subtype: 'text', text, deltaTime });
+    const controller = (controllerType, value, deltaTime = 0) => ({ type: 'channel', subtype: 'controller', controllerType, value, deltaTime, channel: 0 });
+    const controllerOf = (event) => event.type === 'damper' ? MIDIControlEvents.SUSTAIN : MIDIControlEvents.SOFT_PEDAL;
+    midi.push(text(`linked-rolls (${systemName})`));
+    if (source) {
+        midi.push(text(source));
+    }
+    for (const [key, value] of Object.entries(options)) {
+        midi.push(text(`${key}=${typeof value === 'object' ? JSON.stringify(value) : value}`));
+    }
+    midi.push({
+        type: 'meta',
+        subtype: 'setTempo',
+        microsecondsPerBeat: 1000000,
+        deltaTime: 0
+    });
+    // both pedals start at rest
+    midi.push(controller(MIDIControlEvents.SUSTAIN, 0), controller(MIDIControlEvents.SOFT_PEDAL, 0));
+    // a pedal step is labelled with its command only where that
+    // command changes, so the file is not swamped with labels
+    const lastCause = {};
+    let currentTick = 0;
+    for (const event of events.toSorted((a, b) => a.at - b.at)) {
+        const tick = Math.round(event.at * TICKS_PER_SECOND);
+        const deltaTime = tick - currentTick;
+        currentTick = tick;
+        if (event.type === 'noteOn') {
+            midi.push(text(event.performs.id, deltaTime));
+            midi.push({
+                type: 'channel',
+                subtype: 'noteOn',
+                noteNumber: event.pitch,
+                velocity: +event.velocity.toFixed(0),
+                deltaTime: 0,
+                channel: 0
+            });
+        }
+        else if (event.type === 'noteOff') {
+            midi.push({
+                type: 'channel',
+                subtype: 'noteOff',
+                noteNumber: event.pitch,
+                velocity: 127,
+                deltaTime,
+                channel: 0
+            });
+        }
+        else {
+            const labelled = lastCause[event.type] === event.performs.id;
+            lastCause[event.type] = event.performs.id;
+            if (!labelled) {
+                midi.push(text(event.performs.id, deltaTime));
+            }
+            midi.push(controller(controllerOf(event), event.value, labelled ? deltaTime : 0));
+        }
+    }
+    return {
+        header: {
+            ticksPerBeat: TICKS_PER_SECOND,
+            formatType: 0,
+            trackCount: 1
+        },
+        tracks: [midi]
+    };
+};
+/**
+ * A version of the edition, performed and kept: `emulate` and `midiOf`
+ * with the result held on the object between the two calls. Prefer the
+ * functions where nothing needs holding.
+ */
+export class Emulation {
+    constructor(system, options = system.defaultOptions) {
+        Object.defineProperty(this, "system", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "midiEvents", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        // sorted list of events with the negotiated assumptions already applied
+        Object.defineProperty(this, "negotiatedEvents", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "curves", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "source", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.system = system;
+        this.options = options;
+    }
+    /** Moves the negotiated events to where their statements put them; see `withPlacementsApplied`. */
+    applyConstraints(view) {
+        this.negotiatedEvents = withPlacementsApplied(view, this.negotiatedEvents);
+    }
+    emulateVersion(version, view, scope = {}) {
+        const emulated = emulate(this.system, version, view, this.options, scope);
+        this.source = emulated.source;
+        this.negotiatedEvents = [...emulated.negotiated];
+        this.curves = emulated.curves;
+        this.midiEvents = [...emulated.events];
+        return this.midiEvents;
+    }
+    findEventsPerforming(id) {
+        return this.midiEvents.filter(event => event.performs.id === id);
+    }
+    asMIDI() {
+        return midiOf(this.midiEvents, this.system.name, this.options, this.source);
+    }
+}

package/lib/emulation/negotiation.d.ts

@@ -0,0 +1,14 @@
+import type { EditionView } from "../view/EditionView.js";
+import type { Expression, Note } from "../model/Symbol.js";
+import type { TrackerBar } from "../systems/TrackerBar.js";
+import type { NegotiatedEvent } from "../systems/ReproducingSystem.js";
+/**
+ * The symbol as a performance needs it: where it lies, and the
+ * position the performing bar reads it on.
+ *
+ * Nothing where that bar reads nothing of it, which is the case a
+ * transfer between systems leaves behind: a red `ForzandoOn` a
+ * green version still inherits cannot be performed on a green
+ * machine, and an edit has yet to say what took its place.
+ */
+export declare const negotiatedEventOf: (view: EditionView, symbol: Note | Expression, bar: TrackerBar) => NegotiatedEvent | null;