linked-rolls 0.65.0 → 0.67.0

package/lib/spec/context.json

@@ -89,6 +89,10 @@
                 "used": {
                     "@id": "crm:P16_used_specific_object",
                     "@type": "@id"
+                },
+                "software": {
+                    "@id": "crmdig:L23_used_software_or_firmware",
+                    "@context": { "version": "owl:versionInfo" }
                 }
             }
         },
@@ -99,6 +103,13 @@
         },
         "creation": "lrmoo:R17i_was_created_by",
         "procedure": "crm:P33_used_specific_technique",
+        "lengthRatio": {
+            "@id": "reo:lengthRatio",
+            "@context": {
+                "value": "crm:P90_has_value",
+                "uncertainty": "reo:uncertainty"
+            }
+        },
         "editors": "crm:P14_carried_out_by",
         "publisher": "crm:P14_carried_out_by",
         "publicationDate": {
@@ -139,13 +150,6 @@
         "created": "lrmoo:R17_created",
         "copies": "reo:witness",
         "versions": "lrmoo:R75_incorporates",
-        "tempoAdjustment": {
-            "@id": "reo:tempo",
-            "@context": {
-                "startsWith": "reo:from",
-                "endsWith": "reo:to"
-            }
-        },
         "name": "rdfs:label",
         "sameAs": {
             "@id": "owl:sameAs",
@@ -176,14 +180,7 @@
                 "height": "reo:height",
                 "holeSeparation": "reo:holeSeparation",
                 "scanResolution": "reo:scanResolution",
-                "value": "crm:P90_has_value",
-                "measuredBy": "crmdig:L23_used_software_or_firmware",
-                "software": "rdfs:label",
-                "version": "owl:versionInfo",
-                "date": {
-                    "@id": "dcterms:date",
-                    "@type": "xsd:date"
-                }
+                "value": "crm:P90_has_value"
             }
         },
         "production": {

package/lib/systems/ReproducingSystem.d.ts

@@ -1,32 +1,7 @@
 import { HoleChain } from "../model/Feature.js";
 import { Expression, Note } from "../model/Symbol.js";
 import { TrackerBar } from "./TrackerBar.js";
-import { Millimeters, Quantity, Seconds } from "../model/Quantity.js";
-export type SpeedUnit = 'ft/min' | 'm/min';
-/**
- * The playback tempo of the roll as a paper speed, stated at the
- * beginning and at the end, since the speed may change over the
- * course of the roll through acceleration.
- * @see crm:E54 Dimension
- */
-export interface RollTempoIn<U extends SpeedUnit> {
-    /**
-     * The tempo at the beginning of the roll.
-     * @see reo:from
-     */
-    startsWith: Quantity<U>;
-    /**
-     * The tempo at the end of the roll.
-     * @see reo:to
-     */
-    endsWith: Quantity<U>;
-    /**
-     * The unit of the tempo measurement.
-     * @see crm:P91 has unit
-     */
-    unit: U;
-}
-export type RollTempo = RollTempoIn<'ft/min'> | RollTempoIn<'m/min'>;
+import { MetersPerMinute, Millimeters, Seconds } from "../model/Quantity.js";
 /**
  * A note or expression of a version with the dimensions of its carriers
  * averaged in and the editorial assumptions applied, which is all a
@@ -99,8 +74,26 @@ export type EmulatedCurve = DynamicsCurve | PedalCurve;
 export type RollProperties = {
     /** Diameter of the punches, where the copies record it. */
     punchDiameter?: Millimeters;
-    /** The tempo the edition adjusts the roll to, where it states one. */
-    tempo?: RollTempo;
+    /**
+     * The speed the version's paper starts at, where the copies that bear
+     * witness to it state the speed they were cut for (`paperSpeedOf`), or
+     * failing them those of the version it derives from on the same
+     * system, whose paper it keeps. A stated speed is the speed at the
+     * beginning of the roll, as a tempo marking gives it, and the spool
+     * accelerates from there.
+     */
+    paperSpeed?: MetersPerMinute;
+    /**
+     * Where the version is a re-cut for another system: how long its paper
+     * runs for a length of the paper of the version it derives from, and
+     * the speed stated for that version, if any. A system with no spool of
+     * its own times such a version by these, so that it sounds at the
+     * tempo of the roll it was re-cut from.
+     */
+    recutFrom?: {
+        readonly lengthRatio: number;
+        readonly paperSpeed?: MetersPerMinute;
+    };
     /**
      * Place on the edition's shared axis × this = millimetres of the version's
      * own paper, unstretched. About 0.775 for a green issue of a red

package/lib/systems/welte.d.ts

@@ -1,7 +1,7 @@
 import { Grid, Half, Model, ModelInput, Parameters, PedalInput, PedalMode, PedalTravel, PortGeometry, Spool } from "welte-mignon-emulator";
 import { Expression } from "../model/Symbol.js";
 import { NegotiatedEvent, Performance, RollProperties } from "./ReproducingSystem.js";
-import { Millimeters, Seconds, Track } from "../model/Quantity.js";
+import { MetersPerMinute, Millimeters, Seconds, Track } from "../model/Quantity.js";
 import { type VelocityMap } from "./velocity.js";
 /**
  * What the Welte systems share downstream of the relay. Hagmann has the
@@ -15,6 +15,9 @@ export type WelteOptions = {
     /**
      * The take-up spool, which sets the time axis: it is held at a constant
      * rate of revolution, so the paper runs faster as the spool fills.
+     * Where a speed is stated for the version's copies, or a re-cut is timed
+     * by the roll it was made from, the spool is started at that speed and
+     * only its geometry is taken from here; see `spoolFor`.
      */
     spool: Spool;
     /** Constants of the nuancing mechanism, one set for each half of the keyboard. */
@@ -67,15 +70,33 @@ export declare const pedalPresetOf: (pedals: Parameters) => PedalPreset | undefi
  *
  * Rows are rows of the version's own paper, so the spool is asked in
  * `paperOfRow` and never in `placeOfRow`: one is the paper that passes the
- * tracker bar, the other is the coordinate the edition states.
+ * tracker bar, the other is the coordinate the edition states. A place is
+ * put to the spool through `paperOfPlace` for the same reason, so that a
+ * note sounds on the clock its pedal and bellows run on.
  */
 export type Paper = {
     readonly rowOf: (place: Millimeters) => number;
     readonly placeOfRow: (row: number) => Millimeters;
     readonly paperOfRow: (row: number) => Millimeters;
+    readonly paperOfPlace: (place: Millimeters) => Millimeters;
 };
 /** When the spool brings a place on the roll to the tracker bar. */
 export declare const secondsAt: (spool: Spool, place: Millimeters) => Seconds;
+/** The speed the spool starts the paper at. */
+export declare const startingSpeedOf: (spool: Spool) => MetersPerMinute;
+/**
+ * The spool a version runs on.
+ *
+ * A speed stated for the version's copies is where it starts, as a tempo
+ * marking is the speed at the beginning of the roll. Failing that, a system
+ * whose spool is a reading of its own instruments runs on it as it stands:
+ * the red and the green spool are both calibrated at Welte's Tempo 70. A
+ * system with no spool of its own, as the Licensee has none, times a re-cut
+ * by the roll it was re-cut from, at that roll's stated speed or else the
+ * spool's own, shortened by the length ratio, so that it sounds at the tempo
+ * of the original. Where none of this applies the spool stands as given.
+ */
+export declare const spoolFor: (spool: Spool, roll: RollProperties, ownSpool: boolean) => Spool;
 /** A perforation as the emulator reads it: the control it operates and the rows it spans. */
 export type WeltePunch = {
     readonly half: Half;
@@ -98,6 +119,12 @@ export type Mechanism<P extends WeltePunch> = {
     readonly portsOf: (grid: Grid, punches: readonly P[], geometry: PortGeometry) => Ports;
     readonly model: Model;
     readonly runPedals: (input: PedalInput, params: Parameters) => PedalTravel;
+    /**
+     * Whether the spool in the options is a reading of this system's own
+     * instruments. Where it is not, a re-cut is timed by the roll it was
+     * re-cut from (`spoolFor`).
+     */
+    readonly ownSpool: boolean;
     /** The name of the instrument the curves say they came from. */
     readonly instrument: string;
 };
@@ -108,10 +135,7 @@ export type WeltePerformance = Performance & {
 };
 /**
  * Plays the events on a Welte mechanism: notes at the velocity of their half's
- * bellows, and the two pedals as the travel of theirs.
- *
- * The edition's tempo adjustment is left aside: it is stated as a paper
- * speed, and what the spool holds constant is its rate of revolution, so
- * the two are not the same quantity. The spool in the options sets the speed.
+ * bellows, and the two pedals as the travel of theirs, on the spool
+ * `spoolFor` gives the version.
  */
 export declare const performWelte: <P extends WeltePunch>(events: readonly NegotiatedEvent[], options: WelteOptions, roll: RollProperties, mechanism: Mechanism<P>) => WeltePerformance;

package/lib/systems/welte.js

@@ -1,5 +1,5 @@
-import { clamp, geometryInMm, Grid, levelChanges, mezzoforteTravel, paperSeconds, pedalBrushing, pedalDefaults, ROWS_PER_MM, travelBetweenRails, } from "welte-mignon-emulator";
-import { inCentimeters, mm, seconds } from "../model/Quantity.js";
+import { clamp, geometryInMm, Grid, levelChanges, mezzoforteTravel, paperSeconds, paperSpeed, pedalBrushing, pedalDefaults, ROWS_PER_MM, travelBetweenRails, } from "welte-mignon-emulator";
+import { inCentimeters, metersPerMinute, mm, seconds } from "../model/Quantity.js";
 import { partitionPoint } from "../shared/sorted.js";
 import { velocityOf } from "./velocity.js";
 /** Whether two sets of constants are the same, value for value. */
@@ -28,10 +28,35 @@ const isExpression = (event) => event.type === 'expression';
 const paperOf = (toOwnPaper) => ({
     rowOf: place => place * toOwnPaper * ROWS_PER_MM,
     placeOfRow: row => mm(row / (toOwnPaper * ROWS_PER_MM)),
-    paperOfRow: row => mm(row / ROWS_PER_MM)
+    paperOfRow: row => mm(row / ROWS_PER_MM),
+    paperOfPlace: place => mm(place * toOwnPaper)
 });
 /** When the spool brings a place on the roll to the tracker bar. */
 export const secondsAt = (spool, place) => seconds(paperSeconds(spool, inCentimeters(place)));
+/** The speed the spool starts the paper at. */
+export const startingSpeedOf = (spool) => metersPerMinute(paperSpeed(spool, 0) * 60 / 100);
+/** The spool turned so that it starts the paper at the speed, its geometry and acceleration kept. */
+const startingAt = (spool, speed) => ({ ...spool, revolutionSeconds: spool.circumferenceCm / (speed * 100 / 60) });
+/**
+ * The spool a version runs on.
+ *
+ * A speed stated for the version's copies is where it starts, as a tempo
+ * marking is the speed at the beginning of the roll. Failing that, a system
+ * whose spool is a reading of its own instruments runs on it as it stands:
+ * the red and the green spool are both calibrated at Welte's Tempo 70. A
+ * system with no spool of its own, as the Licensee has none, times a re-cut
+ * by the roll it was re-cut from, at that roll's stated speed or else the
+ * spool's own, shortened by the length ratio, so that it sounds at the tempo
+ * of the original. Where none of this applies the spool stands as given.
+ */
+export const spoolFor = (spool, roll, ownSpool) => {
+    if (roll.paperSpeed !== undefined)
+        return startingAt(spool, roll.paperSpeed);
+    if (ownSpool || !roll.recutFrom)
+        return spool;
+    const { lengthRatio, paperSpeed: original = startingSpeedOf(spool) } = roll.recutFrom;
+    return startingAt(spool, metersPerMinute(original * lengthRatio));
+};
 const halfOf = (note, division) => note.vertical.from >= division ? 'treble' : 'bass';
 /**
  * One sample per row of the scan the constants were fitted on, from the
@@ -62,14 +87,15 @@ const nuanceCurves = (grid, ports, samples, options, model, instrument) => {
     };
     return { bass: curveOf('bass'), treble: curveOf('treble') };
 };
-const performNotes = (events, grid, nuance, options, paper) => events
+const performNotes = (events, grid, nuance, options, paper, spool) => events
     .filter(isNote)
     .flatMap((note) => {
     const curve = nuance[halfOf(note, options.division)];
     const velocity = curve.velocity[grid.indexOfRow(paper.rowOf(note.horizontal.from))];
+    const at = (place) => secondsAt(spool, paper.paperOfPlace(place));
     return [
-        { type: 'noteOn', performs: note, pitch: note.pitch, velocity, at: secondsAt(options.spool, note.horizontal.from) },
-        { type: 'noteOff', performs: note, pitch: note.pitch, velocity: 127, at: secondsAt(options.spool, note.horizontal.to) }
+        { type: 'noteOn', performs: note, pitch: note.pitch, velocity, at: at(note.horizontal.from) },
+        { type: 'noteOff', performs: note, pitch: note.pitch, velocity: 127, at: at(note.horizontal.to) }
     ];
 });
 /**
@@ -93,11 +119,8 @@ const performPedal = (type, curve, grid, readings, mode) => {
 };
 /**
  * Plays the events on a Welte mechanism: notes at the velocity of their half's
- * bellows, and the two pedals as the travel of theirs.
- *
- * The edition's tempo adjustment is left aside: it is stated as a paper
- * speed, and what the spool holds constant is its rate of revolution, so
- * the two are not the same quantity. The spool in the options sets the speed.
+ * bellows, and the two pedals as the travel of theirs, on the spool
+ * `spoolFor` gives the version.
  */
 export const performWelte = (events, options, roll, mechanism) => {
     const paper = paperOf(roll.toOwnPaper ?? 1);
@@ -110,7 +133,8 @@ export const performWelte = (events, options, roll, mechanism) => {
         });
         return punch ? [{ event, punch }] : [];
     });
-    const grid = gridOver(events, options.spool, paper);
+    const spool = spoolFor(options.spool, roll, mechanism.ownSpool);
+    const grid = gridOver(events, spool, paper);
     const geometry = geometryInMm(roll.punchDiameter ?? options.punchDiameter, options.trackerBore);
     const ports = mechanism.portsOf(grid, readings.map(reading => reading.punch), geometry);
     const samples = {
@@ -126,7 +150,7 @@ export const performWelte = (events, options, roll, mechanism) => {
         grid,
         ports,
         events: [
-            ...performNotes(events, grid, nuance, options, paper),
+            ...performNotes(events, grid, nuance, options, paper, spool),
             ...performPedal('damper', damper, grid, readingsOf('sustainPedal'), options.pedalMode),
             ...performPedal('hammerRail', hammerRail, grid, readingsOf('hammerRail'), options.pedalMode)
         ],

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

@@ -27,9 +27,13 @@ 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.
+ * It is therefore never played as it stands where anything better is known:
+ * a speed stated for the version's copies, as a Licensee label states its
+ * tempo, sets where it starts, and failing that a re-cut runs at the speed of
+ * the roll it was re-cut from times the length ratio, so that it sounds at
+ * that roll's tempo (`spoolFor`). Either way only its geometry is used, and
+ * that 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;
 /**
@@ -41,6 +45,8 @@ export declare const defaultWelteLicenseeOptions: WelteLicenseeOptions;
  * 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.
+ * curve produced here names itself as such. The spool sets no tempo of its
+ * own: a version runs at the speed stated for its copies, or at that of the
+ * roll it was re-cut from times the length ratio.
  */
 export declare const welteLicenseeSystem: ReproducingSystem<WelteLicenseeOptions>;

package/lib/systems/welteLicensee/system.js

@@ -23,9 +23,13 @@ export const instrumentNames = [
  * 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.
+ * It is therefore never played as it stands where anything better is known:
+ * a speed stated for the version's copies, as a Licensee label states its
+ * tempo, sets where it starts, and failing that a re-cut runs at the speed of
+ * the roll it was re-cut from times the length ratio, so that it sounds at
+ * that roll's tempo (`spoolFor`). Either way only its geometry is used, and
+ * that 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,
@@ -50,11 +54,13 @@ const licenseeInstrument = (nuance) => instrumentNameOf(nuance) === 'consensus'
  * 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.
+ * curve produced here names itself as such. The spool sets no tempo of its
+ * own: a version runs at the speed stated for its copies, or at that of the
+ * roll it was re-cut from times the length ratio.
  */
 export const welteLicenseeSystem = {
     name: 'Welte-Mignon (Licensee)',
     trackerBar: welteLicensee,
     defaultOptions: defaultWelteLicenseeOptions,
-    perform: performAs(licenseeInstrument)
+    perform: performAs(licenseeInstrument, false)
 };

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

@@ -24,12 +24,13 @@ export type WelteT100Options = WelteOptions;
 export declare const defaultWelteT100Options: WelteT100Options;
 /**
  * The mechanism, given a way of naming the instrument on the curves it
- * produces. The Licensee reads the same commands and is played by the same
- * valves, so it shares this; what it may not share is the name, since a
- * Licensee playback runs on constants fitted to Freiburg instruments and the
- * curve has to say so.
+ * produces and whether the spool it is given is that instrument's own. The
+ * Licensee reads the same commands and is played by the same valves, so it
+ * shares this; what it may not share is the name, since a Licensee playback
+ * runs on constants fitted to Freiburg instruments and the curve has to say
+ * so, nor the spool, which is the red one it carries over.
  */
-export declare const performAs: (instrumentOf: (nuance: Record<Half, Parameters>) => string) => (events: readonly NegotiatedEvent[], options: WelteT100Options, roll: RollProperties) => Performance;
+export declare const performAs: (instrumentOf: (nuance: Record<Half, Parameters>) => string, ownSpool?: boolean) => (events: readonly NegotiatedEvent[], options: WelteT100Options, roll: RollProperties) => Performance;
 /**
  * The red Welte, as welte-mignon-emulator models it: the take-up spool sets
  * the time axis, the Nuancierbälge fill through their conduits and are

package/lib/systems/welteT100/system.js

@@ -55,17 +55,19 @@ const punchOf = (event, rows) => {
 };
 /**
  * The mechanism, given a way of naming the instrument on the curves it
- * produces. The Licensee reads the same commands and is played by the same
- * valves, so it shares this; what it may not share is the name, since a
- * Licensee playback runs on constants fitted to Freiburg instruments and the
- * curve has to say so.
+ * produces and whether the spool it is given is that instrument's own. The
+ * Licensee reads the same commands and is played by the same valves, so it
+ * shares this; what it may not share is the name, since a Licensee playback
+ * runs on constants fitted to Freiburg instruments and the curve has to say
+ * so, nor the spool, which is the red one it carries over.
  */
-export const performAs = (instrumentOf) => (events, options, roll) => {
+export const performAs = (instrumentOf, ownSpool = true) => (events, options, roll) => {
     const { events: performed, curves } = performWelte(events, options, roll, {
         punchOf,
         portsOf: aperturePorts,
         model: pneumaticModel,
         runPedals,
+        ownSpool,
         instrument: instrumentOf(options.nuance)
     });
     return { events: performed, curves };

package/lib/systems/welteT98/system.js

@@ -110,6 +110,7 @@ const perform = (events, options, roll) => {
         portsOf: (grid, punches, geometry) => aperturePorts(grid, punches, geometry, gap),
         model: pneumaticT98Model,
         runPedals,
+        ownSpool: true,
         instrument: `Welte-Mignon T-98, ${labelOf(options.instrument)}`
     });
     const stops = rewindRow(grid, ports, options);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linked-rolls",
-  "version": "0.65.0",
+  "version": "0.67.0",
   "description": "Digital editions of piano rolls: import, collation, editorial assumptions, JSON-LD export, and emulation through a reproducing system",
   "license": "MIT",
   "repository": {