linked-rolls 0.43.0 → 0.45.0

package/README.md

@@ -75,6 +75,98 @@ at. It then reads as the version it derives from, and
 `reservationsAboutVersion` says so. A file that names a single
 derivation loads as a list of one.
 
+What a version is called is not stored with it. `siglaOf` reads the
+sigla off the stemma as it stands, so a label never outlives the
+arrangement it describes, and nothing should cite one without saying
+which state of the edition it belongs to.
+
+## The tolerance a derivation was collated at
+
+`collationTolerance` on a derivation is the window two readings of one
+symbol must fall in to be collated: how far apart they may lie at
+either end, and, since two copies differ by a systematic offset as well
+as by scatter, where that window is centred. A window naming no offset
+is centred on nothing, which is what every window written before the
+offset was held here means.
+
+The number decides what counts as a reading at all, so it is worth
+measuring rather than picking. `scatterOfCopy` measures how far one
+copy puts each symbol from where the copies collated with it put it,
+and `scatterOf` describes that sample: its median, its scatter as a
+median absolute deviation scaled to a standard deviation, a histogram
+with the normal curve to lay over it, and the readings the curve does
+not account for. The scatter is taken from the median because the
+displacements an editor is looking for are in the sample, and a
+standard deviation would grow towards them until they no longer stood
+out.
+
+The copies named are one **side** of the comparison and the rest are
+the other, so which copies to name is the first question and the
+edition no longer answers it: 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. `sidesOf` reads the sides
+off the edits instead, the copies bearing what a version inserts
+standing for the reading it moves to and those bearing what it strikes
+for the reading it moves from. Naming a set that is not a side measures
+one copy's noise against a mixture of both sides, which is wider than
+the truth.
+
+The tolerance that follows is the scatter times a threshold fixed by
+the size of the sample, the point beyond which fewer than one reading
+is expected to fall by chance (`departureThreshold`). For the few
+hundred readings an edge of a stemma yields this lands a little above
+three. `toleranceAcross` covers several samples with one window, since
+a derivation states one tolerance while notes and expressions scatter
+differently. It asks which side was measured, because a window is
+signed: the offset runs from the parent to the child, and one stored
+the other way round has the right width and the wrong centre, so it
+separates readings that belong together and merges readings that do
+not while nothing in the number looks wrong. `inferredTolerance` builds
+the belief the number rests on, to annotate `collationTolerance` with. It is held likely and not
+true: the tolerance follows from the sample only as far as the sample
+is normal, which is what the reported excess kurtosis and tail counts
+are there to show.
+
+Two limits are worth naming. Notes and expressions are estimated apart
+by default, which is a stopgap standing in for a skew across the width
+of the paper rather than a distinction in the model, so the grouping is
+a parameter of the estimator and appears nowhere in the format. And the
+method screens: it says which readings the curve does not account for,
+and an editor says which of those are editorial acts.
+
+A separation reports which end made it (`separatedBy`, and
+`admittedAtEnds` for a collation). The two ends answer different
+questions: the onset, with the kind, decides whether two copies read one
+command, and the end decides whether that command was lengthened or
+shortened. On welte225.org the end alone decides 24 collations of 2839
+and the onset alone 39, so neither test is idle, but a difference at the
+end is as often a punch measured badly as a punch genuinely prolonged,
+and the two are not worth confusing.
+
+## Collating a derivation a second time
+
+A collated symbol is one symbol carrying every copy that reads it, so a
+collation cannot simply be run again: there is no second symbol left to
+match. `separateReadings` is the inverse. It takes one copy's carriers
+back off the symbols it shares, gives them to new symbols of the
+version's own, and states the exchange, leaving the edition in the state
+a collation would have produced had nothing joined. `connectVersions` at
+a new tolerance then re-collates, joining again whatever the new window
+admits.
+
+Nothing an editor established is lost by that. `connectVersions`
+rewrites only what a collation wrote (`isCollationsOwn`): a bare
+insertion or deletion, or an equivalence between two systems' spellings.
+An edit naming what the change is, why it was made, or what it rests on
+stays, and the symbols it speaks for are left out of the collation. An
+equivalence counts as the collation's own, since it is derived from the
+two systems' vocabularies rather than read off the paper and freezing it
+would leave the transfers uncollatable, but one drawn a second time over
+the very same symbols is kept as it stands, identifier and motivation
+and all. Readings already separated by hand are carried by one copy
+alone, so `separateReadings` passes over them and they keep their
+identifiers.
+
 ## What brought a feature about
 
 A copy states no list of features. Each feature stands in the act that
@@ -140,8 +232,8 @@ they carry it, a statement with the belief it rests on;
 `versionsWitnessedBy` gathers the same from the side of a copy.
 `carriageProblems` reports a statement made beside features that carry
 symbols already, or one naming a version the edition lacks. A copy may
-carry a `siglum`, as a version does; one without is named by its
-keeper.
+carry a `siglum`, which is given by hand and not read off anything;
+one without is named by its keeper.
 
 ```ts
 import { reservationsAbout, stateSource } from 'linked-rolls'

package/lib/Agent.d.ts

@@ -1,4 +1,4 @@
-import { WithId } from "./utils";
+import { WithId } from "./utils.js";
 /**
  * Something with a name and, where one exists, an authority record.
  */

package/lib/Assumption.d.ts

@@ -1,5 +1,5 @@
-import { WithNote, WithId } from "./utils";
-import { Person, WithActor } from "./Agent";
+import { WithNote, WithId } from "./utils.js";
+import { Person, WithActor } from "./Agent.js";
 export declare const certainties: readonly ['true', 'likely', 'possible', 'unlikely', 'false'];
 /**
  * Certainty levels for beliefs, ranging from 'true' to 'false'

package/lib/Collation.d.ts

@@ -1,17 +1,76 @@
-import { HorizontalSpan } from "./Feature";
-import { AnySymbol } from "./Symbol";
-import { Millimeters } from "./Quantity";
+import { Edit } from "./Edit.js";
+import { HorizontalSpan } from "./Feature.js";
+import { AnySymbol } from "./Symbol.js";
+import { Millimeters } from "./Quantity.js";
+/** A value taken at each end of a feature: where it begins and where it stops. */
+export interface BothEnds<T> {
+    from: T;
+    to: T;
+}
+/** How far one text puts a feature from where another puts it, at either end. */
+export type Displacement = BothEnds<Millimeters>;
 /**
- * Tolerance used in collation of roll copies: the acceptable deviation
- * at either end when aligning features across copies.
+ * The window two readings of one feature must fall in to be collated:
+ * how far apart they may lie at either end, and where that window is
+ * centred.
+ *
+ * The centre is worth stating. Two copies of one roll differ by a
+ * systematic offset as well as by scatter, and a window centred on
+ * nothing has to be widened by the whole of that offset before it
+ * admits what the offset alone displaces. Naming the offset lets the
+ * tolerance stand for the scatter only. A window that names none is
+ * centred on nothing, which is what every window written before the
+ * offset was held here means.
  */
 export interface CollationTolerance {
-    /** Tolerance at the start position of a feature. */
+    /** How far the two readings may lie apart at the start of a feature, measured from `offsetStart`. */
     toleranceStart: Millimeters;
-    /** Tolerance at the end position of a feature. */
+    /** How far they may lie apart at the end, measured from `offsetEnd`. */
     toleranceEnd: Millimeters;
+    /**
+     * 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.
+     *
+     * The 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.
+     */
+    offsetStart?: Millimeters;
+    /** The same at the end of a feature, in the same direction. */
+    offsetEnd?: Millimeters;
 }
 export declare const defaultCollationTolerance: CollationTolerance;
+/** Where the window is centred at the start of a feature, on nothing where it names no offset. */
+export declare const offsetStartOf: (tolerance: CollationTolerance) => Millimeters;
+/** Where the window is centred at the end of a feature. */
+export declare const offsetEndOf: (tolerance: CollationTolerance) => Millimeters;
+/**
+ * Whether the window admits the displacement at each end, taken apart.
+ *
+ * The two ends answer different questions. The onset, with the kind,
+ * decides identity: whether the two copies read one command. The end
+ * decides duration: whether the same command was lengthened or
+ * shortened. A collation joins two readings only where both admit, so a
+ * separation may be the work of either, and an editor looking at one
+ * wants to know which.
+ *
+ * A difference at the end alone has at least three causes and only the
+ * first is an editorial act. A punch may genuinely have been lengthened
+ * or shortened. A chain of punches, bridged to keep the paper strong,
+ * may have been read as one perforation on one copy and as repeated
+ * notes on the other, which Phillips names as a common error of roll
+ * scanning and which runs in both directions (p. 173). Or a reading may
+ * report something other than the punched slot, as a pneumatic reader
+ * reports how long a valve stayed open. Long held notes are where the
+ * second is likeliest, since that is where the chains are.
+ */
+export declare const admittedAtEnds: (tolerance: CollationTolerance, displacement: Displacement) => BothEnds<boolean>;
+/** Whether the window admits the displacement: within the tolerance of the offset, at both ends. */
+export declare const admits: (tolerance: CollationTolerance, displacement: Displacement) => boolean;
 /** Where a symbol lies along the roll, as its carriers put it, or nothing for a symbol without a place. */
 export type Locate = (symbol: AnySymbol) => Readonly<HorizontalSpan> | undefined;
 /**
@@ -26,3 +85,21 @@ export type Collation = {
 };
 /** Each of the own symbols with every inherited symbol it collates with, both in the order given. */
 export declare const collationsOf: (own: readonly Readonly<AnySymbol>[], inherited: readonly Readonly<AnySymbol>[], locate: Locate, tolerance?: CollationTolerance) => Collation[];
+/**
+ * Whether the edit is one a collation writes by itself: a bare
+ * insertion or a bare deletion saying nothing further, or an
+ * equivalence between two systems' spellings for one command.
+ *
+ * Collating again rewrites these and keeps the rest. An edit that says
+ * what the change is, or why it was made, or what it rests on, is an
+ * editor's reading of the difference between two texts, and collating
+ * the two again is no reason to discard it.
+ *
+ * An equivalence counts as the collation's own even where an editor
+ * added a motivation to it, because it is derived rather than read:
+ * freezing it would leave the transfers, where nearly every edit is
+ * one, unable to be collated again at all. What an editor wrote on it
+ * is not lost by that, since `connectVersions` keeps an equivalence it
+ * draws a second time over the very same symbols.
+ */
+export declare const isCollationsOwn: (edit: Readonly<Edit>) => boolean;

package/lib/Collation.js

@@ -1,7 +1,41 @@
-import { keyOf } from "./TrackerBar";
-import { distance, mm } from "./Quantity";
-import { partitionPoint } from "./sorted";
+import { keyOf } from "./TrackerBar.js";
+import { distance, mm } from "./Quantity.js";
+import { partitionPoint } from "./sorted.js";
+import { groupBy } from "./utils.js";
 export const defaultCollationTolerance = { toleranceStart: mm(5), toleranceEnd: mm(5) };
+/** Where the window is centred at the start of a feature, on nothing where it names no offset. */
+export const offsetStartOf = (tolerance) => tolerance.offsetStart ?? mm(0);
+/** Where the window is centred at the end of a feature. */
+export const offsetEndOf = (tolerance) => tolerance.offsetEnd ?? mm(0);
+/**
+ * Whether the window admits the displacement at each end, taken apart.
+ *
+ * The two ends answer different questions. The onset, with the kind,
+ * decides identity: whether the two copies read one command. The end
+ * decides duration: whether the same command was lengthened or
+ * shortened. A collation joins two readings only where both admit, so a
+ * separation may be the work of either, and an editor looking at one
+ * wants to know which.
+ *
+ * A difference at the end alone has at least three causes and only the
+ * first is an editorial act. A punch may genuinely have been lengthened
+ * or shortened. A chain of punches, bridged to keep the paper strong,
+ * may have been read as one perforation on one copy and as repeated
+ * notes on the other, which Phillips names as a common error of roll
+ * scanning and which runs in both directions (p. 173). Or a reading may
+ * report something other than the punched slot, as a pneumatic reader
+ * reports how long a valve stayed open. Long held notes are where the
+ * second is likeliest, since that is where the chains are.
+ */
+export const admittedAtEnds = (tolerance, displacement) => ({
+    from: distance(displacement.from, offsetStartOf(tolerance)) <= tolerance.toleranceStart,
+    to: distance(displacement.to, offsetEndOf(tolerance)) <= tolerance.toleranceEnd
+});
+/** Whether the window admits the displacement: within the tolerance of the offset, at both ends. */
+export const admits = (tolerance, displacement) => {
+    const ends = admittedAtEnds(tolerance, displacement);
+    return ends.from && ends.to;
+};
 /**
  * What a symbol says, as a key: the pitch of a note, the type and scope
  * of an expression. Symbols collate within one key only. This is the
@@ -10,8 +44,8 @@ export const defaultCollationTolerance = { toleranceStart: mm(5), toleranceEnd:
  * what carries a note across a transfer between systems.
  */
 const kindOf = (symbol) => symbol.type === 'text' ? 'text' : keyOf(symbol);
-const nearby = (here, there, tolerance) => distance(here.from, there.from) <= tolerance.toleranceStart
-    && distance(here.to, there.to) <= tolerance.toleranceEnd;
+const displacementBetween = (here, there) => ({ from: mm(here.from - there.from), to: mm(here.to - there.to) });
+const nearby = (here, there, tolerance) => admits(tolerance, displacementBetween(here, there));
 /**
  * Two symbols collate when they are of one kind, say the same thing
  * (pitch, or expression type and scope), and lie at about the same
@@ -28,15 +62,6 @@ const placed = (symbols, locate) => symbols.flatMap((symbol, index) => {
     const horizontal = locate(symbol);
     return horizontal ? [{ symbol, index, horizontal }] : [];
 });
-const groupBy = (items, keyOf) => items.reduce((groups, item) => {
-    const key = keyOf(item);
-    const group = groups.get(key);
-    if (group)
-        group.push(item);
-    else
-        groups.set(key, [item]);
-    return groups;
-}, new Map());
 /** The placed symbols by kind, each kind in order of onset. */
 const byKindInOrderOfOnset = (symbols) => {
     const groups = groupBy(symbols, ({ symbol }) => kindOf(symbol));
@@ -47,8 +72,9 @@ const byKindInOrderOfOnset = (symbols) => {
 const WINDOW_SLACK = 1e-9;
 /** The symbols of a kind whose onset lies within the start tolerance of the span. */
 const nearOnsetOf = (kind, span, tolerance) => {
-    const lowest = span.from - tolerance.toleranceStart - WINDOW_SLACK;
-    const highest = span.from + tolerance.toleranceStart + WINDOW_SLACK;
+    const centre = span.from - offsetStartOf(tolerance);
+    const lowest = centre - tolerance.toleranceStart - WINDOW_SLACK;
+    const highest = centre + tolerance.toleranceStart + WINDOW_SLACK;
     const first = partitionPoint(kind, candidate => candidate.horizontal.from < lowest);
     const end = partitionPoint(kind, candidate => candidate.horizontal.from <= highest);
     return kind.slice(first, end);
@@ -61,3 +87,24 @@ export const collationsOf = (own, inherited, locate, tolerance = defaultCollatio
         .sort((a, b) => a.index - b.index)
         .map(({ symbol: counterpart }) => ({ symbol, counterpart })));
 };
+/** The edit type a collation draws by itself, from the two systems' vocabularies rather than off the paper. */
+const drawnByCollation = 'replace-with-equivalent';
+/**
+ * Whether the edit is one a collation writes by itself: a bare
+ * insertion or a bare deletion saying nothing further, or an
+ * equivalence between two systems' spellings for one command.
+ *
+ * Collating again rewrites these and keeps the rest. An edit that says
+ * what the change is, or why it was made, or what it rests on, is an
+ * editor's reading of the difference between two texts, and collating
+ * the two again is no reason to discard it.
+ *
+ * An equivalence counts as the collation's own even where an editor
+ * added a motivation to it, because it is derived rather than read:
+ * freezing it would leave the transfers, where nearly every edit is
+ * one, unable to be collated again at all. What an editor wrote on it
+ * is not lost by that, since `connectVersions` keeps an equivalence it
+ * draws a second time over the very same symbols.
+ */
+export const isCollationsOwn = (edit) => edit.editType === drawnByCollation
+    || (edit.editType === undefined && edit.motivation === undefined && edit['@annotation'] === undefined);

package/lib/ConditionState.d.ts

@@ -1,4 +1,4 @@
-import { WithType } from "./utils";
+import { WithType } from "./utils.js";
 /**
  * Physical condition of a roll or
  * of a feature on the roll (e.g. a damaged

package/lib/Edit.d.ts

@@ -1,6 +1,6 @@
-import { Assumption } from "./Assumption";
-import { AnySymbol } from "./Symbol";
-import { WithId } from "./utils";
+import { Assumption } from "./Assumption.js";
+import { AnySymbol } from "./Symbol.js";
+import { WithId } from "./utils.js";
 export declare const editTypes: readonly [
 /**
  * An additional accent that can only be encoded with

package/lib/Edition.d.ts

@@ -1,9 +1,9 @@
-import { RollCopy } from "./RollCopy";
-import { Version } from "./Version";
-import { CollationTolerance } from "./Collation";
-import { DateAssignment, ObjectAssumption } from "./Assumption";
-import { Editor, Person, Place } from "./Agent";
-import { RollTempo } from "./ReproducingSystem";
+import { RollCopy } from "./RollCopy.js";
+import { Version } from "./Version.js";
+import { CollationTolerance } from "./Collation.js";
+import { DateAssignment, ObjectAssumption } from "./Assumption.js";
+import { Editor, Person, Place } from "./Agent.js";
+import { RollTempo } from "./ReproducingSystem.js";
 /**
  * This type describes the creation of an edition,
  * i.e. the editor, publisher, and publication date.
@@ -29,9 +29,15 @@ export interface EditionCreation {
      */
     publicationDate: Date;
     /**
-     * The tolerance parameters used when collating (aligning)
-     * the different roll copies for this edition.
+     * The tolerance every version of the edition was collated at,
+     * before each derivation stated its own. How precisely two copies
+     * place a symbol depends on which two they are, so the tolerance
+     * belongs to the derivation, `Derivation.collationTolerance`, and
+     * migration writes this one onto every derivation that gives none.
+     * Nothing else reads it. A window's offset is the displacement
+     * between two particular copies and so can never be stated here.
      * Not exported to RDF.
+     * @deprecated
      */
     collationTolerance?: CollationTolerance;
 }

package/lib/EditionView.d.ts

@@ -1,11 +1,11 @@
-import { Edition } from "./Edition";
-import { HorizontalSpan, FeatureOrPatch } from "./Feature";
-import { AnySymbol, Expression, Note } from "./Symbol";
-import { Version } from "./Version";
-import { NegotiatedEvent } from "./ReproducingSystem";
-import { TrackerBar } from "./TrackerBar";
-import { Modification, ProductionEvent, RollCopy } from "./RollCopy";
-import { Millimeters } from "./Quantity";
+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";
 export type Path = (string | number)[];
 export declare const getAt: <T>(path: Path, obj: unknown) => T | undefined;
 export declare class EditionView {

package/lib/EditionView.js

@@ -1,9 +1,9 @@
-import { withBorneFeatures } from "./Feature";
-import { deletedBy, insertedBy, principalDerivationOf } from "./Version";
-import { systemIdOf } from "./TrackerBar";
-import { featuresMadeBy, featuresOf, isPaperStretch } from "./RollCopy";
-import { idOf, idsOf } from "./Assumption";
-import { mean } from "./Quantity";
+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";
 export const getAt = (path, obj) => {
     let node = obj;
     for (const key of path) {

package/lib/Emulation.d.ts

@@ -1,8 +1,8 @@
 import { MidiFile } from "midifile-ts";
-import { EditionView } from "./EditionView";
-import { Version } from "./Version";
-import { AnyPerformedRollFeature, EmulatedCurve, NegotiatedEvent, ReproducingSystem } from "./ReproducingSystem";
-import { Millimeters } from "./Quantity";
+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];

package/lib/Emulation.js

@@ -1,7 +1,7 @@
 import { MIDIControlEvents } from "midifile-ts";
-import { idOf } from "./Assumption";
-import { isCommand, pairsAmong, placementsOf } from "./Symbol";
-import { add, mean, mm, seconds, subtract } from "./Quantity";
+import { idOf } from "./Assumption.js";
+import { isCommand, pairsAmong, placementsOf } from "./Symbol.js";
+import { add, mean, mm, seconds, subtract } from "./Quantity.js";
 /** The punch diameter the edition's copies report, where any of them does. */
 const punchDiameterOf = (view) => {
     const measured = view.edition.copies

package/lib/Feature.d.ts

@@ -1,8 +1,8 @@
-import { ObjectAssumption } from "./Assumption";
-import { ConditionState } from "./ConditionState";
-import { Text } from "./Symbol";
-import { PartialBy, WithId, WithType } from "./utils";
-import { Measure, Millimeters, Track } from "./Quantity";
+import { ObjectAssumption } from "./Assumption.js";
+import { ConditionState } from "./ConditionState.js";
+import { Text } from "./Symbol.js";
+import { PartialBy, WithId, WithType } from "./utils.js";
+import { Measure, Millimeters, Track } from "./Quantity.js";
 /**
  * Describes the horizontal extent of a feature on the roll,
  * measured in millimeters from the beginning of the roll.

package/lib/FeatureSource.d.ts

@@ -1,7 +1,7 @@
-import { ActorAssignment, DateAssignment, ObjectAssumption } from "./Assumption";
-import { Concept, Named } from "./Agent";
-import { ConditionState } from "./ConditionState";
-import { WithNote } from "./utils";
+import { ActorAssignment, DateAssignment, ObjectAssumption } from "./Assumption.js";
+import { Concept, Named } from "./Agent.js";
+import { ConditionState } from "./ConditionState.js";
+import { WithNote } from "./utils.js";
 /**
  * What a copy's features were read from. The kinds run from the paper
  * itself, through files in which the roll has already been read into

package/lib/ReproducingSystem.d.ts

@@ -1,7 +1,7 @@
-import { Hole } from "./Feature";
-import { Expression, Note } from "./Symbol";
-import { TrackerBar } from "./TrackerBar";
-import { Millimeters, Quantity, Seconds } from "./Quantity";
+import { Hole } from "./Feature.js";
+import { Expression, Note } from "./Symbol.js";
+import { TrackerBar } from "./TrackerBar.js";
+import { Millimeters, Quantity, Seconds } from "./Quantity.js";
 export type SpeedUnit = 'ft/min' | 'm/min';
 /**
  * The playback tempo of the roll as a paper speed, stated at the

package/lib/RollCopy.d.ts

@@ -1,13 +1,13 @@
-import { ConditionState } from "./ConditionState";
-import { AnySymbol } from "./Symbol";
-import { TrackerBar } from "./TrackerBar";
-import { TrackCalibration } from "./TrackCalibration";
-import { AnyFeature, FeatureOrPatch, GluedOn } from "./Feature";
-import { ActorAssignment, DateAssignment, ObjectAssumption, ReferenceAssumption } from "./Assumption";
-import { WithId, WithType } from "./utils";
-import { Agent, Concept } from "./Agent";
-import { FeatureSource } from "./FeatureSource";
-import { Measure, Millimeters, Quantity, Track } from "./Quantity";
+import { ConditionState } from "./ConditionState.js";
+import { AnySymbol } from "./Symbol.js";
+import { TrackerBar } from "./TrackerBar.js";
+import { TrackCalibration } from "./TrackCalibration.js";
+import { AnyFeature, FeatureOrPatch, GluedOn } from "./Feature.js";
+import { ActorAssignment, DateAssignment, ObjectAssumption, ReferenceAssumption } from "./Assumption.js";
+import { WithId, WithType } from "./utils.js";
+import { Agent, Concept } from "./Agent.js";
+import { FeatureSource } from "./FeatureSource.js";
+import { Measure, Millimeters, Quantity, Track } from "./Quantity.js";
 /**
  * This condition state is used to describe the roll's
  * paper shrinkage or stretching. It might be calculated

package/lib/RollCopy.js

@@ -1,8 +1,8 @@
 import { v4 } from "uuid";
-import { welteT100 } from "./systems/welteT100/bar";
-import { trackerBarOf } from "./systems";
-import { assignReference } from "./Assumption";
-import { px, track } from "./Quantity";
+import { welteT100 } from "./systems/welteT100/bar.js";
+import { trackerBarOf } from "./systems/index.js";
+import { assignReference } from "./Assumption.js";
+import { px, track } from "./Quantity.js";
 export const rollConditions = [
     'general',
     'paper-stretch'

package/lib/Symbol.d.ts

@@ -1,5 +1,5 @@
-import { ReferenceAssumption } from "./Assumption";
-import { WithId } from "./utils";
+import { ReferenceAssumption } from "./Assumption.js";
+import { WithId } from "./utils.js";
 /**
  * A symbol is an abstract musical or textual entity carried by one or more
  * physical features on the roll. Symbols are the result of interpreting

package/lib/Symbol.js

@@ -1,4 +1,4 @@
-import { idOf } from "./Assumption";
+import { idOf } from "./Assumption.js";
 export const isSymbol = (object) => {
     return ('type' in object
         && (object.type === 'note' || object.type === 'expression' || object.type === 'text'));

package/lib/TrackCalibration.d.ts

@@ -1,4 +1,4 @@
-import { Pixels, Track } from "./Quantity";
+import { Pixels, Track } from "./Quantity.js";
 /**
  * Relates a scan to the tracker bar it was read with.
  *

package/lib/TrackCalibration.js

@@ -1,4 +1,4 @@
-import { px, subtract, track } from "./Quantity";
+import { px, subtract, track } from "./Quantity.js";
 /** Image column at the centre of a tracker bar track. */
 export const columnOf = (position, calibration) => px(calibration.offset + (position - calibration.shift) * calibration.separation);
 /** Tracker bar track covering an image column, unrounded. */

package/lib/TrackerBar.d.ts

@@ -1,6 +1,6 @@
-import type { Concept } from "./Agent";
-import { Expression, Note } from "./Symbol";
-import { Millimeters, SpeedMeasure, Track } from "./Quantity";
+import type { Concept } from "./Agent.js";
+import { Expression, Note } from "./Symbol.js";
+import { Millimeters, SpeedMeasure, Track } from "./Quantity.js";
 /**
  * What a tracker bar position does: sound a note, or operate one of
  * the expression valves on the bass or the treble side.

package/lib/TrackerBar.js

@@ -1,4 +1,4 @@
-import { mm, track } from "./Quantity";
+import { mm, track } from "./Quantity.js";
 /**
  * What a position says, as a key. Two bars read the same thing exactly
  * where their keys agree, which is what lets a symbol cross from one

package/lib/Version.d.ts

@@ -1,9 +1,9 @@
-import { Edit } from "./Edit";
-import { Concept } from "./Agent";
-import { ActorAssignment, Belief, Certainty, DateAssignment, ReferenceAssumption } from "./Assumption";
-import { CollationTolerance } from "./Collation";
-import { AnySymbol } from "./Symbol";
-import { WithId, WithNote, WithType } from "./utils";
+import { Edit } from "./Edit.js";
+import { Concept } from "./Agent.js";
+import { ActorAssignment, Belief, Certainty, DateAssignment, ObjectAssumption, ReferenceAssumption } from "./Assumption.js";
+import { CollationTolerance } from "./Collation.js";
+import { AnySymbol } from "./Symbol.js";
+import { WithId, WithNote, WithType } from "./utils.js";
 /**
  * A motivation provides a reason or rationale for an editorial change.
  * Motivations are defined at the version level and referenced by edits.
@@ -22,8 +22,14 @@ export type Derivation = ReferenceAssumption & {
      * The tolerance at which the derived version was collated against
      * the one it is based on. A derivation written before the tolerance
      * was held here states none. Not exported to RDF.
+     *
+     * It is an object assumption, so that a tolerance calculated from
+     * the scatter of the readings can carry the inference it was drawn
+     * by. It is the one quantity in the edition that decides what
+     * counts as a reading at all, and a number arrived at by a method
+     * should say so.
      */
-    collationTolerance?: CollationTolerance;
+    collationTolerance?: ObjectAssumption<CollationTolerance>;
 };
 /** The tolerance the derivation was collated at, or the default where it states none. */
 export declare const collationToleranceOf: (derivation: Readonly<Derivation>) => CollationTolerance;
@@ -66,14 +72,6 @@ export interface VersionCreation {
  * @see lrmoo:F2 Expression
  */
 export interface Version extends WithId, WithType<'Version'> {
-    /**
-     * A label a document carries from before the sigla were computed.
-     * Nothing should write one here and nothing should show one: what a
-     * version is called comes from `siglaOf`.
-     * @deprecated
-     * @see reo:siglum
-     */
-    siglum?: string;
     /**
      * The reproducing system this version is coded for. One roll was
      * often issued for several of them, and a version is a reading in