linked-rolls 0.56.0 → 0.58.0

package/lib/emulation/Emulation.js

@@ -0,0 +1,282 @@
+import { MIDIControlEvents } from "midifile-ts";
+import { idOf } from "../model/Assumption.js";
+import { isCommand, pairsAmong, placementsOf } from "../model/Symbol.js";
+import { add, mean, mm, seconds, subtract } from "../model/Quantity.js";
+import { punchDiameterOf } from "../model/RollCopy.js";
+import { toOwnPaperOf } from "../analysis/ownPaper.js";
+import { negotiatedEventOf } from "./negotiation.js";
+/** The punch diameter the edition's copies report, where any of them does. */
+const meanPunchDiameterOf = (view) => {
+    const measured = view.edition.copies
+        .map(punchDiameterOf)
+        .filter(value => value !== undefined);
+    return measured.length > 0 ? mean(measured) : undefined;
+};
+const propertiesOf = (view, version) => ({
+    punchDiameter: meanPunchDiameterOf(view),
+    tempo: view.edition.tempoAdjustment,
+    toOwnPaper: toOwnPaperOf(view, version)
+});
+/** The onset a symbol has on each copy carrying it, by the copy's id, as the mean of its chains there. */
+const onsetsByCopy = (view, symbolId) => {
+    const symbol = view.symbol(symbolId);
+    if (!symbol)
+        return new Map();
+    const onsets = view.placedCarriersOf(symbol).flatMap((carrier) => {
+        const copy = view.copyOf(carrier.id);
+        return copy ? [[copy.id, 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 ? [] : [subtract(onset, reference)];
+    });
+};
+/**
+ * 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 distanceOnSide = (side, offsets, gap) => {
+    const agreeing = offsets.filter(offset => side === 'before' ? offset < 0 : offset > 0);
+    return agreeing.length > 0 ? mm(Math.abs(mean(agreeing))) : gap;
+};
+/**
+ * How far each event has to move 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]));
+    /** 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 : subtract(referenceOnset, distance('before'));
+            case 'after': return measured > referenceOnset ? measured : add(referenceOnset, distance('after'));
+        }
+    };
+    const displacements = new Map(events
+        .map((event) => [event, subtract(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)
+            return;
+        displacements.set(one, shared);
+        displacements.set(other, shared);
+    });
+    return displacements;
+};
+/** The earliest of the times, or the beginning of the roll where there are none. */
+const earliestOf = (times) => times.length === 0 ? seconds(0) : times.reduce((soonest, at) => at < soonest ? at : soonest);
+/**
+ * The events moved to where their statements put them, the events given
+ * left as they were. The view supplies the copies, whose measurements
+ * decide how far before or after its reference a command goes, and a
+ * punch diameter, or a millimetre, where no copy agrees with a statement.
+ */
+export const withPlacementsApplied = (view, events) => {
+    const gap = meanPunchDiameterOf(view) ?? mm(1);
+    const offsets = (follower, reference) => offsetsBetween(view, follower, reference);
+    const displacements = displacementsOf(events, offsets, gap);
+    return events.map(event => {
+        const distance = displacements.get(event);
+        return distance === undefined ? event : {
+            ...event,
+            horizontal: { ...event.horizontal, from: add(event.horizontal.from, distance), to: add(event.horizontal.to, distance) }
+        };
+    });
+};
+/**
+ * The commands of a version as the bar performs them, in order of place,
+ * within the scope and with the placements applied. A note plays only
+ * where its onset falls in the range; expressions play throughout.
+ */
+export const negotiatedEventsOf = (view, version, bar, { range } = {}) => {
+    const inScope = (event) => !range || event.type !== 'note' || (event.horizontal.from > range[0] && event.horizontal.from < range[1]);
+    return withPlacementsApplied(view, view.snapshot(version.id)
+        .filter(isCommand)
+        .map(symbol => negotiatedEventOf(view, symbol, bar))
+        .filter(event => event !== null)
+        .filter(inScope));
+};
+/**
+ * Performs a version on a reproducing system: the symbols are negotiated
+ * into placed events and the system plays them. Nothing given is changed.
+ */
+export const emulate = (system, version, view, options = system.defaultOptions, { range, skipToFirstNote = false } = {}) => {
+    const negotiated = negotiatedEventsOf(view, version, system.trackerBar, { range });
+    if (negotiated.length === 0)
+        return { source: version.id, negotiated, events: [], curves: [] };
+    const performance = system.perform(negotiated, options, propertiesOf(view, version));
+    const onsets = performance.events.filter(event => event.type === 'noteOn').map(event => event.at);
+    const origin = skipToFirstNote ? earliestOf(onsets) : seconds(0);
+    return {
+        source: version.id,
+        negotiated,
+        curves: performance.curves,
+        events: performance.events
+            .map(event => ({ ...event, at: subtract(event.at, origin) }))
+            .filter(event => event.at >= 0)
+            .sort((a, b) => a.at - b.at)
+    };
+};
+/**
+ * The performed events as a MIDI file, in which every note and pedal step
+ * is labelled with the symbol it performs. The file names the system, the
+ * version and the options it was played with.
+ */
+export const midiOf = (events, systemName, options, source) => {
+    const TICKS_PER_SECOND = 1000;
+    const midi = [];
+    const text = (text, deltaTime = 0) => ({ type: 'meta', subtype: 'text', text, deltaTime });
+    const controller = (controllerType, value, deltaTime = 0) => ({ type: 'channel', subtype: 'controller', controllerType, value, deltaTime, channel: 0 });
+    const controllerOf = (event) => event.type === 'damper' ? MIDIControlEvents.SUSTAIN : MIDIControlEvents.SOFT_PEDAL;
+    midi.push(text(`linked-rolls (${systemName})`));
+    if (source) {
+        midi.push(text(source));
+    }
+    for (const [key, value] of Object.entries(options)) {
+        midi.push(text(`${key}=${typeof value === 'object' ? JSON.stringify(value) : value}`));
+    }
+    midi.push({
+        type: 'meta',
+        subtype: 'setTempo',
+        microsecondsPerBeat: 1000000,
+        deltaTime: 0
+    });
+    // both pedals start at rest
+    midi.push(controller(MIDIControlEvents.SUSTAIN, 0), controller(MIDIControlEvents.SOFT_PEDAL, 0));
+    // a pedal step is labelled with its command only where that
+    // command changes, so the file is not swamped with labels
+    const lastCause = {};
+    let currentTick = 0;
+    for (const event of events.toSorted((a, b) => a.at - b.at)) {
+        const tick = Math.round(event.at * TICKS_PER_SECOND);
+        const deltaTime = tick - currentTick;
+        currentTick = tick;
+        if (event.type === 'noteOn') {
+            midi.push(text(event.performs.id, deltaTime));
+            midi.push({
+                type: 'channel',
+                subtype: 'noteOn',
+                noteNumber: event.pitch,
+                velocity: +event.velocity.toFixed(0),
+                deltaTime: 0,
+                channel: 0
+            });
+        }
+        else if (event.type === 'noteOff') {
+            midi.push({
+                type: 'channel',
+                subtype: 'noteOff',
+                noteNumber: event.pitch,
+                velocity: 127,
+                deltaTime,
+                channel: 0
+            });
+        }
+        else {
+            const labelled = lastCause[event.type] === event.performs.id;
+            lastCause[event.type] = event.performs.id;
+            if (!labelled) {
+                midi.push(text(event.performs.id, deltaTime));
+            }
+            midi.push(controller(controllerOf(event), event.value, labelled ? deltaTime : 0));
+        }
+    }
+    return {
+        header: {
+            ticksPerBeat: TICKS_PER_SECOND,
+            formatType: 0,
+            trackCount: 1
+        },
+        tracks: [midi]
+    };
+};
+/**
+ * A version of the edition, performed and kept: `emulate` and `midiOf`
+ * with the result held on the object between the two calls. Prefer the
+ * functions where nothing needs holding.
+ */
+export class Emulation {
+    constructor(system, options = system.defaultOptions) {
+        Object.defineProperty(this, "system", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "midiEvents", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        // sorted list of events with the negotiated assumptions already applied
+        Object.defineProperty(this, "negotiatedEvents", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "curves", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "source", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.system = system;
+        this.options = options;
+    }
+    /** Moves the negotiated events to where their statements put them; see `withPlacementsApplied`. */
+    applyConstraints(view) {
+        this.negotiatedEvents = withPlacementsApplied(view, this.negotiatedEvents);
+    }
+    emulateVersion(version, view, scope = {}) {
+        const emulated = emulate(this.system, version, view, this.options, scope);
+        this.source = emulated.source;
+        this.negotiatedEvents = [...emulated.negotiated];
+        this.curves = emulated.curves;
+        this.midiEvents = [...emulated.events];
+        return this.midiEvents;
+    }
+    findEventsPerforming(id) {
+        return this.midiEvents.filter(event => event.performs.id === id);
+    }
+    asMIDI() {
+        return midiOf(this.midiEvents, this.system.name, this.options, this.source);
+    }
+}

package/lib/emulation/negotiation.d.ts

@@ -0,0 +1,14 @@
+import type { EditionView } from "../view/EditionView.js";
+import type { Expression, Note } from "../model/Symbol.js";
+import type { TrackerBar } from "../systems/TrackerBar.js";
+import type { NegotiatedEvent } from "../systems/ReproducingSystem.js";
+/**
+ * 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.
+ */
+export declare const negotiatedEventOf: (view: EditionView, symbol: Note | Expression, bar: TrackerBar) => NegotiatedEvent | null;

package/lib/emulation/negotiation.js

@@ -0,0 +1,20 @@
+/**
+ * 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.
+ */
+export const negotiatedEventOf = (view, symbol, bar) => {
+    const horizontal = view.placeOf(symbol);
+    const position = bar.positionOf(symbol);
+    if (!horizontal || position === undefined)
+        return null;
+    return {
+        ...symbol,
+        horizontal,
+        vertical: { unit: 'track', from: position }
+    };
+};

package/lib/index.d.ts

@@ -1,43 +1,51 @@
-export * from './utils.js';
-export * from './Quantity.js';
-export * from './Agent.js';
-export * from './Assumption.js';
-export * from './ConditionState.js';
-export * from './Symbol.js';
-export * from './Feature.js';
-export * from './Edit.js';
-export * from './Version.js';
-export * from './Collation.js';
-export * from './TrackCalibration.js';
-export * from './TrackerBar.js';
+/**
+ * The public interface of the library. Everything else under lib/ is its
+ * implementation and may change in any release: the in-place helpers the
+ * operations are built from, the date conversions of the serialisation,
+ * and the general utilities.
+ */
+export type { WithId, WithNote, WithType } from './shared/utils.js';
+export * from './model/Quantity.js';
+export * from './model/Agent.js';
+export * from './model/Assumption.js';
+export * from './model/ConditionState.js';
+export * from './model/Symbol.js';
+export * from './model/Feature.js';
+export * from './model/Edit.js';
+export * from './model/Version.js';
+export * from './collation/Collation.js';
+export * from './model/TrackCalibration.js';
+export * from './systems/TrackerBar.js';
 export * from './systems/welteT100/bar.js';
 export * from './systems/welteLicensee/bar.js';
 export * from './systems/welteT98/bar.js';
 export * from './systems/index.js';
-export * from './ReproducingSystem.js';
-export * from './FeatureSource.js';
-export * from './Perforator.js';
-export * from './RollCopy.js';
-export * from './procedures.js';
-export * from './vocabulary.js';
-export * from './reservations.js';
-export * from './witnesses.js';
-export * from './alignment.js';
-export * from './statistics.js';
-export * from './Edition.js';
-export * from './EditionView.js';
-export * from './scatter.js';
-export * from './editionOps.js';
-export * from './Emulation.js';
+export * from './systems/ReproducingSystem.js';
+export * from './model/FeatureSource.js';
+export * from './model/Perforator.js';
+export * from './model/RollCopy.js';
+export * from './model/procedures.js';
+export * from './model/vocabulary.js';
+export * from './analysis/reservations.js';
+export * from './analysis/witnesses.js';
+export { alignFeatures, tooShortToShorten, type AlignmentResult } from './collation/alignment.js';
+export * from './collation/statistics.js';
+export * from './model/Edition.js';
+export * from './view/EditionView.js';
+export * from './analysis/ownPaper.js';
+export * from './emulation/negotiation.js';
+export * from './collation/scatter.js';
+export * from './ops/index.js';
+export * from './emulation/Emulation.js';
 export * from './validate.js';
-export * from './constraints.js';
-export * from './substitution.js';
-export * from './context.js';
-export * from './sigla.js';
-export * from './notes.js';
-export * from './asJsonLd.js';
-export * from './importJsonLd.js';
-export * from './migrate.js';
+export * from './analysis/constraints.js';
+export * from './collation/substitution.js';
+export * from './io/context.js';
+export * from './analysis/sigla.js';
+export * from './model/notes.js';
+export { asJsonLd } from './io/asJsonLd.js';
+export { importJsonLd } from './io/importJsonLd.js';
+export { formatVersion, migrate } from './io/migrate.js';
 export { readFromStanfordAton, type StanfordAtonOptions } from './readers/stanfordAton.js';
 export { readFromPhillipsEroll, CONTROL_OFFSET, phillipsSystems, type PhillipsErollOptions } from './readers/phillipsEroll.js';
 export { readFromSpencerBar, readSpencerAnn, paperSpeedOfSpencerAnn, SPENCER_ROWS_PER_INCH, type SpencerBarOptions } from './readers/spencerBar.js';

package/lib/index.js

@@ -1,43 +1,44 @@
-export * from './utils.js';
-export * from './Quantity.js';
-export * from './Agent.js';
-export * from './Assumption.js';
-export * from './ConditionState.js';
-export * from './Symbol.js';
-export * from './Feature.js';
-export * from './Edit.js';
-export * from './Version.js';
-export * from './Collation.js';
-export * from './TrackCalibration.js';
-export * from './TrackerBar.js';
+export * from './model/Quantity.js';
+export * from './model/Agent.js';
+export * from './model/Assumption.js';
+export * from './model/ConditionState.js';
+export * from './model/Symbol.js';
+export * from './model/Feature.js';
+export * from './model/Edit.js';
+export * from './model/Version.js';
+export * from './collation/Collation.js';
+export * from './model/TrackCalibration.js';
+export * from './systems/TrackerBar.js';
 export * from './systems/welteT100/bar.js';
 export * from './systems/welteLicensee/bar.js';
 export * from './systems/welteT98/bar.js';
 export * from './systems/index.js';
-export * from './ReproducingSystem.js';
-export * from './FeatureSource.js';
-export * from './Perforator.js';
-export * from './RollCopy.js';
-export * from './procedures.js';
-export * from './vocabulary.js';
-export * from './reservations.js';
-export * from './witnesses.js';
-export * from './alignment.js';
-export * from './statistics.js';
-export * from './Edition.js';
-export * from './EditionView.js';
-export * from './scatter.js';
-export * from './editionOps.js';
-export * from './Emulation.js';
+export * from './systems/ReproducingSystem.js';
+export * from './model/FeatureSource.js';
+export * from './model/Perforator.js';
+export * from './model/RollCopy.js';
+export * from './model/procedures.js';
+export * from './model/vocabulary.js';
+export * from './analysis/reservations.js';
+export * from './analysis/witnesses.js';
+export { alignFeatures, tooShortToShorten } from './collation/alignment.js';
+export * from './collation/statistics.js';
+export * from './model/Edition.js';
+export * from './view/EditionView.js';
+export * from './analysis/ownPaper.js';
+export * from './emulation/negotiation.js';
+export * from './collation/scatter.js';
+export * from './ops/index.js';
+export * from './emulation/Emulation.js';
 export * from './validate.js';
-export * from './constraints.js';
-export * from './substitution.js';
-export * from './context.js';
-export * from './sigla.js';
-export * from './notes.js';
-export * from './asJsonLd.js';
-export * from './importJsonLd.js';
-export * from './migrate.js';
+export * from './analysis/constraints.js';
+export * from './collation/substitution.js';
+export * from './io/context.js';
+export * from './analysis/sigla.js';
+export * from './model/notes.js';
+export { asJsonLd } from './io/asJsonLd.js';
+export { importJsonLd } from './io/importJsonLd.js';
+export { formatVersion, migrate } from './io/migrate.js';
 export { readFromStanfordAton } from './readers/stanfordAton.js';
 export { readFromPhillipsEroll, CONTROL_OFFSET, phillipsSystems } from './readers/phillipsEroll.js';
 export { readFromSpencerBar, readSpencerAnn, paperSpeedOfSpencerAnn, SPENCER_ROWS_PER_INCH } from './readers/spencerBar.js';

package/lib/{asJsonLd.d.ts → io/asJsonLd.d.ts}

@@ -1,4 +1,4 @@
-import { Edition } from "./Edition.js";
+import { Edition } from "../model/Edition.js";
 /**
  * The keys an export derives from the tree, which no node of the
  * edition states itself. An import reads them off again.

package/lib/{asJsonLd.js → io/asJsonLd.js}

@@ -1,11 +1,12 @@
-import { systemIdIn } from "./TrackerBar.js";
-import { certaintyOf, isAsserted } from "./Assumption.js";
-import context from "./spec/context.json" with { type: 'json' };
+import { systemIdIn } from "../systems/TrackerBar.js";
+import { certaintyOf, isAsserted } from "../model/Assumption.js";
+import context from "../spec/context.json" with { type: 'json' };
+import { formatVersion } from "./migrate.js";
 /**
  * The keys an export derives from the tree, which no node of the
  * edition states itself. An import reads them off again.
  */
-export const derivedKeys = new Set(['bears', 'composedOf', 'augmented', 'diminished']);
+export const derivedKeys = new Set(['augmented', 'diminished']);
 export const exportDate = (date) => {
     const year = date.getFullYear();
     const month = String(date.getMonth() + 1).padStart(2, "0");
@@ -53,32 +54,12 @@ const asJsonLdEntity = (obj) => {
  * reading as whichever came last. An embedded context merges with the
  * active one, so the shared prefixes survive.
  */
-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;
+const withSystemContext = (version) => {
+    const system = systemIdIn(version?.system?.['@id']);
+    return system ? { '@context': `https://w3id.org/reo/${system}/context.jsonld`, ...version } : version;
 };
+const withSystemContexts = (edition) => Array.isArray(edition.versions) ? { ...edition, versions: edition.versions.map(withSystemContext) } : edition;
 const isRecord = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
-const nodesIn = (value) => Array.isArray(value) ? value.filter(isRecord) : [];
-/** What the acts of a copy brought onto it: the features they produced and the patches they glued on. */
-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'] === 'Patch') === patches && typeof node['@id'] === 'string')
-    .map(node => ({ '@id': node['@id'] }));
-const featuresAmong = (nodes) => referencing(nodes, false);
-const patchesAmong = (nodes) => referencing(nodes, true);
-/** The key, where there is anything to state under it. */
-const stating = (key, references) => references.length > 0 ? { [key]: references } : {};
 /** The act with what it changed named: an attachment augments the copy, a removal diminishes it. */
 const changing = (copyId) => (act) => {
     if (typeof copyId !== 'string' || !isRecord(act))
@@ -90,31 +71,21 @@ const changing = (copyId) => (act) => {
     return act;
 };
 /**
- * The document with every bearing stated that its tree only implies. A
- * copy bears the features its acts brought about and is composed of the
- * patches they glued on, a patch bears the features glued onto it in
- * turn. Each feature stands in the act that made it and nothing reads a
- * bearing off that, so the export states it; a patch is no feature, and
- * P56 bears feature takes only features, so a patch is stated as a part.
+ * The document with what each act changed stated. Which of P110
+ * augmented and P112 diminished applies depends on the class of the
+ * act, which no property chain in OWL 2 RL can test, so the export
+ * states it. What a copy or a patch bears is left to a reasoner (see
+ * the entailments in reo.ttl).
  */
-const withBearings = (value) => {
+const withChanges = (value) => {
     if (Array.isArray(value))
-        return value.map(withBearings);
+        return value.map(withChanges);
     if (!isRecord(value))
         return value;
-    const node = Object.fromEntries(Object.entries(value).map(([key, child]) => [key, withBearings(child)]));
-    if (node['@type'] === 'RollCopy') {
-        const made = madeOn(node);
-        return {
-            ...node,
-            ...(Array.isArray(node.modifications) && { modifications: node.modifications.map(changing(node['@id'])) }),
-            ...stating('bears', featuresAmong(made)),
-            ...stating('composedOf', patchesAmong(made))
-        };
-    }
-    if (node['@type'] === 'Patch')
-        return { ...node, ...stating('bears', featuresAmong(nodesIn(node.features))) };
-    return node;
+    const node = Object.fromEntries(Object.entries(value).map(([key, child]) => [key, withChanges(child)]));
+    return node['@type'] === 'RollCopy' && Array.isArray(node.modifications)
+        ? { ...node, modifications: node.modifications.map(changing(node['@id'])) }
+        : node;
 };
 /** Terms the context sets to null, which say nothing when the edition is read as RDF. */
 const silentTerms = new Set(Object.entries(context['@context'])
@@ -182,7 +153,7 @@ const withDoubtedReferencesQuoted = (value) => {
     };
 };
 export const asJsonLd = (edition) => {
-    const { node, quoted } = withDoubtedReferencesQuoted(withSystemContexts(withBearings(asJsonLdEntity(edition))));
+    const { node, quoted } = withDoubtedReferencesQuoted(withSystemContexts(withChanges(asJsonLdEntity(edition))));
     // The context is the export's own; one carried in from an import must not override it.
     const { base, '@context': carried, ...rest } = node;
     return {
@@ -192,8 +163,8 @@ export const asJsonLd = (edition) => {
                 '@base': edition.base
             }
         ],
-        '@type': "Edition",
         '@id': edition.base,
+        formatVersion,
         ...rest,
         ...(quoted.length > 0 && { '@included': quoted })
     };

package/lib/{context.d.ts → io/context.d.ts}

@@ -1,12 +1,12 @@
-export { default as jsonLdContext } from './spec/context.json';
+export { default as jsonLdContext } from '../spec/context.json';
 /** The context of the Welte-Mignon T-100, added to a version coded for it. */
-export { default as welteT100JsonLdContext } from './spec/welte-t100.context.json';
+export { default as welteT100JsonLdContext } from '../spec/welte-t100.context.json';
 /**
  * The context of the Welte-Mignon Licensee. Its expression terms are
  * the T-100's, the two systems differing in the tracker scale rather
  * than in the coding, so it reads them out of the T-100's vocabulary
  * rather than minting a second set of IRIs for the same commands.
  */
-export { default as welteLicenseeJsonLdContext } from './spec/welte-licensee.context.json';
+export { default as welteLicenseeJsonLdContext } from '../spec/welte-licensee.context.json';
 /** The context of the Welte-Mignon T-98, added to an edition of a green roll. */
-export { default as welteT98JsonLdContext } from './spec/welte-t98.context.json';
+export { default as welteT98JsonLdContext } from '../spec/welte-t98.context.json';

package/lib/{context.js → io/context.js}

@@ -1,12 +1,12 @@
-export { default as jsonLdContext } from './spec/context.json' with { type: 'json' };
+export { default as jsonLdContext } from '../spec/context.json' with { type: 'json' };
 /** The context of the Welte-Mignon T-100, added to a version coded for it. */
-export { default as welteT100JsonLdContext } from './spec/welte-t100.context.json' with { type: 'json' };
+export { default as welteT100JsonLdContext } from '../spec/welte-t100.context.json' with { type: 'json' };
 /**
  * The context of the Welte-Mignon Licensee. Its expression terms are
  * the T-100's, the two systems differing in the tracker scale rather
  * than in the coding, so it reads them out of the T-100's vocabulary
  * rather than minting a second set of IRIs for the same commands.
  */
-export { default as welteLicenseeJsonLdContext } from './spec/welte-licensee.context.json' with { type: 'json' };
+export { default as welteLicenseeJsonLdContext } from '../spec/welte-licensee.context.json' with { type: 'json' };
 /** The context of the Welte-Mignon T-98, added to an edition of a green roll. */
-export { default as welteT98JsonLdContext } from './spec/welte-t98.context.json' with { type: 'json' };
+export { default as welteT98JsonLdContext } from '../spec/welte-t98.context.json' with { type: 'json' };

package/lib/{importJsonLd.d.ts → io/importJsonLd.d.ts}

@@ -1,4 +1,4 @@
-import { Edition } from "./Edition.js";
+import { Edition } from "../model/Edition.js";
 export declare const importDate: (str: string) => Date;
 type Json = any;
 export declare const importJsonLd: (json: Json) => Edition;