linked-rolls 0.20.0 → 0.22.0

package/README.md

@@ -79,7 +79,7 @@ tracker bar and a `perform` function; the core does not depend on any one
 instrument's model.
 
 The first system is the red Welte, `linked-rolls/welte-t100`, built on
-[welte-t100-emulator](https://github.com/pfefferniels/welte-t100): the
+[welte-mignon-emulator](https://github.com/pfefferniels/welte-t100): the
 take-up spool sets the time axis, the Nuancierbälge fill through their
 conduits and are arrested by the Mezzoforte pin, and the two pedals travel
 rather than switch. The nuancing constants come as `instruments`: the
@@ -103,11 +103,36 @@ emulation.emulateVersion(version, view)
 const midi = emulation.asMIDI()
 ```
 
-The emulator is an optional peer dependency: an application that uses the
-T-100 system installs `welte-t100-emulator` itself, and one that only
-reads editions does not need it. For development on both at once, `npm
-link` a checkout of [welte-t100](https://github.com/pfefferniels/welte-t100)
-into this repository.
+The second is the green Welte, `linked-rolls/welte-t98`. Everything
+downstream of the relay is the same mechanism — Hagmann has the nuancing
+unit built the same for both tracker scales (p. 96) — and what differs is
+in front of it: each function lasts exactly as long as its own perforation
+runs over the glide block rather than latching until a cancel line is read,
+four conduits stand on one bellows and their drives add as flows, the
+crescendo's ceiling is the balance of its throttle against a permanently
+open bleed rather than a cap, the two pedals sit on the opposite edges of
+the paper, and a long perforation on the bass sforzando-piano line sends
+the roll back. Its constants are **not fitted**: `instruments.genuine` and
+`instruments.derived` are empty until their fits are run, and until then a
+playback runs on unfitted starting values, which every curve says in its
+own `instrument` field.
+
+Both systems share one velocity map, and `DynamicsCurve.travel` means the
+same thing on both: the position on the printed ordinate of Welte's own
+ruled band, 0 at that half's P.P. gridline and 1 at the shared F.F. line.
+That is what lets a red issue and a green issue of one recording be
+compared at all, since the band is ruled the same way on both.
+
+```ts
+import { welteT98System } from 'linked-rolls/welte-t98'
+```
+
+The emulator is an optional peer dependency: an application that uses one
+of the Welte systems installs `welte-mignon-emulator` itself, and one that
+only reads editions does not need it. For development on both at once,
+`npm link` a checkout of
+[welte-t100](https://github.com/pfefferniels/welte-t100) into this
+repository.
 
 ### Alignment, order and pairing
 

package/lib/Emulation.js

@@ -9,9 +9,10 @@ const punchDiameterOf = (view) => {
         .filter((value) => value !== undefined && value > 0);
     return measured.length > 0 ? mean(measured) : undefined;
 };
-const propertiesOf = (view) => ({
+const propertiesOf = (view, version) => ({
     punchDiameter: punchDiameterOf(view),
-    tempo: view.edition.tempoAdjustment
+    tempo: view.edition.tempoAdjustment,
+    toOwnPaper: view.toOwnPaperOf(version)
 });
 /** The onset a symbol has on each copy carrying it, by the copy's index, as the mean of its holes there. */
 const onsetsByCopy = (view, symbolId) => {
@@ -163,7 +164,7 @@ export class Emulation {
             return this.midiEvents;
         }
         this.applyConstraints(view);
-        const performance = this.system.perform(this.negotiatedEvents, this.options, propertiesOf(view));
+        const performance = this.system.perform(this.negotiatedEvents, this.options, propertiesOf(view, version));
         this.curves = performance.curves;
         const onsets = performance.events.filter(event => event.type === 'noteOn').map(event => event.at);
         const origin = skipToFirstNote ? earliestOf(onsets) : seconds(0);

package/lib/ReproducingSystem.d.ts

@@ -63,8 +63,18 @@ interface CurveSamples {
     readonly place: Float64Array;
     readonly seconds: Float64Array;
     /**
-     * Position between the two ends of a travel: 0 with a bellows open and
-     * 1 with it closed, 0 with a pedal up and 1 with it down.
+     * Position on the printed ordinate of the roll's own ruled band: 0 at that
+     * half's P.P. gridline, 1 at the shared F.F. line, with M.F. at 0.5. For a
+     * pedal, 0 with it up and 1 with it down.
+     *
+     * Both Welte scales rule that band the same way — five rails, "P.P. M.F.
+     * F.F. M.F. P.P.", three named levels a side with the centre F.F. shared,
+     * measuring 20.0 mm between rails on red 3309 and on green Welte 184 alike —
+     * so a curve from one system and a curve from the other are in one unit, on
+     * Welte's authority rather than on ours. That is what lets a red issue and a
+     * green issue of one recording be compared at all. It is a unit of *drawn
+     * deflection*: whether the deflection is linear in the bellows' own travel is
+     * open, and is what the emulator's `scaleWarp` exists to answer.
      */
     readonly travel: Float64Array;
 }
@@ -72,6 +82,14 @@ interface CurveSamples {
 export type DynamicsCurve = CurveSamples & {
     readonly kind: 'dynamics';
     readonly velocity: Float64Array;
+    /**
+     * The instrument whose constants produced it, by name. A comparison plot
+     * must not be able to put two curves side by side without saying which
+     * instrument each came from: a T-98 fitted to a green roll's drawn line and
+     * a T-98 fitted to a red copy's curve answer different questions, and their
+     * difference is the point of the comparison.
+     */
+    readonly instrument: string;
 };
 export type PedalCurve = CurveSamples & {
     readonly kind: 'pedal';
@@ -83,6 +101,24 @@ export type RollProperties = {
     punchDiameter?: Millimeters;
     /** The tempo the edition adjusts the roll to, where it states one. */
     tempo?: RollTempo;
+    /**
+     * Place on the edition's shared axis × this = millimetres of the version's
+     * own paper. About 0.775 for a green issue of a red recording, 1 for a
+     * version on the axis it was measured on, which is the default.
+     *
+     * Versions of several systems share one place axis, so a green version's
+     * places are in red millimetres and would play about 29 % long if the
+     * spool read them as green paper. The factor is the inverse of the scale
+     * `alignCopy` recorded when it put the copy on the shared axis, taken from
+     * the copies of the version's own system: red copies carry a green
+     * version's notes too and say nothing about green paper.
+     *
+     * It scales **places only**. Punch diameter, the chain gap and the tracker
+     * bore are measured on the version's own paper already, and scaling them
+     * as well would put the aperture model out by the factor with nothing
+     * failing loudly.
+     */
+    toOwnPaper?: number;
 };
 export type Performance = {
     readonly events: readonly AnyPerformedRollFeature[];

package/lib/RollCopy.d.ts

@@ -320,11 +320,21 @@ export declare const barOf: (copy: Pick<RollCopy, 'production'>) => TrackerBar;
  *
  * The bar is named rather than defaulted: a copy is read by its own
  * bar, and reading a green copy with the red one is a silent semitone.
+ *
+ * Reading stops where the bar says the roll's content ends. What a
+ * scanner punched past the rewind is not the roll speaking: Julian
+ * Dyer's scan of the green 225 carries a staircase of test punches
+ * across nearly every track after its rewind, which read on as symbols
+ * would be 318 notes nobody played. The features stay on the copy,
+ * since they are really on the paper and are his calibration of his own
+ * scan; it is the reading that stops.
  */
 export declare function asSymbols(features: AnyFeature[], bar: TrackerBar): AnySymbol[];
 /**
  * The tracks a copy carries holes on that the tracker bar does not read.
- * A non-empty result usually means the scan is calibrated wrongly.
+ * A non-empty result usually means the scan is calibrated wrongly. A hole
+ * lying across several positions is counted against each one the bar
+ * cannot read, and not at all where it reads them all.
  */
 export declare function unreadTracks(features: AnyFeature[], bar: TrackerBar): Map<Track, number>;
 /**

package/lib/RollCopy.js

@@ -26,34 +26,41 @@ export const barOf = (copy) => trackerBarOf(copy.production?.system) ?? welteT10
  *
  * The bar is named rather than defaulted: a copy is read by its own
  * bar, and reading a green copy with the red one is a silent semitone.
+ *
+ * Reading stops where the bar says the roll's content ends. What a
+ * scanner punched past the rewind is not the roll speaking: Julian
+ * Dyer's scan of the green 225 carries a staircase of test punches
+ * across nearly every track after its rewind, which read on as symbols
+ * would be 318 notes nobody played. The features stay on the copy,
+ * since they are really on the paper and are his calibration of his own
+ * scan; it is the reading that stops.
  */
 export function asSymbols(features, bar) {
-    return features
-        .filter(feature => feature.type === 'Hole')
-        .flatMap((feature) => {
-        const meaning = bar.meaningOf(feature.vertical.from);
-        if (!meaning)
-            return [];
-        return [{
-                id: `symbol_${v4()}`,
-                ...meaning,
-                carriers: [assignReference(feature.id)]
-            }];
-    });
+    const holes = features.filter(feature => feature.type === 'Hole');
+    const end = bar.endsAt(holes);
+    return holes
+        .filter(feature => end === undefined || feature.horizontal.from <= end.at)
+        // An opening across two positions uncovers both bar holes and so
+        // reads as both commands; one on a single position gives the one.
+        .flatMap((feature) => bar.meaningsOf(feature.vertical).map(meaning => ({
+        id: `symbol_${v4()}`,
+        ...meaning,
+        carriers: [assignReference(feature.id)]
+    })));
 }
 /**
  * The tracks a copy carries holes on that the tracker bar does not read.
- * A non-empty result usually means the scan is calibrated wrongly.
+ * A non-empty result usually means the scan is calibrated wrongly. A hole
+ * lying across several positions is counted against each one the bar
+ * cannot read, and not at all where it reads them all.
  */
 export function unreadTracks(features, bar) {
     const counts = new Map();
     features
         .filter(feature => feature.type === 'Hole')
-        .filter(feature => !bar.meaningOf(feature.vertical.from))
-        .forEach(feature => {
-        const position = feature.vertical.from;
-        counts.set(position, (counts.get(position) || 0) + 1);
-    });
+        .flatMap(feature => bar.positionsIn(feature.vertical))
+        .filter(position => !bar.meaningOf(position))
+        .forEach(position => counts.set(position, (counts.get(position) || 0) + 1));
     return counts;
 }
 /**

package/lib/TrackerBar.d.ts

@@ -56,8 +56,31 @@ export interface TrackerBar {
      * of their own, as the Licensee's do, states none.
      */
     readonly paperSpeed?: SpeedMeasure;
-    /** `undefined` for a position the bar does not read. */
+    /**
+     * Where the roll's own content ends, from its perforations alone, or
+     * `undefined` where nothing on the paper says. A copy that reads
+     * `undefined` runs to the end of whatever was scanned, which is a fact
+     * about the scan rather than about the roll and should be reported as one.
+     *
+     * Takes anything with a place and a position, so a reader can ask it of a
+     * copy's features before there are symbols, and a collation can ask it of
+     * the symbols afterwards.
+     */
+    endsAt(features: readonly PlacedOnBar[]): RollEnd | undefined;
+    /**
+     * `undefined` for a position the bar does not read. A measured place
+     * is snapped to the nearest position: perforations sit on the grid and
+     * measurements of them scatter around it.
+     */
     meaningOf(position: Track): TrackMeaning | undefined;
+    /**
+     * What the bar reads off a feature, which may lie across more than one
+     * position. A perforation lifts every valve whose bar hole it uncovers,
+     * so an opening across two positions reads as two commands; one on a
+     * single position reads as the one `meaningOf` gives, and one on
+     * positions the bar does not read as none at all.
+     */
+    meaningsOf(span: OnBar): readonly TrackMeaning[];
     /**
      * `meaningOf` inverted: the position this bar reads the meaning on,
      * or `undefined` where it does not read it at all. A symbol's track
@@ -65,8 +88,10 @@ export interface TrackerBar {
      * sits on exactly one position of a given bar.
      */
     positionOf(meaning: TrackMeaning): Track | undefined;
-    /** `undefined` for a position the bar does not read. */
+    /** `undefined` for a position the bar does not read; snapped as `meaningOf` is. */
     roleOf(position: Track): TrackRole | undefined;
+    /** The positions a feature lies across, snapped to the grid. */
+    positionsIn(span: OnBar): readonly Track[];
 }
 /**
  * What a position says, as a key. Two bars read the same thing exactly
@@ -85,6 +110,37 @@ export declare const systemIdOf: (system: Concept | undefined) => string | undef
  * in the bar's own 1-based numbering; `describeTrackerBar` gives them
  * their type.
  */
+/**
+ * Where a roll's own content ends, as far as its perforations say.
+ *
+ * This is a question about the paper, not about the mechanism: it asks where
+ * the rewind is *punched*, not when the rewind pneumatic takes hold. The second
+ * is a matter of valve lift and belongs to whatever performs the roll. Keeping
+ * them apart is what lets collation and counting ask this without an emulator.
+ */
+export type RollEnd = {
+    readonly at: Millimeters;
+    readonly because: 'rewind';
+};
+/** Anything carrying a place on the roll and a position on the bar. */
+export type PlacedOnBar = {
+    readonly horizontal: {
+        readonly from: Millimeters;
+        readonly to: Millimeters;
+    };
+    readonly vertical: {
+        readonly from: Track;
+    };
+};
+/**
+ * Where a feature lies across the bar: one place, or a run of them where
+ * `to` is given. Structural, so a feature's `vertical` passes as it is and
+ * this module need know nothing about features.
+ */
+export type OnBar = {
+    readonly from: Track;
+    readonly to?: Track;
+};
 export interface TrackerBarSpec {
     id: string;
     name: string;
@@ -107,6 +163,13 @@ export interface TrackerBarSpec {
     rewindTrack?: number;
     /** The speed the system runs its rolls at, where the literature states one. */
     paperSpeed?: SpeedMeasure;
+    /**
+     * How long a perforation on a *shared* rewind position has to be before it
+     * is the rewind rather than the command the position usually carries. Only
+     * meaningful with `rewindTrack`: a system that gives the rewind a line of
+     * its own needs no threshold, since anything there is the rewind.
+     */
+    rewindHold?: Millimeters;
 }
 export declare const describeTrackerBar: (spec: TrackerBarSpec) => TrackerBar;
 /**

package/lib/TrackerBar.js

@@ -1,4 +1,4 @@
-import { track } from "./Quantity";
+import { mm, track } from "./Quantity";
 /**
  * What a position says, as a key. Two bars read the same thing exactly
  * where their keys agree, which is what lets a symbol cross from one
@@ -20,24 +20,42 @@ const areasOf = ({ notes, trackCount }) => [
     { role: 'treble-expression', from: track(notes.to + 1), to: track(trackCount) }
 ];
 const scopeOf = (role) => role === 'bass-expression' ? 'bass' : 'treble';
+/**
+ * The bar position a measured place falls on. Places are measured off a
+ * scan and scatter around the grid, while the bar has holes only at whole
+ * positions, so the nearest one is the one uncovered.
+ */
+const snap = (place) => track(Math.round(place));
+/** The positions a span reaches, both ends snapped and the run between them. */
+const positionsBetween = (span) => {
+    const ends = [snap(span.from), snap(span.to ?? span.from)];
+    const [first, last] = [Math.min(...ends), Math.max(...ends)];
+    return Array.from({ length: last - first + 1 }, (_, step) => track(first + step));
+};
 export const describeTrackerBar = (spec) => {
     const areas = areasOf(spec);
-    const roleOf = (position) => areas.find(area => position >= area.from && position <= area.to)?.role;
+    const areaAt = (position) => areas.find(area => position >= area.from && position <= area.to)?.role;
+    const roleOf = (position) => areaAt(snap(position));
     const meaningOf = (position) => {
-        const role = roleOf(position);
+        const place = snap(position);
+        const role = areaAt(place);
         if (!role)
             return undefined;
         if (role === 'note') {
             return {
                 type: 'note',
-                pitch: position - spec.notes.from + spec.notes.lowestPitch
+                pitch: place - spec.notes.from + spec.notes.lowestPitch
             };
         }
-        const expressionType = spec.expressions.get(position);
+        const expressionType = spec.expressions.get(place);
         if (!expressionType)
             return undefined;
         return { type: 'expression', expressionType, scope: scopeOf(role) };
     };
+    const meaningsOf = (span) => positionsBetween(span).flatMap(position => {
+        const meaning = meaningOf(position);
+        return meaning ? [meaning] : [];
+    });
     const positions = new Map(Array.from({ length: spec.trackCount }, (_, i) => track(i + 1))
         .flatMap(position => {
         const meaning = meaningOf(position);
@@ -48,18 +66,32 @@ export const describeTrackerBar = (spec) => {
     if (rewind === undefined) {
         throw new Error(`${spec.name} declares no rewind track`);
     }
+    // A rewind on a line of its own is unambiguous; one sharing a line is only
+    // the rewind when it is far longer than that line's usual command.
+    const shared = spec.rewindTrack !== undefined;
+    const endsAt = (features) => {
+        const hold = spec.rewindHold ?? mm(0);
+        const candidates = features
+            .filter(feature => snap(feature.vertical.from) === rewind)
+            .filter(feature => !shared || feature.horizontal.to - feature.horizontal.from >= hold)
+            .map(feature => feature.horizontal.from);
+        return candidates.length ? { at: mm(Math.min(...candidates)), because: 'rewind' } : undefined;
+    };
     return {
         id: spec.id,
         name: spec.name,
         width: spec.width,
         trackCount: spec.trackCount,
+        endsAt,
         areas,
         expressionTypes: [...new Set(spec.expressions.values())],
         rewindTrack: track(rewind),
         ...(spec.paperSpeed && { paperSpeed: spec.paperSpeed }),
         meaningOf,
+        meaningsOf,
         positionOf: meaning => positions.get(keyOf(meaning)),
-        roleOf
+        roleOf,
+        positionsIn: positionsBetween
     };
 };
 /**

package/lib/alignment.js

@@ -59,8 +59,9 @@ const noteOnsets = (features, bar) => features
     .flatMap((feature) => {
     if (feature.type !== 'Hole')
         return [];
-    const meaning = bar.meaningOf(feature.vertical.from);
-    return meaning?.type === 'note' ? [{ pitch: meaning.pitch, at: feature.horizontal.from }] : [];
+    return bar.meaningsOf(feature.vertical)
+        .filter(meaning => meaning.type === 'note')
+        .map(meaning => ({ pitch: meaning.pitch, at: feature.horizontal.from }));
 })
     .sort(byPlace);
 const median = (values) => {

package/lib/constraints.js

@@ -79,8 +79,10 @@ const carriersOffTheirMeaning = (view, version, perforations) => {
         const copy = view.copyOf(carrier.id);
         if (!copy)
             return false;
-        const meaning = barOf(copy).meaningOf(carrier.vertical.from);
-        return !meaning || keyOf(meaning) !== keyOf(symbol);
+        // A carrier lying across several positions reads as several commands,
+        // and carries the symbol as long as one of them is the symbol's.
+        return !barOf(copy).meaningsOf(carrier.vertical)
+            .some(meaning => keyOf(meaning) === keyOf(symbol));
     };
     return perforations
         .filter(symbol => view.carriersOf(symbol).some(carrier => misread(carrier, symbol)))

package/lib/context.d.ts

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

package/lib/context.js

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

package/lib/readers/phillipsEroll.d.ts

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

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

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

package/lib/systems/velocity.d.ts

@@ -0,0 +1,34 @@
+/**
+ * How bellows travel becomes a MIDI velocity.
+ *
+ * Shared by every Welte system rather than declared per system, and that is a
+ * decision about comparability rather than about accuracy. The point of running
+ * a red issue and a green issue of one recording through two emulators is to
+ * attribute the difference between them to the coding. If the two systems used
+ * two velocity maps, the difference between the maps would dominate and the
+ * comparison would measure the maps.
+ *
+ * Nothing in either mechanism determines the map. These three anchors are
+ * midi2exp's published velocities, joined linearly with the middle one at the
+ * Mezzoforte pin of the half in question, and they are what the T-100's
+ * published results were produced with. Two independent implementations
+ * disagree with them and may well be right: Stahnke gives `v_h = K_s √(w − W_s)`
+ * for vacuum to hammer velocity and `V_MIDI = round(52 + 25 log₂ v_h)` for
+ * velocity to MIDI, and Phillips and Gosden's *Rollmidi*, in the same volume,
+ * uses an explicitly logarithmic curve; Phillips's own bench measurement has the
+ * suction-to-velocity relation "essentially logarithmic" (pp. 215 f.). The
+ * default should change only once a red/green comparison has been run both ways
+ * and the difference measured, and then for both systems at once.
+ */
+export type VelocityMap = {
+    piano: number;
+    mezzoforte: number;
+    forte: number;
+};
+/** midi2exp's three velocities, which is what the T-100's published results used. */
+export declare const defaultVelocityMap: VelocityMap;
+/**
+ * The map joined linearly through its three anchors, with the middle one at the
+ * Mezzoforte pin of the half in question.
+ */
+export declare const velocityOf: (travel: number, hook: number, map: VelocityMap) => number;

package/lib/systems/velocity.js

@@ -0,0 +1,36 @@
+/**
+ * How bellows travel becomes a MIDI velocity.
+ *
+ * Shared by every Welte system rather than declared per system, and that is a
+ * decision about comparability rather than about accuracy. The point of running
+ * a red issue and a green issue of one recording through two emulators is to
+ * attribute the difference between them to the coding. If the two systems used
+ * two velocity maps, the difference between the maps would dominate and the
+ * comparison would measure the maps.
+ *
+ * Nothing in either mechanism determines the map. These three anchors are
+ * midi2exp's published velocities, joined linearly with the middle one at the
+ * Mezzoforte pin of the half in question, and they are what the T-100's
+ * published results were produced with. Two independent implementations
+ * disagree with them and may well be right: Stahnke gives `v_h = K_s √(w − W_s)`
+ * for vacuum to hammer velocity and `V_MIDI = round(52 + 25 log₂ v_h)` for
+ * velocity to MIDI, and Phillips and Gosden's *Rollmidi*, in the same volume,
+ * uses an explicitly logarithmic curve; Phillips's own bench measurement has the
+ * suction-to-velocity relation "essentially logarithmic" (pp. 215 f.). The
+ * default should change only once a red/green comparison has been run both ways
+ * and the difference measured, and then for both systems at once.
+ */
+/** midi2exp's three velocities, which is what the T-100's published results used. */
+export const defaultVelocityMap = { piano: 35, mezzoforte: 60, forte: 90 };
+const clamp = (value, low, high) => Math.min(Math.max(value, low), high);
+/**
+ * The map joined linearly through its three anchors, with the middle one at the
+ * Mezzoforte pin of the half in question.
+ */
+export const velocityOf = (travel, hook, map) => {
+    const position = clamp(travel, 0, 1);
+    if (position <= hook) {
+        return map.piano + (position / hook) * (map.mezzoforte - map.piano);
+    }
+    return map.mezzoforte + ((position - hook) / (1 - hook)) * (map.forte - map.mezzoforte);
+};

package/lib/systems/welteLicensee/system.d.ts

@@ -0,0 +1,46 @@
+import { ReproducingSystem } from "../../ReproducingSystem";
+import { type WelteT100Options } from "../welteT100/system";
+export type WelteLicenseeOptions = WelteT100Options;
+/**
+ * The one instrument on offer, and it is not a Licensee instrument.
+ *
+ * These are the T-100 consensus constants, fitted across the hand-drawn
+ * nuance lines of six rolls played on Freiburg instruments. Nothing here was
+ * measured on a Licensee: no Licensee roll is known to carry a drawn line, no
+ * Licensee instrument has been fitted, and the published prior art does not
+ * agree with itself — the same 186 ms is a part stroke in midi2exp and a whole
+ * stroke in pianolatron, a factor of 2.2.
+ *
+ * So a Licensee playback is a Freiburg reading of American paper, and the
+ * union has one arm to keep that visible. Nothing should be published from it.
+ */
+export declare const instruments: {
+    unfitted: {
+        'welte-t100-consensus': import("welte-mignon-emulator/t100").Instrument;
+    };
+};
+export type WelteLicenseeInstrumentName = {
+    unfitted: 'welte-t100-consensus';
+};
+export declare const instrumentNames: readonly WelteLicenseeInstrumentName[];
+/**
+ * Welte's own spool is carried over with the constants. Phillips (p. 181) says
+ * Licensee rolls "play at a range of paper speeds", so there is no one figure
+ * to put here and the red geometry is a placeholder rather than a reading.
+ * Where an edition states a tempo of its own it is the better authority, and
+ * the spool is better varied than trusted: it scales every conductance by k
+ * and every time constant by 1/k, and touches nothing dimensionless.
+ */
+export declare const defaultWelteLicenseeOptions: WelteLicenseeOptions;
+/**
+ * Welte-Mignon (Licensee), the American re-cut. It keeps the T-100's
+ * lock-and-cancel coding on 98 tracks — which is what separates it from the
+ * green, the coding rule rather than the track count (Phillips, Table 4.3) —
+ * so it reads the same commands and is played by the same mechanism.
+ *
+ * What it does not have is an instrument of its own. The constants are the
+ * T-100's, the spool is the T-100's, and neither has ever been checked against
+ * a Licensee. `instruments` therefore offers a single `unfitted` arm, and every
+ * curve produced here names itself as such.
+ */
+export declare const welteLicenseeSystem: ReproducingSystem<WelteLicenseeOptions>;

package/lib/systems/welteLicensee/system.js

@@ -0,0 +1,60 @@
+import { CONSENSUS } from "welte-mignon-emulator/t100";
+import { track } from "../../Quantity";
+import { welteLicensee } from "./bar";
+import { defaultWelteT100Options, instrumentNameOf, nuanceOf, performAs } from "../welteT100/system";
+/**
+ * The one instrument on offer, and it is not a Licensee instrument.
+ *
+ * These are the T-100 consensus constants, fitted across the hand-drawn
+ * nuance lines of six rolls played on Freiburg instruments. Nothing here was
+ * measured on a Licensee: no Licensee roll is known to carry a drawn line, no
+ * Licensee instrument has been fitted, and the published prior art does not
+ * agree with itself — the same 186 ms is a part stroke in midi2exp and a whole
+ * stroke in pianolatron, a factor of 2.2.
+ *
+ * So a Licensee playback is a Freiburg reading of American paper, and the
+ * union has one arm to keep that visible. Nothing should be published from it.
+ */
+export const instruments = { unfitted: { 'welte-t100-consensus': CONSENSUS } };
+export const instrumentNames = [
+    { unfitted: 'welte-t100-consensus' }
+];
+/**
+ * Welte's own spool is carried over with the constants. Phillips (p. 181) says
+ * Licensee rolls "play at a range of paper speeds", so there is no one figure
+ * to put here and the red geometry is a placeholder rather than a reading.
+ * Where an edition states a tempo of its own it is the better authority, and
+ * the spool is better varied than trusted: it scales every conductance by k
+ * and every time constant by 1/k, and touches nothing dimensionless.
+ */
+export const defaultWelteLicenseeOptions = {
+    ...defaultWelteT100Options,
+    nuance: nuanceOf(CONSENSUS),
+    /**
+     * Two positions lower than the T-100's 54: the Licensee drops the two
+     * motor tracks, so the note block and the treble valves sit two places in
+     * (Hagmann p. 40 f., Phillips p. 123).
+     */
+    division: track(52)
+};
+/** Never the bare name of a T-100 instrument: a curve from here has to say what it ran on. */
+const licenseeInstrument = (nuance) => instrumentNameOf(nuance) === 'consensus'
+    ? 'Welte-Mignon (Licensee), unfitted — Welte-Mignon T-100 consensus'
+    : 'Welte-Mignon (Licensee), custom';
+/**
+ * Welte-Mignon (Licensee), the American re-cut. It keeps the T-100's
+ * lock-and-cancel coding on 98 tracks — which is what separates it from the
+ * green, the coding rule rather than the track count (Phillips, Table 4.3) —
+ * so it reads the same commands and is played by the same mechanism.
+ *
+ * What it does not have is an instrument of its own. The constants are the
+ * T-100's, the spool is the T-100's, and neither has ever been checked against
+ * a Licensee. `instruments` therefore offers a single `unfitted` arm, and every
+ * curve produced here names itself as such.
+ */
+export const welteLicenseeSystem = {
+    name: 'Welte-Mignon (Licensee)',
+    trackerBar: welteLicensee,
+    defaultOptions: defaultWelteLicenseeOptions,
+    perform: performAs(licenseeInstrument)
+};