linked-rolls 0.43.0 → 0.45.0

package/lib/schema.json

@@ -204,15 +204,23 @@
             "type": "string"
         },
         "CollationTolerance": {
-            "description": "Tolerance used in collation of roll copies: the acceptable deviation at either end when aligning features across copies.",
+            "description": "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.\n\nThe 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.",
             "properties": {
+                "offsetEnd": {
+                    "$ref": "#/definitions/Millimeters",
+                    "description": "The same at the end of a feature, in the same direction."
+                },
+                "offsetStart": {
+                    "$ref": "#/definitions/Millimeters",
+                    "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",
-                    "description": "Tolerance at the end position of a feature."
+                    "description": "How far they may lie apart at the end, measured from `offsetEnd`."
                 },
                 "toleranceStart": {
                     "$ref": "#/definitions/Millimeters",
-                    "description": "Tolerance at the start position of a feature."
+                    "description": "How far the two readings may lie apart at the start of a feature, measured from `offsetStart`."
                 }
             },
             "required": [
@@ -414,8 +422,8 @@
                     "type": "object"
                 },
                 "collationTolerance": {
-                    "$ref": "#/definitions/CollationTolerance",
-                    "description": "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."
+                    "$ref": "#/definitions/ObjectAssumption%3CCollationTolerance%3E",
+                    "description": "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.\n\nIt 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."
                 },
                 "@id": {
                     "description": "A unique identifier for this object.",
@@ -576,7 +584,8 @@
             "properties": {
                 "collationTolerance": {
                     "$ref": "#/definitions/CollationTolerance",
-                    "description": "The tolerance parameters used when collating (aligning) the different roll copies for this edition. Not exported to RDF."
+                    "deprecated": true,
+                    "description": "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."
                 },
                 "editors": {
                     "description": "The persons who prepared the edition, each with the part they took in the editorial work. An edition written before this field existed carries none.",
@@ -1899,6 +1908,51 @@
             ],
             "type": "object"
         },
+        "ObjectAssumption<CollationTolerance>": {
+            "description": "An object assumption wraps a complex object with an optional annotation. Used for structured values (e.g. persons, conditions) whose properties may be uncertain.",
+            "properties": {
+                "@annotation": {
+                    "description": "An optional annotation expressing a belief about this assumption. Uses the JSON-LD-star `@annotation` mechanism to attach epistemic metadata (certainty and reasons) to any triple.",
+                    "properties": {
+                        "belief": {
+                            "$ref": "#/definitions/Belief",
+                            "description": "The belief held about the annotated statement.",
+                            "ontology": "crminf:J4i is subject of"
+                        },
+                        "@id": {
+                            "description": "A unique identifier for this object.",
+                            "type": "string"
+                        }
+                    },
+                    "required": [
+                        "belief",
+                        "@id"
+                    ],
+                    "type": "object"
+                },
+                "offsetEnd": {
+                    "$ref": "#/definitions/Millimeters",
+                    "description": "The same at the end of a feature, in the same direction."
+                },
+                "offsetStart": {
+                    "$ref": "#/definitions/Millimeters",
+                    "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",
+                    "description": "How far they may lie apart at the end, measured from `offsetEnd`."
+                },
+                "toleranceStart": {
+                    "$ref": "#/definitions/Millimeters",
+                    "description": "How far the two readings may lie apart at the start of a feature, measured from `offsetStart`."
+                }
+            },
+            "required": [
+                "toleranceEnd",
+                "toleranceStart"
+            ],
+            "type": "object"
+        },
         "ObjectAssumption<ConditionState<\"general\">>": {
             "description": "An object assumption wraps a complex object with an optional annotation. Used for structured values (e.g. persons, conditions) whose properties may be uncertain.",
             "properties": {
@@ -3043,12 +3097,6 @@
                     },
                     "type": "array"
                 },
-                "siglum": {
-                    "deprecated": true,
-                    "description": "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`.",
-                    "type": "string",
-                    "ontology": "reo:siglum"
-                },
                 "system": {
                     "$ref": "#/definitions/Concept",
                     "description": "The reproducing system this version is coded for. One roll was often issued for several of them, and a version is a reading in one system's words: its expression types are that system's vocabulary and its notes sit on that bar's positions. A system the type vocabulary knows carries the IRI of its concept as `id`, from which the export takes the system's own context.",

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

@@ -0,0 +1,71 @@
+import { Quantity } from "./Quantity.js";
+/**
+ * The statistics a sample of measurements is described with.
+ *
+ * The centre and the scatter are taken from the median rather than from
+ * the mean, because the departures a measurement over an edition looks
+ * for are in the sample it is taken over. A mean and a standard
+ * deviation would grow towards those departures until they no longer
+ * stood out; a median and a median absolute deviation leave them out of
+ * account.
+ */
+/** The middle of a sample, the mean of the two middle values where it has an even number of them. */
+export declare const medianOf: <U extends string>(values: readonly Quantity<U>[]) => Quantity<U> | undefined;
+/** Where a sample sits and how far it scatters. */
+export interface Spread<U extends string> {
+    /** How many measurements it was taken over. */
+    n: number;
+    /** The middle measurement. */
+    median: Quantity<U>;
+    /**
+     * The scatter about the median, as the median absolute deviation
+     * scaled to the standard deviation a normal sample of that scatter
+     * would have. It is zero where more than half the sample sits at
+     * one value, and no scatter can be read off such a sample.
+     */
+    sigma: Quantity<U>;
+}
+/** Where the sample sits and how far it scatters, or nothing for an empty sample. */
+export declare const spreadOf: <U extends string>(values: readonly Quantity<U>[]) => Spread<U> | undefined;
+/** How far the value lies from the centre of the spread, in units of its scatter. */
+export declare const standardise: <U extends string>(value: Quantity<U>, spread: Spread<U>) => number;
+/** The share of a normal sample lying below `z` standard deviations. */
+export declare const normalBelow: (z: number) => number;
+/** The share of a normal sample lying further than `z` standard deviations from its centre, on either side. */
+export declare const normalBeyond: (z: number) => number;
+/**
+ * How many standard deviations out the given share of a normal sample
+ * lies below, after Acklam's rational approximation, whose relative
+ * error stays below 1.15e-9. The inverse of `normalBelow`.
+ */
+export declare const normalQuantile: (share: number) => number;
+/**
+ * How much heavier the tails of a standardised sample are than a normal
+ * sample's. Zero for a normal shape, positive where more of the sample
+ * lies far out than the curve allows.
+ */
+export declare const excessKurtosisOf: (standardised: readonly number[]) => number;
+/** How much of a sample lies beyond a given distance from its centre, against how much would under a normal curve. */
+export interface Tail {
+    /** The distance from the centre, in standard deviations. */
+    beyond: number;
+    /** How many of the sample lie further out than that. */
+    observed: number;
+    /** How many a normal sample of the same size would put there. */
+    expected: number;
+}
+/** What the sample puts beyond the given distance, against what a normal sample would. */
+export declare const tailOf: (standardised: readonly number[], beyond: number) => Tail;
+/** A sample counted into bins of one width. */
+export interface Histogram<U extends string> {
+    /** The bounds of the bins, in order, one more of them than there are counts. */
+    edges: Quantity<U>[];
+    /** How many of the sample fall in each bin. */
+    counts: number[];
+}
+/**
+ * The sample counted into bins of the given width, laid out on
+ * multiples of that width so that two histograms of one width share
+ * their bounds. Nothing for an empty sample or a width of nothing.
+ */
+export declare const histogramOf: <U extends string>(values: readonly Quantity<U>[], binWidth: Quantity<U>) => Histogram<U> | undefined;

package/lib/statistics.js

@@ -0,0 +1,121 @@
+import { quantity } from "./Quantity.js";
+/**
+ * The statistics a sample of measurements is described with.
+ *
+ * The centre and the scatter are taken from the median rather than from
+ * the mean, because the departures a measurement over an edition looks
+ * for are in the sample it is taken over. A mean and a standard
+ * deviation would grow towards those departures until they no longer
+ * stood out; a median and a median absolute deviation leave them out of
+ * account.
+ */
+/** The middle of a sample, the mean of the two middle values where it has an even number of them. */
+export const medianOf = (values) => {
+    if (values.length === 0)
+        return undefined;
+    const sorted = [...values].sort((a, b) => a - b);
+    const middle = Math.floor(sorted.length / 2);
+    return sorted.length % 2 === 1
+        ? sorted[middle]
+        : quantity((sorted[middle - 1] + sorted[middle]) / 2);
+};
+/** What the median absolute deviation must be multiplied by to estimate the standard deviation of a normal sample. */
+const MAD_TO_SIGMA = 1.4826;
+/** Where the sample sits and how far it scatters, or nothing for an empty sample. */
+export const spreadOf = (values) => {
+    const median = medianOf(values);
+    if (median === undefined)
+        return undefined;
+    const deviations = values.map(value => quantity(Math.abs(value - median)));
+    return {
+        n: values.length,
+        median,
+        sigma: quantity(MAD_TO_SIGMA * (medianOf(deviations) ?? 0))
+    };
+};
+/** How far the value lies from the centre of the spread, in units of its scatter. */
+export const standardise = (value, spread) => (value - spread.median) / spread.sigma;
+/** The complementary error function, after Press et al., whose fractional error stays below 1.2e-7. */
+const erfc = (x) => {
+    const z = Math.abs(x);
+    const t = 1 / (1 + z / 2);
+    const tail = t * Math.exp(-z * z - 1.26551223 + t * (1.00002368 + t * (0.37409196 + t * (0.09678418 +
+        t * (-0.18628806 + t * (0.27886807 + t * (-1.13520398 + t * (1.48851587 +
+            t * (-0.82215223 + t * 0.17087277)))))))));
+    return x >= 0 ? tail : 2 - tail;
+};
+/** The share of a normal sample lying below `z` standard deviations. */
+export const normalBelow = (z) => erfc(-z / Math.SQRT2) / 2;
+/** The share of a normal sample lying further than `z` standard deviations from its centre, on either side. */
+export const normalBeyond = (z) => erfc(z / Math.SQRT2);
+const horner = (coefficients, x) => coefficients.reduce((total, coefficient) => total * x + coefficient, 0);
+const CENTRAL_NUMERATOR = [
+    -3.969683028665376e+01, 2.209460984245205e+02, -2.759285104469687e+02,
+    1.383577518672690e+02, -3.066479806614716e+01, 2.506628277459239e+00
+];
+const CENTRAL_DENOMINATOR = [
+    -5.447609879822406e+01, 1.615858368580409e+02, -1.556989798598866e+02,
+    6.680131188771972e+01, -1.328068155288572e+01
+];
+const TAIL_NUMERATOR = [
+    -7.784894002430293e-03, -3.223964580411365e-01, -2.400758277161838e+00,
+    -2.549732539343734e+00, 4.374664141464968e+00, 2.938163982698783e+00
+];
+const TAIL_DENOMINATOR = [
+    7.784695709041462e-03, 3.224671290700398e-01, 2.445134137142996e+00, 3.754408661907416e+00
+];
+/** Outside this share the tail approximation is used in place of the central one. */
+const CENTRAL_SHARE = 0.02425;
+const tailQuantile = (share) => {
+    const q = Math.sqrt(-2 * Math.log(share));
+    return horner(TAIL_NUMERATOR, q) / (horner(TAIL_DENOMINATOR, q) * q + 1);
+};
+/**
+ * How many standard deviations out the given share of a normal sample
+ * lies below, after Acklam's rational approximation, whose relative
+ * error stays below 1.15e-9. The inverse of `normalBelow`.
+ */
+export const normalQuantile = (share) => {
+    if (share <= 0)
+        return -Infinity;
+    if (share >= 1)
+        return Infinity;
+    if (share < CENTRAL_SHARE)
+        return tailQuantile(share);
+    if (share > 1 - CENTRAL_SHARE)
+        return -tailQuantile(1 - share);
+    const q = share - 0.5;
+    const r = q * q;
+    return horner(CENTRAL_NUMERATOR, r) * q / (horner(CENTRAL_DENOMINATOR, r) * r + 1);
+};
+/**
+ * How much heavier the tails of a standardised sample are than a normal
+ * sample's. Zero for a normal shape, positive where more of the sample
+ * lies far out than the curve allows.
+ */
+export const excessKurtosisOf = (standardised) => standardised.reduce((total, z) => total + z ** 4, 0) / standardised.length - 3;
+/** What the sample puts beyond the given distance, against what a normal sample would. */
+export const tailOf = (standardised, beyond) => ({
+    beyond,
+    observed: standardised.filter(z => Math.abs(z) > beyond).length,
+    expected: standardised.length * normalBeyond(beyond)
+});
+/**
+ * The sample counted into bins of the given width, laid out on
+ * multiples of that width so that two histograms of one width share
+ * their bounds. Nothing for an empty sample or a width of nothing.
+ */
+export const histogramOf = (values, binWidth) => {
+    if (values.length === 0 || binWidth <= 0)
+        return undefined;
+    const first = Math.floor(Math.min(...values) / binWidth) * binWidth;
+    const last = Math.ceil(Math.max(...values) / binWidth) * binWidth;
+    const bins = Math.max(1, Math.round((last - first) / binWidth));
+    return {
+        edges: Array.from({ length: bins + 1 }, (_, i) => quantity(first + i * binWidth)),
+        counts: values.reduce((tally, value) => {
+            tally[Math.min(bins - 1, Math.floor((value - first) / binWidth))] += 1;
+            return tally;
+        }, new Array(bins).fill(0))
+    };
+};

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. */

package/lib/systems/index.js

@@ -1,7 +1,7 @@
-import { systemIdOf } from "../TrackerBar";
-import { welteT100 } from "./welteT100/bar";
-import { welteLicensee } from "./welteLicensee/bar";
-import { welteT98 } from "./welteT98/bar";
+import { systemIdOf } from "../TrackerBar.js";
+import { welteT100 } from "./welteT100/bar.js";
+import { welteLicensee } from "./welteLicensee/bar.js";
+import { welteT98 } from "./welteT98/bar.js";
 /** The tracker bars the library knows, the T-100 first as the usual one. */
 export const trackerBars = [welteT100, welteLicensee, welteT98];
 /** The bar of a system the type vocabulary knows, from its concept. */

package/lib/systems/welteLicensee/bar.d.ts

@@ -1,4 +1,4 @@
-import { TrackerBar } from "../../TrackerBar";
+import { TrackerBar } from "../../TrackerBar.js";
 /**
  * Welte-Mignon (Licensee), the American re-cut of the T-100 rolls on
  * a roll 11¼ inches wide with 98 positions at nine to the inch, cf.

package/lib/systems/welteLicensee/bar.js

@@ -1,5 +1,5 @@
-import { describeTrackerBar } from "../../TrackerBar";
-import { mm } from "../../Quantity";
+import { describeTrackerBar } from "../../TrackerBar.js";
+import { mm } from "../../Quantity.js";
 /**
  * Welte-Mignon (Licensee), the American re-cut of the T-100 rolls on
  * a roll 11¼ inches wide with 98 positions at nine to the inch, cf.

package/lib/systems/welteLicensee/system.d.ts

@@ -1,5 +1,5 @@
-import { ReproducingSystem } from "../../ReproducingSystem";
-import { type WelteT100Options } from "../welteT100/system";
+import { ReproducingSystem } from "../../ReproducingSystem.js";
+import { type WelteT100Options } from "../welteT100/system.js";
 export type WelteLicenseeOptions = WelteT100Options;
 /**
  * The one instrument on offer, and it is not a Licensee instrument.

package/lib/systems/welteLicensee/system.js

@@ -1,7 +1,7 @@
 import { CONSENSUS } from "welte-mignon-emulator/t100";
-import { track } from "../../Quantity";
-import { welteLicensee } from "./bar";
-import { defaultWelteT100Options, instrumentNameOf, nuanceOf, performAs } from "../welteT100/system";
+import { track } from "../../Quantity.js";
+import { welteLicensee } from "./bar.js";
+import { defaultWelteT100Options, instrumentNameOf, nuanceOf, performAs } from "../welteT100/system.js";
 /**
  * The one instrument on offer, and it is not a Licensee instrument.
  *

package/lib/systems/welteT100/bar.d.ts

@@ -1,4 +1,4 @@
-import { TrackerBar } from "../../TrackerBar";
+import { TrackerBar } from "../../TrackerBar.js";
 /**
  * The commands of the Welte-Mignon T-100, as its tracker bar reads them.
  */

package/lib/systems/welteT100/bar.js

@@ -1,5 +1,5 @@
-import { describeTrackerBar } from "../../TrackerBar";
-import { metersPerMinute, mm } from "../../Quantity";
+import { describeTrackerBar } from "../../TrackerBar.js";
+import { metersPerMinute, mm } from "../../Quantity.js";
 /**
  * The commands of the Welte-Mignon T-100, as its tracker bar reads them.
  */

package/lib/systems/welteT100/system.d.ts

@@ -1,9 +1,9 @@
 import { Half, Parameters, PedalMode, Spool } from "welte-mignon-emulator";
 import { Instrument, RollNumber } from "welte-mignon-emulator/t100";
-import { NegotiatedEvent, Performance, ReproducingSystem, RollProperties } from "../../ReproducingSystem";
-import { Millimeters, Seconds, Track } from "../../Quantity";
-import { type VelocityMap } from "../velocity";
-export type { VelocityMap } from "../velocity";
+import { NegotiatedEvent, Performance, ReproducingSystem, RollProperties } from "../../ReproducingSystem.js";
+import { Millimeters, Seconds, Track } from "../../Quantity.js";
+import { type VelocityMap } from "../velocity.js";
+export type { VelocityMap } from "../velocity.js";
 export type { Instrument } from "welte-mignon-emulator/t100";
 export type InstrumentName = 'consensus' | RollNumber;
 /**

package/lib/systems/welteT100/system.js

@@ -1,9 +1,9 @@
 import { DEFAULT_PUNCH_MM, geometryInMm, Grid, levelChanges, paperSeconds, pedalBrushing, pedalDefaults, ROWS_PER_MM, TRACKER_BORE_MM, WELTE_SPOOL, } from "welte-mignon-emulator";
 import { aperturePorts, CONSENSUS, mezzoforteTravel, pneumaticModel, PRESETS, runPedals, travelBetweenRails, } from "welte-mignon-emulator/t100";
-import { welteT100 } from "./bar";
-import { inCentimeters, mm, seconds, track } from "../../Quantity";
-import { partitionPoint } from "../../sorted";
-import { defaultVelocityMap, velocityOf } from "../velocity";
+import { welteT100 } from "./bar.js";
+import { inCentimeters, mm, seconds, track } from "../../Quantity.js";
+import { partitionPoint } from "../../sorted.js";
+import { defaultVelocityMap, velocityOf } from "../velocity.js";
 /**
  * The instruments the emulator was fitted as: the consensus over the six
  * rolls with drawn nuance lines, and the setting that drew each of them,

package/lib/systems/welteT98/bar.d.ts

@@ -1,4 +1,4 @@
-import { TrackerBar } from "../../TrackerBar";
+import { TrackerBar } from "../../TrackerBar.js";
 /**
  * The commands of the Welte-Mignon T-98, as its tracker bar reads them.
  *

package/lib/systems/welteT98/bar.js

@@ -1,5 +1,5 @@
-import { describeTrackerBar } from "../../TrackerBar";
-import { metersPerMinute, mm } from "../../Quantity";
+import { describeTrackerBar } from "../../TrackerBar.js";
+import { metersPerMinute, mm } from "../../Quantity.js";
 /**
  * The commands of the Welte-Mignon T-98, as its tracker bar reads them.
  *

package/lib/systems/welteT98/system.d.ts

@@ -1,9 +1,9 @@
 import { Half, Parameters, PedalMode, Spool } from "welte-mignon-emulator";
 import { instrumentT98Of, labelOf, nuanceOf, WelteT98InstrumentName } from "welte-mignon-emulator/t98";
-import { ReproducingSystem } from "../../ReproducingSystem";
-import { Millimeters, Seconds, Track } from "../../Quantity";
-import { type VelocityMap } from "../velocity";
-export type { VelocityMap } from "../velocity";
+import { ReproducingSystem } from "../../ReproducingSystem.js";
+import { Millimeters, Seconds, Track } from "../../Quantity.js";
+import { type VelocityMap } from "../velocity.js";
+export type { VelocityMap } from "../velocity.js";
 export type { WelteT98Instrument, WelteT98InstrumentName } from "welte-mignon-emulator/t98";
 /**
  * The instruments the emulator offers for the green Welte, in three groups that

package/lib/systems/welteT98/system.js

@@ -1,9 +1,9 @@
 import { geometryInMm, Grid, levelChanges, mezzoforteTravel, paperSeconds, pedalBrushing, pedalDefaults, ROWS_PER_MM, travelBetweenRails, 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";
-import { inCentimeters, mm, seconds, track } from "../../Quantity";
-import { partitionPoint } from "../../sorted";
-import { defaultVelocityMap, velocityOf } from "../velocity";
+import { welteT98 } from "./bar.js";
+import { inCentimeters, mm, seconds, track } from "../../Quantity.js";
+import { partitionPoint } from "../../sorted.js";
+import { defaultVelocityMap, velocityOf } from "../velocity.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.

package/lib/utils.d.ts

@@ -14,6 +14,8 @@ export type WithId = {
 };
 /** Whether a value is a date as the format writes one, `YYYY-MM-DD`. */
 export declare const isDateString: (value: unknown) => value is string;
+/** The items by the key each of them gives, every group in the order its first item came in. */
+export declare const groupBy: <T>(items: readonly T[], keyOf: (item: T) => string) => Map<string, T[]>;
 export type WithNote = {
     /**
      * A free-text note providing additional context.

package/lib/utils.js

@@ -1,2 +1,12 @@
 /** Whether a value is a date as the format writes one, `YYYY-MM-DD`. */
 export const isDateString = (value) => typeof value === 'string' && /^\d{4}-\d{1,2}-\d{1,2}$/.test(value);
+/** The items by the key each of them gives, every group in the order its first item came in. */
+export 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());

package/lib/validate.d.ts

@@ -1,5 +1,5 @@
 import { type ErrorObject } from "ajv";
-import { Edition } from "./Edition";
+import { Edition } from "./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/validate.js

@@ -1,5 +1,5 @@
 import Ajv from "ajv";
-import * as schema from "./schema.json";
+import * as schema from "./schema.json" with { type: 'json' };
 const compileEditionSchema = () => new Ajv({ strict: false, formats: { "date": true } }).compile(schema);
 /**
  * Compiling costs enough that a consumer which never validates should not

package/lib/vocabulary.d.ts

@@ -1,4 +1,4 @@
-import { Concept } from "./Agent";
+import { Concept } from "./Agent.js";
 /**
  * The concepts the type vocabulary declares, whatever kind they are:
  * the reproducing systems and the procedures. An edition names one of

package/lib/vocabulary.js

@@ -1,6 +1,6 @@
-import { procedures } from "./procedures";
-import { systemOf } from "./TrackerBar";
-import { trackerBars } from "./systems";
+import { procedures } from "./procedures.js";
+import { systemOf } from "./TrackerBar.js";
+import { trackerBars } from "./systems/index.js";
 /**
  * The concepts the type vocabulary declares, whatever kind they are:
  * the reproducing systems and the procedures. An edition names one of

package/lib/witnesses.d.ts

@@ -1,5 +1,5 @@
-import { Belief, Certainty } from "./Assumption";
-import { EditionView } from "./EditionView";
+import { Belief, Certainty } from "./Assumption.js";
+import { EditionView } from "./EditionView.js";
 export type WitnessBy = 'carriers' | 'statement';
 /** A copy that bears witness to a version, and how. */
 export interface Witness {

package/lib/witnesses.js

@@ -1,5 +1,5 @@
-import { certaintyOf, idOf, idsOf } from "./Assumption";
-import { insertedBy } from "./Version";
+import { certaintyOf, idOf, idsOf } from "./Assumption.js";
+import { insertedBy } from "./Version.js";
 /** The copies whose features carry any of the symbols. */
 const copiesCarrying = (view, symbols) => new Set(symbols
     .flatMap(symbol => idsOf(symbol.carriers))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linked-rolls",
-  "version": "0.43.0",
+  "version": "0.45.0",
   "description": "Digital editions of piano rolls: import, collation, editorial assumptions, JSON-LD export, and emulation through a reproducing system",
   "license": "MIT",
   "repository": {