linked-rolls 0.32.0 → 0.33.0

package/lib/EditionView.d.ts

@@ -32,8 +32,8 @@ export declare class EditionView {
     getPath(anyId: string): Path | undefined;
     linksTo(anyId: string): Path[];
     travelUp(versionId: string, callback: (version: Readonly<Version>) => void): void;
-    /** The version and its ancestors, from the version up to the root. */
-    private lineageOf;
+    /** The version and its ancestors along the principal line, from the version up to the root. */
+    lineageOf(versionId: string): Readonly<Version>[];
     carriersOf(symbol: AnySymbol): Readonly<AnyFeature>[];
     /** The copy a feature sits on, a patch and everything it bears included. */
     copyOf(featureId: string): Readonly<RollCopy> | undefined;

package/lib/EditionView.js

@@ -143,7 +143,7 @@ export class EditionView {
             this.travelUp(idOf(principal), callback);
         }
     }
-    /** The version and its ancestors, from the version up to the root. */
+    /** The version and its ancestors along the principal line, from the version up to the root. */
     lineageOf(versionId) {
         const lineage = [];
         this.travelUp(versionId, version => lineage.push(version));

package/lib/witnesses.d.ts

@@ -7,6 +7,13 @@ export interface Witness {
     copy: string;
     /** Whether the copy's features carry what the version inserts, or the copy states that it carries the version. */
     by: WitnessBy;
+    /**
+     * The later version this copy reaches the version through, where its
+     * features carry what a version derived from this one inserts. It then
+     * attests the text only as that later version passed it on. A copy
+     * that bears witness at first hand names none.
+     */
+    through?: string;
     /** How certainly a statement is held. Carriage through features is no statement and holds none. */
     certainty?: Certainty;
     /** The belief a statement rests on, where it states one. */
@@ -18,8 +25,17 @@ export interface Witness {
  * it, with the certainty each statement is held with.
  *
  * What a version inherits is carried by nearly every copy of the roll, so
- * only what it inserts tells its witnesses apart. A version whose edits
- * are not stated is witnessed by statement alone.
+ * only what it inserts tells its witnesses apart from its ancestors'. Its
+ * insertions are in turn inherited downwards, and the copies of the
+ * versions derived from it carry them as well. Those bear witness to it
+ * only through the latest state they carry, which `through` names; a copy
+ * carrying nothing a later version inserts speaks for the version at first
+ * hand. A version no copy attests at first hand survives, as a lost state
+ * does, in what its descendants passed on.
+ *
+ * A statement is the editor's own about the version it names and is
+ * 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[];
 /**

package/lib/witnesses.js

@@ -7,25 +7,36 @@ const copiesCarrying = (view, symbols) => new Set(symbols
     const copy = view.copyOf(id);
     return copy ? [copy.id] : [];
 }));
-/**
- * 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
- * it, with the certainty each statement is held with.
- *
- * What a version inherits is carried by nearly every copy of the roll, so
- * only what it inserts tells its witnesses apart. A version whose edits
- * are not stated is witnessed by statement alone.
- */
-export const witnessesOf = (view, versionId) => {
-    const version = view.get(versionId);
-    if (!version)
-        return [];
+/** 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 byCarriers = view.edition.copies
+    const depth = view.lineageOf(version.id).length;
+    return view.edition.copies
         .filter(copy => carrying.has(copy.id))
-        .map((copy) => ({ copy: copy.id, by: 'carriers' }));
+        .map((copy) => ({ copy: copy.id, version: version.id, depth }));
+});
+const carriersIn = (view) => {
+    const carriages = carriagesIn(view);
+    return {
+        copiesOf: new Map(view.edition.versions.map(version => [
+            version.id,
+            carriages.filter(carriage => carriage.version === 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]))
+    };
+};
+const witnessesIn = (carriers, view, 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
-        .filter(copy => !carrying.has(copy.id))
+        .filter(copy => !carryingIt.has(copy.id))
         .flatMap(copy => (copy.carries ?? [])
         .filter(statement => idOf(statement) === versionId)
         .map((statement) => {
@@ -34,13 +45,35 @@ export const witnessesOf = (view, versionId) => {
     }));
     return [...byCarriers, ...byStatement];
 };
+/**
+ * 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
+ * it, with the certainty each statement is held with.
+ *
+ * What a version inherits is carried by nearly every copy of the roll, so
+ * only what it inserts tells its witnesses apart from its ancestors'. Its
+ * insertions are in turn inherited downwards, and the copies of the
+ * versions derived from it carry them as well. Those bear witness to it
+ * only through the latest state they carry, which `through` names; a copy
+ * carrying nothing a later version inserts speaks for the version at first
+ * hand. A version no copy attests at first hand survives, as a lost state
+ * does, in what its descendants passed on.
+ *
+ * A statement is the editor's own about the version it names and is
+ * 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.get(versionId) ? witnessesIn(carriersIn(view), view, versionId) : [];
 /**
  * The versions the copy bears witness to, each with how, in the order the
  * edition lists its versions.
  */
-export const versionsWitnessedBy = (view, copyId) => view.edition.versions.flatMap(version => witnessesOf(view, version.id)
-    .filter(witness => witness.copy === copyId)
-    .map(witness => ({ ...witness, version: version.id })));
+export const versionsWitnessedBy = (view, copyId) => {
+    const carriers = carriersIn(view);
+    return view.edition.versions.flatMap(version => witnessesIn(carriers, view, version.id)
+        .filter(witness => witness.copy === copyId)
+        .map(witness => ({ ...witness, version: version.id })));
+};
 /**
  * Where a copy's statement that it carries a version cannot stand: one
  * made although the copy's features carry symbols, which say by

package/package.json

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