linked-rolls 0.64.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/constraints.js

@@ -80,20 +80,19 @@ const typesNotOnTheBar = (version, snapshot) => {
  * out says 59. Collation across systems consults only the place, so
  * without this nothing checks the tracks at all.
  */
-const carriersOffTheirMeaning = (edition, version, commands) => {
-    const misread = (carrier, symbol) => {
+const carriedOffItsMeaning = (edition) => (symbol) => {
+    const key = keyOf(symbol);
+    return placedCarriersOf(edition, symbol).some(carrier => {
         const copy = copyOfFeature(edition, carrier.id);
-        if (!copy)
-            return false;
         // A carrier lying across several positions reads as several commands,
         // and carries the symbol as long as one of them is the symbol's.
-        return !barOf(copy).meaningsOf(carrier.vertical)
-            .some(meaning => keyOf(meaning) === keyOf(symbol));
-    };
-    return commands
-        .filter(symbol => placedCarriersOf(edition, symbol).some(carrier => misread(carrier, symbol)))
-        .map(symbol => ({ version, symbol: symbol.id, problem: 'carrier-on-another-track' }));
+        return copy !== undefined && !barOf(copy).meaningsOf(carrier.vertical).some(meaning => keyOf(meaning) === key);
+    });
 };
+/** The commands the version shows among those carried off their meaning. */
+const carriersOffTheirMeaning = (misread, version, commands) => commands
+    .filter(symbol => misread.has(symbol))
+    .map(symbol => ({ version, symbol: symbol.id, problem: 'carrier-on-another-track' }));
 /**
  * Where a copy of the version's own system strays from the others in
  * its paper by more than paper does.
@@ -104,13 +103,9 @@ const carriersOffTheirMeaning = (edition, version, commands) => {
  * speed, and averaging it in would hide both that and the fact that the
  * playback rests on a guess.
  */
-const paperDisagreed = (edition, version) => {
-    const own = new Set(paperOfVersion(edition, version)?.copies ?? []);
-    return alignmentProblems(edition)
-        .some(({ copy, problem }) => problem === 'paper-beyond-its-spread' && own.has(copy))
-        ? [{ version: version.id, symbol: version.id, problem: 'copies-disagree-on-the-paper' }]
-        : [];
-};
+const paperDisagreed = (edition, strays, version) => paperOfVersion(edition, version)?.copies.some(copy => strays.has(copy))
+    ? [{ version: version.id, symbol: version.id, problem: 'copies-disagree-on-the-paper' }]
+    : [];
 /**
  * A version's strikes that take nothing out of its text: each deleted
  * symbol has to be one the parent hands down, or one the version put
@@ -143,14 +138,22 @@ const strikesBitingNothing = (edition, version) => {
  * track that does not say what its symbol says, and a strike that takes
  * nothing out.
  */
-export const constraintProblems = (edition) => edition.versions.flatMap(version => {
-    const snapshot = snapshotOf(edition, version.id);
-    const commands = snapshot.filter(isCommand);
-    return [
-        ...problemsIn(version.id, commands),
-        ...typesNotOnTheBar(version, snapshot),
-        ...carriersOffTheirMeaning(edition, version.id, commands),
-        ...paperDisagreed(edition, version),
-        ...strikesBitingNothing(edition, version)
-    ];
-});
+export const constraintProblems = (edition) => {
+    // What a symbol's carriers and the copies' paper say holds whichever
+    // version shows them, so it is asked once for the edition.
+    const misread = new Set(edition.versions.flatMap(insertedBy).filter(isCommand).filter(carriedOffItsMeaning(edition)));
+    const strays = new Set(alignmentProblems(edition)
+        .filter(({ problem }) => problem === 'paper-beyond-its-spread')
+        .map(({ copy }) => copy));
+    return edition.versions.flatMap(version => {
+        const snapshot = snapshotOf(edition, version.id);
+        const commands = snapshot.filter(isCommand);
+        return [
+            ...problemsIn(version.id, commands),
+            ...typesNotOnTheBar(version, snapshot),
+            ...carriersOffTheirMeaning(misread, version.id, commands),
+            ...paperDisagreed(edition, strays, version),
+            ...strikesBitingNothing(edition, version)
+        ];
+    });
+};

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/analysis/witnesses.js

@@ -2,6 +2,7 @@ import { certaintyOf, idOf, idsOf } from "../model/Assumption.js";
 import { insertedBy } from "../model/Version.js";
 import { lineageOf } from "./stemma.js";
 import { copyOfFeature, versionIn } from "../lookup/lookup.js";
+import { perState } from "../lookup/perState.js";
 /** The copies whose features carry any of the symbols. */
 const copiesCarrying = (edition, symbols) => new Set(symbols
     .flatMap(symbol => idsOf(symbol.carriers))
@@ -17,19 +18,21 @@ const carriagesIn = (edition) => edition.versions.flatMap(version => {
         .filter(copy => carrying.has(copy.id))
         .map((copy) => ({ copy: copy.id, version: version.id, depth }));
 });
-const carriersIn = (edition) => {
+/** What the copies' features attest, worked out once for each state of the edition. */
+const carriersIn = perState((edition) => {
     const carriages = carriagesIn(edition);
+    const byVersion = Map.groupBy(carriages, carriage => carriage.version);
     return {
         copiesOf: new Map(edition.versions.map(version => [
             version.id,
-            carriages.filter(carriage => carriage.version === version.id).map(carriage => carriage.copy)
+            (byVersion.get(version.id) ?? []).map(carriage => carriage.copy)
         ])),
         // Written in order of depth, so a copy's latest carriage is set last and stands.
         latestOf: new Map([...carriages]
             .sort((one, other) => one.depth - other.depth)
             .map(carriage => [carriage.copy, carriage.version]))
     };
-};
+});
 /**
  * The versions a copy's features carry at first hand: for every copy,
  * the latest state it bears. A version left out is reached only through

package/lib/collation/alignment.js

@@ -1,6 +1,7 @@
 import { featuresOf, isTear, tearsOf } from "../model/RollCopy.js";
 import { defaultTrackerBar } from "../systems/index.js";
 import { add, mm, subtract, track } from "../model/Quantity.js";
+import { partitionPoint } from "../shared/sorted.js";
 /** A place on the copy's own paper, on the edition's axis. */
 export const toAxis = (alignment) => (place) => alignment ? mm((place + alignment.shift.horizontal) * alignment.scale) : place;
 /** A place on the edition's axis, on the copy's own paper. */
@@ -217,12 +218,41 @@ const noteOnsets = (features, bar) => features
         .map(meaning => ({ pitch: meaning.pitch, at: feature.horizontal.from }));
 })
     .sort(byPlace);
+/**
+ * The middle one of the values, the upper of the two where their number
+ * is even. It is selected rather than the values sorted (Hoare's FIND,
+ * as Wirth writes it): a long roll gives over a million slopes, and only
+ * the one in the middle is wanted. The values are reordered where they
+ * lie.
+ */
 const median = (values) => {
-    const sorted = [...values].sort((x, y) => x - y);
-    return sorted[Math.floor(sorted.length / 2)] ?? 0;
+    const middle = values.length >> 1;
+    let low = 0;
+    let high = values.length - 1;
+    while (low < high) {
+        const pivot = values[middle];
+        let i = low;
+        let j = high;
+        while (i <= j) {
+            while (values[i] < pivot)
+                i++;
+            while (pivot < values[j])
+                j--;
+            if (i <= j) {
+                const swapped = values[i];
+                values[i] = values[j];
+                values[j] = swapped;
+                i++;
+                j--;
+            }
+        }
+        if (j < middle)
+            low = i;
+        if (middle < i)
+            high = j;
+    }
+    return values[middle] ?? 0;
 };
-/** The slope of the line through two matches, or nothing where they share a place on the copy. */
-const slopeBetween = (m, n) => n.a === m.a ? [] : [(n.b - m.b) / (n.a - m.a)];
 /** Matches beyond this are thinned before the slopes are taken, whose number grows with the square. */
 const SLOPE_SAMPLE = 1500;
 /**
@@ -234,25 +264,27 @@ const SLOPE_SAMPLE = 1500;
 const robustLine = (matches) => {
     const step = Math.max(1, Math.ceil(matches.length / SLOPE_SAMPLE));
     const sample = matches.filter((_, i) => i % step === 0);
-    const slopes = sample.flatMap((m, i) => sample.slice(i + 1).flatMap(n => slopeBetween(m, n)));
-    if (slopes.length === 0)
+    const slopes = new Float64Array(sample.length * (sample.length - 1) / 2);
+    let count = 0;
+    sample.forEach((m, i) => {
+        for (let j = i + 1; j < sample.length; j++) {
+            const n = sample[j];
+            // Two matches at one place on the copy give no slope.
+            if (n.a !== m.a)
+                slopes[count++] = (n.b - m.b) / (n.a - m.a);
+        }
+    });
+    if (count === 0)
         return undefined;
-    const slope = median(slopes);
-    return { slope, intercept: median(matches.map(m => m.b - slope * m.a)) };
+    const slope = median(slopes.subarray(0, count));
+    return { slope, intercept: median(Float64Array.from(matches, m => m.b - slope * m.a)) };
 };
 const placed = (line, a) => line.slope * a + line.intercept;
 const residualOf = (line, match) => match.b - placed(line, match.a);
 /** Pitches in a row that pin down a place on a roll, provided the row occurs once. */
 const ANCHOR_LENGTH = 6;
 /** Every run of `length` pitches, keyed by the run, with the onsets it starts at. */
-const runsOf = (onsets, length) => {
-    const runs = new Map();
-    onsets.slice(0, Math.max(0, onsets.length - length + 1)).forEach((start, i) => {
-        const key = onsets.slice(i, i + length).map(onset => onset.pitch).join(',');
-        runs.set(key, [...(runs.get(key) ?? []), start]);
-    });
-    return runs;
-};
+const runsOf = (onsets, length) => Map.groupBy(onsets.slice(0, Math.max(0, onsets.length - length + 1)), (_, i) => onsets.slice(i, i + length).map(onset => onset.pitch).join(','));
 /** The places a run of pitches found once on each roll ties together. */
 const anchors = (a, b) => {
     const runsB = runsOf(b, ANCHOR_LENGTH);
@@ -277,13 +309,16 @@ const pairedNearestFirst = (candidates) => {
     }
     return matches;
 };
+/** Widens the window by a hair before it is searched, so that rounding in its bounds cannot leave out what the distance admits. */
+const WINDOW_SLACK = 1e-9;
 /** Each onset of A paired with the nearest onset of B of its pitch within the window around where the line puts it. */
 const nearestMatches = (a, b, line, window) => {
-    const bByPitch = new Map();
-    b.forEach(onset => bByPitch.set(onset.pitch, [...(bByPitch.get(onset.pitch) ?? []), onset]));
     const candidates = a.flatMap(onset => {
         const expected = placed(line, onset.at);
-        return (bByPitch.get(onset.pitch) ?? [])
+        const ofPitch = b.get(onset.pitch) ?? [];
+        const first = partitionPoint(ofPitch, other => other.at < expected - window - WINDOW_SLACK);
+        const end = partitionPoint(ofPitch, other => other.at <= expected + window + WINDOW_SLACK);
+        return ofPitch.slice(first, end)
             .map(other => ({ distance: Math.abs(other.at - expected), a: onset, b: other }))
             .filter(candidate => candidate.distance <= window);
     });
@@ -341,5 +376,5 @@ export function alignFeatures(rollA, rollB, barA = defaultTrackerBar, barB = bar
     const coarse = robustLine(anchors(a, b));
     if (!coarse)
         return undefined;
-    return resultOf(WINDOWS.reduce(settled(a, b), { line: coarse, matches: [] }));
+    return resultOf(WINDOWS.reduce(settled(a, Map.groupBy(b, onset => onset.pitch)), { line: coarse, matches: [] }));
 }

package/lib/collation/scatter.d.ts

@@ -66,7 +66,7 @@ export interface ScatterOptions {
     groupOf?: Grouping;
     /** The width of the histogram's bins. */
     binWidth?: Millimeters;
-    /** The tolerance the edition states at present, against which each departure is reported as still admitted or not. */
+    /** The tolerance the derivation states at present, against which each departure is reported as still admitted or not. */
     stated?: CollationTolerance;
 }
 /** A reading the calculated tolerance does not admit. */
@@ -90,7 +90,7 @@ export interface Departure {
      */
     separatedBy: BothEnds<boolean>;
     /**
-     * Whether the tolerance the edition states at present still admits
+     * Whether the tolerance the derivation states at present still admits
      * it. Absent where none was given to compare against.
      *
      * This sees one direction only. A departure is by definition a

package/lib/io/asJsonLd.js

@@ -80,23 +80,19 @@ const changing = (copyId) => (act) => {
         return { ...act, diminished: { '@id': copyId } };
     return act;
 };
+/** The copy with what each of its acts changed stated. */
+const withChangesOf = (copy) => isRecord(copy) && Array.isArray(copy.modifications)
+    ? { ...copy, modifications: copy.modifications.map(changing(copy['@id'])) }
+    : copy;
 /**
  * The document with what each act changed stated. Which of P110
  * augmented and P112 diminished applies depends on the class of the
  * act, which no property chain in OWL 2 RL can test, so the export
  * states it. What a copy or a patch bears is left to a reasoner (see
- * the entailments in reo.ttl).
+ * the entailments in reo.ttl). The copies are the only nodes that are
+ * modified, and the edition holds them in its list of copies alone.
  */
-const withChanges = (value) => {
-    if (Array.isArray(value))
-        return value.map(withChanges);
-    if (!isRecord(value))
-        return value;
-    const node = Object.fromEntries(Object.entries(value).map(([key, child]) => [key, withChanges(child)]));
-    return node['@type'] === 'RollCopy' && Array.isArray(node.modifications)
-        ? { ...node, modifications: node.modifications.map(changing(node['@id'])) }
-        : node;
-};
+const withChanges = (edition) => Array.isArray(edition.copies) ? { ...edition, copies: edition.copies.map(withChangesOf) } : edition;
 /** Terms the context sets to null, which say nothing when the edition is read as RDF. */
 const silentTerms = new Set(Object.entries(context['@context'])
     .filter(([, definition]) => definition === null)
@@ -120,21 +116,24 @@ const quote = (subject, key, reference, listed) => {
     const { '@annotation': { '@id': annotation, ...about }, ...object } = reference;
     return { '@id': { '@id': subject, [key]: listed ? [object] : object }, annotation, ...about };
 };
-/** The value a node states under a key, less the doubted references, and those references quoted. */
-const quotingValue = (subject, key, value) => {
+/** The value a node states under a key, less the doubted references, which go to the quoted. */
+const unquoted = (subject, key, value, quoted) => {
     if (Array.isArray(value)) {
-        return {
-            node: value.filter(item => !isDoubtedReference(item)),
-            quoted: value.filter(isDoubtedReference).map(item => quote(subject, key, item, true))
-        };
+        return value.filter(item => {
+            if (!isDoubtedReference(item))
+                return true;
+            quoted.push(quote(subject, key, item, true));
+            return false;
+        });
     }
-    return isDoubtedReference(value)
-        ? { node: undefined, quoted: [quote(subject, key, value, false)] }
-        : { node: value, quoted: [] };
+    if (!isDoubtedReference(value))
+        return value;
+    quoted.push(quote(subject, key, value, false));
+    return undefined;
 };
 /**
  * The document with every doubted reference taken off the node that
- * states it, and quoted instead.
+ * states it, and quoted instead, in the order the document states them.
  *
  * An `@annotation` in JSON-LD-star states the triple it annotates and
  * then says something about it, so a statement the edition holds
@@ -142,32 +141,28 @@ const quotingValue = (subject, key, value) => {
  * between nodes are quoted, since only they can be put back where they
  * stood; a doubted date or attribution stays annotated in place.
  */
-const withDoubtedReferencesQuoted = (value) => {
-    if (Array.isArray(value)) {
-        const quotings = value.map(withDoubtedReferencesQuoted);
-        return { node: quotings.map(({ node }) => node), quoted: quotings.flatMap(({ quoted }) => quoted) };
-    }
+const withDoubtedReferencesQuoted = (value, quoted) => {
+    if (Array.isArray(value))
+        return value.map(item => withDoubtedReferencesQuoted(item, quoted));
     if (!isRecord(value))
-        return { node: value, quoted: [] };
+        return value;
     const subject = value['@id'];
-    const entries = Object.entries(value).map(([key, child]) => {
-        const own = typeof subject === 'string' && !key.startsWith('@')
-            ? quotingValue(subject, key, child)
-            : { node: child, quoted: [] };
-        const below = withDoubtedReferencesQuoted(own.node);
-        return { key, node: below.node, quoted: [...own.quoted, ...below.quoted] };
+    const node = {};
+    Object.entries(value).forEach(([key, child]) => {
+        const stated = typeof subject === 'string' && !key.startsWith('@') ? unquoted(subject, key, child, quoted) : child;
+        const below = withDoubtedReferencesQuoted(stated, quoted);
+        if (below !== undefined)
+            node[key] = below;
     });
-    return {
-        node: Object.fromEntries(entries.filter(({ node }) => node !== undefined).map(({ key, node }) => [key, node])),
-        quoted: entries.flatMap(({ quoted }) => quoted)
-    };
+    return node;
 };
 /** The edition with each copy's features and tears at the copy's own places, as a document holds them. */
 const atOwnPlacesAll = (edition) => edition.copies.some(copy => copy.measurements.alignment)
     ? { ...edition, copies: edition.copies.map(atOwnPlaces) }
     : edition;
 export const asJsonLd = (edition) => {
-    const { node, quoted } = withDoubtedReferencesQuoted(withSystemContexts(withCreations(withChanges(asJsonLdEntity(atOwnPlacesAll(edition))))));
+    const quoted = [];
+    const node = withDoubtedReferencesQuoted(withSystemContexts(withCreations(withChanges(asJsonLdEntity(atOwnPlacesAll(edition))))), quoted);
     // The context is the export's own; one carried in from an import must not override it.
     const { base, '@context': carried, ...rest } = node;
     return {

package/lib/io/migrate.js

@@ -1,7 +1,9 @@
+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";
 import { isDateString } from "../shared/utils.js";
+import { mapped, withValues } from "../ops/immutable.js";
 const retiredVersionTypes = new Set(['edition', 'unicum']);
 /**
  * The vocabulary the steps below were written against, as it stood in
@@ -37,10 +39,10 @@ const referenceKeys = ['alignedWith', 'pairedWith', 'basedOn'];
  * The five type terms that were capitalised while the rest of the
  * vocabulary was not, under the keys that carried them then.
  */
-const lowerCasedTerms = {
+const lowerCasedTerms = Object.entries({
     method: { Print: 'print', Handwriting: 'handwriting', Stamp: 'stamp' },
     material: { Paper: 'paper', Tape: 'tape' }
-};
+});
 const named = (name) => ({ name, sameAs: [] });
 const withRenamedKeys = (node) => Object.keys(node).some(key => Object.hasOwn(renamedKeys, key))
     ? Object.fromEntries(Object.entries(node).map(([key, value]) => [renamedKeys[key] ?? key, value]))
@@ -82,7 +84,7 @@ const withoutVersionSiglum = (node) => {
     const { siglum: _labelled, ...rest } = node;
     return rest;
 };
-const withLowerCaseTerms = (node) => Object.entries(lowerCasedTerms).reduce((result, [key, terms]) => {
+const withLowerCaseTerms = (node) => lowerCasedTerms.reduce((result, [key, terms]) => {
     const lowered = terms[result[key]];
     return lowered ? { ...result, [key]: lowered } : result;
 }, node);
@@ -450,26 +452,68 @@ const withTimeSpanDates = (node) => {
     const { '@value': within, '@type': _typed, ...rest } = node;
     return { ...rest, within };
 };
-const migrateNode = (node) => [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]
-    .reduce((result, step) => step(result), node);
-/** The items each walked, or the very same list where the walk changed none. */
-const walked = (items) => {
-    const result = items.map(walk);
-    return result.every((item, i) => item === items[i]) ? items : result;
-};
-/** The node with each child walked, or the very same node where the walk changed none. */
-const withWalkedChildren = (node) => {
-    const entries = Object.entries(node);
-    const result = entries.map(([key, child]) => [key, walk(child)]);
-    return result.every(([, child], i) => child === entries[i][1]) ? node : Object.fromEntries(result);
+/** 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,
+    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) => {
     if (Array.isArray(value))
-        return walked(value);
+        return mapped(value, walk);
     if (value && typeof value === 'object')
-        return withWalkedChildren(migrateNode(value));
+        return withValues(migrateNode(value), walk);
     return value;
 };
 /** The production of a copy, under whichever of its two names it carries. */
@@ -576,18 +620,21 @@ const statesNoTolerance = (version) => isSingleDerivation(version.basedOn) && !v
  * The collation tolerance was the edition's before it was stated on
  * each derivation. An edition written then collated every version at
  * that one value, so it is written onto every derivation that gives
- * none of its own.
+ * none of its own, and the edition states it no longer.
  */
 const withDerivationTolerance = (edition) => {
-    const collationTolerance = edition.creation?.collationTolerance;
-    const versions = Array.isArray(edition.versions) ? edition.versions : [];
-    if (!collationTolerance || !versions.some(statesNoTolerance))
+    if (!edition.creation || !Object.hasOwn(edition.creation, 'collationTolerance'))
         return edition;
+    const { collationTolerance, ...creation } = edition.creation;
+    const versions = listAt(edition, 'versions');
     return {
         ...edition,
-        versions: versions.map(version => statesNoTolerance(version)
-            ? { ...version, basedOn: { ...version.basedOn, collationTolerance } }
-            : version)
+        creation,
+        ...(collationTolerance && versions && {
+            versions: versions.map(version => statesNoTolerance(version)
+                ? { ...version, basedOn: { ...version.basedOn, collationTolerance } }
+                : version)
+        })
     };
 };
 /** Release 0.58.0 stated a revision of the format, which the format does not state. */

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 {};