linked-rolls 0.10.1 → 0.12.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/Quantity.d.ts

@@ -58,4 +58,8 @@ export declare const mean: <U extends Unit>(values: readonly Quantity<U>[]) => Q
 export declare const inMillimeters: (place: Pixels, dpi: number) => Millimeters;
 export declare const inCentimeters: (length: Millimeters) => Centimeters;
 export declare const inSeconds: (time: Milliseconds) => Seconds;
+/** A speed as a record states it, in feet or metres per minute. */
+export type SpeedMeasure = Measure<'ft/min'> | Measure<'m/min'>;
+/** A speed in metres per minute, whichever unit it was stated in. */
+export declare const inMetersPerMinute: (speed: SpeedMeasure) => MetersPerMinute;
 export {};

package/lib/Quantity.js

@@ -23,3 +23,6 @@ const MM_PER_INCH = 25.4;
 export const inMillimeters = (place, dpi) => mm(place / dpi * MM_PER_INCH);
 export const inCentimeters = (length) => cm(length / 10);
 export const inSeconds = (time) => seconds(time / 1000);
+const METERS_PER_FOOT = 0.3048;
+/** A speed in metres per minute, whichever unit it was stated in. */
+export const inMetersPerMinute = (speed) => speed.unit === 'm/min' ? speed.value : metersPerMinute(speed.value * METERS_PER_FOOT);

package/lib/RollCopy.d.ts

@@ -51,9 +51,28 @@ export interface Margins<U extends 'px' | 'mm'> {
     bass: Quantity<U>;
     unit: U;
 }
+/**
+ * A paper speed, as a roll's label, its catalogue or its format
+ * states it.
+ * @see crm:E54 Dimension
+ */
+export type PaperSpeed = Measure<'ft/min'> | Measure<'m/min'>;
+/**
+ * What the scale an alignment found is put down to: the paper of the
+ * copy having stretched or shrunk, or the copy having been cut for
+ * another paper speed than the roll it is aligned with.
+ */
+export type ScaleReading = {
+    cause: 'paper';
+    condition: ObjectAssumption<PaperStretch>;
+} | {
+    cause: 'speed';
+    speed: ObjectAssumption<PaperSpeed>;
+};
 /**
  * Describes the production of a roll copy: the manufacturer,
- * the paper used, and the date.
+ * the paper used, the date, and the system and paper speed the
+ * copy was cut for.
  * @see lrmoo:F32 Item Production Event
  */
 export interface ProductionEvent {
@@ -73,6 +92,22 @@ export interface ProductionEvent {
      * @see dcterms:date
      */
     date?: DateAssignment;
+    /**
+     * The reproducing system the copy was cut for. Left out, it is
+     * the roll's own; a Licensee re-cut of a T-100 roll names the
+     * Licensee here. A system the type vocabulary knows carries the
+     * IRI of its concept as `id`.
+     * @see crm:P32 used general technique
+     */
+    system?: Concept;
+    /**
+     * The paper speed the copy was cut for. A copy cut from the same
+     * master for another speed comes out longer or shorter than the
+     * roll it is aligned with by the ratio of the speeds, which is
+     * what the alignment then measures.
+     * @see reo:paperSpeed
+     */
+    speed?: ObjectAssumption<PaperSpeed>;
 }
 /**
  * This type denotes identifiable activities that modified
@@ -179,6 +214,13 @@ export interface RollCopy extends WithType<'RollCopy'>, WithId {
          * Not exported to RDF.
          */
         shift: Shift;
+        /**
+         * The factor this copy's features were scaled by to align them
+         * with the others. What it is put down to is stated apart: a
+         * paper-stretch condition, or the speed the copy was cut for.
+         * Not exported to RDF.
+         */
+        scale: number;
         /**
          * Relates this copy's scan to the tracker bar: how the scanning
          * software's hole numbering was shifted onto the bar, and where

package/lib/TrackerBar.d.ts

@@ -1,6 +1,6 @@
 import type { Concept } from "./Agent";
 import { Expression, Note } from "./Symbol";
-import { Millimeters, Track } from "./Quantity";
+import { Millimeters, SpeedMeasure, Track } from "./Quantity";
 /**
  * What a tracker bar position does: sound a note, or operate one of
  * the expression valves on the bass or the treble side.
@@ -50,6 +50,12 @@ export interface TrackerBar {
      * a scan against the bar.
      */
     readonly rewindTrack: Track;
+    /**
+     * The paper speed the system runs its rolls at, where the
+     * literature states one. A system whose rolls each carry a tempo
+     * of their own, as the Licensee's do, states none.
+     */
+    readonly paperSpeed?: SpeedMeasure;
     /** `undefined` for a position the bar does not read. */
     meaningOf(position: Track): TrackMeaning | undefined;
     /** `undefined` for a position the bar does not read. */
@@ -77,5 +83,14 @@ export interface TrackerBarSpec {
     };
     /** Every position outside the note block, keyed by track. */
     expressions: ReadonlyMap<number, string>;
+    /** The speed the system runs its rolls at, where the literature states one. */
+    paperSpeed?: SpeedMeasure;
 }
 export declare const describeTrackerBar: (spec: TrackerBarSpec) => TrackerBar;
+/**
+ * Puts a position of one bar onto the position of another that reads
+ * the same thing, or nowhere when the other bar does not read it. This
+ * is how a copy cut for one system takes its place in an edition of
+ * another, as a Licensee re-cut does in an edition of a T-100 roll.
+ */
+export declare const translationBetween: (from: TrackerBar, to: TrackerBar) => (position: Track) => Track | undefined;

package/lib/TrackerBar.js

@@ -41,7 +41,28 @@ export const describeTrackerBar = (spec) => {
         areas,
         expressionTypes: [...new Set(spec.expressions.values())],
         rewindTrack: track(rewind),
+        ...(spec.paperSpeed && { paperSpeed: spec.paperSpeed }),
         meaningOf,
         roleOf
     };
 };
+const keyOf = (meaning) => meaning.type === 'note' ? `note ${meaning.pitch}` : `${meaning.scope} ${meaning.expressionType}`;
+const positionsOf = (bar) => Array.from({ length: bar.trackCount }, (_, i) => track(i + 1));
+/**
+ * Puts a position of one bar onto the position of another that reads
+ * the same thing, or nowhere when the other bar does not read it. This
+ * is how a copy cut for one system takes its place in an edition of
+ * another, as a Licensee re-cut does in an edition of a T-100 roll.
+ */
+export const translationBetween = (from, to) => {
+    const positions = new Map();
+    positionsOf(to).forEach(position => {
+        const meaning = to.meaningOf(position);
+        if (meaning)
+            positions.set(keyOf(meaning), position);
+    });
+    return position => {
+        const meaning = from.meaningOf(position);
+        return meaning ? positions.get(keyOf(meaning)) : undefined;
+    };
+};

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

@@ -1,22 +1,22 @@
-import { ObjectAssumption } from "./Assumption";
 import { AnyFeature } from "./Feature";
-import { PaperStretch, RollCopy, Shift } from "./RollCopy";
+import { RollCopy, Shift } from "./RollCopy";
 import { TrackerBar } from "./TrackerBar";
 import { Millimeters } from "./Quantity";
 export declare const applyShift: (shift: Shift, copy: RollCopy) => void;
-export declare const applyStretch: (paperStretch: ObjectAssumption<PaperStretch>, copy: RollCopy) => void;
+/** Scales the copy's features away from the beginning of the roll, and records the factor. */
+export declare const applyScale: (factor: number, copy: RollCopy) => void;
 /** Takes the shift off the copy's features again, as far as one was applied. */
 export declare const revertShift: (copy: RollCopy) => void;
-/** Takes the stretch off the copy's features again, as far as one was applied. */
-export declare const revertStretch: (copy: RollCopy) => void;
+/** Takes the scale off the copy's features again, as far as one was applied. */
+export declare const revertScale: (copy: RollCopy) => void;
 type AlignmentResult = {
-    /** Applied before the stretch. */
+    /** Applied before the scale. */
     shift: Millimeters;
-    stretch: number;
+    scale: number;
 };
 /**
  * Align two rolls by computing independent linear fits of each roll's note-onset positions
- * using only the first and last segments, then deriving a transform x2 = (x1 + shift) * stretch.
+ * using only the first and last segments, then deriving a transform x2 = (x1 + shift) * scale.
  */
 export declare function alignFeatures(rollA: AnyFeature[], rollB: AnyFeature[], bar?: TrackerBar): AlignmentResult;
 export {};

package/lib/alignment.js

@@ -23,12 +23,13 @@ export const applyShift = (shift, copy) => {
     copy.ops = [...copy.ops, 'shifted'];
     copy.measurements.shift = shift;
 };
-export const applyStretch = (paperStretch, copy) => {
+/** Scales the copy's features away from the beginning of the roll, and records the factor. */
+export const applyScale = (factor, copy) => {
     if (copy.ops.includes('stretched'))
         return;
-    copy.features.forEach(feature => stretch(feature.horizontal, paperStretch.factor));
+    copy.features.forEach(feature => stretch(feature.horizontal, factor));
     copy.ops = [...copy.ops, 'stretched'];
-    copy.conditions.push(paperStretch);
+    copy.measurements.scale = factor;
 };
 /** Takes the shift off the copy's features again, as far as one was applied. */
 export const revertShift = (copy) => {
@@ -43,15 +44,14 @@ export const revertShift = (copy) => {
     copy.ops = copy.ops.filter(op => op !== 'shifted');
     delete copy.measurements.shift;
 };
-const isPaperStretch = (condition) => condition.conditionType === 'paper-stretch';
-/** Takes the stretch off the copy's features again, as far as one was applied. */
-export const revertStretch = (copy) => {
-    const applied = copy.conditions.find(isPaperStretch);
-    if (!copy.ops.includes('stretched') || !applied)
+/** Takes the scale off the copy's features again, as far as one was applied. */
+export const revertScale = (copy) => {
+    const factor = copy.measurements.scale;
+    if (!copy.ops.includes('stretched') || factor === undefined)
         return;
-    copy.features.forEach(feature => stretch(feature.horizontal, 1 / applied.factor));
+    copy.features.forEach(feature => stretch(feature.horizontal, 1 / factor));
     copy.ops = copy.ops.filter(op => op !== 'stretched');
-    copy.conditions = copy.conditions.filter(condition => !isPaperStretch(condition));
+    delete copy.measurements.scale;
 };
 const isNoteOn = (bar) => (feature) => {
     return feature.type === 'Hole' && bar.meaningOf(feature.vertical.from)?.type === 'note';
@@ -85,7 +85,7 @@ function selectEnds(arr, count) {
 }
 /**
  * Align two rolls by computing independent linear fits of each roll's note-onset positions
- * using only the first and last segments, then deriving a transform x2 = (x1 + shift) * stretch.
+ * using only the first and last segments, then deriving a transform x2 = (x1 + shift) * scale.
  */
 export function alignFeatures(rollA, rollB, bar = welteT100) {
     // 1. Extract note-onset positions
@@ -102,8 +102,8 @@ export function alignFeatures(rollA, rollB, bar = welteT100) {
     // 4. Fit index->position for each roll on selected ends
     const { alpha: alphaA, beta: betaA } = fitIndexToPosition(idxA, XA);
     const { alpha: alphaB, beta: betaB } = fitIndexToPosition(idxB, XB);
-    // 5. Derive stretch and shift such that x2 = (x1 + shift) * stretch
-    const stretch = alphaB / alphaA;
-    const shift = mm(betaB / stretch - betaA);
-    return { stretch, shift };
+    // 5. Derive scale and shift such that x2 = (x1 + shift) * scale
+    const scale = alphaB / alphaA;
+    const shift = mm(betaB / scale - betaA);
+    return { scale, shift };
 }