linked-rolls 0.37.0 → 0.39.0

package/lib/EditionView.d.ts

@@ -4,7 +4,7 @@ import { AnySymbol, Expression, Note } from "./Symbol";
 import { Version } from "./Version";
 import { NegotiatedEvent } from "./ReproducingSystem";
 import { TrackerBar } from "./TrackerBar";
-import { RollCopy } from "./RollCopy";
+import { Modification, ProductionEvent, RollCopy } from "./RollCopy";
 import { Millimeters } from "./Quantity";
 export type Path = (string | number)[];
 export declare const getAt: <T>(path: Path, obj: unknown) => T | undefined;
@@ -37,6 +37,15 @@ export declare class EditionView {
     carriersOf(symbol: AnySymbol): Readonly<FeatureOrPatch>[];
     /** The copy a feature sits on, a patch and everything it bears included. */
     copyOf(featureId: string): Readonly<RollCopy> | undefined;
+    /**
+     * The act a copy states a feature in: the production event that
+     * punched it, or the modification that brought it about. A feature
+     * a patch bears came onto the copy with the patch, so the act is
+     * the one that glued the patch on. Two features stand in one act
+     * where this returns the very same object, which is what
+     * `mergeFeatures` asks before it reads them as one.
+     */
+    actOf(featureId: string): Readonly<ProductionEvent | Modification> | undefined;
     /**
      * How a place on the edition's shared axis relates to the paper of
      * this version: place × factor = millimetres of its own paper.

package/lib/EditionView.js

@@ -1,7 +1,7 @@
 import { withBorneFeatures } from "./Feature";
 import { deletedBy, insertedBy, principalDerivationOf } from "./Version";
 import { systemIdOf } from "./TrackerBar";
-import { featuresOf, isPaperStretch } from "./RollCopy";
+import { featuresMadeBy, featuresOf, isPaperStretch } from "./RollCopy";
 import { idOf, idsOf } from "./Assumption";
 import { mean } from "./Quantity";
 export const getAt = (path, obj) => {
@@ -161,6 +161,23 @@ export class EditionView {
         }
         return this.copiesByFeature.get(featureId);
     }
+    /**
+     * The act a copy states a feature in: the production event that
+     * punched it, or the modification that brought it about. A feature
+     * a patch bears came onto the copy with the patch, so the act is
+     * the one that glued the patch on. Two features stand in one act
+     * where this returns the very same object, which is what
+     * `mergeFeatures` asks before it reads them as one.
+     */
+    actOf(featureId) {
+        const copy = this.copyOf(featureId);
+        if (!copy)
+            return undefined;
+        const states = (features) => features.flatMap(withBorneFeatures).some(feature => feature.id === featureId);
+        if (states(copy.production?.produced ?? []))
+            return copy.production;
+        return copy.modifications.find(act => states(featuresMadeBy(act)));
+    }
     /**
      * How a place on the edition's shared axis relates to the paper of
      * this version: place × factor = millimetres of its own paper.

package/lib/Feature.d.ts

@@ -2,7 +2,7 @@ import { ObjectAssumption } from "./Assumption";
 import { ConditionState } from "./ConditionState";
 import { Text } from "./Symbol";
 import { PartialBy, WithId, WithType } from "./utils";
-import { Millimeters, Track } from "./Quantity";
+import { Measure, Millimeters, Track } from "./Quantity";
 /**
  * Describes the horizontal extent of a feature on the roll,
  * measured in millimeters from the beginning of the roll.
@@ -119,11 +119,23 @@ export interface Hole extends RollFeature<'Hole', typeof conditions.Hole[number]
      */
     pattern?: 'regular' | 'accelerating' | 'staggering';
 }
+/**
+ * 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.
+ */
+export interface OnAFace {
+    /**
+     * The face of the roll it lies on: the side that faces the reader
+     * as the roll plays, or the back of it.
+     * @see reo:side
+     */
+    side?: 'recto' | 'verso';
+}
 /**
  * A trace is a visible mark or writing on the roll surface.
  * Traces may fade over time.
  */
-export interface Trace<T extends FeatureType> extends RollFeature<T, typeof conditions[T][number]> {
+export interface Trace<T extends FeatureType> extends RollFeature<T, typeof conditions[T][number]>, OnAFace {
 }
 export declare const writingMethods: readonly ['print', 'handwriting', 'stamp'];
 /**
@@ -156,6 +168,13 @@ export interface Writing extends Trace<'Writing'> {
      * @see crm:P128 carries
      */
     transcription: ObjectAssumption<Transcription>;
+    /**
+     * How far the writing stands askew, clockwise from the line across
+     * the roll. A stamp pressed crooked and a label written along the
+     * roll rather than across it are both stated here.
+     * @see reo:rotation
+     */
+    rotation?: Measure<'deg'>;
 }
 /**
  * A visible mark on the roll, such as a pencil circle, an ink stroke,
@@ -178,12 +197,18 @@ export interface Mark extends Trace<'Mark'> {
  * such as writings or additional holes.
  * @see reo:GluedOn
  */
-export interface GluedOn extends RollFeature<'GluedOn', typeof conditions.GluedOn[number]> {
+export interface GluedOn extends RollFeature<'GluedOn', typeof conditions.GluedOn[number]>, OnAFace {
     /**
      * The material of the glued-on feature.
      * @see crm:P45 consists of
      */
     material: 'paper' | 'tape';
+    /**
+     * How far the patch was stuck on askew, clockwise from the line
+     * across the roll.
+     * @see reo:rotation
+     */
+    rotation?: Measure<'deg'>;
     /**
      * A glued-on feature itself may carry other features.
      * Nested features do not need to be positioned explicitly.

package/lib/Quantity.d.ts

@@ -11,7 +11,7 @@ declare const unit: unique symbol;
  * The units a record may state. A `Measure` is limited to these, since
  * they are what the `unit` field is allowed to say.
  */
-export type Unit = 'mm' | 'cm' | 'px' | 'track' | 's' | 'ms' | 'ft/min' | 'm/min' | 'px/in';
+export type Unit = 'mm' | 'cm' | 'px' | 'track' | 's' | 'ms' | 'ft/min' | 'm/min' | 'px/in' | 'deg';
 export type Quantity<U extends string> = number & {
     readonly [unit]: U;
 };
@@ -28,6 +28,8 @@ export type FeetPerMinute = Quantity<'ft/min'>;
 export type MetersPerMinute = Quantity<'m/min'>;
 /** How finely a scan was read: pixels of the image per inch of paper. */
 export type Resolution = Quantity<'px/in'>;
+/** An angle, clockwise from the line across the roll. */
+export type Degrees = Quantity<'deg'>;
 /** Names a number in a unit. Partially apply it to make a constructor. */
 export declare const quantity: <U extends string>(value: number) => Quantity<U>;
 export declare const mm: (value: number) => Quantity<"mm">;
@@ -39,6 +41,7 @@ export declare const milliseconds: (value: number) => Quantity<"ms">;
 export declare const feetPerMinute: (value: number) => Quantity<"ft/min">;
 export declare const metersPerMinute: (value: number) => Quantity<"m/min">;
 export declare const pixelsPerInch: (value: number) => Quantity<"px/in">;
+export declare const degrees: (value: number) => Quantity<"deg">;
 /**
  * A value together with the unit it was measured in, as a record
  * states it.

package/lib/Quantity.js

@@ -9,6 +9,7 @@ export const milliseconds = quantity;
 export const feetPerMinute = quantity;
 export const metersPerMinute = quantity;
 export const pixelsPerInch = quantity;
+export const degrees = quantity;
 // The second operand takes its unit from the first. Inferred from both,
 // TypeScript would unite two units rather than reject them.
 export const add = (a, b) => quantity(a + b);

package/lib/RollCopy.d.ts

@@ -346,6 +346,10 @@ export interface RollCopy extends WithType<'RollCopy'>, WithId {
      */
     carries?: ReferenceAssumption[];
 }
+/** What an act brought onto the copy: what it produced or glued on, a removal nothing. */
+export declare const featuresMadeBy: (modification: Modification) => FeatureOrPatch[];
+/** Whether the act is one that modified the copy, rather than the production that punched it. */
+export declare const isModification: (act: ProductionEvent | Modification) => act is Modification;
 /** Whether the act is left stating nothing: it produced, added or removed nothing. */
 export declare const statesNothing: (modification: Modification) => boolean;
 /**

package/lib/RollCopy.js

@@ -17,20 +17,22 @@ export const modificationPurposes = [
     'glossing'
 ];
 /** What an act brought onto the copy: what it produced or glued on, a removal nothing. */
-const madeBy = (modification) => {
+export const featuresMadeBy = (modification) => {
     if (modification.type === 'Alteration')
         return modification.produced;
     return modification.type === 'Attachment' ? modification.added : [];
 };
+/** Whether the act is one that modified the copy, rather than the production that punched it. */
+export const isModification = (act) => 'type' in act;
 /** Whether the act is left stating nothing: it produced, added or removed nothing. */
-export const statesNothing = (modification) => modification.type === 'Removal' ? modification.removed.length === 0 : madeBy(modification).length === 0;
+export const statesNothing = (modification) => modification.type === 'Removal' ? modification.removed.length === 0 : featuresMadeBy(modification).length === 0;
 /**
  * The features of the copy act by act: what the punching produced
  * first, then what each modification produced or glued on. A feature a
  * patch bears states no place of its own and is not among them;
  * `withBorneFeatures` reaches those.
  */
-export const featuresByAct = (copy) => [copy.production?.produced ?? [], ...copy.modifications.map(madeBy)];
+export const featuresByAct = (copy) => [copy.production?.produced ?? [], ...copy.modifications.map(featuresMadeBy)];
 /** Every feature the copy states at a place of its own, whichever act made it. */
 export const featuresOf = (copy) => featuresByAct(copy).flat();
 /**

package/lib/editionOps.d.ts

@@ -4,10 +4,10 @@ import { Edition } from "./Edition";
 import { AnySymbol, PlacementRelation } from "./Symbol";
 import { CollationTolerance } from "./Collation";
 import { Edit } from "./Edit";
-import { GeneralRollCondition, RollCopy, ScaleReading, Shift } from "./RollCopy";
+import { GeneralRollCondition, ModificationPurpose, RollCopy, ScaleReading, Shift } from "./RollCopy";
 import { FeatureSource } from "./FeatureSource";
 import { AnyArgumentation, Belief, Certainty, ObjectAssumption } from "./Assumption";
-import { FeatureConditionAssignment, FeatureOrPatch } from "./Feature";
+import { FeatureConditionAssignment, FeatureOrPatch, NestedFeature } from "./Feature";
 /**
  * A change to an edition, written onto an immer draft of it. One
  * operation is one undo step, so an operation that has to read the
@@ -70,6 +70,34 @@ export declare const addGeneralCondition: (copyId: string, condition: ObjectAssu
 export declare const stateFeatureCondition: (copyId: string, featureId: string, condition: FeatureConditionAssignment) => EditionOp;
 /** The symbols of the versions that no other copy carries. */
 export declare const symbolsCarriedOnlyBy: (edition: Edition, copyId: string) => AnySymbol[];
+/**
+ * The act a feature an editor states belongs to: the punching of the
+ * copy, the act that brought another feature about, or, where neither
+ * is said, an act of its own for the purpose given. A patch is never
+ * punched, being glued on, so `punched` says nothing of one.
+ */
+export interface FeatureAct {
+    /** The copy was punched with it, which is where a reading of a scan puts every hole. */
+    punched?: boolean;
+    /** The act that brought this feature about brought the new one about as well. */
+    beside?: string;
+    /** What the act was for, where a new one is made for the feature. */
+    purpose?: ModificationPurpose;
+}
+/**
+ * States that the copy bears the feature, in the act that brought it
+ * about: a patch was glued on by an attachment, anything else was
+ * produced, by the punching or by a later act. Which act, `FeatureAct`
+ * says; a `beside` that names nothing the copy bears is passed over and
+ * the feature goes into an act of its own.
+ */
+export declare const addFeature: (copyId: string, feature: FeatureOrPatch, act?: FeatureAct) => EditionOp;
+/**
+ * States that the patch bears the feature. What a patch bears came onto
+ * the copy with the patch, so it belongs to no act of its own and
+ * states no place: it stands where the patch stands.
+ */
+export declare const addBorneFeature: (copyId: string, patchId: string, feature: NestedFeature) => EditionOp;
 /**
  * Takes the features off the copy, and out of the versions with what
  * only they carried. A feature may be named wherever the copy bears it:
@@ -95,6 +123,14 @@ export type MergeObstacle = 'fewer-than-two' | 'different-types' | 'different-tr
  * perforations of their own is the editor's reading.
  */
 export declare const mergeObstacle: (features: readonly FeatureOrPatch[]) => MergeObstacle | undefined;
+/**
+ * What stands in the way of reading the features the ids name as one,
+ * as `mergeFeatures` will find it. `mergeObstacle` asks only what the
+ * features themselves say, which cannot reach `different-acts`: one
+ * feature is the work of one act, and where the features stand is the
+ * edition's business rather than theirs.
+ */
+export declare const mergeObstacleIn: (view: EditionView, featureIds: readonly string[]) => MergeObstacle | undefined;
 /**
  * Replaces the features of the copy with a single one covering them
  * all, where a scan has split what the editor reads as one feature.

package/lib/editionOps.js

@@ -379,6 +379,66 @@ const rewriteFeatures = (copy, rewrite) => {
     }
     copy.modifications = pruned(state.modifications, rewritingAct(rewrite), statesNothing);
 };
+/** The features of the act that brought the named feature about, where that act produces features. */
+const producedBeside = (copy, featureId) => {
+    const names = (features) => features.some(feature => feature.id === featureId);
+    const punched = copy.production?.produced;
+    if (punched && names(punched))
+        return punched;
+    const act = copy.modifications.find(act => act.type === 'Alteration' && names(act.produced));
+    return act?.type === 'Alteration' ? act.produced : undefined;
+};
+/** The patches of the attachment that glued the named one on. */
+const gluedBeside = (copy, patchId) => {
+    const act = copy.modifications.find(act => act.type === 'Attachment' && act.added.some(patch => patch.id === patchId));
+    return act?.type === 'Attachment' ? act.added : undefined;
+};
+/** The list the copy states a new feature in, making the act it belongs to where there is none. */
+const actFor = (copy, patch, act) => {
+    const beside = act.beside !== undefined
+        ? (patch ? gluedBeside(copy, act.beside) : producedBeside(copy, act.beside))
+        : undefined;
+    if (beside)
+        return beside;
+    if (patch) {
+        const added = [];
+        copy.modifications.push({ type: 'Attachment', added, ...(act.purpose && { purpose: act.purpose }) });
+        return added;
+    }
+    if (act.punched) {
+        if (!copy.production)
+            copy.production = {};
+        if (!copy.production.produced)
+            copy.production.produced = [];
+        return copy.production.produced;
+    }
+    const produced = [];
+    copy.modifications.push({ type: 'Alteration', produced, ...(act.purpose && { purpose: act.purpose }) });
+    return produced;
+};
+/**
+ * States that the copy bears the feature, in the act that brought it
+ * about: a patch was glued on by an attachment, anything else was
+ * produced, by the punching or by a later act. Which act, `FeatureAct`
+ * says; a `beside` that names nothing the copy bears is passed over and
+ * the feature goes into an act of its own.
+ */
+export const addFeature = (copyId, feature, act = {}) => onCopy(copyId, copy => {
+    actFor(copy, isGluedOn(feature), act).push(feature);
+});
+/**
+ * States that the patch bears the feature. What a patch bears came onto
+ * the copy with the patch, so it belongs to no act of its own and
+ * states no place: it stands where the patch stands.
+ */
+export const addBorneFeature = (copyId, patchId, feature) => onCopy(copyId, copy => {
+    const patch = featuresOf(copy).flatMap(withBorneFeatures).find(borne => borne.id === patchId);
+    if (!patch || !isGluedOn(patch))
+        return;
+    if (!patch.features)
+        patch.features = [];
+    patch.features.push(feature);
+});
 /**
  * Takes the features off the copy, and out of the versions with what
  * only they carried. A feature may be named wherever the copy bears it:
@@ -451,6 +511,32 @@ export const mergeObstacle = (features) => {
         return 'differing-conditions';
     return undefined;
 };
+/** The acts of the copy that state any of the named features. */
+const actsHolding = (copy, named) => featuresByAct(copy).filter(features => features.some(feature => named.has(feature.id)));
+/**
+ * What stands in the way of reading the named features of the copy as
+ * one, which is the whole of what `mergeFeatures` asks: whether one act
+ * brought them all about, and what the features themselves say. An id
+ * the copy does not bear at a place of its own is passed over.
+ */
+const obstacleIn = (copy, featureIds) => {
+    const named = new Set(featureIds);
+    const acts = actsHolding(copy, named);
+    return acts.length > 1
+        ? 'different-acts'
+        : mergeObstacle((acts[0] ?? []).filter(feature => named.has(feature.id)));
+};
+/**
+ * What stands in the way of reading the features the ids name as one,
+ * as `mergeFeatures` will find it. `mergeObstacle` asks only what the
+ * features themselves say, which cannot reach `different-acts`: one
+ * feature is the work of one act, and where the features stand is the
+ * edition's business rather than theirs.
+ */
+export const mergeObstacleIn = (view, featureIds) => {
+    const copy = featureIds.map(id => view.copyOf(id)).find(copy => copy !== undefined);
+    return copy ? obstacleIn(copy, featureIds) : 'fewer-than-two';
+};
 /** The items with the replacement in the place of the first it stands for, the others dropped. */
 const standingFor = (items, stands, replacement) => {
     const first = items.findIndex(stands);
@@ -516,14 +602,13 @@ const carryOver = (draft, replaced, mergedId) => {
  * says beforehand whether they can.
  */
 export const mergeFeatures = (copyId, featureIds) => onCopy(copyId, (copy, draft) => {
-    const named = new Set(featureIds);
-    const holds = (features) => features.some(feature => named.has(feature.id));
-    const acts = featuresByAct(stateOf(copy)).filter(holds);
-    const toMerge = (acts[0] ?? []).filter(feature => named.has(feature.id));
-    const obstacle = acts.length > 1 ? 'different-acts' : mergeObstacle(toMerge);
+    const state = stateOf(copy);
+    const obstacle = obstacleIn(state, featureIds);
     if (obstacle) {
         throw new Error(`The features of copy ${copyId} cannot be merged: ${obstacle}`);
     }
+    const named = new Set(featureIds);
+    const toMerge = (actsHolding(state, named)[0] ?? []).filter(feature => named.has(feature.id));
     const replaced = new Set(toMerge.map(feature => feature.id));
     const mergedId = v4();
     rewriteFeatures(copy, (stated) => {

package/lib/schema.json

@@ -780,6 +780,20 @@
                     "type": "string",
                     "ontology": "crm:P45 consists of"
                 },
+                "rotation": {
+                    "$ref": "#/definitions/Measure%3C%22deg%22%3E",
+                    "description": "How far the patch was stuck on askew, clockwise from the line across the roll.",
+                    "ontology": "reo:rotation"
+                },
+                "side": {
+                    "description": "The face of the roll it lies on: the side that faces the reader as the roll plays, or the back of it.",
+                    "enum": [
+                        "recto",
+                        "verso"
+                    ],
+                    "type": "string",
+                    "ontology": "reo:side"
+                },
                 "vertical": {
                     "$ref": "#/definitions/VerticalSpan",
                     "description": "Vertical span of the feature on the roll.",
@@ -1015,6 +1029,15 @@
                     "description": "The medium the mark was drawn in, where it can be told.",
                     "ontology": "reo:method"
                 },
+                "side": {
+                    "description": "The face of the roll it lies on: the side that faces the reader as the roll plays, or the back of it.",
+                    "enum": [
+                        "recto",
+                        "verso"
+                    ],
+                    "type": "string",
+                    "ontology": "reo:side"
+                },
                 "vertical": {
                     "$ref": "#/definitions/VerticalSpan",
                     "description": "Vertical span of the feature on the roll.",
@@ -1084,6 +1107,28 @@
             "type": "object",
             "ontology": "crminf:I16 Meaning Comprehension"
         },
+        "Measure<\"deg\">": {
+            "description": "A value together with the unit it was measured in, as a record states it.",
+            "properties": {
+                "unit": {
+                    "const": "deg",
+                    "description": "The unit of measurement.",
+                    "type": "string",
+                    "ontology": "crm:P91 has unit"
+                },
+                "value": {
+                    "$ref": "#/definitions/Quantity%3C%22deg%22%3E",
+                    "description": "The measured value.",
+                    "ontology": "crm:P90 has value"
+                }
+            },
+            "required": [
+                "value",
+                "unit"
+            ],
+            "type": "object",
+            "ontology": "crm:E54 Dimension"
+        },
         "Measure<\"mm\">": {
             "description": "A value together with the unit it was measured in, as a record states it.",
             "properties": {
@@ -1411,6 +1456,20 @@
                             "description": "The method by which this writing was produced (e.g. through print, handwriting, or stamping).",
                             "ontology": "reo:method"
                         },
+                        "rotation": {
+                            "$ref": "#/definitions/Measure%3C%22deg%22%3E",
+                            "description": "How far the writing stands askew, clockwise from the line across the roll. A stamp pressed crooked and a label written along the roll rather than across it are both stated here.",
+                            "ontology": "reo:rotation"
+                        },
+                        "side": {
+                            "description": "The face of the roll it lies on: the side that faces the reader as the roll plays, or the back of it.",
+                            "enum": [
+                                "recto",
+                                "verso"
+                            ],
+                            "type": "string",
+                            "ontology": "reo:side"
+                        },
                         "transcription": {
                             "$ref": "#/definitions/ObjectAssumption%3CTranscription%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.",
@@ -1462,6 +1521,15 @@
                             "description": "The medium the mark was drawn in, where it can be told.",
                             "ontology": "reo:method"
                         },
+                        "side": {
+                            "description": "The face of the roll it lies on: the side that faces the reader as the roll plays, or the back of it.",
+                            "enum": [
+                                "recto",
+                                "verso"
+                            ],
+                            "type": "string",
+                            "ontology": "reo:side"
+                        },
                         "vertical": {
                             "$ref": "#/definitions/VerticalSpan",
                             "description": "Vertical span of the feature on the roll. Left out by a feature a patch bears.",
@@ -1518,6 +1586,20 @@
                             "type": "string",
                             "ontology": "crm:P45 consists of"
                         },
+                        "rotation": {
+                            "$ref": "#/definitions/Measure%3C%22deg%22%3E",
+                            "description": "How far the patch was stuck on askew, clockwise from the line across the roll.",
+                            "ontology": "reo:rotation"
+                        },
+                        "side": {
+                            "description": "The face of the roll it lies on: the side that faces the reader as the roll plays, or the back of it.",
+                            "enum": [
+                                "recto",
+                                "verso"
+                            ],
+                            "type": "string",
+                            "ontology": "reo:side"
+                        },
                         "vertical": {
                             "$ref": "#/definitions/VerticalSpan",
                             "description": "Vertical span of the feature on the roll. Left out by a feature a patch bears.",
@@ -2406,6 +2488,9 @@
             "type": "object",
             "ontology": "lrmoo:F32 Item Production Event"
         },
+        "Quantity<\"deg\">": {
+            "type": "number"
+        },
         "Quantity<\"ft/min\">": {
             "type": "number"
         },
@@ -3005,6 +3090,20 @@
                     "description": "The method by which this writing was produced (e.g. through print, handwriting, or stamping).",
                     "ontology": "reo:method"
                 },
+                "rotation": {
+                    "$ref": "#/definitions/Measure%3C%22deg%22%3E",
+                    "description": "How far the writing stands askew, clockwise from the line across the roll. A stamp pressed crooked and a label written along the roll rather than across it are both stated here.",
+                    "ontology": "reo:rotation"
+                },
+                "side": {
+                    "description": "The face of the roll it lies on: the side that faces the reader as the roll plays, or the back of it.",
+                    "enum": [
+                        "recto",
+                        "verso"
+                    ],
+                    "type": "string",
+                    "ontology": "reo:side"
+                },
                 "transcription": {
                     "$ref": "#/definitions/ObjectAssumption%3CTranscription%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.",

package/lib/spec/context.json

@@ -247,6 +247,15 @@
             "@context": { "@vocab": "https://w3id.org/reo/type/" }
         },
         "transcription": "crm:P128_carries",
+        "side": {
+            "@id": "reo:side",
+            "@type": "@vocab",
+            "@context": { "@vocab": "https://w3id.org/reo/type/" }
+        },
+        "rotation": {
+            "@id": "reo:rotation",
+            "@context": { "value": "crm:P90_has_value" }
+        },
         "material": {
             "@id": "crm:P45_consists_of",
             "@type": "@vocab",

package/package.json

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