linked-rolls 0.56.0 → 0.58.0

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

@@ -1,7 +1,7 @@
-import { Edit } from "./Edit.js";
-import { HorizontalSpan } from "./Feature.js";
-import { AnySymbol } from "./Symbol.js";
-import { Millimeters } from "./Quantity.js";
+import { Edit } from "../model/Edit.js";
+import { HorizontalSpan } from "../model/Feature.js";
+import { AnySymbol } from "../model/Symbol.js";
+import { Millimeters } from "../model/Quantity.js";
 /** A value taken at each end of a feature: where it begins and where it stops. */
 export interface BothEnds<T> {
     from: T;

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))
@@ -37,7 +37,7 @@ const sitsOn = (view, copies) => (feature) => {
 export const readingsOf = (view, symbols, copies) => {
     const tested = sitsOn(view, copies);
     return symbols.flatMap((symbol) => {
-        const carriers = view.carriersOf(symbol);
+        const carriers = view.placedCarriersOf(symbol);
         const here = carriers.filter(tested);
         const there = carriers.filter(carrier => !tested(carrier));
         if (here.length === 0 || there.length === 0)
@@ -220,12 +220,12 @@ const copiesBearing = (view, symbols) => {
  * stopped saying and an editor has to.
  */
 export const sidesOf = (view, versionId) => {
-    const version = view.get(versionId);
+    const version = view.version(versionId);
     if (!version)
         return undefined;
     return {
         child: copiesBearing(view, insertedBy(version)),
-        parent: copiesBearing(view, view.getAll(deletedBy(version)))
+        parent: copiesBearing(view, view.symbols(deletedBy(version)))
     };
 };
 const inMillimetres = (value) => `${value.toFixed(2)} mm`;

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