linked-rolls 0.64.0 → 0.65.0

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/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

@@ -2,6 +2,7 @@ import { systemIdIn, systemOf, translationBetween } from "../systems/TrackerBar.
 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 +38,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 +83,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 +451,16 @@ 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,
+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]
-    .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);
-};
+    withoutFeatureKind, withBorneFeaturesNamed, withFeaturesInActs, withOwnPlaces, withDriveOfStaggering, withoutPattern, withoutBearings, withoutEntailedType];
+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 +567,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/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/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

@@ -3,6 +3,7 @@ import { AtonParser } from "./AtonParser.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 +21,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 +72,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)

package/lib/schema.json

@@ -272,32 +272,6 @@
             ],
             "type": "string"
         },
-        "CollationTolerance": {
-            "description": "The window two readings of one feature must fall in to be collated: how far apart they may lie at either end, and where that window is centred.\n\nThe centre is worth stating. Two copies of one roll differ by a systematic offset as well as by scatter, and a window centred on nothing has to be widened by the whole of that offset before it admits what the offset alone displaces. Naming the offset lets the tolerance stand for the scatter only. A window that names none is centred on nothing, which is what every window written before the offset was held here means.",
-            "properties": {
-                "offsetEnd": {
-                    "$ref": "#/definitions/Millimeters",
-                    "description": "The same at the end of a feature, in the same direction."
-                },
-                "offsetStart": {
-                    "$ref": "#/definitions/Millimeters",
-                    "description": "How much later the derived version puts the start of a feature than the version it is read against, where the two differ systematically. Nothing where they do not.\n\nThe direction is the one a collation measures in, the child less the parent, and it is not symmetric: stored the other way round the window sits on the wrong side of the readings and merges what it should separate. A measurement taken over the parent's copies gives the negative of this, which is what `toleranceAcross` asks the side for."
-                },
-                "toleranceEnd": {
-                    "$ref": "#/definitions/Millimeters",
-                    "description": "How far they may lie apart at the end, measured from `offsetEnd`."
-                },
-                "toleranceStart": {
-                    "$ref": "#/definitions/Millimeters",
-                    "description": "How far the two readings may lie apart at the start of a feature, measured from `offsetStart`."
-                }
-            },
-            "required": [
-                "toleranceStart",
-                "toleranceEnd"
-            ],
-            "type": "object"
-        },
         "Concept": {
             "anyOf": [
                 {
@@ -671,11 +645,6 @@
         "EditionCreation": {
             "description": "This type describes the creation of an edition, i.e. the editor, publisher, and publication date.",
             "properties": {
-                "collationTolerance": {
-                    "$ref": "#/definitions/CollationTolerance",
-                    "deprecated": true,
-                    "description": "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."
-                },
                 "editors": {
                     "description": "The persons who prepared the edition, each with the part they took in the editorial work. An edition written before this field existed carries none.",
                     "items": {

package/lib/systems/welte.d.ts

@@ -42,6 +42,23 @@ export type WelteOptions = {
 };
 /** Whether two sets of constants are the same, value for value. */
 export declare const sameParameters: (a: Parameters, b: Parameters) => boolean;
+/**
+ * The two readings of the pedal mechanism the emulator offers, by name,
+ * which the systems share: Hagmann has the valves and bellows that carry
+ * out the movements "in beiden Systemen dieselbe" (p. 106), and only the
+ * Vorpneumatik differs. Under `damping` the dampers reach the strings
+ * within the shortest lift the rolls punch, so every lift damps. Under
+ * `brushing` their fall is slowed until the quick runs of latch changes
+ * in the SUPRA corpus dip without damping, at the price that lifts
+ * shorter than about 265 ms brush as well.
+ */
+export declare const pedalPresets: {
+    damping: Readonly<Record<string, number>>;
+    brushing: Readonly<Record<string, number>>;
+};
+export type PedalPreset = keyof typeof pedalPresets;
+/** The preset a set of pedal constants is, if it is one. */
+export declare const pedalPresetOf: (pedals: Parameters) => PedalPreset | undefined;
 /**
  * Between the edition's shared place axis and this version's own paper.
  * `toOwnPaper` is 1 for a version on the axis it was measured on, and about

package/lib/systems/welte.js

@@ -1,10 +1,26 @@
-import { clamp, geometryInMm, Grid, levelChanges, mezzoforteTravel, paperSeconds, ROWS_PER_MM, travelBetweenRails, } from "welte-mignon-emulator";
+import { clamp, geometryInMm, Grid, levelChanges, mezzoforteTravel, paperSeconds, pedalBrushing, pedalDefaults, ROWS_PER_MM, travelBetweenRails, } from "welte-mignon-emulator";
 import { inCentimeters, mm, seconds } from "../model/Quantity.js";
 import { partitionPoint } from "../shared/sorted.js";
 import { velocityOf } from "./velocity.js";
 /** Whether two sets of constants are the same, value for value. */
 export const sameParameters = (a, b) => Object.keys(a).length === Object.keys(b).length
     && Object.entries(a).every(([name, value]) => b[name] === value);
+/**
+ * The two readings of the pedal mechanism the emulator offers, by name,
+ * which the systems share: Hagmann has the valves and bellows that carry
+ * out the movements "in beiden Systemen dieselbe" (p. 106), and only the
+ * Vorpneumatik differs. Under `damping` the dampers reach the strings
+ * within the shortest lift the rolls punch, so every lift damps. Under
+ * `brushing` their fall is slowed until the quick runs of latch changes
+ * in the SUPRA corpus dip without damping, at the price that lifts
+ * shorter than about 265 ms brush as well.
+ */
+export const pedalPresets = {
+    damping: pedalDefaults,
+    brushing: pedalBrushing
+};
+/** The preset a set of pedal constants is, if it is one. */
+export const pedalPresetOf = (pedals) => Object.keys(pedalPresets).find(name => sameParameters(pedalPresets[name], pedals));
 /** Paper the grid runs on past the last hole, so that a final pedal release completes. */
 const RUN_OUT = mm(100);
 const isNote = (event) => event.type === 'note';

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

@@ -3,7 +3,7 @@ import { Instrument, RollNumber } from "welte-mignon-emulator/t100";
 import { NegotiatedEvent, Performance, ReproducingSystem, RollProperties } from "../ReproducingSystem.js";
 import { type WelteOptions } from "../welte.js";
 export type { VelocityMap } from "../velocity.js";
-export { secondsAt } from "../welte.js";
+export { pedalPresetOf, pedalPresets, secondsAt, type PedalPreset } from "../welte.js";
 export type { Instrument } from "welte-mignon-emulator/t100";
 export type InstrumentName = 'consensus' | RollNumber;
 /**
@@ -19,21 +19,6 @@ export declare const instrumentNames: readonly InstrumentName[];
 export declare const nuanceOf: (instrument: Instrument) => Record<Half, Parameters>;
 /** The instrument a pair of nuancing constants belongs to, if it is one. */
 export declare const instrumentNameOf: (nuance: Record<Half, Parameters>) => InstrumentName | undefined;
-/**
- * The two readings of the pedal mechanism the emulator offers, by name.
- * Under `damping` the dampers reach the strings within the shortest lift
- * the rolls punch, so every lift damps. Under `brushing` their fall is
- * slowed until the quick runs of latch changes in the SUPRA corpus dip
- * without damping, at the price that lifts shorter than about 265 ms brush
- * as well.
- */
-export declare const pedalPresets: {
-    damping: Readonly<Record<string, number>>;
-    brushing: Readonly<Record<string, number>>;
-};
-export type PedalPreset = keyof typeof pedalPresets;
-/** The preset a set of pedal constants is, if it is one. */
-export declare const pedalPresetOf: (pedals: Parameters) => PedalPreset | undefined;
 /** The T-100 takes the options every Welte system does; see `WelteOptions`. */
 export type WelteT100Options = WelteOptions;
 export declare const defaultWelteT100Options: WelteT100Options;

package/lib/systems/welteT100/system.js

@@ -1,10 +1,10 @@
-import { DEFAULT_PUNCH_MM, pedalBrushing, pedalDefaults, TRACKER_BORE_MM, WELTE_SPOOL, } from "welte-mignon-emulator";
+import { DEFAULT_PUNCH_MM, TRACKER_BORE_MM, WELTE_SPOOL, } from "welte-mignon-emulator";
 import { aperturePorts, CONSENSUS, pneumaticModel, PRESETS, runPedals, } from "welte-mignon-emulator/t100";
 import { welteT100 } from "./bar.js";
 import { mm, track } from "../../model/Quantity.js";
 import { defaultVelocityMap } from "../velocity.js";
-import { performWelte, sameParameters } from "../welte.js";
-export { secondsAt } from "../welte.js";
+import { pedalPresets, performWelte, sameParameters } from "../welte.js";
+export { pedalPresetOf, pedalPresets, secondsAt } from "../welte.js";
 /**
  * The instruments the emulator was fitted as: the consensus over the six
  * rolls with drawn nuance lines, and the setting that drew each of them,
@@ -18,20 +18,6 @@ export const instrumentNames = ['consensus', ...Object.keys(PRESETS)];
 export const nuanceOf = (instrument) => ({ bass: instrument.bass, treble: instrument.treble });
 /** The instrument a pair of nuancing constants belongs to, if it is one. */
 export const instrumentNameOf = (nuance) => instrumentNames.find(name => sameParameters(instruments[name].bass, nuance.bass) && sameParameters(instruments[name].treble, nuance.treble));
-/**
- * The two readings of the pedal mechanism the emulator offers, by name.
- * Under `damping` the dampers reach the strings within the shortest lift
- * the rolls punch, so every lift damps. Under `brushing` their fall is
- * slowed until the quick runs of latch changes in the SUPRA corpus dip
- * without damping, at the price that lifts shorter than about 265 ms brush
- * as well.
- */
-export const pedalPresets = {
-    damping: pedalDefaults,
-    brushing: pedalBrushing
-};
-/** The preset a set of pedal constants is, if it is one. */
-export const pedalPresetOf = (pedals) => Object.keys(pedalPresets).find(name => sameParameters(pedalPresets[name], pedals));
 export const defaultWelteT100Options = {
     spool: WELTE_SPOOL,
     nuance: nuanceOf(instruments.consensus),

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

@@ -4,7 +4,7 @@ import { ReproducingSystem } from "../ReproducingSystem.js";
 import { Millimeters } from "../../model/Quantity.js";
 import { type WelteOptions } from "../welte.js";
 export type { VelocityMap } from "../velocity.js";
-export { secondsAt } from "../welte.js";
+export { pedalPresetOf, pedalPresets, secondsAt, type PedalPreset } from "../welte.js";
 export type { WelteT98Instrument, WelteT98InstrumentName } from "welte-mignon-emulator/t98";
 /**
  * The instruments the emulator offers for the green Welte, in three groups that
@@ -44,17 +44,6 @@ export declare const instrumentNames: readonly WelteT98InstrumentName[];
 /** The instrument a pair of nuancing constants belongs to, if it is one. */
 export declare const instrumentNameOf: (nuance: Record<Half, Parameters>) => WelteT98InstrumentName | undefined;
 export { instrumentT98Of, labelOf, nuanceOf };
-/**
- * The two readings of the pedal mechanism, which is the T-100's below the
- * command: Hagmann has the valves and bellows that carry out the movements "in
- * beiden Systemen dieselbe" (p. 106), and only the Vorpneumatik differs.
- */
-export declare const pedalPresets: {
-    damping: Readonly<Record<string, number>>;
-    brushing: Readonly<Record<string, number>>;
-};
-export type PedalPreset = keyof typeof pedalPresets;
-export declare const pedalPresetOf: (pedals: Parameters) => PedalPreset | undefined;
 /**
  * The options every Welte system takes (see `WelteOptions`), with what the
  * T-98 adds. No source states a T-98 spool geometry, so the default keeps the

package/lib/systems/welteT98/system.js

@@ -1,10 +1,10 @@
-import { pedalBrushing, pedalDefaults, ROWS_PER_MM, WELTE_T98_SPOOL, } from "welte-mignon-emulator";
+import { ROWS_PER_MM, WELTE_T98_SPOOL, } from "welte-mignon-emulator";
 import { aperturePorts, CHAIN_GAP_MM, DERIVED, GENUINE, instrumentT98Of, labelOf, nuanceOf, PUNCH_T98_MM, pneumaticT98Model, rewindAt, runPedals, sforzandoPianoLift, STARTING_VALUES, TRACKER_BORE_T98_MM, } from "welte-mignon-emulator/t98";
 import { welteT98 } from "./bar.js";
 import { mm, seconds, track } from "../../model/Quantity.js";
 import { defaultVelocityMap } from "../velocity.js";
-import { performWelte, sameParameters } from "../welte.js";
-export { secondsAt } from "../welte.js";
+import { pedalPresets, performWelte, sameParameters } from "../welte.js";
+export { pedalPresetOf, pedalPresets, secondsAt } from "../welte.js";
 /**
  * The instruments the emulator offers for the green Welte, in three groups that
  * answer three different questions and must not be listed as one.
@@ -46,16 +46,6 @@ export const instrumentNameOf = (nuance) => instrumentNames.find(name => {
         && sameParameters(instrument.treble, nuance.treble);
 });
 export { instrumentT98Of, labelOf, nuanceOf };
-/**
- * The two readings of the pedal mechanism, which is the T-100's below the
- * command: Hagmann has the valves and bellows that carry out the movements "in
- * beiden Systemen dieselbe" (p. 106), and only the Vorpneumatik differs.
- */
-export const pedalPresets = {
-    damping: pedalDefaults,
-    brushing: pedalBrushing
-};
-export const pedalPresetOf = (pedals) => Object.keys(pedalPresets).find(name => sameParameters(pedalPresets[name], pedals));
 export const defaultWelteT98Options = {
     spool: WELTE_T98_SPOOL,
     nuance: nuanceOf(GENUINE.consensus),

package/package.json

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