linked-rolls 0.62.0 → 0.64.0

package/lib/collation/alignment.js

@@ -1,56 +1,126 @@
-import { featuresOf } from "../model/RollCopy.js";
+import { featuresOf, isTear, tearsOf } from "../model/RollCopy.js";
 import { defaultTrackerBar } from "../systems/index.js";
-import { add, mm, scale, subtract } from "../model/Quantity.js";
-/** Moves both ends of a span, the far end only where the span has one. */
-const move = (span, by) => {
-    span.from = add(span.from, by);
+import { add, mm, subtract, track } from "../model/Quantity.js";
+/** A place on the copy's own paper, on the edition's axis. */
+export const toAxis = (alignment) => (place) => alignment ? mm((place + alignment.shift.horizontal) * alignment.scale) : place;
+/** A place on the edition's axis, on the copy's own paper. */
+export const fromAxis = (alignment) => (place) => alignment ? mm(place / alignment.scale - alignment.shift.horizontal) : place;
+const acrossToAxis = (alignment) => (position) => alignment ? track(position + alignment.shift.vertical) : position;
+const acrossFromAxis = (alignment) => (position) => alignment ? track(position - alignment.shift.vertical) : position;
+/** Both ends of a span taken through the mapping, the far end only where the span has one. */
+const mapped = (span, through) => {
+    span.from = through(span.from);
     if (span.to !== undefined)
-        span.to = add(span.to, by);
+        span.to = through(span.to);
 };
-/** Stretches both ends of a span away from the beginning of the roll. */
-const stretch = (span, factor) => {
-    span.from = scale(span.from, factor);
-    if (span.to !== undefined)
-        span.to = scale(span.to, factor);
+/**
+ * Where along the roll the copy states anything: its features, and its
+ * tears, which are measured as the features are. A tear states no track,
+ * so the shift across the roll leaves it where it is.
+ */
+const spansAlong = (copy) => [...featuresOf(copy), ...tearsOf(copy)].map(placed => placed.horizontal);
+/** Puts the copy's own places onto the axis in place. */
+const moveOnto = (alignment, copy) => {
+    spansAlong(copy).forEach(span => mapped(span, toAxis(alignment)));
+    featuresOf(copy).forEach(feature => mapped(feature.vertical, acrossToAxis(alignment)));
 };
-const back = (shift) => ({ horizontal: scale(shift.horizontal, -1), vertical: scale(shift.vertical, -1) });
-export const applyShift = (shift, copy) => {
-    if (copy.measurements.shift)
-        return;
-    featuresOf(copy).forEach(feature => {
-        move(feature.horizontal, shift.horizontal);
-        move(feature.vertical, shift.vertical);
-    });
-    copy.measurements.shift = shift;
+/** Takes the copy's places on the axis back to its own paper in place. */
+const moveOff = (alignment, copy) => {
+    spansAlong(copy).forEach(span => mapped(span, fromAxis(alignment)));
+    featuresOf(copy).forEach(feature => mapped(feature.vertical, acrossFromAxis(alignment)));
 };
-/** Scales the copy's features away from the beginning of the roll, and records the factor. */
-export const applyScale = (factor, copy) => {
-    if (copy.measurements.scale !== undefined)
-        return;
-    featuresOf(copy).forEach(feature => stretch(feature.horizontal, factor));
-    copy.measurements.scale = factor;
+/**
+ * Carries the copy's features and tears from its own places onto the
+ * axis, and records how, in place of any alignment it had: that one is
+ * taken off first.
+ */
+export const applyAlignment = (alignment, copy) => {
+    revertAlignment(copy);
+    moveOnto(alignment, copy);
+    copy.measurements.alignment = alignment;
 };
-/** Takes the shift off the copy's features again, as far as one was applied. */
-export const revertShift = (copy) => {
-    const shift = copy.measurements.shift;
-    if (!shift)
+/** Takes the copy's features and tears back to its own places, as far as it was aligned. */
+export const revertAlignment = (copy) => {
+    const alignment = copy.measurements.alignment;
+    if (!alignment)
         return;
-    const reversed = back(shift);
-    featuresOf(copy).forEach(feature => {
-        move(feature.horizontal, reversed.horizontal);
-        move(feature.vertical, reversed.vertical);
-    });
-    delete copy.measurements.shift;
+    moveOff(alignment, copy);
+    delete copy.measurements.alignment;
 };
-/** 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 (factor === undefined)
-        return;
-    featuresOf(copy).forEach(feature => stretch(feature.horizontal, 1 / factor));
-    delete copy.measurements.scale;
+/**
+ * Places are written to the nanometre. Carried onto the axis and back,
+ * a place comes back a rounding error away from where it was, and a
+ * document saved again would change in its last digits every time.
+ * A scan resolves a tenth of a millimetre at best.
+ */
+const PLACES_PER_MM = 1e6;
+const written = (place) => mm(Math.round(place * PLACES_PER_MM) / PLACES_PER_MM);
+/**
+ * The copy with its features and tears at its own places, as a document
+ * holds them, and its alignment kept to say how they go onto the axis.
+ * The copy given is left as it is. A copy that is not aligned is the
+ * very same copy.
+ */
+export const atOwnPlaces = (copy) => {
+    const alignment = copy.measurements.alignment;
+    if (!alignment)
+        return copy;
+    const along = (place) => written(fromAxis(alignment)(place));
+    const across = acrossFromAxis(alignment);
+    const ownSpan = (span, through) => {
+        const own = { ...span };
+        mapped(own, through);
+        return own;
+    };
+    const ownFeature = (feature) => ({ ...feature, horizontal: ownSpan(feature.horizontal, along), vertical: ownSpan(feature.vertical, across) });
+    return {
+        ...copy,
+        ...(copy.production && {
+            production: {
+                ...copy.production,
+                ...(copy.production.produced && { produced: copy.production.produced.map(ownFeature) })
+            }
+        }),
+        modifications: copy.modifications.map(act => {
+            if (act.type === 'Alteration')
+                return { ...act, produced: act.produced.map(ownFeature) };
+            if (act.type === 'Attachment')
+                return { ...act, added: act.added.map(ownFeature) };
+            return act;
+        }),
+        conditions: copy.conditions.map(condition => isTear(condition)
+            ? { ...condition, horizontal: ownSpan(condition.horizontal, along) }
+            : condition)
+    };
+};
+/**
+ * Puts the features and tears of a copy read from a document, which
+ * holds them at the copy's own places, onto the axis. The copy given is
+ * changed.
+ */
+export const putOnAxis = (copy) => {
+    const alignment = copy.measurements.alignment;
+    if (alignment)
+        moveOnto(alignment, copy);
+};
+/** The copy's features at its own places, as it was read, whatever alignment it has. */
+export const ownFeaturesOf = (copy) => {
+    const alignment = copy.measurements.alignment;
+    if (!alignment)
+        return featuresOf(copy);
+    return featuresOf(copy).map(feature => {
+        const own = { ...feature, horizontal: { ...feature.horizontal }, vertical: { ...feature.vertical } };
+        mapped(own.horizontal, fromAxis(alignment));
+        mapped(own.vertical, acrossFromAxis(alignment));
+        return own;
+    });
 };
 const chainsOf = (copy) => featuresOf(copy).filter(feature => feature.type === 'HoleChain');
+/**
+ * The reader's extension as it lies on the axis. It is a length on the
+ * copy's own paper, which the alignment scales like any other.
+ */
+const extensionOnAxis = (extension, copy) => mm(extension * (copy.measurements.alignment?.scale ?? 1));
 /**
  * Takes the extension a pneumatic reader adds off the ends of the
  * copy's chains of holes, and records how much was taken.
@@ -86,7 +156,10 @@ const chainsOf = (copy) => featuresOf(copy).filter(feature => feature.type === '
  * on the feature, a reading of the chain, a smaller extension — and
  * `shortenChains` throws rather than answer it.
  */
-export const tooShortToShorten = (extension, copy, leaving = new Set()) => chainsOf(copy).filter(chain => !leaving.has(chain.id) && chain.horizontal.to - chain.horizontal.from <= extension);
+export const tooShortToShorten = (extension, copy, leaving = new Set()) => {
+    const onAxis = extensionOnAxis(extension, copy);
+    return chainsOf(copy).filter(chain => !leaving.has(chain.id) && chain.horizontal.to - chain.horizontal.from <= onAxis);
+};
 /**
  * Takes the extension off, leaving the named chains as the reader gave
  * them. Naming a chain is an editorial act and not a repair: it says
@@ -107,10 +180,11 @@ export const shortenChains = (extension, copy, leaving = new Set()) => {
             + `chain(s) of holes of copy ${copy.id}, which are no longer than it: `
             + `${tooShort.map(chain => chain.id).join(', ')}`);
     }
+    const onAxis = extensionOnAxis(extension, copy);
     const left = chainsOf(copy).filter(chain => leaving.has(chain.id)).map(chain => chain.id);
     chainsOf(copy)
         .filter(chain => !leaving.has(chain.id))
-        .forEach(chain => { chain.horizontal.to = subtract(chain.horizontal.to, extension); });
+        .forEach(chain => { chain.horizontal.to = subtract(chain.horizontal.to, onAxis); });
     copy.measurements.readerExtension = { length: extension, ...(left.length > 0 && { leaving: left }) };
 };
 /** Puts the reader's extension back on the chains it was taken off, as far as one was taken off. */
@@ -118,12 +192,20 @@ export const revertShortening = (copy) => {
     const taken = copy.measurements.readerExtension;
     if (taken === undefined)
         return;
+    const onAxis = extensionOnAxis(taken.length, copy);
     const left = new Set(taken.leaving ?? []);
     chainsOf(copy)
         .filter(chain => !left.has(chain.id))
-        .forEach(chain => { chain.horizontal.to = add(chain.horizontal.to, taken.length); });
+        .forEach(chain => { chain.horizontal.to = add(chain.horizontal.to, onAxis); });
     delete copy.measurements.readerExtension;
 };
+/**
+ * The method `alignFeatures` follows, as an alignment records it. Its
+ * revision changes when the method does and at no other release, so
+ * that an alignment found by an earlier method can be told from one
+ * that would be found again as it stands.
+ */
+export const ALIGNMENT_METHOD = { software: 'linked-rolls alignFeatures', version: '1' };
 const byPlace = (x, y) => x.at - y.at || x.pitch - y.pitch;
 /** The notes the bar reads off the features, in the order they pass it. */
 const noteOnsets = (features, bar) => features
@@ -218,15 +300,23 @@ const settled = (a, b) => (fit, window) => {
     const matches = nearestMatches(a, b, fit.line, window);
     return { line: robustLine(matches) ?? fit.line, matches };
 };
+/** How far the places of the matches on the copy spread, as a standard deviation. */
+const spreadOf = (matches) => {
+    const centre = matches.reduce((total, m) => total + m.a, 0) / matches.length;
+    return Math.sqrt(matches.reduce((total, m) => total + (m.a - centre) ** 2, 0) / matches.length);
+};
 const resultOf = ({ line, matches }) => {
     if (matches.length < 2 || line.slope <= 0)
         return undefined;
     const squares = matches.reduce((total, m) => total + residualOf(line, m) ** 2, 0);
+    const residual = Math.sqrt(squares / matches.length);
+    const spread = spreadOf(matches);
     return {
         shift: mm(line.intercept / line.slope),
         scale: line.slope,
         matched: matches.length,
-        residual: mm(Math.sqrt(squares / matches.length))
+        residual: mm(residual),
+        scaleError: spread > 0 ? residual / (spread * Math.sqrt(matches.length)) : Infinity
     };
 };
 /**

package/lib/collation/scatter.d.ts

@@ -1,9 +1,9 @@
 import { Belief } from "../model/Assumption.js";
 import { BothEnds, CollationTolerance, Displacement } from "./Collation.js";
-import { EditionView } from "../view/EditionView.js";
 import { Millimeters } from "../model/Quantity.js";
 import { Histogram, Spread, Tail } from "./statistics.js";
 import { AnySymbol } from "../model/Symbol.js";
+import { Edition } from "../model/Edition.js";
 /**
  * How far the copies of a roll disagree about where a symbol lies, and
  * the collation tolerance that follows from it.
@@ -44,7 +44,7 @@ export interface Reading {
  * A symbol only one side carries measures nothing and is passed over,
  * which leaves out exactly the insertions and the deletions.
  */
-export declare const readingsOf: (view: EditionView, symbols: readonly Readonly<AnySymbol>[], copies: ReadonlySet<string>) => Reading[];
+export declare const readingsOf: (edition: Edition, symbols: readonly Readonly<AnySymbol>[], copies: ReadonlySet<string>) => Reading[];
 /**
  * What sample a reading belongs to. Notes and expressions are taken
  * apart by default, since in the present material they scatter
@@ -166,7 +166,7 @@ export declare const departureThreshold: (n: number) => number;
  */
 export declare const scatterOf: (readings: readonly Reading[], options?: ScatterOptions) => Scatter[];
 /** How one copy's readings of a version's text scatter against the readings of the copies it is collated with. */
-export declare const scatterOfCopy: (view: EditionView, versionId: string, copyId: string, options?: ScatterOptions) => Scatter[];
+export declare const scatterOfCopy: (edition: Edition, versionId: string, copyId: string, options?: ScatterOptions) => Scatter[];
 /**
  * Which side of a derivation a measurement was taken over: the version
  * derived, or the version it is read against.
@@ -256,7 +256,7 @@ export interface Sides {
  * neither side, which is the case where the edition has genuinely
  * stopped saying and an editor has to.
  */
-export declare const sidesOf: (view: EditionView, versionId: string) => Sides | undefined;
+export declare const sidesOf: (edition: Edition, versionId: string) => Sides | undefined;
 /**
  * The belief a calculated tolerance rests on, to annotate the
  * derivation's `collationTolerance` with: an inference from the scatter

package/lib/collation/scatter.js

@@ -4,12 +4,14 @@ import { mean, mm } from "../model/Quantity.js";
 import { excessKurtosisOf, histogramOf, normalQuantile, spreadOf, standardise, tailOf } from "./statistics.js";
 import { groupBy } from "../shared/utils.js";
 import { deletedBy, insertedBy } from "../model/Version.js";
+import { carriersOf, placedCarriersOf, snapshotOf } from "../analysis/text.js";
+import { copyOfFeature, symbolsIn, versionIn } from "../lookup/lookup.js";
 const placeOf = (carriers) => ({
     from: mean(carriers.map(carrier => carrier.horizontal.from)),
     to: mean(carriers.map(carrier => carrier.horizontal.to))
 });
-const sitsOn = (view, copies) => (feature) => {
-    const copy = view.copyOf(feature.id);
+const sitsOn = (edition, copies) => (feature) => {
+    const copy = copyOfFeature(edition, feature.id);
     return copy !== undefined && copies.has(copy.id);
 };
 /**
@@ -34,10 +36,10 @@ const sitsOn = (view, copies) => (feature) => {
  * A symbol only one side carries measures nothing and is passed over,
  * which leaves out exactly the insertions and the deletions.
  */
-export const readingsOf = (view, symbols, copies) => {
-    const tested = sitsOn(view, copies);
+export const readingsOf = (edition, symbols, copies) => {
+    const tested = sitsOn(edition, copies);
     return symbols.flatMap((symbol) => {
-        const carriers = view.placedCarriersOf(symbol);
+        const carriers = placedCarriersOf(edition, symbol);
         const here = carriers.filter(tested);
         const there = carriers.filter(carrier => !tested(carrier));
         if (here.length === 0 || there.length === 0)
@@ -120,7 +122,7 @@ const scatterIn = (group, sample, { binWidth = DEFAULT_BIN_WIDTH, stated }) => {
 export const scatterOf = (readings, options = {}) => [...groupBy(readings, reading => (options.groupOf ?? byWhatItIs)(reading.symbol))]
     .flatMap(([group, sample]) => scatterIn(group, sample, options));
 /** How one copy's readings of a version's text scatter against the readings of the copies it is collated with. */
-export const scatterOfCopy = (view, versionId, copyId, options = {}) => scatterOf(readingsOf(view, view.snapshot(versionId), new Set([copyId])), options);
+export const scatterOfCopy = (edition, versionId, copyId, options = {}) => scatterOf(readingsOf(edition, snapshotOf(edition, versionId), new Set([copyId])), options);
 const covering = (windows) => {
     const lowest = Math.min(...windows.map(window => window.offset - window.tolerance));
     const highest = Math.max(...windows.map(window => window.offset + window.tolerance));
@@ -189,10 +191,10 @@ export const changesBetween = (readings, inForce, proposed) => ({
     separated: readings.filter(({ displacement }) => admits(inForce, displacement) && !admits(proposed, displacement)),
     merged: readings.filter(({ displacement }) => !admits(inForce, displacement) && admits(proposed, displacement))
 });
-const copiesBearing = (view, symbols) => {
+const copiesBearing = (edition, symbols) => {
     const tally = symbols.reduce((counts, symbol) => {
-        const bearers = new Set(view.carriersOf(symbol).flatMap(carrier => {
-            const copy = view.copyOf(carrier.id);
+        const bearers = new Set(carriersOf(edition, symbol).flatMap(carrier => {
+            const copy = copyOfFeature(edition, carrier.id);
             return copy ? [copy.id] : [];
         }));
         bearers.forEach(copy => counts.set(copy, (counts.get(copy) ?? 0) + 1));
@@ -219,13 +221,13 @@ const copiesBearing = (view, symbols) => {
  * neither side, which is the case where the edition has genuinely
  * stopped saying and an editor has to.
  */
-export const sidesOf = (view, versionId) => {
-    const version = view.version(versionId);
+export const sidesOf = (edition, versionId) => {
+    const version = versionIn(edition, versionId);
     if (!version)
         return undefined;
     return {
-        child: copiesBearing(view, insertedBy(version)),
-        parent: copiesBearing(view, view.symbols(deletedBy(version)))
+        child: copiesBearing(edition, insertedBy(version)),
+        parent: copiesBearing(edition, symbolsIn(edition, deletedBy(version)))
     };
 };
 const inMillimetres = (value) => `${value.toFixed(2)} mm`;

package/lib/emulation/Emulation.d.ts

@@ -1,9 +1,9 @@
 import { MidiFile } from "midifile-ts";
-import { EditionView } from "../view/EditionView.js";
 import type { TrackerBar } from "../systems/TrackerBar.js";
 import { Version } from "../model/Version.js";
 import { AnyPerformedRollFeature, EmulatedCurve, NegotiatedEvent, ReproducingSystem } from "../systems/ReproducingSystem.js";
 import { Millimeters } from "../model/Quantity.js";
+import { Edition } from "../model/Edition.js";
 export type EmulationScope = {
     /** Only notes whose onset lies within this span of the roll are played. */
     range?: [Millimeters, Millimeters];
@@ -12,17 +12,17 @@ export type EmulationScope = {
 };
 /**
  * The events moved to where their statements put them, the events given
- * left as they were. The view supplies the copies, whose measurements
+ * left as they were. The edition supplies the copies, whose measurements
  * decide how far before or after its reference a command goes, and a
  * punch diameter, or a millimetre, where no copy agrees with a statement.
  */
-export declare const withPlacementsApplied: (view: EditionView, events: readonly NegotiatedEvent[]) => NegotiatedEvent[];
+export declare const withPlacementsApplied: (edition: Edition, events: readonly NegotiatedEvent[]) => NegotiatedEvent[];
 /**
  * The commands of a version as the bar performs them, in order of place,
  * within the scope and with the placements applied. A note plays only
  * where its onset falls in the range; expressions play throughout.
  */
-export declare const negotiatedEventsOf: (view: EditionView, version: Readonly<Version>, bar: TrackerBar, { range }?: Pick<EmulationScope, 'range'>) => NegotiatedEvent[];
+export declare const negotiatedEventsOf: (edition: Edition, version: Readonly<Version>, bar: TrackerBar, { range }?: Pick<EmulationScope, 'range'>) => NegotiatedEvent[];
 /** A version performed: what was negotiated, and what the system made of it. */
 export interface Emulated {
     /** The id of the version performed. */
@@ -36,7 +36,7 @@ export interface Emulated {
  * Performs a version on a reproducing system: the symbols are negotiated
  * into placed events and the system plays them. Nothing given is changed.
  */
-export declare const emulate: <Options extends object>(system: ReproducingSystem<Options>, version: Readonly<Version>, view: EditionView, options?: Options, { range, skipToFirstNote }?: EmulationScope) => Emulated;
+export declare const emulate: <Options extends object>(system: ReproducingSystem<Options>, version: Readonly<Version>, edition: Edition, options?: Options, { range, skipToFirstNote }?: EmulationScope) => Emulated;
 /**
  * The performed events as a MIDI file, in which every note and pedal step
  * is labelled with the symbol it performs. The file names the system, the
@@ -57,8 +57,8 @@ export declare class Emulation<Options extends object> {
     source?: string;
     constructor(system: ReproducingSystem<Options>, options?: Options);
     /** Moves the negotiated events to where their statements put them; see `withPlacementsApplied`. */
-    applyConstraints(view: EditionView): void;
-    emulateVersion(version: Version, view: EditionView, scope?: EmulationScope): AnyPerformedRollFeature[];
+    applyConstraints(edition: Edition): void;
+    emulateVersion(version: Version, edition: Edition, scope?: EmulationScope): AnyPerformedRollFeature[];
     findEventsPerforming(id: string): AnyPerformedRollFeature[];
     asMIDI(): MidiFile;
 }

package/lib/emulation/Emulation.js

@@ -5,25 +5,27 @@ import { add, mean, mm, seconds, subtract } from "../model/Quantity.js";
 import { punchDiameterOf } from "../model/RollCopy.js";
 import { toOwnPaperOf } from "../analysis/ownPaper.js";
 import { negotiatedEventOf } from "./negotiation.js";
+import { placedCarriersOf, snapshotOf } from "../analysis/text.js";
+import { copyOfFeature, symbolIn } from "../lookup/lookup.js";
 /** The punch diameter the edition's copies report, where any of them does. */
-const meanPunchDiameterOf = (view) => {
-    const measured = view.edition.copies
+const meanPunchDiameterOf = (edition) => {
+    const measured = edition.copies
         .map(punchDiameterOf)
         .filter(value => value !== undefined);
     return measured.length > 0 ? mean(measured) : undefined;
 };
-const propertiesOf = (view, version) => ({
-    punchDiameter: meanPunchDiameterOf(view),
-    tempo: view.edition.tempoAdjustment,
-    toOwnPaper: toOwnPaperOf(view, version)
+const propertiesOf = (edition, version) => ({
+    punchDiameter: meanPunchDiameterOf(edition),
+    tempo: edition.tempoAdjustment,
+    toOwnPaper: toOwnPaperOf(edition, version)
 });
 /** The onset a symbol has on each copy carrying it, by the copy's id, as the mean of its chains there. */
-const onsetsByCopy = (view, symbolId) => {
-    const symbol = view.symbol(symbolId);
+const onsetsByCopy = (edition, symbolId) => {
+    const symbol = symbolIn(edition, symbolId);
     if (!symbol)
         return new Map();
-    const onsets = view.placedCarriersOf(symbol).flatMap((carrier) => {
-        const copy = view.copyOf(carrier.id);
+    const onsets = placedCarriersOf(edition, symbol).flatMap((carrier) => {
+        const copy = copyOfFeature(edition, carrier.id);
         return copy ? [[copy.id, carrier.horizontal.from]] : [];
     });
     const copies = new Set(onsets.map(([copy]) => copy));
@@ -34,9 +36,9 @@ const onsetsByCopy = (view, symbolId) => {
  * the follower on each copy carrying both, negative where the follower
  * comes first there.
  */
-const offsetsBetween = (view, followerId, referenceId) => {
-    const references = onsetsByCopy(view, referenceId);
-    return [...onsetsByCopy(view, followerId)].flatMap(([copy, onset]) => {
+const offsetsBetween = (edition, followerId, referenceId) => {
+    const references = onsetsByCopy(edition, referenceId);
+    return [...onsetsByCopy(edition, followerId)].flatMap(([copy, onset]) => {
         const reference = references.get(copy);
         return reference === undefined ? [] : [subtract(onset, reference)];
     });
@@ -91,13 +93,13 @@ const displacementsOf = (events, offsetsBetween, gap) => {
 const earliestOf = (times) => times.length === 0 ? seconds(0) : times.reduce((soonest, at) => at < soonest ? at : soonest);
 /**
  * The events moved to where their statements put them, the events given
- * left as they were. The view supplies the copies, whose measurements
+ * left as they were. The edition supplies the copies, whose measurements
  * decide how far before or after its reference a command goes, and a
  * punch diameter, or a millimetre, where no copy agrees with a statement.
  */
-export const withPlacementsApplied = (view, events) => {
-    const gap = meanPunchDiameterOf(view) ?? mm(1);
-    const offsets = (follower, reference) => offsetsBetween(view, follower, reference);
+export const withPlacementsApplied = (edition, events) => {
+    const gap = meanPunchDiameterOf(edition) ?? mm(1);
+    const offsets = (follower, reference) => offsetsBetween(edition, follower, reference);
     const displacements = displacementsOf(events, offsets, gap);
     return events.map(event => {
         const distance = displacements.get(event);
@@ -112,11 +114,11 @@ export const withPlacementsApplied = (view, events) => {
  * within the scope and with the placements applied. A note plays only
  * where its onset falls in the range; expressions play throughout.
  */
-export const negotiatedEventsOf = (view, version, bar, { range } = {}) => {
+export const negotiatedEventsOf = (edition, version, bar, { range } = {}) => {
     const inScope = (event) => !range || event.type !== 'note' || (event.horizontal.from > range[0] && event.horizontal.from < range[1]);
-    return withPlacementsApplied(view, view.snapshot(version.id)
+    return withPlacementsApplied(edition, snapshotOf(edition, version.id)
         .filter(isCommand)
-        .map(symbol => negotiatedEventOf(view, symbol, bar))
+        .map(symbol => negotiatedEventOf(edition, symbol, bar))
         .filter(event => event !== null)
         .filter(inScope));
 };
@@ -124,11 +126,11 @@ export const negotiatedEventsOf = (view, version, bar, { range } = {}) => {
  * Performs a version on a reproducing system: the symbols are negotiated
  * into placed events and the system plays them. Nothing given is changed.
  */
-export const emulate = (system, version, view, options = system.defaultOptions, { range, skipToFirstNote = false } = {}) => {
-    const negotiated = negotiatedEventsOf(view, version, system.trackerBar, { range });
+export const emulate = (system, version, edition, options = system.defaultOptions, { range, skipToFirstNote = false } = {}) => {
+    const negotiated = negotiatedEventsOf(edition, version, system.trackerBar, { range });
     if (negotiated.length === 0)
         return { source: version.id, negotiated, events: [], curves: [] };
-    const performance = system.perform(negotiated, options, propertiesOf(view, version));
+    const performance = system.perform(negotiated, options, propertiesOf(edition, version));
     const onsets = performance.events.filter(event => event.type === 'noteOn').map(event => event.at);
     const origin = skipToFirstNote ? earliestOf(onsets) : seconds(0);
     return {
@@ -262,11 +264,11 @@ export class Emulation {
         this.options = options;
     }
     /** Moves the negotiated events to where their statements put them; see `withPlacementsApplied`. */
-    applyConstraints(view) {
-        this.negotiatedEvents = withPlacementsApplied(view, this.negotiatedEvents);
+    applyConstraints(edition) {
+        this.negotiatedEvents = withPlacementsApplied(edition, this.negotiatedEvents);
     }
-    emulateVersion(version, view, scope = {}) {
-        const emulated = emulate(this.system, version, view, this.options, scope);
+    emulateVersion(version, edition, scope = {}) {
+        const emulated = emulate(this.system, version, edition, this.options, scope);
         this.source = emulated.source;
         this.negotiatedEvents = [...emulated.negotiated];
         this.curves = emulated.curves;

package/lib/emulation/negotiation.d.ts

@@ -1,7 +1,7 @@
-import type { EditionView } from "../view/EditionView.js";
 import type { Expression, Note } from "../model/Symbol.js";
 import type { TrackerBar } from "../systems/TrackerBar.js";
 import type { NegotiatedEvent } from "../systems/ReproducingSystem.js";
+import { Edition } from "../model/Edition.js";
 /**
  * The symbol as a performance needs it: where it lies, and the
  * position the performing bar reads it on.
@@ -11,4 +11,4 @@ import type { NegotiatedEvent } from "../systems/ReproducingSystem.js";
  * green version still inherits cannot be performed on a green
  * machine, and an edit has yet to say what took its place.
  */
-export declare const negotiatedEventOf: (view: EditionView, symbol: Note | Expression, bar: TrackerBar) => NegotiatedEvent | null;
+export declare const negotiatedEventOf: (edition: Edition, symbol: Note | Expression, bar: TrackerBar) => NegotiatedEvent | null;

package/lib/emulation/negotiation.js

@@ -1,3 +1,4 @@
+import { placeOf } from "../analysis/text.js";
 /**
  * The symbol as a performance needs it: where it lies, and the
  * position the performing bar reads it on.
@@ -7,8 +8,8 @@
  * green version still inherits cannot be performed on a green
  * machine, and an edit has yet to say what took its place.
  */
-export const negotiatedEventOf = (view, symbol, bar) => {
-    const horizontal = view.placeOf(symbol);
+export const negotiatedEventOf = (edition, symbol, bar) => {
+    const horizontal = placeOf(edition, symbol);
     const position = bar.positionOf(symbol);
     if (!horizontal || position === undefined)
         return null;

package/lib/index.d.ts

@@ -28,11 +28,15 @@ export * from './model/procedures.js';
 export * from './model/vocabulary.js';
 export * from './analysis/reservations.js';
 export * from './analysis/witnesses.js';
-export { alignFeatures, tooShortToShorten, type AlignmentResult } from './collation/alignment.js';
+export { alignFeatures, ALIGNMENT_METHOD, fromAxis, ownFeaturesOf, toAxis, tooShortToShorten, type AlignmentResult } from './collation/alignment.js';
 export * from './collation/statistics.js';
 export * from './model/Edition.js';
-export * from './view/EditionView.js';
+export * from './lookup/lookup.js';
+export * from './lookup/paths.js';
+export * from './analysis/stemma.js';
+export * from './analysis/text.js';
 export * from './analysis/ownPaper.js';
+export * from './analysis/paper.js';
 export * from './emulation/negotiation.js';
 export * from './collation/scatter.js';
 export * from './ops/index.js';

package/lib/index.js

@@ -21,11 +21,15 @@ export * from './model/procedures.js';
 export * from './model/vocabulary.js';
 export * from './analysis/reservations.js';
 export * from './analysis/witnesses.js';
-export { alignFeatures, tooShortToShorten } from './collation/alignment.js';
+export { alignFeatures, ALIGNMENT_METHOD, fromAxis, ownFeaturesOf, toAxis, tooShortToShorten } from './collation/alignment.js';
 export * from './collation/statistics.js';
 export * from './model/Edition.js';
-export * from './view/EditionView.js';
+export * from './lookup/lookup.js';
+export * from './lookup/paths.js';
+export * from './analysis/stemma.js';
+export * from './analysis/text.js';
 export * from './analysis/ownPaper.js';
+export * from './analysis/paper.js';
 export * from './emulation/negotiation.js';
 export * from './collation/scatter.js';
 export * from './ops/index.js';

package/lib/io/asJsonLd.js

@@ -1,6 +1,7 @@
 import { systemIdIn } from "../systems/TrackerBar.js";
 import { certaintyOf, isAsserted } from "../model/Assumption.js";
 import context from "../spec/context.json" with { type: 'json' };
+import { atOwnPlaces } from "../collation/alignment.js";
 /**
  * The keys an export derives from the tree, which no node of the
  * edition states itself. An import reads them off again.
@@ -58,6 +59,16 @@ const withSystemContext = (version) => {
     return system ? { '@context': `https://w3id.org/reo/${system}/context.jsonld`, ...version } : version;
 };
 const withSystemContexts = (edition) => Array.isArray(edition.versions) ? { ...edition, versions: edition.versions.map(withSystemContext) } : edition;
+/**
+ * Gives every version the act that made it, stating nothing of it where
+ * nothing is known. The axioms of reo.ttl order that act in time against
+ * the recording, the copies and the act that made the version it derives
+ * from, and a reasoner cannot place a node the graph lacks. An import
+ * drops it again where it states nothing.
+ */
+const withCreations = (edition) => Array.isArray(edition.versions)
+    ? { ...edition, versions: edition.versions.map((version) => version.creation ? version : { ...version, creation: {} }) }
+    : edition;
 const isRecord = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
 /** The act with what it changed named: an attachment augments the copy, a removal diminishes it. */
 const changing = (copyId) => (act) => {
@@ -151,8 +162,12 @@ const withDoubtedReferencesQuoted = (value) => {
         quoted: entries.flatMap(({ quoted }) => quoted)
     };
 };
+/** The edition with each copy's features and tears at the copy's own places, as a document holds them. */
+const atOwnPlacesAll = (edition) => edition.copies.some(copy => copy.measurements.alignment)
+    ? { ...edition, copies: edition.copies.map(atOwnPlaces) }
+    : edition;
 export const asJsonLd = (edition) => {
-    const { node, quoted } = withDoubtedReferencesQuoted(withSystemContexts(withChanges(asJsonLdEntity(edition))));
+    const { node, quoted } = withDoubtedReferencesQuoted(withSystemContexts(withCreations(withChanges(asJsonLdEntity(atOwnPlacesAll(edition))))));
     // The context is the export's own; one carried in from an import must not override it.
     const { base, '@context': carried, ...rest } = node;
     return {

package/lib/io/importJsonLd.d.ts

@@ -1,5 +1,10 @@
 import { Edition } from "../model/Edition.js";
 export declare const importDate: (str: string) => Date;
 type Json = any;
+/**
+ * Reads an edition. A document holds each copy's features and tears at
+ * the copy's own places, as they were read; the edition holds them on
+ * its axis, which is where the copy's alignment carries them.
+ */
 export declare const importJsonLd: (json: Json) => Edition;
 export {};