linked-rolls 0.43.0 → 0.45.0

package/lib/Version.js

@@ -1,5 +1,5 @@
-import { certainties, certaintyOf, idOf } from "./Assumption";
-import { defaultCollationTolerance } from "./Collation";
+import { certainties, certaintyOf, idOf } from "./Assumption.js";
+import { defaultCollationTolerance } from "./Collation.js";
 /** The tolerance the derivation was collated at, or the default where it states none. */
 export const collationToleranceOf = (derivation) => derivation.collationTolerance ?? defaultCollationTolerance;
 /** The edits the version states, none where it leaves its text unstated. */

package/lib/alignment.d.ts

@@ -1,7 +1,7 @@
-import { FeatureOrPatch } from "./Feature";
-import { RollCopy, Shift } from "./RollCopy";
-import { TrackerBar } from "./TrackerBar";
-import { Millimeters } from "./Quantity";
+import { FeatureOrPatch } from "./Feature.js";
+import { RollCopy, Shift } from "./RollCopy.js";
+import { TrackerBar } from "./TrackerBar.js";
+import { Millimeters } from "./Quantity.js";
 export declare const applyShift: (shift: Shift, copy: RollCopy) => void;
 /** Scales the copy's features away from the beginning of the roll, and records the factor. */
 export declare const applyScale: (factor: number, copy: RollCopy) => void;

package/lib/alignment.js

@@ -1,6 +1,6 @@
-import { featuresOf } from "./RollCopy";
-import { welteT100 } from "./systems/welteT100/bar";
-import { add, mm, scale } from "./Quantity";
+import { featuresOf } from "./RollCopy.js";
+import { welteT100 } from "./systems/welteT100/bar.js";
+import { add, mm, scale } from "./Quantity.js";
 /** Moves both ends of a span, the far end only where the span has one. */
 const move = (span, by) => {
     span.from = add(span.from, by);

package/lib/asJsonLd.d.ts

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

package/lib/asJsonLd.js

@@ -1,6 +1,6 @@
-import { systemIdIn } from "./TrackerBar";
-import { certaintyOf, isAsserted } from "./Assumption";
-import context from "./spec/context.json";
+import { systemIdIn } from "./TrackerBar.js";
+import { certaintyOf, isAsserted } from "./Assumption.js";
+import context from "./spec/context.json" with { type: 'json' };
 /**
  * The keys an export derives from the tree, which no node of the
  * edition states itself. An import reads them off again.

package/lib/constraints.d.ts

@@ -1,4 +1,4 @@
-import { EditionView } from "./EditionView";
+import { EditionView } from "./EditionView.js";
 export type ConstraintProblem = {
     version: string;
     symbol: string;

package/lib/constraints.js

@@ -1,8 +1,8 @@
-import { idOf } from "./Assumption";
-import { isCommand, pairsAmong, placementsOf } from "./Symbol";
-import { keyOf } from "./TrackerBar";
-import { trackerBarOf } from "./systems";
-import { barOf } from "./RollCopy";
+import { idOf } from "./Assumption.js";
+import { isCommand, pairsAmong, placementsOf } from "./Symbol.js";
+import { keyOf } from "./TrackerBar.js";
+import { trackerBarOf } from "./systems/index.js";
+import { barOf } from "./RollCopy.js";
 const missingReference = {
     alignedWith: 'alignment-reference-missing',
     before: 'before-reference-missing',

package/lib/context.js

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

package/lib/editionOps.d.ts

@@ -1,13 +1,13 @@
 import { Draft } from "immer";
-import { EditionView, Path } from "./EditionView";
-import { Edition } from "./Edition";
-import { AnySymbol, PlacementRelation } from "./Symbol";
-import { CollationTolerance } from "./Collation";
-import { Edit } from "./Edit";
-import { GeneralRollCondition, ModificationPurpose, RollCopy, ScaleReading, Shift } from "./RollCopy";
-import { FeatureSource } from "./FeatureSource";
-import { AnyArgumentation, Belief, Certainty, ObjectAssumption } from "./Assumption";
-import { FeatureConditionAssignment, FeatureOrPatch, NestedFeature } from "./Feature";
+import { EditionView, Path } from "./EditionView.js";
+import { Edition } from "./Edition.js";
+import { AnySymbol, PlacementRelation } from "./Symbol.js";
+import { CollationTolerance } from "./Collation.js";
+import { Edit } from "./Edit.js";
+import { GeneralRollCondition, ModificationPurpose, RollCopy, ScaleReading, Shift } from "./RollCopy.js";
+import { FeatureSource } from "./FeatureSource.js";
+import { AnyArgumentation, Belief, Certainty, ObjectAssumption } from "./Assumption.js";
+import { FeatureConditionAssignment, FeatureOrPatch, NestedFeature } from "./Feature.js";
 /**
  * A change to an edition, written onto an immer draft of it. One
  * operation is one undo step, so an operation that has to read the
@@ -157,14 +157,46 @@ export declare const mergeFeatures: (copyId: string, featureIds: readonly string
  * and the child lacks becomes its deletions. The derivation states the
  * tolerance it was collated at and becomes the principal one; the
  * hypotheses the child stated beside its former one stay.
+ *
+ * The edits the child already stated are rewritten only as far as a
+ * collation wrote them (`isCollationsOwn`). An editor's reading of the
+ * difference between the two texts stays, and the symbols it speaks for
+ * are left out of the collation, so that connecting the two again
+ * neither doubles them nor silently drops what somebody established by
+ * hand. An equivalence is the collation's own, since it is drawn from
+ * the two systems' vocabularies rather than read off the paper, but one
+ * drawn again over the very same symbols is kept as it stands, with its
+ * identifier and whatever was written on it.
+ *
+ * The child's own text is what it shows less what the parent hands
+ * down, so that connecting two versions already connected collates the
+ * child's symbols and not the parent's with themselves.
  */
-export declare const connectVersions: (view: EditionView, childId: string, parentId: string, tolerance?: CollationTolerance) => EditionOp;
+export declare const connectVersions: (view: EditionView, childId: string, parentId: string, tolerance?: ObjectAssumption<CollationTolerance>) => EditionOp;
 /**
  * Folds the version's own symbols into those it inherits and collates
  * with: the carriers pass over, and the insertions go. Collates at the
  * tolerance of the derivation, where the caller names none.
  */
 export declare const collateSymbols: (view: EditionView, versionId: string, symbolIds: readonly string[], tolerance?: CollationTolerance) => EditionOp;
+/**
+ * Takes the copy's reading of a symbol back out of the symbol it was
+ * collated into: the copy's carriers pass to a new symbol of the
+ * version's own, the other copies keep the symbol they had, and the
+ * version states the exchange.
+ *
+ * This is the inverse of the hand-over a collation makes, and it is
+ * what lets a derivation be collated a second time. A collated symbol
+ * is one symbol carrying every copy that reads it, so nothing else
+ * takes the two readings apart again, and without that a tolerance
+ * arrived at after the fact could never be applied.
+ *
+ * Symbols the copy alone carries are already the version's own and are
+ * passed over, so a reading somebody has separated by hand keeps its
+ * identifier and the edit that speaks for it. Named symbols narrow the
+ * act to those; naming none separates the copy's whole reading.
+ */
+export declare const separateReadings: (view: EditionView, versionId: string, copyId: string, symbolIds?: readonly string[]) => EditionOp;
 /**
  * Makes the version stand on its own: what it inherited becomes its
  * own insertions, and its derivations go, the hypotheses among them,

package/lib/editionOps.js

@@ -1,17 +1,17 @@
 import { current, isDraft } from "immer";
 import { v4 } from "uuid";
-import { getAt } from "./EditionView";
-import { isCommand, placementRelations } from "./Symbol";
-import { collationsOf, defaultCollationTolerance } from "./Collation";
-import { collationToleranceOf, editsOf, insertedBy, principalDerivationOf } from "./Version";
-import { asSymbols, barOf, featuresByAct, featuresOf, isPaperStretch, statesNothing } from "./RollCopy";
-import { systemOf } from "./TrackerBar";
-import { substitutionsBetween } from "./substitution";
-import { trackerBarOf } from "./systems";
-import { applyShift, applyScale, revertShift, revertScale } from "./alignment";
-import { assignReference, idOf } from "./Assumption";
-import { conditions as conditionsAllowed, featuresBorneBy, isGluedOn, withBorneFeatures } from "./Feature";
-import { distance, mm, subtract } from "./Quantity";
+import { getAt } from "./EditionView.js";
+import { isCommand, placementRelations } from "./Symbol.js";
+import { collationsOf, defaultCollationTolerance, isCollationsOwn } from "./Collation.js";
+import { collationToleranceOf, editsOf, insertedBy, principalDerivationOf } from "./Version.js";
+import { asSymbols, barOf, featuresByAct, featuresOf, isPaperStretch, statesNothing } from "./RollCopy.js";
+import { systemOf } from "./TrackerBar.js";
+import { substitutionsBetween } from "./substitution.js";
+import { trackerBarOf } from "./systems/index.js";
+import { applyShift, applyScale, revertShift, revertScale } from "./alignment.js";
+import { assignReference, idOf } from "./Assumption.js";
+import { conditions as conditionsAllowed, featuresBorneBy, isGluedOn, withBorneFeatures } from "./Feature.js";
+import { distance, mm, subtract } from "./Quantity.js";
 const noChange = () => undefined;
 const onCopy = (copyId, op) => draft => {
     const copy = draft.copies.find(c => c.id === copyId);
@@ -651,6 +651,20 @@ const dropDerivations = (version, matches) => {
     else
         delete version.basedOn;
 };
+/** The symbols a set of edits speaks for, whether by inserting or by deleting them. */
+const spokenForBy = (edits) => new Set(edits.flatMap(edit => [
+    ...(edit.insert ?? []).map(symbol => symbol.id),
+    ...(edit.delete ?? [])
+]));
+/** An exchange of symbols, as a key: what it puts in against what it takes out. */
+const exchangeKey = (inserted, deleted) => `${[...inserted].sort().join(',')}/${[...deleted].sort().join(',')}`;
+/**
+ * The edits already stated, by the exchange each of them makes. An
+ * equivalence the collation draws a second time is the one already
+ * stated, and drawing it again is no reason to mint a new identifier or
+ * to drop the motivation somebody wrote on it.
+ */
+const byExchange = (edits) => new Map(edits.map(edit => [exchangeKey((edit.insert ?? []).map(symbol => symbol.id), edit.delete ?? []), edit]));
 /**
  * Bases the child on the parent. A symbol of the child that collates
  * with one the parent hands down adds its carriers to that symbol; the
@@ -658,10 +672,36 @@ const dropDerivations = (version, matches) => {
  * and the child lacks becomes its deletions. The derivation states the
  * tolerance it was collated at and becomes the principal one; the
  * hypotheses the child stated beside its former one stay.
+ *
+ * The edits the child already stated are rewritten only as far as a
+ * collation wrote them (`isCollationsOwn`). An editor's reading of the
+ * difference between the two texts stays, and the symbols it speaks for
+ * are left out of the collation, so that connecting the two again
+ * neither doubles them nor silently drops what somebody established by
+ * hand. An equivalence is the collation's own, since it is drawn from
+ * the two systems' vocabularies rather than read off the paper, but one
+ * drawn again over the very same symbols is kept as it stands, with its
+ * identifier and whatever was written on it.
+ *
+ * The child's own text is what it shows less what the parent hands
+ * down, so that connecting two versions already connected collates the
+ * child's symbols and not the parent's with themselves.
  */
 export const connectVersions = (view, childId, parentId, tolerance = defaultCollationTolerance) => {
-    const inherited = view.snapshot(parentId);
-    const own = view.snapshot(childId);
+    const child = view.get(childId);
+    const stated = child ? editsOf(child) : [];
+    const established = stated.filter(edit => !isCollationsOwn(edit));
+    const spokenFor = spokenForBy(established);
+    const unspoken = (symbol) => !spokenFor.has(symbol.id);
+    // What the parent hands down and the child still shows passes
+    // through: it is neither the child's own symbol nor one it lacks.
+    // Without that, connecting a pair already connected would collate
+    // the inherited symbols with themselves and double their carriers.
+    const handedDown = view.snapshot(parentId).filter(unspoken);
+    const shown = new Set(view.snapshot(childId).map(symbol => symbol.id));
+    const inheritedIds = new Set(handedDown.map(symbol => symbol.id));
+    const inherited = handedDown.filter(symbol => !shown.has(symbol.id));
+    const own = view.snapshot(childId).filter(symbol => unspoken(symbol) && !inheritedIds.has(symbol.id));
     const locate = (symbol) => view.placeOf(symbol);
     const collations = collationsOf(own, inherited, locate, tolerance);
     const collated = new Set(collations.map(({ symbol }) => symbol.id));
@@ -673,18 +713,25 @@ export const connectVersions = (view, childId, parentId, tolerance = defaultColl
      * apart would make the apparatus a list of unexplained losses beside
      * a list of unexplained gains.
      */
-    const substituted = differ(view.get(childId), view.get(parentId))
+    const substituted = differ(child, view.get(parentId))
         ? substitutionsBetween(own.filter(symbol => !collated.has(symbol.id)), inherited.filter(symbol => !matched.has(symbol.id)), locate, tolerance)
         : [];
     const paired = new Set(substituted.flatMap(({ replaced, by }) => [...by, ...replaced].map(symbol => symbol.id)));
-    const edits = [
-        ...substituted.map(({ replaced, by }) => ({
+    const alreadyStated = byExchange(stated);
+    const equivalence = ({ replaced, by }) => {
+        const inserted = by.map(symbol => symbol.id);
+        const deleted = replaced.map(symbol => symbol.id);
+        return alreadyStated.get(exchangeKey(inserted, deleted)) ?? {
             type: 'edit',
             id: v4(),
             editType: 'replace-with-equivalent',
             insert: [...by],
-            delete: replaced.map(symbol => symbol.id)
-        })),
+            delete: deleted
+        };
+    };
+    const edits = [
+        ...established,
+        ...substituted.map(equivalence),
         ...own.filter(symbol => !collated.has(symbol.id) && !paired.has(symbol.id)).map(insertion),
         ...inherited
             .filter(symbol => !matched.has(symbol.id) && !paired.has(symbol.id))
@@ -718,6 +765,72 @@ export const collateSymbols = (view, versionId, symbolIds, tolerance) => {
         dropInsertions(version, collated);
     });
 };
+/** The symbol as one copy reads it: what it says, on the given carriers, standing in no relation of its own. */
+const readingOf = (symbol, carriers) => {
+    const identity = { id: v4(), carriers };
+    switch (symbol.type) {
+        case 'note':
+            return { type: 'note', pitch: symbol.pitch, ...identity };
+        case 'expression':
+            return { type: 'expression', expressionType: symbol.expressionType, scope: symbol.scope, ...identity };
+        case 'text':
+            return { type: 'text', text: symbol.text, ...identity };
+    }
+};
+/** The symbol where the copy and at least one other carry it, with the carriers of each side. */
+const sharedWith = (view, symbol, copyId) => {
+    const onCopy = (carrier) => view.copyOf(idOf(carrier))?.id === copyId;
+    const mine = symbol.carriers.filter(onCopy);
+    const theirs = symbol.carriers.filter(carrier => !onCopy(carrier));
+    return mine.length > 0 && theirs.length > 0 ? [{ symbol, mine, theirs }] : [];
+};
+/**
+ * Takes the copy's reading of a symbol back out of the symbol it was
+ * collated into: the copy's carriers pass to a new symbol of the
+ * version's own, the other copies keep the symbol they had, and the
+ * version states the exchange.
+ *
+ * This is the inverse of the hand-over a collation makes, and it is
+ * what lets a derivation be collated a second time. A collated symbol
+ * is one symbol carrying every copy that reads it, so nothing else
+ * takes the two readings apart again, and without that a tolerance
+ * arrived at after the fact could never be applied.
+ *
+ * Symbols the copy alone carries are already the version's own and are
+ * passed over, so a reading somebody has separated by hand keeps its
+ * identifier and the edit that speaks for it. Named symbols narrow the
+ * act to those; naming none separates the copy's whole reading.
+ */
+export const separateReadings = (view, versionId, copyId, symbolIds) => {
+    const version = view.get(versionId);
+    if (!version)
+        return noChange;
+    const chosen = symbolIds && new Set(symbolIds);
+    const shared = view.snapshot(versionId)
+        .filter(symbol => chosen === undefined || chosen.has(symbol.id))
+        .flatMap(symbol => sharedWith(view, symbol, copyId));
+    if (shared.length === 0)
+        return noChange;
+    const inserted = new Set(insertedBy(version).map(symbol => symbol.id));
+    const stated = editsOf(version);
+    const separations = shared.map(({ symbol, mine }) => ({
+        type: 'edit',
+        id: v4(),
+        insert: [readingOf(symbol, [...mine])],
+        // A symbol the version inserts itself stays where it is, minus
+        // the carriers that leave it. Only one it inherits is exchanged.
+        ...(inserted.has(symbol.id) ? {} : { delete: [symbol.id] })
+    }));
+    return onVersion(versionId, (version, draft) => {
+        shared.forEach(({ symbol, theirs }) => {
+            const path = view.getPath(symbol.id);
+            const target = path && getAt(path, draft);
+            if (target)
+                target.carriers = theirs;
+        });
+        version.edits = [...stated, ...separations];
+    });
+};
 /**
  * Makes the version stand on its own: what it inherited becomes its
  * own insertions, and its derivations go, the hypotheses among them,

package/lib/importJsonLd.d.ts

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

package/lib/importJsonLd.js

@@ -1,6 +1,6 @@
-import { derivedKeys } from "./asJsonLd";
-import { migrate } from "./migrate";
-import { isDateString } from "./utils";
+import { derivedKeys } from "./asJsonLd.js";
+import { migrate } from "./migrate.js";
+import { isDateString } from "./utils.js";
 export const importDate = (str) => {
     const [y, m, d] = str.split('-').map(s => parseInt(s, 10));
     if ([y, m, d].some(n => isNaN(n))) {

package/lib/index.d.ts

@@ -1,40 +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 './Edition';
-export * from './EditionView';
-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, type StanfordAtonOptions } from './readers/stanfordAton';
-export { readFromPhillipsEroll, CONTROL_OFFSET, phillipsSystems, type PhillipsErollOptions } from './readers/phillipsEroll';
-export { readFromSpencerBar, readSpencerAnn, paperSpeedOfSpencerAnn, SPENCER_ROWS_PER_INCH, type SpencerBarOptions } 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, type StanfordAtonOptions } from './readers/stanfordAton.js';
+export { readFromPhillipsEroll, CONTROL_OFFSET, phillipsSystems, type PhillipsErollOptions } from './readers/phillipsEroll.js';
+export { readFromSpencerBar, readSpencerAnn, paperSpeedOfSpencerAnn, SPENCER_ROWS_PER_INCH, type SpencerBarOptions } from './readers/spencerBar.js';

package/lib/index.js

@@ -1,40 +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 './Edition';
-export * from './EditionView';
-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 = {
@@ -40,6 +40,17 @@ const withoutVersionType = (node) => {
     const { versionType: _retired, ...rest } = node;
     return rest;
 };
+/**
+ * A version carried the label it was cited under, from before the sigla
+ * were read off the stemma. A copy keeps its siglum, which is given by
+ * hand and derives from nothing.
+ */
+const withoutVersionSiglum = (node) => {
+    if (node['@type'] !== 'Version' || !Object.hasOwn(node, 'siglum'))
+        return node;
+    const { siglum: _labelled, ...rest } = node;
+    return rest;
+};
 const withLowerCaseTerms = (node) => Object.entries(lowerCasedTerms).reduce((result, [key, terms]) => {
     const lowered = terms[result[key]];
     return lowered ? { ...result, [key]: lowered } : result;
@@ -221,7 +232,7 @@ const withTimeSpanDates = (node) => {
     const { '@value': within, '@type': _typed, ...rest } = node;
     return { ...rest, within };
 };
-const migrateNode = (node) => [withRenamedKeys, withTypology, withoutVersionType, withLowerCaseTerms, withSplitMethod, withReferences, withKeeper, withoutEmptyKeeper,
+const migrateNode = (node) => [withRenamedKeys, withTypology, withoutVersionType, withoutVersionSiglum, withLowerCaseTerms, withSplitMethod, withReferences, withKeeper, withoutEmptyKeeper,
     withProductionNodes, withScale, withDerivationList, withReadingKind, withTimeSpanDates, withoutFeatureKind,
     withBorneFeaturesNamed, withFeaturesInActs]
     .reduce((result, step) => step(result), node);

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
@@ -14,7 +14,22 @@ import { Millimeters, Seconds } from "../Quantity";
  * elapsed time, not paper, and the take-up spool accelerates the paper
  * as it fills, so `placeAt` has to put the time back onto the paper.
  * And a switch stays open longer than its perforation is long, so a
- * hole read here runs past the punched one.
+ * hole read here runs past the punched one: Phillips measures the
+ * pneumatic on-time as exceeding the apparent length of a perforation
+ * (p. 178), and names what it depends on as the length of the
+ * perforation, the height of the tracker bar hole and the paper speed
+ * (p. 180).
+ *
+ * That extension is not subtracted. Doing so would need the absolute
+ * hole height of the Welte bar, where he gives only the 0.5 mm by which
+ * it exceeds the Licensee's. So the end of a hole on this copy is a
+ * pneumatic on-time where the end of a scanned copy's hole is a punched
+ * slot, and the two are not the same quantity. It shows in a collation:
+ * across welte225.org his notes run about 1.8 mm longer than the other
+ * copies read them, while the onsets agree. Until it is corrected, a
+ * comparison of hole ends against this copy measures the reader as much
+ * as the roll, and `offsetEnd` on the derivation absorbs the systematic
+ * part of it.
  */
 /**
  * He numbers his files by two rules at once, which his free samples