linked-rolls 0.65.0 → 0.66.0

package/README.md

@@ -55,6 +55,14 @@ between the two. What the alignments say about the paper of the copies,
 how far each has stretched and how the papers of the systems relate, is
 worked out by `paperOf`.
 
+What is worked out is not stated. Where the edition holds to the ratio a
+re-cut gave the paper of its version, the creation of the version states
+it (`lengthRatio`, as `lengthRatioOf` gives it), so that others can take
+it as a premise. A measured value, such as that ratio, a copy's
+dimensions and hole separation, or the setting of its perforator, is
+held on the strength of a measurement, which names what it was taken
+on, the program and its version, and the day.
+
 Documents written by earlier releases are brought up to date on import.
 To check a document against the schema:
 

package/lib/analysis/paper.d.ts

@@ -1,5 +1,6 @@
 import { Edition } from "../model/Edition.js";
 import { Strain } from "../model/RollCopy.js";
+import { LengthRatio } from "../model/Version.js";
 import { Percent } from "../model/Quantity.js";
 /**
  * How far the paper of one copy is taken to have stretched or shrunk
@@ -127,3 +128,19 @@ export type AlignmentProblem = {
  * is `alignmentFor`'s to say.
  */
 export declare const alignmentProblems: (edition: Pick<Edition, 'copies' | 'referenceCopy'>) => AlignmentProblem[];
+/**
+ * How long the version's paper runs for a length of the paper of the
+ * version it derives from, as the alignments give it: the ratio of the
+ * two versions' systems' papers, with its uncertainty. It is what the
+ * creation of the version states where the edition holds to it
+ * (`VersionCreation.lengthRatio`).
+ *
+ * The reading pools the copies of a system, so the ratio is only given
+ * for a version that one of those copies bears witness to: a second
+ * re-cut for the same system, whose copies measure no paper, is not
+ * credited with the first one's ratio. Where the reading has copies of
+ * two versions re-cut for one system, the ratio is theirs together.
+ * Nothing is given for a version that derives from none, or from one on
+ * its own system, whose paper it keeps.
+ */
+export declare const lengthRatioOf: (edition: Edition, versionId: string) => LengthRatio | undefined;

package/lib/analysis/paper.js

@@ -1,7 +1,11 @@
 import { referenceCopyOf } from "../model/Edition.js";
 import { barOf, featuresOf, paperStretchOf } from "../model/RollCopy.js";
-import { certaintyOf, isAsserted } from "../model/Assumption.js";
+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";
 /**
  * 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
@@ -258,3 +262,36 @@ export const alignmentProblems = (edition) => {
     });
     return [...unaligned, ...elsewhere, ...beyond, ...speeds];
 };
+/**
+ * How long the version's paper runs for a length of the paper of the
+ * version it derives from, as the alignments give it: the ratio of the
+ * two versions' systems' papers, with its uncertainty. It is what the
+ * creation of the version states where the edition holds to it
+ * (`VersionCreation.lengthRatio`).
+ *
+ * The reading pools the copies of a system, so the ratio is only given
+ * for a version that one of those copies bears witness to: a second
+ * re-cut for the same system, whose copies measure no paper, is not
+ * credited with the first one's ratio. Where the reading has copies of
+ * two versions re-cut for one system, the ratio is theirs together.
+ * Nothing is given for a version that derives from none, or from one on
+ * its own system, whose paper it keeps.
+ */
+export const lengthRatioOf = (edition, versionId) => {
+    const version = versionIn(edition, versionId);
+    const derivation = version && principalDerivationOf(version);
+    const base = derivation && versionIn(edition, idOf(derivation));
+    const reading = paperOf(edition);
+    if (!version || !base || !reading)
+        return undefined;
+    const systemOf = (of) => reading.systems.find(paper => paper.system === trackerBarOf(of.system)?.id);
+    const own = systemOf(version);
+    const theirs = systemOf(base);
+    if (!own || !theirs || own.system === theirs.system)
+        return undefined;
+    const witnesses = new Set(witnessesOf(edition, versionId).map(witness => witness.copy));
+    if (!own.copies.some(copy => witnesses.has(copy)))
+        return undefined;
+    const value = own.ratio / theirs.ratio;
+    return { value, uncertainty: value * Math.hypot(own.ratioError / own.ratio, theirs.ratioError / theirs.ratio) };
+};

package/lib/analysis/reservations.js

@@ -1,5 +1,5 @@
 import { bearsPhysicalEvidence, isMeasured, sourceLabels } from "../model/FeatureSource.js";
-import { calibrationOf, featuresOf } from "../model/RollCopy.js";
+import { calibrationOf, featuresOf, measuringSoftwareOf } from "../model/RollCopy.js";
 import { trackerBarOf } from "../systems/index.js";
 import { witnessesOf } from "./witnesses.js";
 export const reservationTypes = [
@@ -49,7 +49,7 @@ const physicalEvidence = copy => copy.readFrom && !bearsPhysicalEvidence(copy.re
     type: 'no-physical-evidence',
     note: 'Punch diameter, hole separation, punching pattern, marks and writings cannot be observed on this source.'
 } : undefined;
-const measurementDocumented = copy => !copy.measurements.measuredBy && copy.readFrom?.kind !== 'roll' ? {
+const measurementDocumented = copy => measuringSoftwareOf(copy).length === 0 && copy.readFrom?.kind !== 'roll' ? {
     type: 'measurement-undocumented',
     note: 'No measuring software is recorded for this copy.'
 } : undefined;

package/lib/io/migrate.js

@@ -1,3 +1,4 @@
+import { v4 } from "uuid";
 import { systemIdIn, systemOf, translationBetween } from "../systems/TrackerBar.js";
 import { trackerBars } from "../systems/index.js";
 import { welteT100 } from "../systems/welteT100/bar.js";
@@ -451,9 +452,61 @@ const withTimeSpanDates = (node) => {
     const { '@value': within, '@type': _typed, ...rest } = node;
     return { ...rest, within };
 };
+/** The values a copy's one `measuredBy` stood for, of those the edition exports: what the analysis it named had given. */
+const measuredByCovered = ['dimensions', 'holeSeparation'];
+/** A day written as a date, of a date written with or without its time. */
+const dayOf = (date) => typeof date === 'string' && /^\d{4}-\d{2}-\d{2}/.test(date) ? date.slice(0, 10) : undefined;
+/**
+ * A copy once named one program for all its measurements, beside values
+ * that could not say what took them. Each value the edition exports now
+ * carries the measurement it rests on, so the program, its version and
+ * the day go into the reasons of the dimensions and the hole separation,
+ * which the analysis it named had given. The scan resolution is read
+ * off the file rather than measured, and the margins are not exported;
+ * nothing is said of them. The ids are the copy's, so that migrating a
+ * file twice writes the same document.
+ */
+const withMeasuredByInReasons = (node) => {
+    const measurements = node?.measurements;
+    if (!measurements || typeof measurements !== 'object' || !Object.hasOwn(measurements, 'measuredBy'))
+        return node;
+    const { measuredBy, ...rest } = measurements;
+    const day = dayOf(measuredBy?.date);
+    const reason = measuredBy?.software && {
+        '@type': 'measurement',
+        software: [{ name: measuredBy.software, ...(measuredBy.version && { version: measuredBy.version }) }],
+        ...(day && { date: { within: day } })
+    };
+    const owner = typeof node['@id'] === 'string' ? plainCopyId(node['@id']) : v4();
+    const withReason = (key, value) => {
+        if (!reason || !value || typeof value !== 'object')
+            return value;
+        const annotation = value['@annotation'];
+        if (annotation?.belief) {
+            return { ...value, '@annotation': { ...annotation, belief: { ...annotation.belief, reasons: [...(annotation.belief.reasons ?? []), reason] } } };
+        }
+        return {
+            ...value,
+            '@annotation': {
+                '@id': `${owner}-${key}-annotation`,
+                belief: { '@type': 'belief', '@id': `${owner}-${key}-belief`, certainty: 'true', reasons: [reason] }
+            }
+        };
+    };
+    return {
+        ...node,
+        measurements: {
+            ...rest,
+            ...Object.fromEntries(measuredByCovered
+                .filter(key => Object.hasOwn(rest, key))
+                .map(key => [key, withReason(key, rest[key])]))
+        }
+    };
+};
 const nodeSteps = [withRenamedKeys, withRenamedEditType, withTypology, withRenamedType, withoutVersionType, withoutVersionSiglum, withLowerCaseTerms, withSplitMethod, withReferences, withKeeper, withoutEmptyKeeper,
     withPerforator, withProductionNodes, withTypedPerforator, withScale, withoutOps, withDerivationList, withReadingKind, withTimeSpanDates,
-    withoutFeatureKind, withBorneFeaturesNamed, withFeaturesInActs, withOwnPlaces, withDriveOfStaggering, withoutPattern, withoutBearings, withoutEntailedType];
+    withoutFeatureKind, withBorneFeaturesNamed, withFeaturesInActs, withOwnPlaces, withDriveOfStaggering, withoutPattern, withoutBearings, withoutEntailedType,
+    withMeasuredByInReasons];
 const migrateNode = (node) => nodeSteps.reduce((result, step) => step(result), node);
 /** The value with every node in it migrated, a node before its children; the very same value where nothing changed. */
 const walk = (value) => {

package/lib/model/Agent.d.ts

@@ -78,4 +78,21 @@ export interface Place extends Named {
  * @see crm:E55 Type
  */
 export type Concept = (WithId & Partial<Named>) | (Named & Partial<WithId>);
+/**
+ * Software that captured a copy or measured it: the transcriber that
+ * read a recording into notes, the emulator that wrote a MIDI file, the
+ * program that found the holes on a scan or aligned two copies.
+ * @see crmdig:D14 Software
+ */
+export interface Software {
+    /**
+     * @see rdfs:label
+     */
+    name: string;
+    /**
+     * The release, the commit, or the model checkpoint of a transcriber.
+     * @see owl:versionInfo
+     */
+    version?: string;
+}
 export {};

package/lib/model/Assumption.d.ts

@@ -1,5 +1,5 @@
 import { WithNote, WithId } from "../shared/utils.js";
-import { Person, WithActor } from "./Agent.js";
+import { Concept, Person, Software, WithActor } from "./Agent.js";
 export declare const certainties: readonly ['true', 'likely', 'possible', 'unlikely', 'false'];
 /**
  * Certainty levels for beliefs, ranging from 'true' to 'false'
@@ -102,6 +102,11 @@ export interface BeliefAdoption extends Argumentation<'beliefAdoption'> {
  * premises. CRMinf counts observations, and a measurement is one, among
  * the ways a belief comes about, so the value does not have to be
  * passed off as an inference.
+ *
+ * A measurement a program took names the program and its version, so
+ * that the value can be taken again and a value taken by a program
+ * later found wanting can be told from the rest. Naming software makes
+ * it a digital measurement event in the sense of CRMdig.
  * @see crmsci:S21 Measurement
  */
 export interface Measurement extends Argumentation<'measurement'> {
@@ -111,6 +116,24 @@ export interface Measurement extends Argumentation<'measurement'> {
      * @see crm:P16 used specific object
      */
     used?: string[];
+    /**
+     * The method followed, where it has a name apart from the program
+     * that carries it out, such as a line of Theil and Sen through the
+     * matched notes of two copies.
+     * @see crm:P33 used specific technique
+     */
+    procedure?: Concept;
+    /**
+     * The programs that took the measurement, each with its version.
+     * @see crmdig:L23 used software or firmware
+     */
+    software?: Software[];
+    /**
+     * When the measurement was taken. It is part of the reason and
+     * carries no belief of its own.
+     * @see crm:P4 has time-span
+     */
+    date?: TimeSpan;
 }
 /**
  * An argumentation can be either a plain argumentation, a
@@ -185,7 +208,6 @@ export type ObjectAssumption<O extends object> = Assumption & O;
  * annotated with a belief about its certainty.
  */
 export type ActorAssignment = ObjectAssumption<Person>;
-/** The day an event falls within. */
 interface DateWithin {
     /**
      * The day the event falls within.
@@ -194,8 +216,7 @@ interface DateWithin {
      */
     within: Date;
 }
-/** The bounds an event lies between. */
-interface DateBounds {
+interface DateAfter {
     /**
      * The earliest day the event can have happened on: it did not
      * happen before it.
@@ -203,6 +224,22 @@ interface DateBounds {
      * @see crm:P82a begin of the begin
      */
     after: Date;
+    /**
+     * The latest day the event can have happened on: it did not
+     * happen after it.
+     * @format date
+     * @see crm:P82b end of the end
+     */
+    before?: Date;
+}
+interface DateBefore {
+    /**
+     * The earliest day the event can have happened on: it did not
+     * happen before it.
+     * @format date
+     * @see crm:P82a begin of the begin
+     */
+    after?: Date;
     /**
      * The latest day the event can have happened on: it did not
      * happen after it.
@@ -212,12 +249,20 @@ interface DateBounds {
     before: Date;
 }
 /**
- * When something happened, as far as the edition can state it: the day
- * it falls `within`, or the bounds it lies between. A bound nobody can
- * give is left out, so `after` alone says "not before".
+ * When something happened: the day it falls `within`, or the bounds it
+ * lies between. A bound nobody can give is left out, so `after` alone
+ * says "not before".
+ * @see crm:E52 Time-Span
+ */
+export type TimeSpan = DateWithin | DateAfter | DateBefore;
+/**
+ * When something happened, as far as the edition can state it, and as
+ * an assumption, so that a dating can carry the belief it rests on: the
+ * day it falls `within`, or the bounds it lies between. A bound nobody
+ * can give is left out, so `after` alone says "not before".
  * @see crm:E52 Time-Span
  */
-export type DateAssignment = Assumption & (DateWithin | (Pick<DateBounds, 'after'> & Partial<Pick<DateBounds, 'before'>>) | (Pick<DateBounds, 'before'> & Partial<Pick<DateBounds, 'after'>>));
+export type DateAssignment = Assumption & TimeSpan;
 export declare function valueOf<ValueT>(assumption: ValueAssumption<ValueT>): ValueT;
 export declare function valuesOf<ValueT>(assumptions: ValueAssumption<ValueT>[]): ValueT[];
 export declare function idOf(assumption: ReferenceAssumption): string;

package/lib/model/FeatureSource.d.ts

@@ -1,5 +1,5 @@
 import { ActorAssignment, DateAssignment, ObjectAssumption } from "./Assumption.js";
-import { Concept, Named } from "./Agent.js";
+import { Concept, Named, Software } from "./Agent.js";
 import { ConditionState } from "./ConditionState.js";
 import { WithNote } from "../shared/utils.js";
 /**
@@ -25,22 +25,7 @@ export declare const isMeasured: (kind: SourceKind) => boolean;
  * be observed on the roll and on an image of it, and on nothing else.
  */
 export declare const bearsPhysicalEvidence: (kind: SourceKind) => boolean;
-/**
- * Software a capture ran, such as the transcriber that read a recording
- * into notes or the emulator that wrote a MIDI file.
- * @see crmdig:D14 Software
- */
-export interface Software {
-    /**
-     * @see rdfs:label
-     */
-    name: string;
-    /**
-     * The release, or the model checkpoint of a transcriber.
-     * @see owl:versionInfo
-     */
-    version?: string;
-}
+export type { Software } from "./Agent.js";
 /**
  * An instrument a copy was played on to be recorded. How it was
  * regulated, where that is known, is its condition.

package/lib/model/RollCopy.d.ts

@@ -5,7 +5,7 @@ import { TrackCalibration } from "./TrackCalibration.js";
 import { AnyFeature, FeatureOrPatch, HorizontalSpan, Patch } from "./Feature.js";
 import { ActorAssignment, DateAssignment, ObjectAssumption, ReferenceAssumption } from "./Assumption.js";
 import { WithId, WithType } from "../shared/utils.js";
-import { Agent, Concept } from "./Agent.js";
+import { Agent, Concept, Software } from "./Agent.js";
 import { FeatureSource } from "./FeatureSource.js";
 import { Measure, Millimeters, Percent, Quantity, Track } from "./Quantity.js";
 import { Perforator } from "./Perforator.js";
@@ -161,6 +161,28 @@ export interface Alignment {
         date: Date;
     };
 }
+/**
+ * The width and length of a roll copy's paper, as they were measured on
+ * it or on its scan.
+ * @see crm:E54 Dimension
+ */
+export interface RollDimensions {
+    /**
+     * The width of the roll.
+     * @see reo:width
+     */
+    width: Millimeters;
+    /**
+     * The total height (length) of the roll.
+     * @see reo:height
+     */
+    height: Millimeters;
+    /**
+     * The unit of measurement.
+     * @see crm:P91 has unit
+     */
+    unit: 'mm';
+}
 /** The margins on the treble and bass sides of the roll, in the unit the scan was measured in. */
 export interface Margins<U extends 'px' | 'mm'> {
     treble: Quantity<U>;
@@ -307,11 +329,14 @@ export type Modification = Partial<{
  */
 export interface RollCopy extends WithType<'RollCopy'>, WithId {
     /**
-     * Physical measurements of this roll copy, including
-     * dimensions, hole separation, margins, the alignment onto the
-     * edition's axis, and information about the measuring software. What the
-     * perforations tell about the machine that cut them is stated
-     * with the production.
+     * Physical measurements of this roll copy: its dimensions, hole
+     * separation and margins, the resolution of its scan, and how it
+     * lies on the edition's axis. What the perforations tell about the
+     * machine that cut them is stated with the production.
+     *
+     * A value the edition exports is an object assumption, so that it
+     * can say what took it: a measurement naming the program and its
+     * version, the scan or analysis it was taken on, and the day.
      * @see crm:P39i was measured by
      */
     measurements: Partial<{
@@ -319,23 +344,7 @@ export interface RollCopy extends WithType<'RollCopy'>, WithId {
          * The physical dimensions of the roll.
          * @see reo:dimensions
          */
-        dimensions: {
-            /**
-             * The width of the roll.
-             * @see reo:width
-             */
-            width: Millimeters;
-            /**
-             * The total height (length) of the roll.
-             * @see reo:height
-             */
-            height: Millimeters;
-            /**
-             * The unit of measurement.
-             * @see crm:P91 has unit
-             */
-            unit: 'mm';
-        };
+        dimensions: ObjectAssumption<RollDimensions>;
         /**
          * The distance across the roll from the centre of one track to
          * the next, the track pitch or Teilung, in the unit the scan was
@@ -344,7 +353,7 @@ export interface RollCopy extends WithType<'RollCopy'>, WithId {
          * along the roll.
          * @see reo:holeSeparation
          */
-        holeSeparation: Measure<'px'> | Measure<'mm'>;
+        holeSeparation: ObjectAssumption<Measure<'px'> | Measure<'mm'>>;
         /**
          * The margins on the treble and bass sides of the roll.
          * Not exported to RDF.
@@ -389,35 +398,13 @@ export interface RollCopy extends WithType<'RollCopy'>, WithId {
          * files do not state.
          * @see reo:scanResolution
          */
-        scanResolution: Measure<'px/in'>;
+        scanResolution: ObjectAssumption<Measure<'px/in'>>;
         /**
          * Relates this copy's scan to the tracker bar: how the scanning
          * software's hole numbering was shifted onto the bar, and where
          * the track grid sits in the image. Not exported to RDF.
          */
         trackCalibration: TrackCalibration;
-        /**
-         * Information about the software used to take the measurements.
-         * @see crmdig:L23 used software or firmware
-         */
-        measuredBy: {
-            /**
-             * The name of the measurement software.
-             * @see rdfs:label
-             */
-            software: string;
-            /**
-             * The version of the measurement software.
-             * @see owl:versionInfo
-             */
-            version: string;
-            /**
-             * The date on which the measurements were taken.
-             * @format date
-             * @see dcterms:date
-             */
-            date: Date;
-        };
     }>;
     /**
      * The production event that created this roll copy.
@@ -496,6 +483,8 @@ export declare const statesNothing: (modification: Modification) => boolean;
 export declare const featuresByAct: (copy: Pick<RollCopy, 'production' | 'modifications'>) => FeatureOrPatch[][];
 /** Every feature the copy states at a place of its own, whichever act made it. */
 export declare const featuresOf: (copy: Pick<RollCopy, 'production' | 'modifications'>) => FeatureOrPatch[];
+/** The programs the measurements of a copy name as having taken them, each once, as far as they name any. */
+export declare const measuringSoftwareOf: (copy: Pick<RollCopy, 'measurements'>) => Software[];
 /** Whether the condition is the stretch or shrinkage of the paper, as measured on the copy. */
 export declare const isPaperStretch: (condition: RollConditionAssignment) => condition is ObjectAssumption<PaperStretch>;
 /** What the copy's paper was measured to have done, where anything was measured. */

package/lib/model/RollCopy.js

@@ -35,6 +35,16 @@ export const statesNothing = (modification) => modification.type === 'Removal' ?
 export const featuresByAct = (copy) => [copy.production?.produced ?? [], ...copy.modifications.map(featuresMadeBy)];
 /** Every feature the copy states at a place of its own, whichever act made it. */
 export const featuresOf = (copy) => featuresByAct(copy).flat();
+/** The measurements of a copy the edition exports, each of which can say what took it. */
+const exportedMeasurementsOf = (copy) => [copy.measurements.dimensions, copy.measurements.holeSeparation, copy.measurements.scanResolution]
+    .filter(value => value !== undefined);
+/** The programs the measurements of a copy name as having taken them, each once, as far as they name any. */
+export const measuringSoftwareOf = (copy) => {
+    const named = exportedMeasurementsOf(copy)
+        .flatMap(value => value['@annotation']?.belief.reasons ?? [])
+        .flatMap(reason => reason.type === 'measurement' ? reason.software ?? [] : []);
+    return [...new Map(named.map(software => [`${software.name}\u0000${software.version ?? ''}`, software])).values()];
+};
 /** Whether the condition is the stretch or shrinkage of the paper, as measured on the copy. */
 export const isPaperStretch = (condition) => condition.conditionType === 'paper-stretch';
 /** What the copy's paper was measured to have done, where anything was measured. */

package/lib/model/Version.d.ts

@@ -33,6 +33,23 @@ export type Derivation = ReferenceAssumption & {
 };
 /** The tolerance the derivation was collated at, or the default where it states none. */
 export declare const collationToleranceOf: (derivation: Readonly<Derivation>) => CollationTolerance;
+/**
+ * How long a version's paper runs for a length of the paper of the
+ * version it derives from: about 0.77 for a Licensee or green re-cut of
+ * a red roll, cut for a slower paper speed.
+ * @see crm:E54 Dimension
+ */
+export interface LengthRatio {
+    /**
+     * @see crm:P90 has value
+     */
+    value: number;
+    /**
+     * The standard uncertainty of the value, one standard deviation.
+     * @see reo:uncertainty
+     */
+    uncertainty?: number;
+}
 /**
  * How a version was made, where that is known and worth stating.
  *
@@ -63,6 +80,19 @@ export interface VersionCreation {
      * @see crm:P33 used specific technique
      */
     procedure?: Concept;
+    /**
+     * How long the act made the version's paper for a length of the
+     * paper of the version it derives from. A re-cut for a system whose
+     * paper runs slower comes out shorter by the ratio of the speeds,
+     * and the alignments of the copies measure that ratio more closely
+     * than any label states a speed (`lengthRatioOf`). It is stated
+     * where the edition holds to it, as a measurement naming the copies
+     * it used and the program that found it, so that it can serve as a
+     * premise. A speed follows from it only together with a premise
+     * about the speed of the other version.
+     * @see reo:lengthRatio
+     */
+    lengthRatio?: ObjectAssumption<LengthRatio>;
 }
 /**
  * A version is defined by the sum of edits applied to the version it is

package/lib/readers/stanfordAton.js

@@ -1,5 +1,6 @@
 import { v4 } from "uuid";
 import { AtonParser } from "./AtonParser.js";
+import { assignDate } from "../model/Assumption.js";
 import { systemOf } from "../systems/TrackerBar.js";
 import { welteT100 } from "../systems/welteT100/bar.js";
 import { inMillimeters, mean, mm, pixelsPerInch, px, subtract, track } from "../model/Quantity.js";
@@ -120,19 +121,24 @@ const tearsIn = (tears, dpi, depictionOf) => {
         .sort((a, b) => a.horizontal.from - b.horizontal.from);
 };
 /**
- * The software behind an analysis and when it was run, as the
- * analysis file states them.
+ * The software behind an analysis and the day it was run, as the
+ * analysis file states them: the measurement the dimensions and the
+ * hole separation it gives rest on.
  */
-const measuredByOf = (rollinfo) => {
+const measurementOf = (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
+        type: 'measurement',
+        software: [{ name: rollinfo.HOLE_SOFTWARE, ...(rollinfo.SOFTWARE_DATE && { version: rollinfo.SOFTWARE_DATE }) }],
+        date: assignDate(new Date(date.getFullYear(), date.getMonth(), date.getDate()))
     };
 };
+/** The value held on the strength of the measurement, where the file names one, and plainly where it does not. */
+const takenBy = (measurement) => (value) => measurement
+    ? { ...value, '@annotation': { id: v4(), belief: { type: 'belief', id: v4(), certainty: 'true', reasons: [measurement] } } }
+    : value;
 export function readFromStanfordAton(atonString, { trackShift, system = welteT100, scan } = {}) {
     const parser = new AtonParser();
     const json = parser.parse(atonString);
@@ -141,7 +147,7 @@ export function readFromStanfordAton(atonString, { trackShift, system = welteT10
     const stanford = druid ? stanfordScan(druid) : undefined;
     const separation = readPx(json.ROLLINFO.HOLE_SEPARATION);
     const dpi = parseFloat(json.ROLLINFO.LENGTH_DPI);
-    const measuredBy = measuredByOf(json.ROLLINFO);
+    const measured = takenBy(measurementOf(json.ROLLINFO));
     const shift = trackShift ?? calibrationShiftIn(holes, system);
     const calibration = {
         unit: 'px',
@@ -196,15 +202,15 @@ export function readFromStanfordAton(atonString, { trackShift, system = welteT10
         modifications: [],
         ...((scan ?? stanford) && { scan: scan ?? stanford?.scan }),
         measurements: {
-            dimensions: {
+            dimensions: measured({
                 width: inMillimeters(readPx(json.ROLLINFO.ROLL_WIDTH), dpi),
                 height: inMillimeters(readPx(json.ROLLINFO.IMAGE_LENGTH), dpi),
                 unit: 'mm'
-            },
-            holeSeparation: {
+            }),
+            holeSeparation: measured({
                 value: separation,
                 unit: 'px'
-            },
+            }),
             margins: {
                 treble: readPx(json.ROLLINFO.HARD_MARGIN_TREBLE),
                 bass: readPx(json.ROLLINFO.HARD_MARGIN_BASS),
@@ -213,8 +219,7 @@ export function readFromStanfordAton(atonString, { trackShift, system = welteT10
             ...(Number.isFinite(dpi) && {
                 scanResolution: { value: pixelsPerInch(dpi), unit: 'px/in' }
             }),
-            trackCalibration: calibration,
-            ...(measuredBy && { measuredBy })
+            trackCalibration: calibration
         }
     };
 }

package/lib/schema.json

@@ -449,7 +449,7 @@
                     "type": "object"
                 }
             ],
-            "description": "When something happened, as far as the edition can state it: the day it falls `within`, or the bounds it lies between. A bound nobody can give is left out, so `after` alone says \"not before\".",
+            "description": "When something happened, as far as the edition can state it, and as an assumption, so that a dating can carry the belief it rests on: the day it falls `within`, or the bounds it lies between. A bound nobody can give is left out, so `after` alone says \"not before\".",
             "ontology": "crm:E52 Time-Span"
         },
         "Derivation": {
@@ -1145,63 +1145,37 @@
             "type": "object",
             "ontology": "crm:E54 Dimension"
         },
-        "Measure<\"px\">": {
-            "description": "A value together with the unit it was measured in, as a record states it.",
-            "properties": {
-                "unit": {
-                    "const": "px",
-                    "description": "The unit of measurement.",
-                    "type": "string",
-                    "ontology": "crm:P91 has unit"
-                },
-                "value": {
-                    "$ref": "#/definitions/Quantity%3C%22px%22%3E",
-                    "description": "The measured value.",
-                    "ontology": "crm:P90 has value"
-                }
-            },
-            "required": [
-                "value",
-                "unit"
-            ],
-            "type": "object",
-            "ontology": "crm:E54 Dimension"
-        },
-        "Measure<\"px/in\">": {
-            "description": "A value together with the unit it was measured in, as a record states it.",
-            "properties": {
-                "unit": {
-                    "const": "px/in",
-                    "description": "The unit of measurement.",
-                    "type": "string",
-                    "ontology": "crm:P91 has unit"
-                },
-                "value": {
-                    "$ref": "#/definitions/Quantity%3C%22px%2Fin%22%3E",
-                    "description": "The measured value.",
-                    "ontology": "crm:P90 has value"
-                }
-            },
-            "required": [
-                "value",
-                "unit"
-            ],
-            "type": "object",
-            "ontology": "crm:E54 Dimension"
-        },
         "Measurement": {
-            "description": "A measurement takes a value off an object by a stated procedure: the period the slot lengths of a copy keep, the median pitch of its held notes. It concludes the belief in that value by itself, with no premises. CRMinf counts observations, and a measurement is one, among the ways a belief comes about, so the value does not have to be passed off as an inference.",
+            "description": "A measurement takes a value off an object by a stated procedure: the period the slot lengths of a copy keep, the median pitch of its held notes. It concludes the belief in that value by itself, with no premises. CRMinf counts observations, and a measurement is one, among the ways a belief comes about, so the value does not have to be passed off as an inference.\n\nA measurement a program took names the program and its version, so that the value can be taken again and a value taken by a program later found wanting can be told from the rest. Naming software makes it a digital measurement event in the sense of CRMdig.",
             "properties": {
                 "actor": {
                     "$ref": "#/definitions/Person",
                     "description": "The person who carried out this activity.",
                     "ontology": "crm:P14 carried out by"
                 },
+                "date": {
+                    "$ref": "#/definitions/TimeSpan",
+                    "description": "When the measurement was taken. It is part of the reason and carries no belief of its own.",
+                    "ontology": "crm:P4 has time-span"
+                },
                 "note": {
                     "description": "A free-text note providing additional context.",
                     "type": "string",
                     "ontology": "crm:P3 has note"
                 },
+                "procedure": {
+                    "$ref": "#/definitions/Concept",
+                    "description": "The method followed, where it has a name apart from the program that carries it out, such as a line of Theil and Sen through the matched notes of two copies.",
+                    "ontology": "crm:P33 used specific technique"
+                },
+                "software": {
+                    "description": "The programs that took the measurement, each with its version.",
+                    "items": {
+                        "$ref": "#/definitions/Software"
+                    },
+                    "type": "array",
+                    "ontology": "crmdig:L23 used software or firmware"
+                },
                 "used": {
                     "description": "References (by `@id` or URL) to what the measurement was taken on or with, such as the scan, the analysis output or the script.",
                     "items": {
@@ -1872,6 +1846,89 @@
             ],
             "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<(Measure<\"px\">|Measure<\"mm\">)>": {
+            "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"
+                        },
+                        "unit": {
+                            "const": "px",
+                            "description": "The unit of measurement.",
+                            "type": "string",
+                            "ontology": "crm:P91 has unit"
+                        },
+                        "value": {
+                            "$ref": "#/definitions/Quantity%3C%22px%22%3E",
+                            "description": "The measured value.",
+                            "ontology": "crm:P90 has value"
+                        }
+                    },
+                    "required": [
+                        "unit",
+                        "value"
+                    ],
+                    "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"
+                        },
+                        "unit": {
+                            "const": "mm",
+                            "description": "The unit of measurement.",
+                            "type": "string",
+                            "ontology": "crm:P91 has unit"
+                        },
+                        "value": {
+                            "$ref": "#/definitions/Quantity%3C%22mm%22%3E",
+                            "description": "The measured value.",
+                            "ontology": "crm:P90 has value"
+                        }
+                    },
+                    "required": [
+                        "unit",
+                        "value"
+                    ],
+                    "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<Advance>": {
             "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": {
@@ -2458,6 +2515,43 @@
             ],
             "type": "object"
         },
+        "ObjectAssumption<LengthRatio>": {
+            "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": {
+                    "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"
+                },
+                "uncertainty": {
+                    "description": "The standard uncertainty of the value, one standard deviation.",
+                    "type": "number",
+                    "ontology": "reo:uncertainty"
+                },
+                "value": {
+                    "type": "number",
+                    "ontology": "crm:P90 has value"
+                }
+            },
+            "required": [
+                "value"
+            ],
+            "type": "object"
+        },
         "ObjectAssumption<Measure<\"mm\">>": {
             "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": {
@@ -2498,6 +2592,46 @@
             ],
             "type": "object"
         },
+        "ObjectAssumption<Measure<\"px/in\">>": {
+            "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": {
+                    "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"
+                },
+                "unit": {
+                    "const": "px/in",
+                    "description": "The unit of measurement.",
+                    "type": "string",
+                    "ontology": "crm:P91 has unit"
+                },
+                "value": {
+                    "$ref": "#/definitions/Quantity%3C%22px%2Fin%22%3E",
+                    "description": "The measured value.",
+                    "ontology": "crm:P90 has value"
+                }
+            },
+            "required": [
+                "unit",
+                "value"
+            ],
+            "type": "object"
+        },
         "ObjectAssumption<PaperSpeed>": {
             "anyOf": [
                 {
@@ -2635,6 +2769,52 @@
             ],
             "type": "object"
         },
+        "ObjectAssumption<RollDimensions>": {
+            "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": {
+                    "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"
+                },
+                "height": {
+                    "$ref": "#/definitions/Millimeters",
+                    "description": "The total height (length) of the roll.",
+                    "ontology": "reo:height"
+                },
+                "unit": {
+                    "const": "mm",
+                    "description": "The unit of measurement.",
+                    "type": "string",
+                    "ontology": "crm:P91 has unit"
+                },
+                "width": {
+                    "$ref": "#/definitions/Millimeters",
+                    "description": "The width of the roll.",
+                    "ontology": "reo:width"
+                }
+            },
+            "required": [
+                "height",
+                "unit",
+                "width"
+            ],
+            "type": "object"
+        },
         "ObjectAssumption<RollTempo>": {
             "anyOf": [
                 {
@@ -3153,49 +3333,19 @@
                     "ontology": "crm:P50 has current keeper"
                 },
                 "measurements": {
-                    "description": "Physical measurements of this roll copy, including dimensions, hole separation, margins, the alignment onto the edition's axis, and information about the measuring software. What the perforations tell about the machine that cut them is stated with the production.",
+                    "description": "Physical measurements of this roll copy: its dimensions, hole separation and margins, the resolution of its scan, and how it lies on the edition's axis. What the perforations tell about the machine that cut them is stated with the production.\n\nA value the edition exports is an object assumption, so that it can say what took it: a measurement naming the program and its version, the scan or analysis it was taken on, and the day.",
                     "properties": {
                         "alignment": {
                             "$ref": "#/definitions/Alignment",
                             "description": "How the copy's places are carried onto the edition's axis. Left out for the reference copy, whose places are the axis, and for a copy not aligned yet. Not exported to RDF."
                         },
                         "dimensions": {
+                            "$ref": "#/definitions/ObjectAssumption%3CRollDimensions%3E",
                             "description": "The physical dimensions of the roll.",
-                            "properties": {
-                                "height": {
-                                    "$ref": "#/definitions/Millimeters",
-                                    "description": "The total height (length) of the roll.",
-                                    "ontology": "reo:height"
-                                },
-                                "unit": {
-                                    "const": "mm",
-                                    "description": "The unit of measurement.",
-                                    "type": "string",
-                                    "ontology": "crm:P91 has unit"
-                                },
-                                "width": {
-                                    "$ref": "#/definitions/Millimeters",
-                                    "description": "The width of the roll.",
-                                    "ontology": "reo:width"
-                                }
-                            },
-                            "required": [
-                                "width",
-                                "height",
-                                "unit"
-                            ],
-                            "type": "object",
                             "ontology": "reo:dimensions"
                         },
                         "holeSeparation": {
-                            "anyOf": [
-                                {
-                                    "$ref": "#/definitions/Measure%3C%22px%22%3E"
-                                },
-                                {
-                                    "$ref": "#/definitions/Measure%3C%22mm%22%3E"
-                                }
-                            ],
+                            "$ref": "#/definitions/ObjectAssumption%3C(Measure%3C%22px%22%3E%7CMeasure%3C%22mm%22%3E)%3E",
                             "description": "The distance across the roll from the centre of one track to the next, the track pitch or Teilung, in the unit the scan was measured in. It is fixed by the tracker bar the roll was cut for, and is another thing than the chain pitch, which runs along the roll.",
                             "ontology": "reo:holeSeparation"
                         },
@@ -3210,34 +3360,6 @@
                             ],
                             "description": "The margins on the treble and bass sides of the roll. Not exported to RDF."
                         },
-                        "measuredBy": {
-                            "description": "Information about the software used to take the measurements.",
-                            "properties": {
-                                "date": {
-                                    "description": "The date on which the measurements were taken.",
-                                    "format": "date",
-                                    "type": "string",
-                                    "ontology": "dcterms:date"
-                                },
-                                "software": {
-                                    "description": "The name of the measurement software.",
-                                    "type": "string",
-                                    "ontology": "rdfs:label"
-                                },
-                                "version": {
-                                    "description": "The version of the measurement software.",
-                                    "type": "string",
-                                    "ontology": "owl:versionInfo"
-                                }
-                            },
-                            "required": [
-                                "software",
-                                "version",
-                                "date"
-                            ],
-                            "type": "object",
-                            "ontology": "crmdig:L23 used software or firmware"
-                        },
                         "readerExtension": {
                             "description": "What a pneumatic reader added to this copy's chains of holes, where it was taken off again. Such a reader reports how long a valve stayed open, which exceeds the perforation that opened it, so its chains are overlong by a constant while its onsets agree. Nothing for a copy read by other means, whose chains are the punched ones themselves. Not exported to RDF.",
                             "properties": {
@@ -3259,7 +3381,7 @@
                             "type": "object"
                         },
                         "scanResolution": {
-                            "$ref": "#/definitions/Measure%3C%22px%2Fin%22%3E",
+                            "$ref": "#/definitions/ObjectAssumption%3CMeasure%3C%22px%2Fin%22%3E%3E",
                             "description": "The resolution this copy's scan was read at, along the roll. It is what the measurements given in pixels are to be read against, and what every conversion between a place in the scan and one on the paper goes through. A scanner may read across the roll at another resolution, which the analysis files do not state.",
                             "ontology": "reo:scanResolution"
                         },
@@ -3346,14 +3468,14 @@
             "type": "object"
         },
         "Software": {
-            "description": "Software a capture ran, such as the transcriber that read a recording into notes or the emulator that wrote a MIDI file.",
+            "description": "Software that captured a copy or measured it: the transcriber that read a recording into notes, the emulator that wrote a MIDI file, the program that found the holes on a scan or aligned two copies.",
             "properties": {
                 "name": {
                     "type": "string",
                     "ontology": "rdfs:label"
                 },
                 "version": {
-                    "description": "The release, or the model checkpoint of a transcriber.",
+                    "description": "The release, the commit, or the model checkpoint of a transcriber.",
                     "type": "string",
                     "ontology": "owl:versionInfo"
                 }
@@ -3447,6 +3569,66 @@
             "type": "object",
             "ontology": "crm:E33 Linguistic Object"
         },
+        "TimeSpan": {
+            "anyOf": [
+                {
+                    "properties": {
+                        "within": {
+                            "description": "The day the event falls within.",
+                            "format": "date",
+                            "type": "string",
+                            "ontology": "crm:P82 at some time within"
+                        }
+                    },
+                    "required": [
+                        "within"
+                    ],
+                    "type": "object"
+                },
+                {
+                    "properties": {
+                        "after": {
+                            "description": "The earliest day the event can have happened on: it did not happen before it.",
+                            "format": "date",
+                            "type": "string",
+                            "ontology": "crm:P82a begin of the begin"
+                        },
+                        "before": {
+                            "description": "The latest day the event can have happened on: it did not happen after it.",
+                            "format": "date",
+                            "type": "string",
+                            "ontology": "crm:P82b end of the end"
+                        }
+                    },
+                    "required": [
+                        "after"
+                    ],
+                    "type": "object"
+                },
+                {
+                    "properties": {
+                        "after": {
+                            "description": "The earliest day the event can have happened on: it did not happen before it.",
+                            "format": "date",
+                            "type": "string",
+                            "ontology": "crm:P82a begin of the begin"
+                        },
+                        "before": {
+                            "description": "The latest day the event can have happened on: it did not happen after it.",
+                            "format": "date",
+                            "type": "string",
+                            "ontology": "crm:P82b end of the end"
+                        }
+                    },
+                    "required": [
+                        "before"
+                    ],
+                    "type": "object"
+                }
+            ],
+            "description": "When something happened: the day it falls `within`, or the bounds it lies between. A bound nobody can give is left out, so `after` alone says \"not before\".",
+            "ontology": "crm:E52 Time-Span"
+        },
         "Track": {
             "$ref": "#/definitions/Quantity%3C%22track%22%3E",
             "description": "A position across the roll, numbered as the tracker bar does."
@@ -3541,6 +3723,11 @@
                     "description": "When it took place.",
                     "ontology": "crm:P4 has time-span"
                 },
+                "lengthRatio": {
+                    "$ref": "#/definitions/ObjectAssumption%3CLengthRatio%3E",
+                    "description": "How long the act made the version's paper for a length of the paper of the version it derives from. A re-cut for a system whose paper runs slower comes out shorter by the ratio of the speeds, and the alignments of the copies measure that ratio more closely than any label states a speed (`lengthRatioOf`). It is stated where the edition holds to it, as a measurement naming the copies it used and the program that found it, so that it can serve as a premise. A speed follows from it only together with a premise about the speed of the other version.",
+                    "ontology": "reo:lengthRatio"
+                },
                 "procedure": {
                     "$ref": "#/definitions/Concept",
                     "description": "The rule followed, as a term of the vocabulary: the notes stand at their pitch, the expression is re-spelled in the other system's words.",

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": {
@@ -176,14 +187,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/welte.d.ts

@@ -67,12 +67,15 @@ 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;

package/lib/systems/welte.js

@@ -28,7 +28,8 @@ 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)));
@@ -67,9 +68,10 @@ const performNotes = (events, grid, nuance, options, paper) => events
     .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));
     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) }
     ];
 });
 /**

package/package.json

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