linked-rolls 0.66.0 → 0.67.0

package/lib/analysis/paper.d.ts

@@ -1,7 +1,7 @@
 import { Edition } from "../model/Edition.js";
 import { Strain } from "../model/RollCopy.js";
 import { LengthRatio } from "../model/Version.js";
-import { Percent } from "../model/Quantity.js";
+import { MetersPerMinute, Percent } from "../model/Quantity.js";
 /**
  * How far the paper of one copy is taken to have stretched or shrunk
  * along the roll, as a standard deviation, where the edition has too few
@@ -121,6 +121,16 @@ export type AlignmentProblem = {
      */
     by?: number;
 };
+/**
+ * The speed the version's paper starts at, as the copies of its own system
+ * that bear witness to it at first hand state they were cut for: the mean
+ * of the speeds the edition holds true or likely. A stated speed is the
+ * speed at the beginning of the roll, as a tempo marking gives it. Nothing
+ * where no such copy states one; in particular, a copy that reaches the
+ * version only through a later one says nothing about it, since the later
+ * one may have been cut for another speed.
+ */
+export declare const paperSpeedOf: (edition: Edition, versionId: string) => MetersPerMinute | undefined;
 /**
  * Where the alignments of the edition's copies, or what they say about
  * the paper, want looking into. None of it is recomputed, so it is cheap

package/lib/analysis/paper.js

@@ -4,8 +4,8 @@ import { certaintyOf, idOf, isAsserted } from "../model/Assumption.js";
 import { principalDerivationOf } from "../model/Version.js";
 import { versionIn } from "../lookup/lookup.js";
 import { witnessesOf } from "./witnesses.js";
-import { inMetersPerMinute, percent } from "../model/Quantity.js";
-import { trackerBarOf } from "../systems/index.js";
+import { inMetersPerMinute, mean, percent } from "../model/Quantity.js";
+import { defaultTrackerBar, trackerBarOf } from "../systems/index.js";
 /**
  * How far the paper of one copy is taken to have stretched or shrunk
  * along the roll, as a standard deviation, where the edition has too few
@@ -217,6 +217,27 @@ const statedSpeed = (copy) => {
     const speed = copy.production?.speed;
     return speed && isAsserted(certaintyOf(speed)) ? inMetersPerMinute(speed) : undefined;
 };
+/**
+ * The speed the version's paper starts at, as the copies of its own system
+ * that bear witness to it at first hand state they were cut for: the mean
+ * of the speeds the edition holds true or likely. A stated speed is the
+ * speed at the beginning of the roll, as a tempo marking gives it. Nothing
+ * where no such copy states one; in particular, a copy that reaches the
+ * version only through a later one says nothing about it, since the later
+ * one may have been cut for another speed.
+ */
+export const paperSpeedOf = (edition, versionId) => {
+    const version = versionIn(edition, versionId);
+    if (!version)
+        return undefined;
+    const system = (trackerBarOf(version.system) ?? defaultTrackerBar).id;
+    const speeds = witnessesOf(edition, versionId)
+        .filter(witness => witness.through === undefined)
+        .flatMap(witness => edition.copies.filter(copy => copy.id === witness.copy && barOf(copy).id === system))
+        .map(statedSpeed)
+        .filter(speed => speed !== undefined);
+    return speeds.length > 0 ? mean(speeds) : undefined;
+};
 /** The speed the reference copy was cut at: as stated for it, or as its system runs. */
 const referenceSpeed = (reference) => {
     const system = barOf(reference).paperSpeed;

package/lib/emulation/Emulation.js

@@ -1,12 +1,15 @@
 import { MIDIControlEvents } from "midifile-ts";
-import { idOf } from "../model/Assumption.js";
+import { certaintyOf, idOf, isAsserted } from "../model/Assumption.js";
 import { isCommand, pairsAmong, placementsOf } from "../model/Symbol.js";
+import { principalDerivationOf } from "../model/Version.js";
 import { add, mean, mm, seconds, subtract } from "../model/Quantity.js";
 import { punchDiameterOf } from "../model/RollCopy.js";
 import { toOwnPaperOf } from "../analysis/ownPaper.js";
+import { paperSpeedOf } from "../analysis/paper.js";
+import { defaultTrackerBar, trackerBarOf } from "../systems/index.js";
 import { negotiatedEventOf } from "./negotiation.js";
 import { placedCarriersOf, snapshotOf } from "../analysis/text.js";
-import { copyOfFeature, symbolIn } from "../lookup/lookup.js";
+import { copyOfFeature, symbolIn, versionIn } from "../lookup/lookup.js";
 /** The punch diameter the edition's copies report, where any of them does. */
 const meanPunchDiameterOf = (edition) => {
     const measured = edition.copies
@@ -14,10 +17,62 @@ const meanPunchDiameterOf = (edition) => {
         .filter(value => value !== undefined);
     return measured.length > 0 ? mean(measured) : undefined;
 };
+/** The version this one derives from, where it names one the edition has. */
+const baseOf = (edition, version) => {
+    const derivation = principalDerivationOf(version);
+    return derivation && versionIn(edition, idOf(derivation));
+};
+const onOneSystem = (one, other) => (trackerBarOf(one.system) ?? defaultTrackerBar).id === (trackerBarOf(other.system) ?? defaultTrackerBar).id;
+/**
+ * The speed the version starts at, as far as the edition states one: as
+ * its own copies state it (`paperSpeedOf`), or else as stated for the
+ * version it derives from on the same system, whose paper it keeps.
+ */
+const statedSpeedOf = (edition, version, seen = new Set()) => {
+    const own = paperSpeedOf(edition, version.id);
+    if (own !== undefined || seen.has(version.id))
+        return own;
+    const base = baseOf(edition, version);
+    return base && onOneSystem(base, version)
+        ? statedSpeedOf(edition, base, new Set([...seen, version.id]))
+        : undefined;
+};
+/**
+ * How long the version's paper runs for a length of the paper of the
+ * version it derives from: as its creation states it where the edition
+ * holds to that, else as the papers the two are performed on relate. That
+ * is what the alignments give for the two systems (`toOwnPaperOf`), which
+ * a performance credits every version of a system with, whether or not its
+ * own copies measure the paper (cf. `lengthRatioOf`).
+ */
+const lengthRatioIn = (edition, version, base) => {
+    const stated = version.creation?.lengthRatio;
+    if (stated && isAsserted(certaintyOf(stated)))
+        return stated.value;
+    const own = toOwnPaperOf(edition, version);
+    const theirs = toOwnPaperOf(edition, base);
+    return own !== undefined && theirs !== undefined ? own / theirs : undefined;
+};
+/**
+ * The roll a re-cut was made from, as far as its timing goes: the length
+ * ratio, and the speed stated for the original. Nothing for a version that
+ * derives from none, or from one on its own system.
+ */
+const recutFromOf = (edition, version) => {
+    const base = baseOf(edition, version);
+    if (!base || onOneSystem(base, version))
+        return undefined;
+    const lengthRatio = lengthRatioIn(edition, version, base);
+    if (lengthRatio === undefined)
+        return undefined;
+    const paperSpeed = statedSpeedOf(edition, base);
+    return { lengthRatio, ...(paperSpeed !== undefined && { paperSpeed }) };
+};
 const propertiesOf = (edition, version) => ({
     punchDiameter: meanPunchDiameterOf(edition),
-    tempo: edition.tempoAdjustment,
-    toOwnPaper: toOwnPaperOf(edition, version)
+    toOwnPaper: toOwnPaperOf(edition, version),
+    paperSpeed: statedSpeedOf(edition, version),
+    recutFrom: recutFromOf(edition, version)
 });
 /** The onset a symbol has on each copy carrying it, by the copy's id, as the mean of its chains there. */
 const onsetsByCopy = (edition, symbolId) => {

package/lib/io/migrate.js

@@ -644,6 +644,18 @@ const withoutFormatVersion = (edition) => {
     const { formatVersion: _stated, ...rest } = edition;
     return rest;
 };
+/**
+ * An edition once stated one tempo for the roll, which cannot hold where the
+ * roll was issued for systems whose papers run at different speeds. A copy
+ * states the speed it was cut for, and a re-cut's follows from its original's
+ * and the length ratio, so the edition's goes.
+ */
+const withoutTempoAdjustment = (edition) => {
+    if (!Object.hasOwn(edition, 'tempoAdjustment'))
+        return edition;
+    const { tempoAdjustment: _stated, ...rest } = edition;
+    return rest;
+};
 /** Whether the copy states features, in either shape. */
 const hasFeatures = (copy) => [copy?.features, copy?.production?.produced, copy?.productionEvent?.produced]
     .some(features => Array.isArray(features) && features.length > 0);
@@ -664,5 +676,5 @@ const withReferenceCopy = (edition) => {
         ? { ...edition, referenceCopy: plainCopyId(reference['@id']) }
         : edition;
 };
-const editionSteps = [withoutFormatVersion, withoutEditionType, withSystems, withEditors, withDerivationTolerance, withReferenceCopy];
+const editionSteps = [withoutFormatVersion, withoutTempoAdjustment, withoutEditionType, withSystems, withEditors, withDerivationTolerance, withReferenceCopy];
 export const migrate = (edition) => walk(editionSteps.reduce((result, step) => step(result), edition));

package/lib/model/Edition.d.ts

@@ -1,8 +1,7 @@
 import { RollCopy } from "./RollCopy.js";
 import { Version } from "./Version.js";
-import { DateAssignment, ObjectAssumption } from "./Assumption.js";
+import { DateAssignment } from "./Assumption.js";
 import { Editor, Person, Place } from "./Agent.js";
-import { RollTempo } from "../systems/ReproducingSystem.js";
 /**
  * This type describes the creation of an edition,
  * i.e. the editor, publisher, and publication date.
@@ -145,12 +144,6 @@ export interface Edition {
      * @see lrmoo:R75 incorporates
      */
     versions: Version[];
-    /**
-     * An optional tempo adjustment for playback of the roll,
-     * annotatable with a belief about its correctness.
-     * @see reo:tempo
-     */
-    tempoAdjustment?: ObjectAssumption<RollTempo>;
 }
 export type EditionMetadata = Pick<Edition, 'base' | 'title' | 'license' | 'creation' | 'roll'>;
 /**

package/lib/model/RollCopy.d.ts

@@ -231,11 +231,14 @@ export interface ProductionEvent {
      */
     system?: Concept;
     /**
-     * The paper speed the copy was cut for. A copy cut from the same
-     * master for another speed comes out longer or shorter than the
-     * roll it is aligned with by the ratio of the speeds. The alignment
-     * measures that ratio far more closely than a label states a speed,
-     * so the speed is held against what the alignments give
+     * The paper speed the copy was cut for, as the speed at the
+     * beginning of the roll: a tempo marking states it so, and the
+     * take-up spool accelerates from there. A performance of a version
+     * the copy bears witness to starts at it (`paperSpeedOf`). A copy cut
+     * from the same master for another speed comes out longer or shorter
+     * than the roll it is aligned with by the ratio of the speeds. The
+     * alignment measures that ratio far more closely than a label states
+     * a speed, so the speed is held against what the alignments give
      * (`alignmentProblems`) rather than used to find it.
      * @see reo:paperSpeed
      */

package/lib/schema.json

@@ -609,11 +609,6 @@
                     "description": "The roll which is edited in this edition.",
                     "ontology": "lrmoo:R3i realises"
                 },
-                "tempoAdjustment": {
-                    "$ref": "#/definitions/ObjectAssumption%3CRollTempo%3E",
-                    "description": "An optional tempo adjustment for playback of the roll, annotatable with a belief about its correctness.",
-                    "ontology": "reo:tempo"
-                },
                 "title": {
                     "description": "The title of the edition.",
                     "examples": [
@@ -2815,101 +2810,6 @@
             ],
             "type": "object"
         },
-        "ObjectAssumption<RollTempo>": {
-            "anyOf": [
-                {
-                    "properties": {
-                        "@annotation": {
-                            "description": "An optional annotation expressing a belief about this assumption. Uses the JSON-LD-star `@annotation` mechanism to attach epistemic metadata (certainty and reasons) to any triple.",
-                            "properties": {
-                                "belief": {
-                                    "$ref": "#/definitions/Belief",
-                                    "description": "The belief held about the annotated statement.",
-                                    "ontology": "crminf:J4i is subject of"
-                                },
-                                "@id": {
-                                    "description": "A unique identifier for this object.",
-                                    "type": "string"
-                                }
-                            },
-                            "required": [
-                                "belief",
-                                "@id"
-                            ],
-                            "type": "object"
-                        },
-                        "endsWith": {
-                            "$ref": "#/definitions/Quantity%3C%22ft%2Fmin%22%3E",
-                            "description": "The tempo at the end of the roll.",
-                            "ontology": "reo:to"
-                        },
-                        "startsWith": {
-                            "$ref": "#/definitions/Quantity%3C%22ft%2Fmin%22%3E",
-                            "description": "The tempo at the beginning of the roll.",
-                            "ontology": "reo:from"
-                        },
-                        "unit": {
-                            "const": "ft/min",
-                            "description": "The unit of the tempo measurement.",
-                            "type": "string",
-                            "ontology": "crm:P91 has unit"
-                        }
-                    },
-                    "required": [
-                        "endsWith",
-                        "startsWith",
-                        "unit"
-                    ],
-                    "type": "object"
-                },
-                {
-                    "properties": {
-                        "@annotation": {
-                            "description": "An optional annotation expressing a belief about this assumption. Uses the JSON-LD-star `@annotation` mechanism to attach epistemic metadata (certainty and reasons) to any triple.",
-                            "properties": {
-                                "belief": {
-                                    "$ref": "#/definitions/Belief",
-                                    "description": "The belief held about the annotated statement.",
-                                    "ontology": "crminf:J4i is subject of"
-                                },
-                                "@id": {
-                                    "description": "A unique identifier for this object.",
-                                    "type": "string"
-                                }
-                            },
-                            "required": [
-                                "belief",
-                                "@id"
-                            ],
-                            "type": "object"
-                        },
-                        "endsWith": {
-                            "$ref": "#/definitions/Quantity%3C%22m%2Fmin%22%3E",
-                            "description": "The tempo at the end of the roll.",
-                            "ontology": "reo:to"
-                        },
-                        "startsWith": {
-                            "$ref": "#/definitions/Quantity%3C%22m%2Fmin%22%3E",
-                            "description": "The tempo at the beginning of the roll.",
-                            "ontology": "reo:from"
-                        },
-                        "unit": {
-                            "const": "m/min",
-                            "description": "The unit of the tempo measurement.",
-                            "type": "string",
-                            "ontology": "crm:P91 has unit"
-                        }
-                    },
-                    "required": [
-                        "endsWith",
-                        "startsWith",
-                        "unit"
-                    ],
-                    "type": "object"
-                }
-            ],
-            "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."
-        },
         "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": {
@@ -3165,7 +3065,7 @@
                 },
                 "speed": {
                     "$ref": "#/definitions/ObjectAssumption%3CPaperSpeed%3E",
-                    "description": "The paper speed the copy was cut for. A copy cut from the same master for another speed comes out longer or shorter than the roll it is aligned with by the ratio of the speeds. The alignment measures that ratio far more closely than a label states a speed, so the speed is held against what the alignments give (`alignmentProblems`) rather than used to find it.",
+                    "description": "The paper speed the copy was cut for, as the speed at the beginning of the roll: a tempo marking states it so, and the take-up spool accelerates from there. A performance of a version the copy bears witness to starts at it (`paperSpeedOf`). A copy cut from the same master for another speed comes out longer or shorter than the roll it is aligned with by the ratio of the speeds. The alignment measures that ratio far more closely than a label states a speed, so the speed is held against what the alignments give (`alignmentProblems`) rather than used to find it.",
                     "ontology": "reo:paperSpeed"
                 },
                 "system": {

package/lib/spec/context.json

@@ -150,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",

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. */
@@ -79,6 +82,21 @@ export type Paper = {
 };
 /** 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;
@@ -101,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;
 };
@@ -111,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. */
@@ -33,6 +33,30 @@ const paperOf = (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
@@ -63,12 +87,12 @@ 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(options.spool, paper.paperOfPlace(place));
+    const at = (place) => secondsAt(spool, paper.paperOfPlace(place));
     return [
         { 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) }
@@ -95,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);
@@ -112,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 = {
@@ -128,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.66.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": {