linked-rolls 0.51.0 → 0.52.0

package/README.md

@@ -80,6 +80,16 @@ sigla off the stemma as it stands, so a label never outlives the
 arrangement it describes, and nothing should cite one without saying
 which state of the edition it belongs to.
 
+Handed an `EditionView`, which knows the copies as well, `siglaOf`
+lowercases the versions no copy's features carry at first hand, as
+editions mark a state nothing surviving shows: r3 stands to R3 as a
+reconstructed state stands to a witnessed one. A version reached only
+through the versions derived from it is lowercased, and so is one a
+copy does no more than state it carries, since a statement gives no
+readings. `attestedVersions` reports the same fact on its own. Handed
+the versions alone, `siglaOf` cannot tell and leaves every siglum in
+capitals.
+
 ## The tolerance a derivation was collated at
 
 `collationTolerance` on a derivation is the window two readings of one

package/lib/reservations.js

@@ -125,7 +125,7 @@ const witnessedAtFirstHand = (view, version) => {
     const carriers = witnessesOf(view, 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; it is attested only through the versions derived from it.'
+        note: 'No copy carries it at first hand; its text is a reconstruction from the versions derived from it.'
     } : undefined;
 };
 const versionChecks = [textStated, witnessedByFeatures, witnessedAtFirstHand];

package/lib/sigla.d.ts

@@ -1,19 +1,24 @@
 import { Edition } from './Edition.js';
+import { EditionView } from './EditionView.js';
 /**
- * The siglum of every version, as the stemma stands. The letter names the
- * reproducing system a version is coded for, the number counts the
- * generations within that system, and a number after a dot marks a branch
- * that leaves a generation. A version coded for another system than the
- * one it derives from starts that system's next number, since nothing in
- * that system precedes it.
+ * 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.
+ */
+export type Stemma = Pick<Edition, 'versions'> | EditionView;
+/**
+ * The siglum of every version, as the stemma stands: where it sits
+ * (`alongTheStemma`) and, given a view, 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
+ * no more than state that it carries it. Its siglum is lowercased, so
+ * that r3 stands to R3 as a reconstructed state stands to a witnessed
+ * one. Handed the versions alone, the sigla cannot tell and stay in
+ * capitals throughout.
  *
- * The main line runs through the child that has descendants of its own;
- * where several have, the one with the most, and where none has, the line
- * ends and the children hang off it as branches. So a siglum says where a
- * version sits in this stemma, and it is computed anew when the stemma
- * changes. Nothing should cite one without saying which state it belongs
- * to.
+ * 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 declare const siglaOf: (edition: Pick<Edition, 'versions'>) => ReadonlyMap<string, string>;
+export declare const siglaOf: (stemma: Stemma) => ReadonlyMap<string, string>;
 /** The siglum of one version as the stemma stands, or nothing where the edition holds no such version. */
-export declare const siglumOf: (edition: Pick<Edition, 'versions'>, versionId: string) => string | undefined;
+export declare const siglumOf: (stemma: Stemma, versionId: string) => string | undefined;

package/lib/sigla.js

@@ -2,6 +2,7 @@ import { idOf } from './Assumption.js';
 import { systemIdOf } from './TrackerBar.js';
 import { trackerBarOf } from './systems/index.js';
 import { principalDerivationOf } from './Version.js';
+import { attestedVersions } from './witnesses.js';
 /** The letter the versions of a system are labelled with. */
 const letters = new Map([
     ['welte-t100', 'R'],
@@ -27,13 +28,9 @@ const letterOf = (version) => {
  *
  * The main line runs through the child that has descendants of its own;
  * where several have, the one with the most, and where none has, the line
- * ends and the children hang off it as branches. So a siglum says where a
- * version sits in this stemma, and it is computed anew when the stemma
- * changes. Nothing should cite one without saying which state it belongs
- * to.
+ * ends and the children hang off it as branches.
  */
-export const siglaOf = (edition) => {
-    const versions = edition.versions;
+const alongTheStemma = (versions) => {
     const byId = new Map(versions.map(version => [version.id, version]));
     const parentOf = (version) => {
         const principal = principalDerivationOf(version);
@@ -94,5 +91,29 @@ export const siglaOf = (edition) => {
     }
     return sigla;
 };
+const isView = (stemma) => !('versions' 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
+ * the number still counts the generation.
+ */
+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.
+ *
+ * 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
+ * no more than state that it carries it. Its siglum is lowercased, so
+ * that r3 stands to R3 as a reconstructed state stands to a witnessed
+ * one. Handed the versions alone, the sigla cannot tell and stay in
+ * capitals throughout.
+ *
+ * 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))
+    : alongTheStemma(stemma.versions);
 /** The siglum of one version as the stemma stands, or nothing where the edition holds no such version. */
-export const siglumOf = (edition, versionId) => siglaOf(edition).get(versionId);
+export const siglumOf = (stemma, versionId) => siglaOf(stemma).get(versionId);

package/lib/witnesses.d.ts

@@ -19,6 +19,13 @@ export interface Witness {
     /** The belief a statement rests on, where it states one. */
     belief?: Belief;
 }
+/**
+ * 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 declare const attestedVersions: (view: EditionView) => 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

package/lib/witnesses.js

@@ -28,6 +28,13 @@ const carriersIn = (view) => {
             .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) => {
     const carrying = carriers.copiesOf.get(versionId) ?? [];
     const byCarriers = carrying.map((copy) => {

package/package.json

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