linked-rolls 0.50.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/constraints.d.ts

@@ -2,7 +2,7 @@ import { EditionView } from "./EditionView.js";
 export type ConstraintProblem = {
     version: string;
     symbol: string;
-    problem: 'alignment-reference-missing' | 'before-reference-missing' | 'after-reference-missing' | 'placed-relative-to-itself' | 'placed-several-ways' | 'partner-missing' | 'paired-with-itself' | 'in-several-pairs' | 'pair-placed-on-both-sides' | 'type-not-on-the-bar' | 'carrier-on-another-track' | 'copies-disagree-on-the-paper';
+    problem: 'alignment-reference-missing' | 'before-reference-missing' | 'after-reference-missing' | 'placed-relative-to-itself' | 'placed-several-ways' | 'partner-missing' | 'paired-with-itself' | 'in-several-pairs' | 'pair-placed-on-both-sides' | 'type-not-on-the-bar' | 'carrier-on-another-track' | 'copies-disagree-on-the-paper' | 'strike-bites-nothing';
 };
 /**
  * Where the edition cannot hold as stated, version by version: a
@@ -10,7 +10,8 @@ export type ConstraintProblem = {
  * placed relative to itself or in several ways at once, one claimed by
  * several pairs, a pair whose members are both placed and so cannot
  * keep their distance and follow their references at once, an
- * expression the version's own bar cannot read, and a carrier sitting
- * on a track that does not say what its symbol says.
+ * expression the version's own bar cannot read, a carrier sitting on a
+ * track that does not say what its symbol says, and a strike that takes
+ * nothing out.
  */
 export declare const constraintProblems: (view: EditionView) => ConstraintProblem[];

package/lib/constraints.js

@@ -3,6 +3,7 @@ import { isCommand, pairsAmong, placementsOf } from "./Symbol.js";
 import { keyOf } from "./TrackerBar.js";
 import { trackerBarOf } from "./systems/index.js";
 import { barOf } from "./RollCopy.js";
+import { deletedBy, insertedBy } from "./Version.js";
 const missingReference = {
     alignedWith: 'alignment-reference-missing',
     before: 'before-reference-missing',
@@ -100,14 +101,37 @@ const carriersOffTheirMeaning = (view, version, commands) => {
 const paperDisagreed = (view, version) => view.speedScalesIn(version).length > 1
     ? [{ 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
+ * there itself, or the strike says nothing.
+ *
+ * It is the check for what happens when a symbol two versions shared is
+ * parted in two. The strike still names a symbol that exists, so
+ * nothing dangles and nothing looks wrong, but the reading it meant to
+ * reject has passed to the symbol standing in its place and comes back
+ * 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 reachable = new Set([
+        ...(parent ? view.snapshot(parent.id).map(symbol => symbol.id) : []),
+        ...insertedBy(version).map(symbol => symbol.id)
+    ]);
+    return deletedBy(version)
+        .filter(id => !reachable.has(id))
+        .map(id => ({ version: version.id, symbol: id, problem: 'strike-bites-nothing' }));
+};
 /**
  * Where the edition cannot hold as stated, version by version: a
  * placement or pairing reference absent from the version, a command
  * placed relative to itself or in several ways at once, one claimed by
  * several pairs, a pair whose members are both placed and so cannot
  * keep their distance and follow their references at once, an
- * expression the version's own bar cannot read, and a carrier sitting
- * on a track that does not say what its symbol says.
+ * expression the version's own bar cannot read, a carrier sitting on a
+ * 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);
@@ -116,6 +140,7 @@ export const constraintProblems = (view) => view.edition.versions.flatMap(versio
         ...problemsIn(version.id, commands),
         ...typesNotOnTheBar(version, snapshot),
         ...carriersOffTheirMeaning(view, version.id, commands),
-        ...paperDisagreed(view, version)
+        ...paperDisagreed(view, version),
+        ...strikesBitingNothing(view, version)
     ];
 });

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.50.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": {