linked-rolls 0.4.1 → 0.5.1

package/lib/editionOps.d.ts

@@ -0,0 +1,76 @@
+import { Draft } from "immer";
+import { EditionView, Path } from "./EditionView";
+import { Edition } from "./Edition";
+import { AnySymbol, PlacementRelation } from "./Symbol";
+import { CollationTolerance } from "./Collation";
+import { Edit } from "./Edit";
+import { PaperStretch, RollCopy, Shift } from "./RollCopy";
+import { AnyArgumentation, Certainty, ObjectAssumption } from "./Assumption";
+/**
+ * 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.
+ */
+export type EditionOp = (draft: Draft<Edition>) => void;
+/**
+ * Puts the copy into the edition with a version of its own, which
+ * inserts every symbol the tracker bar reads on the copy.
+ */
+export declare const createVersion: (siglum: string, copy: RollCopy) => EditionOp;
+/** Shifts and then stretches the copy's features into line with another copy's. */
+export declare const alignCopy: (copyId: string, shift: Shift, stretch: ObjectAssumption<PaperStretch>) => EditionOp;
+/** Puts the copy's features back where they were measured. */
+export declare const unalignCopy: (copyId: string) => EditionOp;
+/** The symbols of the versions that no other copy carries. */
+export declare const symbolsCarriedOnlyBy: (edition: Edition, copyId: string) => AnySymbol[];
+/** Takes the features off the copy, and out of the versions with what only they carried. */
+export declare const removeFeatures: (copyId: string, featureIds: readonly string[]) => EditionOp;
+/**
+ * Takes the copy out of the edition together with the symbols only it
+ * carries, and with every reference the versions made to those symbols.
+ */
+export declare const removeCopy: (copyId: string) => EditionOp;
+/**
+ * Bases the child on the parent. A symbol of the child that collates
+ * with one the parent hands down adds its carriers to that symbol; the
+ * rest become the child's insertions, and what the parent hands down
+ * and the child lacks becomes its deletions.
+ */
+export declare const connectVersions: (view: EditionView, childId: string, parentId: string, tolerance?: CollationTolerance) => EditionOp;
+/**
+ * Folds the version's own symbols into those it inherits and collates
+ * with: the carriers pass over, and the insertions go.
+ */
+export declare const collateSymbols: (view: EditionView, versionId: string, symbolIds: readonly string[], tolerance?: CollationTolerance) => EditionOp;
+/**
+ * Makes the version stand on its own: what it inherited becomes its
+ * own insertions, and the link to the version it was based on goes,
+ * with the motivations that belonged to that derivation.
+ */
+export declare const detachVersion: (view: EditionView, versionId: string) => EditionOp;
+/** Takes the version out; whatever was based on it comes to stand on its own. */
+export declare const removeVersion: (view: EditionView, 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. */
+export declare const deriveVersion: (versionId: string, editIds: readonly string[]) => EditionOp;
+/**
+ * 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: (view: EditionView, 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;
+/** States how the follower is placed relative to the reference, in place of any earlier statement. */
+export declare const placePerforation: (view: EditionView, followerId: string, referenceId: string, relation: PlacementRelation) => EditionOp;
+export declare const unplacePerforation: (view: EditionView, followerId: string) => EditionOp;
+/** The pair is stated on `statingId` only, as the format asks. */
+export declare const pairPerforations: (view: EditionView, statingId: string, partnerId: string) => EditionOp;
+export declare const unpairPerforation: (view: EditionView, statingId: string) => EditionOp;
+/** Annotates the assumption at the path with a belief held true, for reasons to be added. */
+export declare const createBelief: (path: Path) => EditionOp;
+export declare const clearBelief: (path: Path) => EditionOp;
+export declare const setCertainty: (path: Path, certainty: Certainty) => EditionOp;
+export declare const addReason: (path: Path, reason: AnyArgumentation) => EditionOp;
+export declare const removeReason: (path: Path, index: number) => EditionOp;

package/lib/editionOps.js

@@ -0,0 +1,312 @@
+import { v4 } from "uuid";
+import { getAt } from "./EditionView";
+import { isPerforation, placementRelations } from "./Symbol";
+import { collationsOf, defaultCollationTolerance } from "./Collation";
+import { asSymbols } from "./RollCopy";
+import { applyShift, applyStretch, revertShift, revertStretch } from "./alignment";
+import { assignReference, idOf } from "./Assumption";
+const noChange = () => undefined;
+const onCopy = (copyId, op) => draft => {
+    const copy = draft.copies.find(c => c.id === copyId);
+    if (copy)
+        op(copy, draft);
+};
+const onVersion = (versionId, op) => draft => {
+    const version = draft.versions.find(v => v.id === versionId);
+    if (version)
+        op(version, draft);
+};
+/** The items that do not match, or the very same array when none does, so that a draft stays untouched. */
+const without = (items, matches) => items.some(matches) ? items.filter(item => !matches(item)) : items;
+const insertion = (symbol) => ({ type: 'edit', id: v4(), insert: [symbol] });
+const deletion = (symbolId) => ({ type: 'edit', id: v4(), delete: [symbolId] });
+const isEmpty = (edit) => !edit.insert?.length && !edit.delete?.length;
+const insertedIn = (versions) => versions.flatMap(version => version.edits).flatMap(edit => edit.insert ?? []);
+/** Runs the change over the version's edits and drops those it emptied, leaving edits that were empty before alone. */
+const editing = (version, change) => {
+    const emptyBefore = new Set(version.edits.filter(isEmpty).map(edit => edit.id));
+    version.edits.forEach(change);
+    version.edits = without(version.edits, edit => isEmpty(edit) && !emptyBefore.has(edit.id));
+};
+/** Takes the symbols out of the version's own insertions. */
+const dropInsertions = (version, symbolIds) => editing(version, edit => {
+    if (edit.insert)
+        edit.insert = without(edit.insert, symbol => symbolIds.has(symbol.id));
+});
+/**
+ * Puts the copy into the edition with a version of its own, which
+ * inserts every symbol the tracker bar reads on the copy.
+ */
+export const createVersion = (siglum, copy) => draft => {
+    draft.copies.push(copy);
+    draft.versions.push({
+        type: 'Version',
+        id: v4(),
+        siglum,
+        versionType: 'edition',
+        edits: asSymbols(copy.features).map(insertion),
+        motivations: []
+    });
+};
+/** Shifts and then stretches the copy's features into line with another copy's. */
+export const alignCopy = (copyId, shift, stretch) => onCopy(copyId, copy => {
+    applyShift(shift, copy);
+    applyStretch(stretch, copy);
+});
+/** Puts the copy's features back where they were measured. */
+export const unalignCopy = (copyId) => onCopy(copyId, copy => {
+    revertStretch(copy);
+    revertShift(copy);
+});
+const featureIdsOf = (copy) => new Set(copy.features.map(feature => feature.id));
+/**
+ * A symbol every carrier of which lies among the features loses its
+ * evidence with them. A symbol without carriers, such as a label,
+ * stands on its own.
+ */
+const carriedOnlyOn = (features) => (symbol) => symbol.carriers.length > 0 && symbol.carriers.every(carrier => features.has(idOf(carrier)));
+/** The symbols of the versions that no other copy carries. */
+export const symbolsCarriedOnlyBy = (edition, copyId) => {
+    const copy = edition.copies.find(c => c.id === copyId);
+    return copy ? insertedIn(edition.versions).filter(carriedOnlyOn(featureIdsOf(copy))) : [];
+};
+const references = [...placementRelations, 'pairedWith'];
+const forgetPerforations = (perforation, dropped) => references
+    .filter(relation => {
+    const reference = perforation[relation];
+    return reference && dropped.has(idOf(reference));
+})
+    .forEach(relation => { delete perforation[relation]; });
+const forgetCarriers = (symbol, features, dropped) => {
+    symbol.carriers = without(symbol.carriers, carrier => features.has(idOf(carrier)));
+    if (isPerforation(symbol))
+        forgetPerforations(symbol, dropped);
+};
+const forgetFeaturesInEdit = (edit, features, dropped) => {
+    if (edit.insert) {
+        edit.insert = without(edit.insert, symbol => dropped.has(symbol.id));
+        edit.insert.forEach(symbol => forgetCarriers(symbol, features, dropped));
+    }
+    if (edit.delete) {
+        edit.delete = without(edit.delete, id => dropped.has(id));
+    }
+};
+/**
+ * Strikes the features from the versions: their carriers go, a symbol
+ * that had no other carrier goes with them, and so does every
+ * reference the versions made to such a symbol.
+ */
+const forgetFeatures = (draft, features) => {
+    const dropped = new Set(insertedIn(draft.versions).filter(carriedOnlyOn(features)).map(symbol => symbol.id));
+    draft.versions.forEach(version => editing(version, edit => forgetFeaturesInEdit(edit, features, dropped)));
+};
+/** Takes the features off the copy, and out of the versions with what only they carried. */
+export const removeFeatures = (copyId, featureIds) => onCopy(copyId, (copy, draft) => {
+    const features = new Set(featureIds);
+    copy.features = without(copy.features, feature => features.has(feature.id));
+    forgetFeatures(draft, features);
+});
+/**
+ * Takes the copy out of the edition together with the symbols only it
+ * carries, and with every reference the versions made to those symbols.
+ */
+export const removeCopy = (copyId) => onCopy(copyId, (copy, draft) => {
+    forgetFeatures(draft, featureIdsOf(copy));
+    draft.copies = draft.copies.filter(c => c.id !== copyId);
+});
+/** The carriers of each collated symbol pass to its counterpart. */
+const handOverCarriers = (view, draft, collations) => collations.forEach(({ symbol, counterpart }) => {
+    const path = view.getPath(counterpart.id);
+    const target = path && getAt(path, draft);
+    target?.carriers.push(...symbol.carriers);
+});
+/**
+ * Bases the child on the parent. A symbol of the child that collates
+ * with one the parent hands down adds its carriers to that symbol; the
+ * rest become the child's insertions, and what the parent hands down
+ * and the child lacks becomes its deletions.
+ */
+export const connectVersions = (view, childId, parentId, tolerance = defaultCollationTolerance) => {
+    const inherited = view.snapshot(parentId);
+    const own = view.snapshot(childId);
+    const collations = collationsOf(own, inherited, symbol => view.dimensionOf(symbol), tolerance);
+    const collated = new Set(collations.map(({ symbol }) => symbol.id));
+    const matched = new Set(collations.map(({ counterpart }) => counterpart.id));
+    const edits = [
+        ...own.filter(symbol => !collated.has(symbol.id)).map(insertion),
+        ...inherited.filter(symbol => !matched.has(symbol.id)).map(symbol => deletion(symbol.id))
+    ];
+    return onVersion(childId, (child, draft) => {
+        handOverCarriers(view, draft, collations);
+        child.edits = edits;
+        child.basedOn = assignReference(parentId);
+    });
+};
+/**
+ * Folds the version's own symbols into those it inherits and collates
+ * with: the carriers pass over, and the insertions go.
+ */
+export const collateSymbols = (view, versionId, symbolIds, tolerance = defaultCollationTolerance) => {
+    const version = view.get(versionId);
+    if (!version?.basedOn)
+        return noChange;
+    const chosen = new Set(symbolIds);
+    const own = insertedIn([version]).filter(symbol => chosen.has(symbol.id));
+    const collations = collationsOf(own, view.snapshot(idOf(version.basedOn)), symbol => view.dimensionOf(symbol), tolerance);
+    const collated = new Set(collations.map(({ symbol }) => symbol.id));
+    return onVersion(versionId, (version, draft) => {
+        handOverCarriers(view, draft, collations);
+        dropInsertions(version, collated);
+    });
+};
+/**
+ * Makes the version stand on its own: what it inherited becomes its
+ * own insertions, and the link to the version it was based on goes,
+ * with the motivations that belonged to that derivation.
+ */
+export const detachVersion = (view, versionId) => {
+    const edits = view.snapshot(versionId).map(insertion);
+    return onVersion(versionId, version => {
+        version.edits = edits;
+        delete version.basedOn;
+        version.motivations = [];
+    });
+};
+/** Takes the version out; whatever was based on it comes to stand on its own. */
+export const removeVersion = (view, versionId) => {
+    const detachments = view.edition.versions
+        .filter(version => version.basedOn && idOf(version.basedOn) === versionId)
+        .map(version => detachVersion(view, version.id));
+    return draft => {
+        detachments.forEach(detach => detach(draft));
+        draft.versions = without(draft.versions, version => version.id === versionId);
+    };
+};
+/** Takes the symbols out of the version's own insertions, and the edits that had nothing else. */
+export const removeSymbols = (versionId, symbolIds) => onVersion(versionId, version => dropInsertions(version, new Set(symbolIds)));
+/** Moves the edits into a new version based on this one. */
+export const deriveVersion = (versionId, editIds) => onVersion(versionId, (version, draft) => {
+    const chosen = new Set(editIds);
+    const moved = version.edits.filter(edit => chosen.has(edit.id));
+    version.edits = without(version.edits, edit => chosen.has(edit.id));
+    draft.versions.push({
+        type: 'Version',
+        id: v4(),
+        siglum: `${version.siglum}_derived`,
+        versionType: 'unicum',
+        basedOn: assignReference(versionId),
+        edits: moved,
+        motivations: []
+    });
+});
+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);
+const accents = [['SlowCrescendoOn', 'SlowCrescendoOff'], ['ForzandoOn', 'ForzandoOff']];
+const lengthOf = (span) => span.to - span.from;
+/** Shorten or prolong, where the inserted symbol starts about where the deleted one did. */
+const replacementType = (view, inserted, deleted) => {
+    const after = view.dimensionOf(inserted)?.horizontal;
+    const before = view.dimensionOf(deleted)?.horizontal;
+    if (!after || !before || Math.abs(after.from - before.from) >= 5)
+        return undefined;
+    return lengthOf(after) < lengthOf(before) ? 'shorten' : 'prolong';
+};
+/** A guess at what an edit does, from the symbols it exchanges. */
+const guessEditType = (view, edit) => {
+    const inserts = edit.insert ?? [];
+    const deletes = view.getAll(edit.delete ?? []);
+    const inserted = expressionTypesOf(inserts);
+    const deleted = expressionTypesOf(deletes);
+    if (deleted.length === 0 && accents.some(accent => sameSequence(inserted, accent)))
+        return 'additional-accent';
+    if (inserted.length > 1 && sameSequence(inserted, deleted))
+        return 'shift';
+    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 '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 = (view, versionId, toMerge) => {
+    if (toMerge.length === 0)
+        return noChange;
+    const merged = {
+        ...toMerge[0],
+        id: v4(),
+        insert: toMerge.flatMap(edit => edit.insert ?? []),
+        delete: toMerge.flatMap(edit => edit.delete ?? [])
+    };
+    merged.editType = guessEditType(view, merged);
+    const mergedIds = new Set(toMerge.map(edit => edit.id));
+    return onVersion(versionId, version => {
+        version.edits = [...version.edits.filter(edit => !mergedIds.has(edit.id)), merged];
+    });
+};
+/** Replaces the edit with one edit per inserted and one per deleted symbol. */
+export const splitEdit = (versionId, toSplit) => {
+    const parts = [
+        ...(toSplit.insert ?? []).map(insertion),
+        ...(toSplit.delete ?? []).map(deletion)
+    ];
+    return onVersion(versionId, version => {
+        version.edits = [...version.edits.filter(edit => edit.id !== toSplit.id), ...parts];
+    });
+};
+/**
+ * Runs the change on the perforation the view locates by id, in whichever
+ * version inserted it. A statement made there holds in every version
+ * that carries the perforation.
+ */
+const onPerforation = (view, id, op) => draft => {
+    const path = view.getPath(id);
+    const symbol = path && getAt(path, draft);
+    if (isPerforation(symbol))
+        op(symbol);
+};
+const clearPlacement = (perforation) => placementRelations.forEach(relation => { delete perforation[relation]; });
+/** States how the follower is placed relative to the reference, in place of any earlier statement. */
+export const placePerforation = (view, followerId, referenceId, relation) => onPerforation(view, followerId, perforation => {
+    clearPlacement(perforation);
+    perforation[relation] = assignReference(referenceId);
+});
+export const unplacePerforation = (view, followerId) => onPerforation(view, followerId, clearPlacement);
+/** The pair is stated on `statingId` only, as the format asks. */
+export const pairPerforations = (view, statingId, partnerId) => onPerforation(view, statingId, perforation => {
+    perforation.pairedWith = assignReference(partnerId);
+});
+export const unpairPerforation = (view, statingId) => onPerforation(view, statingId, perforation => {
+    delete perforation.pairedWith;
+});
+const onAssumptionAt = (path, op) => draft => {
+    const assumption = getAt(path, draft);
+    if (assumption)
+        op(assumption);
+};
+const onBeliefAt = (path, op) => onAssumptionAt(path, assumption => {
+    const belief = assumption['@annotation']?.belief;
+    if (belief)
+        op(belief);
+});
+/** Annotates the assumption at the path with a belief held true, for reasons to be added. */
+export const createBelief = (path) => onAssumptionAt(path, assumption => {
+    assumption['@annotation'] = {
+        id: v4(),
+        belief: { type: 'belief', id: v4(), certainty: 'true', reasons: [] }
+    };
+});
+export const clearBelief = (path) => onAssumptionAt(path, assumption => {
+    delete assumption['@annotation'];
+});
+export const setCertainty = (path, certainty) => onBeliefAt(path, belief => {
+    belief.certainty = certainty;
+});
+export const addReason = (path, reason) => onBeliefAt(path, belief => {
+    belief.reasons.push(reason);
+});
+export const removeReason = (path, index) => onBeliefAt(path, belief => {
+    belief.reasons.splice(index, 1);
+});

package/lib/index.d.ts

@@ -1,21 +1,26 @@
+export * from './utils';
+export * from './Agent';
 export * from './Assumption';
-export * from './asJsonLd';
-export * from './Collation';
 export * from './ConditionState';
-export * from './context';
-export * from './Edit';
-export * from './Edition';
-export * from './Emulation';
-export * from './ReproducingSystem';
+export * from './Symbol';
 export * from './Feature';
-export * from './importJsonLd';
-export * from './RollCopy';
+export * from './Edit';
 export * from './Version';
-export * from './Symbol';
-export * from './TrackerBar';
+export * from './Collation';
 export * from './TrackCalibration';
-export * from './alignFeatures';
+export * from './TrackerBar';
+export * from './systems/welteT100/bar';
+export * from './ReproducingSystem';
+export * from './RollCopy';
+export * from './alignment';
+export * from './Edition';
 export * from './EditionView';
-export * from './Plan';
+export * from './editionOps';
+export * from './Emulation';
 export * from './validate';
-export * from './utils';
+export * from './constraints';
+export * from './context';
+export * from './asJsonLd';
+export * from './importJsonLd';
+export { readFromStanfordAton, type StanfordAtonOptions } from './readers/stanfordAton';
+export { readFromSpencerMIDI, atConstantSpeed, spencerTrackOf, SPENCER_FEET_PER_MINUTE } from './readers/spencerMidi';

package/lib/index.js

@@ -1,21 +1,26 @@
+export * from './utils';
+export * from './Agent';
 export * from './Assumption';
-export * from './asJsonLd';
-export * from './Collation';
 export * from './ConditionState';
-export * from './context';
-export * from './Edit';
-export * from './Edition';
-export * from './Emulation';
-export * from './ReproducingSystem';
+export * from './Symbol';
 export * from './Feature';
-export * from './importJsonLd';
-export * from './RollCopy';
+export * from './Edit';
 export * from './Version';
-export * from './Symbol';
-export * from './TrackerBar';
+export * from './Collation';
 export * from './TrackCalibration';
-export * from './alignFeatures';
+export * from './TrackerBar';
+export * from './systems/welteT100/bar';
+export * from './ReproducingSystem';
+export * from './RollCopy';
+export * from './alignment';
+export * from './Edition';
 export * from './EditionView';
-export * from './Plan';
+export * from './editionOps';
+export * from './Emulation';
 export * from './validate';
-export * from './utils';
+export * from './constraints';
+export * from './context';
+export * from './asJsonLd';
+export * from './importJsonLd';
+export { readFromStanfordAton } from './readers/stanfordAton';
+export { readFromSpencerMIDI, atConstantSpeed, spencerTrackOf, SPENCER_FEET_PER_MINUTE } from './readers/spencerMidi';

package/lib/migrate.js

@@ -1,6 +1,7 @@
 import { conditions } from "./Feature";
 import { rollConditions } from "./RollCopy";
-import { systemOf, welteT100 } from "./TrackerBar";
+import { systemOf } from "./TrackerBar";
+import { welteT100 } from "./systems/welteT100/bar";
 import { versionTypes } from "./Version";
 const versionTypeValues = new Set(versionTypes);
 const conditionTypeValues = new Set([...rollConditions, ...Object.values(conditions).flat()]);

package/lib/readers/spencerMidi.d.ts

@@ -0,0 +1,26 @@
+import { RollCopy } from "../RollCopy";
+/**
+ * How a MIDI key number in one of Spencer Chase's roll files names a
+ * tracker bar track.
+ *
+ * The note block follows the obvious rule, `pitch - 13`, which puts
+ * track 11 on MIDI 24 as the T100 compass requires. The bass expression
+ * block does not: it reads two tracks high, and subtracting two is what
+ * has made these files come out right so far.
+ *
+ * The boundary between the two rules is unresolved. Taken literally the
+ * rules leave tracks 8 and 9 unreachable and jump from track 7 to track 10,
+ * which no lateral offset can produce, so at least one of them is
+ * approximate. Settling it needs a Spencer file whose expression holes
+ * can be checked against the roll, hence the option to override.
+ */
+export declare const spencerTrackOf: (pitch: number) => number;
+/**
+ * Spencer Chase's rolls seem to be scanned at a roll speed of
+ * 83 (=8.3 feet per minute). A scanner feeds the paper at one
+ * speed, so time in his files is proportional to place.
+ */
+export declare const SPENCER_FEET_PER_MINUTE = 8.3;
+/** Place on the roll in mm after `seconds` at a constant `feetPerMinute`. */
+export declare const atConstantSpeed: (feetPerMinute: number) => (seconds: number) => number;
+export declare function readFromSpencerMIDI(midiBuffer: ArrayBuffer, placeAt?: (seconds: number) => number, trackOf?: (pitch: number) => number): RollCopy;

package/lib/readers/spencerMidi.js

@@ -0,0 +1,58 @@
+import { v4 } from "uuid";
+import { read } from "midifile-ts";
+import { asSpans } from "./midiSpans";
+/**
+ * How a MIDI key number in one of Spencer Chase's roll files names a
+ * tracker bar track.
+ *
+ * The note block follows the obvious rule, `pitch - 13`, which puts
+ * track 11 on MIDI 24 as the T100 compass requires. The bass expression
+ * block does not: it reads two tracks high, and subtracting two is what
+ * has made these files come out right so far.
+ *
+ * The boundary between the two rules is unresolved. Taken literally the
+ * rules leave tracks 8 and 9 unreachable and jump from track 7 to track 10,
+ * which no lateral offset can produce, so at least one of them is
+ * approximate. Settling it needs a Spencer file whose expression holes
+ * can be checked against the roll, hence the option to override.
+ */
+export const spencerTrackOf = (pitch) => {
+    const track = pitch - 13;
+    return track < 10 ? track - 2 : track;
+};
+const MM_PER_FOOT = 304.8;
+/**
+ * Spencer Chase's rolls seem to be scanned at a roll speed of
+ * 83 (=8.3 feet per minute). A scanner feeds the paper at one
+ * speed, so time in his files is proportional to place.
+ */
+export const SPENCER_FEET_PER_MINUTE = 8.3;
+/** Place on the roll in mm after `seconds` at a constant `feetPerMinute`. */
+export const atConstantSpeed = (feetPerMinute) => (seconds) => feetPerMinute * MM_PER_FOOT / 60 * seconds;
+export function readFromSpencerMIDI(midiBuffer, placeAt = atConstantSpeed(SPENCER_FEET_PER_MINUTE), trackOf = spencerTrackOf) {
+    const features = asSpans(read(midiBuffer))
+        .filter(span => span.type === 'note')
+        .map((span) => ({
+        type: 'Hole',
+        id: v4(),
+        vertical: {
+            from: trackOf(span.pitch),
+            unit: 'track'
+        },
+        horizontal: {
+            from: placeAt(span.onsetMs / 1000),
+            to: placeAt(span.offsetMs / 1000),
+            unit: 'mm'
+        }
+    }));
+    return {
+        type: 'RollCopy',
+        id: v4(),
+        ops: [],
+        conditions: [],
+        keeper: { name: '', sameAs: [] },
+        measurements: {},
+        modifications: [],
+        features
+    };
+}

package/lib/readers/stanfordAton.d.ts

@@ -0,0 +1,18 @@
+import { RollCopy } from "../RollCopy";
+import { TrackerBar } from "../TrackerBar";
+export interface StanfordAtonOptions {
+    /**
+     * Added to the scanning software's hole numbering to reach the
+     * tracker bar. Left out, it is inferred by putting the rewind
+     * perforation on the bar's rewind track.
+     */
+    trackShift?: number;
+    bar?: TrackerBar;
+    /**
+     * Where the scan the analysis was made from can be seen. Stanford's
+     * files name their scan by DRUID, so this is only needed for an
+     * analysis of a scan hosted elsewhere.
+     */
+    scan?: string;
+}
+export declare function readFromStanfordAton(atonString: string, { trackShift, bar, scan }?: StanfordAtonOptions): RollCopy;