linked-rolls 0.53.0 → 0.55.0

package/README.md

@@ -153,19 +153,20 @@ and the onset alone 39, so neither test is idle, but a difference at the
 end is as often a punch measured badly as a punch genuinely prolonged,
 and the two are not worth confusing.
 
-## What a reader adds to a hole
+## What a reader adds to a chain of holes
 
 A copy read pneumatically rather than scanned reports how long a valve
 stayed open, and a valve is held on past the perforation that opened it,
-so its holes run longer than the punched slots while their onsets agree.
-Left in, that is not a difference between copies: a collation comparing
-such a copy's hole ends against a scanned copy's compares an on-time
-with a slot, and reads the one as a lengthening of the other.
+so the chains it reports run longer than the punched ones while their
+onsets agree. Left in, that is not a difference between copies: a
+collation comparing such a copy's chain ends against a scanned copy's
+compares an on-time with a slot, and reads the one as a lengthening of
+the other.
 
-`shortenHoles` takes the extension off and records it on the copy,
+`shortenChains` takes the extension off and records it on the copy,
 `revertShortening` puts it back, and `readFromPhillipsEroll` will take
-it off at import. Only holes are touched, what a writing spans being no
-valve. The figure is measured against the other copies rather than
+it off at import. Only chains of holes are touched, what a writing spans
+being no valve. The figure is measured against the other copies rather than
 derived from the bar, since Phillips gives only the difference between
 two bars and not the absolute.
 
@@ -223,7 +224,7 @@ hand, and says nothing about what kind of feature it is. A hole may be
 punched by hand long after the roll was cut, and a mark may come from
 the factory, rarely though that happens. A feature no later act is
 known to have made belongs to the punching, which is where a reading of
-a scan puts every hole it finds.
+a scan puts every chain of holes it finds.
 
 Three kinds of act rather than two, because the CRM tells them apart.
 E79 Part Addition asks that what is added be "a separate identifiable
@@ -358,9 +359,9 @@ repository.
 
 ### Alignment, order and pairing
 
-A command takes its place from the holes that carry it. Four fields
-on a command let an editor state where the measurement should give
-way. `alignedWith` names another command whose onset this one takes
+A command takes its place from the chains of holes that carry it. Four
+fields on a command let an editor state where the measurement should
+give way. `alignedWith` names another command whose onset this one takes
 in the performance, as a "crescendo off" is meant to fall on the note
 it belongs to. `before` and `after` name a command whose onset this
 one precedes or follows, without saying by how much: where the copies

package/lib/Emulation.js

@@ -15,7 +15,7 @@ const propertiesOf = (view, version) => ({
     tempo: view.edition.tempoAdjustment,
     toOwnPaper: view.toOwnPaperOf(version)
 });
-/** The onset a symbol has on each copy carrying it, by the copy's index, as the mean of its holes there. */
+/** The onset a symbol has on each copy carrying it, by the copy's index, as the mean of its chains there. */
 const onsetsByCopy = (view, symbolId) => {
     const symbol = view.get(symbolId);
     if (!symbol)

package/lib/Feature.d.ts

@@ -53,7 +53,7 @@ export interface VerticalSpan {
      */
     to?: Track;
 }
-export declare const featureTypes: readonly ['Hole', 'Writing', 'Mark', 'GluedOn'];
+export declare const featureTypes: readonly ['HoleChain', 'Writing', 'Mark', 'GluedOn'];
 export type FeatureType = typeof featureTypes[number];
 export declare const isFeatureType: (value: unknown) => value is FeatureType;
 /**
@@ -86,7 +86,7 @@ export interface RollFeature<T extends FeatureType, DamageT extends string> exte
     condition?: ObjectAssumption<ConditionState<DamageT>>;
 }
 export declare const conditions: {
-    readonly Hole: readonly ["partially-torn", "missing-perforation"];
+    readonly HoleChain: readonly ["partially-torn", "missing-perforation"];
     readonly Writing: readonly ["illegible"];
     readonly Mark: readonly ["faded"];
     readonly GluedOn: readonly ["detaching", "ripped"];
@@ -100,28 +100,21 @@ export type FeatureConditionType = typeof conditions[FeatureType][number];
  */
 export type FeatureConditionAssignment = ObjectAssumption<ConditionState<FeatureConditionType>>;
 /**
- * A hole (perforation) in the roll paper. Holes are the primary
- * carriers of musical information on piano rolls, as they trigger
- * notes and expression controls when passing over the tracker bar.
- * A punched hole is a human-made feature: CRM counts "the information
- * encoding features on mechanical or digital carriers" among the
- * features purposely created by human activity.
- * @see reo:Hole
+ * A chain of holes punched along the roll, which the tracker bar reads
+ * as it passes. The perforator cuts a held note or function as a row of
+ * punches with bridges of paper left between them, so most perforations
+ * are chains; one without a bridge is a chain of a single hole. The
+ * holes are the chain's parts and are not stated one by one. A punched
+ * chain is a human-made feature: CRM counts "the information encoding
+ * features on mechanical or digital carriers" among the features
+ * purposely created by human activity.
+ * @see reo:HoleChain
  */
-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';
+export interface HoleChain extends RollFeature<'HoleChain', typeof conditions.HoleChain[number]> {
 }
 /**
  * Something that lies on a face of the paper rather than through it. A
- * hole is not one: it goes through, and is on both faces at once.
+ * chain of holes is not one: it goes through, and is on both faces at once.
  */
 export interface OnAFace {
     /**
@@ -225,11 +218,11 @@ export interface GluedOn extends RollFeature<'GluedOn', typeof conditions.GluedO
     features?: NestedFeature[];
 }
 /**
- * The features proper: a hole, a writing and a mark are all human-made
- * features, and each of them is borne by whatever it sits on. A patch
- * is an object glued onto the paper and stands apart from them.
+ * The features proper: a chain of holes, a writing and a mark are all
+ * human-made features, and each of them is borne by whatever it sits on.
+ * A patch is an object glued onto the paper and stands apart from them.
  */
-export type AnyFeature = Hole | Writing | Mark;
+export type AnyFeature = HoleChain | Writing | Mark;
 /**
  * Anything found at a place of its own on the roll: a feature or a
  * glued-on patch. E24 Physical Human-Made Thing is the class both fall

package/lib/Feature.js

@@ -1,7 +1,7 @@
-export const featureTypes = ['Hole', 'Writing', 'Mark', 'GluedOn'];
+export const featureTypes = ['HoleChain', 'Writing', 'Mark', 'GluedOn'];
 export const isFeatureType = (value) => featureTypes.includes(value);
 export const conditions = {
-    Hole: ['partially-torn', 'missing-perforation'],
+    HoleChain: ['partially-torn', 'missing-perforation'],
     Writing: ['illegible'],
     Mark: ['faded'],
     GluedOn: ['detaching', 'ripped']

package/lib/FeatureSource.d.ts

@@ -16,7 +16,7 @@ export declare const sourceLabels: Record<SourceKind, string>;
  * roll reader measures when each perforation passes its bar. An
  * emulation and a recording give the reading somebody else made: the
  * roll has been turned into notes and commands already, and turning
- * those back into holes reconstructs them.
+ * those back into chains of holes reconstructs them.
  */
 export declare const isMeasured: (kind: SourceKind) => boolean;
 /**

package/lib/FeatureSource.js

@@ -27,7 +27,7 @@ const physical = ['roll', 'scan'];
  * roll reader measures when each perforation passes its bar. An
  * emulation and a recording give the reading somebody else made: the
  * roll has been turned into notes and commands already, and turning
- * those back into holes reconstructs them.
+ * those back into chains of holes reconstructs them.
  */
 export const isMeasured = (kind) => measured.includes(kind);
 /**

package/lib/Perforator.d.ts

@@ -1,7 +1,7 @@
 import { ObjectAssumption } from "./Assumption.js";
 import { ConditionState } from "./ConditionState.js";
 import { Measure, Millimeters } from "./Quantity.js";
-import { WithId } from "./utils.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
@@ -75,13 +75,44 @@ export interface PerforatorSetting extends ConditionState<'setting'> {
      */
     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 WithId {
+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
      */

package/lib/Perforator.js

@@ -1 +1,11 @@
-export {};
+/**
+ * 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/ReproducingSystem.d.ts

@@ -1,4 +1,4 @@
-import { Hole } from "./Feature.js";
+import { HoleChain } from "./Feature.js";
 import { Expression, Note } from "./Symbol.js";
 import { TrackerBar } from "./TrackerBar.js";
 import { Millimeters, Quantity, Seconds } from "./Quantity.js";
@@ -32,7 +32,7 @@ export type RollTempo = RollTempoIn<'ft/min'> | RollTempoIn<'m/min'>;
  * averaged in and the editorial assumptions applied, which is all a
  * performance needs to know of a symbol.
  */
-export type NegotiatedEvent = Omit<Note | Expression, 'carriers'> & Pick<Hole, 'horizontal' | 'vertical'>;
+export type NegotiatedEvent = Omit<Note | Expression, 'carriers'> & Pick<HoleChain, 'horizontal' | 'vertical'>;
 interface PerformedRollFeature<T> {
     type: T;
     performs: NegotiatedEvent;

package/lib/RollCopy.d.ts

@@ -116,18 +116,18 @@ export interface ProductionEvent {
      */
     speed?: ObjectAssumption<PaperSpeed>;
     /**
-     * The perforator the copy was punched on, with the setting its
-     * perforations show.
+     * 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
-     * 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.
+     * left. A reading of a scan finds every chain of holes 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.
      * @see crm:P108 has produced
      */
     produced?: AnyFeature[];
@@ -266,24 +266,24 @@ export interface RollCopy extends WithType<'RollCopy'>, WithId {
          */
         scale: number;
         /**
-         * 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.
+         * What a pneumatic reader added to this copy's chains of 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 chains are overlong by a constant while its onsets agree.
+         * Nothing for a copy read by other means, whose chains are the
+         * punched ones themselves.
          * Not exported to RDF.
          */
         readerExtension: {
-            /** How much longer the reading of a hole ran than the perforation that caused it. */
+            /** How much longer the reading of a chain ran than the perforation that caused it. */
             length: Millimeters;
             /**
-             * The holes it was not taken off, by `@id`, being no longer
+             * The chains it was not taken off, by `@id`, being no longer
              * than it is. The constant reaches its limit there rather
              * than the copy being wrong, and why they were left is for
              * the edition to state about the features themselves; this
              * only records that they stand as the reader gave them, so
-             * that putting the extension back does not lengthen a hole
+             * that putting the extension back does not lengthen a chain
              * nothing was taken from.
              */
             leaving?: string[];
@@ -411,8 +411,8 @@ export declare const barOf: (copy: Pick<RollCopy, 'production'>) => TrackerBar;
 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
- * dropped, which is what happens physically as well.
+ * Chains of holes on a position the bar does not read carry no symbol
+ * and are dropped, which is what happens physically as well.
  *
  * The bar is named rather than defaulted: a copy is read by its own
  * bar, and reading a green copy with the red one is a silent semitone.
@@ -428,7 +428,7 @@ export declare const punchDiameterOf: (copy: Pick<RollCopy, 'production'>) => Mi
 export declare function asSymbols(features: readonly FeatureOrPatch[], bar: TrackerBar): AnySymbol[];
 /**
  * The tracks a copy carries holes on that the tracker bar does not read.
- * A non-empty result usually means the scan is calibrated wrongly. A hole
+ * A non-empty result usually means the scan is calibrated wrongly. A chain
  * lying across several positions is counted against each one the bar
  * cannot read, and not at all where it reads them all.
  */

package/lib/RollCopy.js

@@ -54,8 +54,8 @@ export const punchDiameterOf = (copy) => {
 };
 /**
  * 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
- * dropped, which is what happens physically as well.
+ * Chains of holes on a position the bar does not read carry no symbol
+ * and are dropped, which is what happens physically as well.
  *
  * The bar is named rather than defaulted: a copy is read by its own
  * bar, and reading a green copy with the red one is a silent semitone.
@@ -69,9 +69,9 @@ export const punchDiameterOf = (copy) => {
  * scan; it is the reading that stops.
  */
 export function asSymbols(features, bar) {
-    const holes = features.filter(feature => feature.type === 'Hole');
-    const end = bar.endsAt(holes);
-    return holes
+    const chains = features.filter(feature => feature.type === 'HoleChain');
+    const end = bar.endsAt(chains);
+    return chains
         .filter(feature => end === undefined || feature.horizontal.from <= end.at)
         // An opening across two positions uncovers both bar holes and so
         // reads as both commands; one on a single position gives the one.
@@ -83,14 +83,14 @@ export function asSymbols(features, bar) {
 }
 /**
  * The tracks a copy carries holes on that the tracker bar does not read.
- * A non-empty result usually means the scan is calibrated wrongly. A hole
+ * A non-empty result usually means the scan is calibrated wrongly. A chain
  * lying across several positions is counted against each one the bar
  * cannot read, and not at all where it reads them all.
  */
 export function unreadTracks(features, bar) {
     const counts = new Map();
     features
-        .filter(feature => feature.type === 'Hole')
+        .filter(feature => feature.type === 'HoleChain')
         .flatMap(feature => bar.positionsIn(feature.vertical))
         .filter(position => !bar.meaningOf(position))
         .forEach(position => counts.set(position, (counts.get(position) || 0) + 1));

package/lib/Symbol.d.ts

@@ -3,13 +3,13 @@ import { WithId } from "./utils.js";
 /**
  * A symbol is an abstract musical or textual entity carried by one or more
  * physical features on the roll. Symbols are the result of interpreting
- * the physical features (holes, writings, etc.) on the roll copies.
+ * the physical features (chains of holes, writings, etc.) on the roll copies.
  * @see crm:E90 Symbolic Object
  */
 export interface Symbol<T extends string> extends WithId {
     type: T;
     /**
-     * References to the physical features (e.g. holes) on the roll copies
+     * References to the physical features (e.g. chains of holes) on the roll copies
      * that carry this symbol. Since the association might be debatable,
      * it can be annotated. There might be e.g. doubts about the meaning
      * and correct transcription of a feature on a physical roll.
@@ -21,10 +21,10 @@ export interface Symbol<T extends string> extends WithId {
 export declare const isSymbol: (object: any) => object is AnySymbol;
 export declare const isCommand: (symbol: object | undefined) => symbol is AnyCommand;
 /**
- * A command is what the tracker bar reads from a perforation, or from a
- * group of them: the note it sounds, or the function it operates. It is
- * typically carried by a single punched hole or a chain of them, but it
- * might also have different physical appearences.
+ * A command is what the tracker bar reads from a chain of holes: the
+ * note it sounds, or the function it operates. It is typically carried
+ * by such a chain, but it might also have different physical
+ * appearances.
  * @see reo:Command
  */
 export interface Command<T extends string> extends Symbol<T> {

package/lib/alignment.d.ts

@@ -11,13 +11,13 @@ export declare const revertShift: (copy: RollCopy) => void;
 export declare const revertScale: (copy: RollCopy) => void;
 /**
  * Takes the extension a pneumatic reader adds off the ends of the
- * copy's holes, and records how much was taken.
+ * copy's chains of holes, and records how much was taken.
  *
  * Such a reader reports how long a valve stayed open, and a valve is
- * held on past the perforation that opened it, so its holes run longer
- * than the punched slots while their onsets agree. Left in, the
+ * held on past the perforation that opened it, so its chains run longer
+ * than the punched ones while their onsets agree. Left in, the
  * difference is not a difference between copies at all: a collation
- * comparing this copy's hole ends against a scanned copy's compares a
+ * comparing this copy's chain ends against a scanned copy's compares a
  * pneumatic on-time with a punched slot, and reads the one as a
  * lengthening of the other.
  *
@@ -30,10 +30,10 @@ export declare const revertScale: (copy: RollCopy) => void;
  * way and without any gradient across the bar, which is measured but
  * too coarse to model from one roll.
  *
- * Only holes are touched. What a writing or a mark spans is no valve.
+ * Only chains of holes are touched. What a writing or a mark spans is no valve.
  */
 /**
- * The holes the extension cannot be taken off, being no longer than it
+ * The chains the extension cannot be taken off, being no longer than it
  * is: the reader reported them open for less time than it holds a valve
  * on beyond the perforation, so the constant over-corrects them and
  * would leave them ending before they begin.
@@ -41,23 +41,23 @@ export declare const revertScale: (copy: RollCopy) => void;
  * They are where the constant shows its limit rather than where the
  * copy is wrong, the extension varying by about half a millimetre with
  * the port. What to do with them is an editorial question — a condition
- * on the feature, a reading of the hole, a smaller extension — and
- * `shortenHoles` throws rather than answer it.
+ * on the feature, a reading of the chain, a smaller extension — and
+ * `shortenChains` throws rather than answer it.
  */
 export declare const tooShortToShorten: (extension: Millimeters, copy: RollCopy, leaving?: ReadonlySet<string>) => Readonly<FeatureOrPatch>[];
 /**
- * Takes the extension off, leaving the named holes as the reader gave
- * them. Naming a hole is an editorial act and not a repair: it says
+ * Takes the extension off, leaving the named chains as the reader gave
+ * them. Naming a chain is an editorial act and not a repair: it says
  * this one is where the constant stops applying, and the edition is
  * what has to say why. The copy records which were left, so that
- * putting the extension back does not lengthen a hole nothing was
+ * putting the extension back does not lengthen a chain nothing was
  * taken from.
  *
- * Throws where a hole that was not named is no longer than the
+ * Throws where a chain that was not named is no longer than the
  * extension, `tooShortToShorten` saying beforehand which those are.
  */
-export declare const shortenHoles: (extension: Millimeters, copy: RollCopy, leaving?: ReadonlySet<string>) => void;
-/** Puts the reader's extension back on the holes it was taken off, as far as one was taken off. */
+export declare const shortenChains: (extension: Millimeters, copy: RollCopy, leaving?: ReadonlySet<string>) => void;
+/** Puts the reader's extension back on the chains it was taken off, as far as one was taken off. */
 export declare const revertShortening: (copy: RollCopy) => void;
 /**
  * How a copy's places are carried onto another copy's:

package/lib/alignment.js

@@ -54,16 +54,16 @@ export const revertScale = (copy) => {
     copy.ops = copy.ops.filter(op => op !== 'stretched');
     delete copy.measurements.scale;
 };
-const holesOf = (copy) => featuresOf(copy).filter(feature => feature.type === 'Hole');
+const chainsOf = (copy) => featuresOf(copy).filter(feature => feature.type === 'HoleChain');
 /**
  * Takes the extension a pneumatic reader adds off the ends of the
- * copy's holes, and records how much was taken.
+ * copy's chains of holes, and records how much was taken.
  *
  * Such a reader reports how long a valve stayed open, and a valve is
- * held on past the perforation that opened it, so its holes run longer
- * than the punched slots while their onsets agree. Left in, the
+ * held on past the perforation that opened it, so its chains run longer
+ * than the punched ones while their onsets agree. Left in, the
  * difference is not a difference between copies at all: a collation
- * comparing this copy's hole ends against a scanned copy's compares a
+ * comparing this copy's chain ends against a scanned copy's compares a
  * pneumatic on-time with a punched slot, and reads the one as a
  * lengthening of the other.
  *
@@ -76,10 +76,10 @@ const holesOf = (copy) => featuresOf(copy).filter(feature => feature.type === 'H
  * way and without any gradient across the bar, which is measured but
  * too coarse to model from one roll.
  *
- * Only holes are touched. What a writing or a mark spans is no valve.
+ * Only chains of holes are touched. What a writing or a mark spans is no valve.
  */
 /**
- * The holes the extension cannot be taken off, being no longer than it
+ * The chains the extension cannot be taken off, being no longer than it
  * is: the reader reported them open for less time than it holds a valve
  * on beyond the perforation, so the constant over-corrects them and
  * would leave them ending before they begin.
@@ -87,46 +87,46 @@ const holesOf = (copy) => featuresOf(copy).filter(feature => feature.type === 'H
  * They are where the constant shows its limit rather than where the
  * copy is wrong, the extension varying by about half a millimetre with
  * the port. What to do with them is an editorial question — a condition
- * on the feature, a reading of the hole, a smaller extension — and
- * `shortenHoles` throws rather than answer it.
+ * on the feature, a reading of the chain, a smaller extension — and
+ * `shortenChains` throws rather than answer it.
  */
-export const tooShortToShorten = (extension, copy, leaving = new Set()) => holesOf(copy).filter(hole => !leaving.has(hole.id) && hole.horizontal.to - hole.horizontal.from <= extension);
+export const tooShortToShorten = (extension, copy, leaving = new Set()) => chainsOf(copy).filter(chain => !leaving.has(chain.id) && chain.horizontal.to - chain.horizontal.from <= extension);
 /**
- * Takes the extension off, leaving the named holes as the reader gave
- * them. Naming a hole is an editorial act and not a repair: it says
+ * Takes the extension off, leaving the named chains as the reader gave
+ * them. Naming a chain is an editorial act and not a repair: it says
  * this one is where the constant stops applying, and the edition is
  * what has to say why. The copy records which were left, so that
- * putting the extension back does not lengthen a hole nothing was
+ * putting the extension back does not lengthen a chain nothing was
  * taken from.
  *
- * Throws where a hole that was not named is no longer than the
+ * Throws where a chain that was not named is no longer than the
  * extension, `tooShortToShorten` saying beforehand which those are.
  */
-export const shortenHoles = (extension, copy, leaving = new Set()) => {
+export const shortenChains = (extension, copy, leaving = new Set()) => {
     if (copy.ops.includes('shortened'))
         return;
     const tooShort = tooShortToShorten(extension, copy, leaving);
     if (tooShort.length > 0) {
         throw new Error(`The extension of ${extension} mm cannot be taken off ${tooShort.length} `
-            + `hole(s) of copy ${copy.id}, which are no longer than it: `
-            + `${tooShort.map(hole => hole.id).join(', ')}`);
+            + `chain(s) of holes of copy ${copy.id}, which are no longer than it: `
+            + `${tooShort.map(chain => chain.id).join(', ')}`);
     }
-    const left = holesOf(copy).filter(hole => leaving.has(hole.id)).map(hole => hole.id);
-    holesOf(copy)
-        .filter(hole => !leaving.has(hole.id))
-        .forEach(hole => { hole.horizontal.to = subtract(hole.horizontal.to, extension); });
+    const left = chainsOf(copy).filter(chain => leaving.has(chain.id)).map(chain => chain.id);
+    chainsOf(copy)
+        .filter(chain => !leaving.has(chain.id))
+        .forEach(chain => { chain.horizontal.to = subtract(chain.horizontal.to, extension); });
     copy.ops = [...copy.ops, 'shortened'];
     copy.measurements.readerExtension = { length: extension, ...(left.length > 0 && { leaving: left }) };
 };
-/** Puts the reader's extension back on the holes it was taken off, as far as one was taken off. */
+/** Puts the reader's extension back on the chains it was taken off, as far as one was taken off. */
 export const revertShortening = (copy) => {
     const taken = copy.measurements.readerExtension;
     if (!copy.ops.includes('shortened') || taken === undefined)
         return;
     const left = new Set(taken.leaving ?? []);
-    holesOf(copy)
-        .filter(hole => !left.has(hole.id))
-        .forEach(hole => { hole.horizontal.to = add(hole.horizontal.to, taken.length); });
+    chainsOf(copy)
+        .filter(chain => !left.has(chain.id))
+        .forEach(chain => { chain.horizontal.to = add(chain.horizontal.to, taken.length); });
     copy.ops = copy.ops.filter(op => op !== 'shortened');
     delete copy.measurements.readerExtension;
 };
@@ -134,7 +134,7 @@ const byPlace = (x, y) => x.at - y.at || x.pitch - y.pitch;
 /** The notes the bar reads off the features, in the order they pass it. */
 const noteOnsets = (features, bar) => features
     .flatMap((feature) => {
-    if (feature.type !== 'Hole')
+    if (feature.type !== 'HoleChain')
         return [];
     return bar.meaningsOf(feature.vertical)
         .filter(meaning => meaning.type === 'note')

package/lib/editionOps.d.ts

@@ -43,11 +43,11 @@ export declare const alignCopy: (copyId: string, shift: Shift, scale: number, re
 export declare const unalignCopy: (copyId: string) => EditionOp;
 /**
  * Takes the extension a pneumatic reader adds off the ends of the
- * copy's holes, and records how much was taken, so that its lengths
+ * copy's chains of holes, and records how much was taken, so that their lengths
  * can be compared with a scanned copy's at all.
  */
 export declare const shortenCopy: (copyId: string, extension: Millimeters, leaving?: ReadonlySet<string>) => EditionOp;
-/** Puts the reader's extension back on the copy's holes. */
+/** Puts the reader's extension back on the copy's chains of holes. */
 export declare const unshortenCopy: (copyId: string) => EditionOp;
 /** States what the copy's features were read from, in place of any earlier statement. */
 export declare const stateSource: (copyId: string, source: FeatureSource) => EditionOp;
@@ -86,7 +86,7 @@ export declare const symbolsCarriedOnlyBy: (edition: Edition, copyId: string) =>
  * punched, being glued on, so `punched` says nothing of one.
  */
 export interface FeatureAct {
-    /** The copy came from its punching with it, which is where a reading of a scan puts every hole. */
+    /** The copy came from its punching with it, which is where a reading of a scan puts every chain of holes. */
     punched?: boolean;
     /** The act that brought this feature about brought the new one about as well. */
     beside?: string;

package/lib/editionOps.js

@@ -8,7 +8,7 @@ import { asSymbols, barOf, featuresByAct, featuresOf, isPaperStretch, statesNoth
 import { systemOf } from "./TrackerBar.js";
 import { substitutionsBetween } from "./substitution.js";
 import { trackerBarOf } from "./systems/index.js";
-import { applyShift, applyScale, revertShift, revertScale, revertShortening, shortenHoles } from "./alignment.js";
+import { applyShift, applyScale, revertShift, revertScale, revertShortening, shortenChains } from "./alignment.js";
 import { assignReference, idOf } from "./Assumption.js";
 import { conditions as conditionsAllowed, featuresBorneBy, isGluedOn, withBorneFeatures } from "./Feature.js";
 import { distance, mm, subtract } from "./Quantity.js";
@@ -138,11 +138,11 @@ export const unalignCopy = (copyId) => onCopy(copyId, copy => {
 });
 /**
  * Takes the extension a pneumatic reader adds off the ends of the
- * copy's holes, and records how much was taken, so that its lengths
+ * copy's chains of holes, and records how much was taken, so that their lengths
  * can be compared with a scanned copy's at all.
  */
-export const shortenCopy = (copyId, extension, leaving) => onCopy(copyId, copy => shortenHoles(extension, copy, leaving));
-/** Puts the reader's extension back on the copy's holes. */
+export const shortenCopy = (copyId, extension, leaving) => onCopy(copyId, copy => shortenChains(extension, copy, leaving));
+/** Puts the reader's extension back on the copy's chains of holes. */
 export const unshortenCopy = (copyId) => onCopy(copyId, copy => revertShortening(copy));
 /** States what the copy's features were read from, in place of any earlier statement. */
 export const stateSource = (copyId, source) => onCopy(copyId, copy => {

package/lib/migrate.js

@@ -33,6 +33,8 @@ const withTypology = (node) => {
     }
     return node;
 };
+/** A chain of holes written while its class was named after a single hole. */
+const withHoleChainType = (node) => node['@type'] === 'Hole' ? { ...node, '@type': 'HoleChain' } : node;
 /** A version once stated whether it served as a master or stood on one copy. */
 const withoutVersionType = (node) => {
     if (!Object.hasOwn(node, 'versionType'))
@@ -119,11 +121,15 @@ const withScale = (node) => {
 };
 /** 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. The perforator is named
- * after the copy, so that a file migrated twice names it the same way.
+ * for one nobody had measured and is left out.
  */
 const withPerforator = (node) => {
     const diameter = node.measurements?.punchDiameter;
@@ -132,7 +138,7 @@ const withPerforator = (node) => {
     const { punchDiameter: _moved, ...measurements } = node.measurements;
     if (!(diameter?.value > 0))
         return { ...node, measurements };
-    const perforator = node.production?.perforator ?? { '@id': `perforator_${plainCopyId(node['@id'])}` };
+    const perforator = perforatorOf(node);
     return {
         ...node,
         measurements,
@@ -150,6 +156,37 @@ const withPerforator = (node) => {
         }
     };
 };
+/** 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 chain once stated its punching pattern. A staggering chain 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'] !== 'HoleChain' || !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;
@@ -158,13 +195,14 @@ const featuresOf = (copy) => [
     ...(Array.isArray(copy.features) ? copy.features : []),
     ...(Array.isArray(copy.production?.produced) ? copy.production.produced : [])
 ];
+/** A chain of holes under either name, since a node is migrated before its children are. */
+const isHoleChain = (feature) => feature?.['@type'] === 'HoleChain' || feature?.['@type'] === 'Hole';
 /**
  * A copy read on a roll reader was stated as a recording before a sound
  * recording could be one. A sound recording gives no holes, so a recording
  * with holes is a reading.
  */
-const withReadingKind = (node) => node.readFrom?.kind === 'recording'
-    && featuresOf(node).some((feature) => feature?.['@type'] === 'Hole')
+const withReadingKind = (node) => node.readFrom?.kind === 'recording' && featuresOf(node).some(isHoleChain)
     ? { ...node, readFrom: { ...node.readFrom, kind: 'reading' } }
     : node;
 /** A feature written while the kind of a feature was a type beside its class. */
@@ -265,9 +303,9 @@ const withTimeSpanDates = (node) => {
     const { '@value': within, '@type': _typed, ...rest } = node;
     return { ...rest, within };
 };
-const migrateNode = (node) => [withRenamedKeys, withTypology, withoutVersionType, withoutVersionSiglum, withLowerCaseTerms, withSplitMethod, withReferences, withKeeper, withoutEmptyKeeper,
-    withPerforator, withProductionNodes, withScale, withDerivationList, withReadingKind, withTimeSpanDates, withoutFeatureKind,
-    withBorneFeaturesNamed, withFeaturesInActs]
+const migrateNode = (node) => [withRenamedKeys, withTypology, withHoleChainType, withoutVersionType, withoutVersionSiglum, withLowerCaseTerms, withSplitMethod, withReferences, withKeeper, withoutEmptyKeeper,
+    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/phillipsEroll.d.ts

@@ -14,17 +14,17 @@ import { Millimeters, Seconds } from "../Quantity.js";
  * elapsed time, not paper, and the take-up spool accelerates the paper
  * as it fills, so `placeAt` has to put the time back onto the paper.
  * And a switch stays open longer than its perforation is long, so a
- * hole read here runs past the punched one: Phillips measures the
+ * chain read here runs past the punched one: Phillips measures the
  * pneumatic on-time as exceeding the apparent length of a perforation
  * (p. 178), and names what it depends on as the length of the
  * perforation, the height of the tracker bar hole and the paper speed
  * (p. 180).
  *
  * Left in, that extension is not a difference between copies at all:
- * the end of a hole here is a pneumatic on-time where the end of a
- * scanned copy's hole is a punched slot, so a collation comparing the
+ * the end of a chain here is a pneumatic on-time where the end of a
+ * scanned copy's chain is a punched slot, so a collation comparing the
  * two reads the one as a lengthening of the other. `extension` takes it
- * off at the end of every hole, and the copy records what was taken.
+ * off at the end of every chain, and the copy records what was taken.
  *
  * How much to take off is measured rather than derived, since he gives
  * only the 0.5 mm by which the Welte bar's holes exceed the Licensee's
@@ -71,8 +71,8 @@ export interface PhillipsErollOptions {
     placeAt?: (elapsed: Seconds) => Millimeters;
     /**
      * How much longer a valve is held on than the perforation that
-     * opened it, taken off the end of every hole so that these lengths
-     * can be compared with a scanned copy's. Nothing leaves the holes
+     * opened it, taken off the end of every chain so that these lengths
+     * can be compared with a scanned copy's. Nothing leaves the chains
      * as the reader reported them, which is what every copy read before
      * this option existed states.
      *

package/lib/readers/phillipsEroll.js

@@ -2,7 +2,7 @@ import { read } from "midifile-ts";
 import { v4 } from "uuid";
 import { assignObject } from "../Assumption.js";
 import { systemOf } from "../TrackerBar.js";
-import { shortenHoles } from "../alignment.js";
+import { shortenChains } from "../alignment.js";
 import { welteT100 } from "../systems/welteT100/bar.js";
 import { welteLicensee } from "../systems/welteLicensee/bar.js";
 import { inMetersPerMinute, mm, seconds, track } from "../Quantity.js";
@@ -19,17 +19,17 @@ import { inMetersPerMinute, mm, seconds, track } from "../Quantity.js";
  * elapsed time, not paper, and the take-up spool accelerates the paper
  * as it fills, so `placeAt` has to put the time back onto the paper.
  * And a switch stays open longer than its perforation is long, so a
- * hole read here runs past the punched one: Phillips measures the
+ * chain read here runs past the punched one: Phillips measures the
  * pneumatic on-time as exceeding the apparent length of a perforation
  * (p. 178), and names what it depends on as the length of the
  * perforation, the height of the tracker bar hole and the paper speed
  * (p. 180).
  *
  * Left in, that extension is not a difference between copies at all:
- * the end of a hole here is a pneumatic on-time where the end of a
- * scanned copy's hole is a punched slot, so a collation comparing the
+ * the end of a chain here is a pneumatic on-time where the end of a
+ * scanned copy's chain is a punched slot, so a collation comparing the
  * two reads the one as a lengthening of the other. `extension` takes it
- * off at the end of every hole, and the copy records what was taken.
+ * off at the end of every chain, and the copy records what was taken.
  *
  * How much to take off is measured rather than derived, since he gives
  * only the 0.5 mm by which the Welte bar's holes exceed the Licensee's
@@ -153,7 +153,7 @@ export function readFromPhillipsEroll(buffer, { system = welteT100, controlOffse
         if (!system.meaningOf(position))
             return [];
         return [{
-                type: 'Hole',
+                type: 'HoleChain',
                 id: v4(),
                 vertical: { from: position, unit: 'track' },
                 horizontal: {
@@ -174,11 +174,11 @@ export function readFromPhillipsEroll(buffer, { system = welteT100, controlOffse
         readFrom: {
             kind: 'reading',
             actor: assignObject({ name: 'Phillips, Peter', sameAs: [] }),
-            note: 'Read on Phillips’s pneumatic roll reader. The places are elapsed time put back onto the paper, and a hole runs as long as its switch stayed open, which is longer than the perforation.'
+            note: 'Read on Phillips’s pneumatic roll reader. The places are elapsed time put back onto the paper, and a chain of holes runs as long as its switch stayed open, which is longer than the perforation.'
         }
     };
     if (extension !== undefined)
-        shortenHoles(extension, copy);
+        shortenChains(extension, copy);
     return copy;
 }
 /** The bars his files are known to be numbered by. */

package/lib/readers/spencerBar.d.ts

@@ -19,7 +19,7 @@ export interface SpencerBarOptions {
 }
 /**
  * Reads the copy on the bar it was cut for, whose numbering it keeps.
- * A hole on a position that bar does not read is left out, as the bar
+ * A chain on a position that bar does not read is left out, as the bar
  * would leave it.
  */
 export declare function readFromSpencerBar(buffer: ArrayBuffer, { rowsPerInch, system }?: SpencerBarOptions): RollCopy;

package/lib/readers/spencerBar.js

@@ -80,7 +80,7 @@ const holesOf = (events) => {
 };
 /**
  * Reads the copy on the bar it was cut for, whose numbering it keeps.
- * A hole on a position that bar does not read is left out, as the bar
+ * A chain on a position that bar does not read is left out, as the bar
  * would leave it.
  */
 export function readFromSpencerBar(buffer, { rowsPerInch = SPENCER_ROWS_PER_INCH, system = welteLicensee } = {}) {
@@ -95,7 +95,7 @@ export function readFromSpencerBar(buffer, { rowsPerInch = SPENCER_ROWS_PER_INCH
         if (!system.meaningOf(position))
             return [];
         return [{
-                type: 'Hole',
+                type: 'HoleChain',
                 id: v4(),
                 vertical: {
                     from: position,

package/lib/readers/stanfordAton.js

@@ -136,7 +136,7 @@ export function readFromStanfordAton(atonString, { trackShift, system = welteT10
         const column = readPx(hole.ORIGIN_COL);
         const columnWidth = readPx(hole.WIDTH_COL);
         return [{
-                type: 'Hole',
+                type: 'HoleChain',
                 id: v4(),
                 ...(stanford && {
                     depiction: stanford.depictionOf(column, attack, columnWidth, subtract(release, attack))
@@ -161,6 +161,7 @@ export function readFromStanfordAton(atonString, { trackShift, system = welteT10
             system: systemOf(system),
             ...(punchDiameter !== undefined && {
                 perforator: {
+                    type: 'Perforator',
                     id: `perforator_${v4()}`,
                     condition: {
                         type: 'ConditionState',

package/lib/schema.json

@@ -78,7 +78,7 @@
         "AnyFeature": {
             "anyOf": [
                 {
-                    "$ref": "#/definitions/Hole"
+                    "$ref": "#/definitions/HoleChain"
                 },
                 {
                     "$ref": "#/definitions/Writing"
@@ -87,7 +87,7 @@
                     "$ref": "#/definitions/Mark"
                 }
             ],
-            "description": "The features proper: a hole, a writing and a mark are all human-made features, and each of them is borne by whatever it sits on. A patch is an object glued onto the paper and stands apart from them."
+            "description": "The features proper: a chain of holes, a writing and a mark are all human-made features, and each of them is borne by whatever it sits on. A patch is an object glued onto the paper and stands apart from them."
         },
         "AnySymbol": {
             "anyOf": [
@@ -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": {
@@ -681,7 +688,7 @@
                     "ontology": "reo:before"
                 },
                 "carriers": {
-                    "description": "References to the physical features (e.g. holes) on the roll copies that carry this symbol. Since the association might be debatable, it can be annotated. There might be e.g. doubts about the meaning and correct transcription of a feature on a physical roll. This points to a feature by its `@id`.",
+                    "description": "References to the physical features (e.g. chains of holes) on the roll copies that carry this symbol. Since the association might be debatable, it can be annotated. There might be e.g. doubts about the meaning and correct transcription of a feature on a physical roll. This points to a feature by its `@id`.",
                     "items": {
                         "$ref": "#/definitions/ReferenceAssumption"
                     },
@@ -877,8 +884,8 @@
             "type": "object",
             "ontology": "reo:GluedOn"
         },
-        "Hole": {
-            "description": "A hole (perforation) in the roll paper. Holes are the primary carriers of musical information on piano rolls, as they trigger notes and expression controls when passing over the tracker bar. A punched hole is a human-made feature: CRM counts \"the information encoding features on mechanical or digital carriers\" among the features purposely created by human activity.",
+        "HoleChain": {
+            "description": "A chain of holes punched along the roll, which the tracker bar reads as it passes. The perforator cuts a held note or function as a row of punches with bridges of paper left between them, so most perforations are chains; one without a bridge is a chain of a single hole. The holes are the chain's parts and are not stated one by one. A punched chain is a human-made feature: CRM counts \"the information encoding features on mechanical or digital carriers\" among the features purposely created by human activity.",
             "properties": {
                 "condition": {
                     "$ref": "#/definitions/ObjectAssumption%3CConditionState%3C(%22partially-torn%22%7C%22missing-perforation%22)%3E%3E",
@@ -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.",
@@ -915,7 +912,7 @@
                     "type": "string"
                 },
                 "@type": {
-                    "const": "Hole",
+                    "const": "HoleChain",
                     "description": "The type discriminator for this object.",
                     "type": "string",
                     "ontology": "rdf:type"
@@ -928,7 +925,7 @@
                 "vertical"
             ],
             "type": "object",
-            "ontology": "reo:Hole"
+            "ontology": "reo:HoleChain"
         },
         "HorizontalSpan": {
             "description": "Describes the horizontal extent of a feature on the roll, measured in millimeters from the beginning of the roll. The `from` value is the start position and `to` is the end position.",
@@ -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.",
@@ -1468,7 +1455,7 @@
                             "type": "string"
                         },
                         "@type": {
-                            "const": "Hole",
+                            "const": "HoleChain",
                             "description": "The type discriminator for this object.",
                             "type": "string",
                             "ontology": "rdf:type"
@@ -1716,7 +1703,7 @@
                     "ontology": "reo:before"
                 },
                 "carriers": {
-                    "description": "References to the physical features (e.g. holes) on the roll copies that carry this symbol. Since the association might be debatable, it can be annotated. There might be e.g. doubts about the meaning and correct transcription of a feature on a physical roll. This points to a feature by its `@id`.",
+                    "description": "References to the physical features (e.g. chains of holes) on the roll copies that carry this symbol. Since the association might be debatable, it can be annotated. There might be e.g. doubts about the meaning and correct transcription of a feature on a physical roll. This points to a feature by its `@id`.",
                     "items": {
                         "$ref": "#/definitions/ReferenceAssumption"
                     },
@@ -2294,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": {
@@ -2666,13 +2685,25 @@
                     "$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"
+                "@id",
+                "@type"
             ],
             "type": "object",
             "ontology": "crm:E22 Human-Made Object"
@@ -2773,11 +2804,11 @@
                 },
                 "perforator": {
                     "$ref": "#/definitions/Perforator",
-                    "description": "The perforator the copy was punched on, with the setting its perforations show.",
+                    "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.",
+                    "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 chain of holes 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": {
                         "$ref": "#/definitions/AnyFeature"
                     },
@@ -3033,10 +3064,10 @@
                             "ontology": "crmdig:L23 used software or firmware"
                         },
                         "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.",
+                            "description": "What a pneumatic reader added to this copy's chains of 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 chains are overlong by a constant while its onsets agree. Nothing for a copy read by other means, whose chains are the punched ones themselves. Not exported to RDF.",
                             "properties": {
                                 "leaving": {
-                                    "description": "The holes it was not taken off, by `@id`, being no longer than it is. The constant reaches its limit there rather than the copy being wrong, and why they were left is for the edition to state about the features themselves; this only records that they stand as the reader gave them, so that putting the extension back does not lengthen a hole nothing was taken from.",
+                                    "description": "The chains it was not taken off, by `@id`, being no longer than it is. The constant reaches its limit there rather than the copy being wrong, and why they were left is for the edition to state about the features themselves; this only records that they stand as the reader gave them, so that putting the extension back does not lengthen a chain nothing was taken from.",
                                     "items": {
                                         "type": "string"
                                     },
@@ -3044,7 +3075,7 @@
                                 },
                                 "length": {
                                     "$ref": "#/definitions/Millimeters",
-                                    "description": "How much longer the reading of a hole ran than the perforation that caused it."
+                                    "description": "How much longer the reading of a chain ran than the perforation that caused it."
                                 }
                             },
                             "required": [
@@ -3227,7 +3258,7 @@
             "description": "A textual symbol, e.g. a label or annotation found on the roll.",
             "properties": {
                 "carriers": {
-                    "description": "References to the physical features (e.g. holes) on the roll copies that carry this symbol. Since the association might be debatable, it can be annotated. There might be e.g. doubts about the meaning and correct transcription of a feature on a physical roll. This points to a feature by its `@id`.",
+                    "description": "References to the physical features (e.g. chains of holes) on the roll copies that carry this symbol. Since the association might be debatable, it can be annotated. There might be e.g. doubts about the meaning and correct transcription of a feature on a physical roll. This points to a feature by its `@id`.",
                     "items": {
                         "$ref": "#/definitions/ReferenceAssumption"
                     },

package/lib/spec/context.json

@@ -14,13 +14,14 @@
         "Edition": "lrmoo:F2_Expression",
         "Version": "lrmoo:F2_Expression",
         "RollCopy": "reo:RollCopy",
-        "Hole": "reo:Hole",
+        "HoleChain": "reo:HoleChain",
         "Mark": "reo:Mark",
         "Writing": "reo:Writing",
         "GluedOn": "reo:GluedOn",
         "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",
@@ -192,6 +193,7 @@
                 }
             }
         },
+        "drive": "reo:drive",
         "company": "crm:P14_carried_out_by",
         "paper": "crm:P126_employed",
         "conditions": "crm:P44_has_condition",
@@ -249,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.53.0",
+  "version": "0.55.0",
   "description": "Digital editions of piano rolls: import, collation, editorial assumptions, JSON-LD export, and emulation through a reproducing system",
   "license": "MIT",
   "repository": {