linked-rolls 0.10.1 → 0.11.0

package/lib/Collation.d.ts

@@ -26,5 +26,5 @@ export type Collation = {
     symbol: Readonly<AnySymbol>;
     counterpart: Readonly<AnySymbol>;
 };
-/** Each of the own symbols with every inherited symbol it collates with. */
+/** Each of the own symbols with every inherited symbol it collates with, both in the order given. */
 export declare const collationsOf: (own: readonly Readonly<AnySymbol>[], inherited: readonly Readonly<AnySymbol>[], locate: Locate, tolerance?: CollationTolerance) => Collation[];

package/lib/Collation.js

@@ -1,26 +1,65 @@
 import { distance, mm } from "./Quantity";
+import { partitionPoint } from "./sorted";
 export const defaultCollationTolerance = { toleranceStart: mm(5), toleranceEnd: mm(5) };
+/**
+ * What a symbol says, as a key: the pitch of a note, the type and scope
+ * of an expression. Symbols collate within one key only.
+ */
+const kindOf = (symbol) => {
+    switch (symbol.type) {
+        case 'note': return `note ${symbol.pitch}`;
+        case 'expression': return `expression ${symbol.scope} ${symbol.expressionType}`;
+        case 'text': return 'text';
+    }
+};
+const nearby = (here, there, tolerance) => distance(here.from, there.from) <= tolerance.toleranceStart
+    && distance(here.to, there.to) <= tolerance.toleranceEnd;
 /**
  * Two symbols collate when they are of one kind, say the same thing
  * (pitch, or expression type and scope), and lie at about the same
  * place along the roll.
  */
 export const isCollatable = (a, b, locate, tolerance = defaultCollationTolerance) => {
-    if (a.type !== b.type)
-        return false;
-    if (a.type === 'note' && b.type === 'note' && a.pitch !== b.pitch)
-        return false;
-    if (a.type === 'expression' && b.type === 'expression'
-        && (a.expressionType !== b.expressionType || a.scope !== b.scope))
+    if (kindOf(a) !== kindOf(b))
         return false;
     const here = locate(a)?.horizontal;
     const there = locate(b)?.horizontal;
-    if (!here || !there)
-        return false;
-    return distance(here.from, there.from) <= tolerance.toleranceStart
-        && distance(here.to, there.to) <= tolerance.toleranceEnd;
+    return here !== undefined && there !== undefined && nearby(here, there, tolerance);
+};
+const placed = (symbols, locate) => symbols.flatMap((symbol, index) => {
+    const horizontal = locate(symbol)?.horizontal;
+    return horizontal ? [{ symbol, index, horizontal }] : [];
+});
+const groupBy = (items, keyOf) => items.reduce((groups, item) => {
+    const key = keyOf(item);
+    const group = groups.get(key);
+    if (group)
+        group.push(item);
+    else
+        groups.set(key, [item]);
+    return groups;
+}, new Map());
+/** The placed symbols by kind, each kind in order of onset. */
+const byKindInOrderOfOnset = (symbols) => {
+    const groups = groupBy(symbols, ({ symbol }) => kindOf(symbol));
+    groups.forEach(group => group.sort((a, b) => a.horizontal.from - b.horizontal.from));
+    return groups;
+};
+/** Widens the onset window by a hair, so that rounding in its bounds cannot leave out what `nearby` accepts. */
+const WINDOW_SLACK = 1e-9;
+/** The symbols of a kind whose onset lies within the start tolerance of the span. */
+const nearOnsetOf = (kind, span, tolerance) => {
+    const lowest = span.from - tolerance.toleranceStart - WINDOW_SLACK;
+    const highest = span.from + tolerance.toleranceStart + WINDOW_SLACK;
+    const first = partitionPoint(kind, candidate => candidate.horizontal.from < lowest);
+    const end = partitionPoint(kind, candidate => candidate.horizontal.from <= highest);
+    return kind.slice(first, end);
+};
+/** Each of the own symbols with every inherited symbol it collates with, both in the order given. */
+export const collationsOf = (own, inherited, locate, tolerance = defaultCollationTolerance) => {
+    const kinds = byKindInOrderOfOnset(placed(inherited, locate));
+    return placed(own, locate).flatMap(({ symbol, horizontal }) => nearOnsetOf(kinds.get(kindOf(symbol)) ?? [], horizontal, tolerance)
+        .filter(candidate => nearby(horizontal, candidate.horizontal, tolerance))
+        .sort((a, b) => a.index - b.index)
+        .map(({ symbol: counterpart }) => ({ symbol, counterpart })));
 };
-/** Each of the own symbols with every inherited symbol it collates with. */
-export const collationsOf = (own, inherited, locate, tolerance = defaultCollationTolerance) => own.flatMap(symbol => inherited
-    .filter(candidate => isCollatable(symbol, candidate, locate, tolerance))
-    .map(counterpart => ({ symbol, counterpart })));

package/lib/EditionView.d.ts

@@ -3,6 +3,7 @@ import { HorizontalSpan, VerticalSpan, AnyFeature } from "./Feature";
 import { AnySymbol, Expression, Note } from "./Symbol";
 import { Version } from "./Version";
 import { NegotiatedEvent } from "./ReproducingSystem";
+import { Millimeters } from "./Quantity";
 export type Path = (string | number)[];
 export declare const getAt: <T>(path: Path, obj: unknown) => T | undefined;
 export declare class EditionView {
@@ -27,12 +28,22 @@ export declare class EditionView {
     getPath(anyId: string): Path | undefined;
     linksTo(anyId: string): Path[];
     travelUp(versionId: string, callback: (version: Readonly<Version>) => void): void;
+    /** The version and its ancestors, from the version up to the root. */
+    private lineageOf;
     carriersOf(symbol: AnySymbol): Readonly<AnyFeature>[];
     predecessorOf(versionId: string): Readonly<Version> | undefined;
     dimensionOf(symbol: AnySymbol): Readonly<{
         horizontal: HorizontalSpan;
         vertical: VerticalSpan;
     }> | undefined;
+    /** Where the symbol begins, as the mean onset of its carriers, or nothing for a symbol without a place. */
+    onsetOf(symbol: AnySymbol): Millimeters | undefined;
+    /** The symbols by onset, those without a place first; symbols at one place keep their order. */
+    private inOrderOfPlace;
+    /**
+     * The symbols the version shows: what it and its ancestors insert,
+     * each version's deletions striking what it or its ancestors inserted.
+     */
     snapshot(versionId: string): readonly Readonly<AnySymbol>[];
     /**
      * Assigns a generation (depth) to every node.

package/lib/EditionView.js

@@ -1,3 +1,4 @@
+import { deletedBy, insertedBy } from "./Version";
 import { idOf, idsOf } from "./Assumption";
 import { mean } from "./Quantity";
 export const getAt = (path, obj) => {
@@ -9,11 +10,17 @@ export const getAt = (path, obj) => {
     }
     return node;
 };
-const referenceKeys = new Set([
-    'delete',
-    'comprehends',
-    'motivation'
-]);
+/** Keys under which an object names others by id, singly or in a list. */
+const referenceKeys = ['delete', 'comprehends', 'motivation'];
+const isObject = (v) => v !== null && typeof v === "object";
+/** An object that names another by its id and says nothing else, save perhaps a belief about the reference. */
+const isReferenceOnly = (keys) => keys.every(key => key === 'id' || key === '@annotation');
+const pathOf = (trail) => {
+    const path = [];
+    for (let link = trail; link !== null; link = link.up)
+        path.push(link.key);
+    return path.reverse();
+};
 export class EditionView {
     constructor(edition) {
         Object.defineProperty(this, "edition", {
@@ -58,63 +65,48 @@ export class EditionView {
     }
     indexObjects() {
         const visited = new WeakSet();
-        const isObject = (v) => v !== null && typeof v === "object";
-        const traverse = (node, path) => {
-            if (!isObject(node))
+        const link = (id, trail) => {
+            const trails = this.links.get(id);
+            if (trails)
+                trails.push(trail);
+            else
+                this.links.set(id, [trail]);
+        };
+        const index = (record, keys, trail) => {
+            if (typeof record.id !== "string")
                 return;
-            if (visited.has(node))
+            if (isReferenceOnly(keys))
+                link(record.id, { key: 'id', up: trail });
+            else if (!this.byId.has(record.id)) {
+                this.byId.set(record.id, record);
+                this.paths.set(record.id, trail);
+            }
+        };
+        const linkReferences = (record, trail) => referenceKeys.forEach(key => {
+            const ref = record[key];
+            if (typeof ref === "string")
+                link(ref, { key, up: trail });
+            else if (Array.isArray(ref))
+                ref.forEach((r, i) => {
+                    if (typeof r === "string")
+                        link(r, { key: i, up: { key, up: trail } });
+                });
+        });
+        const traverse = (node, trail) => {
+            if (!isObject(node) || visited.has(node))
                 return;
             visited.add(node);
-            const anyNode = node;
-            if (typeof anyNode.id === "string") {
-                if (Object.keys(anyNode).filter(k => k !== '@annotation').length === 1) {
-                    // this is a reference-only object, store link
-                    if (!this.links.has(anyNode.id)) {
-                        this.links.set(anyNode.id, new Set());
-                    }
-                    this.links.get(anyNode.id).add([...path, 'id']);
-                }
-                else {
-                    if (!this.byId.has(anyNode.id)) {
-                        this.byId.set(anyNode.id, node);
-                        this.paths.set(anyNode.id, [...path]);
-                    }
-                }
-            }
-            Object
-                .keys(anyNode)
-                .filter(k => referenceKeys.has(k))
-                .forEach(key => {
-                const ref = anyNode[key];
-                if (typeof ref === "string") {
-                    if (!this.links.has(ref)) {
-                        this.links.set(ref, new Set());
-                    }
-                    this.links.get(ref).add([...path, key]);
-                }
-                else if (Array.isArray(ref)) {
-                    for (const r of ref) {
-                        if (typeof r === "string") {
-                            if (!this.links.has(anyNode.id)) {
-                                this.links.set(anyNode.id, new Set());
-                            }
-                            this.links.get(anyNode.id).add([...path, key]);
-                        }
-                    }
-                }
-            });
             if (Array.isArray(node)) {
-                for (let i = 0; i < node.length; i++) {
-                    traverse(node[i], [...path, i]);
-                }
-            }
-            else {
-                for (const key of Object.keys(node)) {
-                    traverse(anyNode[key], [...path, key]);
-                }
+                node.forEach((item, i) => traverse(item, { key: i, up: trail }));
+                return;
             }
+            const record = node;
+            const keys = Object.keys(record);
+            index(record, keys, trail);
+            linkReferences(record, trail);
+            keys.forEach(key => traverse(record[key], { key, up: trail }));
         };
-        traverse(this.edition, []);
+        traverse(this.edition, null);
     }
     get(anyId) {
         return this.byId.get(anyId);
@@ -123,10 +115,11 @@ export class EditionView {
         return anyIds.map(id => this.get(id)).filter((v) => !!v);
     }
     getPath(anyId) {
-        return this.paths.get(anyId);
+        const trail = this.paths.get(anyId);
+        return trail === undefined ? undefined : pathOf(trail);
     }
     linksTo(anyId) {
-        return Array.from(this.links.get(anyId) || []);
+        return (this.links.get(anyId) ?? []).map(pathOf);
     }
     travelUp(versionId, callback) {
         const v = this.get(versionId);
@@ -137,6 +130,12 @@ export class EditionView {
             this.travelUp(idOf(v.basedOn), callback);
         }
     }
+    /** The version and its ancestors, from the version up to the root. */
+    lineageOf(versionId) {
+        const lineage = [];
+        this.travelUp(versionId, version => lineage.push(version));
+        return lineage;
+    }
     carriersOf(symbol) {
         return this.getAll(idsOf(symbol.carriers));
     }
@@ -165,32 +164,29 @@ export class EditionView {
             }
         };
     }
+    /** Where the symbol begins, as the mean onset of its carriers, or nothing for a symbol without a place. */
+    onsetOf(symbol) {
+        const carriers = this.carriersOf(symbol);
+        return carriers.length > 0 ? mean(carriers.map(carrier => carrier.horizontal.from)) : undefined;
+    }
+    /** The symbols by onset, those without a place first; symbols at one place keep their order. */
+    inOrderOfPlace(symbols) {
+        return symbols
+            .map(symbol => ({ symbol, at: this.onsetOf(symbol) || 0 }))
+            .sort((a, b) => a.at - b.at)
+            .map(({ symbol }) => symbol);
+    }
+    /**
+     * The symbols the version shows: what it and its ancestors insert,
+     * each version's deletions striking what it or its ancestors inserted.
+     */
     snapshot(versionId) {
-        const snapshot = [];
-        const toDelete = [];
-        this.travelUp(versionId, s => {
-            snapshot.push(...s.edits.flatMap(edit => edit.insert || []));
-            // as we travel further up, remove symbols that are 
-            // deleted in the versions further down
-            const deleted = [];
-            for (const toRemove of toDelete) {
-                const index = snapshot.findIndex(s => s.id === toRemove);
-                if (index !== -1) {
-                    snapshot.splice(index, 1);
-                    deleted.push(toRemove);
-                }
-            }
-            for (const del of deleted) {
-                toDelete.splice(toDelete.indexOf(del), 1);
-            }
-            // collect symbols that are deleted in the current version
-            toDelete.push(...s.edits.flatMap(edit => edit.delete || []));
-        });
-        return snapshot.sort((a, b) => {
-            const aDimension = this.dimensionOf(a);
-            const bDimension = this.dimensionOf(b);
-            return (aDimension?.horizontal.from || 0) - (bDimension?.horizontal.from || 0);
+        const deleted = new Set();
+        const symbols = this.lineageOf(versionId).flatMap(version => {
+            deletedBy(version).forEach(id => deleted.add(id));
+            return insertedBy(version).filter(symbol => !deleted.has(symbol.id));
         });
+        return this.inOrderOfPlace(symbols);
     }
     /**
      * Assigns a generation (depth) to every node.

package/lib/Emulation.js

@@ -1,6 +1,6 @@
 import { MIDIControlEvents } from "midifile-ts";
 import { idOf } from "./Assumption";
-import { pairsAmong, placementsOf } from "./Symbol";
+import { isPerforation, pairsAmong, placementsOf } from "./Symbol";
 import { add, mean, mm, seconds, subtract } from "./Quantity";
 /** The punch diameter the edition's copies report, where any of them does. */
 const punchDiameterOf = (view) => {
@@ -83,6 +83,8 @@ const displacementsOf = (events, offsetsBetween, gap) => {
     });
     return displacements;
 };
+/** The earliest of the times, or the beginning of the roll where there are none. */
+const earliestOf = (times) => times.length === 0 ? seconds(0) : times.reduce((soonest, at) => at < soonest ? at : soonest);
 /**
  * A version of the edition, performed: the symbols are negotiated into
  * placed events, the reproducing system plays them, and the result goes
@@ -147,22 +149,14 @@ export class Emulation {
     }
     emulateVersion(version, view, { range, skipToFirstNote = false } = {}) {
         this.source = version.id;
+        /** A note plays only where its onset falls in the range; expressions play throughout. */
+        const inScope = (event) => !range || event.type !== 'note' || (event.horizontal.from > range[0] && event.horizontal.from < range[1]);
         this.negotiatedEvents =
             view.snapshot(version.id)
-                .filter(s => s.type === 'note' || s.type === 'expression')
-                .filter(s => {
-                if (range && s.type === 'note') {
-                    const dimensions = view.dimensionOf(s);
-                    if (!dimensions)
-                        return true; // in case of doubt, include the note
-                    // check if the note onset is within the specified range
-                    const onset = dimensions.horizontal.from;
-                    return onset > range[0] && onset < range[1];
-                }
-                return true;
-            })
-                .map((e) => view.simplifySymbol(e))
-                .filter(s => s !== null);
+                .filter(isPerforation)
+                .map(symbol => view.simplifySymbol(symbol))
+                .filter(event => event !== null)
+                .filter(inScope);
         if (this.negotiatedEvents.length === 0) {
             this.midiEvents = [];
             this.curves = [];
@@ -172,7 +166,7 @@ export class Emulation {
         const performance = this.system.perform(this.negotiatedEvents, this.options, propertiesOf(view));
         this.curves = performance.curves;
         const onsets = performance.events.filter(event => event.type === 'noteOn').map(event => event.at);
-        const origin = seconds(skipToFirstNote && onsets.length > 0 ? Math.min(...onsets) : 0);
+        const origin = skipToFirstNote ? earliestOf(onsets) : seconds(0);
         this.midiEvents = performance.events
             .map(event => ({ ...event, at: subtract(event.at, origin) }))
             .filter(event => event.at >= 0)

package/lib/Version.d.ts

@@ -1,5 +1,6 @@
 import { Edit } from "./Edit";
 import { ReferenceAssumption } from "./Assumption";
+import { AnySymbol } from "./Symbol";
 import { WithId, WithNote, WithType } from "./utils";
 export declare const versionTypes: readonly [
 /**
@@ -56,3 +57,7 @@ export interface Version extends WithId, WithType<'Version'> {
      */
     motivations: Motivation[];
 }
+/** The symbols the version's edits insert. */
+export declare const insertedBy: (version: Readonly<Version>) => AnySymbol[];
+/** The ids of the symbols the version's edits delete. */
+export declare const deletedBy: (version: Readonly<Version>) => string[];

package/lib/Version.js

@@ -9,3 +9,7 @@ export const versionTypes = [
      */
     'unicum'
 ];
+/** The symbols the version's edits insert. */
+export const insertedBy = (version) => version.edits.flatMap(edit => edit.insert ?? []);
+/** The ids of the symbols the version's edits delete. */
+export const deletedBy = (version) => version.edits.flatMap(edit => edit.delete ?? []);

package/lib/constraints.js

@@ -25,9 +25,11 @@ const problemsIn = (version, perforations) => {
         .filter(p => p.pairedWith && idOf(p.pairedWith) === p.id)
         .map(p => report(p.id, 'paired-with-itself'));
     const pairs = pairsAmong(perforations);
-    const pairsOf = (p) => pairs.filter(pair => pair.includes(p));
+    const pairsPerId = pairs
+        .flatMap(([one, other]) => one === other ? [one] : [one, other])
+        .reduce((counts, p) => counts.set(p.id, (counts.get(p.id) ?? 0) + 1), new Map());
     const inSeveralPairs = perforations
-        .filter(p => pairsOf(p).length > 1)
+        .filter(p => (pairsPerId.get(p.id) ?? 0) > 1)
         .map(p => report(p.id, 'in-several-pairs'));
     const placedOnBothSides = pairs
         .filter(([one, other]) => placementsOf(one).length > 0 && placementsOf(other).length > 0)

package/lib/editionOps.js

@@ -1,7 +1,9 @@
+import { current, isDraft } from "immer";
 import { v4 } from "uuid";
 import { getAt } from "./EditionView";
 import { isPerforation, placementRelations } from "./Symbol";
 import { collationsOf, defaultCollationTolerance } from "./Collation";
+import { insertedBy } from "./Version";
 import { asSymbols } from "./RollCopy";
 import { applyShift, applyStretch, revertShift, revertStretch } from "./alignment";
 import { assignReference, idOf } from "./Assumption";
@@ -17,23 +19,36 @@ const onVersion = (versionId, op) => draft => {
     if (version)
         op(version, 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.
+ */
+const stateOf = (draft) => isDraft(draft) ? current(draft) : 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;
+/** The items each changed, or the very same array when the change left every one as it was. */
+const mapped = (items, change) => {
+    const changed = items.map(change);
+    return changed.every((item, i) => item === items[i]) ? items : changed;
+};
 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));
+const insertedIn = (versions) => versions.flatMap(insertedBy);
+/** The edits with the change applied, less those it emptied; the very same array where it changed none. */
+const edited = (edits, change) => {
+    const changed = mapped(edits, change);
+    return changed === edits ? edits : changed.filter((edit, i) => edit === edits[i] || !isEmpty(edit));
+};
+/** The edit without the symbols among its insertions, or the very same edit where it inserts none of them. */
+const droppingInsertions = (symbolIds) => (edit) => {
+    const insert = edit.insert && without(edit.insert, symbol => symbolIds.has(symbol.id));
+    return insert === edit.insert ? edit : { ...edit, insert };
+};
+/** Takes the symbols out of the version's own insertions, and the edits that had nothing else. */
+const dropInsertions = (version, symbolIds) => {
+    version.edits = edited(stateOf(version).edits, droppingInsertions(symbolIds));
 };
-/** 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.
@@ -72,25 +87,34 @@ export const symbolsCarriedOnlyBy = (edition, 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);
+/** The perforation without its references to the dropped symbols, or the very same one where it makes none. */
+const forgettingReferences = (perforation, dropped) => {
+    const stale = references.filter(relation => {
+        const reference = perforation[relation];
+        return reference !== undefined && dropped.has(idOf(reference));
+    });
+    if (stale.length === 0)
+        return perforation;
+    const kept = { ...perforation };
+    stale.forEach(relation => { delete kept[relation]; });
+    return kept;
 };
-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));
-    }
+/** The symbol without the features among its carriers, and without references to what went with them. */
+const forgettingCarriers = (features, dropped) => (symbol) => {
+    const carriers = without(symbol.carriers, carrier => features.has(idOf(carrier)));
+    const relieved = carriers === symbol.carriers ? symbol : { ...symbol, carriers };
+    return isPerforation(relieved) ? forgettingReferences(relieved, dropped) : relieved;
+};
+/** The edit without the dropped symbols and the features, or the very same edit where it had none of them. */
+const forgettingFeatures = (features, dropped) => {
+    const forgetCarriers = forgettingCarriers(features, dropped);
+    return (edit) => {
+        const insert = edit.insert && mapped(without(edit.insert, symbol => dropped.has(symbol.id)), forgetCarriers);
+        const deleted = edit.delete && without(edit.delete, id => dropped.has(id));
+        if (insert === edit.insert && deleted === edit.delete)
+            return edit;
+        return { ...edit, ...(insert && { insert }), ...(deleted && { delete: deleted }) };
+    };
 };
 /**
  * Strikes the features from the versions: their carriers go, a symbol
@@ -98,8 +122,12 @@ const forgetFeaturesInEdit = (edit, features, dropped) => {
  * 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)));
+    const versions = stateOf(draft.versions);
+    const dropped = new Set(insertedIn(versions).filter(carriedOnlyOn(features)).map(symbol => symbol.id));
+    const forget = forgettingFeatures(features, dropped);
+    draft.versions.forEach((version, i) => {
+        version.edits = edited(versions[i].edits, forget);
+    });
 };
 /** 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) => {

package/lib/importJsonLd.d.ts

@@ -1,3 +1,5 @@
 import { Edition } from "./Edition";
 export declare const importDate: (str: string) => Date;
-export declare const importJsonLd: (json: any) => Edition;
+type Json = any;
+export declare const importJsonLd: (json: Json) => Edition;
+export {};

package/lib/importJsonLd.js

@@ -10,49 +10,29 @@ export const importDate = (str) => {
     }
     return new Date(y, m - 1, d);
 };
+/** A value as the edition holds it: a date read, an entity converted, anything else as it stands. */
+const fromJsonLdValue = (value) => {
+    if (typeof value === 'string')
+        return isDate(value) ? importDate(value) : value;
+    if (Array.isArray(value))
+        return value.map(fromJsonLdValue);
+    if (value !== null && typeof value === 'object')
+        return fromJsonLdEntity(value);
+    return value;
+};
+/**
+ * An entity with its keywords read as plain keys. The input is left as
+ * it is. The `@type` of a value object names the datatype of the value,
+ * not a class, and is dropped.
+ */
 const fromJsonLdEntity = (json) => {
-    if (typeof json !== 'object') {
-        return json;
-    }
-    let result = json;
-    if ('@value' in json) {
-        // the datatype of a value object, not a class
-        delete result['@type'];
-    }
-    else if ('@type' in json) {
-        result['type'] = json['@type'];
-        delete result['@type'];
-    }
-    for (const [key, value] of Object.entries(json)) {
-        if (key === '@id') {
-            // console.log("deleting @id", value);
-            result['id'] = value;
-            delete result['@id'];
-        }
-        else if (typeof value === 'string' && isDate(value)) {
-            result[key] = importDate(value);
-        }
-        else if (Array.isArray(value)) {
-            result[key] = value.map(v => {
-                if (typeof v === 'string') {
-                    if (isDate(v)) {
-                        return importDate(v);
-                    }
-                    return v;
-                }
-                else {
-                    return fromJsonLdEntity(v);
-                }
-            });
-        }
-        else if (typeof value === 'object') {
-            result[key] = fromJsonLdEntity(value);
-        }
-        else {
-            result[key] = value;
-        }
-    }
-    return result;
+    const { '@type': type, '@id': id, ...rest } = json;
+    const entity = Object.fromEntries(Object.entries(rest).map(([key, value]) => [key, fromJsonLdValue(value)]));
+    if (type !== undefined && !('@value' in json))
+        entity.type = type;
+    if (id !== undefined)
+        entity.id = id;
+    return entity;
 };
 // The export prefixes copy identifiers with `copy/`; this is its inverse.
 const withPlainCopyIds = (json) => ({

package/lib/index.d.ts

@@ -24,4 +24,4 @@ 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';
+export { readFromSpencerBar, licenseeOnT100, SPENCER_ROWS_PER_INCH, type SpencerBarOptions } from './readers/spencerBar';

package/lib/index.js

@@ -24,4 +24,4 @@ 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';
+export { readFromSpencerBar, licenseeOnT100, SPENCER_ROWS_PER_INCH } from './readers/spencerBar';

package/lib/migrate.js

@@ -12,7 +12,9 @@ const renamedKeys = {
 };
 const referenceKeys = ['alignedWith', 'pairedWith', 'basedOn'];
 const named = (name) => ({ name, sameAs: [] });
-const withRenamedKeys = (node) => Object.fromEntries(Object.entries(node).map(([key, value]) => [renamedKeys[key] ?? key, value]));
+const withRenamedKeys = (node) => Object.keys(node).some(key => Object.hasOwn(renamedKeys, key))
+    ? Object.fromEntries(Object.entries(node).map(([key, value]) => [renamedKeys[key] ?? key, value]))
+    : node;
 const withTypology = (node) => {
     if (versionTypeValues.has(node['@type'])) {
         return { ...node, '@type': 'Version', versionType: node['@type'] };
@@ -52,12 +54,22 @@ const withProductionNodes = (node) => {
 };
 const migrateNode = (node) => [withRenamedKeys, withTypology, withReferences, withKeeper, withProductionNodes]
     .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);
+};
 const walk = (value) => {
     if (Array.isArray(value))
-        return value.map(walk);
-    if (value && typeof value === 'object') {
-        return Object.fromEntries(Object.entries(migrateNode(value)).map(([key, child]) => [key, walk(child)]));
-    }
+        return walked(value);
+    if (value && typeof value === 'object')
+        return withWalkedChildren(migrateNode(value));
     return value;
 };
 /**

package/lib/readers/spencerBar.d.ts

@@ -0,0 +1,18 @@
+import { RollCopy } from "../RollCopy";
+import { Track } from "../Quantity";
+/**
+ * Rows of the image on an inch of paper. The player reads eight rows a
+ * second per unit of roll tempo (tempo 80 comes with a sample rate of
+ * 640 Hz), and the tempo counts tenths of a foot per minute, which puts
+ * 400 rows on an inch. This is the file's own calibration; whether the
+ * scanner kept it is for an alignment with other copies to tell.
+ */
+export declare const SPENCER_ROWS_PER_INCH = 400;
+export declare const licenseeOnT100: (position: number) => Track;
+export interface SpencerBarOptions {
+    /** Rows of the image on an inch of paper. */
+    rowsPerInch?: number;
+    /** Puts a position the file names onto the edition's bar. */
+    trackOf?: (position: number) => Track;
+}
+export declare function readFromSpencerBar(buffer: ArrayBuffer, { rowsPerInch, trackOf }?: SpencerBarOptions): RollCopy;

package/lib/readers/spencerBar.js

@@ -0,0 +1,120 @@
+import { v4 } from "uuid";
+import { welteT100 } from "../systems/welteT100/bar";
+import { inMillimeters, px, track } from "../Quantity";
+/**
+ * Spencer Chase's e-roll file (`.bar`, "eRoll Tracker Bar Image") holds
+ * a roll as a list of events: a distance in rows of the scanned image,
+ * then the tracker bar position whose hole begins or ends on that row.
+ *
+ * Layout, as read off W225E.bar: four bytes (00 01 00 00), the tag F4
+ * and a null-terminated text ("/oldtrackname:..."), then the events,
+ * each an unsigned LEB128 distance and one position byte. A position
+ * byte of FF closes the list. A hole ends when its position turns up
+ * a second time.
+ */
+const TEXT_AT = 4;
+const TEXT_TAG = 0xF4;
+const END_OF_EVENTS = 0xFF;
+/**
+ * Rows of the image on an inch of paper. The player reads eight rows a
+ * second per unit of roll tempo (tempo 80 comes with a sample rate of
+ * 640 Hz), and the tempo counts tenths of a foot per minute, which puts
+ * 400 rows on an inch. This is the file's own calibration; whether the
+ * scanner kept it is for an alignment with other copies to tell.
+ */
+export const SPENCER_ROWS_PER_INCH = 400;
+/**
+ * The file numbers positions as the 98-hole Welte Licensee bar does.
+ * Its bass controls are the T-100's tracks 1 to 8, it has no motor
+ * tracks, and its note block follows the controls at once, so from
+ * there on every position lies two tracks lower than on the T-100 bar.
+ * Checked valve by valve on roll 225 against the Stanford copies.
+ */
+const LICENSEE_NOTES_FROM = 9;
+const T100_NOTES_FROM = welteT100.areas.find(area => area.role === 'note').from;
+export const licenseeOnT100 = (position) => track(position < LICENSEE_NOTES_FROM ? position : position + T100_NOTES_FROM - LICENSEE_NOTES_FROM);
+const byteAt = (bytes, at) => {
+    const byte = bytes[at];
+    if (byte === undefined)
+        throw new Error(`Spencer .bar file ends early at byte ${at}`);
+    return byte;
+};
+const leb128 = (bytes, at) => {
+    let value = 0;
+    let next = at;
+    for (let weight = 1;; weight *= 128) {
+        const byte = byteAt(bytes, next++);
+        value += (byte & 0x7F) * weight;
+        if (!(byte & 0x80))
+            return { value, next };
+    }
+};
+const endOfText = (bytes, from) => {
+    const end = bytes.indexOf(0, from);
+    if (end < 0)
+        throw new Error('Spencer .bar file: the text is not terminated');
+    return end + 1;
+};
+function* eventsIn(bytes, from) {
+    let row = 0;
+    let at = from;
+    while (true) {
+        const distance = leb128(bytes, at);
+        const position = byteAt(bytes, distance.next);
+        if (position === END_OF_EVENTS)
+            return;
+        row += distance.value;
+        yield { row, position };
+        at = distance.next + 1;
+    }
+}
+/** Pairs the events of each position into holes: the first opens one, the next closes it. */
+const holesOf = (events) => {
+    const open = new Map();
+    const holes = [];
+    for (const { row, position } of events) {
+        const from = open.get(position);
+        if (from === undefined) {
+            open.set(position, row);
+        }
+        else {
+            holes.push({ position, from, to: row });
+            open.delete(position);
+        }
+    }
+    if (open.size > 0) {
+        throw new Error(`Spencer .bar file: holes on positions ${[...open.keys()].join(', ')} never end`);
+    }
+    return holes.sort((a, b) => a.from - b.from);
+};
+export function readFromSpencerBar(buffer, { rowsPerInch = SPENCER_ROWS_PER_INCH, trackOf = licenseeOnT100 } = {}) {
+    const bytes = new Uint8Array(buffer);
+    if (byteAt(bytes, TEXT_AT) !== TEXT_TAG) {
+        throw new Error('Not a Spencer .bar file: no text after the header');
+    }
+    const placeOf = (row) => inMillimeters(px(row), rowsPerInch);
+    const features = holesOf(eventsIn(bytes, endOfText(bytes, TEXT_AT + 1)))
+        .map((hole) => ({
+        type: 'Hole',
+        id: v4(),
+        vertical: {
+            from: trackOf(hole.position),
+            unit: 'track'
+        },
+        horizontal: {
+            unit: 'mm',
+            from: placeOf(hole.from),
+            to: placeOf(hole.to)
+        }
+    }));
+    return {
+        type: 'RollCopy',
+        id: v4(),
+        ops: [],
+        conditions: [],
+        keeper: { name: '', sameAs: [] },
+        measurements: {},
+        modifications: [],
+        features
+    };
+}

package/lib/readers/stanfordAton.js

@@ -50,6 +50,10 @@ const gridOffsetOf = (holes, separation, stated) => {
         return readPx(stated);
     return px(median(holes.map(hole => readPx(hole.CENTROID_COL) - +hole.TRACKER_HOLE * separation)));
 };
+const chainsAmong = (holes) => holes
+    .filter(hole => hole.NOTE_ATTACK && hole.OFF_TIME)
+    .map(hole => ({ hole, attack: readPx(hole.NOTE_ATTACK), release: readPx(hole.OFF_TIME) }))
+    .sort((a, b) => a.attack - b.attack);
 const punchDiameterOf = (holes, dpi) => {
     const circular = holes
         .filter(hole => parseFloat(hole.CIRCULARITY) > 0.95)
@@ -97,13 +101,9 @@ export function readFromStanfordAton(atonString, { trackShift, bar = welteT100,
         shift
     };
     const punchDiameter = punchDiameterOf(holes, dpi);
-    const chains = [...holes, ...chainedBadHoles(listOf(json.ROLLINFO.BADHOLES?.HOLE), calibration)]
-        .filter(hole => hole.NOTE_ATTACK && hole.OFF_TIME)
-        .sort((a, b) => readPx(a.NOTE_ATTACK) - readPx(b.NOTE_ATTACK));
+    const chains = chainsAmong([...holes, ...chainedBadHoles(listOf(json.ROLLINFO.BADHOLES?.HOLE), calibration)]);
     const features = chains
-        .map((hole) => {
-        const attack = readPx(hole.NOTE_ATTACK);
-        const release = readPx(hole.OFF_TIME);
+        .map(({ hole, attack, release }) => {
         const column = readPx(hole.ORIGIN_COL);
         const columnWidth = readPx(hole.WIDTH_COL);
         return {

package/lib/sorted.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The index at which a list partitioned by the predicate turns: it
+ * holds for every item before that index and for none from it on.
+ * Binary search, so the list is read in logarithmic time.
+ */
+export declare const partitionPoint: <T>(partitioned: readonly T[], holds: (item: T) => boolean) => number;

package/lib/sorted.js

@@ -0,0 +1,17 @@
+/**
+ * The index at which a list partitioned by the predicate turns: it
+ * holds for every item before that index and for none from it on.
+ * Binary search, so the list is read in logarithmic time.
+ */
+export const partitionPoint = (partitioned, holds) => {
+    let low = 0;
+    let high = partitioned.length;
+    while (low < high) {
+        const middle = (low + high) >>> 1;
+        if (holds(partitioned[middle]))
+            low = middle + 1;
+        else
+            high = middle;
+    }
+    return low;
+};

package/lib/systems/welteT100/system.js

@@ -1,6 +1,7 @@
 import { aperturePorts, CONSENSUS, DEFAULT_PUNCH_MM, geometryInMm, Grid, levelChanges, mezzoforteTravel, paperSeconds, pedalBrushing, pedalDefaults, pneumaticModel, PRESETS, ROWS_PER_MM, runPedals, TRACKER_BORE_MM, travelBetweenRails, WELTE_SPOOL, } from "welte-t100-emulator";
 import { welteT100 } from "./bar";
 import { add, inCentimeters, mm, seconds, track } from "../../Quantity";
+import { partitionPoint } from "../../sorted";
 /**
  * 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,
@@ -113,7 +114,7 @@ const velocityOf = (travel, hook, map) => {
 const gridOver = (events, spool) => {
     const last = mm(events.reduce((furthest, event) => Math.max(furthest, event.horizontal.to), 0));
     const length = Math.ceil(rowOf(add(last, RUN_OUT))) + 1;
-    const times = Float64Array.from({ length }, (_, row) => secondsAt(spool, placeOfRow(row)));
+    const times = new Float64Array(length).map((_, row) => secondsAt(spool, placeOfRow(row)));
     return new Grid(0, times);
 };
 const nuanceCurves = (grid, ports, samples, options) => {
@@ -127,7 +128,7 @@ const nuanceCurves = (grid, ports, samples, options) => {
             name: half,
             kind: 'dynamics',
             travel,
-            velocity: Float64Array.from(travel, value => velocityOf(value, hook, options.velocity))
+            velocity: travel.map(value => velocityOf(value, hook, options.velocity))
         };
     };
     return { bass: curveOf('bass'), treble: curveOf('treble') };
@@ -158,7 +159,7 @@ const performPedal = (type, curve, grid, readings, mode) => {
     if (readings.length === 0)
         return [];
     const ordered = readings.toSorted((a, b) => a.punch.rowOn - b.punch.rowOn);
-    const causeOf = (row) => ordered[Math.max(ordered.findLastIndex(reading => reading.punch.rowOn <= row), 0)].event;
+    const causeOf = (row) => ordered[Math.max(partitionPoint(ordered, reading => reading.punch.rowOn <= row) - 1, 0)].event;
     return levelChanges(curve.travel, { mode })
         .filter(change => change.index > 0)
         .map(change => ({
@@ -182,7 +183,7 @@ const perform = (events, options, roll) => {
     const geometry = geometryInMm(roll.punchDiameter ?? options.punchDiameter, options.trackerBore);
     const ports = aperturePorts(grid, readings.map(reading => reading.punch), geometry);
     const samples = {
-        place: Float64Array.from(grid.seconds, (_, row) => placeOfRow(row)),
+        place: grid.seconds.map((_, row) => placeOfRow(row)),
         seconds: grid.seconds
     };
     const nuance = nuanceCurves(grid, ports, samples, options);

package/package.json

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

package/lib/readers/midiSpans.d.ts

@@ -1,25 +0,0 @@
-import { MidiFile } from "midifile-ts";
-import { Milliseconds } from "../Quantity";
-export declare function midiTickToMilliseconds(ticks: number, microsecondsPerBeat: number, ppq: number): Milliseconds;
-interface Span<T extends string> {
-    type: T;
-    id: string;
-    /** In ticks of the file. */
-    onset: number;
-    offset: number;
-    onsetMs: Milliseconds;
-    offsetMs: Milliseconds;
-    link?: string;
-}
-export interface NoteSpan extends Span<'note'> {
-    pitch: number;
-    velocity: number;
-    channel: number;
-}
-export interface SustainSpan extends Span<'sustain'> {
-}
-export interface SoftSpan extends Span<'soft'> {
-}
-export type AnySpan = NoteSpan | SustainSpan | SoftSpan;
-export declare const asSpans: (file: MidiFile, readLinks?: boolean) => AnySpan[];
-export {};

package/lib/readers/midiSpans.js

@@ -1,112 +0,0 @@
-import { MIDIControlEvents } from "midifile-ts";
-import { milliseconds } from "../Quantity";
-const isNoteOn = (event) => event.type === 'channel' && event.subtype === 'noteOn';
-const isNoteOff = (event) => event.type === 'channel' && event.subtype === 'noteOff';
-const isPedalOn = (event) => (event.type === 'channel'
-    && event.subtype === 'controller'
-    && event.controllerType === MIDIControlEvents.SUSTAIN
-    && event.value > 63);
-const isPedalOff = (event) => (event.type === 'channel'
-    && event.subtype === 'controller'
-    && event.controllerType === MIDIControlEvents.SUSTAIN
-    && event.value <= 63);
-const isSoftPedalOn = (event) => {
-    return event.type === 'channel'
-        && event.subtype === 'controller'
-        && event.controllerType === MIDIControlEvents.SOFT_PEDAL
-        && event.value > 63;
-};
-const isSoftPedalOff = (event) => {
-    return event.type === 'channel'
-        && event.subtype === 'controller'
-        && event.controllerType === MIDIControlEvents.SOFT_PEDAL
-        && event.value <= 63;
-};
-export function midiTickToMilliseconds(ticks, microsecondsPerBeat, ppq) {
-    const beats = ticks / ppq;
-    return milliseconds((beats * microsecondsPerBeat) / 1000);
-}
-export const asSpans = (file, readLinks = false) => {
-    const resultingSpans = [];
-    const tempoMap = [];
-    const currentSpans = [];
-    let bufferedMetaText;
-    for (let i = 0; i < file.tracks.length; i++) {
-        const track = file.tracks[i];
-        let currentTime = 0;
-        for (const event of track) {
-            currentTime += event.deltaTime;
-            if (event.type === 'meta' && event.subtype === 'setTempo') {
-                tempoMap.push({
-                    atTick: currentTime,
-                    microsecondsPerBeat: event.microsecondsPerBeat
-                });
-            }
-            if (readLinks && event.type === 'meta' && event.subtype === 'text') {
-                bufferedMetaText = event.text;
-            }
-            else if (isNoteOn(event) || isPedalOn(event) || isSoftPedalOn(event)) {
-                const type = isNoteOn(event) ? 'note' : isPedalOn(event) ? 'sustain' : 'soft';
-                const currentTempo = tempoMap.slice().reverse().find(tempo => tempo.atTick <= currentTime);
-                if (!currentTempo) {
-                    console.log('No tempo event found. Skipping');
-                    continue;
-                }
-                const onsetMs = midiTickToMilliseconds(currentTime, currentTempo.microsecondsPerBeat, file.header.ticksPerBeat);
-                const link = bufferedMetaText;
-                if (type === 'note') {
-                    const pitch = event.noteNumber;
-                    currentSpans.push({
-                        type,
-                        id: `${i}-${currentTime}-${pitch}`,
-                        onset: currentTime,
-                        offset: 0,
-                        velocity: event.velocity,
-                        pitch,
-                        channel: i,
-                        onsetMs,
-                        offsetMs: milliseconds(0),
-                        link
-                    });
-                }
-                else {
-                    currentSpans.push({
-                        type,
-                        id: `${i}-${currentTime}-${type}`,
-                        onset: currentTime,
-                        offset: 0,
-                        onsetMs,
-                        offsetMs: milliseconds(0),
-                        link
-                    });
-                }
-                bufferedMetaText = undefined;
-            }
-            else if (isNoteOff(event) || isPedalOff(event) || isSoftPedalOff(event)) {
-                const type = isNoteOff(event) ? 'note' : isPedalOff(event) ? 'sustain' : 'soft';
-                const currentTempo = tempoMap.slice().reverse().find(tempo => tempo.atTick <= currentTime);
-                if (!currentTempo) {
-                    console.log('No tempo event found. Skipping');
-                    continue;
-                }
-                const counterpart = isNoteOff(event)
-                    ? currentSpans.find(e => e.type === 'note' && e.pitch === event.noteNumber)
-                    : currentSpans.find(e => e.type === type);
-                if (!counterpart) {
-                    console.log('Found an off event of type', type, 'at', currentTime, 'without a previous on.', 'Event:', event, 'Current spans: ', currentSpans.map(span => span.type).join(' '));
-                    continue;
-                }
-                counterpart.offset = currentTime;
-                counterpart.offsetMs = midiTickToMilliseconds(currentTime, currentTempo.microsecondsPerBeat, file.header.ticksPerBeat);
-                if (bufferedMetaText && counterpart.link) {
-                    counterpart.link += ` ${bufferedMetaText}`;
-                }
-                resultingSpans.push(counterpart);
-                currentSpans.splice(currentSpans.indexOf(counterpart), 1);
-            }
-        }
-    }
-    return resultingSpans
-        .filter(span => span.offsetMs > span.onsetMs)
-        .sort((a, b) => a.onset - b.onset);
-};

package/lib/readers/spencerMidi.d.ts

@@ -1,27 +0,0 @@
-import { RollCopy } from "../RollCopy";
-import { FeetPerMinute, Millimeters, Seconds, Track } from "../Quantity";
-/**
- * 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) => Track;
-/**
- * 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: import("..").Quantity<"ft/min">;
-/** Place on the roll after `time` at a constant `speed`. */
-export declare const atConstantSpeed: (speed: FeetPerMinute) => (time: Seconds) => Millimeters;
-export declare function readFromSpencerMIDI(midiBuffer: ArrayBuffer, placeAt?: (time: Seconds) => Millimeters, trackOf?: (pitch: number) => Track): RollCopy;

package/lib/readers/spencerMidi.js

@@ -1,60 +0,0 @@
-import { v4 } from "uuid";
-import { read } from "midifile-ts";
-import { asSpans } from "./midiSpans";
-import { feetPerMinute, inSeconds, mm, track } from "../Quantity";
-/**
- * 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 position = pitch - 13;
-    return track(position < 10 ? position - 2 : position);
-};
-const MM_PER_FOOT = 304.8;
-const SECONDS_PER_MINUTE = 60;
-/**
- * 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 = feetPerMinute(8.3);
-/** Place on the roll after `time` at a constant `speed`. */
-export const atConstantSpeed = (speed) => (time) => mm(speed * MM_PER_FOOT / SECONDS_PER_MINUTE * time);
-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(inSeconds(span.onsetMs)),
-            to: placeAt(inSeconds(span.offsetMs)),
-            unit: 'mm'
-        }
-    }));
-    return {
-        type: 'RollCopy',
-        id: v4(),
-        ops: [],
-        conditions: [],
-        keeper: { name: '', sameAs: [] },
-        measurements: {},
-        modifications: [],
-        features
-    };
-}