linked-rolls 0.5.0 → 0.6.0

package/lib/editionOps.js

@@ -1,7 +1,9 @@
 import { v4 } from "uuid";
 import { getAt } from "./EditionView";
 import { isPerforation, placementRelations } from "./Symbol";
-import { applyShift, applyStretch, asSymbols, revertShift, revertStretch } from "./RollCopy";
+import { collationsOf, defaultCollationTolerance } from "./Collation";
+import { asSymbols } from "./RollCopy";
+import { applyShift, applyStretch, revertShift, revertStretch } from "./alignment";
 import { assignReference, idOf } from "./Assumption";
 const noChange = () => undefined;
 const onCopy = (copyId, op) => draft => {
@@ -16,7 +18,6 @@ const onVersion = (versionId, op) => draft => {
 };
 /** The items that do not match, or the very same array when none does, so that a draft stays untouched. */
 const without = (items, matches) => items.some(matches) ? items.filter(item => !matches(item)) : items;
-const defaultTolerance = { toleranceStart: 5, toleranceEnd: 5 };
 const insertion = (symbol) => ({ type: 'edit', id: v4(), insert: [symbol] });
 const deletion = (symbolId) => ({ type: 'edit', id: v4(), delete: [symbolId] });
 const isEmpty = (edit) => !edit.insert?.length && !edit.delete?.length;
@@ -113,10 +114,6 @@ export const removeCopy = (copyId) => onCopy(copyId, (copy, draft) => {
     forgetFeatures(draft, featureIdsOf(copy));
     draft.copies = draft.copies.filter(c => c.id !== copyId);
 });
-/** Each of the version's own symbols with every inherited symbol it collates with. */
-const collationsOf = (view, own, inherited, tolerance) => own.flatMap(symbol => inherited
-    .filter(candidate => view.isCollatable(symbol, candidate, tolerance))
-    .map(counterpart => ({ symbol, counterpart })));
 /** The carriers of each collated symbol pass to its counterpart. */
 const handOverCarriers = (view, draft, collations) => collations.forEach(({ symbol, counterpart }) => {
     const path = view.getPath(counterpart.id);
@@ -129,10 +126,10 @@ const handOverCarriers = (view, draft, collations) => collations.forEach(({ symb
  * rest become the child's insertions, and what the parent hands down
  * and the child lacks becomes its deletions.
  */
-export const connectVersions = (view, childId, parentId, tolerance = defaultTolerance) => {
+export const connectVersions = (view, childId, parentId, tolerance = defaultCollationTolerance) => {
     const inherited = view.snapshot(parentId);
     const own = view.snapshot(childId);
-    const collations = collationsOf(view, own, inherited, tolerance);
+    const collations = collationsOf(own, inherited, symbol => view.dimensionOf(symbol), tolerance);
     const collated = new Set(collations.map(({ symbol }) => symbol.id));
     const matched = new Set(collations.map(({ counterpart }) => counterpart.id));
     const edits = [
@@ -149,13 +146,13 @@ export const connectVersions = (view, childId, parentId, tolerance = defaultTole
  * Folds the version's own symbols into those it inherits and collates
  * with: the carriers pass over, and the insertions go.
  */
-export const collateSymbols = (view, versionId, symbolIds, tolerance = defaultTolerance) => {
+export const collateSymbols = (view, versionId, symbolIds, tolerance = defaultCollationTolerance) => {
     const version = view.get(versionId);
     if (!version?.basedOn)
         return noChange;
     const chosen = new Set(symbolIds);
     const own = insertedIn([version]).filter(symbol => chosen.has(symbol.id));
-    const collations = collationsOf(view, own, view.snapshot(idOf(version.basedOn)), tolerance);
+    const collations = collationsOf(own, view.snapshot(idOf(version.basedOn)), symbol => view.dimensionOf(symbol), tolerance);
     const collated = new Set(collations.map(({ symbol }) => symbol.id));
     return onVersion(versionId, (version, draft) => {
         handOverCarriers(view, draft, collations);

package/lib/index.d.ts

@@ -1,21 +1,26 @@
+export * from './utils';
+export * from './Agent';
 export * from './Assumption';
-export * from './asJsonLd';
-export * from './Collation';
 export * from './ConditionState';
-export * from './context';
-export * from './Edit';
-export * from './Edition';
-export * from './Emulation';
-export * from './ReproducingSystem';
+export * from './Symbol';
 export * from './Feature';
-export * from './importJsonLd';
-export * from './RollCopy';
+export * from './Edit';
 export * from './Version';
-export * from './Symbol';
-export * from './TrackerBar';
+export * from './Collation';
 export * from './TrackCalibration';
-export * from './alignFeatures';
+export * from './TrackerBar';
+export * from './systems/welteT100/bar';
+export * from './ReproducingSystem';
+export * from './RollCopy';
+export * from './alignment';
+export * from './Edition';
 export * from './EditionView';
 export * from './editionOps';
+export * from './Emulation';
 export * from './validate';
-export * from './utils';
+export * from './constraints';
+export * from './context';
+export * from './asJsonLd';
+export * from './importJsonLd';
+export { readFromStanfordAton, type StanfordAtonOptions } from './readers/stanfordAton';
+export { readFromSpencerMIDI, atConstantSpeed, spencerTrackOf, SPENCER_FEET_PER_MINUTE } from './readers/spencerMidi';

package/lib/index.js

@@ -1,21 +1,26 @@
+export * from './utils';
+export * from './Agent';
 export * from './Assumption';
-export * from './asJsonLd';
-export * from './Collation';
 export * from './ConditionState';
-export * from './context';
-export * from './Edit';
-export * from './Edition';
-export * from './Emulation';
-export * from './ReproducingSystem';
+export * from './Symbol';
 export * from './Feature';
-export * from './importJsonLd';
-export * from './RollCopy';
+export * from './Edit';
 export * from './Version';
-export * from './Symbol';
-export * from './TrackerBar';
+export * from './Collation';
 export * from './TrackCalibration';
-export * from './alignFeatures';
+export * from './TrackerBar';
+export * from './systems/welteT100/bar';
+export * from './ReproducingSystem';
+export * from './RollCopy';
+export * from './alignment';
+export * from './Edition';
 export * from './EditionView';
 export * from './editionOps';
+export * from './Emulation';
 export * from './validate';
-export * from './utils';
+export * from './constraints';
+export * from './context';
+export * from './asJsonLd';
+export * from './importJsonLd';
+export { readFromStanfordAton } from './readers/stanfordAton';
+export { readFromSpencerMIDI, atConstantSpeed, spencerTrackOf, SPENCER_FEET_PER_MINUTE } from './readers/spencerMidi';

package/lib/migrate.js

@@ -1,6 +1,7 @@
 import { conditions } from "./Feature";
 import { rollConditions } from "./RollCopy";
-import { systemOf, welteT100 } from "./TrackerBar";
+import { systemOf } from "./TrackerBar";
+import { welteT100 } from "./systems/welteT100/bar";
 import { versionTypes } from "./Version";
 const versionTypeValues = new Set(versionTypes);
 const conditionTypeValues = new Set([...rollConditions, ...Object.values(conditions).flat()]);

package/lib/readers/spencerMidi.d.ts

@@ -0,0 +1,26 @@
+import { RollCopy } from "../RollCopy";
+/**
+ * How a MIDI key number in one of Spencer Chase's roll files names a
+ * tracker bar track.
+ *
+ * The note block follows the obvious rule, `pitch - 13`, which puts
+ * track 11 on MIDI 24 as the T100 compass requires. The bass expression
+ * block does not: it reads two tracks high, and subtracting two is what
+ * has made these files come out right so far.
+ *
+ * The boundary between the two rules is unresolved. Taken literally the
+ * rules leave tracks 8 and 9 unreachable and jump from track 7 to track 10,
+ * which no lateral offset can produce, so at least one of them is
+ * approximate. Settling it needs a Spencer file whose expression holes
+ * can be checked against the roll, hence the option to override.
+ */
+export declare const spencerTrackOf: (pitch: number) => number;
+/**
+ * Spencer Chase's rolls seem to be scanned at a roll speed of
+ * 83 (=8.3 feet per minute). A scanner feeds the paper at one
+ * speed, so time in his files is proportional to place.
+ */
+export declare const SPENCER_FEET_PER_MINUTE = 8.3;
+/** Place on the roll in mm after `seconds` at a constant `feetPerMinute`. */
+export declare const atConstantSpeed: (feetPerMinute: number) => (seconds: number) => number;
+export declare function readFromSpencerMIDI(midiBuffer: ArrayBuffer, placeAt?: (seconds: number) => number, trackOf?: (pitch: number) => number): RollCopy;

package/lib/readers/spencerMidi.js

@@ -0,0 +1,58 @@
+import { v4 } from "uuid";
+import { read } from "midifile-ts";
+import { asSpans } from "./midiSpans";
+/**
+ * How a MIDI key number in one of Spencer Chase's roll files names a
+ * tracker bar track.
+ *
+ * The note block follows the obvious rule, `pitch - 13`, which puts
+ * track 11 on MIDI 24 as the T100 compass requires. The bass expression
+ * block does not: it reads two tracks high, and subtracting two is what
+ * has made these files come out right so far.
+ *
+ * The boundary between the two rules is unresolved. Taken literally the
+ * rules leave tracks 8 and 9 unreachable and jump from track 7 to track 10,
+ * which no lateral offset can produce, so at least one of them is
+ * approximate. Settling it needs a Spencer file whose expression holes
+ * can be checked against the roll, hence the option to override.
+ */
+export const spencerTrackOf = (pitch) => {
+    const track = pitch - 13;
+    return track < 10 ? track - 2 : track;
+};
+const MM_PER_FOOT = 304.8;
+/**
+ * Spencer Chase's rolls seem to be scanned at a roll speed of
+ * 83 (=8.3 feet per minute). A scanner feeds the paper at one
+ * speed, so time in his files is proportional to place.
+ */
+export const SPENCER_FEET_PER_MINUTE = 8.3;
+/** Place on the roll in mm after `seconds` at a constant `feetPerMinute`. */
+export const atConstantSpeed = (feetPerMinute) => (seconds) => feetPerMinute * MM_PER_FOOT / 60 * seconds;
+export function readFromSpencerMIDI(midiBuffer, placeAt = atConstantSpeed(SPENCER_FEET_PER_MINUTE), trackOf = spencerTrackOf) {
+    const features = asSpans(read(midiBuffer))
+        .filter(span => span.type === 'note')
+        .map((span) => ({
+        type: 'Hole',
+        id: v4(),
+        vertical: {
+            from: trackOf(span.pitch),
+            unit: 'track'
+        },
+        horizontal: {
+            from: placeAt(span.onsetMs / 1000),
+            to: placeAt(span.offsetMs / 1000),
+            unit: 'mm'
+        }
+    }));
+    return {
+        type: 'RollCopy',
+        id: v4(),
+        ops: [],
+        conditions: [],
+        keeper: { name: '', sameAs: [] },
+        measurements: {},
+        modifications: [],
+        features
+    };
+}

package/lib/readers/stanfordAton.d.ts

@@ -0,0 +1,18 @@
+import { RollCopy } from "../RollCopy";
+import { TrackerBar } from "../TrackerBar";
+export interface StanfordAtonOptions {
+    /**
+     * Added to the scanning software's hole numbering to reach the
+     * tracker bar. Left out, it is inferred by putting the rewind
+     * perforation on the bar's rewind track.
+     */
+    trackShift?: number;
+    bar?: TrackerBar;
+    /**
+     * Where the scan the analysis was made from can be seen. Stanford's
+     * files name their scan by DRUID, so this is only needed for an
+     * analysis of a scan hosted elsewhere.
+     */
+    scan?: string;
+}
+export declare function readFromStanfordAton(atonString: string, { trackShift, bar, scan }?: StanfordAtonOptions): RollCopy;

package/lib/readers/stanfordAton.js

@@ -0,0 +1,158 @@
+import { v4 } from "uuid";
+import { AtonParser } from "./AtonParser";
+import { welteT100 } from "../systems/welteT100/bar";
+/** Values in these files carry their unit as a suffix, e.g. "37.7646px". */
+const px = (value) => parseFloat(value);
+/** The parser writes one record as an object and several as an array. */
+const listOf = (value) => value === undefined ? [] : Array.isArray(value) ? value : [value];
+/**
+ * Holes the parser set aside as suspicious after it had already chained
+ * them into a note: the head of such a chain is usually a punch that
+ * came out a little short, and leaving it out would lose the whole
+ * chain. They carry no track number of their own, so the column says
+ * which track they sit on.
+ */
+const chainedBadHoles = (holes, calibration) => holes
+    .filter(hole => hole.NOTE_ATTACK && hole.OFF_TIME)
+    .map(hole => ({
+    ...hole,
+    TRACKER_HOLE: `${Math.round((px(hole.CENTROID_COL) - calibration.offset) / calibration.separation)}`
+}));
+const millimeters = (pixels, dpi) => pixels / dpi * 25.4;
+const median = (values) => {
+    const sorted = [...values].sort((a, b) => a - b);
+    const middle = Math.floor(sorted.length / 2);
+    return sorted.length % 2 ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2;
+};
+const mostFrequent = (values) => {
+    const counts = values.reduce((acc, value) => acc.set(value, (acc.get(value) || 0) + 1), new Map());
+    return [...counts].sort(([, a], [, b]) => b - a)[0]?.[0];
+};
+/**
+ * Only the first hole of a chain carries an attack and an off time;
+ * the rest continue it. The rewind perforation carries neither, and it
+ * is the last thing punched on the roll, so whatever the holes past the
+ * final musical attack sit on is the rewind track.
+ */
+const rewindTrackIn = (holes) => {
+    const lastMusical = holes.findLastIndex(hole => hole.NOTE_ATTACK);
+    const trailing = holes.slice(lastMusical + 1).map(hole => +hole.TRACKER_HOLE);
+    return mostFrequent(trailing);
+};
+/**
+ * The phase of the tracker grid within the image. The analysis file
+ * usually states it; where it does not, the holes themselves give it away,
+ * since each sits close to the centre of its column.
+ */
+const gridOffsetOf = (holes, separation, stated) => {
+    if (stated !== undefined)
+        return px(stated);
+    return median(holes.map(hole => px(hole.CENTROID_COL) - +hole.TRACKER_HOLE * separation));
+};
+const punchDiameterOf = (holes, dpi) => {
+    const circular = holes
+        .filter(hole => px(hole.CIRCULARITY) > 0.95)
+        .map(hole => millimeters(px(hole.PERIMETER), dpi) / Math.PI);
+    if (!circular.length)
+        return undefined;
+    return circular.reduce((sum, diameter) => sum + diameter, 0) / circular.length;
+};
+/**
+ * The image service Stanford keeps for a scan, and a crop of a
+ * feature from it.
+ */
+const stanfordScan = (druid) => ({
+    scan: `https://stacks.stanford.edu/image/iiif/${druid}%2F${druid}_0001/`,
+    depictionOf: (column, row, width, height) => `https://stacks.stanford.edu/image/iiif/${druid}/${druid}_0001/${column},${row},${width},${height}/128,/270/default.jpg`
+});
+/**
+ * The software behind an analysis and when it was run, as the
+ * analysis file states them.
+ */
+const measuredByOf = (rollinfo) => {
+    const date = new Date(rollinfo.ANALYSIS_DATE);
+    if (!rollinfo.HOLE_SOFTWARE || isNaN(date.getTime()))
+        return undefined;
+    return {
+        software: rollinfo.HOLE_SOFTWARE,
+        version: rollinfo.SOFTWARE_DATE ?? '',
+        date
+    };
+};
+export function readFromStanfordAton(atonString, { trackShift, bar = welteT100, scan } = {}) {
+    const parser = new AtonParser();
+    const json = parser.parse(atonString);
+    const holes = json.ROLLINFO.HOLES.HOLE;
+    const druid = json.ROLLINFO.DRUID;
+    const stanford = druid ? stanfordScan(druid) : undefined;
+    const separation = px(json.ROLLINFO.HOLE_SEPARATION);
+    const dpi = parseFloat(json.ROLLINFO.LENGTH_DPI);
+    const measuredBy = measuredByOf(json.ROLLINFO);
+    const rewindTrack = rewindTrackIn(holes);
+    const shift = trackShift
+        ?? (rewindTrack === undefined ? 0 : bar.rewindTrack - rewindTrack);
+    const calibration = {
+        unit: 'px',
+        offset: gridOffsetOf(holes, separation, json.ROLLINFO.HOLE_OFFSET),
+        separation,
+        shift
+    };
+    const punchDiameter = punchDiameterOf(holes, dpi);
+    const chains = [...holes, ...chainedBadHoles(listOf(json.ROLLINFO.BADHOLES?.HOLE), calibration)]
+        .filter(hole => hole.NOTE_ATTACK && hole.OFF_TIME)
+        .sort((a, b) => px(a.NOTE_ATTACK) - px(b.NOTE_ATTACK));
+    const features = chains
+        .map((hole) => {
+        const attack = px(hole.NOTE_ATTACK);
+        const release = px(hole.OFF_TIME);
+        const column = px(hole.ORIGIN_COL);
+        const columnWidth = px(hole.WIDTH_COL);
+        return {
+            type: 'Hole',
+            id: v4(),
+            ...(stanford && {
+                depiction: stanford.depictionOf(column, attack, columnWidth, release - attack)
+            }),
+            vertical: {
+                from: +hole.TRACKER_HOLE + shift,
+                unit: 'track'
+            },
+            horizontal: {
+                unit: 'mm',
+                from: millimeters(attack, dpi),
+                to: millimeters(release, dpi)
+            }
+        };
+    });
+    return {
+        type: 'RollCopy',
+        id: v4(),
+        ops: [],
+        conditions: [],
+        keeper: { name: '', sameAs: [] },
+        modifications: [],
+        ...((scan ?? stanford) && { scan: scan ?? stanford?.scan }),
+        measurements: {
+            dimensions: {
+                width: millimeters(px(json.ROLLINFO.ROLL_WIDTH), dpi),
+                height: millimeters(px(json.ROLLINFO.IMAGE_LENGTH), dpi),
+                unit: 'mm'
+            },
+            ...(punchDiameter !== undefined && {
+                punchDiameter: { value: punchDiameter, unit: 'mm' }
+            }),
+            holeSeparation: {
+                value: separation,
+                unit: 'px'
+            },
+            margins: {
+                treble: px(json.ROLLINFO.HARD_MARGIN_TREBLE),
+                bass: px(json.ROLLINFO.HARD_MARGIN_BASS),
+                unit: 'px'
+            },
+            trackCalibration: calibration,
+            ...(measuredBy && { measuredBy })
+        },
+        features
+    };
+}

package/lib/schema.json

@@ -1189,7 +1189,7 @@
             ],
             "type": "object"
         },
-        "ObjectAssumption<alias-731470504-73739-73887-731470504-0-217694<def-interface-src_Symbol.ts-5758-6122-src_Symbol.ts-0-6378400334313,\"carriers\">>": {
+        "ObjectAssumption<Transcription>": {
             "description": "An object assumption wraps a complex object with an optional annotation. Used for structured values (e.g. persons, conditions) whose properties may be uncertain.",
             "properties": {
                 "@annotation": {
@@ -1760,7 +1760,7 @@
                     "description": "The method by which this writing was produced (e.g. through print, handwriting, or stamping). [ontology: crm:P2 has type]"
                 },
                 "transcription": {
-                    "$ref": "#/definitions/ObjectAssumption%3Calias-731470504-73739-73887-731470504-0-217694%3Cdef-interface-src_Symbol.ts-5758-6122-src_Symbol.ts-0-6378400334313%2C%22carriers%22%3E%3E",
+                    "$ref": "#/definitions/ObjectAssumption%3CTranscription%3E",
                     "description": "A transcription of the text content of the writing. This is an object assumption so that the transcription can be annotated with a belief about its correctness. [ontology: crm:P128 carries]"
                 },
                 "vertical": {

package/lib/systems/welteT100/bar.d.ts

@@ -0,0 +1,14 @@
+import { TrackerBar } from "../../TrackerBar";
+/**
+ * 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];
+/**
+ * Welte-Mignon T-100 ("red Welte"), cf. Hagmann, pp. 75 and 178.
+ *
+ * The note block spans 80 positions from C1 to g⁴, i.e. MIDI 24 to 103.
+ * The expression valves are duplicated, bass below the note block and
+ * treble above it, in mirrored order.
+ */
+export declare const welteT100: TrackerBar;

package/lib/systems/welteT100/bar.js

@@ -0,0 +1,56 @@
+import { describeTrackerBar } from "../../TrackerBar";
+/**
+ * The commands of the Welte-Mignon T-100, as its tracker bar reads them.
+ */
+export const welteT100ExpressionTypes = [
+    'SustainPedalOn',
+    'SustainPedalOff',
+    'SoftPedalOn',
+    'SoftPedalOff',
+    'MezzoforteOff',
+    'MezzoforteOn',
+    'SlowCrescendoOn',
+    'SlowCrescendoOff',
+    'ForzandoOn',
+    'ForzandoOff',
+    'MotorOff',
+    'MotorOn',
+    'Rewind',
+    'ElectricCutOff'
+];
+/**
+ * Welte-Mignon T-100 ("red Welte"), cf. Hagmann, pp. 75 and 178.
+ *
+ * The note block spans 80 positions from C1 to g⁴, i.e. MIDI 24 to 103.
+ * The expression valves are duplicated, bass below the note block and
+ * treble above it, in mirrored order.
+ */
+export const welteT100 = describeTrackerBar({
+    id: 'welte-t100',
+    name: 'Welte-Mignon T100',
+    width: 328,
+    trackCount: 100,
+    notes: { from: 11, to: 90, lowestPitch: 24 },
+    expressions: new Map([
+        [1, 'MezzoforteOff'],
+        [2, 'MezzoforteOn'],
+        [3, 'SlowCrescendoOff'],
+        [4, 'SlowCrescendoOn'],
+        [5, 'ForzandoOff'],
+        [6, 'ForzandoOn'],
+        [7, 'SoftPedalOff'],
+        [8, 'SoftPedalOn'],
+        [9, 'MotorOff'],
+        [10, 'MotorOn'],
+        [91, 'Rewind'],
+        [92, 'ElectricCutOff'],
+        [93, 'SustainPedalOn'],
+        [94, 'SustainPedalOff'],
+        [95, 'ForzandoOn'],
+        [96, 'ForzandoOff'],
+        [97, 'SlowCrescendoOn'],
+        [98, 'SlowCrescendoOff'],
+        [99, 'MezzoforteOn'],
+        [100, 'MezzoforteOff']
+    ])
+});

package/lib/systems/{welteT100.d.ts → welteT100/system.d.ts}

@@ -1,5 +1,5 @@
 import { Half, Parameters, PedalMode, Spool } from "welte-t100-emulator";
-import { ReproducingSystem } from "../ReproducingSystem";
+import { ReproducingSystem } from "../../ReproducingSystem";
 /**
  * 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
@@ -12,6 +12,21 @@ export type VelocityMap = {
     mezzoforte: number;
     forte: number;
 };
+/**
+ * The two readings of the pedal mechanism the emulator offers, by name.
+ * Under `damping` the dampers reach the strings within the shortest lift
+ * the rolls punch, so every lift damps. Under `brushing` their fall is
+ * slowed until the quick runs of latch changes in the SUPRA corpus dip
+ * without damping, at the price that lifts shorter than about 265 ms brush
+ * as well.
+ */
+export declare const pedalPresets: {
+    damping: Readonly<Record<string, number>>;
+    brushing: Readonly<Record<string, number>>;
+};
+export type PedalPreset = keyof typeof pedalPresets;
+/** The preset a set of pedal constants is, if it is one. */
+export declare const pedalPresetOf: (pedals: Parameters) => PedalPreset | undefined;
 export type WelteT100Options = {
     /**
      * The take-up spool, which sets the time axis: it is held at a constant
@@ -20,7 +35,7 @@ export type WelteT100Options = {
     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. */
+    /** Constants of the two pedal actions, one of `pedalPresets` or a set of one's own. */
     pedals: Parameters;
     velocity: VelocityMap;
     /**

package/lib/systems/{welteT100.js → welteT100/system.js}

@@ -1,12 +1,28 @@
-import { aperturePorts, DEFAULT_PUNCH_MM, geometryInMm, Grid, levelChanges, mezzoforteTravel, paperSeconds, pedalDefaults, playbackParameters, pneumaticModel, ROWS_PER_MM, runPedals, TRACKER_BORE_MM, travelBetweenRails, WELTE_SPOOL, } from "welte-t100-emulator";
-import { welteT100 } from "../TrackerBar";
+import { aperturePorts, DEFAULT_PUNCH_MM, geometryInMm, Grid, levelChanges, mezzoforteTravel, paperSeconds, pedalBrushing, pedalDefaults, playbackParameters, pneumaticModel, ROWS_PER_MM, runPedals, TRACKER_BORE_MM, travelBetweenRails, WELTE_SPOOL, } from "welte-t100-emulator";
+import { welteT100 } from "./bar";
+/**
+ * The two readings of the pedal mechanism the emulator offers, by name.
+ * Under `damping` the dampers reach the strings within the shortest lift
+ * the rolls punch, so every lift damps. Under `brushing` their fall is
+ * slowed until the quick runs of latch changes in the SUPRA corpus dip
+ * without damping, at the price that lifts shorter than about 265 ms brush
+ * as well.
+ */
+export const pedalPresets = {
+    damping: pedalDefaults,
+    brushing: pedalBrushing
+};
+const sameParameters = (a, b) => Object.keys(a).length === Object.keys(b).length
+    && Object.entries(a).every(([name, value]) => b[name] === value);
+/** The preset a set of pedal constants is, if it is one. */
+export const pedalPresetOf = (pedals) => Object.keys(pedalPresets).find(name => sameParameters(pedalPresets[name], pedals));
 export const defaultWelteT100Options = {
     spool: WELTE_SPOOL,
     nuance: {
         bass: playbackParameters('bass'),
         treble: playbackParameters('treble')
     },
-    pedals: pedalDefaults,
+    pedals: pedalPresets.damping,
     velocity: { piano: 35, mezzoforte: 60, forte: 90 },
     pedalMode: 'continuous',
     trackerBore: TRACKER_BORE_MM,

package/lib/utils.d.ts

@@ -1,4 +1,3 @@
-import { Person } from "./Edition";
 export type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 export type WithType<T extends string> = {
     /**
@@ -13,13 +12,6 @@ export type WithId = {
      */
     readonly id: string;
 };
-export type WithActor = {
-    /**
-     * The person who carried out this activity.
-     * @see crm:P14 carried out by
-     */
-    actor?: Person;
-};
 export type WithNote = {
     /**
      * A free-text note providing additional context.

package/lib/validate.d.ts

@@ -1,30 +1,3 @@
 import { Edition } from "./Edition";
-import { EditionView } from "./EditionView";
-import { TrackerBar } from "./TrackerBar";
 declare const validate: import("ajv").ValidateFunction<Edition>;
 export { validate };
-export type ConstraintProblem = {
-    version: string;
-    symbol: string;
-    problem: 'alignment-reference-missing' | 'before-reference-missing' | 'after-reference-missing' | 'placed-relative-to-itself' | 'placed-several-ways' | 'partner-missing' | 'paired-with-itself' | 'in-several-pairs' | 'pair-placed-on-both-sides';
-};
-/**
- * Where the placements and pairings of the edition cannot hold as
- * stated, version by version: a reference or partner absent from the
- * version, a perforation placed relative to itself or in several ways
- * at once, one claimed by several pairs, or a pair whose members are
- * both placed and so cannot keep their distance and follow their
- * references at once.
- */
-export declare const constraintProblems: (view: EditionView) => ConstraintProblem[];
-export type UnknownExpressionType = {
-    version: string;
-    symbol: string;
-    expressionType: string;
-};
-/**
- * The expressions of the edition whose type the tracker bar does not
- * read, version by version. The roll names its system; a type from
- * another system, or a misspelt one, means nothing on it.
- */
-export declare const unknownExpressionTypes: (view: EditionView, bar: TrackerBar) => UnknownExpressionType[];