linked-rolls 0.19.1 → 0.20.0

package/lib/Collation.d.ts

@@ -13,9 +13,7 @@ export interface CollationTolerance {
 }
 export declare const defaultCollationTolerance: CollationTolerance;
 /** Where a symbol lies along the roll, as its carriers put it, or nothing for a symbol without a place. */
-export type Locate = (symbol: AnySymbol) => Readonly<{
-    horizontal: HorizontalSpan;
-}> | undefined;
+export type Locate = (symbol: AnySymbol) => Readonly<HorizontalSpan> | undefined;
 /**
  * Two symbols collate when they are of one kind, say the same thing
  * (pitch, or expression type and scope), and lie at about the same

package/lib/Collation.js

@@ -1,17 +1,15 @@
+import { keyOf } from "./TrackerBar";
 import { distance, mm } from "./Quantity";
 import { partitionPoint } from "./sorted";
 export const defaultCollationTolerance = { toleranceStart: mm(5), toleranceEnd: mm(5) };
 /**
  * What a symbol says, as a key: the pitch of a note, the type and scope
- * of an expression. Symbols collate within one key only.
+ * of an expression. Symbols collate within one key only. This is the
+ * same key the tracker bars are indexed by, so two symbols collate
+ * exactly where two bars would read them as the same thing, which is
+ * what carries a note across a transfer between systems.
  */
-const kindOf = (symbol) => {
-    switch (symbol.type) {
-        case 'note': return `note ${symbol.pitch}`;
-        case 'expression': return `expression ${symbol.scope} ${symbol.expressionType}`;
-        case 'text': return 'text';
-    }
-};
+const kindOf = (symbol) => symbol.type === 'text' ? 'text' : keyOf(symbol);
 const nearby = (here, there, tolerance) => distance(here.from, there.from) <= tolerance.toleranceStart
     && distance(here.to, there.to) <= tolerance.toleranceEnd;
 /**
@@ -22,12 +20,12 @@ const nearby = (here, there, tolerance) => distance(here.from, there.from) <= to
 export const isCollatable = (a, b, locate, tolerance = defaultCollationTolerance) => {
     if (kindOf(a) !== kindOf(b))
         return false;
-    const here = locate(a)?.horizontal;
-    const there = locate(b)?.horizontal;
+    const here = locate(a);
+    const there = locate(b);
     return here !== undefined && there !== undefined && nearby(here, there, tolerance);
 };
 const placed = (symbols, locate) => symbols.flatMap((symbol, index) => {
-    const horizontal = locate(symbol)?.horizontal;
+    const horizontal = locate(symbol);
     return horizontal ? [{ symbol, index, horizontal }] : [];
 });
 const groupBy = (items, keyOf) => items.reduce((groups, item) => {

package/lib/Edition.d.ts

@@ -2,7 +2,7 @@ import { RollCopy } from "./RollCopy";
 import { Version } from "./Version";
 import { CollationTolerance } from "./Collation";
 import { DateAssignment, ObjectAssumption } from "./Assumption";
-import { Concept, Editor, Person, Place } from "./Agent";
+import { Editor, Person, Place } from "./Agent";
 import { RollTempo } from "./ReproducingSystem";
 /**
  * This type describes the creation of an edition,
@@ -91,14 +91,6 @@ export interface Roll {
      * @see dcterms:identifier
      */
     catalogueNumber: string;
-    /**
-     * The reproducing system the roll was cut for. A system the
-     * type vocabulary knows carries the IRI of its concept as `id`,
-     * from which the export takes the system's own context, so that
-     * the expression types are read as that system's.
-     * @see crm:P2 has type
-     */
-    system: Concept;
     /**
      * @see lrmoo:R19i was realised through
      */

package/lib/EditionView.d.ts

@@ -1,8 +1,10 @@
 import { Edition } from "./Edition";
-import { HorizontalSpan, VerticalSpan, AnyFeature } from "./Feature";
+import { HorizontalSpan, AnyFeature } from "./Feature";
 import { AnySymbol, Expression, Note } from "./Symbol";
 import { Version } from "./Version";
 import { NegotiatedEvent } from "./ReproducingSystem";
+import { TrackerBar } from "./TrackerBar";
+import { RollCopy } from "./RollCopy";
 import { Millimeters } from "./Quantity";
 export type Path = (string | number)[];
 export declare const getAt: <T>(path: Path, obj: unknown) => T | undefined;
@@ -20,6 +22,8 @@ export declare class EditionView {
      * Map from id to paths where it is referenced
      */
     private readonly links;
+    /** Built when a copy is first asked for, the walk not recording it. */
+    private copiesByFeature?;
     constructor(edition: Edition);
     atPath<T>(path: Path): T | null;
     indexObjects(): void;
@@ -31,11 +35,46 @@ export declare class EditionView {
     /** The version and its ancestors, from the version up to the root. */
     private lineageOf;
     carriersOf(symbol: AnySymbol): Readonly<AnyFeature>[];
+    /** The copy a feature sits on, a patch and everything it bears included. */
+    copyOf(featureId: string): Readonly<RollCopy> | undefined;
+    /**
+     * How a place on the edition's shared axis relates to the paper of
+     * this version: place × factor = millimetres of its own paper.
+     *
+     * Copies cut for different systems are scaled onto one axis so that
+     * they can be collated at all, which leaves a version of another
+     * system carrying places in the axis copy's millimetres. A
+     * performance needs the paper the roll actually ran on, and the
+     * factor is the inverse of the scale `alignCopy` recorded.
+     *
+     * It is read only from the copies of the version's own system, since
+     * under the shared axis a green version's notes are carried by red
+     * copies too and those say nothing about green paper. A copy whose
+     * scale is put down to its own paper having stretched is left out as
+     * well: that is a fact about the one exemplar, not about the speed
+     * the system's rolls were cut at. Where what remains disagrees,
+     * `constraintProblems` reports it rather than averaging it away.
+     */
+    toOwnPaperOf(version: Readonly<Version>): number | undefined;
+    /** The scales of the version's own copies that are not their own paper stretch. */
+    speedScalesIn(version: Readonly<Version>): number[];
+    /** The copies of the version's own system that carry any of its symbols. */
+    copiesOwning(version: Readonly<Version>): Readonly<RollCopy>[];
     predecessorOf(versionId: string): Readonly<Version> | undefined;
-    dimensionOf(symbol: AnySymbol): Readonly<{
-        horizontal: HorizontalSpan;
-        vertical: VerticalSpan;
-    }> | undefined;
+    /**
+     * Where along the roll the symbol lies, as its carriers put it, or
+     * nothing for a symbol no copy carries.
+     *
+     * Only the place is measured. Which track the symbol sits on is not
+     * a measurement but a question for a tracker bar, since a note of
+     * one pitch sits on exactly one position of a given bar: ask
+     * `bar.positionOf`. The carriers cannot answer it, because a copy
+     * cut for another system numbers its tracks differently, and one
+     * symbol may be carried by copies of both — averaging a red carrier
+     * on track 47 with a green one on 45 would give 46, a legal
+     * position a semitone away on either bar.
+     */
+    placeOf(symbol: AnySymbol): Readonly<HorizontalSpan> | undefined;
     /** Where the symbol begins, as the mean onset of its carriers, or nothing for a symbol without a place. */
     onsetOf(symbol: AnySymbol): Millimeters | undefined;
     /** The symbols by onset, those without a place first; symbols at one place keep their order. */
@@ -51,5 +90,14 @@ export declare class EditionView {
     withGenerations(): Array<Version & {
         generation: number;
     }>;
-    simplifySymbol(symbol: Note | Expression): NegotiatedEvent | null;
+    /**
+     * The symbol as a performance needs it: where it lies, and the
+     * position the performing bar reads it on.
+     *
+     * Nothing where that bar reads nothing of it, which is the case a
+     * transfer between systems leaves behind: a red `ForzandoOn` a
+     * green version still inherits cannot be performed on a green
+     * machine, and an edit has yet to say what took its place.
+     */
+    simplifySymbol(symbol: Note | Expression, bar: TrackerBar): NegotiatedEvent | null;
 }

package/lib/EditionView.js

@@ -1,4 +1,7 @@
+import { withBorneFeatures } from "./Feature";
 import { deletedBy, insertedBy } from "./Version";
+import { systemIdOf } from "./TrackerBar";
+import { isPaperStretch } from "./RollCopy";
 import { idOf, idsOf } from "./Assumption";
 import { mean } from "./Quantity";
 export const getAt = (path, obj) => {
@@ -58,6 +61,13 @@ export class EditionView {
             writable: true,
             value: new Map()
         });
+        /** Built when a copy is first asked for, the walk not recording it. */
+        Object.defineProperty(this, "copiesByFeature", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.edition = edition;
         this.indexObjects();
     }
@@ -141,35 +151,87 @@ export class EditionView {
     carriersOf(symbol) {
         return this.getAll(idsOf(symbol.carriers));
     }
+    /** The copy a feature sits on, a patch and everything it bears included. */
+    copyOf(featureId) {
+        if (!this.copiesByFeature) {
+            this.copiesByFeature = new Map(this.edition.copies.flatMap(copy => copy.features
+                .flatMap(withBorneFeatures)
+                .map(feature => [feature.id, copy])));
+        }
+        return this.copiesByFeature.get(featureId);
+    }
+    /**
+     * How a place on the edition's shared axis relates to the paper of
+     * this version: place × factor = millimetres of its own paper.
+     *
+     * Copies cut for different systems are scaled onto one axis so that
+     * they can be collated at all, which leaves a version of another
+     * system carrying places in the axis copy's millimetres. A
+     * performance needs the paper the roll actually ran on, and the
+     * factor is the inverse of the scale `alignCopy` recorded.
+     *
+     * It is read only from the copies of the version's own system, since
+     * under the shared axis a green version's notes are carried by red
+     * copies too and those say nothing about green paper. A copy whose
+     * scale is put down to its own paper having stretched is left out as
+     * well: that is a fact about the one exemplar, not about the speed
+     * the system's rolls were cut at. Where what remains disagrees,
+     * `constraintProblems` reports it rather than averaging it away.
+     */
+    toOwnPaperOf(version) {
+        const scales = this.speedScalesIn(version);
+        return scales.length === 1 ? 1 / scales[0] : undefined;
+    }
+    /** The scales of the version's own copies that are not their own paper stretch. */
+    speedScalesIn(version) {
+        return [...new Set(this.copiesOwning(version)
+                .filter(copy => !copy.conditions.some(isPaperStretch))
+                .map(copy => copy.measurements.scale)
+                .filter((scale) => scale !== undefined && scale > 0))];
+    }
+    /** The copies of the version's own system that carry any of its symbols. */
+    copiesOwning(version) {
+        const system = systemIdOf(version.system);
+        const carrying = new Set(this.snapshot(version.id)
+            .flatMap(symbol => idsOf(symbol.carriers))
+            .flatMap(id => {
+            const copy = this.copyOf(id);
+            return copy ? [copy.id] : [];
+        }));
+        return this.edition.copies.filter(copy => carrying.has(copy.id) && systemIdOf(copy.production?.system) === system);
+    }
     predecessorOf(versionId) {
         const v = this.get(versionId);
         if (!v?.basedOn)
             return;
         return this.get(idOf(v.basedOn));
     }
-    dimensionOf(symbol) {
+    /**
+     * Where along the roll the symbol lies, as its carriers put it, or
+     * nothing for a symbol no copy carries.
+     *
+     * Only the place is measured. Which track the symbol sits on is not
+     * a measurement but a question for a tracker bar, since a note of
+     * one pitch sits on exactly one position of a given bar: ask
+     * `bar.positionOf`. The carriers cannot answer it, because a copy
+     * cut for another system numbers its tracks differently, and one
+     * symbol may be carried by copies of both — averaging a red carrier
+     * on track 47 with a green one on 45 would give 46, a legal
+     * position a semitone away on either bar.
+     */
+    placeOf(symbol) {
         const carriers = this.getAll(idsOf(symbol.carriers));
-        if (carriers.length === 0) {
+        if (carriers.length === 0)
             return;
-        }
-        const farEnds = carriers.flatMap(carrier => carrier.vertical.to === undefined ? [] : [carrier.vertical.to]);
         return {
-            horizontal: {
-                unit: 'mm',
-                from: mean(carriers.map(carrier => carrier.horizontal.from)),
-                to: mean(carriers.map(carrier => carrier.horizontal.to))
-            },
-            vertical: {
-                unit: 'track',
-                from: mean(carriers.map(carrier => carrier.vertical.from)),
-                ...(farEnds.length > 0 && { to: mean(farEnds) })
-            }
+            unit: 'mm',
+            from: mean(carriers.map(carrier => carrier.horizontal.from)),
+            to: mean(carriers.map(carrier => carrier.horizontal.to))
         };
     }
     /** Where the symbol begins, as the mean onset of its carriers, or nothing for a symbol without a place. */
     onsetOf(symbol) {
-        const carriers = this.carriersOf(symbol);
-        return carriers.length > 0 ? mean(carriers.map(carrier => carrier.horizontal.from)) : undefined;
+        return this.placeOf(symbol)?.from;
     }
     /** The symbols by onset, those without a place first; symbols at one place keep their order. */
     inOrderOfPlace(symbols) {
@@ -231,13 +293,24 @@ export class EditionView {
         }));
         return withGen;
     }
-    simplifySymbol(symbol) {
-        const dim = this.dimensionOf(symbol);
-        if (!symbol.carriers.length || !dim)
+    /**
+     * The symbol as a performance needs it: where it lies, and the
+     * position the performing bar reads it on.
+     *
+     * Nothing where that bar reads nothing of it, which is the case a
+     * transfer between systems leaves behind: a red `ForzandoOn` a
+     * green version still inherits cannot be performed on a green
+     * machine, and an edit has yet to say what took its place.
+     */
+    simplifySymbol(symbol, bar) {
+        const horizontal = this.placeOf(symbol);
+        const position = bar.positionOf(symbol);
+        if (!horizontal || position === undefined)
             return null;
         return {
             ...symbol,
-            ...dim
+            horizontal,
+            vertical: { unit: 'track', from: position }
         };
     }
 }

package/lib/Emulation.js

@@ -154,7 +154,7 @@ export class Emulation {
         this.negotiatedEvents =
             view.snapshot(version.id)
                 .filter(isPerforation)
-                .map(symbol => view.simplifySymbol(symbol))
+                .map(symbol => view.simplifySymbol(symbol, this.system.trackerBar))
                 .filter(event => event !== null)
                 .filter(inScope);
         if (this.negotiatedEvents.length === 0) {

package/lib/RollCopy.d.ts

@@ -301,17 +301,32 @@ export interface RollCopy extends WithType<'RollCopy'>, WithId {
      */
     readFrom?: FeatureSource;
 }
+/**
+ * Whether the condition is the stretch or shrinkage of the paper. A
+ * scale put down to this belongs to the one exemplar and says nothing
+ * about the speed its system's rolls were cut at.
+ */
+export declare const isPaperStretch: (condition: RollConditionAssignment) => boolean;
+/**
+ * The bar a copy is read by, which is the one it was cut for. A copy
+ * that names no system falls back to the T-100, as every copy was read
+ * before the systems were told apart; `reservationsAbout` says so.
+ */
+export declare const barOf: (copy: Pick<RollCopy, 'production'>) => TrackerBar;
 /**
  * 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.
+ *
+ * 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.
  */
-export declare function asSymbols(features: AnyFeature[], bar?: TrackerBar): AnySymbol[];
+export declare function asSymbols(features: AnyFeature[], 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.
  */
-export declare function unreadTracks(features: AnyFeature[], bar?: TrackerBar): Map<Track, number>;
+export declare function unreadTracks(features: AnyFeature[], bar: TrackerBar): Map<Track, number>;
 /**
  * Falls back to the way the scan geometry was reconstructed before the
  * calibration was recorded: the bass hard margin stood in for the phase

package/lib/RollCopy.js

@@ -1,17 +1,33 @@
 import { v4 } from "uuid";
 import { welteT100 } from "./systems/welteT100/bar";
+import { trackerBarOf } from "./systems";
 import { assignReference } from "./Assumption";
 import { px, track } from "./Quantity";
 export const rollConditions = [
     'general',
     'paper-stretch'
 ];
+/**
+ * Whether the condition is the stretch or shrinkage of the paper. A
+ * scale put down to this belongs to the one exemplar and says nothing
+ * about the speed its system's rolls were cut at.
+ */
+export const isPaperStretch = (condition) => condition.conditionType === 'paper-stretch';
+/**
+ * The bar a copy is read by, which is the one it was cut for. A copy
+ * that names no system falls back to the T-100, as every copy was read
+ * before the systems were told apart; `reservationsAbout` says so.
+ */
+export const barOf = (copy) => trackerBarOf(copy.production?.system) ?? welteT100;
 /**
  * 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.
+ *
+ * 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.
  */
-export function asSymbols(features, bar = welteT100) {
+export function asSymbols(features, bar) {
     return features
         .filter(feature => feature.type === 'Hole')
         .flatMap((feature) => {
@@ -29,7 +45,7 @@ export function asSymbols(features, bar = welteT100) {
  * 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.
  */
-export function unreadTracks(features, bar = welteT100) {
+export function unreadTracks(features, bar) {
     const counts = new Map();
     features
         .filter(feature => feature.type === 'Hole')

package/lib/TrackerBar.d.ts

@@ -58,11 +58,26 @@ export interface TrackerBar {
     readonly paperSpeed?: SpeedMeasure;
     /** `undefined` for a position the bar does not read. */
     meaningOf(position: Track): TrackMeaning | undefined;
+    /**
+     * `meaningOf` inverted: the position this bar reads the meaning on,
+     * or `undefined` where it does not read it at all. A symbol's track
+     * is this rather than anything measured, since a note of one pitch
+     * sits on exactly one position of a given bar.
+     */
+    positionOf(meaning: TrackMeaning): Track | undefined;
     /** `undefined` for a position the bar does not read. */
     roleOf(position: Track): TrackRole | undefined;
 }
+/**
+ * What a position says, as a key. Two bars read the same thing exactly
+ * where their keys agree, which is what lets a symbol cross from one
+ * system to another and what decides whether two symbols collate.
+ */
+export declare const keyOf: (meaning: TrackMeaning) => string;
 /** The roll system a tracker bar belongs to, as the roll metadata states it. */
 export declare const systemOf: (bar: TrackerBar) => Concept;
+/** The identifier of a system the type vocabulary knows, from the IRI naming it. */
+export declare const systemIdIn: (id: string | undefined) => string | undefined;
 /** The identifier of a system the type vocabulary knows, from its concept. */
 export declare const systemIdOf: (system: Concept | undefined) => string | undefined;
 /**
@@ -97,7 +112,7 @@ export declare const describeTrackerBar: (spec: TrackerBarSpec) => TrackerBar;
 /**
  * Puts a position of one bar onto the position of another that reads
  * the same thing, or nowhere when the other bar does not read it. This
- * is how a copy cut for one system takes its place in an edition of
- * another, as a Licensee re-cut does in an edition of a T-100 roll.
+ * is how a copy read in one system's numbering is put into another's,
+ * as the migration does for a Licensee copy stored on T-100 tracks.
  */
 export declare const translationBetween: (from: TrackerBar, to: TrackerBar) => (position: Track) => Track | undefined;

package/lib/TrackerBar.js

@@ -1,9 +1,19 @@
 import { track } from "./Quantity";
+/**
+ * What a position says, as a key. Two bars read the same thing exactly
+ * where their keys agree, which is what lets a symbol cross from one
+ * system to another and what decides whether two symbols collate.
+ */
+export const keyOf = (meaning) => meaning.type === 'note'
+    ? `note ${meaning.pitch}`
+    : `expression ${meaning.scope} ${meaning.expressionType}`;
 const SYSTEM_IRI = 'https://w3id.org/reo/type/system/';
 /** The roll system a tracker bar belongs to, as the roll metadata states it. */
 export const systemOf = (bar) => ({ id: SYSTEM_IRI + bar.id, name: bar.name, sameAs: [] });
+/** The identifier of a system the type vocabulary knows, from the IRI naming it. */
+export const systemIdIn = (id) => id?.startsWith(SYSTEM_IRI) ? id.slice(SYSTEM_IRI.length) : undefined;
 /** The identifier of a system the type vocabulary knows, from its concept. */
-export const systemIdOf = (system) => system?.id?.startsWith(SYSTEM_IRI) ? system.id.slice(SYSTEM_IRI.length) : undefined;
+export const systemIdOf = (system) => systemIdIn(system?.id);
 const areasOf = ({ notes, trackCount }) => [
     { role: 'bass-expression', from: track(1), to: track(notes.from - 1) },
     { role: 'note', from: track(notes.from), to: track(notes.to) },
@@ -28,6 +38,11 @@ export const describeTrackerBar = (spec) => {
             return undefined;
         return { type: 'expression', expressionType, scope: scopeOf(role) };
     };
+    const positions = new Map(Array.from({ length: spec.trackCount }, (_, i) => track(i + 1))
+        .flatMap(position => {
+        const meaning = meaningOf(position);
+        return meaning ? [[keyOf(meaning), position]] : [];
+    }));
     const rewind = spec.rewindTrack
         ?? [...spec.expressions].find(([, type]) => type === 'Rewind')?.[0];
     if (rewind === undefined) {
@@ -43,26 +58,17 @@ export const describeTrackerBar = (spec) => {
         rewindTrack: track(rewind),
         ...(spec.paperSpeed && { paperSpeed: spec.paperSpeed }),
         meaningOf,
+        positionOf: meaning => positions.get(keyOf(meaning)),
         roleOf
     };
 };
-const keyOf = (meaning) => meaning.type === 'note' ? `note ${meaning.pitch}` : `${meaning.scope} ${meaning.expressionType}`;
-const positionsOf = (bar) => Array.from({ length: bar.trackCount }, (_, i) => track(i + 1));
 /**
  * Puts a position of one bar onto the position of another that reads
  * the same thing, or nowhere when the other bar does not read it. This
- * is how a copy cut for one system takes its place in an edition of
- * another, as a Licensee re-cut does in an edition of a T-100 roll.
+ * is how a copy read in one system's numbering is put into another's,
+ * as the migration does for a Licensee copy stored on T-100 tracks.
  */
-export const translationBetween = (from, to) => {
-    const positions = new Map();
-    positionsOf(to).forEach(position => {
-        const meaning = to.meaningOf(position);
-        if (meaning)
-            positions.set(keyOf(meaning), position);
-    });
-    return position => {
-        const meaning = from.meaningOf(position);
-        return meaning ? positions.get(keyOf(meaning)) : undefined;
-    };
+export const translationBetween = (from, to) => (position) => {
+    const meaning = from.meaningOf(position);
+    return meaning && to.positionOf(meaning);
 };

package/lib/Version.d.ts

@@ -1,5 +1,6 @@
 import { Edit } from "./Edit";
-import { ReferenceAssumption } from "./Assumption";
+import { Concept } from "./Agent";
+import { ActorAssignment, DateAssignment, ReferenceAssumption } from "./Assumption";
 import { CollationTolerance } from "./Collation";
 import { AnySymbol } from "./Symbol";
 import { WithId, WithNote, WithType } from "./utils";
@@ -42,6 +43,37 @@ export type Derivation = ReferenceAssumption & {
 };
 /** The tolerance the derivation was collated at, or the default where it states none. */
 export declare const collationToleranceOf: (derivation: Readonly<Derivation>) => CollationTolerance;
+/**
+ * How a version was made, where that is known and worth stating.
+ *
+ * A roll issued for another system was re-punched by an editor of the
+ * publisher's, and that was an editorial act rather than a conversion:
+ * Lawson names Kähle as the man who corrected second masters for the
+ * green system. The rule he worked by is the procedure named here, and
+ * the version's edits carry it out, so the mechanical part of a
+ * transfer is stated once instead of being spelled out per note.
+ * @see lrmoo:F28 Expression Creation
+ */
+export interface VersionCreation {
+    /**
+     * Who carried the act out. An `ObjectAssumption`, so an attribution
+     * can carry the belief it rests on and the reasons for it.
+     * @see crm:P14 carried out by
+     */
+    actor?: ActorAssignment;
+    /**
+     * When it took place.
+     * @see dcterms:date
+     */
+    date?: DateAssignment;
+    /**
+     * The rule followed, as a term of the vocabulary: the notes stand
+     * at their pitch, the expression is re-spelled in the other
+     * system's words.
+     * @see crm:P33 used specific technique
+     */
+    procedure?: Concept;
+}
 /**
  * A version is defined by the sum of edits applied
  * to the version it is based on. For simple identification,
@@ -54,6 +86,16 @@ export interface Version extends WithId, WithType<'Version'> {
      * @see reo:siglum
      */
     siglum: string;
+    /**
+     * The reproducing system this version is coded for. One roll was
+     * often issued for several of them, and a version is a reading in
+     * one system's words: its expression types are that system's
+     * vocabulary and its notes sit on that bar's positions. A system
+     * the type vocabulary knows carries the IRI of its concept as
+     * `id`, from which the export takes the system's own context.
+     * @see crm:P2 has type
+     */
+    system: Concept;
     /**
      * Whether the version served as a master for reproductions
      * or exists on one copy only.
@@ -65,6 +107,12 @@ export interface Version extends WithId, WithType<'Version'> {
      * @see lrmoo:R76 is derivative of
      */
     basedOn?: Derivation;
+    /**
+     * The act that made this version, where it is known: who carried it
+     * out, when, and by what rule.
+     * @see lrmoo:R17i was created by
+     */
+    creation?: VersionCreation;
     /**
      * The list of edits that, applied to the base version, produce this version.
      * @see reo:involvedEdit

package/lib/asJsonLd.js

@@ -1,4 +1,4 @@
-import { systemIdOf } from "./TrackerBar";
+import { systemIdIn } from "./TrackerBar";
 export const exportDate = (date) => {
     const year = date.getFullYear();
     const month = String(date.getMonth() + 1).padStart(2, "0");
@@ -39,20 +39,35 @@ const asJsonLdEntity = (obj) => {
     return result;
 };
 /**
- * The context of the roll's reproducing system, which reads the
- * expression types as that system's terms.
+ * Gives every version the context of its own reproducing system, which
+ * reads its expression types as that system's terms.
+ *
+ * It sits on the version rather than on the edition because one edition
+ * may hold versions of several systems, and each system's context
+ * defines `expressionType` with its own `@vocab`. Two of them in one
+ * context array would leave every expression type in the document
+ * reading as whichever came last. An embedded context merges with the
+ * active one, so the shared prefixes survive.
  */
-const systemContextOf = (edition) => {
-    const system = systemIdOf(edition.roll?.system);
-    return system ? [`https://w3id.org/reo/${system}/context.jsonld`] : [];
+const withSystemContexts = (node) => {
+    if (Array.isArray(node))
+        return node.map(withSystemContexts);
+    if (node === null || typeof node !== 'object')
+        return node;
+    const walked = Object.fromEntries(Object.entries(node).map(([key, value]) => [key, withSystemContexts(value)]));
+    const system = node['@type'] === 'Version'
+        ? systemIdIn(node.system?.['@id'])
+        : undefined;
+    return system
+        ? { '@context': `https://w3id.org/reo/${system}/context.jsonld`, ...walked }
+        : walked;
 };
 export const asJsonLd = (edition) => {
     // The context is the export's own; one carried in from an import must not override it.
-    const { base, copies, '@context': carried, ...rest } = asJsonLdEntity(edition);
+    const { base, copies, '@context': carried, ...rest } = withSystemContexts(asJsonLdEntity(edition));
     return {
         '@context': [
             'https://w3id.org/reo/context.jsonld',
-            ...systemContextOf(edition),
             {
                 '@base': edition.base
             }