linked-rolls 0.30.0 → 0.32.0

package/README.md

@@ -40,8 +40,24 @@ Files written by linked-rolls 0.1 load unchanged: `importJsonLd`
 recognises their shapes and brings them to the current format, in
 which versions and conditions carry a typology key beside their type,
 the keeper and the production metadata are nodes with a name and
-authority links, and the roll names its reproducing system. Exports
-are always in the current format.
+authority links, and the roll names its reproducing system. A date
+written as a value of its own is read as the day the event falls
+within. Exports are always in the current format.
+
+## How a date is stated
+
+A date is the time-span of the event rather than a value on it.
+`within` gives the day it falls within, and `after` and `before` give
+the bounds where nobody can give the day. A bound the edition does not
+know is left out, so `after` alone says "not before". In RDF the three
+become `P82 at some time within`, `P82a begin of the begin` and `P82b
+end of the end` on the `E52 Time-Span` the event has. `assignDate`,
+`notBefore` and `notAfter` build the three shapes, and `dateOf`,
+`earliestOf` and `latestOf` read them.
+
+Note that `before` and `after` mean something else on a perforation,
+where they order two onsets. The context defines them for a date
+within the date itself, so the two never meet.
 
 ## What a version derives from
 

package/lib/Assumption.d.ts

@@ -144,16 +144,20 @@ export type ObjectAssumption<O extends object> = Assumption & O;
  */
 export type ActorAssignment = ObjectAssumption<Person>;
 /**
- * A date value wrapped as an assumption, so that the date
- * can be annotated with a belief about its certainty and source.
+ * When something happened, as far as the edition can state it: the day
+ * it falls `within`, or the bounds it lies between. A bound nobody can
+ * give is left out, so `after` alone says "not before".
+ * @see crm:E52 Time-Span
  */
-export type DateAssignment = ValueAssumption<Date> & {
-    /**
-     * The datatype of the value. Written on export so that
-     * RDF reads the value as a date rather than a string.
-     */
-    '@type'?: 'xsd:date';
-};
+export type DateAssignment = Assumption & ({
+    within: Date;
+} | {
+    after: Date;
+    before?: Date;
+} | {
+    before: Date;
+    after?: Date;
+});
 export declare function valueOf<ValueT>(assumption: ValueAssumption<ValueT>): ValueT;
 export declare function valuesOf<ValueT>(assumptions: ValueAssumption<ValueT>[]): ValueT[];
 export declare function idOf(assumption: ReferenceAssumption): string;
@@ -161,3 +165,15 @@ export declare function idsOf(assumptions: ReferenceAssumption[]): string[];
 export declare function assignValue<ValueT>(value: ValueT): ValueAssumption<ValueT>;
 export declare function assignReference(id: string): ReferenceAssumption;
 export declare function assignObject<O extends object>(obj: O): ObjectAssumption<O>;
+/** A date the edition states: the day the event falls within. */
+export declare const assignDate: (within: Date) => DateAssignment;
+/** A date the edition can only bound from below, as in "not before 1924". */
+export declare const notBefore: (after: Date) => DateAssignment;
+/** A date the edition can only bound from above. */
+export declare const notAfter: (before: Date) => DateAssignment;
+/** The day the event falls within, where the edition states one. */
+export declare const dateOf: (assignment: DateAssignment) => Date | undefined;
+/** The earliest the event can have happened, as far as the edition states it. */
+export declare const earliestOf: (assignment: DateAssignment) => Date | undefined;
+/** The latest the event can have happened, as far as the edition states it. */
+export declare const latestOf: (assignment: DateAssignment) => Date | undefined;

package/lib/Assumption.js

@@ -41,3 +41,15 @@ export function assignObject(obj) {
         ...obj
     };
 }
+/** A date the edition states: the day the event falls within. */
+export const assignDate = (within) => ({ within });
+/** A date the edition can only bound from below, as in "not before 1924". */
+export const notBefore = (after) => ({ after });
+/** A date the edition can only bound from above. */
+export const notAfter = (before) => ({ before });
+/** The day the event falls within, where the edition states one. */
+export const dateOf = (assignment) => 'within' in assignment ? assignment.within : undefined;
+/** The earliest the event can have happened, as far as the edition states it. */
+export const earliestOf = (assignment) => 'within' in assignment ? assignment.within : assignment.after;
+/** The latest the event can have happened, as far as the edition states it. */
+export const latestOf = (assignment) => 'within' in assignment ? assignment.within : assignment.before;

package/lib/Edition.d.ts

@@ -68,7 +68,7 @@ export interface RecordingEvent {
      * The recording date of the roll. This is a date
      * assignment so that we can state e.g. the catalogue
      * or the roll label which indicates the date of the recording.
-     * @see dcterms:date
+     * @see crm:P4 has time-span
      */
     date: DateAssignment;
     /**

package/lib/FeatureSource.d.ts

@@ -98,8 +98,7 @@ export interface FeatureSource extends WithNote {
     instrument?: ObjectAssumption<Instrument>;
     /**
      * When the capture took place.
-     * @format date
-     * @see dcterms:date
+     * @see crm:P4 has time-span
      */
     date?: DateAssignment;
 }

package/lib/RollCopy.d.ts

@@ -90,7 +90,7 @@ export interface ProductionEvent {
     paper?: Concept;
     /**
      * The date of production, if known.
-     * @see dcterms:date
+     * @see crm:P4 has time-span
      */
     date?: DateAssignment;
     /**
@@ -124,7 +124,7 @@ export type Modification = Partial<{
     actor: ActorAssignment;
     /**
      * When the modification took place.
-     * @see dcterms:date
+     * @see crm:P4 has time-span
      */
     date: DateAssignment;
 }> & ({

package/lib/Version.d.ts

@@ -47,7 +47,7 @@ export interface VersionCreation {
     actor?: ActorAssignment;
     /**
      * When it took place.
-     * @see dcterms:date
+     * @see crm:P4 has time-span
      */
     date?: DateAssignment;
     /**
@@ -59,21 +59,21 @@ export interface VersionCreation {
     procedure?: Concept;
 }
 /**
- * A version is defined by the sum of edits applied
- * to the version it is based on. For simple identification,
- * a siglum is given to each version.
+ * A version is defined by the sum of edits applied to the version it is
+ * based on. What it is called is not stored with it: `siglaOf` reads the
+ * sigla off the stemma, so that a label never outlives the arrangement
+ * it describes.
  * @see lrmoo:F2 Expression
  */
 export interface Version extends WithId, WithType<'Version'> {
     /**
-     * A short siglum to identify the version, e.g. "A" or "B2". A siglum
-     * is given once and not changed: its letter names the line the version
-     * was first recognised in, its number counts the versions admitted to
-     * that line. Where later work places the version elsewhere in the
-     * stemma, `basedOn` changes and the siglum stays.
+     * A label a document carries from before the sigla were computed.
+     * Nothing should write one here and nothing should show one: what a
+     * version is called comes from `siglaOf`.
+     * @deprecated
      * @see reo:siglum
      */
-    siglum: string;
+    siglum?: string;
     /**
      * The reproducing system this version is coded for. One roll was
      * often issued for several of them, and a version is a reading in

package/lib/asJsonLd.js

@@ -35,9 +35,6 @@ const asJsonLdEntity = (obj) => {
             result[key] = value;
         }
     }
-    if ('@value' in obj && obj['@value'] instanceof Date) {
-        result['@type'] = 'xsd:date';
-    }
     return result;
 };
 /**

package/lib/editionOps.d.ts

@@ -21,7 +21,7 @@ export type EditionOp = (draft: Draft<Edition>) => void;
  * version is a reading in that system's words, so it is coded for the
  * system the copy was cut for.
  */
-export declare const createVersion: (siglum: string, copy: RollCopy) => EditionOp;
+export declare const createVersion: (copy: RollCopy) => EditionOp;
 /**
  * Puts the copy into the edition without a version of its own, as for a
  * copy whose features are not read into symbols: one known only from a

package/lib/editionOps.js

@@ -75,13 +75,12 @@ const dropInsertions = (version, symbolIds) => {
  * version is a reading in that system's words, so it is coded for the
  * system the copy was cut for.
  */
-export const createVersion = (siglum, copy) => draft => {
+export const createVersion = (copy) => draft => {
     const bar = barOf(copy);
     draft.copies.push(copy);
     draft.versions.push({
         type: 'Version',
         id: v4(),
-        siglum,
         system: systemOf(bar),
         edits: asSymbols(copy.features, bar).map(insertion),
         motivations: []
@@ -637,19 +636,6 @@ export const removeVersion = (view, versionId) => {
 };
 /** Takes the symbols out of the version's own insertions, and the edits that had nothing else. */
 export const removeSymbols = (versionId, symbolIds) => onVersion(versionId, version => dropInsertions(version, new Set(symbolIds)));
-/**
- * The siglum for a version derived from this one: the line the siglum
- * names, and the next number free in it. A number already given stays
- * given, whatever the stemma does later.
- */
-const nextInLine = (versions, siglum) => {
-    const [line] = siglum.match(/^\D*/) ?? [siglum];
-    const numbers = versions.flatMap(other => {
-        const match = other.siglum.match(/^(\D*)(\d*)$/);
-        return match && match[1] === line ? [Number(match[2] || 1)] : [];
-    });
-    return `${line}${Math.max(1, ...numbers) + 1}`;
-};
 /** Moves the edits into a new version based on this one. */
 export const deriveVersion = (versionId, editIds) => onVersion(versionId, (version, draft) => {
     const chosen = new Set(editIds);
@@ -659,7 +645,6 @@ export const deriveVersion = (versionId, editIds) => onVersion(versionId, (versi
     draft.versions.push({
         type: 'Version',
         id: v4(),
-        siglum: nextInLine(draft.versions, version.siglum),
         system: stateOf(version).system,
         basedOn: [assignReference(versionId)],
         edits: moved,

package/lib/importJsonLd.js

@@ -1,8 +1,5 @@
 import { migrate } from "./migrate";
-const isDate = (value) => {
-    const datePattern = /^\d{4}-\d{1,2}-\d{1,2}$/;
-    return datePattern.test(value);
-};
+import { isDateString } from "./utils";
 export const importDate = (str) => {
     const [y, m, d] = str.split('-').map(s => parseInt(s, 10));
     if ([y, m, d].some(n => isNaN(n))) {
@@ -13,7 +10,7 @@ export const importDate = (str) => {
 /** A value as the edition holds it: a date read, an entity converted, anything else as it stands. */
 const fromJsonLdValue = (value) => {
     if (typeof value === 'string')
-        return isDate(value) ? importDate(value) : value;
+        return isDateString(value) ? importDate(value) : value;
     if (Array.isArray(value))
         return value.map(fromJsonLdValue);
     if (value !== null && typeof value === 'object')

package/lib/index.d.ts

@@ -28,6 +28,8 @@ export * from './validate';
 export * from './constraints';
 export * from './substitution';
 export * from './context';
+export * from './sigla';
+export * from './notes';
 export * from './asJsonLd';
 export * from './importJsonLd';
 export * from './migrate';

package/lib/index.js

@@ -28,6 +28,8 @@ export * from './validate';
 export * from './constraints';
 export * from './substitution';
 export * from './context';
+export * from './sigla';
+export * from './notes';
 export * from './asJsonLd';
 export * from './importJsonLd';
 export * from './migrate';

package/lib/migrate.js

@@ -3,6 +3,7 @@ import { rollConditions } from "./RollCopy";
 import { systemIdIn, systemOf, translationBetween } from "./TrackerBar";
 import { trackerBars } from "./systems";
 import { welteT100 } from "./systems/welteT100/bar";
+import { isDateString } from "./utils";
 const retiredVersionTypes = new Set(['edition', 'unicum']);
 const conditionTypeValues = new Set([...rollConditions, ...Object.values(conditions).flat()]);
 const renamedKeys = {
@@ -94,8 +95,19 @@ const withoutEmptyKeeper = (node) => {
     const { keeper: _unnamed, ...rest } = node;
     return rest;
 };
+/**
+ * A date was a value of its own before it was the time-span the event
+ * falls within. The datatype goes with it: the context now types each
+ * bound, and a `@type` left on the node would read as a class.
+ */
+const withTimeSpanDates = (node) => {
+    if (!isDateString(node['@value']))
+        return node;
+    const { '@value': within, '@type': _typed, ...rest } = node;
+    return { ...rest, within };
+};
 const migrateNode = (node) => [withRenamedKeys, withTypology, withoutVersionType, withReferences, withKeeper, withoutEmptyKeeper, withProductionNodes, withScale,
-    withDerivationList, withReadingKind]
+    withDerivationList, withReadingKind, withTimeSpanDates]
     .reduce((result, step) => step(result), node);
 /** The items each walked, or the very same list where the walk changed none. */
 const walked = (items) => {

package/lib/notes.d.ts

@@ -0,0 +1,17 @@
+export type NotePart = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'reference';
+    id: string;
+};
+/** The note in the pieces it is shown in: stretches of text and what they refer to. */
+export declare const partsOfNote: (note: string) => NotePart[];
+/** The ids a note refers to, in the order it names them. */
+export declare const referencesInNote: (note: string) => string[];
+/**
+ * The note as it reads, with every reference resolved to the name the
+ * edition gives that entity. A reference nothing answers to keeps its id,
+ * so that the gap is visible rather than silent.
+ */
+export declare const resolveNote: (note: string, nameOf: (id: string) => string | undefined) => string;

package/lib/notes.js

@@ -0,0 +1,32 @@
+/**
+ * A note refers to a version or a copy instead of naming it, so that a
+ * label the stemma decides is never written into the prose. A reference
+ * reads `{{<id>}}`, where the id is the entity's, and is resolved when
+ * the note is shown.
+ */
+const reference = /\{\{\s*([^{}\s]+)\s*\}\}/g;
+/** The note in the pieces it is shown in: stretches of text and what they refer to. */
+export const partsOfNote = (note) => {
+    const parts = [];
+    let read = 0;
+    for (const match of note.matchAll(reference)) {
+        const at = match.index ?? 0;
+        if (at > read)
+            parts.push({ type: 'text', text: note.slice(read, at) });
+        parts.push({ type: 'reference', id: match[1] });
+        read = at + match[0].length;
+    }
+    if (read < note.length)
+        parts.push({ type: 'text', text: note.slice(read) });
+    return parts;
+};
+/** The ids a note refers to, in the order it names them. */
+export const referencesInNote = (note) => partsOfNote(note).flatMap(part => part.type === 'reference' ? [part.id] : []);
+/**
+ * The note as it reads, with every reference resolved to the name the
+ * edition gives that entity. A reference nothing answers to keeps its id,
+ * so that the gap is visible rather than silent.
+ */
+export const resolveNote = (note, nameOf) => partsOfNote(note)
+    .map(part => part.type === 'text' ? part.text : nameOf(part.id) ?? part.id)
+    .join('');

package/lib/schema.json

@@ -256,43 +256,111 @@
             "ontology": "crm:E55 Type"
         },
         "DateAssignment": {
-            "description": "A date value wrapped as an assumption, so that the date can be annotated with a belief about its certainty and source.",
-            "properties": {
-                "@annotation": {
-                    "description": "An optional annotation expressing a belief about this assumption. Uses the JSON-LD-star `@annotation` mechanism to attach epistemic metadata (certainty and reasons) to any triple.",
+            "anyOf": [
+                {
                     "properties": {
-                        "belief": {
-                            "$ref": "#/definitions/Belief",
-                            "description": "The belief held about the annotated statement.",
-                            "ontology": "crminf:J4i is subject of"
+                        "@annotation": {
+                            "description": "An optional annotation expressing a belief about this assumption. Uses the JSON-LD-star `@annotation` mechanism to attach epistemic metadata (certainty and reasons) to any triple.",
+                            "properties": {
+                                "belief": {
+                                    "$ref": "#/definitions/Belief",
+                                    "description": "The belief held about the annotated statement.",
+                                    "ontology": "crminf:J4i is subject of"
+                                },
+                                "@id": {
+                                    "description": "A unique identifier for this object.",
+                                    "type": "string"
+                                }
+                            },
+                            "required": [
+                                "belief",
+                                "@id"
+                            ],
+                            "type": "object"
                         },
-                        "@id": {
-                            "description": "A unique identifier for this object.",
+                        "within": {
+                            "format": "date",
                             "type": "string"
                         }
                     },
                     "required": [
-                        "belief",
-                        "@id"
+                        "within"
                     ],
                     "type": "object"
                 },
-                "@type": {
-                    "const": "xsd:date",
-                    "description": "The datatype of the value. Written on export so that RDF reads the value as a date rather than a string.",
-                    "type": "string",
-                    "ontology": "rdf:type"
+                {
+                    "properties": {
+                        "@annotation": {
+                            "description": "An optional annotation expressing a belief about this assumption. Uses the JSON-LD-star `@annotation` mechanism to attach epistemic metadata (certainty and reasons) to any triple.",
+                            "properties": {
+                                "belief": {
+                                    "$ref": "#/definitions/Belief",
+                                    "description": "The belief held about the annotated statement.",
+                                    "ontology": "crminf:J4i is subject of"
+                                },
+                                "@id": {
+                                    "description": "A unique identifier for this object.",
+                                    "type": "string"
+                                }
+                            },
+                            "required": [
+                                "belief",
+                                "@id"
+                            ],
+                            "type": "object"
+                        },
+                        "after": {
+                            "format": "date",
+                            "type": "string"
+                        },
+                        "before": {
+                            "format": "date",
+                            "type": "string"
+                        }
+                    },
+                    "required": [
+                        "after"
+                    ],
+                    "type": "object"
                 },
-                "@value": {
-                    "description": "The assumed value.",
-                    "format": "date",
-                    "type": "string"
+                {
+                    "properties": {
+                        "@annotation": {
+                            "description": "An optional annotation expressing a belief about this assumption. Uses the JSON-LD-star `@annotation` mechanism to attach epistemic metadata (certainty and reasons) to any triple.",
+                            "properties": {
+                                "belief": {
+                                    "$ref": "#/definitions/Belief",
+                                    "description": "The belief held about the annotated statement.",
+                                    "ontology": "crminf:J4i is subject of"
+                                },
+                                "@id": {
+                                    "description": "A unique identifier for this object.",
+                                    "type": "string"
+                                }
+                            },
+                            "required": [
+                                "belief",
+                                "@id"
+                            ],
+                            "type": "object"
+                        },
+                        "after": {
+                            "format": "date",
+                            "type": "string"
+                        },
+                        "before": {
+                            "format": "date",
+                            "type": "string"
+                        }
+                    },
+                    "required": [
+                        "before"
+                    ],
+                    "type": "object"
                 }
-            },
-            "required": [
-                "@value"
             ],
-            "type": "object"
+            "description": "When something happened, as far as the edition can state it: the day it falls `within`, or the bounds it lies between. A bound nobody can give is left out, so `after` alone says \"not before\".",
+            "ontology": "crm:E52 Time-Span"
         },
         "Derivation": {
             "description": "A derivation names the version another one was derived from, together with the tolerance the two were collated at. How precisely the copies put a symbol depends on what they are and on how their features were obtained, so the tolerance can differ from derivation to derivation.",
@@ -638,8 +706,7 @@
                 "date": {
                     "$ref": "#/definitions/DateAssignment",
                     "description": "When the capture took place.",
-                    "format": "date",
-                    "ontology": "dcterms:date"
+                    "ontology": "crm:P4 has time-span"
                 },
                 "device": {
                     "$ref": "#/definitions/Concept",
@@ -1074,7 +1141,7 @@
                         "date": {
                             "$ref": "#/definitions/DateAssignment",
                             "description": "When the modification took place.",
-                            "ontology": "dcterms:date"
+                            "ontology": "crm:P4 has time-span"
                         },
                         "purpose": {
                             "enum": [
@@ -1113,7 +1180,7 @@
                         "date": {
                             "$ref": "#/definitions/DateAssignment",
                             "description": "When the modification took place.",
-                            "ontology": "dcterms:date"
+                            "ontology": "crm:P4 has time-span"
                         },
                         "purpose": {
                             "const": "delabeling",
@@ -1951,7 +2018,7 @@
                 "date": {
                     "$ref": "#/definitions/DateAssignment",
                     "description": "The date of production, if known.",
-                    "ontology": "dcterms:date"
+                    "ontology": "crm:P4 has time-span"
                 },
                 "paper": {
                     "$ref": "#/definitions/Concept",
@@ -2001,7 +2068,7 @@
                 "date": {
                     "$ref": "#/definitions/DateAssignment",
                     "description": "The recording date of the roll. This is a date assignment so that we can state e.g. the catalogue or the roll label which indicates the date of the recording.",
-                    "ontology": "dcterms:date"
+                    "ontology": "crm:P4 has time-span"
                 },
                 "place": {
                     "$ref": "#/definitions/Place",
@@ -2415,7 +2482,7 @@
             "type": "object"
         },
         "Version": {
-            "description": "A version is defined by the sum of edits applied to the version it is based on. For simple identification, a siglum is given to each version.",
+            "description": "A version is defined by the sum of edits applied to the version it is based on. What it is called is not stored with it: `siglaOf` reads the sigla off the stemma, so that a label never outlives the arrangement it describes.",
             "properties": {
                 "basedOn": {
                     "description": "The versions this one is held to derive from, each under the belief it rests on. The text is read against the principal one (`principalDerivationOf`); the others stand as hypotheses, such as a contamination. A version that names none represents the mother roll.",
@@ -2446,7 +2513,8 @@
                     "type": "array"
                 },
                 "siglum": {
-                    "description": "A short siglum to identify the version, e.g. \"A\" or \"B2\". A siglum is given once and not changed: its letter names the line the version was first recognised in, its number counts the versions admitted to that line. Where later work places the version elsewhere in the stemma, `basedOn` changes and the siglum stays.",
+                    "deprecated": true,
+                    "description": "A label a document carries from before the sigla were computed. Nothing should write one here and nothing should show one: what a version is called comes from `siglaOf`.",
                     "type": "string",
                     "ontology": "reo:siglum"
                 },
@@ -2469,7 +2537,6 @@
             "required": [
                 "@id",
                 "motivations",
-                "siglum",
                 "system",
                 "@type"
             ],
@@ -2487,7 +2554,7 @@
                 "date": {
                     "$ref": "#/definitions/DateAssignment",
                     "description": "When it took place.",
-                    "ontology": "dcterms:date"
+                    "ontology": "crm:P4 has time-span"
                 },
                 "procedure": {
                     "$ref": "#/definitions/Concept",

package/lib/sigla.d.ts

@@ -0,0 +1,19 @@
+import { Edition } from './Edition';
+/**
+ * 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.
+ *
+ * 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.
+ */
+export declare const siglaOf: (edition: Pick<Edition, 'versions'>) => 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;

package/lib/sigla.js

@@ -0,0 +1,98 @@
+import { idOf } from './Assumption';
+import { systemIdOf } from './TrackerBar';
+import { trackerBarOf } from './systems';
+import { principalDerivationOf } from './Version';
+/** The letter the versions of a system are labelled with. */
+const letters = new Map([
+    ['welte-t100', 'R'],
+    ['welte-green', 'G'],
+    ['welte-licensee', 'L']
+]);
+/** The letter of a version's system, from the systems the library knows, else from the system's name. */
+const letterOf = (version) => {
+    const bar = trackerBarOf(version.system);
+    const known = bar && letters.get(bar.id);
+    if (known)
+        return known;
+    const name = (bar?.name ?? version.system?.name ?? '').replace(/[^A-Za-z]/g, '');
+    return (name.charAt(0) || 'X').toUpperCase();
+};
+/**
+ * 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.
+ *
+ * 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.
+ */
+export const siglaOf = (edition) => {
+    const versions = edition.versions;
+    const byId = new Map(versions.map(version => [version.id, version]));
+    const parentOf = (version) => {
+        const principal = principalDerivationOf(version);
+        const parent = principal && byId.get(idOf(principal));
+        return parent === version ? undefined : parent;
+    };
+    const children = new Map();
+    const roots = [];
+    for (const version of versions) {
+        const parent = parentOf(version);
+        if (!parent)
+            roots.push(version);
+        else
+            children.set(parent.id, [...(children.get(parent.id) ?? []), version]);
+    }
+    const counted = new Map();
+    const descendants = (version) => {
+        const known = counted.get(version.id);
+        if (known !== undefined)
+            return known;
+        counted.set(version.id, 0);
+        const count = (children.get(version.id) ?? []).reduce((sum, child) => sum + 1 + descendants(child), 0);
+        counted.set(version.id, count);
+        return count;
+    };
+    /** The child the main line runs through: the one of the same system carrying most of the stemma. */
+    const mainChildOf = (version) => (children.get(version.id) ?? [])
+        .filter(child => systemIdOf(child.system) === systemIdOf(version.system))
+        .sort((one, other) => descendants(other) - descendants(one))[0];
+    const sigla = new Map();
+    const taken = new Map();
+    const branches = new Map();
+    const nextIn = (letter) => {
+        const number = (taken.get(letter) ?? 0) + 1;
+        taken.set(letter, number);
+        return `${letter}${number}`;
+    };
+    const branchOf = (version) => {
+        const number = (branches.get(version.id) ?? 0) + 1;
+        branches.set(version.id, number);
+        return `${sigla.get(version.id)}.${number}`;
+    };
+    const queue = roots.map(version => {
+        sigla.set(version.id, nextIn(letterOf(version)));
+        return { version, onMainLine: true };
+    });
+    while (queue.length > 0) {
+        const { version, onMainLine } = queue.shift();
+        const main = mainChildOf(version);
+        for (const child of children.get(version.id) ?? []) {
+            if (sigla.has(child.id))
+                continue;
+            const entersSystem = systemIdOf(child.system) !== systemIdOf(version.system);
+            const continuesLine = onMainLine && child === main;
+            sigla.set(child.id, entersSystem || continuesLine ? nextIn(letterOf(child)) : branchOf(version));
+            queue.push({ version: child, onMainLine: continuesLine });
+        }
+    }
+    return sigla;
+};
+/** 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);

package/lib/spec/context.json

@@ -103,8 +103,21 @@
         },
         "place": "crm:P7_took_place_at",
         "date": {
-            "@id": "dcterms:date",
-            "@type": "xsd:date"
+            "@id": "crm:P4_has_time-span",
+            "@context": {
+                "within": {
+                    "@id": "crm:P82_at_some_time_within",
+                    "@type": "xsd:date"
+                },
+                "after": {
+                    "@id": "crm:P82a_begin_of_the_begin",
+                    "@type": "xsd:date"
+                },
+                "before": {
+                    "@id": "crm:P82b_end_of_the_end",
+                    "@type": "xsd:date"
+                }
+            }
         },
         "created": "lrmoo:R17_created",
         "copies": "reo:witness",
@@ -148,7 +161,11 @@
                 "value": "crm:P90_has_value",
                 "measuredBy": "crmdig:L23_used_software_or_firmware",
                 "software": "rdfs:label",
-                "version": "owl:versionInfo"
+                "version": "owl:versionInfo",
+                "date": {
+                    "@id": "dcterms:date",
+                    "@type": "xsd:date"
+                }
             }
         },
         "production": {

package/lib/systems/welteT98/system.d.ts

@@ -18,11 +18,19 @@ export type { WelteT98Instrument, WelteT98InstrumentName } from "welte-mignon-em
  * difference between the two, in the printed ordinate both scales share, is how
  * far the transfer of a red reading onto the green mechanism succeeded.
  *
- * Neither has been fitted yet, so both groups are empty and what a playback runs
- * on until then is the third group: the **unfitted** starting values, arithmetic
- * from Welte's regulation controls and the T-100 consensus with no green roll
- * behind any of it. A curve produced with them says so in its own `instrument`
- * field, and nothing should be published from them.
+ * Both are now fitted, on `welte-mignon-emulator` 1.1.0: five genuine
+ * instruments, one per lined green roll that could be read, a consensus across
+ * them, and the derived instrument for the one recording issued on both scales.
+ * The **unfitted** starting values remain as a third group, arithmetic from
+ * Welte's regulation controls with no green roll behind any of it, and a curve
+ * produced with them says so in its own `instrument` field.
+ *
+ * **Prefer a roll's own instrument where the roll is one of the five.** The
+ * green instruments disagree with one another far more than the red ones do:
+ * the consensus is held out at 0.121 on the bass where the per-roll instruments
+ * are 0.029 to 0.066, because a shared mechanism describes none of them well.
+ * That spread is a property of the instruments rather than of the fit, and
+ * Gottschewski's finding that they were out of regulation is visible in it.
  */
 export declare const instruments: {
     genuine: Readonly<Partial<Record<"consensus" | import("welte-mignon-emulator/t98").GenuineRoll, import("welte-mignon-emulator/t98").WelteT98Instrument>>>;
@@ -112,8 +120,9 @@ export declare const secondsAt: (spool: Spool, place: Millimeters) => Seconds;
  * permanently open bore 100, and a long perforation on the bass sforzando-piano
  * line sends the roll back.
  *
- * Its constants are **not fitted**. `instruments.genuine` and
- * `instruments.derived` are empty until their fits run, and what a playback runs
- * on until then is the unfitted starting values, which every curve says.
+ * Its constants are fitted to the drawn nuance lines of five green rolls, and a
+ * playback runs on the consensus across them unless the caller names another
+ * instrument. Where the roll being played is one of the five, its own instrument
+ * is the better choice and `instruments.genuine` carries it.
  */
 export declare const welteT98System: ReproducingSystem<WelteT98Options>;

package/lib/systems/welteT98/system.js

@@ -17,11 +17,19 @@ import { defaultVelocityMap, velocityOf } from "../velocity";
  * difference between the two, in the printed ordinate both scales share, is how
  * far the transfer of a red reading onto the green mechanism succeeded.
  *
- * Neither has been fitted yet, so both groups are empty and what a playback runs
- * on until then is the third group: the **unfitted** starting values, arithmetic
- * from Welte's regulation controls and the T-100 consensus with no green roll
- * behind any of it. A curve produced with them says so in its own `instrument`
- * field, and nothing should be published from them.
+ * Both are now fitted, on `welte-mignon-emulator` 1.1.0: five genuine
+ * instruments, one per lined green roll that could be read, a consensus across
+ * them, and the derived instrument for the one recording issued on both scales.
+ * The **unfitted** starting values remain as a third group, arithmetic from
+ * Welte's regulation controls with no green roll behind any of it, and a curve
+ * produced with them says so in its own `instrument` field.
+ *
+ * **Prefer a roll's own instrument where the roll is one of the five.** The
+ * green instruments disagree with one another far more than the red ones do:
+ * the consensus is held out at 0.121 on the bass where the per-roll instruments
+ * are 0.029 to 0.066, because a shared mechanism describes none of them well.
+ * That spread is a property of the instruments rather than of the fit, and
+ * Gottschewski's finding that they were out of regulation is visible in it.
  */
 export const instruments = { genuine: GENUINE, derived: DERIVED, unfitted: { 'starting-values': STARTING_VALUES } };
 export const instrumentNames = [
@@ -51,8 +59,8 @@ export const pedalPresets = {
 export const pedalPresetOf = (pedals) => Object.keys(pedalPresets).find(name => sameParameters(pedalPresets[name], pedals));
 export const defaultWelteT98Options = {
     spool: WELTE_T98_SPOOL,
-    nuance: nuanceOf(STARTING_VALUES),
-    instrument: { unfitted: 'starting-values' },
+    nuance: nuanceOf(GENUINE.consensus),
+    instrument: { genuine: 'consensus' },
     pedals: pedalPresets.damping,
     velocity: defaultVelocityMap,
     pedalMode: 'continuous',
@@ -233,9 +241,10 @@ const perform = (events, options, roll) => {
  * permanently open bore 100, and a long perforation on the bass sforzando-piano
  * line sends the roll back.
  *
- * Its constants are **not fitted**. `instruments.genuine` and
- * `instruments.derived` are empty until their fits run, and what a playback runs
- * on until then is the unfitted starting values, which every curve says.
+ * Its constants are fitted to the drawn nuance lines of five green rolls, and a
+ * playback runs on the consensus across them unless the caller names another
+ * instrument. Where the roll being played is one of the five, its own instrument
+ * is the better choice and `instruments.genuine` carries it.
  */
 export const welteT98System = {
     name: 'Welte-Mignon T98',

package/lib/utils.d.ts

@@ -12,6 +12,8 @@ export type WithId = {
      */
     readonly id: string;
 };
+/** Whether a value is a date as the format writes one, `YYYY-MM-DD`. */
+export declare const isDateString: (value: unknown) => value is string;
 export type WithNote = {
     /**
      * A free-text note providing additional context.

package/lib/utils.js

@@ -1 +1,2 @@
-export {};
+/** Whether a value is a date as the format writes one, `YYYY-MM-DD`. */
+export const isDateString = (value) => typeof value === 'string' && /^\d{4}-\d{1,2}-\d{1,2}$/.test(value);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linked-rolls",
-  "version": "0.30.0",
+  "version": "0.32.0",
   "description": "Digital editions of piano rolls: import, collation, editorial assumptions, JSON-LD export, and emulation through a reproducing system",
   "license": "MIT",
   "repository": {
@@ -51,10 +51,10 @@
     "typescript": "^7.0.2",
     "vite": "^8.2.2",
     "vitest": "^5.0.0",
-    "welte-mignon-emulator": "^1.0.0"
+    "welte-mignon-emulator": "^1.1.0"
   },
   "peerDependencies": {
-    "welte-mignon-emulator": "^1.0.0"
+    "welte-mignon-emulator": "^1.1.0"
   },
   "peerDependenciesMeta": {
     "welte-mignon-emulator": {