linked-rolls 0.52.0 → 0.54.0

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/Feature.d.ts

@@ -109,15 +109,6 @@ export type FeatureConditionAssignment = ObjectAssumption<ConditionState<Feature
  * @see reo:Hole
  */
 export interface Hole extends RollFeature<'Hole', typeof conditions.Hole[number]> {
-    /**
-     * The punching pattern of the hole. Regular holes have evenly-spaced
-     * bridges, accelerating holes have decreasing bridge widths, and
-     * staggering holes do not align in rows across the tracks, the mark
-     * of an asynchronous perforator with a separate driver for each
-     * punch (Phillips 2016, p. 112).
-     * @see reo:pattern
-     */
-    pattern?: 'regular' | 'accelerating' | 'staggering';
 }
 /**
  * Something that lies on a face of the paper rather than through it. A

package/lib/Perforator.d.ts

@@ -0,0 +1,120 @@
+import { ObjectAssumption } from "./Assumption.js";
+import { ConditionState } from "./ConditionState.js";
+import { Measure, Millimeters } from "./Quantity.js";
+import { WithId, WithType } 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>;
+}
+/**
+ * How the punches of a perforator were driven, after Phillips (2016,
+ * pp. 112 f.): all at once by one ram head, or each by a driver of its
+ * own. `ontology/types.ttl` defines them, and a test holds this list
+ * against it.
+ * @see crm:E55 Type
+ */
+export declare const drives: readonly [{
+    readonly id: 'https://w3id.org/reo/type/drive/ram-head';
+    readonly name: 'ram head';
+}, {
+    readonly id: 'https://w3id.org/reo/type/drive/asynchronous';
+    readonly name: 'asynchronous';
+}];
+export type DriveId = typeof drives[number]['id'];
+/**
+ * A drive, named by its IRI alone.
+ * @see crm:E55 Type
+ */
+export interface Drive {
+    /** The IRI the type vocabulary gives the drive. */
+    readonly id: DriveId;
+}
+/**
+ * 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 WithType<'Perforator'>, WithId {
+    /**
+     * How its punches were driven, as the rows of its chains show it:
+     * in line across the tracks where one ram head drove them all, and
+     * staggered where each punch had a driver of its own. It is part of
+     * how the machine was built and so no part of its setting.
+     * @see reo:drive
+     */
+    drive?: ObjectAssumption<Drive>;
+    /**
+     * @see crm:P44 has condition
+     */
+    condition?: PerforatorSetting;
+}

package/lib/Perforator.js

@@ -0,0 +1,11 @@
+/**
+ * How the punches of a perforator were driven, after Phillips (2016,
+ * pp. 112 f.): all at once by one ram head, or each by a driver of its
+ * own. `ontology/types.ttl` defines them, and a test holds this list
+ * against it.
+ * @see crm:E55 Type
+ */
+export const drives = [
+    { id: 'https://w3id.org/reo/type/drive/ram-head', name: 'ram head' },
+    { id: 'https://w3id.org/reo/type/drive/asynchronous', name: 'asynchronous' }
+];

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 drive and 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,74 @@ 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 perforator the copy states, or a new one named after the copy, so
+ * that a file migrated twice names it the same way.
+ */
+const perforatorOf = (copy) => copy.production?.perforator ?? { '@type': 'Perforator', '@id': `perforator_${plainCopyId(copy['@id'])}` };
+/**
+ * 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.
+ */
+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 = perforatorOf(node);
+    return {
+        ...node,
+        measurements,
+        production: {
+            ...node.production,
+            perforator: {
+                ...perforator,
+                condition: {
+                    '@type': 'ConditionState',
+                    conditionType: 'setting',
+                    ...perforator.condition,
+                    punchDiameter: diameter
+                }
+            }
+        }
+    };
+};
+/** A perforator was first written without a type. */
+const withTypedPerforator = (node) => {
+    const perforator = node.perforator;
+    if (!perforator || typeof perforator !== 'object' || perforator['@type'])
+        return node;
+    return { ...node, perforator: { '@type': 'Perforator', ...perforator } };
+};
+const asynchronous = 'https://w3id.org/reo/type/drive/asynchronous';
+/**
+ * Each hole once stated its punching pattern. A staggering hole the copy
+ * was punched with shows that its perforator drove each punch on its
+ * own; one a later act made shows nothing about the machine. Regular
+ * and accelerating bridges are not carried over: the chain pitch states
+ * the one, and for the other no source was found. The features are in
+ * their acts here, since a node is migrated before its children are.
+ */
+const withDriveOfStaggering = (node) => {
+    const produced = node.production?.produced;
+    if (!Array.isArray(produced) || !produced.some((feature) => feature?.pattern === 'staggering'))
+        return node;
+    const perforator = perforatorOf(node);
+    if (perforator.drive)
+        return node;
+    return { ...node, production: { ...node.production, perforator: { ...perforator, drive: { '@id': asynchronous } } } };
+};
+const withoutPattern = (node) => {
+    if (node['@type'] !== 'Hole' || !Object.hasOwn(node, 'pattern'))
+        return node;
+    const { pattern: _moved, ...rest } = node;
+    return rest;
+};
 /** 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,8 +301,8 @@ const withTimeSpanDates = (node) => {
     return { ...rest, within };
 };
 const migrateNode = (node) => [withRenamedKeys, withTypology, withoutVersionType, withoutVersionSiglum, withLowerCaseTerms, withSplitMethod, withReferences, withKeeper, withoutEmptyKeeper,
-    withProductionNodes, withScale, withDerivationList, withReadingKind, withTimeSpanDates, withoutFeatureKind,
-    withBorneFeaturesNamed, withFeaturesInActs]
+    withPerforator, withProductionNodes, withTypedPerforator, withScale, withDerivationList, withReadingKind, withTimeSpanDates,
+    withoutFeatureKind, withBorneFeaturesNamed, withFeaturesInActs, withDriveOfStaggering, withoutPattern]
     .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/readers/stanfordAton.js

@@ -157,7 +157,21 @@ export function readFromStanfordAton(atonString, { trackShift, system = welteT10
         id: v4(),
         ops: [],
         conditions: [],
-        production: { system: systemOf(system), produced: features },
+        production: {
+            system: systemOf(system),
+            ...(punchDiameter !== undefined && {
+                perforator: {
+                    type: '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 +180,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/schema.json

@@ -436,6 +436,13 @@
             "type": "object",
             "ontology": "lrmoo:R76 is derivative of"
         },
+        "DriveId": {
+            "enum": [
+                "https://w3id.org/reo/type/drive/ram-head",
+                "https://w3id.org/reo/type/drive/asynchronous"
+            ],
+            "type": "string"
+        },
         "Edit": {
             "description": "A set of edits transforms a version of a roll into another version. Edits insert or delete symbols, or both (= replace). Edits may be motivated by a given set of reasons, e.g. to add an additional accent or to correct an error. If an edit is the interpretation of a metamark, such as a pencil mark, this should be made explicit using a meaning comprehension on the `@annotation` field.",
             "properties": {
@@ -895,16 +902,6 @@
                     "description": "Horizontal span of the feature on the roll.",
                     "ontology": "crm:P43 has dimension"
                 },
-                "pattern": {
-                    "description": "The punching pattern of the hole. Regular holes have evenly-spaced bridges, accelerating holes have decreasing bridge widths, and staggering holes do not align in rows across the tracks, the mark of an asynchronous perforator with a separate driver for each punch (Phillips 2016, p. 112).",
-                    "enum": [
-                        "regular",
-                        "accelerating",
-                        "staggering"
-                    ],
-                    "type": "string",
-                    "ontology": "reo:pattern"
-                },
                 "vertical": {
                     "$ref": "#/definitions/VerticalSpan",
                     "description": "Vertical span of the feature on the roll.",
@@ -1448,16 +1445,6 @@
                             "description": "Horizontal span of the feature on the roll. Left out by a feature a patch bears.",
                             "ontology": "crm:P43 has dimension"
                         },
-                        "pattern": {
-                            "description": "The punching pattern of the hole. Regular holes have evenly-spaced bridges, accelerating holes have decreasing bridge widths, and staggering holes do not align in rows across the tracks, the mark of an asynchronous perforator with a separate driver for each punch (Phillips 2016, p. 112).",
-                            "enum": [
-                                "regular",
-                                "accelerating",
-                                "staggering"
-                            ],
-                            "type": "string",
-                            "ontology": "reo:pattern"
-                        },
                         "vertical": {
                             "$ref": "#/definitions/VerticalSpan",
                             "description": "Vertical span of the feature on the roll. Left out by a feature a patch bears.",
@@ -1854,6 +1841,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 +1945,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": {
@@ -2189,6 +2281,38 @@
             ],
             "type": "object"
         },
+        "ObjectAssumption<Drive>": {
+            "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"
+                },
+                "@id": {
+                    "$ref": "#/definitions/DriveId",
+                    "description": "The IRI the type vocabulary gives the drive."
+                }
+            },
+            "required": [
+                "@id"
+            ],
+            "type": "object"
+        },
         "ObjectAssumption<Instrument>": {
             "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 +2362,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 +2678,77 @@
             ],
             "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"
+                },
+                "drive": {
+                    "$ref": "#/definitions/ObjectAssumption%3CDrive%3E",
+                    "description": "How its punches were driven, as the rows of its chains show it: in line across the tracks where one ram head drove them all, and staggered where each punch had a driver of its own. It is part of how the machine was built and so no part of its setting.",
+                    "ontology": "reo:drive"
+                },
+                "@id": {
+                    "description": "A unique identifier for this object.",
+                    "type": "string"
+                },
+                "@type": {
+                    "const": "Perforator",
+                    "description": "The type discriminator for this object.",
+                    "type": "string",
+                    "ontology": "rdf:type"
+                }
+            },
+            "required": [
+                "@id",
+                "@type"
+            ],
+            "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 +2802,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 drive and 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 +2982,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 +3021,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 +3063,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/spec/context.json

@@ -21,6 +21,7 @@
         "Attachment": "crm:E79_Part_Addition",
         "Removal": "crm:E80_Part_Removal",
         "Alteration": "crm:E12_Production",
+        "Perforator": "crm:E22_Human-Made_Object",
         "ConditionState": "crm:E3_Condition_State",
         "note": "reo:Note",
         "expression": "reo:Expression",
@@ -157,7 +158,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,9 +177,23 @@
                 "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"
+                    }
                 }
             }
         },
+        "drive": "reo:drive",
         "company": "crm:P14_carried_out_by",
         "paper": "crm:P126_employed",
         "conditions": "crm:P44_has_condition",
@@ -237,11 +251,6 @@
             "@type": "@vocab",
             "@context": { "@vocab": "https://w3id.org/reo/type/" }
         },
-        "pattern": {
-            "@id": "reo:pattern",
-            "@type": "@vocab",
-            "@context": { "@vocab": "https://w3id.org/reo/type/" }
-        },
         "technique": {
             "@id": "reo:technique",
             "@type": "@vocab",

package/lib/vocabulary.d.ts

@@ -1,8 +1,8 @@
 import { Concept } from "./Agent.js";
 /**
  * The concepts the type vocabulary declares, whatever kind they are:
- * the reproducing systems and the procedures. An edition names one of
- * them by its IRI alone.
+ * the reproducing systems, the procedures and the drives of a
+ * perforator. An edition names one of them by its IRI alone.
  */
 export declare const vocabulary: readonly Concept[];
 /** The concept of that IRI, where the vocabulary declares one. */

package/lib/vocabulary.js

@@ -1,14 +1,16 @@
+import { drives } from "./Perforator.js";
 import { procedures } from "./procedures.js";
 import { systemOf } from "./TrackerBar.js";
 import { trackerBars } from "./systems/index.js";
 /**
  * The concepts the type vocabulary declares, whatever kind they are:
- * the reproducing systems and the procedures. An edition names one of
- * them by its IRI alone.
+ * the reproducing systems, the procedures and the drives of a
+ * perforator. An edition names one of them by its IRI alone.
  */
 export const vocabulary = [
     ...trackerBars.map(systemOf),
-    ...procedures
+    ...procedures,
+    ...drives
 ];
 /** The concept of that IRI, where the vocabulary declares one. */
 export const conceptOf = (id) => id === undefined ? undefined : vocabulary.find(concept => concept.id === id);

package/package.json

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