linked-rolls 0.54.0 → 0.56.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,12 +53,12 @@ export interface VerticalSpan {
      */
     to?: Track;
 }
-export declare const featureTypes: readonly ['Hole', 'Writing', 'Mark', 'GluedOn'];
+export declare const featureTypes: readonly ['HoleChain', 'Writing', 'Mark', 'Patch'];
 export type FeatureType = typeof featureTypes[number];
 export declare const isFeatureType: (value: unknown) => value is FeatureType;
 /**
  * A feature on the roll, e.g. a perforation, a writing, a mark or a
- * glued-on patch, defined by its horizontal and vertical position and
+ * patch, defined by its horizontal and vertical position and
  * extent. Each kind of feature is a class of its own, which its type
  * names.
  */
@@ -86,10 +86,10 @@ 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"];
+    readonly Patch: readonly ["detaching", "ripped"];
 };
 /** The kinds of condition a feature may be in, whichever kind of feature it is. */
 export type FeatureConditionType = typeof conditions[FeatureType][number];
@@ -100,19 +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]> {
+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 {
     /**
@@ -189,15 +191,14 @@ export interface Writing extends Trace<'Writing'> {
 export interface Mark extends Trace<'Mark'> {
 }
 /**
- * A piece of material (paper or tape) glued onto the roll surface.
- * Glued-on features are typically used to cover perforations (for corrections)
- * or to reinforce damaged areas. They may themselves carry other features
- * such as writings or additional holes.
- * @see reo:GluedOn
+ * A piece of paper or tape glued onto the roll: a label naming it, a
+ * strip covering perforations, or a patch reinforcing a tear. A patch
+ * may itself carry other features, such as writings or holes.
+ * @see reo:Patch
  */
-export interface GluedOn extends RollFeature<'GluedOn', typeof conditions.GluedOn[number]>, OnAFace {
+export interface Patch extends RollFeature<'Patch', typeof conditions.Patch[number]>, OnAFace {
     /**
-     * The material of the glued-on feature.
+     * What the patch is made of.
      * @see crm:P45 consists of
      */
     material: 'paper' | 'tape';
@@ -209,24 +210,24 @@ export interface GluedOn extends RollFeature<'GluedOn', typeof conditions.GluedO
      */
     rotation?: Measure<'deg'>;
     /**
-     * A glued-on feature itself may carry other features.
-     * Nested features do not need to be positioned explicitly.
+     * The features the patch itself carries. They need not be
+     * positioned explicitly.
      * @see crm:P46 is composed of
      */
     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
- * under, E22 and E25 being its subclasses.
+ * patch. E24 Physical Human-Made Thing is the class both fall under,
+ * E22 and E25 being its subclasses.
  */
-export type FeatureOrPatch = AnyFeature | GluedOn;
+export type FeatureOrPatch = AnyFeature | Patch;
 /**
  * A feature without the place it would state of its own. The union is
  * distributed over, so that each kind of feature keeps its own keys.
@@ -238,7 +239,7 @@ type Unplaced<T> = T extends FeatureOrPatch ? PartialBy<T, 'horizontal' | 'verti
  */
 export type NestedFeature = Unplaced<FeatureOrPatch>;
 export declare const isRollFeature: (obj: object) => obj is FeatureOrPatch;
-export declare const isGluedOn: <T extends NestedFeature>(feature: T) => feature is T & GluedOn;
+export declare const isPatch: <T extends NestedFeature>(feature: T) => feature is T & Patch;
 /** The features a feature bears: a patch those stated as parts of it, any other feature none. */
 export declare const featuresBorneBy: (feature: NestedFeature) => NestedFeature[];
 /** The feature together with everything it bears, as deep as a patch on a patch goes. */

package/lib/Feature.js

@@ -1,18 +1,18 @@
-export const featureTypes = ['Hole', 'Writing', 'Mark', 'GluedOn'];
+export const featureTypes = ['HoleChain', 'Writing', 'Mark', 'Patch'];
 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']
+    Patch: ['detaching', 'ripped']
 };
 export const techniques = ['print', 'handwriting', 'stamp'];
 export const media = ['ink', 'pencil', 'crayon'];
 export const isRollFeature = (obj) => {
     return 'type' in obj && isFeatureType(obj.type);
 };
-export const isGluedOn = (feature) => feature.type === 'GluedOn';
+export const isPatch = (feature) => feature.type === 'Patch';
 /** The features a feature bears: a patch those stated as parts of it, any other feature none. */
-export const featuresBorneBy = (feature) => isGluedOn(feature) ? feature.features ?? [] : [];
+export const featuresBorneBy = (feature) => isPatch(feature) ? feature.features ?? [] : [];
 /** The feature together with everything it bears, as deep as a patch on a patch goes. */
 export const withBorneFeatures = (feature) => [feature, ...featuresBorneBy(feature).flatMap(withBorneFeatures)];

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/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

@@ -2,7 +2,7 @@ import { ConditionState } from "./ConditionState.js";
 import { AnySymbol } from "./Symbol.js";
 import { TrackerBar } from "./TrackerBar.js";
 import { TrackCalibration } from "./TrackCalibration.js";
-import { AnyFeature, FeatureOrPatch, GluedOn } from "./Feature.js";
+import { AnyFeature, FeatureOrPatch, Patch } from "./Feature.js";
 import { ActorAssignment, DateAssignment, ObjectAssumption, ReferenceAssumption } from "./Assumption.js";
 import { WithId, WithType } from "./utils.js";
 import { Agent, Concept } from "./Agent.js";
@@ -124,10 +124,10 @@ export interface ProductionEvent {
     /**
      * 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[];
@@ -161,7 +161,7 @@ export type Modification = Partial<{
      * The patches glued onto the copy, each with whatever it bears.
      * @see crm:P111 added
      */
-    added: GluedOn[];
+    added: Patch[];
     /**
      * @see crm:P21 had general purpose
      */
@@ -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/asJsonLd.js

@@ -73,7 +73,7 @@ const madeOn = (copy) => [
     ...nodesIn(copy.production?.produced),
     ...nodesIn(copy.modifications).flatMap(act => [...nodesIn(act.produced), ...nodesIn(act.added)])
 ];
-const referencing = (nodes, patches) => nodes.filter(node => (node['@type'] === 'GluedOn') === patches && typeof node['@id'] === 'string')
+const referencing = (nodes, patches) => nodes.filter(node => (node['@type'] === 'Patch') === patches && typeof node['@id'] === 'string')
     .map(node => ({ '@id': node['@id'] }));
 const featuresAmong = (nodes) => referencing(nodes, false);
 const patchesAmong = (nodes) => referencing(nodes, true);
@@ -112,7 +112,7 @@ const withBearings = (value) => {
             ...stating('composedOf', patchesAmong(made))
         };
     }
-    if (node['@type'] === 'GluedOn')
+    if (node['@type'] === 'Patch')
         return { ...node, ...stating('bears', featuresAmong(nodesIn(node.features))) };
     return node;
 };

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;