linked-rolls 0.63.0 → 0.65.0

package/lib/collation/alignment.js

@@ -1,6 +1,7 @@
 import { featuresOf, isTear, tearsOf } from "../model/RollCopy.js";
 import { defaultTrackerBar } from "../systems/index.js";
 import { add, mm, subtract, track } from "../model/Quantity.js";
+import { partitionPoint } from "../shared/sorted.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. */
@@ -217,12 +218,41 @@ const noteOnsets = (features, bar) => features
         .map(meaning => ({ pitch: meaning.pitch, at: feature.horizontal.from }));
 })
     .sort(byPlace);
+/**
+ * The middle one of the values, the upper of the two where their number
+ * is even. It is selected rather than the values sorted (Hoare's FIND,
+ * as Wirth writes it): a long roll gives over a million slopes, and only
+ * the one in the middle is wanted. The values are reordered where they
+ * lie.
+ */
 const median = (values) => {
-    const sorted = [...values].sort((x, y) => x - y);
-    return sorted[Math.floor(sorted.length / 2)] ?? 0;
+    const middle = values.length >> 1;
+    let low = 0;
+    let high = values.length - 1;
+    while (low < high) {
+        const pivot = values[middle];
+        let i = low;
+        let j = high;
+        while (i <= j) {
+            while (values[i] < pivot)
+                i++;
+            while (pivot < values[j])
+                j--;
+            if (i <= j) {
+                const swapped = values[i];
+                values[i] = values[j];
+                values[j] = swapped;
+                i++;
+                j--;
+            }
+        }
+        if (j < middle)
+            low = i;
+        if (middle < i)
+            high = j;
+    }
+    return values[middle] ?? 0;
 };
-/** The slope of the line through two matches, or nothing where they share a place on the copy. */
-const slopeBetween = (m, n) => n.a === m.a ? [] : [(n.b - m.b) / (n.a - m.a)];
 /** Matches beyond this are thinned before the slopes are taken, whose number grows with the square. */
 const SLOPE_SAMPLE = 1500;
 /**
@@ -234,25 +264,27 @@ const SLOPE_SAMPLE = 1500;
 const robustLine = (matches) => {
     const step = Math.max(1, Math.ceil(matches.length / SLOPE_SAMPLE));
     const sample = matches.filter((_, i) => i % step === 0);
-    const slopes = sample.flatMap((m, i) => sample.slice(i + 1).flatMap(n => slopeBetween(m, n)));
-    if (slopes.length === 0)
+    const slopes = new Float64Array(sample.length * (sample.length - 1) / 2);
+    let count = 0;
+    sample.forEach((m, i) => {
+        for (let j = i + 1; j < sample.length; j++) {
+            const n = sample[j];
+            // Two matches at one place on the copy give no slope.
+            if (n.a !== m.a)
+                slopes[count++] = (n.b - m.b) / (n.a - m.a);
+        }
+    });
+    if (count === 0)
         return undefined;
-    const slope = median(slopes);
-    return { slope, intercept: median(matches.map(m => m.b - slope * m.a)) };
+    const slope = median(slopes.subarray(0, count));
+    return { slope, intercept: median(Float64Array.from(matches, m => m.b - slope * m.a)) };
 };
 const placed = (line, a) => line.slope * a + line.intercept;
 const residualOf = (line, match) => match.b - placed(line, match.a);
 /** Pitches in a row that pin down a place on a roll, provided the row occurs once. */
 const ANCHOR_LENGTH = 6;
 /** Every run of `length` pitches, keyed by the run, with the onsets it starts at. */
-const runsOf = (onsets, length) => {
-    const runs = new Map();
-    onsets.slice(0, Math.max(0, onsets.length - length + 1)).forEach((start, i) => {
-        const key = onsets.slice(i, i + length).map(onset => onset.pitch).join(',');
-        runs.set(key, [...(runs.get(key) ?? []), start]);
-    });
-    return runs;
-};
+const runsOf = (onsets, length) => Map.groupBy(onsets.slice(0, Math.max(0, onsets.length - length + 1)), (_, i) => onsets.slice(i, i + length).map(onset => onset.pitch).join(','));
 /** The places a run of pitches found once on each roll ties together. */
 const anchors = (a, b) => {
     const runsB = runsOf(b, ANCHOR_LENGTH);
@@ -277,13 +309,16 @@ const pairedNearestFirst = (candidates) => {
     }
     return matches;
 };
+/** Widens the window by a hair before it is searched, so that rounding in its bounds cannot leave out what the distance admits. */
+const WINDOW_SLACK = 1e-9;
 /** Each onset of A paired with the nearest onset of B of its pitch within the window around where the line puts it. */
 const nearestMatches = (a, b, line, window) => {
-    const bByPitch = new Map();
-    b.forEach(onset => bByPitch.set(onset.pitch, [...(bByPitch.get(onset.pitch) ?? []), onset]));
     const candidates = a.flatMap(onset => {
         const expected = placed(line, onset.at);
-        return (bByPitch.get(onset.pitch) ?? [])
+        const ofPitch = b.get(onset.pitch) ?? [];
+        const first = partitionPoint(ofPitch, other => other.at < expected - window - WINDOW_SLACK);
+        const end = partitionPoint(ofPitch, other => other.at <= expected + window + WINDOW_SLACK);
+        return ofPitch.slice(first, end)
             .map(other => ({ distance: Math.abs(other.at - expected), a: onset, b: other }))
             .filter(candidate => candidate.distance <= window);
     });
@@ -341,5 +376,5 @@ export function alignFeatures(rollA, rollB, barA = defaultTrackerBar, barB = bar
     const coarse = robustLine(anchors(a, b));
     if (!coarse)
         return undefined;
-    return resultOf(WINDOWS.reduce(settled(a, b), { line: coarse, matches: [] }));
+    return resultOf(WINDOWS.reduce(settled(a, Map.groupBy(b, onset => onset.pitch)), { line: coarse, matches: [] }));
 }

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
@@ -66,7 +66,7 @@ export interface ScatterOptions {
     groupOf?: Grouping;
     /** The width of the histogram's bins. */
     binWidth?: Millimeters;
-    /** The tolerance the edition states at present, against which each departure is reported as still admitted or not. */
+    /** The tolerance the derivation states at present, against which each departure is reported as still admitted or not. */
     stated?: CollationTolerance;
 }
 /** A reading the calculated tolerance does not admit. */
@@ -90,7 +90,7 @@ export interface Departure {
      */
     separatedBy: BothEnds<boolean>;
     /**
-     * Whether the tolerance the edition states at present still admits
+     * Whether the tolerance the derivation states at present still admits
      * it. Absent where none was given to compare against.
      *
      * This sees one direction only. A departure is by definition a
@@ -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

@@ -31,7 +31,10 @@ export * from './analysis/witnesses.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';

package/lib/index.js

@@ -24,7 +24,10 @@ export * from './analysis/witnesses.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';

package/lib/io/asJsonLd.js

@@ -59,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) => {
@@ -70,23 +80,19 @@ const changing = (copyId) => (act) => {
         return { ...act, diminished: { '@id': copyId } };
     return act;
 };
+/** The copy with what each of its acts changed stated. */
+const withChangesOf = (copy) => isRecord(copy) && Array.isArray(copy.modifications)
+    ? { ...copy, modifications: copy.modifications.map(changing(copy['@id'])) }
+    : copy;
 /**
  * The document with what each act changed stated. Which of P110
  * augmented and P112 diminished applies depends on the class of the
  * act, which no property chain in OWL 2 RL can test, so the export
  * states it. What a copy or a patch bears is left to a reasoner (see
- * the entailments in reo.ttl).
+ * the entailments in reo.ttl). The copies are the only nodes that are
+ * modified, and the edition holds them in its list of copies alone.
  */
-const withChanges = (value) => {
-    if (Array.isArray(value))
-        return value.map(withChanges);
-    if (!isRecord(value))
-        return value;
-    const node = Object.fromEntries(Object.entries(value).map(([key, child]) => [key, withChanges(child)]));
-    return node['@type'] === 'RollCopy' && Array.isArray(node.modifications)
-        ? { ...node, modifications: node.modifications.map(changing(node['@id'])) }
-        : node;
-};
+const withChanges = (edition) => Array.isArray(edition.copies) ? { ...edition, copies: edition.copies.map(withChangesOf) } : edition;
 /** Terms the context sets to null, which say nothing when the edition is read as RDF. */
 const silentTerms = new Set(Object.entries(context['@context'])
     .filter(([, definition]) => definition === null)
@@ -110,21 +116,24 @@ const quote = (subject, key, reference, listed) => {
     const { '@annotation': { '@id': annotation, ...about }, ...object } = reference;
     return { '@id': { '@id': subject, [key]: listed ? [object] : object }, annotation, ...about };
 };
-/** The value a node states under a key, less the doubted references, and those references quoted. */
-const quotingValue = (subject, key, value) => {
+/** The value a node states under a key, less the doubted references, which go to the quoted. */
+const unquoted = (subject, key, value, quoted) => {
     if (Array.isArray(value)) {
-        return {
-            node: value.filter(item => !isDoubtedReference(item)),
-            quoted: value.filter(isDoubtedReference).map(item => quote(subject, key, item, true))
-        };
+        return value.filter(item => {
+            if (!isDoubtedReference(item))
+                return true;
+            quoted.push(quote(subject, key, item, true));
+            return false;
+        });
     }
-    return isDoubtedReference(value)
-        ? { node: undefined, quoted: [quote(subject, key, value, false)] }
-        : { node: value, quoted: [] };
+    if (!isDoubtedReference(value))
+        return value;
+    quoted.push(quote(subject, key, value, false));
+    return undefined;
 };
 /**
  * The document with every doubted reference taken off the node that
- * states it, and quoted instead.
+ * states it, and quoted instead, in the order the document states them.
  *
  * An `@annotation` in JSON-LD-star states the triple it annotates and
  * then says something about it, so a statement the edition holds
@@ -132,32 +141,28 @@ const quotingValue = (subject, key, value) => {
  * between nodes are quoted, since only they can be put back where they
  * stood; a doubted date or attribution stays annotated in place.
  */
-const withDoubtedReferencesQuoted = (value) => {
-    if (Array.isArray(value)) {
-        const quotings = value.map(withDoubtedReferencesQuoted);
-        return { node: quotings.map(({ node }) => node), quoted: quotings.flatMap(({ quoted }) => quoted) };
-    }
+const withDoubtedReferencesQuoted = (value, quoted) => {
+    if (Array.isArray(value))
+        return value.map(item => withDoubtedReferencesQuoted(item, quoted));
     if (!isRecord(value))
-        return { node: value, quoted: [] };
+        return value;
     const subject = value['@id'];
-    const entries = Object.entries(value).map(([key, child]) => {
-        const own = typeof subject === 'string' && !key.startsWith('@')
-            ? quotingValue(subject, key, child)
-            : { node: child, quoted: [] };
-        const below = withDoubtedReferencesQuoted(own.node);
-        return { key, node: below.node, quoted: [...own.quoted, ...below.quoted] };
+    const node = {};
+    Object.entries(value).forEach(([key, child]) => {
+        const stated = typeof subject === 'string' && !key.startsWith('@') ? unquoted(subject, key, child, quoted) : child;
+        const below = withDoubtedReferencesQuoted(stated, quoted);
+        if (below !== undefined)
+            node[key] = below;
     });
-    return {
-        node: Object.fromEntries(entries.filter(({ node }) => node !== undefined).map(({ key, node }) => [key, node])),
-        quoted: entries.flatMap(({ quoted }) => quoted)
-    };
+    return node;
 };
 /** 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(atOwnPlacesAll(edition)))));
+    const quoted = [];
+    const node = withDoubtedReferencesQuoted(withSystemContexts(withCreations(withChanges(asJsonLdEntity(atOwnPlacesAll(edition))))), quoted);
     // 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.js

@@ -71,6 +71,16 @@ const withPlainCopyIds = (json) => ({
         '@id': typeof copy['@id'] === 'string' ? plainCopyId(copy['@id']) : copy['@id']
     }))
 });
+/** The document without the creations an export gave versions that state none. */
+const withoutEmptyCreations = (json) => Array.isArray(json.versions)
+    ? {
+        ...json,
+        versions: json.versions.map((version) => {
+            const { creation, ...rest } = version;
+            return creation !== null && typeof creation === 'object' && Object.keys(creation).length === 0 ? rest : version;
+        })
+    }
+    : json;
 /** A statement an export quoted rather than stated: an included node whose id is a triple. */
 const isQuotedStatement = (node) => node !== null && typeof node === 'object' && node['@id'] !== null && typeof node['@id'] === 'object';
 /** The reference a quoted statement made, annotated again with the belief the export set beside it. */
@@ -125,7 +135,7 @@ const withQuotedStatementsInPlace = (edition) => {
  * its axis, which is where the copy's alignment carries them.
  */
 export const importJsonLd = (json) => {
-    const { '@context': context, ...document } = withPlainCopyIds(migrate(withQuotedStatementsInPlace(json)));
+    const { '@context': context, ...document } = withoutEmptyCreations(withPlainCopyIds(migrate(withQuotedStatementsInPlace(json))));
     const edition = fromJsonLdEntity(document);
     edition.base = Array.isArray(context)
         ? context.find((c) => c['@base'])?.['@base'] || ''