linked-rolls 0.64.0 → 0.66.0

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/Edition.d.ts

@@ -1,6 +1,5 @@
 import { RollCopy } from "./RollCopy.js";
 import { Version } from "./Version.js";
-import { CollationTolerance } from "../collation/Collation.js";
 import { DateAssignment, ObjectAssumption } from "./Assumption.js";
 import { Editor, Person, Place } from "./Agent.js";
 import { RollTempo } from "../systems/ReproducingSystem.js";
@@ -28,18 +27,6 @@ export interface EditionCreation {
      * @see dcterms:date
      */
     publicationDate: Date;
-    /**
-     * The tolerance every version of the edition was collated at,
-     * before each derivation stated its own. How precisely two copies
-     * place a symbol depends on which two they are, so the tolerance
-     * belongs to the derivation, `Derivation.collationTolerance`, and
-     * migration writes this one onto every derivation that gives none.
-     * Nothing else reads it. A window's offset is the displacement
-     * between two particular copies and so can never be stated here.
-     * Not exported to RDF.
-     * @deprecated
-     */
-    collationTolerance?: CollationTolerance;
 }
 /**
  * Describes the event of recording and documents

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/ops/collation.js

@@ -5,7 +5,7 @@ import { collationToleranceOf, derivesFrom, editsOf, insertedBy, principalDeriva
 import { substitutionsBetween } from "../collation/substitution.js";
 import { trackerBarOf } from "../systems/index.js";
 import { assignReference, idOf } from "../model/Assumption.js";
-import { noChange, onVersion, stateOf, insertion, deletion, asUnchecked, declaring, insertedIn, dropInsertions, reading } from "./draft.js";
+import { noChange, onVersion, insertion, deletion, asUnchecked, declaring, dropInsertions, reading } from "./draft.js";
 import { hypothesesBeside } from "./versions.js";
 import { placeOf, snapshotOf } from "../analysis/text.js";
 import { copyOfFeature, versionIn } from "../lookup/lookup.js";
@@ -114,14 +114,18 @@ export const connectVersions = (childId, parentId, tolerance = defaultCollationT
             .filter(symbol => !matched.has(symbol.id) && !paired.has(symbol.id))
             .map(symbol => asUnchecked(deletion(symbol.id)))
     ];
-    return onVersion(childId, (child, draft) => {
+    // Read off the child as it stands, since once its edits are written a
+    // reading of it would copy them all.
+    const motivations = declaring(child?.motivations ?? [], edits);
+    const basedOn = [
+        { ...assignReference(parentId), collationTolerance: tolerance },
+        ...(child ? hypothesesBeside(child, parentId) : [])
+    ];
+    return onVersion(childId, (version, draft) => {
         handOverCarriers(edition, draft, collations);
-        child.edits = edits;
-        child.motivations = declaring(stateOf(child).motivations, edits);
-        child.basedOn = [
-            { ...assignReference(parentId), collationTolerance: tolerance },
-            ...hypothesesBeside(stateOf(child), parentId)
-        ];
+        version.edits = edits;
+        version.motivations = motivations;
+        version.basedOn = basedOn;
     });
 });
 /**
@@ -135,7 +139,7 @@ export const collateSymbols = (versionId, symbolIds, tolerance) => reading(editi
     if (!version || !principal)
         return noChange;
     const chosen = new Set(symbolIds);
-    const own = insertedIn([version]).filter(symbol => chosen.has(symbol.id));
+    const own = insertedBy(version).filter(symbol => chosen.has(symbol.id));
     const collations = collationsOf(own, snapshotOf(edition, idOf(principal)), symbol => placeOf(edition, symbol), tolerance ?? collationToleranceOf(principal));
     const collated = new Set(collations.map(({ symbol }) => symbol.id));
     return onVersion(versionId, (version, draft) => {

package/lib/ops/copies.js

@@ -83,9 +83,17 @@ export const alignCopies = (date = new Date()) => draft => {
     const own = draft.copies.find(c => c.id === reference.id);
     if (own)
         revertAlignment(own);
-    stateOf(draft).copies
-        .filter(copy => copy.id !== reference.id && featuresOf(copy).length > 0)
-        .forEach(copy => alignCopy(copy.id, date)(draft));
+    // Aligning a copy moves neither the reference copy nor any other,
+    // so every copy is aligned from the one state. Read afresh after
+    // each, the draft would be copied with every copy aligned so far.
+    const state = stateOf(draft);
+    state.copies.forEach((copy, i) => {
+        if (copy.id === reference.id || featuresOf(copy).length === 0)
+            return;
+        const alignment = alignmentFor(state, copy, date);
+        if (alignment)
+            applyAlignment(alignment, draft.copies[i]);
+    });
 };
 /**
  * Makes the copy the one whose millimetres are the edition's axis, and

package/lib/ops/immutable.d.ts

@@ -1,7 +1,11 @@
 /** Rewritings that return the very object they were given wherever they change nothing, so that an immer draft is left untouched there. */
 /** The items that do not match, or the very same array when none does, so that a draft stays untouched. */
 export declare const without: <T>(items: T[], matches: (item: T) => boolean) => T[];
-/** The items each changed, or the very same array when the change left every one as it was. */
+/**
+ * The items each changed, or the very same array when the change left
+ * every one as it was. The array is copied at the first item that
+ * changes, so that one left as it was costs no copy.
+ */
 export declare const mapped: <T>(items: T[], change: (item: T) => T) => T[];
 /** The items each changed, less those the change emptied; the very same array where it changed none. */
 export declare const pruned: <T>(items: T[], change: (item: T) => T, emptied: (item: T) => boolean) => T[];
@@ -10,6 +14,8 @@ export declare const replacing: <T extends object, K extends keyof T>(record: T,
 /** A record of the edition, as the walk over it sees one. */
 export type Node = Record<string, unknown>;
 export declare const isRecord: (value: unknown) => value is Node;
+/** The record's values each changed, or the very same record where the change left every one as it was, copied as `mapped` copies. */
+export declare const withValues: (record: Node, change: (value: unknown) => unknown) => Node;
 /** The value with the change applied to every record within it and then to itself, innermost first. */
 export declare const deeply: (change: (record: object) => object) => (value: unknown) => unknown;
 /** Writes onto the draft what the rewriting changed, as deep as the change reaches. */

package/lib/ops/immutable.js

@@ -1,10 +1,19 @@
 /** Rewritings that return the very object they were given wherever they change nothing, so that an immer draft is left untouched there. */
 /** The items that do not match, or the very same array when none does, so that a draft stays untouched. */
 export const without = (items, matches) => items.some(matches) ? items.filter(item => !matches(item)) : items;
-/** The items each changed, or the very same array when the change left every one as it was. */
+/**
+ * The items each changed, or the very same array when the change left
+ * every one as it was. The array is copied at the first item that
+ * changes, so that one left as it was costs no copy.
+ */
 export const mapped = (items, change) => {
-    const changed = items.map(change);
-    return changed.every((item, i) => item === items[i]) ? items : changed;
+    let changed;
+    items.forEach((item, i) => {
+        const after = change(item);
+        if (after !== item)
+            (changed ?? (changed = items.slice()))[i] = after;
+    });
+    return changed ?? items;
 };
 /** The items each changed, less those the change emptied; the very same array where it changed none. */
 export const pruned = (items, change, emptied) => {
@@ -14,11 +23,16 @@ export const pruned = (items, change, emptied) => {
 /** The record with the field replaced, or the very same record where that is what stood there. */
 export const replacing = (record, key, value) => record[key] === value ? record : { ...record, [key]: value };
 export const isRecord = (value) => typeof value === 'object' && value !== null;
-/** The record's values each changed, or the very same record where the change left every one as it was. */
-const withValues = (record, change) => {
-    const entries = Object.entries(record);
-    const changed = entries.map(([key, value]) => [key, change(value)]);
-    return changed.every(([, value], i) => value === entries[i][1]) ? record : Object.fromEntries(changed);
+/** The record's values each changed, or the very same record where the change left every one as it was, copied as `mapped` copies. */
+export const withValues = (record, change) => {
+    let changed;
+    Object.keys(record).forEach(key => {
+        const value = record[key];
+        const after = change(value);
+        if (after !== value)
+            (changed ?? (changed = { ...record }))[key] = after;
+    });
+    return changed ?? record;
 };
 /** The value with the change applied to every record within it and then to itself, innermost first. */
 export const deeply = (change) => {

package/lib/readers/phillipsEroll.js

@@ -129,12 +129,6 @@ const controlOffsetOf = (system, given) => {
     }
     return measured;
 };
-/** The position each note of the bar sounds from. */
-const positionsByPitch = (bar) => new Map(Array.from({ length: bar.trackCount }, (_, index) => track(index + 1))
-    .flatMap((position) => {
-    const meaning = bar.meaningOf(position);
-    return meaning?.type === 'note' ? [[meaning.pitch, position]] : [];
-}));
 /**
  * Reads one of his e-roll files as a copy of the roll, in millimetres
  * of paper, on the bar it was cut for and in that bar's numbering. A
@@ -146,8 +140,7 @@ export function readFromPhillipsEroll(buffer, { system = welteT100, controlOffse
     const elapsedAt = clockOf(temposIn(timed), file.header.ticksPerBeat);
     const place = placeAt ?? atStatedSpeed(system);
     const offset = controlOffsetOf(system, controlOffset);
-    const notePositions = positionsByPitch(system);
-    const positionOf = (number) => notePositions.get(number) ?? track(number - offset);
+    const positionOf = (number) => system.positionOf({ type: 'note', pitch: number }) ?? track(number - offset);
     const features = notesIn(timed).flatMap((note) => {
         const position = positionOf(note.pitch);
         if (!system.meaningOf(position))

package/lib/readers/stanfordAton.js

@@ -1,8 +1,10 @@
 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";
+import { medianOf } from "../collation/statistics.js";
 /** Values in these files carry their unit as a suffix, e.g. "37.7646px". */
 const readPx = (value) => px(parseFloat(value));
 /** The parser writes one record as an object and several as an array. */
@@ -20,11 +22,6 @@ const chainedBadHoles = (holes, calibration) => holes
     ...hole,
     TRACKER_HOLE: `${Math.round((readPx(hole.CENTROID_COL) - calibration.offset) / calibration.separation)}`
 }));
-const median = (values) => {
-    const sorted = [...values].sort((a, b) => a - b);
-    const middle = Math.floor(sorted.length / 2);
-    return sorted.length % 2 ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2;
-};
 const mostFrequent = (values) => {
     const counts = values.reduce((acc, value) => acc.set(value, (acc.get(value) || 0) + 1), new Map());
     return [...counts].sort(([, a], [, b]) => b - a)[0]?.[0];
@@ -76,7 +73,7 @@ const calibrationShiftIn = (holes, bar) => {
 const gridOffsetOf = (holes, separation, stated) => {
     if (stated !== undefined)
         return readPx(stated);
-    return px(median(holes.map(hole => readPx(hole.CENTROID_COL) - +hole.TRACKER_HOLE * separation)));
+    return medianOf(holes.map(hole => px(readPx(hole.CENTROID_COL) - +hole.TRACKER_HOLE * separation))) ?? px(0);
 };
 const chainsAmong = (holes) => holes
     .filter(hole => hole.NOTE_ATTACK && hole.OFF_TIME)
@@ -124,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);
@@ -145,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',
@@ -200,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),
@@ -217,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
         }
     };
 }