linked-rolls 0.63.0 → 0.65.0

package/README.md

@@ -22,7 +22,7 @@ single undo step.
 
 ```ts
 import { produce } from 'immer'
-import { alignCopy, asJsonLd, connectVersions, createVersion, EditionView, importJsonLd, readFromStanfordAton } from 'linked-rolls'
+import { alignCopy, asJsonLd, connectVersions, createVersion, importJsonLd, readFromStanfordAton, snapshotOf } from 'linked-rolls'
 
 let edition = importJsonLd(json)
 
@@ -32,13 +32,21 @@ const copy = readFromStanfordAton(aton)
 edition = produce(edition, createVersion(copy))
 edition = produce(edition, alignCopy(copy.id))
 
-// Collate that version against another one
-const view = new EditionView(edition)
-edition = produce(edition, connectVersions(view, childId, parentId))
+// Collate that version against another one, and read what it shows
+edition = produce(edition, connectVersions(childId, parentId))
+const symbols = snapshotOf(edition, childId)
 
 const document = asJsonLd(edition)
 ```
 
+What is read off an edition, such as `snapshotOf`, `placeOf`,
+`versionIn` or `pathIn`, is worked out once for each state of it and
+kept for as long as the state is. Every change through `produce` yields
+a new state, so nothing needs to be told that the edition changed. For
+the same reason an edition is frozen once anything has been asked of it,
+as immer freezes what it produces: change it through an operation, not
+in place. A draft is asked about as `stateOf(draft)`.
+
 Within the library every place along the roll is a place on the edition's
 axis, the millimetres of its reference copy. A document holds each copy's
 features at the copy's own places, as they were read, together with the
@@ -65,7 +73,7 @@ optional peer dependency that you install only if you need playback.
 import { emulate, midiOf } from 'linked-rolls'
 import { welteT100System } from 'linked-rolls/welte-t100'
 
-const { events, source } = emulate(welteT100System, version, view)
+const { events, source } = emulate(welteT100System, version, edition)
 const midi = midiOf(events, welteT100System.name, welteT100System.defaultOptions, source)
 ```
 

package/lib/analysis/constraints.d.ts

@@ -1,4 +1,4 @@
-import { EditionView } from "../view/EditionView.js";
+import { Edition } from "../model/Edition.js";
 export type ConstraintProblem = {
     version: string;
     symbol: string;
@@ -14,4 +14,4 @@ export type ConstraintProblem = {
  * track that does not say what its symbol says, and a strike that takes
  * nothing out.
  */
-export declare const constraintProblems: (view: EditionView) => ConstraintProblem[];
+export declare const constraintProblems: (edition: Edition) => ConstraintProblem[];

package/lib/analysis/constraints.js

@@ -6,6 +6,9 @@ import { keyOf } from "../systems/TrackerBar.js";
 import { trackerBarOf } from "../systems/index.js";
 import { barOf } from "../model/RollCopy.js";
 import { deletedBy, insertedBy } from "../model/Version.js";
+import { predecessorOf } from "./stemma.js";
+import { placedCarriersOf, snapshotOf } from "./text.js";
+import { copyOfFeature } from "../lookup/lookup.js";
 const missingReference = {
     alignedWith: 'alignment-reference-missing',
     before: 'before-reference-missing',
@@ -77,20 +80,19 @@ const typesNotOnTheBar = (version, snapshot) => {
  * out says 59. Collation across systems consults only the place, so
  * without this nothing checks the tracks at all.
  */
-const carriersOffTheirMeaning = (view, version, commands) => {
-    const misread = (carrier, symbol) => {
-        const copy = view.copyOf(carrier.id);
-        if (!copy)
-            return false;
+const carriedOffItsMeaning = (edition) => (symbol) => {
+    const key = keyOf(symbol);
+    return placedCarriersOf(edition, symbol).some(carrier => {
+        const copy = copyOfFeature(edition, carrier.id);
         // A carrier lying across several positions reads as several commands,
         // and carries the symbol as long as one of them is the symbol's.
-        return !barOf(copy).meaningsOf(carrier.vertical)
-            .some(meaning => keyOf(meaning) === keyOf(symbol));
-    };
-    return commands
-        .filter(symbol => view.placedCarriersOf(symbol).some(carrier => misread(carrier, symbol)))
-        .map(symbol => ({ version, symbol: symbol.id, problem: 'carrier-on-another-track' }));
+        return copy !== undefined && !barOf(copy).meaningsOf(carrier.vertical).some(meaning => keyOf(meaning) === key);
+    });
 };
+/** The commands the version shows among those carried off their meaning. */
+const carriersOffTheirMeaning = (misread, version, commands) => commands
+    .filter(symbol => misread.has(symbol))
+    .map(symbol => ({ version, symbol: symbol.id, problem: 'carrier-on-another-track' }));
 /**
  * Where a copy of the version's own system strays from the others in
  * its paper by more than paper does.
@@ -101,13 +103,9 @@ const carriersOffTheirMeaning = (view, version, commands) => {
  * speed, and averaging it in would hide both that and the fact that the
  * playback rests on a guess.
  */
-const paperDisagreed = (view, version) => {
-    const own = new Set(paperOfVersion(view, version)?.copies ?? []);
-    return alignmentProblems(view.edition)
-        .some(({ copy, problem }) => problem === 'paper-beyond-its-spread' && own.has(copy))
-        ? [{ version: version.id, symbol: version.id, problem: 'copies-disagree-on-the-paper' }]
-        : [];
-};
+const paperDisagreed = (edition, strays, version) => paperOfVersion(edition, version)?.copies.some(copy => strays.has(copy))
+    ? [{ version: version.id, symbol: version.id, problem: 'copies-disagree-on-the-paper' }]
+    : [];
 /**
  * A version's strikes that take nothing out of its text: each deleted
  * symbol has to be one the parent hands down, or one the version put
@@ -120,10 +118,10 @@ const paperDisagreed = (view, version) => {
  * into the text unstruck. Nothing else in the edition shows it: the
  * counts move, and only by a handful.
  */
-const strikesBitingNothing = (view, version) => {
-    const parent = view.predecessorOf(version.id);
+const strikesBitingNothing = (edition, version) => {
+    const parent = predecessorOf(edition, version.id);
     const reachable = new Set([
-        ...(parent ? view.snapshot(parent.id).map(symbol => symbol.id) : []),
+        ...(parent ? snapshotOf(edition, parent.id).map(symbol => symbol.id) : []),
         ...insertedBy(version).map(symbol => symbol.id)
     ]);
     return deletedBy(version)
@@ -140,14 +138,22 @@ const strikesBitingNothing = (view, version) => {
  * track that does not say what its symbol says, and a strike that takes
  * nothing out.
  */
-export const constraintProblems = (view) => view.edition.versions.flatMap(version => {
-    const snapshot = view.snapshot(version.id);
-    const commands = snapshot.filter(isCommand);
-    return [
-        ...problemsIn(version.id, commands),
-        ...typesNotOnTheBar(version, snapshot),
-        ...carriersOffTheirMeaning(view, version.id, commands),
-        ...paperDisagreed(view, version),
-        ...strikesBitingNothing(view, version)
-    ];
-});
+export const constraintProblems = (edition) => {
+    // What a symbol's carriers and the copies' paper say holds whichever
+    // version shows them, so it is asked once for the edition.
+    const misread = new Set(edition.versions.flatMap(insertedBy).filter(isCommand).filter(carriedOffItsMeaning(edition)));
+    const strays = new Set(alignmentProblems(edition)
+        .filter(({ problem }) => problem === 'paper-beyond-its-spread')
+        .map(({ copy }) => copy));
+    return edition.versions.flatMap(version => {
+        const snapshot = snapshotOf(edition, version.id);
+        const commands = snapshot.filter(isCommand);
+        return [
+            ...problemsIn(version.id, commands),
+            ...typesNotOnTheBar(version, snapshot),
+            ...carriersOffTheirMeaning(misread, version.id, commands),
+            ...paperDisagreed(edition, strays, version),
+            ...strikesBitingNothing(edition, version)
+        ];
+    });
+};

package/lib/analysis/ownPaper.d.ts

@@ -1,8 +1,8 @@
-import type { EditionView } from "../view/EditionView.js";
 import type { Version } from "../model/Version.js";
 import { PaperOfSystem } from "./paper.js";
+import { Edition } from "../model/Edition.js";
 /** What the alignments say about the paper of the version's own system, where they say anything. */
-export declare const paperOfVersion: (view: EditionView, version: Readonly<Version>) => PaperOfSystem | undefined;
+export declare const paperOfVersion: (edition: Edition, version: Readonly<Version>) => PaperOfSystem | undefined;
 /**
  * How a place on the edition's shared axis relates to the paper of
  * this version: place × factor = millimetres of its own paper.
@@ -18,4 +18,4 @@ export declare const paperOfVersion: (view: EditionView, version: Readonly<Versi
  * Nothing where no copy of the version's system measures its paper,
  * which leaves the performance on the axis.
  */
-export declare const toOwnPaperOf: (view: EditionView, version: Readonly<Version>) => number | undefined;
+export declare const toOwnPaperOf: (edition: Edition, version: Readonly<Version>) => number | undefined;

package/lib/analysis/ownPaper.js

@@ -1,9 +1,9 @@
 import { defaultTrackerBar, trackerBarOf } from "../systems/index.js";
 import { paperOf } from "./paper.js";
 /** What the alignments say about the paper of the version's own system, where they say anything. */
-export const paperOfVersion = (view, version) => {
+export const paperOfVersion = (edition, version) => {
     const system = (trackerBarOf(version.system) ?? defaultTrackerBar).id;
-    return paperOf(view.edition)?.systems.find(paper => paper.system === system);
+    return paperOf(edition)?.systems.find(paper => paper.system === system);
 };
 /**
  * How a place on the edition's shared axis relates to the paper of
@@ -20,4 +20,4 @@ export const paperOfVersion = (view, version) => {
  * Nothing where no copy of the version's system measures its paper,
  * which leaves the performance on the axis.
  */
-export const toOwnPaperOf = (view, version) => paperOfVersion(view, version)?.toOwnPaper;
+export const toOwnPaperOf = (edition, version) => paperOfVersion(edition, version)?.toOwnPaper;

package/lib/analysis/reservations.d.ts

@@ -1,6 +1,6 @@
 import { RollCopy } from "../model/RollCopy.js";
 import { Version } from "../model/Version.js";
-import { EditionView } from "../view/EditionView.js";
+import { Edition } from "../model/Edition.js";
 export declare const reservationTypes: readonly ['source-not-stated', 'source-undocumented', 'software-not-named', 'instrument-not-named', 'features-interpreted', 'no-physical-evidence', 'measurement-undocumented', 'not-calibrated', 'system-unknown', 'keeper-unknown'];
 export type ReservationType = typeof reservationTypes[number];
 /**
@@ -27,4 +27,4 @@ export declare const reservationsAbout: (copy: RollCopy) => Reservation[];
 export declare const versionReservationTypes: readonly ['text-not-stated', 'witnessed-by-statement-only', 'no-direct-witness'];
 export type VersionReservationType = typeof versionReservationTypes[number];
 /** What the edition cannot vouch for in a version, in the order the checks are listed. */
-export declare const reservationsAboutVersion: (view: EditionView, version: Readonly<Version>) => Reservation<VersionReservationType>[];
+export declare const reservationsAboutVersion: (edition: Edition, version: Readonly<Version>) => Reservation<VersionReservationType>[];

package/lib/analysis/reservations.js

@@ -105,12 +105,12 @@ export const versionReservationTypes = [
     'witnessed-by-statement-only',
     'no-direct-witness'
 ];
-const textStated = (_view, version) => version.edits ? undefined : {
+const textStated = (_edition, version) => version.edits ? undefined : {
     type: 'text-not-stated',
     note: 'The version does not state its edits, so it reads as the version it derives from.'
 };
-const witnessedByFeatures = (view, version) => {
-    const witnesses = witnessesOf(view, version.id);
+const witnessedByFeatures = (edition, version) => {
+    const witnesses = witnessesOf(edition, version.id);
     return witnesses.length > 0 && witnesses.every(({ by }) => by === 'statement') ? {
         type: 'witnessed-by-statement-only',
         note: 'No copy\'s features carry what the version inserts; only copies that state they carry it bear witness to it.'
@@ -121,8 +121,8 @@ const witnessedByFeatures = (view, version) => {
  * Its text is a reconstruction from below, as a lost state's is, and
  * nothing surviving shows it as it stood.
  */
-const witnessedAtFirstHand = (view, version) => {
-    const carriers = witnessesOf(view, version.id).filter(({ by }) => by === 'carriers');
+const witnessedAtFirstHand = (edition, version) => {
+    const carriers = witnessesOf(edition, version.id).filter(({ by }) => by === 'carriers');
     return carriers.length > 0 && carriers.every(({ through }) => through !== undefined) ? {
         type: 'no-direct-witness',
         note: 'No copy carries it at first hand; its text is a reconstruction from the versions derived from it.'
@@ -130,4 +130,4 @@ const witnessedAtFirstHand = (view, version) => {
 };
 const versionChecks = [textStated, witnessedByFeatures, witnessedAtFirstHand];
 /** What the edition cannot vouch for in a version, in the order the checks are listed. */
-export const reservationsAboutVersion = (view, version) => versionChecks.flatMap(check => check(view, version) ?? []);
+export const reservationsAboutVersion = (edition, version) => versionChecks.flatMap(check => check(edition, version) ?? []);

package/lib/analysis/sigla.d.ts

@@ -1,13 +1,12 @@
 import { Edition } from '../model/Edition.js';
-import { EditionView } from '../view/EditionView.js';
 /**
- * What the sigla are read off: the versions alone, or a view, which knows
- * the copies as well and so can tell which versions a witness shows.
+ * What the sigla are read off: the versions alone, or the edition, whose
+ * copies tell which versions a witness shows.
  */
-export type Stemma = Pick<Edition, 'versions'> | EditionView;
+export type Stemma = Pick<Edition, 'versions'> | Edition;
 /**
  * The siglum of every version, as the stemma stands: where it sits
- * (`alongTheStemma`) and, given a view, whether any copy shows it.
+ * (`alongTheStemma`) and, given the edition, whether any copy shows it.
  *
  * A version no copy's features carry at first hand is inferred, whether
  * it is reached only through the versions derived from it or a copy does

package/lib/analysis/sigla.js

@@ -91,7 +91,7 @@ const alongTheStemma = (versions) => {
     }
     return sigla;
 };
-const isView = (stemma) => !('versions' in stemma);
+const holdsCopies = (stemma) => 'copies' in stemma;
 /**
  * The sigla with the inferred versions in lowercase, as editions mark a
  * state nothing surviving shows. The letter still names the system and
@@ -100,7 +100,7 @@ const isView = (stemma) => !('versions' in stemma);
 const marking = (sigla, attested) => new Map([...sigla].map(([id, siglum]) => [id, attested.has(id) ? siglum : siglum.toLowerCase()]));
 /**
  * The siglum of every version, as the stemma stands: where it sits
- * (`alongTheStemma`) and, given a view, whether any copy shows it.
+ * (`alongTheStemma`) and, given the edition, whether any copy shows it.
  *
  * A version no copy's features carry at first hand is inferred, whether
  * it is reached only through the versions derived from it or a copy does
@@ -112,8 +112,8 @@ const marking = (sigla, attested) => new Map([...sigla].map(([id, siglum]) => [i
  * A siglum is computed anew when the stemma or the copies change, so
  * nothing should cite one without saying which state it belongs to.
  */
-export const siglaOf = (stemma) => isView(stemma)
-    ? marking(alongTheStemma(stemma.edition.versions), attestedVersions(stemma))
+export const siglaOf = (stemma) => holdsCopies(stemma)
+    ? marking(alongTheStemma(stemma.versions), attestedVersions(stemma))
     : alongTheStemma(stemma.versions);
 /** The siglum of one version as the stemma stands, or nothing where the edition holds no such version. */
 export const siglumOf = (stemma, versionId) => siglaOf(stemma).get(versionId);

package/lib/analysis/stemma.d.ts

@@ -0,0 +1,22 @@
+/** Walking the stemma of an edition along the principal derivations. */
+import { Edition } from "../model/Edition.js";
+import { Version } from "../model/Version.js";
+/**
+ * The version and its ancestors along the principal line, from the
+ * version up to the root. A stemma that loops back on itself is walked
+ * once round, so that an edition in that state can still be read and
+ * repaired.
+ */
+export declare const lineageOf: (edition: Pick<Edition, 'versions'>, versionId: string) => Readonly<Version>[];
+/** The version the given one's text is read against, by its principal derivation. */
+export declare const predecessorOf: (edition: Pick<Edition, 'versions'>, versionId: string) => Readonly<Version> | undefined;
+/**
+ * Every version with its generation: how many principal derivations
+ * lie between it and the root. A version whose parent the edition does
+ * not hold counts as a root. In a stemma that loops, the loop is walked
+ * once round, as `lineageOf` walks it, so that the stemma of an edition
+ * in that state can still be drawn and repaired.
+ */
+export declare const withGenerations: (edition: Pick<Edition, 'versions'>) => Array<Version & {
+    generation: number;
+}>;

package/lib/analysis/stemma.js

@@ -0,0 +1,38 @@
+import { principalDerivationOf } from "../model/Version.js";
+import { idOf } from "../model/Assumption.js";
+import { versionIn } from "../lookup/lookup.js";
+/**
+ * The version and its ancestors along the principal line, from the
+ * version up to the root. A stemma that loops back on itself is walked
+ * once round, so that an edition in that state can still be read and
+ * repaired.
+ */
+export const lineageOf = (edition, versionId) => {
+    const lineage = [];
+    const visited = new Set();
+    let v = versionIn(edition, versionId);
+    while (v && !visited.has(v.id)) {
+        visited.add(v.id);
+        lineage.push(v);
+        const principal = principalDerivationOf(v);
+        v = principal && versionIn(edition, idOf(principal));
+    }
+    return lineage;
+};
+/** The version the given one's text is read against, by its principal derivation. */
+export const predecessorOf = (edition, versionId) => {
+    const v = versionIn(edition, versionId);
+    const principal = v && principalDerivationOf(v);
+    return principal && versionIn(edition, idOf(principal));
+};
+/**
+ * Every version with its generation: how many principal derivations
+ * lie between it and the root. A version whose parent the edition does
+ * not hold counts as a root. In a stemma that loops, the loop is walked
+ * once round, as `lineageOf` walks it, so that the stemma of an edition
+ * in that state can still be drawn and repaired.
+ */
+export const withGenerations = (edition) => edition.versions.map(version => ({
+    ...version,
+    generation: lineageOf(edition, version.id).length - 1
+}));

package/lib/analysis/text.d.ts

@@ -0,0 +1,31 @@
+/** What a version shows, and where along the roll its symbols lie. */
+import { Edition } from "../model/Edition.js";
+import { FeatureOrPatch, HorizontalSpan, NestedFeature } from "../model/Feature.js";
+import { AnySymbol } from "../model/Symbol.js";
+import { Millimeters } from "../model/Quantity.js";
+export declare const carriersOf: (edition: Pick<Edition, 'copies'>, symbol: AnySymbol) => Readonly<NestedFeature>[];
+/** The carriers that state a place of their own, which a feature on a patch does not. */
+export declare const placedCarriersOf: (edition: Pick<Edition, 'copies'>, symbol: AnySymbol) => Readonly<FeatureOrPatch>[];
+/**
+ * Where along the roll the symbol lies, as its carriers put it, or
+ * nothing for a symbol no copy carries.
+ *
+ * Only the place is measured. Which track the symbol sits on is not
+ * a measurement but a question for a tracker bar, since a note of
+ * one pitch sits on exactly one position of a given bar: ask
+ * `bar.positionOf`. The carriers cannot answer it, because a copy
+ * cut for another system numbers its tracks differently, and one
+ * symbol may be carried by copies of both — averaging a red carrier
+ * on track 47 with a green one on 45 would give 46, a legal
+ * position a semitone away on either bar.
+ */
+export declare const placeOf: (edition: Pick<Edition, 'copies'>, symbol: AnySymbol) => Readonly<HorizontalSpan> | undefined;
+/** Where the symbol begins, as the mean onset of its carriers, or nothing for a symbol without a place. */
+export declare const onsetOf: (edition: Pick<Edition, 'copies'>, symbol: AnySymbol) => Millimeters | undefined;
+/**
+ * The symbols the version shows: what it and its ancestors insert,
+ * each version's deletions striking what it or its ancestors inserted.
+ * They are worked out once for each state of the edition, and the list
+ * is frozen, since everyone who asks is handed the same one.
+ */
+export declare const snapshotOf: (edition: Edition, versionId: string) => readonly Readonly<AnySymbol>[];

package/lib/analysis/text.js

@@ -0,0 +1,62 @@
+import { isPlaced } from "../model/Feature.js";
+import { deletedBy, insertedBy } from "../model/Version.js";
+import { idsOf } from "../model/Assumption.js";
+import { mean } from "../model/Quantity.js";
+import { featuresIn } from "../lookup/lookup.js";
+import { perState } from "../lookup/perState.js";
+import { lineageOf } from "./stemma.js";
+export const carriersOf = (edition, symbol) => featuresIn(edition, idsOf(symbol.carriers));
+/** The carriers that state a place of their own, which a feature on a patch does not. */
+export const placedCarriersOf = (edition, symbol) => carriersOf(edition, symbol).filter(isPlaced);
+/**
+ * Where along the roll the symbol lies, as its carriers put it, or
+ * nothing for a symbol no copy carries.
+ *
+ * Only the place is measured. Which track the symbol sits on is not
+ * a measurement but a question for a tracker bar, since a note of
+ * one pitch sits on exactly one position of a given bar: ask
+ * `bar.positionOf`. The carriers cannot answer it, because a copy
+ * cut for another system numbers its tracks differently, and one
+ * symbol may be carried by copies of both — averaging a red carrier
+ * on track 47 with a green one on 45 would give 46, a legal
+ * position a semitone away on either bar.
+ */
+export const placeOf = (edition, symbol) => {
+    const carriers = placedCarriersOf(edition, symbol);
+    if (carriers.length === 0)
+        return;
+    return {
+        unit: 'mm',
+        from: mean(carriers.map(carrier => carrier.horizontal.from)),
+        to: mean(carriers.map(carrier => carrier.horizontal.to))
+    };
+};
+/** Where the symbol begins, as the mean onset of its carriers, or nothing for a symbol without a place. */
+export const onsetOf = (edition, symbol) => placeOf(edition, symbol)?.from;
+/** The symbols by onset, those without a place first; symbols at one place keep their order. */
+const inOrderOfPlace = (edition, symbols) => symbols
+    .map(symbol => ({ symbol, at: onsetOf(edition, symbol) || 0 }))
+    .sort((a, b) => a.at - b.at)
+    .map(({ symbol }) => symbol);
+/** The snapshots of a state asked for so far, by version. */
+const snapshotsIn = perState((_) => new Map());
+/**
+ * The symbols the version shows: what it and its ancestors insert,
+ * each version's deletions striking what it or its ancestors inserted.
+ * They are worked out once for each state of the edition, and the list
+ * is frozen, since everyone who asks is handed the same one.
+ */
+export const snapshotOf = (edition, versionId) => {
+    const known = snapshotsIn(edition);
+    const kept = known.get(versionId);
+    if (kept)
+        return kept;
+    const deleted = new Set();
+    const symbols = lineageOf(edition, versionId).flatMap(version => {
+        deletedBy(version).forEach(id => deleted.add(id));
+        return insertedBy(version).filter(symbol => !deleted.has(symbol.id));
+    });
+    const snapshot = Object.freeze(inOrderOfPlace(edition, symbols));
+    known.set(versionId, snapshot);
+    return snapshot;
+};

package/lib/analysis/witnesses.d.ts

@@ -1,5 +1,5 @@
 import { Belief, Certainty } from "../model/Assumption.js";
-import { EditionView } from "../view/EditionView.js";
+import { Edition } from "../model/Edition.js";
 export type WitnessBy = 'carriers' | 'statement';
 /** A copy that bears witness to a version, and how. */
 export interface Witness {
@@ -25,7 +25,7 @@ export interface Witness {
  * the versions derived from it, or is attested by statement alone, and
  * its text is a reconstruction rather than a reading.
  */
-export declare const attestedVersions: (view: EditionView) => ReadonlySet<string>;
+export declare const attestedVersions: (edition: Edition) => ReadonlySet<string>;
 /**
  * The copies that bear witness to the version: those whose features carry
  * a symbol the version's own edits insert, and those that state they carry
@@ -44,12 +44,12 @@ export declare const attestedVersions: (view: EditionView) => ReadonlySet<string
  * reported as it stands. A version whose edits are not stated inserts
  * nothing and is witnessed by statement alone.
  */
-export declare const witnessesOf: (view: EditionView, versionId: string) => Witness[];
+export declare const witnessesOf: (edition: Edition, versionId: string) => Witness[];
 /**
  * The versions the copy bears witness to, each with how, in the order the
  * edition lists its versions.
  */
-export declare const versionsWitnessedBy: (view: EditionView, copyId: string) => (Witness & {
+export declare const versionsWitnessedBy: (edition: Edition, copyId: string) => (Witness & {
     version: string;
 })[];
 export type CarriageProblem = {
@@ -62,4 +62,4 @@ export type CarriageProblem = {
  * made although the copy's features carry symbols, which say by
  * themselves what it carries, and one naming a version the edition lacks.
  */
-export declare const carriageProblems: (view: EditionView) => CarriageProblem[];
+export declare const carriageProblems: (edition: Edition) => CarriageProblem[];

package/lib/analysis/witnesses.js

@@ -1,48 +1,53 @@
 import { certaintyOf, idOf, idsOf } from "../model/Assumption.js";
 import { insertedBy } from "../model/Version.js";
+import { lineageOf } from "./stemma.js";
+import { copyOfFeature, versionIn } from "../lookup/lookup.js";
+import { perState } from "../lookup/perState.js";
 /** The copies whose features carry any of the symbols. */
-const copiesCarrying = (view, symbols) => new Set(symbols
+const copiesCarrying = (edition, symbols) => new Set(symbols
     .flatMap(symbol => idsOf(symbol.carriers))
     .flatMap(id => {
-    const copy = view.copyOf(id);
+    const copy = copyOfFeature(edition, id);
     return copy ? [copy.id] : [];
 }));
 /** Every copy carrying what a version inserts, version by version, the copies in the order the edition lists them. */
-const carriagesIn = (view) => view.edition.versions.flatMap(version => {
-    const carrying = copiesCarrying(view, insertedBy(version));
-    const depth = view.lineageOf(version.id).length;
-    return view.edition.copies
+const carriagesIn = (edition) => edition.versions.flatMap(version => {
+    const carrying = copiesCarrying(edition, insertedBy(version));
+    const depth = lineageOf(edition, version.id).length;
+    return edition.copies
         .filter(copy => carrying.has(copy.id))
         .map((copy) => ({ copy: copy.id, version: version.id, depth }));
 });
-const carriersIn = (view) => {
-    const carriages = carriagesIn(view);
+/** What the copies' features attest, worked out once for each state of the edition. */
+const carriersIn = perState((edition) => {
+    const carriages = carriagesIn(edition);
+    const byVersion = Map.groupBy(carriages, carriage => carriage.version);
     return {
-        copiesOf: new Map(view.edition.versions.map(version => [
+        copiesOf: new Map(edition.versions.map(version => [
             version.id,
-            carriages.filter(carriage => carriage.version === version.id).map(carriage => carriage.copy)
+            (byVersion.get(version.id) ?? []).map(carriage => carriage.copy)
         ])),
         // Written in order of depth, so a copy's latest carriage is set last and stands.
         latestOf: new Map([...carriages]
             .sort((one, other) => one.depth - other.depth)
             .map(carriage => [carriage.copy, carriage.version]))
     };
-};
+});
 /**
  * The versions a copy's features carry at first hand: for every copy,
  * the latest state it bears. A version left out is reached only through
  * the versions derived from it, or is attested by statement alone, and
  * its text is a reconstruction rather than a reading.
  */
-export const attestedVersions = (view) => new Set(carriersIn(view).latestOf.values());
-const witnessesIn = (carriers, view, versionId) => {
+export const attestedVersions = (edition) => new Set(carriersIn(edition).latestOf.values());
+const witnessesIn = (carriers, edition, versionId) => {
     const carrying = carriers.copiesOf.get(versionId) ?? [];
     const byCarriers = carrying.map((copy) => {
         const latest = carriers.latestOf.get(copy);
         return { copy, by: 'carriers', ...(latest !== undefined && latest !== versionId && { through: latest }) };
     });
     const carryingIt = new Set(carrying);
-    const byStatement = view.edition.copies
+    const byStatement = edition.copies
         .filter(copy => !carryingIt.has(copy.id))
         .flatMap(copy => (copy.carries ?? [])
         .filter(statement => idOf(statement) === versionId)
@@ -70,14 +75,14 @@ const witnessesIn = (carriers, view, versionId) => {
  * reported as it stands. A version whose edits are not stated inserts
  * nothing and is witnessed by statement alone.
  */
-export const witnessesOf = (view, versionId) => view.version(versionId) ? witnessesIn(carriersIn(view), view, versionId) : [];
+export const witnessesOf = (edition, versionId) => versionIn(edition, versionId) ? witnessesIn(carriersIn(edition), edition, versionId) : [];
 /**
  * The versions the copy bears witness to, each with how, in the order the
  * edition lists its versions.
  */
-export const versionsWitnessedBy = (view, copyId) => {
-    const carriers = carriersIn(view);
-    return view.edition.versions.flatMap(version => witnessesIn(carriers, view, version.id)
+export const versionsWitnessedBy = (edition, copyId) => {
+    const carriers = carriersIn(edition);
+    return edition.versions.flatMap(version => witnessesIn(carriers, edition, version.id)
         .filter(witness => witness.copy === copyId)
         .map(witness => ({ ...witness, version: version.id })));
 };
@@ -86,13 +91,13 @@ export const versionsWitnessedBy = (view, copyId) => {
  * made although the copy's features carry symbols, which say by
  * themselves what it carries, and one naming a version the edition lacks.
  */
-export const carriageProblems = (view) => {
-    const carrying = copiesCarrying(view, view.edition.versions.flatMap(insertedBy));
-    return view.edition.copies.flatMap(copy => (copy.carries ?? []).flatMap((statement) => {
+export const carriageProblems = (edition) => {
+    const carrying = copiesCarrying(edition, edition.versions.flatMap(insertedBy));
+    return edition.copies.flatMap(copy => (copy.carries ?? []).flatMap((statement) => {
         const version = idOf(statement);
         return [
             ...(carrying.has(copy.id) ? [{ copy: copy.id, version, problem: 'stated-beside-carriers' }] : []),
-            ...(view.version(version) ? [] : [{ copy: copy.id, version, problem: 'version-missing' }])
+            ...(versionIn(edition, version) ? [] : [{ copy: copy.id, version, problem: 'version-missing' }])
         ];
     }));
 };