linked-rolls 0.51.0 → 0.53.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/Emulation.js

@@ -2,15 +2,16 @@ import { MIDIControlEvents } from "midifile-ts";
 import { idOf } from "./Assumption.js";
 import { isCommand, pairsAmong, placementsOf } from "./Symbol.js";
 import { add, mean, mm, seconds, subtract } from "./Quantity.js";
+import { punchDiameterOf } from "./RollCopy.js";
 /** The punch diameter the edition's copies report, where any of them does. */
-const punchDiameterOf = (view) => {
+const meanPunchDiameterOf = (view) => {
     const measured = view.edition.copies
-        .map(copy => copy.measurements.punchDiameter?.value)
-        .filter((value) => value !== undefined && value > 0);
+        .map(punchDiameterOf)
+        .filter(value => value !== undefined);
     return measured.length > 0 ? mean(measured) : undefined;
 };
 const propertiesOf = (view, version) => ({
-    punchDiameter: punchDiameterOf(view),
+    punchDiameter: meanPunchDiameterOf(view),
     tempo: view.edition.tempoAdjustment,
     toOwnPaper: view.toOwnPaperOf(version)
 });
@@ -141,7 +142,7 @@ export class Emulation {
      * diameter, or a millimetre, where no copy agrees with a statement.
      */
     applyConstraints(view) {
-        const gap = punchDiameterOf(view) ?? mm(1);
+        const gap = meanPunchDiameterOf(view) ?? mm(1);
         const offsets = (follower, reference) => offsetsBetween(view, follower, reference);
         displacementsOf(this.negotiatedEvents, offsets, gap).forEach((distance, event) => {
             event.horizontal.from = add(event.horizontal.from, distance);

package/lib/Perforator.d.ts

@@ -0,0 +1,89 @@
+import { ObjectAssumption } from "./Assumption.js";
+import { ConditionState } from "./ConditionState.js";
+import { Measure, Millimeters } from "./Quantity.js";
+import { WithId } from "./utils.js";
+/**
+ * The pitch in the engineering sense: the distance along the roll from
+ * one punch of a chain to the next, which is the slot one firing cut
+ * together with the bridge of paper left before the next. It is taken
+ * on held notes, whose chains repeat it, as the median over them. It
+ * runs along the roll, and is another thing than the hole separation,
+ * which is the distance across the roll from one track to the next.
+ * @see crm:E54 Dimension
+ */
+export interface ChainPitch extends Measure<'mm'> {
+    /**
+     * The length along the roll of one slot of a chain.
+     * @see reo:slot
+     */
+    slot?: Millimeters;
+    /**
+     * The paper left standing between two slots of a chain. Slot and
+     * bridge are medians of their own and need not add up to the pitch.
+     * @see reo:bridge
+     */
+    bridge?: Millimeters;
+    /**
+     * How many pitches the median was taken over.
+     * @see reo:sampleSize
+     */
+    n?: number;
+}
+/**
+ * The step by which the perforator moved the paper on, read as the
+ * period the lengths of the slots keep: a slot is the punch together
+ * with a whole number of steps, so its lengths fall on a comb of this
+ * spacing.
+ * @see crm:E54 Dimension
+ */
+export interface Advance extends Measure<'mm'> {
+    /**
+     * How closely the lengths keep the period, from 0 where they scatter
+     * to 1 where every one falls on the comb: the mean resultant length
+     * of the lengths folded onto it. A period found weakly is the result
+     * of a search all the same; the belief it is stated with says how far
+     * it is held to be the machine's step.
+     * @see reo:strength
+     */
+    strength?: number;
+    /**
+     * How many slot lengths were folded.
+     * @see reo:sampleSize
+     */
+    n?: number;
+}
+/**
+ * How the perforator was set when it punched the copy, as far as the
+ * perforations show it. No time is stated: how long a machine kept a
+ * setting is for a comparison across rolls to find out.
+ * @see crm:E3 Condition State
+ */
+export interface PerforatorSetting extends ConditionState<'setting'> {
+    /**
+     * The diameter of the round punch. Taken across the roll, it is the
+     * one value of the setting that neither the scale along the roll nor
+     * the shrinkage of the paper enters.
+     * @see reo:punchDiameter
+     */
+    punchDiameter?: ObjectAssumption<Measure<'mm'>>;
+    /**
+     * @see reo:chainPitch
+     */
+    chainPitch?: ObjectAssumption<ChainPitch>;
+    /**
+     * @see reo:advance
+     */
+    advance?: ObjectAssumption<Advance>;
+}
+/**
+ * The machine that punched the copy. It stands for this production
+ * alone. Whether it is the one another copy was punched on is left to a
+ * statement of identity made about it elsewhere, which its id allows.
+ * @see crm:E22 Human-Made Object
+ */
+export interface Perforator extends WithId {
+    /**
+     * @see crm:P44 has condition
+     */
+    condition?: PerforatorSetting;
+}

package/lib/Perforator.js

@@ -0,0 +1 @@
+export {};

package/lib/RollCopy.d.ts

@@ -8,6 +8,7 @@ import { WithId, WithType } from "./utils.js";
 import { Agent, Concept } from "./Agent.js";
 import { FeatureSource } from "./FeatureSource.js";
 import { Measure, Millimeters, Quantity, Track } from "./Quantity.js";
+import { Perforator } from "./Perforator.js";
 /**
  * This condition state is used to describe the roll's
  * paper shrinkage or stretching. It might be calculated
@@ -114,6 +115,12 @@ export interface ProductionEvent {
      * @see reo:paperSpeed
      */
     speed?: ObjectAssumption<PaperSpeed>;
+    /**
+     * The perforator the copy was punched on, with the setting its
+     * perforations show.
+     * @see crm:P16 used specific object
+     */
+    perforator?: Perforator;
     /**
      * The features the copy came from its punching with: the note and
      * expression perforations, and now and then a mark the perforator
@@ -204,8 +211,10 @@ export interface RollCopy extends WithType<'RollCopy'>, WithId {
     ops: Array<'shifted' | 'stretched' | 'shortened'>;
     /**
      * Physical measurements of this roll copy, including
-     * dimensions, punch diameter, hole separation, margins,
-     * shift corrections, and information about the measuring software.
+     * dimensions, hole separation, margins, shift corrections,
+     * and information about the measuring software. What the
+     * perforations tell about the machine that cut them is stated
+     * with the production.
      * @see crm:P39i was measured by
      */
     measurements: Partial<{
@@ -231,13 +240,11 @@ export interface RollCopy extends WithType<'RollCopy'>, WithId {
             unit: 'mm';
         };
         /**
-         * The average diameter of punched holes.
-         * @see reo:punchDiameter
-         */
-        punchDiameter: Measure<'mm'>;
-        /**
-         * The distance between adjacent tracker bar holes, in the
-         * unit the scan was measured in.
+         * The distance across the roll from the centre of one track to
+         * the next, the track pitch or Teilung, in the unit the scan was
+         * measured in. It is fixed by the tracker bar the roll was cut
+         * for, and is another thing than the chain pitch, which runs
+         * along the roll.
          * @see reo:holeSeparation
          */
         holeSeparation: Measure<'px'> | Measure<'mm'>;
@@ -400,6 +407,8 @@ export declare const isPaperStretch: (condition: RollConditionAssignment) => boo
  * before the systems were told apart; `reservationsAbout` says so.
  */
 export declare const barOf: (copy: Pick<RollCopy, 'production'>) => TrackerBar;
+/** The diameter of the punch the copy was cut with, where the edition holds it true or likely. */
+export declare const punchDiameterOf: (copy: Pick<RollCopy, 'production'>) => Millimeters | undefined;
 /**
  * Reads the features of a copy as the tracker bar would read them.
  * Holes on a position the bar does not read carry no symbol and are

package/lib/RollCopy.js

@@ -1,7 +1,7 @@
 import { v4 } from "uuid";
 import { welteT100 } from "./systems/welteT100/bar.js";
 import { trackerBarOf } from "./systems/index.js";
-import { assignReference } from "./Assumption.js";
+import { assignReference, certaintyOf, isAsserted } from "./Assumption.js";
 import { px, track } from "./Quantity.js";
 export const rollConditions = [
     'general',
@@ -47,6 +47,11 @@ export const isPaperStretch = (condition) => condition.conditionType === 'paper-
  * before the systems were told apart; `reservationsAbout` says so.
  */
 export const barOf = (copy) => trackerBarOf(copy.production?.system) ?? welteT100;
+/** The diameter of the punch the copy was cut with, where the edition holds it true or likely. */
+export const punchDiameterOf = (copy) => {
+    const diameter = copy.production?.perforator?.condition?.punchDiameter;
+    return diameter && isAsserted(certaintyOf(diameter)) ? diameter.value : undefined;
+};
 /**
  * Reads the features of a copy as the tracker bar would read them.
  * Holes on a position the bar does not read carry no symbol and are

package/lib/importJsonLd.js

@@ -1,5 +1,5 @@
 import { derivedKeys } from "./asJsonLd.js";
-import { migrate } from "./migrate.js";
+import { migrate, plainCopyId } from "./migrate.js";
 import { isDateString } from "./utils.js";
 export const importDate = (str) => {
     const [y, m, d] = str.split('-').map(s => parseInt(s, 10));
@@ -49,7 +49,7 @@ const withPlainCopyIds = (json) => ({
     ...json,
     copies: (json.copies ?? []).map((copy) => ({
         ...copy,
-        '@id': typeof copy['@id'] === 'string' ? copy['@id'].replace(/^copy\//, '') : copy['@id']
+        '@id': typeof copy['@id'] === 'string' ? plainCopyId(copy['@id']) : copy['@id']
     }))
 });
 export const importJsonLd = (json) => {

package/lib/index.d.ts

@@ -16,6 +16,7 @@ export * from './systems/welteT98/bar.js';
 export * from './systems/index.js';
 export * from './ReproducingSystem.js';
 export * from './FeatureSource.js';
+export * from './Perforator.js';
 export * from './RollCopy.js';
 export * from './procedures.js';
 export * from './vocabulary.js';

package/lib/index.js

@@ -16,6 +16,7 @@ export * from './systems/welteT98/bar.js';
 export * from './systems/index.js';
 export * from './ReproducingSystem.js';
 export * from './FeatureSource.js';
+export * from './Perforator.js';
 export * from './RollCopy.js';
 export * from './procedures.js';
 export * from './vocabulary.js';

package/lib/migrate.d.ts

@@ -11,5 +11,7 @@
  * had renamed before.
  */
 type Json = any;
+/** A copy's id without the `copy/` that documents of earlier releases put before it. */
+export declare const plainCopyId: (id: string) => string;
 export declare const migrate: (edition: Json) => Json;
 export {};

package/lib/migrate.js

@@ -117,6 +117,39 @@ const withScale = (node) => {
     const factor = (node.conditions ?? []).find(isPaperStretch)?.factor;
     return factor === undefined ? node : { ...node, measurements: { ...node.measurements, scale: factor } };
 };
+/** A copy's id without the `copy/` that documents of earlier releases put before it. */
+export const plainCopyId = (id) => id.replace(/^copy\//, '');
+/**
+ * The punch diameter was a measurement of the copy before it was stated
+ * as the setting of the perforator that cut it. A diameter of -1 stood
+ * for one nobody had measured and is left out. The perforator is named
+ * after the copy, so that a file migrated twice names it the same way.
+ */
+const withPerforator = (node) => {
+    const diameter = node.measurements?.punchDiameter;
+    if (diameter === undefined)
+        return node;
+    const { punchDiameter: _moved, ...measurements } = node.measurements;
+    if (!(diameter?.value > 0))
+        return { ...node, measurements };
+    const perforator = node.production?.perforator ?? { '@id': `perforator_${plainCopyId(node['@id'])}` };
+    return {
+        ...node,
+        measurements,
+        production: {
+            ...node.production,
+            perforator: {
+                ...perforator,
+                condition: {
+                    '@type': 'ConditionState',
+                    conditionType: 'setting',
+                    ...perforator.condition,
+                    punchDiameter: diameter
+                }
+            }
+        }
+    };
+};
 /** A derivation written as a single one, before a version could name several. */
 const isSingleDerivation = (basedOn) => basedOn !== null && typeof basedOn === 'object' && !Array.isArray(basedOn);
 const withDerivationList = (node) => isSingleDerivation(node.basedOn) ? { ...node, basedOn: [node.basedOn] } : node;
@@ -233,7 +266,7 @@ const withTimeSpanDates = (node) => {
     return { ...rest, within };
 };
 const migrateNode = (node) => [withRenamedKeys, withTypology, withoutVersionType, withoutVersionSiglum, withLowerCaseTerms, withSplitMethod, withReferences, withKeeper, withoutEmptyKeeper,
-    withProductionNodes, withScale, withDerivationList, withReadingKind, withTimeSpanDates, withoutFeatureKind,
+    withPerforator, withProductionNodes, withScale, withDerivationList, withReadingKind, withTimeSpanDates, withoutFeatureKind,
     withBorneFeaturesNamed, withFeaturesInActs]
     .reduce((result, step) => step(result), node);
 /** The items each walked, or the very same list where the walk changed none. */

package/lib/readers/stanfordAton.js

@@ -157,7 +157,20 @@ export function readFromStanfordAton(atonString, { trackShift, system = welteT10
         id: v4(),
         ops: [],
         conditions: [],
-        production: { system: systemOf(system), produced: features },
+        production: {
+            system: systemOf(system),
+            ...(punchDiameter !== undefined && {
+                perforator: {
+                    id: `perforator_${v4()}`,
+                    condition: {
+                        type: 'ConditionState',
+                        conditionType: 'setting',
+                        punchDiameter: { value: punchDiameter, unit: 'mm' }
+                    }
+                }
+            }),
+            produced: features
+        },
         modifications: [],
         ...((scan ?? stanford) && { scan: scan ?? stanford?.scan }),
         measurements: {
@@ -166,9 +179,6 @@ export function readFromStanfordAton(atonString, { trackShift, system = welteT10
                 height: inMillimeters(readPx(json.ROLLINFO.IMAGE_LENGTH), dpi),
                 unit: 'mm'
             },
-            ...(punchDiameter !== undefined && {
-                punchDiameter: { value: punchDiameter, unit: 'mm' }
-            }),
             holeSeparation: {
                 value: separation,
                 unit: 'px'

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/schema.json

@@ -1854,6 +1854,56 @@
             ],
             "description": "An object assumption wraps a complex object with an optional annotation. Used for structured values (e.g. persons, conditions) whose properties may be uncertain."
         },
+        "ObjectAssumption<Advance>": {
+            "description": "An object assumption wraps a complex object with an optional annotation. Used for structured values (e.g. persons, conditions) whose properties may be uncertain.",
+            "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"
+                },
+                "n": {
+                    "description": "How many slot lengths were folded.",
+                    "type": "number",
+                    "ontology": "reo:sampleSize"
+                },
+                "strength": {
+                    "description": "How closely the lengths keep the period, from 0 where they scatter to 1 where every one falls on the comb: the mean resultant length of the lengths folded onto it. A period found weakly is the result of a search all the same; the belief it is stated with says how far it is held to be the machine's step.",
+                    "type": "number",
+                    "ontology": "reo:strength"
+                },
+                "unit": {
+                    "const": "mm",
+                    "description": "The unit of measurement.",
+                    "type": "string",
+                    "ontology": "crm:P91 has unit"
+                },
+                "value": {
+                    "$ref": "#/definitions/Quantity%3C%22mm%22%3E",
+                    "description": "The measured value.",
+                    "ontology": "crm:P90 has value"
+                }
+            },
+            "required": [
+                "unit",
+                "value"
+            ],
+            "type": "object"
+        },
         "ObjectAssumption<Agent>": {
             "description": "An object assumption wraps a complex object with an optional annotation. Used for structured values (e.g. persons, conditions) whose properties may be uncertain.",
             "properties": {
@@ -1908,6 +1958,61 @@
             ],
             "type": "object"
         },
+        "ObjectAssumption<ChainPitch>": {
+            "description": "An object assumption wraps a complex object with an optional annotation. Used for structured values (e.g. persons, conditions) whose properties may be uncertain.",
+            "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"
+                },
+                "bridge": {
+                    "$ref": "#/definitions/Millimeters",
+                    "description": "The paper left standing between two slots of a chain. Slot and bridge are medians of their own and need not add up to the pitch.",
+                    "ontology": "reo:bridge"
+                },
+                "n": {
+                    "description": "How many pitches the median was taken over.",
+                    "type": "number",
+                    "ontology": "reo:sampleSize"
+                },
+                "slot": {
+                    "$ref": "#/definitions/Millimeters",
+                    "description": "The length along the roll of one slot of a chain.",
+                    "ontology": "reo:slot"
+                },
+                "unit": {
+                    "const": "mm",
+                    "description": "The unit of measurement.",
+                    "type": "string",
+                    "ontology": "crm:P91 has unit"
+                },
+                "value": {
+                    "$ref": "#/definitions/Quantity%3C%22mm%22%3E",
+                    "description": "The measured value.",
+                    "ontology": "crm:P90 has value"
+                }
+            },
+            "required": [
+                "unit",
+                "value"
+            ],
+            "type": "object"
+        },
         "ObjectAssumption<CollationTolerance>": {
             "description": "An object assumption wraps a complex object with an optional annotation. Used for structured values (e.g. persons, conditions) whose properties may be uncertain.",
             "properties": {
@@ -2238,6 +2343,46 @@
             ],
             "type": "object"
         },
+        "ObjectAssumption<Measure<\"mm\">>": {
+            "description": "An object assumption wraps a complex object with an optional annotation. Used for structured values (e.g. persons, conditions) whose properties may be uncertain.",
+            "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"
+                },
+                "unit": {
+                    "const": "mm",
+                    "description": "The unit of measurement.",
+                    "type": "string",
+                    "ontology": "crm:P91 has unit"
+                },
+                "value": {
+                    "$ref": "#/definitions/Quantity%3C%22mm%22%3E",
+                    "description": "The measured value.",
+                    "ontology": "crm:P90 has value"
+                }
+            },
+            "required": [
+                "unit",
+                "value"
+            ],
+            "type": "object"
+        },
         "ObjectAssumption<PaperSpeed>": {
             "anyOf": [
                 {
@@ -2514,6 +2659,65 @@
             ],
             "type": "object"
         },
+        "Perforator": {
+            "description": "The machine that punched the copy. It stands for this production alone. Whether it is the one another copy was punched on is left to a statement of identity made about it elsewhere, which its id allows.",
+            "properties": {
+                "condition": {
+                    "$ref": "#/definitions/PerforatorSetting",
+                    "ontology": "crm:P44 has condition"
+                },
+                "@id": {
+                    "description": "A unique identifier for this object.",
+                    "type": "string"
+                }
+            },
+            "required": [
+                "@id"
+            ],
+            "type": "object",
+            "ontology": "crm:E22 Human-Made Object"
+        },
+        "PerforatorSetting": {
+            "description": "How the perforator was set when it punched the copy, as far as the perforations show it. No time is stated: how long a machine kept a setting is for a comparison across rolls to find out.",
+            "properties": {
+                "advance": {
+                    "$ref": "#/definitions/ObjectAssumption%3CAdvance%3E",
+                    "ontology": "reo:advance"
+                },
+                "chainPitch": {
+                    "$ref": "#/definitions/ObjectAssumption%3CChainPitch%3E",
+                    "ontology": "reo:chainPitch"
+                },
+                "conditionType": {
+                    "const": "setting",
+                    "description": "The kind of condition, from the list the roll or the kind of feature allows.",
+                    "type": "string",
+                    "ontology": "crm:P2 has type"
+                },
+                "description": {
+                    "description": "A free-text description of the condition, providing details beyond the type classification.",
+                    "type": "string",
+                    "ontology": "crm:P3 has note"
+                },
+                "punchDiameter": {
+                    "$ref": "#/definitions/ObjectAssumption%3CMeasure%3C%22mm%22%3E%3E",
+                    "description": "The diameter of the round punch. Taken across the roll, it is the one value of the setting that neither the scale along the roll nor the shrinkage of the paper enters.",
+                    "ontology": "reo:punchDiameter"
+                },
+                "@type": {
+                    "const": "ConditionState",
+                    "description": "The type discriminator for this object.",
+                    "type": "string",
+                    "ontology": "rdf:type"
+                }
+            },
+            "required": [
+                "conditionType",
+                "@type"
+            ],
+            "type": "object",
+            "ontology": "crm:E3 Condition State"
+        },
         "Person": {
             "$ref": "#/definitions/Agent",
             "description": "An agent that is a person."
@@ -2567,6 +2771,11 @@
                     "description": "The paper the roll copy was cut on.",
                     "ontology": "crm:P126 employed"
                 },
+                "perforator": {
+                    "$ref": "#/definitions/Perforator",
+                    "description": "The perforator the copy was punched on, with the setting its perforations show.",
+                    "ontology": "crm:P16 used specific object"
+                },
                 "produced": {
                     "description": "The features the copy came from its punching with: the note and expression perforations, and now and then a mark the perforator left. A reading of a scan finds every hole on the paper at once and states it here, and a feature an editor reads as the work of a later hand belongs in the act that made it, whichever kind of feature it is.",
                     "items": {
@@ -2742,7 +2951,7 @@
                     "ontology": "crm:P50 has current keeper"
                 },
                 "measurements": {
-                    "description": "Physical measurements of this roll copy, including dimensions, punch diameter, hole separation, margins, shift corrections, and information about the measuring software.",
+                    "description": "Physical measurements of this roll copy, including dimensions, hole separation, margins, shift corrections, and information about the measuring software. What the perforations tell about the machine that cut them is stated with the production.",
                     "properties": {
                         "dimensions": {
                             "description": "The physical dimensions of the roll.",
@@ -2781,7 +2990,7 @@
                                     "$ref": "#/definitions/Measure%3C%22mm%22%3E"
                                 }
                             ],
-                            "description": "The distance between adjacent tracker bar holes, in the unit the scan was measured in.",
+                            "description": "The distance across the roll from the centre of one track to the next, the track pitch or Teilung, in the unit the scan was measured in. It is fixed by the tracker bar the roll was cut for, and is another thing than the chain pitch, which runs along the roll.",
                             "ontology": "reo:holeSeparation"
                         },
                         "margins": {
@@ -2823,11 +3032,6 @@
                             "type": "object",
                             "ontology": "crmdig:L23 used software or firmware"
                         },
-                        "punchDiameter": {
-                            "$ref": "#/definitions/Measure%3C%22mm%22%3E",
-                            "description": "The average diameter of punched holes.",
-                            "ontology": "reo:punchDiameter"
-                        },
                         "readerExtension": {
                             "description": "What a pneumatic reader added to this copy's holes, where it was taken off again. Such a reader reports how long a valve stayed open, which exceeds the perforation that opened it, so its holes are overlong by a constant while its onsets agree. Nothing for a copy read by other means, whose holes are the punched slots themselves. Not exported to RDF.",
                             "properties": {

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/spec/context.json

@@ -157,7 +157,6 @@
                 "dimensions": "reo:dimensions",
                 "width": "reo:width",
                 "height": "reo:height",
-                "punchDiameter": "reo:punchDiameter",
                 "holeSeparation": "reo:holeSeparation",
                 "scanResolution": "reo:scanResolution",
                 "value": "crm:P90_has_value",
@@ -177,6 +176,19 @@
                 "speed": {
                     "@id": "reo:paperSpeed",
                     "@context": { "value": "crm:P90_has_value" }
+                },
+                "perforator": {
+                    "@id": "crm:P16_used_specific_object",
+                    "@context": {
+                        "punchDiameter": "reo:punchDiameter",
+                        "chainPitch": "reo:chainPitch",
+                        "advance": "reo:advance",
+                        "slot": "reo:slot",
+                        "bridge": "reo:bridge",
+                        "n": "reo:sampleSize",
+                        "strength": "reo:strength",
+                        "value": "crm:P90_has_value"
+                    }
                 }
             }
         },

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.53.0",
   "description": "Digital editions of piano rolls: import, collation, editorial assumptions, JSON-LD export, and emulation through a reproducing system",
   "license": "MIT",
   "repository": {