linked-rolls 0.3.0 → 0.4.1

package/README.md

@@ -69,20 +69,28 @@ reads editions does not need it. For development on both at once, a
 checkout of [welte-t100](https://github.com/pfefferniels/welte-t100)
 beside this repository, declared as `file:../welte-t100`, works too.
 
-### Alignment and pairing
+### Alignment, order and pairing
 
-A perforation takes its place from the holes that carry it. Two fields
+A perforation takes its place from the holes that carry it. Four fields
 on a perforation let an editor state where the measurement should give
 way. `alignedWith` names another perforation whose onset this one takes
 in the performance, as a "crescendo off" is meant to fall on the note
-it belongs to. `pairedWith` names a partner whose distance to this one
-is fixed, as a "forzando on" belongs with its "forzando off": whatever
-displaces the one displaces the other. Any two perforations may be
-paired, the relation is symmetric, and it is stated on one side only.
-Both are applied when a version is emulated. `constraintProblems` lists,
-version by version, the cases in which the statements cannot hold: a
-reference or partner that is absent, a perforation claimed by several
-pairs, or a pair whose members are both aligned.
+it belongs to. `before` and `after` name a perforation whose onset this
+one precedes or follows, without saying by how much: where the copies
+disagree on which side of a note an expression falls, the statement
+settles the order. A perforation the measurement already has on the
+stated side keeps its place. One it does not is put on that side, as
+far from the reference as the copies that agree with the statement put
+it, and a punch diameter away where none does. A perforation makes one
+of these three statements at most. `pairedWith` names a partner whose
+distance to this one is fixed, as a "forzando on" belongs with its
+"forzando off": whatever displaces the one displaces the other. Any two
+perforations may be paired, the relation is symmetric, and it is stated
+on one side only. All are applied when a version is emulated.
+`constraintProblems` lists, version by version, the cases in which the
+statements cannot hold: a reference or partner that is absent, a
+perforation placed relative to itself or in several ways at once, one
+claimed by several pairs, or a pair whose members are both placed.
 
 ## Building
 ```

package/lib/Emulation.d.ts

@@ -22,7 +22,13 @@ export declare class Emulation<Options extends object> {
     curves: readonly EmulatedCurve[];
     source?: string;
     constructor(system: ReproducingSystem<Options>, options?: Options);
-    applyConstraints(): void;
+    /**
+     * Moves the negotiated events to where their statements put them.
+     * The view supplies the copies, whose measurements decide how far
+     * before or after its reference a perforation goes, and a punch
+     * diameter, or a millimetre, where no copy agrees with a statement.
+     */
+    applyConstraints(view: EditionView): void;
     emulateVersion(version: Version, view: EditionView, { range, skipToFirstNote }?: EmulationScope): AnyPerformedRollFeature[];
     findEventsPerforming(id: string): AnyPerformedRollFeature[];
     asMIDI(): MidiFile;

package/lib/Emulation.js

@@ -1,6 +1,6 @@
 import { MIDIControlEvents } from "midifile-ts";
 import { idOf } from "./Assumption";
-import { pairsAmong } from "./Symbol";
+import { pairsAmong, placementsOf } from "./Symbol";
 /** The punch diameter the edition's copies report, where any of them does. */
 const punchDiameterOf = (view) => {
     const measured = view.edition.copies
@@ -14,24 +14,70 @@ const propertiesOf = (view) => ({
     punchDiameter: punchDiameterOf(view),
     tempo: view.edition.tempoAdjustment
 });
+const mean = (values) => values.reduce((sum, value) => sum + value, 0) / values.length;
+/** The onset a symbol has on each copy carrying it, by the copy's index, as the mean of its holes there. */
+const onsetsByCopy = (view, symbolId) => {
+    const symbol = view.get(symbolId);
+    if (!symbol)
+        return new Map();
+    const onsets = view.carriersOf(symbol).flatMap((carrier) => {
+        const copy = view.getPath(carrier.id)?.[1];
+        return typeof copy === 'number' ? [[copy, carrier.horizontal.from]] : [];
+    });
+    const copies = new Set(onsets.map(([copy]) => copy));
+    return new Map([...copies].map(copy => [copy, mean(onsets.filter(([at]) => at === copy).map(([, onset]) => onset))]));
+};
+/**
+ * The measured distance from the onset of the reference to the onset of
+ * the follower on each copy carrying both, negative where the follower
+ * comes first there.
+ */
+const offsetsBetween = (view, followerId, referenceId) => {
+    const references = onsetsByCopy(view, referenceId);
+    return [...onsetsByCopy(view, followerId)].flatMap(([copy, onset]) => {
+        const reference = references.get(copy);
+        return reference === undefined ? [] : [onset - reference];
+    });
+};
 /**
- * How far each event has to move, in mm, for the alignments to hold:
- * an aligned event takes the onset of its reference, and a paired
- * event follows its partner so that the distance between the two
- * is kept. Events that stay where they are do not appear.
+ * How far before or after its reference a follower is put when the
+ * measurement does not already have it there: as far as the copies
+ * that agree with the statement put it, and one gap where none does.
  */
-const displacementsOf = (events) => {
+const distanceOnSide = (side, offsets, gap) => {
+    const agreeing = offsets
+        .filter(offset => side === 'before' ? offset < 0 : offset > 0)
+        .map(Math.abs);
+    return agreeing.length > 0 ? mean(agreeing) : gap;
+};
+/**
+ * How far each event has to move, in mm, for the placements to hold:
+ * an aligned event takes the onset of its reference, one placed before
+ * or after its reference keeps its place where the measurement has it
+ * on that side and is moved there where it does not, and a paired
+ * event follows its partner so that the distance between the two is
+ * kept. Events that stay where they are do not appear.
+ */
+const displacementsOf = (events, offsetsBetween, gap) => {
     const byId = new Map(events.map(event => [event.id, event]));
-    const referenceOf = (event) => event.alignedWith && byId.get(idOf(event.alignedWith));
-    const alignedOnsetOf = (event, visited = new Set()) => {
-        const reference = referenceOf(event);
-        if (!reference || visited.has(event.id))
-            return event.horizontal.from;
-        return alignedOnsetOf(reference, visited.add(event.id));
+    /** Where an event comes to lie once its statement and those of its references hold. */
+    const placedOnsetOf = (event, visited = new Set()) => {
+        const measured = event.horizontal.from;
+        const placement = placementsOf(event)[0];
+        const reference = placement && byId.get(idOf(placement.reference));
+        if (!placement || !reference || reference.id === event.id || visited.has(event.id))
+            return measured;
+        const referenceOnset = placedOnsetOf(reference, new Set([...visited, event.id]));
+        const distance = (side) => distanceOnSide(side, offsetsBetween(event.id, reference.id), gap);
+        switch (placement.relation) {
+            case 'alignedWith': return referenceOnset;
+            case 'before': return measured < referenceOnset ? measured : referenceOnset - distance('before');
+            case 'after': return measured > referenceOnset ? measured : referenceOnset + distance('after');
+        }
     };
     const displacements = new Map(events
-        .filter(event => referenceOf(event) !== undefined)
-        .map((event) => [event, alignedOnsetOf(event) - event.horizontal.from]));
+        .map((event) => [event, placedOnsetOf(event) - event.horizontal.from])
+        .filter(([, distance]) => distance !== 0));
     pairsAmong(events).forEach(([one, other]) => {
         const shared = displacements.get(one) ?? displacements.get(other);
         if (shared === undefined)
@@ -89,8 +135,16 @@ export class Emulation {
         this.system = system;
         this.options = options;
     }
-    applyConstraints() {
-        displacementsOf(this.negotiatedEvents).forEach((distance, event) => {
+    /**
+     * Moves the negotiated events to where their statements put them.
+     * The view supplies the copies, whose measurements decide how far
+     * before or after its reference a perforation goes, and a punch
+     * diameter, or a millimetre, where no copy agrees with a statement.
+     */
+    applyConstraints(view) {
+        const gap = punchDiameterOf(view) ?? 1;
+        const offsets = (follower, reference) => offsetsBetween(view, follower, reference);
+        displacementsOf(this.negotiatedEvents, offsets, gap).forEach((distance, event) => {
             event.horizontal.from += distance;
             event.horizontal.to += distance;
         });
@@ -118,7 +172,7 @@ export class Emulation {
             this.curves = [];
             return this.midiEvents;
         }
-        this.applyConstraints();
+        this.applyConstraints(view);
         const performance = this.system.perform(this.negotiatedEvents, this.options, propertiesOf(view));
         this.curves = performance.curves;
         const onsets = performance.events.filter(event => event.type === 'noteOn').map(event => event.at);

package/lib/Plan.d.ts

@@ -1,6 +1,7 @@
 import { Draft } from "immer";
 import { EditionView } from "./EditionView";
 import { Edition } from "./Edition";
+import { AnySymbol } from "./Symbol";
 import { CollationTolerance } from "./Collation";
 import { Edit } from "./Edit";
 import { RollCopy } from "./RollCopy";
@@ -175,6 +176,13 @@ export declare class RemoveFeature extends BasePlan {
     constructor(copyID: string, featureIDs: string[]);
     build(): EditionOp[];
 }
+/** The symbols of the versions that no other copy carries. */
+export declare const symbolsCarriedOnlyBy: (edition: Edition, copyId: string) => AnySymbol[];
+/**
+ * Takes the copy out of the edition together with the symbols only it
+ * carries, and with every reference the versions made to those symbols.
+ */
+export declare const removeCopy: (copyId: string) => EditionOp;
 export declare class MergeEdits extends BasePlan {
     private versionId;
     private toMerge;

package/lib/Plan.js

@@ -1,4 +1,5 @@
 import { getAt } from "./EditionView";
+import { isPerforation, placementRelations } from "./Symbol";
 import { v4 } from "uuid";
 import { asSymbols } from "./RollCopy";
 import { assignReference, idOf } from "./Assumption";
@@ -378,6 +379,60 @@ export class RemoveFeature extends BasePlan {
         ];
     }
 }
+const featureIdsOf = (copy) => new Set(copy.features.map(feature => feature.id));
+const insertedIn = (versions) => versions.flatMap(version => version.edits).flatMap(edit => edit.insert ?? []);
+/**
+ * A symbol every carrier of which lies on the copy loses its evidence
+ * with the copy. A symbol without carriers, such as a label, stands
+ * on its own.
+ */
+const carriedOnlyOn = (features) => (symbol) => symbol.carriers.length > 0 && symbol.carriers.every(carrier => features.has(idOf(carrier)));
+/** The symbols of the versions that no other copy carries. */
+export const symbolsCarriedOnlyBy = (edition, copyId) => {
+    const copy = edition.copies.find(c => c.id === copyId);
+    return copy ? insertedIn(edition.versions).filter(carriedOnlyOn(featureIdsOf(copy))) : [];
+};
+const references = [...placementRelations, 'pairedWith'];
+const forgetPerforations = (perforation, dropped) => references
+    .filter(relation => {
+    const reference = perforation[relation];
+    return reference && dropped.has(idOf(reference));
+})
+    .forEach(relation => { delete perforation[relation]; });
+const forgetFeatures = (symbol, features, dropped) => {
+    symbol.carriers = symbol.carriers.filter(carrier => !features.has(idOf(carrier)));
+    if (isPerforation(symbol))
+        forgetPerforations(symbol, dropped);
+};
+const forgetCopy = (edit, features, dropped) => {
+    if (edit.insert) {
+        edit.insert = edit.insert.filter(symbol => !dropped.has(symbol.id));
+        edit.insert.forEach(symbol => forgetFeatures(symbol, features, dropped));
+    }
+    if (edit.delete) {
+        edit.delete = edit.delete.filter(id => !dropped.has(id));
+    }
+};
+const isEmpty = (edit) => !edit.insert?.length && !edit.delete?.length;
+/** Drops the edits the removal has emptied and leaves those that were empty before alone. */
+const forgetCopyIn = (version, features, dropped) => {
+    const emptyBefore = new Set(version.edits.filter(isEmpty).map(edit => edit.id));
+    version.edits.forEach(edit => forgetCopy(edit, features, dropped));
+    version.edits = version.edits.filter(edit => !isEmpty(edit) || emptyBefore.has(edit.id));
+};
+/**
+ * Takes the copy out of the edition together with the symbols only it
+ * carries, and with every reference the versions made to those symbols.
+ */
+export const removeCopy = (copyId) => draft => {
+    const copy = draft.copies.find(c => c.id === copyId);
+    if (!copy)
+        return;
+    const features = featureIdsOf(copy);
+    const dropped = new Set(insertedIn(draft.versions).filter(carriedOnlyOn(features)).map(symbol => symbol.id));
+    draft.copies = draft.copies.filter(c => c.id !== copyId);
+    draft.versions.forEach(version => forgetCopyIn(version, features, dropped));
+};
 export class MergeEdits extends BasePlan {
     constructor(versionId, toMerge) {
         super();

package/lib/Symbol.d.ts

@@ -19,6 +19,7 @@ export interface Symbol<T extends string> extends WithId {
     carriers: ReferenceAssumption[];
 }
 export declare const isSymbol: (object: any) => object is AnySymbol;
+export declare const isPerforation: (symbol: AnySymbol) => symbol is Note | Expression;
 /**
  * A perforation is a symbol that is typically encoded as a single punched
  * hole or a group of punched holes in the physical carrier.
@@ -34,6 +35,24 @@ export interface Perforation<T extends string> extends Symbol<T> {
      * @see reo:alignedWith
      */
     alignedWith?: ReferenceAssumption;
+    /**
+     * A perforation whose onset this one precedes when the roll is
+     * performed, without saying by how much: a "crescendo off" ends
+     * before the note it leads to begins, even where the copies
+     * disagree on it. Where the measurement has it so, nothing moves;
+     * where it does not, this one is placed before the reference as
+     * far as the copies that agree put it. This points to the
+     * perforation by its `@id`.
+     * @see reo:before
+     */
+    before?: ReferenceAssumption;
+    /**
+     * A perforation whose onset this one follows when the roll is
+     * performed, the counterpart of `before`. This points to the
+     * perforation by its `@id`.
+     * @see reo:after
+     */
+    after?: ReferenceAssumption;
     /**
      * The perforation this one forms a pair with, e.g. a "forzando on"
      * with its "forzando off". Any two perforations may be paired.
@@ -44,6 +63,20 @@ export interface Perforation<T extends string> extends Symbol<T> {
      */
     pairedWith?: ReferenceAssumption;
 }
+export declare const placementRelations: readonly ["alignedWith", "before", "after"];
+/** The ways a perforation may be placed relative to another. */
+export type PlacementRelation = typeof placementRelations[number];
+type Placeable = Partial<Record<PlacementRelation, ReferenceAssumption>>;
+export type Placement = {
+    relation: PlacementRelation;
+    reference: ReferenceAssumption;
+};
+/**
+ * The statements placing a perforation relative to others, alignment
+ * first. A perforation is meant to make one at most; the first is the
+ * one a performance applies.
+ */
+export declare const placementsOf: (perforation: Placeable) => Placement[];
 type Pairable = WithId & {
     pairedWith?: ReferenceAssumption;
 };

package/lib/Symbol.js

@@ -3,6 +3,17 @@ export const isSymbol = (object) => {
     return ('type' in object
         && (object.type === 'note' || object.type === 'expression' || object.type === 'text'));
 };
+export const isPerforation = (symbol) => symbol.type !== 'text';
+export const placementRelations = ['alignedWith', 'before', 'after'];
+/**
+ * The statements placing a perforation relative to others, alignment
+ * first. A perforation is meant to make one at most; the first is the
+ * one a performance applies.
+ */
+export const placementsOf = (perforation) => placementRelations.flatMap(relation => {
+    const reference = perforation[relation];
+    return reference ? [{ relation, reference }] : [];
+});
 /**
  * The pairs among the given perforations, each once and in the order
  * the pairing is stated. A pair whose partner is absent is left out.

package/lib/schema.json

@@ -425,10 +425,18 @@
         "Expression": {
             "description": "An expression symbol, representing a perforation on the roll that governs dynamics, pedaling, or mechanical functions of the reproducing piano. Each expression has a scope (bass or treble) and a specific expression type. [ontology: reo:Expression]",
             "properties": {
+                "after": {
+                    "$ref": "#/definitions/ReferenceAssumption",
+                    "description": "A perforation whose onset this one follows when the roll is performed, the counterpart of `before`. This points to the perforation by its `@id`. [ontology: reo:after]"
+                },
                 "alignedWith": {
                     "$ref": "#/definitions/ReferenceAssumption",
                     "description": "In piano rolls, perforations are often aligned with other perforations, e.g. a \"crescendo off\" might be logically aligned to the start of a note perforation. This points to the perforation by its `@id`. [ontology: reo:alignedWith]"
                 },
+                "before": {
+                    "$ref": "#/definitions/ReferenceAssumption",
+                    "description": "A perforation whose onset this one precedes when the roll is performed, without saying by how much: a \"crescendo off\" ends before the note it leads to begins, even where the copies disagree on it. Where the measurement has it so, nothing moves; where it does not, this one is placed before the reference as far as the copies that agree put it. This points to the perforation by its `@id`. [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`. [ontology: crm:P128i is carried by]",
                     "items": {
@@ -813,10 +821,18 @@
         "Note": {
             "description": "A note symbol, representing a single pitched musical event on the roll. The pitch is encoded via the tracker bar position (track number). [ontology: reo:Note]",
             "properties": {
+                "after": {
+                    "$ref": "#/definitions/ReferenceAssumption",
+                    "description": "A perforation whose onset this one follows when the roll is performed, the counterpart of `before`. This points to the perforation by its `@id`. [ontology: reo:after]"
+                },
                 "alignedWith": {
                     "$ref": "#/definitions/ReferenceAssumption",
                     "description": "In piano rolls, perforations are often aligned with other perforations, e.g. a \"crescendo off\" might be logically aligned to the start of a note perforation. This points to the perforation by its `@id`. [ontology: reo:alignedWith]"
                 },
+                "before": {
+                    "$ref": "#/definitions/ReferenceAssumption",
+                    "description": "A perforation whose onset this one precedes when the roll is performed, without saying by how much: a \"crescendo off\" ends before the note it leads to begins, even where the copies disagree on it. Where the measurement has it so, nothing moves; where it does not, this one is placed before the reference as far as the copies that agree put it. This points to the perforation by its `@id`. [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`. [ontology: crm:P128i is carried by]",
                     "items": {
@@ -1173,7 +1189,7 @@
             ],
             "type": "object"
         },
-        "ObjectAssumption<alias-731470504-73739-73887-731470504-0-217694<def-interface-src_Symbol.ts-4034-4398-src_Symbol.ts-0-4606400334313,\"carriers\">>": {
+        "ObjectAssumption<alias-731470504-73739-73887-731470504-0-217694<def-interface-src_Symbol.ts-5670-6034-src_Symbol.ts-0-6242400334313,\"carriers\">>": {
             "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": {
@@ -1744,7 +1760,7 @@
                     "description": "The method by which this writing was produced (e.g. through print, handwriting, or stamping). [ontology: crm:P2 has type]"
                 },
                 "transcription": {
-                    "$ref": "#/definitions/ObjectAssumption%3Calias-731470504-73739-73887-731470504-0-217694%3Cdef-interface-src_Symbol.ts-4034-4398-src_Symbol.ts-0-4606400334313%2C%22carriers%22%3E%3E",
+                    "$ref": "#/definitions/ObjectAssumption%3Calias-731470504-73739-73887-731470504-0-217694%3Cdef-interface-src_Symbol.ts-5670-6034-src_Symbol.ts-0-6242400334313%2C%22carriers%22%3E%3E",
                     "description": "A transcription of the text content of the writing. This is an object assumption so that the transcription can be annotated with a belief about its correctness. [ontology: crm:P128 carries]"
                 },
                 "vertical": {

package/lib/spec/context.json

@@ -208,6 +208,8 @@
         "motivations": "@included",
         "carriers": "crm:P128i_is_carried_by",
         "alignedWith": "reo:alignedWith",
+        "before": "reo:before",
+        "after": "reo:after",
         "pairedWith": "reo:pairedWith",
         "pitch": {
             "@id": "reo:pitch",

package/lib/validate.d.ts

@@ -6,14 +6,15 @@ export { validate };
 export type ConstraintProblem = {
     version: string;
     symbol: string;
-    problem: 'alignment-reference-missing' | 'partner-missing' | 'paired-with-itself' | 'in-several-pairs' | 'pair-aligned-on-both-sides';
+    problem: 'alignment-reference-missing' | 'before-reference-missing' | 'after-reference-missing' | 'placed-relative-to-itself' | 'placed-several-ways' | 'partner-missing' | 'paired-with-itself' | 'in-several-pairs' | 'pair-placed-on-both-sides';
 };
 /**
- * Where the alignments and pairings of the edition cannot hold as
+ * Where the placements and pairings of the edition cannot hold as
  * stated, version by version: a reference or partner absent from the
- * version, a perforation claimed by several pairs, or a pair whose
- * members are both aligned and so cannot keep their distance and
- * follow their references at once.
+ * version, a perforation placed relative to itself or in several ways
+ * at once, one claimed by several pairs, or a pair whose members are
+ * both placed and so cannot keep their distance and follow their
+ * references at once.
  */
 export declare const constraintProblems: (view: EditionView) => ConstraintProblem[];
 export type UnknownExpressionType = {

package/lib/validate.js

@@ -1,7 +1,7 @@
 import Ajv from "ajv";
 import * as schema from "./schema.json";
 import { idOf } from "./Assumption";
-import { pairsAmong } from "./Symbol";
+import { isPerforation, pairsAmong, placementsOf } from "./Symbol";
 const ajv = new Ajv({
     strict: false,
     formats: {
@@ -10,13 +10,24 @@ const ajv = new Ajv({
 });
 const validate = ajv.compile(schema);
 export { validate };
-const isPerforation = (symbol) => symbol.type !== 'text';
+const missingReference = {
+    alignedWith: 'alignment-reference-missing',
+    before: 'before-reference-missing',
+    after: 'after-reference-missing'
+};
 const problemsIn = (version, perforations) => {
     const ids = new Set(perforations.map(p => p.id));
     const report = (symbol, problem) => ({ version, symbol, problem });
     const missingReferences = perforations
-        .filter(p => p.alignedWith && !ids.has(idOf(p.alignedWith)))
-        .map(p => report(p.id, 'alignment-reference-missing'));
+        .flatMap(p => placementsOf(p)
+        .filter(({ reference }) => !ids.has(idOf(reference)))
+        .map(({ relation }) => report(p.id, missingReference[relation])));
+    const selfPlaced = perforations
+        .filter(p => placementsOf(p).some(({ reference }) => idOf(reference) === p.id))
+        .map(p => report(p.id, 'placed-relative-to-itself'));
+    const placedSeveralWays = perforations
+        .filter(p => placementsOf(p).length > 1)
+        .map(p => report(p.id, 'placed-several-ways'));
     const missingPartners = perforations
         .filter(p => p.pairedWith && !ids.has(idOf(p.pairedWith)))
         .map(p => report(p.id, 'partner-missing'));
@@ -28,17 +39,21 @@ const problemsIn = (version, perforations) => {
     const inSeveralPairs = perforations
         .filter(p => pairsOf(p).length > 1)
         .map(p => report(p.id, 'in-several-pairs'));
-    const alignedOnBothSides = pairs
-        .filter(([one, other]) => one.alignedWith && other.alignedWith)
-        .flatMap(pair => pair.map(p => report(p.id, 'pair-aligned-on-both-sides')));
-    return [...missingReferences, ...missingPartners, ...selfPaired, ...inSeveralPairs, ...alignedOnBothSides];
+    const placedOnBothSides = pairs
+        .filter(([one, other]) => placementsOf(one).length > 0 && placementsOf(other).length > 0)
+        .flatMap(pair => pair.map(p => report(p.id, 'pair-placed-on-both-sides')));
+    return [
+        ...missingReferences, ...selfPlaced, ...placedSeveralWays,
+        ...missingPartners, ...selfPaired, ...inSeveralPairs, ...placedOnBothSides
+    ];
 };
 /**
- * Where the alignments and pairings of the edition cannot hold as
+ * Where the placements and pairings of the edition cannot hold as
  * stated, version by version: a reference or partner absent from the
- * version, a perforation claimed by several pairs, or a pair whose
- * members are both aligned and so cannot keep their distance and
- * follow their references at once.
+ * version, a perforation placed relative to itself or in several ways
+ * at once, one claimed by several pairs, or a pair whose members are
+ * both placed and so cannot keep their distance and follow their
+ * references at once.
  */
 export const constraintProblems = (view) => view.edition.versions.flatMap(version => problemsIn(version.id, view.snapshot(version.id).filter(isPerforation)));
 const isExpression = (symbol) => symbol.type === 'expression';

package/package.json

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