linked-rolls 0.63.0 → 0.65.0

package/lib/ops/commands.js

@@ -1,29 +1,29 @@
-import { getAt } from "../view/EditionView.js";
+import { getAt, pathIn } from "../lookup/paths.js";
 import { isCommand, placementRelations } from "../model/Symbol.js";
 import { assignReference } from "../model/Assumption.js";
 import { reading } from "./draft.js";
 /**
- * Runs the change on the command the view locates by id, in whichever
- * version inserted it. A statement made there holds in every version
- * that carries the command.
+ * Runs the change on the command with the id, in whichever version
+ * inserted it. A statement made there holds in every version that
+ * carries the command.
  */
-const onCommand = (view, id, op) => reading(view, fresh => draft => {
-    const path = fresh.getPath(id);
+const onCommand = (id, op) => reading(edition => draft => {
+    const path = pathIn(edition, id);
     const symbol = path && getAt(path, draft);
     if (isCommand(symbol))
         op(symbol);
 });
 const clearPlacement = (command) => placementRelations.forEach(relation => { delete command[relation]; });
 /** States how the follower is placed relative to the reference, in place of any earlier statement. */
-export const placeCommand = (view, followerId, referenceId, relation) => onCommand(view, followerId, command => {
+export const placeCommand = (followerId, referenceId, relation) => onCommand(followerId, command => {
     clearPlacement(command);
     command[relation] = assignReference(referenceId);
 });
-export const unplaceCommand = (view, followerId) => onCommand(view, followerId, clearPlacement);
+export const unplaceCommand = (followerId) => onCommand(followerId, clearPlacement);
 /** The pair is stated on `statingId` only, as the format asks. */
-export const pairCommands = (view, statingId, partnerId) => onCommand(view, statingId, command => {
+export const pairCommands = (statingId, partnerId) => onCommand(statingId, command => {
     command.pairedWith = assignReference(partnerId);
 });
-export const unpairCommand = (view, statingId) => onCommand(view, statingId, command => {
+export const unpairCommand = (statingId) => onCommand(statingId, command => {
     delete command.pairedWith;
 });

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

@@ -1,4 +1,3 @@
-import { EditionView } from "../view/EditionView.js";
 /** What the operations are built from: the type of an operation, how one finds what it writes to on the draft, and the edits it writes. */
 import { Draft } from "immer";
 import { Edition } from "../model/Edition.js";
@@ -12,10 +11,10 @@ import { WithId } from "../shared/utils.js";
 /**
  * A change to an edition, written onto an immer draft of it. One
  * operation is one undo step, so an operation that has to read the
- * edition first takes an `EditionView` of the state it will be
- * applied to and does all its writing in the one function it returns.
- * Where operations run one after another on one draft, the ones after
- * the first read a view of the draft as it then stands (`reading`).
+ * edition reads it as the draft stands when the operation is applied
+ * (`reading`) and does all its writing in the one function it builds
+ * from that. Where operations run one after another on one draft, each
+ * reads what the ones before it wrote.
  */
 export type EditionOp = (draft: Draft<Edition>) => void;
 export declare const noChange: EditionOp;
@@ -23,16 +22,17 @@ export declare const onCopy: (copyId: string, op: (copy: Draft<RollCopy>, draft:
 export declare const onVersion: (versionId: string, op: (version: Draft<Version>, draft: Draft<Edition>) => void) => EditionOp;
 export declare const onFeature: (copyId: string, featureId: string, op: (feature: Draft<FeatureOrPatch>) => void) => EditionOp;
 /**
- * The operation built from a view of the state it is applied to. The
- * view given is used where the draft still stands as the view saw it,
- * and a fresh one is taken of the draft where an operation run before
- * on the same draft has changed it: a path or an index read off the
- * view would otherwise name what stood there before.
+ * The operation built from the state it is applied to: the draft as it
+ * stands, an operation run before on the same draft included. A path
+ * or an index read off an earlier state would name what stood there
+ * before. What is worked out from a state is kept with it, so a draft
+ * nothing has changed yet is read from what is known already.
  */
-export declare const reading: (view: EditionView, build: (view: EditionView) => EditionOp) => EditionOp;
+export declare const reading: (build: (edition: Edition) => EditionOp) => EditionOp;
 /**
  * The state a draft stands at, as plain data. Reading a draft proxies
- * everything it touches, so what is only read is read from this.
+ * everything it touches, so what is only read is read from this, and
+ * what is looked up in an edition is looked up in this (`takenOf`).
  */
 export declare const stateOf: <T>(draft: Draft<T>) => T;
 /** The ids of the items the rewriting left out. */

package/lib/ops/draft.js

@@ -1,12 +1,12 @@
-import { EditionView } from "../view/EditionView.js";
 /** What the operations are built from: the type of an operation, how one finds what it writes to on the draft, and the edits it writes. */
-import { current, isDraft } from "immer";
+import { isDraft } from "immer";
 import { v4 } from "uuid";
 import { unchecked, uncheckedMotivation } from "../collation/Collation.js";
 import { insertedBy } from "../model/Version.js";
 import { featuresOf } from "../model/RollCopy.js";
 import { assignReference } from "../model/Assumption.js";
 import { without, pruned } from "./immutable.js";
+import { takenOf } from "../lookup/perState.js";
 export const noChange = () => undefined;
 export const onCopy = (copyId, op) => draft => {
     const copy = draft.copies.find(c => c.id === copyId);
@@ -24,21 +24,19 @@ export const onFeature = (copyId, featureId, op) => onCopy(copyId, copy => {
         op(feature);
 });
 /**
- * The operation built from a view of the state it is applied to. The
- * view given is used where the draft still stands as the view saw it,
- * and a fresh one is taken of the draft where an operation run before
- * on the same draft has changed it: a path or an index read off the
- * view would otherwise name what stood there before.
+ * The operation built from the state it is applied to: the draft as it
+ * stands, an operation run before on the same draft included. A path
+ * or an index read off an earlier state would name what stood there
+ * before. What is worked out from a state is kept with it, so a draft
+ * nothing has changed yet is read from what is known already.
  */
-export const reading = (view, build) => draft => {
-    const state = stateOf(draft);
-    build(state === view.edition ? view : new EditionView(state))(draft);
-};
+export const reading = (build) => draft => build(stateOf(draft))(draft);
 /**
  * The state a draft stands at, as plain data. Reading a draft proxies
- * everything it touches, so what is only read is read from this.
+ * everything it touches, so what is only read is read from this, and
+ * what is looked up in an edition is looked up in this (`takenOf`).
  */
-export const stateOf = (draft) => isDraft(draft) ? current(draft) : draft;
+export const stateOf = (draft) => isDraft(draft) ? takenOf(draft) : draft;
 /** The ids of the items the rewriting left out. */
 export const droppedIds = (before, after) => {
     const kept = new Set(after.map(item => item.id));

package/lib/ops/edits.d.ts

@@ -1,10 +1,9 @@
-import { EditionView } from "../view/EditionView.js";
 import { Edit } from "../model/Edit.js";
 import { EditionOp } from "./draft.js";
 /**
  * Replaces the edits with a single one carrying all their insertions
  * and deletions, classified by a guess at what the exchange does.
  */
-export declare const mergeEdits: (given: EditionView, versionId: string, toMerge: readonly Edit[]) => EditionOp;
+export declare const mergeEdits: (versionId: string, toMerge: readonly Edit[]) => EditionOp;
 /** Replaces the edit with one edit per inserted and one per deleted symbol. */
 export declare const splitEdit: (versionId: string, toSplit: Edit) => EditionOp;

package/lib/ops/edits.js

@@ -4,6 +4,9 @@ import { editsOf } from "../model/Version.js";
 import { trackerBarOf } from "../systems/index.js";
 import { distance, mm, subtract } from "../model/Quantity.js";
 import { noChange, onVersion, insertion, deletion, reading } from "./draft.js";
+import { predecessorOf } from "../analysis/stemma.js";
+import { placeOf } from "../analysis/text.js";
+import { symbolsIn, versionIn } from "../lookup/lookup.js";
 const sameSequence = (a, b) => a.length === b.length && a.every((value, i) => value === b[i]);
 const expressionTypesOf = (symbols) => symbols.filter((symbol) => symbol.type === 'expression').map(symbol => symbol.expressionType);
 /** The spellings of a single added accent the bar offers, none where no bar is known. */
@@ -12,9 +15,9 @@ const lengthOf = (span) => subtract(span.to, span.from);
 /** How far apart two onsets may lie for the one symbol to count as a replacement of the other. */
 const REPLACEMENT_TOLERANCE = mm(5);
 /** Shorten or prolong, where the inserted symbol starts about where the deleted one did. */
-const replacementType = (view, inserted, deleted) => {
-    const after = view.placeOf(inserted);
-    const before = view.placeOf(deleted);
+const replacementType = (edition, inserted, deleted) => {
+    const after = placeOf(edition, inserted);
+    const before = placeOf(edition, deleted);
     if (!after || !before || distance(after.from, before.from) >= REPLACEMENT_TOLERANCE)
         return undefined;
     return lengthOf(after) < lengthOf(before) ? 'shorten' : 'prolong';
@@ -23,13 +26,13 @@ const replacementType = (view, inserted, deleted) => {
  * A guess at what an edit does, from the symbols it exchanges and from
  * the systems the version and the one it is based on are coded for.
  */
-const guessEditType = (view, versionId, edit) => {
+const guessEditType = (edition, versionId, edit) => {
     const inserts = edit.insert ?? [];
-    const deletes = view.symbols(edit.delete ?? []);
+    const deletes = symbolsIn(edition, edit.delete ?? []);
     const inserted = expressionTypesOf(inserts);
     const deleted = expressionTypesOf(deletes);
-    const bar = trackerBarOf(view.version(versionId)?.system);
-    const parentBar = trackerBarOf(view.predecessorOf(versionId)?.system);
+    const bar = trackerBarOf(versionIn(edition, versionId)?.system);
+    const parentBar = trackerBarOf(predecessorOf(edition, versionId)?.system);
     /**
      * Where the version is coded for another system than its parent,
      * expression matter changed is the transfer being carried out: a red
@@ -54,14 +57,14 @@ const guessEditType = (view, versionId, edit) => {
     if (inserted.length === 0 && deleted.length === 1)
         return 'remove-redundancy';
     if (inserts.length === 1 && deletes.length === 1)
-        return replacementType(view, inserts[0], deletes[0]) ?? 'correct-error';
+        return replacementType(edition, inserts[0], deletes[0]) ?? 'correct-error';
     return 'correct-error';
 };
 /**
  * Replaces the edits with a single one carrying all their insertions
  * and deletions, classified by a guess at what the exchange does.
  */
-export const mergeEdits = (given, versionId, toMerge) => reading(given, view => {
+export const mergeEdits = (versionId, toMerge) => reading(edition => {
     if (toMerge.length === 0)
         return noChange;
     const merged = {
@@ -70,7 +73,7 @@ export const mergeEdits = (given, versionId, toMerge) => reading(given, view =>
         insert: toMerge.flatMap(edit => edit.insert ?? []),
         delete: toMerge.flatMap(edit => edit.delete ?? [])
     };
-    merged.editType = guessEditType(view, versionId, merged);
+    merged.editType = guessEditType(edition, versionId, merged);
     const mergedIds = new Set(toMerge.map(edit => edit.id));
     return onVersion(versionId, version => {
         version.edits = [...editsOf(version).filter(edit => !mergedIds.has(edit.id)), merged];

package/lib/ops/features.d.ts

@@ -1,4 +1,4 @@
-import { EditionView } from "../view/EditionView.js";
+import { Edition } from "../model/Edition.js";
 import { ModificationPurpose } from "../model/RollCopy.js";
 import { FeatureConditionAssignment, FeatureOrPatch, NestedFeature } from "../model/Feature.js";
 import { EditionOp } from "./draft.js";
@@ -62,7 +62,7 @@ export declare const mergeObstacle: (features: readonly FeatureOrPatch[]) => Mer
  * feature is the work of one act, and where the features stand is the
  * edition's business rather than theirs.
  */
-export declare const mergeObstacleIn: (view: EditionView, featureIds: readonly string[]) => MergeObstacle | undefined;
+export declare const mergeObstacleIn: (edition: Edition, featureIds: readonly string[]) => MergeObstacle | undefined;
 /**
  * Replaces the features of the copy with a single one covering them
  * all, where a scan has split what the editor reads as one feature.

package/lib/ops/features.js

@@ -6,6 +6,7 @@ import { mm } from "../model/Quantity.js";
 import { onCopy, onFeature, stateOf } from "./draft.js";
 import { without, mapped, pruned, replacing, isRecord } from "./immutable.js";
 import { renameReferences, forgetFeatures } from "./forget.js";
+import { copyOfFeature } from "../lookup/lookup.js";
 /**
  * Whether the feature's own kind allows a condition of this kind. The
  * type narrowed to is the weaker statement, holding of a condition any
@@ -209,8 +210,8 @@ const obstacleIn = (copy, featureIds) => {
  * feature is the work of one act, and where the features stand is the
  * edition's business rather than theirs.
  */
-export const mergeObstacleIn = (view, featureIds) => {
-    const copy = featureIds.map(id => view.copyOf(id)).find(copy => copy !== undefined);
+export const mergeObstacleIn = (edition, featureIds) => {
+    const copy = featureIds.map(id => copyOfFeature(edition, id)).find(copy => copy !== undefined);
     return copy ? obstacleIn(copy, featureIds) : 'fewer-than-two';
 };
 /** The items with the replacement in the place of the first it stands for, the others dropped. */

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

@@ -3,7 +3,7 @@
  * They are grouped by what they change under `ops/`; this module names
  * the ones the library offers.
  */
-export type { EditionOp } from "./draft.js";
+export { stateOf, type EditionOp } from "./draft.js";
 export { createVersion, addCopy, alignmentFor, alignCopy, alignCopies, chooseReferenceCopy, unalignCopy, shortenCopy, unshortenCopy, stateSource, clearSource, nameCopy, stateCarriage, clearCarriage, addGeneralCondition, statePaperStretch, addTear, symbolsCarriedOnlyBy, removeCopy } from "./copies.js";
 export { stateFeatureCondition, addFeature, addBorneFeature, removeFeatures, mergeObstacle, mergeObstacleIn, mergeFeatures, type FeatureAct, type MergeObstacle } from "./features.js";
 export { detachVersion, removeVersion, removeSymbols, deriveVersion, stateDerivation, clearDerivation } from "./versions.js";

package/lib/ops/index.js

@@ -1,3 +1,9 @@
+/**
+ * The operations on an edition, each written onto an immer draft of it.
+ * They are grouped by what they change under `ops/`; this module names
+ * the ones the library offers.
+ */
+export { stateOf } from "./draft.js";
 export { createVersion, addCopy, alignmentFor, alignCopy, alignCopies, chooseReferenceCopy, unalignCopy, shortenCopy, unshortenCopy, stateSource, clearSource, nameCopy, stateCarriage, clearCarriage, addGeneralCondition, statePaperStretch, addTear, symbolsCarriedOnlyBy, removeCopy } from "./copies.js";
 export { stateFeatureCondition, addFeature, addBorneFeature, removeFeatures, mergeObstacle, mergeObstacleIn, mergeFeatures } from "./features.js";
 export { detachVersion, removeVersion, removeSymbols, deriveVersion, stateDerivation, clearDerivation } from "./versions.js";

package/lib/ops/versions.d.ts

@@ -1,4 +1,3 @@
-import { EditionView } from "../view/EditionView.js";
 import { Derivation, Version } from "../model/Version.js";
 import { Belief } from "../model/Assumption.js";
 import { EditionOp } from "./draft.js";
@@ -9,13 +8,13 @@ export declare const hypothesesBeside: (version: Readonly<Version>, parentId: st
  * own insertions, and its derivations go, the hypotheses among them,
  * with the motivations that belonged to them.
  */
-export declare const detachVersion: (given: EditionView, versionId: string) => EditionOp;
+export declare const detachVersion: (versionId: string) => EditionOp;
 /**
  * Takes the version out. Whatever read its text against it comes to
  * stand on its own, a hypothesis that something derives from it goes,
  * and so does a copy's statement that it carries the version.
  */
-export declare const removeVersion: (given: EditionView, versionId: string) => EditionOp;
+export declare const removeVersion: (versionId: string) => EditionOp;
 /** Takes the symbols out of the version's own insertions, and the edits that had nothing else. */
 export declare const removeSymbols: (versionId: string, symbolIds: readonly string[]) => EditionOp;
 /** Moves the edits into a new version based on this one. */

package/lib/ops/versions.js

@@ -4,6 +4,7 @@ import { assignReference, idOf } from "../model/Assumption.js";
 import { onVersion, stateOf, insertion, dropInsertions, referenceHeld, withoutReferences, reading } from "./draft.js";
 import { without } from "./immutable.js";
 import { dropStatements } from "./copies.js";
+import { snapshotOf } from "../analysis/text.js";
 /** Whether the version's text is read against the parent, its principal derivation naming it. */
 const readsAgainst = (version, parentId) => {
     const principal = principalDerivationOf(version);
@@ -30,8 +31,8 @@ const dropDerivations = (version, matches) => {
  * own insertions, and its derivations go, the hypotheses among them,
  * with the motivations that belonged to them.
  */
-export const detachVersion = (given, versionId) => reading(given, view => {
-    const edits = view.snapshot(versionId).map(insertion);
+export const detachVersion = (versionId) => reading(edition => {
+    const edits = snapshotOf(edition, versionId).map(insertion);
     return onVersion(versionId, version => {
         version.edits = edits;
         delete version.basedOn;
@@ -43,10 +44,10 @@ export const detachVersion = (given, versionId) => reading(given, view => {
  * stand on its own, a hypothesis that something derives from it goes,
  * and so does a copy's statement that it carries the version.
  */
-export const removeVersion = (given, versionId) => reading(given, view => {
-    const detachments = view.edition.versions
+export const removeVersion = (versionId) => reading(edition => {
+    const detachments = edition.versions
         .filter(version => readsAgainst(version, versionId))
-        .map(version => detachVersion(view, version.id));
+        .map(version => detachVersion(version.id));
     const namesIt = (reference) => idOf(reference) === versionId;
     return draft => {
         detachments.forEach(detach => detach(draft));

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": [
                 {
@@ -523,7 +497,7 @@
             "type": "string"
         },
         "Edit": {
-            "description": "A set of edits transforms a version of a roll into another version. Edits insert or delete symbols, or both (= replace). Edits may be motivated by a given set of reasons, e.g. to add an additional accent or to correct an error. If an edit is the interpretation of a metamark, such as a pencil mark, this should be made explicit using a meaning comprehension on the `@annotation` field.",
+            "description": "A set of edits transforms a version of a roll into another version. Edits insert or delete symbols, or both (= replace). Edits may be motivated by a given set of reasons, e.g. to add an additional accent or to correct an error. If an edit is the interpretation of a metamark, such as a pencil mark, this should be made explicit using a meaning comprehension on the `@annotation` field. An edit states no date. That it ended no later than the act that made a feature carrying a symbol it inserts, a reasoner derives with the axioms of reo.ttl; which of those dates bounds it closest is for a query to pick.",
             "properties": {
                 "@annotation": {
                     "description": "An optional annotation expressing a belief about this assumption. Uses the JSON-LD-star `@annotation` mechanism to attach epistemic metadata (certainty and reasons) to any triple.",
@@ -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": {
@@ -3523,7 +3492,7 @@
                 },
                 "creation": {
                     "$ref": "#/definitions/VersionCreation",
-                    "description": "The act that made this version, where it is known: who carried it out, when, and by what rule.",
+                    "description": "The act that made this version, where it is known: who carried it out, when, and by what rule. The export states the act for every version, stating nothing of it where nothing is known, so that the axioms of reo.ttl can place it in time: it started after the recording and the creation of every version it derives from had started, and ended no later than the punching of any copy carrying a symbol it added. A date stated here stands beside those; which of them bounds the act closest is for a query to pick.",
                     "ontology": "lrmoo:R17i was created by"
                 },
                 "edits": {

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;