linked-rolls 0.44.0 → 0.46.0

package/lib/index.js

@@ -1,42 +1,42 @@
-export * from './utils';
-export * from './Quantity';
-export * from './Agent';
-export * from './Assumption';
-export * from './ConditionState';
-export * from './Symbol';
-export * from './Feature';
-export * from './Edit';
-export * from './Version';
-export * from './Collation';
-export * from './TrackCalibration';
-export * from './TrackerBar';
-export * from './systems/welteT100/bar';
-export * from './systems/welteLicensee/bar';
-export * from './systems/welteT98/bar';
-export * from './systems';
-export * from './ReproducingSystem';
-export * from './FeatureSource';
-export * from './RollCopy';
-export * from './procedures';
-export * from './vocabulary';
-export * from './reservations';
-export * from './witnesses';
-export * from './alignment';
-export * from './statistics';
-export * from './Edition';
-export * from './EditionView';
-export * from './scatter';
-export * from './editionOps';
-export * from './Emulation';
-export * from './validate';
-export * from './constraints';
-export * from './substitution';
-export * from './context';
-export * from './sigla';
-export * from './notes';
-export * from './asJsonLd';
-export * from './importJsonLd';
-export * from './migrate';
-export { readFromStanfordAton } from './readers/stanfordAton';
-export { readFromPhillipsEroll, CONTROL_OFFSET, phillipsSystems } from './readers/phillipsEroll';
-export { readFromSpencerBar, readSpencerAnn, paperSpeedOfSpencerAnn, SPENCER_ROWS_PER_INCH } from './readers/spencerBar';
+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 './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 './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 './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 { 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/migrate.js

@@ -1,9 +1,9 @@
-import { conditions, isFeatureType, media, techniques } from "./Feature";
-import { rollConditions } from "./RollCopy";
-import { systemIdIn, systemOf, translationBetween } from "./TrackerBar";
-import { trackerBars } from "./systems";
-import { welteT100 } from "./systems/welteT100/bar";
-import { isDateString } from "./utils";
+import { conditions, isFeatureType, media, techniques } from "./Feature.js";
+import { rollConditions } from "./RollCopy.js";
+import { systemIdIn, systemOf, translationBetween } from "./TrackerBar.js";
+import { trackerBars } from "./systems/index.js";
+import { welteT100 } from "./systems/welteT100/bar.js";
+import { isDateString } from "./utils.js";
 const retiredVersionTypes = new Set(['edition', 'unicum']);
 const conditionTypeValues = new Set([...rollConditions, ...Object.values(conditions).flat()]);
 const renamedKeys = {

package/lib/procedures.d.ts

@@ -1,4 +1,4 @@
-import { Concept } from "./Agent";
+import { Concept } from "./Agent.js";
 /**
  * The procedures the type vocabulary declares, for a consumer that has
  * to offer them. The names are the German labels of the concepts, which

package/lib/readers/phillipsEroll.d.ts

@@ -1,6 +1,6 @@
-import { RollCopy } from "../RollCopy";
-import { TrackerBar } from "../TrackerBar";
-import { Millimeters, Seconds } from "../Quantity";
+import { RollCopy } from "../RollCopy.js";
+import { TrackerBar } from "../TrackerBar.js";
+import { Millimeters, Seconds } from "../Quantity.js";
 /**
  * Peter Phillips's "e-roll" file, the unprocessed output of his
  * pneumatic roll reader (thesis pp. 182–196): the roll runs over a

package/lib/readers/phillipsEroll.js

@@ -1,10 +1,10 @@
 import { read } from "midifile-ts";
 import { v4 } from "uuid";
-import { assignObject } from "../Assumption";
-import { systemOf } from "../TrackerBar";
-import { welteT100 } from "../systems/welteT100/bar";
-import { welteLicensee } from "../systems/welteLicensee/bar";
-import { inMetersPerMinute, mm, seconds, track } from "../Quantity";
+import { assignObject } from "../Assumption.js";
+import { systemOf } from "../TrackerBar.js";
+import { welteT100 } from "../systems/welteT100/bar.js";
+import { welteLicensee } from "../systems/welteLicensee/bar.js";
+import { inMetersPerMinute, mm, seconds, track } from "../Quantity.js";
 /**
  * Peter Phillips's "e-roll" file, the unprocessed output of his
  * pneumatic roll reader (thesis pp. 182–196): the roll runs over a

package/lib/readers/spencerBar.d.ts

@@ -1,5 +1,5 @@
-import { PaperSpeed, RollCopy } from "../RollCopy";
-import { TrackerBar } from "../TrackerBar";
+import { PaperSpeed, RollCopy } from "../RollCopy.js";
+import { TrackerBar } from "../TrackerBar.js";
 /**
  * Rows of the image on an inch of paper. The player reads eight rows a
  * second per unit of roll tempo (tempo 80 comes with a sample rate of

package/lib/readers/spencerBar.js

@@ -1,7 +1,7 @@
 import { v4 } from "uuid";
-import { systemOf } from "../TrackerBar";
-import { welteLicensee } from "../systems/welteLicensee/bar";
-import { feetPerMinute, inMillimeters, px, track } from "../Quantity";
+import { systemOf } from "../TrackerBar.js";
+import { welteLicensee } from "../systems/welteLicensee/bar.js";
+import { feetPerMinute, inMillimeters, px, track } from "../Quantity.js";
 /**
  * Spencer Chase's e-roll file (`.bar`, "eRoll Tracker Bar Image") holds
  * a roll as a list of events: a distance in rows of the scanned image,

package/lib/readers/stanfordAton.d.ts

@@ -1,6 +1,6 @@
-import { RollCopy } from "../RollCopy";
-import { TrackerBar } from "../TrackerBar";
-import { Track } from "../Quantity";
+import { RollCopy } from "../RollCopy.js";
+import { TrackerBar } from "../TrackerBar.js";
+import { Track } from "../Quantity.js";
 export interface StanfordAtonOptions {
     /**
      * Added to the scanning software's hole numbering to reach the

package/lib/readers/stanfordAton.js

@@ -1,8 +1,8 @@
 import { v4 } from "uuid";
-import { AtonParser } from "./AtonParser";
-import { systemOf } from "../TrackerBar";
-import { welteT100 } from "../systems/welteT100/bar";
-import { inMillimeters, mean, mm, pixelsPerInch, px, subtract, track } from "../Quantity";
+import { AtonParser } from "./AtonParser.js";
+import { systemOf } from "../TrackerBar.js";
+import { welteT100 } from "../systems/welteT100/bar.js";
+import { inMillimeters, mean, mm, pixelsPerInch, px, subtract, track } from "../Quantity.js";
 /** Values in these files carry their unit as a suffix, e.g. "37.7646px". */
 const readPx = (value) => px(parseFloat(value));
 /** The parser writes one record as an object and several as an array. */

package/lib/reservations.d.ts

@@ -1,6 +1,6 @@
-import { RollCopy } from "./RollCopy";
-import { Version } from "./Version";
-import { EditionView } from "./EditionView";
+import { RollCopy } from "./RollCopy.js";
+import { Version } from "./Version.js";
+import { EditionView } from "./EditionView.js";
 export declare const reservationTypes: readonly ['source-not-stated', 'source-undocumented', 'software-not-named', 'instrument-not-named', 'features-interpreted', 'no-physical-evidence', 'measurement-undocumented', 'not-calibrated', 'system-unknown', 'keeper-unknown'];
 export type ReservationType = typeof reservationTypes[number];
 /**

package/lib/reservations.js

@@ -1,7 +1,7 @@
-import { bearsPhysicalEvidence, isMeasured, sourceLabels } from "./FeatureSource";
-import { calibrationOf, featuresOf } from "./RollCopy";
-import { trackerBarOf } from "./systems";
-import { witnessesOf } from "./witnesses";
+import { bearsPhysicalEvidence, isMeasured, sourceLabels } from "./FeatureSource.js";
+import { calibrationOf, featuresOf } from "./RollCopy.js";
+import { trackerBarOf } from "./systems/index.js";
+import { witnessesOf } from "./witnesses.js";
 export const reservationTypes = [
     'source-not-stated',
     'source-undocumented',

package/lib/scatter.d.ts

@@ -1,9 +1,9 @@
-import { Belief } from "./Assumption";
-import { BothEnds, CollationTolerance, Displacement } from "./Collation";
-import { EditionView } from "./EditionView";
-import { Millimeters } from "./Quantity";
-import { Histogram, Spread, Tail } from "./statistics";
-import { AnySymbol } from "./Symbol";
+import { Belief } from "./Assumption.js";
+import { BothEnds, CollationTolerance, Displacement } from "./Collation.js";
+import { EditionView } from "./EditionView.js";
+import { Millimeters } from "./Quantity.js";
+import { Histogram, Spread, Tail } from "./statistics.js";
+import { AnySymbol } from "./Symbol.js";
 /**
  * How far the copies of a roll disagree about where a symbol lies, and
  * the collation tolerance that follows from it.
@@ -31,7 +31,15 @@ export interface Reading {
  * that reads it: no second symbol is left to match it against. Which
  * copies a version was established from is therefore not something the
  * edition still states once the collation has run, and the caller
- * names them.
+ * names them. `sidesOf` says which copies attest each side of a
+ * derivation, which is the way to name them rather than by hand.
+ *
+ * The copies named are one **side** of a comparison and the rest are
+ * the other, so the displacement is signed and its sign is the caller's
+ * choice. Naming a set that is not a side yields a well formed
+ * measurement of something else: one copy's own noise against a mixture
+ * of both sides, which is no window any collation used and is wider
+ * than the truth.
  *
  * A symbol only one side carries measures nothing and is passed over,
  * which leaves out exactly the insertions and the deletions.
@@ -81,7 +89,18 @@ export interface Departure {
      * told which test did it.
      */
     separatedBy: BothEnds<boolean>;
-    /** Whether the tolerance the edition states at present still admits it. Absent where none was given to compare against. */
+    /**
+     * Whether the tolerance the edition states at present still admits
+     * it. Absent where none was given to compare against.
+     *
+     * This sees one direction only. A departure is by definition a
+     * reading the calculated window rejects, so this says which of
+     * those the stated window joined and which would therefore be taken
+     * apart. It cannot show the converse, a reading the stated window
+     * rejects and the calculated one would join, because such a reading
+     * is no departure and never reaches this list. `changesBetween`
+     * reports both, and the ones it adds are the silent ones.
+     */
     admittedAsStated?: boolean;
 }
 /** How far a sample departs from the normal shape the tolerance assumes of it. */
@@ -117,7 +136,14 @@ export interface Scatter {
      * one of the sample's own readings is expected to pass it.
      */
     k: number;
-    /** The window that follows: `k` times the scatter, centred on the median. */
+    /**
+     * The window that follows: `k` times the scatter, centred on the
+     * median. Its offsets run in the direction of the sample, the
+     * copies named less the rest, so a window measured over the
+     * parent's copies carries them negated. `toleranceAcross` is what
+     * turns these into the window a derivation stores, and it asks
+     * which side was named; storing one of these directly does not.
+     */
     tolerance: CollationTolerance;
     /** How far the sample departs from the normal shape, at either end. */
     normality: BothEnds<Normality>;
@@ -142,13 +168,95 @@ export declare const scatterOf: (readings: readonly Reading[], options?: Scatter
 /** How one copy's readings of a version's text scatter against the readings of the copies it is collated with. */
 export declare const scatterOfCopy: (view: EditionView, versionId: string, copyId: string, options?: ScatterOptions) => Scatter[];
 /**
- * One window admitting what every sample's own window admits. A
- * derivation states a single tolerance while the samples differ, and
+ * Which side of a derivation a measurement was taken over: the version
+ * derived, or the version it is read against.
+ */
+export type Side = 'child' | 'parent';
+/**
+ * One window admitting what every sample's own window admits, in the
+ * direction a collation applies it.
+ *
+ * A derivation states a single tolerance while the samples differ, and
  * covering them keeps each sample within the budget of chance
- * departures its own threshold was chosen for. Nothing where there is
- * no sample.
+ * departures its own threshold was chosen for.
+ *
+ * `named` says whose copies the scatters were measured over, and it is
+ * asked for rather than assumed because nothing else can tell. A window
+ * measured over the parent's copies runs the other way, and stored
+ * unturned its offsets sit on the wrong side of the readings: the width
+ * is unaffected, so nothing in the magnitude looks wrong, and the
+ * departures are unaffected too, since they are taken about the
+ * sample's own median. Only the collation is wrong, and it is wrong in
+ * both directions at once, separating readings that belong together and
+ * merging readings that do not. Nothing where there is no sample.
+ *
+ * Covering has a cost where the samples sit at different centres, and
+ * it falls on the sample that does not move. One window has one centre,
+ * so where one sample's window contains another's the covering window
+ * is simply the wider one, centred where that sample sits, and the
+ * narrower sample is then judged against an offset it does not have.
+ * On the Phillips edge of welte225.org the expression punches sit
+ * 1.2 mm from the notes and the notes' onsets agree exactly, so the
+ * covering window shifts every note onset by a displacement only the
+ * expressions show. `changesBetween` makes that visible as readings the
+ * window moves; it is the price of one tolerance per derivation, and it
+ * is the same skew the grouping stands in for.
+ */
+export declare const toleranceAcross: (scatters: readonly Scatter[], named: Side) => CollationTolerance | undefined;
+/** What putting one window in force in place of another would do to a collation. */
+export interface Changes {
+    /** Readings the window in force joins and the proposed one would take apart. */
+    separated: Reading[];
+    /** Readings the window in force takes apart and the proposed one would join. */
+    merged: Reading[];
+}
+/**
+ * Which readings two windows disagree about, taken apart by the
+ * direction they disagree in.
+ *
+ * The two are worth seeing separately because they do not cost the
+ * same. A separation leaves a visible edit in the apparatus that a
+ * reader can challenge; a merge erases a reading and says nothing, and
+ * the edition has no way to show what it lost. So the merges are the
+ * list to read first, and an edge that only separates is the safer kind
+ * of change however many readings it touches.
+ *
+ * This is what to ask before applying a calculated window, rather than
+ * reading `admittedAsStated` off the departures, which sees separations
+ * only. An edge both windows agree about throughout needs no
+ * re-collation at all, and its tolerance may simply be stated.
+ */
+export declare const changesBetween: (readings: readonly Reading[], inForce: CollationTolerance, proposed: CollationTolerance) => Changes;
+/** How many of a side's symbols a copy bears. */
+export interface Attestation {
+    copy: string;
+    symbols: number;
+}
+/** The copies attesting each side of a derivation, each side in order of how much it bears. */
+export interface Sides {
+    /** The copies bearing what the child inserts: the reading the derivation moves to. */
+    child: Attestation[];
+    /** The copies bearing what the child strikes from the parent: the reading it moves from. */
+    parent: Attestation[];
+}
+/**
+ * Which copies attest each side of a version's derivation, read off the
+ * edits themselves: the copies bearing what it inserts stand for the
+ * reading it moves to, and those bearing what it strikes for the
+ * reading it moves from.
+ *
+ * This is the way to name a side. Counting only the copies that bear a
+ * version's own text will not do it, because a collation hands a
+ * child's carriers up to the parent's symbols, so a descendant's copies
+ * come to bear an ancestor's readings and look like its own. The
+ * deletions are not exposed to that: what a version strikes is attested
+ * by the copies that read it before the version departed from it.
+ *
+ * A fully collated edge inserts and deletes nothing and so attests
+ * neither side, which is the case where the edition has genuinely
+ * stopped saying and an editor has to.
  */
-export declare const toleranceAcross: (scatters: readonly Scatter[]) => CollationTolerance | undefined;
+export declare const sidesOf: (view: EditionView, versionId: string) => Sides | undefined;
 /**
  * The belief a calculated tolerance rests on, to annotate the
  * derivation's `collationTolerance` with: an inference from the scatter

package/lib/scatter.js

@@ -1,8 +1,9 @@
 import { v4 } from "uuid";
-import { admits, offsetEndOf, offsetStartOf } from "./Collation";
-import { mean, mm } from "./Quantity";
-import { excessKurtosisOf, histogramOf, normalQuantile, spreadOf, standardise, tailOf } from "./statistics";
-import { groupBy } from "./utils";
+import { admits, offsetEndOf, offsetStartOf } from "./Collation.js";
+import { mean, mm } from "./Quantity.js";
+import { excessKurtosisOf, histogramOf, normalQuantile, spreadOf, standardise, tailOf } from "./statistics.js";
+import { groupBy } from "./utils.js";
+import { deletedBy, insertedBy } from "./Version.js";
 const placeOf = (carriers) => ({
     from: mean(carriers.map(carrier => carrier.horizontal.from)),
     to: mean(carriers.map(carrier => carrier.horizontal.to))
@@ -20,7 +21,15 @@ const sitsOn = (view, copies) => (feature) => {
  * that reads it: no second symbol is left to match it against. Which
  * copies a version was established from is therefore not something the
  * edition still states once the collation has run, and the caller
- * names them.
+ * names them. `sidesOf` says which copies attest each side of a
+ * derivation, which is the way to name them rather than by hand.
+ *
+ * The copies named are one **side** of a comparison and the rest are
+ * the other, so the displacement is signed and its sign is the caller's
+ * choice. Naming a set that is not a side yields a well formed
+ * measurement of something else: one copy's own noise against a mixture
+ * of both sides, which is no window any collation used and is wider
+ * than the truth.
  *
  * A symbol only one side carries measures nothing and is passed over,
  * which leaves out exactly the insertions and the deletions.
@@ -118,24 +127,107 @@ const covering = (windows) => {
     return { offset: mm((lowest + highest) / 2), tolerance: mm((highest - lowest) / 2) };
 };
 /**
- * One window admitting what every sample's own window admits. A
- * derivation states a single tolerance while the samples differ, and
+ * One window admitting what every sample's own window admits, in the
+ * direction a collation applies it.
+ *
+ * A derivation states a single tolerance while the samples differ, and
  * covering them keeps each sample within the budget of chance
- * departures its own threshold was chosen for. Nothing where there is
- * no sample.
+ * departures its own threshold was chosen for.
+ *
+ * `named` says whose copies the scatters were measured over, and it is
+ * asked for rather than assumed because nothing else can tell. A window
+ * measured over the parent's copies runs the other way, and stored
+ * unturned its offsets sit on the wrong side of the readings: the width
+ * is unaffected, so nothing in the magnitude looks wrong, and the
+ * departures are unaffected too, since they are taken about the
+ * sample's own median. Only the collation is wrong, and it is wrong in
+ * both directions at once, separating readings that belong together and
+ * merging readings that do not. Nothing where there is no sample.
+ *
+ * Covering has a cost where the samples sit at different centres, and
+ * it falls on the sample that does not move. One window has one centre,
+ * so where one sample's window contains another's the covering window
+ * is simply the wider one, centred where that sample sits, and the
+ * narrower sample is then judged against an offset it does not have.
+ * On the Phillips edge of welte225.org the expression punches sit
+ * 1.2 mm from the notes and the notes' onsets agree exactly, so the
+ * covering window shifts every note onset by a displacement only the
+ * expressions show. `changesBetween` makes that visible as readings the
+ * window moves; it is the price of one tolerance per derivation, and it
+ * is the same skew the grouping stands in for.
  */
-export const toleranceAcross = (scatters) => {
+export const toleranceAcross = (scatters, named) => {
     if (scatters.length === 0)
         return undefined;
+    const towardsChild = named === 'child' ? 1 : -1;
     const start = covering(scatters.map(({ tolerance }) => ({ offset: offsetStartOf(tolerance), tolerance: tolerance.toleranceStart })));
     const end = covering(scatters.map(({ tolerance }) => ({ offset: offsetEndOf(tolerance), tolerance: tolerance.toleranceEnd })));
     return {
-        offsetStart: start.offset,
+        offsetStart: mm(towardsChild * start.offset),
         toleranceStart: start.tolerance,
-        offsetEnd: end.offset,
+        offsetEnd: mm(towardsChild * end.offset),
         toleranceEnd: end.tolerance
     };
 };
+/**
+ * Which readings two windows disagree about, taken apart by the
+ * direction they disagree in.
+ *
+ * The two are worth seeing separately because they do not cost the
+ * same. A separation leaves a visible edit in the apparatus that a
+ * reader can challenge; a merge erases a reading and says nothing, and
+ * the edition has no way to show what it lost. So the merges are the
+ * list to read first, and an edge that only separates is the safer kind
+ * of change however many readings it touches.
+ *
+ * This is what to ask before applying a calculated window, rather than
+ * reading `admittedAsStated` off the departures, which sees separations
+ * only. An edge both windows agree about throughout needs no
+ * re-collation at all, and its tolerance may simply be stated.
+ */
+export const changesBetween = (readings, inForce, proposed) => ({
+    separated: readings.filter(({ displacement }) => admits(inForce, displacement) && !admits(proposed, displacement)),
+    merged: readings.filter(({ displacement }) => !admits(inForce, displacement) && admits(proposed, displacement))
+});
+const copiesBearing = (view, symbols) => {
+    const tally = symbols.reduce((counts, symbol) => {
+        const bearers = new Set(view.carriersOf(symbol).flatMap(carrier => {
+            const copy = view.copyOf(carrier.id);
+            return copy ? [copy.id] : [];
+        }));
+        bearers.forEach(copy => counts.set(copy, (counts.get(copy) ?? 0) + 1));
+        return counts;
+    }, new Map());
+    return [...tally]
+        .map(([copy, symbols]) => ({ copy, symbols }))
+        .sort((a, b) => b.symbols - a.symbols);
+};
+/**
+ * Which copies attest each side of a version's derivation, read off the
+ * edits themselves: the copies bearing what it inserts stand for the
+ * reading it moves to, and those bearing what it strikes for the
+ * reading it moves from.
+ *
+ * This is the way to name a side. Counting only the copies that bear a
+ * version's own text will not do it, because a collation hands a
+ * child's carriers up to the parent's symbols, so a descendant's copies
+ * come to bear an ancestor's readings and look like its own. The
+ * deletions are not exposed to that: what a version strikes is attested
+ * by the copies that read it before the version departed from it.
+ *
+ * A fully collated edge inserts and deletes nothing and so attests
+ * neither side, which is the case where the edition has genuinely
+ * stopped saying and an editor has to.
+ */
+export const sidesOf = (view, versionId) => {
+    const version = view.get(versionId);
+    if (!version)
+        return undefined;
+    return {
+        child: copiesBearing(view, insertedBy(version)),
+        parent: copiesBearing(view, view.getAll(deletedBy(version)))
+    };
+};
 const inMillimetres = (value) => `${value.toFixed(2)} mm`;
 const sampleDescribed = (scatter) => `${scatter.group}: ${scatter.spread.from.n} readings, scattering by `
     + `${inMillimetres(scatter.spread.from.sigma)} at the start and ${inMillimetres(scatter.spread.to.sigma)} at the end `

package/lib/schema.json

@@ -208,11 +208,11 @@
             "properties": {
                 "offsetEnd": {
                     "$ref": "#/definitions/Millimeters",
-                    "description": "The same at the end of a feature."
+                    "description": "The same at the end of a feature, in the same direction."
                 },
                 "offsetStart": {
                     "$ref": "#/definitions/Millimeters",
-                    "description": "How much later the collated copy puts the start of a feature than the copy it is read against, where the two differ systematically. Nothing where they do not."
+                    "description": "How much later the derived version puts the start of a feature than the version it is read against, where the two differ systematically. Nothing where they do not.\n\nThe direction is the one a collation measures in, the child less the parent, and it is not symmetric: stored the other way round the window sits on the wrong side of the readings and merges what it should separate. A measurement taken over the parent's copies gives the negative of this, which is what `toleranceAcross` asks the side for."
                 },
                 "toleranceEnd": {
                     "$ref": "#/definitions/Millimeters",
@@ -1932,11 +1932,11 @@
                 },
                 "offsetEnd": {
                     "$ref": "#/definitions/Millimeters",
-                    "description": "The same at the end of a feature."
+                    "description": "The same at the end of a feature, in the same direction."
                 },
                 "offsetStart": {
                     "$ref": "#/definitions/Millimeters",
-                    "description": "How much later the collated copy puts the start of a feature than the copy it is read against, where the two differ systematically. Nothing where they do not."
+                    "description": "How much later the derived version puts the start of a feature than the version it is read against, where the two differ systematically. Nothing where they do not.\n\nThe direction is the one a collation measures in, the child less the parent, and it is not symmetric: stored the other way round the window sits on the wrong side of the readings and merges what it should separate. A measurement taken over the parent's copies gives the negative of this, which is what `toleranceAcross` asks the side for."
                 },
                 "toleranceEnd": {
                     "$ref": "#/definitions/Millimeters",

package/lib/sigla.d.ts

@@ -1,4 +1,4 @@
-import { Edition } from './Edition';
+import { Edition } from './Edition.js';
 /**
  * The siglum of every version, as the stemma stands. The letter names the
  * reproducing system a version is coded for, the number counts the

package/lib/sigla.js

@@ -1,7 +1,7 @@
-import { idOf } from './Assumption';
-import { systemIdOf } from './TrackerBar';
-import { trackerBarOf } from './systems';
-import { principalDerivationOf } from './Version';
+import { idOf } from './Assumption.js';
+import { systemIdOf } from './TrackerBar.js';
+import { trackerBarOf } from './systems/index.js';
+import { principalDerivationOf } from './Version.js';
 /** The letter the versions of a system are labelled with. */
 const letters = new Map([
     ['welte-t100', 'R'],

package/lib/statistics.d.ts

@@ -1,4 +1,4 @@
-import { Quantity } from "./Quantity";
+import { Quantity } from "./Quantity.js";
 /**
  * The statistics a sample of measurements is described with.
  *

package/lib/statistics.js

@@ -1,4 +1,4 @@
-import { quantity } from "./Quantity";
+import { quantity } from "./Quantity.js";
 /**
  * The statistics a sample of measurements is described with.
  *

package/lib/substitution.d.ts

@@ -1,7 +1,7 @@
-import { CollationTolerance, Locate } from "./Collation";
-import { AnySymbol, Expression } from "./Symbol";
-import { Millimeters, Track } from "./Quantity";
-import { TrackerBar } from "./TrackerBar";
+import { CollationTolerance, Locate } from "./Collation.js";
+import { AnySymbol, Expression } from "./Symbol.js";
+import { Millimeters, Track } from "./Quantity.js";
+import { TrackerBar } from "./TrackerBar.js";
 /**
  * How a scale words a function: as a command that turns it on, one that
  * cancels it, or one that holds it for as long as it lasts.
@@ -46,7 +46,7 @@ export interface Substitution {
  * 2.66 mm grid with bridges of about a millimetre, so a scan read hole
  * by hole shows a run where the paper shows one command.
  */
-export declare const defaultChainGap: import("./Quantity").Quantity<"mm">;
+export declare const defaultChainGap: import("./Quantity.js").Quantity<"mm">;
 /**
  * The position a bar reads its own command for the same function on,
  * where it has no word for this one.

package/lib/substitution.js

@@ -1,5 +1,5 @@
-import { defaultCollationTolerance } from "./Collation";
-import { distance, mm, track } from "./Quantity";
+import { defaultCollationTolerance } from "./Collation.js";
+import { distance, mm, track } from "./Quantity.js";
 /**
  * What each Welte expression type operates.
  *

package/lib/systems/index.d.ts

@@ -1,5 +1,5 @@
-import { Concept } from "../Agent";
-import { TrackerBar } from "../TrackerBar";
+import { Concept } from "../Agent.js";
+import { TrackerBar } from "../TrackerBar.js";
 /** The tracker bars the library knows, the T-100 first as the usual one. */
 export declare const trackerBars: readonly TrackerBar[];
 /** The bar of a system the type vocabulary knows, from its concept. */