linked-rolls 0.56.0 → 0.58.0

package/lib/systems/welteT98/system.js

@@ -1,9 +1,10 @@
-import { geometryInMm, Grid, levelChanges, mezzoforteTravel, paperSeconds, pedalBrushing, pedalDefaults, ROWS_PER_MM, travelBetweenRails, WELTE_T98_SPOOL, } from "welte-mignon-emulator";
+import { pedalBrushing, pedalDefaults, ROWS_PER_MM, WELTE_T98_SPOOL, } from "welte-mignon-emulator";
 import { aperturePorts, CHAIN_GAP_MM, DERIVED, GENUINE, instrumentT98Of, labelOf, nuanceOf, PUNCH_T98_MM, pneumaticT98Model, rewindAt, runPedals, sforzandoPianoLift, STARTING_VALUES, TRACKER_BORE_T98_MM, } from "welte-mignon-emulator/t98";
 import { welteT98 } from "./bar.js";
-import { inCentimeters, mm, seconds, track } from "../../Quantity.js";
-import { partitionPoint } from "../../sorted.js";
-import { defaultVelocityMap, velocityOf } from "../velocity.js";
+import { mm, seconds, track } from "../../model/Quantity.js";
+import { defaultVelocityMap } from "../velocity.js";
+import { performWelte, sameParameters } from "../welte.js";
+export { secondsAt } from "../welte.js";
 /**
  * The instruments the emulator offers for the green Welte, in three groups that
  * answer three different questions and must not be listed as one.
@@ -37,8 +38,6 @@ export const instrumentNames = [
     ...Object.keys(DERIVED).map(derived => ({ derived })),
     { unfitted: 'starting-values' }
 ];
-const sameParameters = (a, b) => Object.keys(a).length === Object.keys(b).length
-    && Object.entries(a).every(([name, value]) => b[name] === value);
 /** The instrument a pair of nuancing constants belongs to, if it is one. */
 export const instrumentNameOf = (nuance) => instrumentNames.find(name => {
     const instrument = instrumentT98Of(name);
@@ -86,98 +85,10 @@ const CODES = {
     SoftPedal: 'hammerRail'
 };
 const isWelteT98ExpressionType = (type) => Object.hasOwn(CODES, type);
-const codeOf = (expressionType) => isWelteT98ExpressionType(expressionType) ? CODES[expressionType] : undefined;
-/** Paper the grid runs on past the last hole, so that a final pedal release completes. */
-const RUN_OUT = mm(100);
-const isNote = (event) => event.type === 'note';
-const isExpression = (event) => event.type === 'expression';
-const paperOf = (toOwnPaper) => ({
-    rowOf: place => place * toOwnPaper * ROWS_PER_MM,
-    placeOfRow: row => mm(row / (toOwnPaper * ROWS_PER_MM)),
-    paperOfRow: row => mm(row / ROWS_PER_MM)
-});
-/** When the spool brings a place on the roll to the tracker bar. */
-export const secondsAt = (spool, place) => seconds(paperSeconds(spool, inCentimeters(place)));
-const halfOf = (note, division) => note.vertical.from >= division ? 'treble' : 'bass';
-const readingOf = (paper) => (event) => {
-    const control = codeOf(event.expressionType);
-    if (!control)
-        return undefined;
-    const half = event.scope;
-    return {
-        event,
-        punch: {
-            half,
-            control,
-            rowOn: paper.rowOf(event.horizontal.from),
-            rowOff: paper.rowOf(event.horizontal.to)
-        }
-    };
-};
-const clamp = (value, low, high) => Math.min(Math.max(value, low), high);
-/**
- * One sample per row of the scan the constants were fitted on, from the
- * beginning of the roll to a little past the last hole.
- */
-const gridOver = (events, spool, paper) => {
-    const last = mm(events.reduce((furthest, event) => Math.max(furthest, event.horizontal.to), 0));
-    const length = Math.ceil(paper.rowOf(last) + RUN_OUT * ROWS_PER_MM) + 1;
-    const times = new Float64Array(length).map((_, row) => secondsAt(spool, paper.paperOfRow(row)));
-    return new Grid(0, times);
-};
-const nuanceCurves = (grid, ports, samples, options) => {
-    const instrument = `Welte-Mignon T-98, ${labelOf(options.instrument)}`;
-    const curveOf = (half) => {
-        const params = options.nuance[half];
-        const output = pneumaticT98Model.run({ grid, half, ports }, params);
-        const travel = travelBetweenRails(output, params);
-        const hook = clamp(mezzoforteTravel(params), 0.01, 0.99);
-        return {
-            ...samples,
-            name: half,
-            kind: 'dynamics',
-            instrument,
-            travel,
-            velocity: travel.map(value => velocityOf(value, hook, options.velocity))
-        };
-    };
-    return { bass: curveOf('bass'), treble: curveOf('treble') };
-};
-const pedalCurves = (grid, ports, samples, options) => {
-    const travel = runPedals({ grid, ports }, options.pedals);
-    return {
-        damper: { ...samples, name: 'damper', kind: 'pedal', travel: travel.damper },
-        hammerRail: { ...samples, name: 'hammerRail', kind: 'pedal', travel: travel.hammerRail }
-    };
-};
-const performNotes = (events, grid, nuance, options, paper) => events
-    .filter(isNote)
-    .flatMap((note) => {
-    const curve = nuance[halfOf(note, options.division)];
-    const velocity = curve.velocity[grid.indexOfRow(paper.rowOf(note.horizontal.from))];
-    return [
-        { type: 'noteOn', performs: note, pitch: note.pitch, velocity, at: secondsAt(options.spool, note.horizontal.from) },
-        { type: 'noteOff', performs: note, pitch: note.pitch, velocity: 127, at: secondsAt(options.spool, note.horizontal.to) }
-    ];
-});
-/**
- * The travel of one pedal as controller steps, each attributed to the last
- * perforation of that pedal the tracker bar has reached.
- */
-const performPedal = (type, curve, grid, readings, mode) => {
-    if (readings.length === 0)
-        return [];
-    const ordered = readings.toSorted((a, b) => a.punch.rowOn - b.punch.rowOn);
-    const causeOf = (row) => ordered[Math.max(partitionPoint(ordered, reading => reading.punch.rowOn <= row) - 1, 0)].event;
-    return levelChanges(curve.travel, { mode })
-        .filter(change => change.index > 0)
-        .map(change => ({
-        type,
-        performs: causeOf(grid.rowAt(change.index)),
-        value: change.value,
-        at: seconds(curve.seconds[change.index])
-    }));
-};
+/** The punch a T-98 expression is read as: its control, held for as long as it runs. */
+const punchOf = (event, rows) => isWelteT98ExpressionType(event.expressionType)
+    ? { half: event.scope, control: CODES[event.expressionType], ...rows }
+    : undefined;
 /**
  * The row at which the Abstellbalg trips and the roll goes back, or the end of
  * the grid where it never does. The shut-off hangs on the bass sforzando-piano
@@ -199,36 +110,24 @@ const cutCurve = (curve, rows) => ({
     ...(curve.kind === 'dynamics' ? { velocity: curve.velocity.slice(0, rows) } : {})
 });
 /**
- * The edition's tempo adjustment is left aside, as on the T-100: it is stated as
- * a paper speed, and what the spool holds constant is its rate of revolution.
+ * The shared Welte performance, cut off where the rewind takes hold unless
+ * the options ignore it.
  */
 const perform = (events, options, roll) => {
-    const paper = paperOf(roll.toOwnPaper ?? 1);
-    const readings = events
-        .filter(isExpression)
-        .map(readingOf(paper))
-        .filter((reading) => reading !== undefined);
-    const grid = gridOver(events, options.spool, paper);
-    const geometry = geometryInMm(roll.punchDiameter ?? options.punchDiameter, options.trackerBore);
     const gap = options.chainGap * ROWS_PER_MM;
-    const ports = aperturePorts(grid, readings.map(reading => reading.punch), geometry, gap);
-    const samples = {
-        place: grid.seconds.map((_, row) => paper.placeOfRow(row)),
-        seconds: grid.seconds
-    };
-    const nuance = nuanceCurves(grid, ports, samples, options);
-    const pedals = pedalCurves(grid, ports, samples, options);
-    const readingsOf = (control) => readings.filter(reading => reading.punch.control === control);
+    const { grid, ports, events: performed, curves } = performWelte(events, options, roll, {
+        punchOf,
+        portsOf: (grid, punches, geometry) => aperturePorts(grid, punches, geometry, gap),
+        model: pneumaticT98Model,
+        runPedals,
+        instrument: `Welte-Mignon T-98, ${labelOf(options.instrument)}`
+    });
     const stops = rewindRow(grid, ports, options);
     const until = seconds(grid.seconds[Math.min(stops, grid.length - 1)]);
     const rows = Math.min(stops + 1, grid.length);
     return {
-        events: truncated([
-            ...performNotes(events, grid, nuance, options, paper),
-            ...performPedal('damper', pedals.damper, grid, readingsOf('sustainPedal'), options.pedalMode),
-            ...performPedal('hammerRail', pedals.hammerRail, grid, readingsOf('hammerRail'), options.pedalMode)
-        ], until),
-        curves: [nuance.bass, nuance.treble, pedals.damper, pedals.hammerRail].map(curve => cutCurve(curve, rows))
+        events: truncated(performed, until),
+        curves: curves.map(curve => cutCurve(curve, rows))
     };
 };
 /**

package/lib/validate.d.ts

@@ -1,5 +1,5 @@
 import { type ErrorObject } from "ajv";
-import { Edition } from "./Edition.js";
+import { Edition } from "./model/Edition.js";
 /**
  * Holds a document against the edition schema. `errors` says what the
  * last call found wrong, and is empty where it found nothing.

package/lib/{EditionView.d.ts → view/EditionView.d.ts}

@@ -1,19 +1,13 @@
-import { Edition } from "./Edition.js";
-import { HorizontalSpan, FeatureOrPatch } from "./Feature.js";
-import { AnySymbol, Expression, Note } from "./Symbol.js";
-import { Version } from "./Version.js";
-import { NegotiatedEvent } from "./ReproducingSystem.js";
-import { TrackerBar } from "./TrackerBar.js";
-import { Modification, ProductionEvent, RollCopy } from "./RollCopy.js";
-import { Millimeters } from "./Quantity.js";
+import { Edition } from "../model/Edition.js";
+import { FeatureOrPatch, HorizontalSpan, NestedFeature } from "../model/Feature.js";
+import { AnySymbol } from "../model/Symbol.js";
+import { Version } from "../model/Version.js";
+import { Modification, ProductionEvent, RollCopy } from "../model/RollCopy.js";
+import { Millimeters } from "../model/Quantity.js";
 export type Path = (string | number)[];
 export declare const getAt: <T>(path: Path, obj: unknown) => T | undefined;
 export declare class EditionView {
     readonly edition: Edition;
-    /**
-     * Map from id to object
-     */
-    private readonly byId;
     /**
      * Map from id to its path within the edition
      */
@@ -24,17 +18,46 @@ export declare class EditionView {
     private readonly links;
     /** Built when a copy is first asked for, the walk not recording it. */
     private copiesByFeature?;
+    /**
+     * One index for each kind of entity, built from where the edition
+     * holds it. The index an entity is found in says what it is, so a
+     * lookup needs neither a type discriminator nor a cast.
+     */
+    private readonly versionsById;
+    private readonly copiesById;
+    private readonly symbolsById;
+    private featuresById?;
     constructor(edition: Edition);
+    /** What stands at the path, or null where nothing does. A zero or an empty string stands there as well. */
     atPath<T>(path: Path): T | null;
+    /**
+     * Walks the edition and records where each id stands and where it is
+     * referenced. The constructor does this; a second call starts afresh
+     * rather than recording every reference twice.
+     */
     indexObjects(): void;
-    get<T>(anyId: string): T | undefined;
-    getAll<T>(anyIds: readonly string[]): T[];
+    version(id: string): Readonly<Version> | undefined;
+    copy(id: string): Readonly<RollCopy> | undefined;
+    symbol(id: string): Readonly<AnySymbol> | undefined;
+    /** The symbols under the ids, leaving out an id that names none. */
+    symbols(ids: readonly string[]): Readonly<AnySymbol>[];
+    /** A feature or a patch on any copy, one a patch bears included. */
+    feature(id: string): Readonly<NestedFeature> | undefined;
+    /** The features and patches under the ids, leaving out an id that names none. */
+    features(ids: readonly string[]): Readonly<NestedFeature>[];
     getPath(anyId: string): Path | undefined;
     linksTo(anyId: string): Path[];
+    /**
+     * Calls back on the version and its ancestors along the principal
+     * line. A stemma that loops back on itself is walked once round, so
+     * that an edition in that state can still be read and repaired.
+     */
     travelUp(versionId: string, callback: (version: Readonly<Version>) => void): void;
     /** The version and its ancestors along the principal line, from the version up to the root. */
     lineageOf(versionId: string): Readonly<Version>[];
-    carriersOf(symbol: AnySymbol): Readonly<FeatureOrPatch>[];
+    carriersOf(symbol: AnySymbol): Readonly<NestedFeature>[];
+    /** The carriers that state a place of their own, which a feature on a patch does not. */
+    placedCarriersOf(symbol: AnySymbol): Readonly<FeatureOrPatch>[];
     /** The copy a feature sits on, a patch and everything it bears included. */
     copyOf(featureId: string): Readonly<RollCopy> | undefined;
     /**
@@ -46,29 +69,6 @@ export declare class EditionView {
      * `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.
-     *
-     * 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>[];
     /** The version the given one's text is read against, by its principal derivation. */
     predecessorOf(versionId: string): Readonly<Version> | undefined;
     /**
@@ -100,14 +100,4 @@ export declare class EditionView {
     withGenerations(): Array<Version & {
         generation: number;
     }>;
-    /**
-     * 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 → view/EditionView.js}

@@ -1,9 +1,8 @@
-import { withBorneFeatures } from "./Feature.js";
-import { deletedBy, insertedBy, principalDerivationOf } from "./Version.js";
-import { systemIdOf } from "./TrackerBar.js";
-import { featuresMadeBy, featuresOf, isPaperStretch } from "./RollCopy.js";
-import { idOf, idsOf } from "./Assumption.js";
-import { mean } from "./Quantity.js";
+import { isPlaced, withBorneFeatures } from "../model/Feature.js";
+import { deletedBy, insertedBy, principalDerivationOf } from "../model/Version.js";
+import { featuresMadeBy, featuresOf } from "../model/RollCopy.js";
+import { idOf, idsOf } from "../model/Assumption.js";
+import { mean } from "../model/Quantity.js";
 export const getAt = (path, obj) => {
     let node = obj;
     for (const key of path) {
@@ -15,6 +14,7 @@ export const getAt = (path, obj) => {
 };
 /** Keys under which an object names others by id, singly or in a list. */
 const referenceKeys = ['delete', 'comprehends', 'motivation', 'premises', 'used'];
+const byIdIn = (entities) => new Map(entities.map(entity => [entity.id, entity]));
 const isObject = (v) => v !== null && typeof v === "object";
 /** What a reference may state besides the id: a belief about it, and the tolerance a derivation was collated at. */
 const referenceOwnKeys = new Set(['id', '@annotation', 'collationTolerance']);
@@ -34,15 +34,6 @@ export class EditionView {
             writable: true,
             value: void 0
         });
-        /**
-         * Map from id to object
-         */
-        Object.defineProperty(this, "byId", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Map()
-        });
         /**
          * Map from id to its path within the edition
          */
@@ -68,14 +59,53 @@ export class EditionView {
             writable: true,
             value: void 0
         });
+        /**
+         * One index for each kind of entity, built from where the edition
+         * holds it. The index an entity is found in says what it is, so a
+         * lookup needs neither a type discriminator nor a cast.
+         */
+        Object.defineProperty(this, "versionsById", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "copiesById", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "symbolsById", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "featuresById", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.edition = edition;
+        this.versionsById = byIdIn(edition.versions);
+        this.copiesById = byIdIn(edition.copies);
+        this.symbolsById = byIdIn(edition.versions.flatMap(insertedBy));
         this.indexObjects();
     }
+    /** What stands at the path, or null where nothing does. A zero or an empty string stands there as well. */
     atPath(path) {
-        const node = getAt(path, this.edition);
-        return node || null;
+        return getAt(path, this.edition) ?? null;
     }
+    /**
+     * Walks the edition and records where each id stands and where it is
+     * referenced. The constructor does this; a second call starts afresh
+     * rather than recording every reference twice.
+     */
     indexObjects() {
+        this.paths.clear();
+        this.links.clear();
         const visited = new WeakSet();
         const link = (id, trail) => {
             const trails = this.links.get(id);
@@ -89,8 +119,7 @@ export class EditionView {
                 return;
             if (isReferenceOnly(keys))
                 link(record.id, { key: 'id', up: trail });
-            else if (!this.byId.has(record.id)) {
-                this.byId.set(record.id, record);
+            else if (!this.paths.has(record.id)) {
                 this.paths.set(record.id, trail);
             }
         };
@@ -120,11 +149,27 @@ export class EditionView {
         };
         traverse(this.edition, null);
     }
-    get(anyId) {
-        return this.byId.get(anyId);
+    version(id) {
+        return this.versionsById.get(id);
+    }
+    copy(id) {
+        return this.copiesById.get(id);
+    }
+    symbol(id) {
+        return this.symbolsById.get(id);
+    }
+    /** The symbols under the ids, leaving out an id that names none. */
+    symbols(ids) {
+        return ids.flatMap(id => this.symbol(id) ?? []);
     }
-    getAll(anyIds) {
-        return anyIds.map(id => this.get(id)).filter((v) => !!v);
+    /** A feature or a patch on any copy, one a patch bears included. */
+    feature(id) {
+        this.featuresById ?? (this.featuresById = byIdIn(this.edition.copies.flatMap(copy => featuresOf(copy).flatMap(withBorneFeatures))));
+        return this.featuresById.get(id);
+    }
+    /** The features and patches under the ids, leaving out an id that names none. */
+    features(ids) {
+        return ids.flatMap(id => this.feature(id) ?? []);
     }
     getPath(anyId) {
         const trail = this.paths.get(anyId);
@@ -133,14 +178,19 @@ export class EditionView {
     linksTo(anyId) {
         return (this.links.get(anyId) ?? []).map(pathOf);
     }
+    /**
+     * Calls back on the version and its ancestors along the principal
+     * line. A stemma that loops back on itself is walked once round, so
+     * that an edition in that state can still be read and repaired.
+     */
     travelUp(versionId, callback) {
-        const v = this.get(versionId);
-        if (!v)
-            return;
-        callback(v);
-        const principal = principalDerivationOf(v);
-        if (principal) {
-            this.travelUp(idOf(principal), callback);
+        const visited = new Set();
+        let v = this.version(versionId);
+        while (v && !visited.has(v.id)) {
+            visited.add(v.id);
+            callback(v);
+            const principal = principalDerivationOf(v);
+            v = principal && this.version(idOf(principal));
         }
     }
     /** The version and its ancestors along the principal line, from the version up to the root. */
@@ -150,7 +200,11 @@ export class EditionView {
         return lineage;
     }
     carriersOf(symbol) {
-        return this.getAll(idsOf(symbol.carriers));
+        return this.features(idsOf(symbol.carriers));
+    }
+    /** The carriers that state a place of their own, which a feature on a patch does not. */
+    placedCarriersOf(symbol) {
+        return this.carriersOf(symbol).filter(isPlaced);
     }
     /** The copy a feature sits on, a patch and everything it bears included. */
     copyOf(featureId) {
@@ -178,51 +232,11 @@ export class EditionView {
             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.
-     *
-     * 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);
-    }
     /** The version the given one's text is read against, by its principal derivation. */
     predecessorOf(versionId) {
-        const v = this.get(versionId);
+        const v = this.version(versionId);
         const principal = v && principalDerivationOf(v);
-        return principal && this.get(idOf(principal));
+        return principal && this.version(idOf(principal));
     }
     /**
      * Where along the roll the symbol lies, as its carriers put it, or
@@ -238,7 +252,7 @@ export class EditionView {
      * position a semitone away on either bar.
      */
     placeOf(symbol) {
-        const carriers = this.getAll(idsOf(symbol.carriers));
+        const carriers = this.placedCarriersOf(symbol);
         if (carriers.length === 0)
             return;
         return {
@@ -282,7 +296,7 @@ export class EditionView {
             if (inStack.has(id)) {
                 throw new Error(`Cycle detected involving node '${id}'. Check parentId links.`);
             }
-            const node = this.get(id);
+            const node = this.version(id);
             if (!node) {
                 memo.set(id, 0);
                 return 0;
@@ -294,7 +308,7 @@ export class EditionView {
             if (basedOn === undefined) {
                 gen = 0; // root
             }
-            else if (!this.get(basedOn)) {
+            else if (!this.version(basedOn)) {
                 // Orphaned parent reference — treat boundary as root
                 gen = 0;
             }
@@ -312,24 +326,4 @@ export class EditionView {
         }));
         return withGen;
     }
-    /**
-     * 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,
-            horizontal,
-            vertical: { unit: 'track', from: position }
-        };
-    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linked-rolls",
-  "version": "0.56.0",
+  "version": "0.58.0",
   "description": "Digital editions of piano rolls: import, collation, editorial assumptions, JSON-LD export, and emulation through a reproducing system",
   "license": "MIT",
   "repository": {
@@ -16,6 +16,10 @@
       "types": "./lib/index.d.ts",
       "default": "./lib/index.js"
     },
+    "./validate": {
+      "types": "./lib/validate.d.ts",
+      "default": "./lib/validate.js"
+    },
     "./welte-t100": {
       "types": "./lib/systems/welteT100/system.d.ts",
       "default": "./lib/systems/welteT100/system.js"
@@ -28,7 +32,6 @@
       "types": "./lib/systems/welteLicensee/system.d.ts",
       "default": "./lib/systems/welteLicensee/system.js"
     },
-    "./lib/*": "./lib/*",
     "./package.json": "./package.json"
   },
   "files": [
@@ -40,6 +43,7 @@
     "build": "npm run build:schema && rm -rf lib && tsc",
     "prepublishOnly": "npm run build && vitest run && npm run smoke",
     "test": "vitest",
+    "lint": "oxlint -c .oxlintrc.json src test scripts schema",
     "build:schema": "npx ts-json-schema-generator --additional-properties --validation-keywords see --path 'src/**/*.ts' --type 'Edition' > schema_.json && node schema/postprocess.js && rm schema_.json && mv schema.json src/schema.json",
     "build:docs": "node schema/docs/generate.ts src/schema.json docs/index.html",
     "smoke": "node scripts/smoke.mjs"
@@ -50,6 +54,7 @@
     "@types/node": "^24.13.3",
     "jsonld": "^9.0.0",
     "n3": "^2.7.12",
+    "oxlint": "^1.85.0",
     "ts-json-schema-generator": "^2.9.0",
     "typescript": "^7.0.2",
     "vite": "^8.2.2",

package/lib/Emulation.d.ts

@@ -1,36 +0,0 @@
-import { MidiFile } from "midifile-ts";
-import { EditionView } from "./EditionView.js";
-import { Version } from "./Version.js";
-import { AnyPerformedRollFeature, EmulatedCurve, NegotiatedEvent, ReproducingSystem } from "./ReproducingSystem.js";
-import { Millimeters } from "./Quantity.js";
-export type EmulationScope = {
-    /** Only notes whose onset lies within this span of the roll are played. */
-    range?: [Millimeters, Millimeters];
-    /** Start the clock at the first note rather than at the beginning of the roll. */
-    skipToFirstNote?: boolean;
-};
-/**
- * A version of the edition, performed: the symbols are negotiated into
- * placed events, the reproducing system plays them, and the result goes
- * out as MIDI in which every note and pedal step is labelled with the
- * symbol it performs.
- */
-export declare class Emulation<Options extends object> {
-    readonly system: ReproducingSystem<Options>;
-    options: Options;
-    midiEvents: AnyPerformedRollFeature[];
-    negotiatedEvents: NegotiatedEvent[];
-    curves: readonly EmulatedCurve[];
-    source?: string;
-    constructor(system: ReproducingSystem<Options>, options?: Options);
-    /**
-     * 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 command 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;
-}