linked-rolls 0.62.0 → 0.64.0

package/lib/model/RollCopy.d.ts

@@ -2,26 +2,52 @@ import { ConditionState } from "./ConditionState.js";
 import { AnySymbol } from "./Symbol.js";
 import { TrackerBar } from "../systems/TrackerBar.js";
 import { TrackCalibration } from "./TrackCalibration.js";
-import { AnyFeature, FeatureOrPatch, Patch } from "./Feature.js";
+import { AnyFeature, FeatureOrPatch, HorizontalSpan, Patch } from "./Feature.js";
 import { ActorAssignment, DateAssignment, ObjectAssumption, ReferenceAssumption } from "./Assumption.js";
 import { WithId, WithType } from "../shared/utils.js";
 import { Agent, Concept } from "./Agent.js";
 import { FeatureSource } from "./FeatureSource.js";
-import { Measure, Millimeters, Quantity, Track } from "./Quantity.js";
+import { Measure, Millimeters, Percent, Quantity, Track } from "./Quantity.js";
 import { Perforator } from "./Perforator.js";
 /**
- * This condition state is used to describe the roll's
- * paper shrinkage or stretching. It might be calculated
- * on the basis of comparing the vertical or horizontal
- * extent with other witnesses of the same roll.
+ * How far the paper has stretched, or shrunk where it is negative, since
+ * it was perforated, as a share of its length then: the strain
+ * ΔL / L. It is a ratio of two lengths and so has no unit of its own,
+ * and it is stated in per cent because what paper does is a matter of
+ * tenths of one. It is taken in one direction, along the roll or across
+ * it, since machine-made paper does not stretch the same way in both.
+ * @see crm:E54 Dimension
+ */
+export interface Strain extends Measure<'percent'> {
+    /**
+     * The standard uncertainty of the value, one standard deviation.
+     * Left out where the measurement gave none, which leaves it no more
+     * precise than paper is known to vary.
+     * @see reo:uncertainty
+     */
+    uncertainty?: Percent;
+}
+/**
+ * The paper of the copy stretched or shrunk, as measured on the copy:
+ * with a rule against a length the perforator fixed, or across the roll
+ * against the pitch of the punch block. What the alignments of the
+ * copies say about the paper is worked out from them (`paperOf`) and not
+ * stated here, so that a condition stands only where something was
+ * measured. A strain along the roll goes into that working out.
+ * @see crm:E3 Condition State
  */
 export interface PaperStretch extends ConditionState<'paper-stretch'> {
     /**
-     * The stretch factor, e.g. 1.02 means the paper has
-     * stretched by 2% compared to its original dimensions.
-     * @see rdf:value
+     * The strain along the roll, the direction the alignment measures.
+     * @see reo:strainAlong
+     */
+    along?: Strain;
+    /**
+     * The strain across the roll. Paper stretches more across than
+     * along, so this is no measure of the other.
+     * @see reo:strainAcross
      */
-    factor: number;
+    across?: Strain;
 }
 /**
  * A general condition description for a roll copy, e.g.
@@ -31,20 +57,53 @@ export interface PaperStretch extends ConditionState<'paper-stretch'> {
 export interface GeneralRollCondition extends ConditionState<'general'> {
 }
 /**
- * An assignment of a condition (general or paper-stretch)
+ * The paper of the copy torn at one place, most often a tear running in
+ * from one of its edges. Each tear is a condition of its own, so that
+ * each can carry the belief it rests on and serve as a premise. A tear
+ * that runs into a chain of holes damages the chain as well, which is
+ * then stated of the chain as `partially-torn`.
+ * @see crm:E3 Condition State
+ */
+export interface Tear extends ConditionState<'torn'> {
+    /**
+     * Where along the roll the tear lies, measured as the copy's
+     * features are, so that it moves with them when the copy is aligned.
+     * @see reo:horizontal
+     */
+    horizontal: HorizontalSpan;
+    /**
+     * The edge of the paper the tear runs in from, where it runs in
+     * from one.
+     * @see reo:edge
+     */
+    edge?: 'bass' | 'treble';
+    /**
+     * How far the tear reaches into the paper, taken across the roll
+     * from the edge it runs in from.
+     * @see reo:depth
+     */
+    depth?: Measure<'mm'>;
+    /**
+     * IIIF region pointing to a depiction of the tear in the scan.
+     * @see crm:P138i has representation
+     */
+    depiction?: string;
+}
+/**
+ * An assignment of a condition (general, paper-stretch or a tear)
  * to a roll copy, annotatable with a belief about its certainty.
  */
-export type RollConditionAssignment = ObjectAssumption<GeneralRollCondition | PaperStretch>;
+export type RollConditionAssignment = ObjectAssumption<GeneralRollCondition | PaperStretch | Tear>;
 /**
  * The keeper a copy is held by, as an object assumption, so that the
  * statement can carry the belief it rests on and the reasons for it.
  */
 export type KeeperAssignment = ObjectAssumption<Agent>;
-export declare const rollConditions: readonly ['general', 'paper-stretch'];
+export declare const rollConditions: readonly ['general', 'paper-stretch', 'torn'];
 /**
- * A shift correction applied to a roll copy to align it
- * with other copies. The shift is defined as horizontal
- * (along the roll length, in mm) and vertical (across tracks).
+ * How far an alignment moves a copy's places before it scales them:
+ * along the roll, in the copy's own millimetres, and across it, in
+ * tracks.
  */
 export interface Shift {
     /** Along the roll. */
@@ -52,6 +111,56 @@ export interface Shift {
     /** Across the tracker bar. */
     vertical: Track;
 }
+/**
+ * How the copy's own places are carried onto the edition's axis, which
+ * is the millimetres of its reference copy (`Edition.referenceCopy`):
+ *
+ *     x_axis = (x + shift.horizontal) · scale
+ *     track_axis = track + shift.vertical
+ *
+ * It is found, not given: `alignCopy` matches the copy's notes with the
+ * reference copy's and records what it found, and can find it again.
+ * The document holds the copy's features and tears at its own places,
+ * as they were read, and this beside them; `importJsonLd` puts them
+ * onto the axis and `asJsonLd` takes them back, so that within the
+ * library every place along the roll is a place on the axis.
+ *
+ * What the scale is put down to, the paper or the speed the copy was
+ * cut for, is worked out from all the alignments together (`paperOf`).
+ * Not exported to RDF.
+ */
+export interface Alignment {
+    /**
+     * The copy it was found against, by id: the edition's reference
+     * copy at the time. Left out by alignments recorded before this was.
+     */
+    against?: string;
+    /** Applied before the scale. */
+    shift: Shift;
+    /** Own millimetres to the axis's, applied after the shift. */
+    scale: number;
+    /** How many notes of the copy found their counterpart on the reference copy. */
+    matched?: number;
+    /** How far the counterparts still lie apart, as a root mean square in millimetres of the axis. */
+    residual?: Millimeters;
+    /**
+     * The standard error of the scale: the residual over the spread of
+     * the matched notes along the roll, as for a line of least squares.
+     */
+    scaleError?: number;
+    /** The software that found it, and when. */
+    foundBy?: {
+        /** The name of the method. */
+        software: string;
+        /** Its revision (`ALIGNMENT_METHOD`). */
+        version: string;
+        /**
+         * The day it was found.
+         * @format date
+         */
+        date: Date;
+    };
+}
 /** The margins on the treble and bass sides of the roll, in the unit the scan was measured in. */
 export interface Margins<U extends 'px' | 'mm'> {
     treble: Quantity<U>;
@@ -64,18 +173,6 @@ export interface Margins<U extends 'px' | 'mm'> {
  * @see crm:E54 Dimension
  */
 export type PaperSpeed = Measure<'ft/min'> | Measure<'m/min'>;
-/**
- * What the scale an alignment found is put down to: the paper of the
- * copy having stretched or shrunk, or the copy having been cut for
- * another paper speed than the roll it is aligned with.
- */
-export type ScaleReading = {
-    cause: 'paper';
-    condition: ObjectAssumption<PaperStretch>;
-} | {
-    cause: 'speed';
-    speed: ObjectAssumption<PaperSpeed>;
-};
 /**
  * Describes the production of a roll copy: the manufacturer,
  * the paper used, the date, and the system and paper speed the
@@ -114,8 +211,10 @@ export interface ProductionEvent {
     /**
      * The paper speed the copy was cut for. A copy cut from the same
      * master for another speed comes out longer or shorter than the
-     * roll it is aligned with by the ratio of the speeds, which is
-     * what the alignment then measures.
+     * roll it is aligned with by the ratio of the speeds. The alignment
+     * measures that ratio far more closely than a label states a speed,
+     * so the speed is held against what the alignments give
+     * (`alignmentProblems`) rather than used to find it.
      * @see reo:paperSpeed
      */
     speed?: ObjectAssumption<PaperSpeed>;
@@ -209,8 +308,8 @@ export type Modification = Partial<{
 export interface RollCopy extends WithType<'RollCopy'>, WithId {
     /**
      * Physical measurements of this roll copy, including
-     * dimensions, hole separation, margins, shift corrections,
-     * and information about the measuring software. What the
+     * dimensions, hole separation, margins, the alignment onto the
+     * edition's axis, and information about the measuring software. What the
      * perforations tell about the machine that cut them is stated
      * with the production.
      * @see crm:P39i was measured by
@@ -252,17 +351,12 @@ export interface RollCopy extends WithType<'RollCopy'>, WithId {
          */
         margins: Margins<'px'> | Margins<'mm'>;
         /**
-         * The shift applied to align this copy with the others.
+         * How the copy's places are carried onto the edition's axis.
+         * Left out for the reference copy, whose places are the axis,
+         * and for a copy not aligned yet.
          * Not exported to RDF.
          */
-        shift: Shift;
-        /**
-         * The factor this copy's features were scaled by to align them
-         * with the others. What it is put down to is stated apart: a
-         * paper-stretch condition, or the speed the copy was cut for.
-         * Not exported to RDF.
-         */
-        scale: number;
+        alignment: Alignment;
         /**
          * What a pneumatic reader added to this copy's chains of holes,
          * where it was taken off again. Such a reader reports how long a
@@ -332,7 +426,7 @@ export interface RollCopy extends WithType<'RollCopy'>, WithId {
     production?: ProductionEvent;
     /**
      * Condition assessments of this roll copy (e.g. paper stretch,
-     * general wear). Each condition is an assumption annotatable
+     * general wear, a tear). Each condition is an assumption annotatable
      * with a belief.
      * @see crm:P44 has condition
      */
@@ -402,12 +496,14 @@ export declare const statesNothing: (modification: Modification) => boolean;
 export declare const featuresByAct: (copy: Pick<RollCopy, 'production' | 'modifications'>) => FeatureOrPatch[][];
 /** Every feature the copy states at a place of its own, whichever act made it. */
 export declare const featuresOf: (copy: Pick<RollCopy, 'production' | 'modifications'>) => FeatureOrPatch[];
-/**
- * Whether the condition is the stretch or shrinkage of the paper. A
- * scale put down to this belongs to the one exemplar and says nothing
- * about the speed its system's rolls were cut at.
- */
-export declare const isPaperStretch: (condition: RollConditionAssignment) => boolean;
+/** Whether the condition is the stretch or shrinkage of the paper, as measured on the copy. */
+export declare const isPaperStretch: (condition: RollConditionAssignment) => condition is ObjectAssumption<PaperStretch>;
+/** What the copy's paper was measured to have done, where anything was measured. */
+export declare const paperStretchOf: (copy: Pick<RollCopy, 'conditions'>) => ObjectAssumption<PaperStretch> | undefined;
+/** Whether the condition is a tear in the paper. */
+export declare const isTear: (condition: RollConditionAssignment) => condition is ObjectAssumption<Tear>;
+/** The tears the copy is stated to have. */
+export declare const tearsOf: (copy: Pick<RollCopy, 'conditions'>) => ObjectAssumption<Tear>[];
 /**
  * The bar a copy is read by, which is the one it was cut for. A copy
  * that names no system falls back to `defaultTrackerBar`.

package/lib/model/RollCopy.js

@@ -4,7 +4,8 @@ import { assignReference, certaintyOf, isAsserted } from "./Assumption.js";
 import { px, track } from "./Quantity.js";
 export const rollConditions = [
     'general',
-    'paper-stretch'
+    'paper-stretch',
+    'torn'
 ];
 export const modificationPurposes = [
     'musical-improvement',
@@ -34,12 +35,14 @@ export const statesNothing = (modification) => modification.type === 'Removal' ?
 export const featuresByAct = (copy) => [copy.production?.produced ?? [], ...copy.modifications.map(featuresMadeBy)];
 /** Every feature the copy states at a place of its own, whichever act made it. */
 export const featuresOf = (copy) => featuresByAct(copy).flat();
-/**
- * Whether the condition is the stretch or shrinkage of the paper. A
- * scale put down to this belongs to the one exemplar and says nothing
- * about the speed its system's rolls were cut at.
- */
+/** Whether the condition is the stretch or shrinkage of the paper, as measured on the copy. */
 export const isPaperStretch = (condition) => condition.conditionType === 'paper-stretch';
+/** What the copy's paper was measured to have done, where anything was measured. */
+export const paperStretchOf = (copy) => copy.conditions.find(isPaperStretch);
+/** Whether the condition is a tear in the paper. */
+export const isTear = (condition) => condition.conditionType === 'torn';
+/** The tears the copy is stated to have. */
+export const tearsOf = (copy) => copy.conditions.filter(isTear);
 /**
  * The bar a copy is read by, which is the one it was cut for. A copy
  * that names no system falls back to `defaultTrackerBar`.

package/lib/model/Version.d.ts

@@ -93,7 +93,13 @@ export interface Version extends WithId {
     basedOn?: Derivation[];
     /**
      * The act that made this version, where it is known: who carried it
-     * out, when, and by what rule.
+     * out, when, and by what rule. The export states the act for every
+     * version, stating nothing of it where nothing is known, so that the
+     * axioms of reo.ttl can place it in time: it started after the
+     * recording and the creation of every version it derives from had
+     * started, and ended no later than the punching of any copy carrying
+     * a symbol it added. A date stated here stands beside those; which of
+     * them bounds the act closest is for a query to pick.
      * @see lrmoo:R17i was created by
      */
     creation?: VersionCreation;

package/lib/ops/beliefs.d.ts

@@ -1,4 +1,4 @@
-import { Path } from "../view/EditionView.js";
+import { Path } from "../lookup/paths.js";
 import { AnyArgumentation, Certainty } from "../model/Assumption.js";
 import { EditionOp } from "./draft.js";
 /** Annotates the assumption at the path with a belief held true, for reasons to be added. */

package/lib/ops/beliefs.js

@@ -1,5 +1,5 @@
 import { v4 } from "uuid";
-import { getAt } from "../view/EditionView.js";
+import { getAt } from "../lookup/paths.js";
 const onAssumptionAt = (path, op) => draft => {
     const assumption = getAt(path, draft);
     if (assumption)

package/lib/ops/collation.d.ts

@@ -1,4 +1,3 @@
-import { EditionView } from "../view/EditionView.js";
 import { CollationTolerance } from "../collation/Collation.js";
 import { ObjectAssumption } from "../model/Assumption.js";
 import { EditionOp } from "./draft.js";
@@ -28,13 +27,13 @@ import { EditionOp } from "./draft.js";
  * statement, since the stemma would loop; asked for that, nothing
  * changes.
  */
-export declare const connectVersions: (given: EditionView, childId: string, parentId: string, tolerance?: ObjectAssumption<CollationTolerance>) => EditionOp;
+export declare const connectVersions: (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: (given: EditionView, versionId: string, symbolIds: readonly string[], tolerance?: CollationTolerance) => EditionOp;
+export declare const collateSymbols: (versionId: string, symbolIds: readonly string[], tolerance?: CollationTolerance) => EditionOp;
 /**
  * Takes the named copies' reading of a symbol back out of the symbol it
  * was collated into: their carriers pass to a new symbol of the
@@ -59,4 +58,4 @@ export declare const collateSymbols: (given: EditionView, versionId: string, sym
  * keeps its identifier and the edit that speaks for it. Named symbols
  * narrow the act to those; naming none separates the whole reading.
  */
-export declare const separateReadings: (given: EditionView, versionId: string, copies: ReadonlySet<string>, symbolIds?: readonly string[]) => EditionOp;
+export declare const separateReadings: (versionId: string, copies: ReadonlySet<string>, symbolIds?: readonly string[]) => EditionOp;

package/lib/ops/collation.js

@@ -1,5 +1,5 @@
 import { v4 } from "uuid";
-import { getAt } from "../view/EditionView.js";
+import { getAt, pathIn } from "../lookup/paths.js";
 import { collationsOf, defaultCollationTolerance, isCollationsOwn, unchecked } from "../collation/Collation.js";
 import { collationToleranceOf, derivesFrom, editsOf, insertedBy, principalDerivationOf } from "../model/Version.js";
 import { substitutionsBetween } from "../collation/substitution.js";
@@ -7,9 +7,11 @@ import { trackerBarOf } from "../systems/index.js";
 import { assignReference, idOf } from "../model/Assumption.js";
 import { noChange, onVersion, stateOf, insertion, deletion, asUnchecked, declaring, insertedIn, dropInsertions, reading } from "./draft.js";
 import { hypothesesBeside } from "./versions.js";
+import { placeOf, snapshotOf } from "../analysis/text.js";
+import { copyOfFeature, versionIn } from "../lookup/lookup.js";
 /** The carriers of each collated symbol pass to its counterpart. */
-const handOverCarriers = (view, draft, collations) => collations.forEach(({ symbol, counterpart }) => {
-    const path = view.getPath(counterpart.id);
+const handOverCarriers = (edition, draft, collations) => collations.forEach(({ symbol, counterpart }) => {
+    const path = pathIn(edition, counterpart.id);
     const target = path && getAt(path, draft);
     target?.carriers.push(...symbol.carriers);
 });
@@ -59,10 +61,10 @@ const byExchange = (edits) => new Map(edits.map(edit => [exchangeKey((edit.inser
  * statement, since the stemma would loop; asked for that, nothing
  * changes.
  */
-export const connectVersions = (given, childId, parentId, tolerance = defaultCollationTolerance) => reading(given, view => {
-    if (childId === parentId || derivesFrom(view.edition.versions, parentId, childId))
+export const connectVersions = (childId, parentId, tolerance = defaultCollationTolerance) => reading(edition => {
+    if (childId === parentId || derivesFrom(edition.versions, parentId, childId))
         return noChange;
-    const child = view.version(childId);
+    const child = versionIn(edition, childId);
     const stated = child ? editsOf(child) : [];
     const established = stated.filter(edit => !isCollationsOwn(edit));
     const spokenFor = spokenForBy(established);
@@ -71,12 +73,12 @@ export const connectVersions = (given, childId, parentId, tolerance = defaultCol
     // 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 handedDown = snapshotOf(edition, parentId).filter(unspoken);
+    const shown = new Set(snapshotOf(edition, 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 own = snapshotOf(edition, childId).filter(symbol => unspoken(symbol) && !inheritedIds.has(symbol.id));
+    const locate = (symbol) => placeOf(edition, symbol);
     const collations = collationsOf(own, inherited, locate, tolerance);
     const collated = new Set(collations.map(({ symbol }) => symbol.id));
     const matched = new Set(collations.map(({ counterpart }) => counterpart.id));
@@ -87,7 +89,7 @@ export const connectVersions = (given, childId, parentId, tolerance = defaultCol
      * apart would make the apparatus a list of unexplained losses beside
      * a list of unexplained gains.
      */
-    const substituted = differ(child, view.version(parentId))
+    const substituted = differ(child, versionIn(edition, 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)));
@@ -113,7 +115,7 @@ export const connectVersions = (given, childId, parentId, tolerance = defaultCol
             .map(symbol => asUnchecked(deletion(symbol.id)))
     ];
     return onVersion(childId, (child, draft) => {
-        handOverCarriers(view, draft, collations);
+        handOverCarriers(edition, draft, collations);
         child.edits = edits;
         child.motivations = declaring(stateOf(child).motivations, edits);
         child.basedOn = [
@@ -127,17 +129,17 @@ export const connectVersions = (given, childId, parentId, tolerance = defaultCol
  * with: the carriers pass over, and the insertions go. Collates at the
  * tolerance of the derivation, where the caller names none.
  */
-export const collateSymbols = (given, versionId, symbolIds, tolerance) => reading(given, view => {
-    const version = view.version(versionId);
+export const collateSymbols = (versionId, symbolIds, tolerance) => reading(edition => {
+    const version = versionIn(edition, versionId);
     const principal = version && principalDerivationOf(version);
     if (!version || !principal)
         return noChange;
     const chosen = new Set(symbolIds);
     const own = insertedIn([version]).filter(symbol => chosen.has(symbol.id));
-    const collations = collationsOf(own, view.snapshot(idOf(principal)), symbol => view.placeOf(symbol), tolerance ?? collationToleranceOf(principal));
+    const collations = collationsOf(own, snapshotOf(edition, idOf(principal)), symbol => placeOf(edition, symbol), tolerance ?? collationToleranceOf(principal));
     const collated = new Set(collations.map(({ symbol }) => symbol.id));
     return onVersion(versionId, (version, draft) => {
-        handOverCarriers(view, draft, collations);
+        handOverCarriers(edition, draft, collations);
         dropInsertions(version, collated);
     });
 });
@@ -163,9 +165,9 @@ const readingOf = (symbol, carriers) => {
  * where the two versions do not disagree and there is nothing to take
  * apart.
  */
-const sharedWith = (view, symbol, copies) => {
+const sharedWith = (edition, symbol, copies) => {
     const onNamedCopy = (carrier) => {
-        const copy = view.copyOf(idOf(carrier));
+        const copy = copyOfFeature(edition, idOf(carrier));
         return copy !== undefined && copies.has(copy.id);
     };
     const mine = symbol.carriers.filter(onNamedCopy);
@@ -196,14 +198,14 @@ const sharedWith = (view, symbol, copies) => {
  * keeps its identifier and the edit that speaks for it. Named symbols
  * narrow the act to those; naming none separates the whole reading.
  */
-export const separateReadings = (given, versionId, copies, symbolIds) => reading(given, view => {
-    const version = view.version(versionId);
+export const separateReadings = (versionId, copies, symbolIds) => reading(edition => {
+    const version = versionIn(edition, versionId);
     if (!version)
         return noChange;
     const chosen = symbolIds && new Set(symbolIds);
-    const shared = view.snapshot(versionId)
+    const shared = snapshotOf(edition, versionId)
         .filter(symbol => chosen === undefined || chosen.has(symbol.id))
-        .flatMap(symbol => sharedWith(view, symbol, copies));
+        .flatMap(symbol => sharedWith(edition, symbol, copies));
     if (shared.length === 0)
         return noChange;
     const inserted = new Set(insertedBy(version).map(symbol => symbol.id));
@@ -218,7 +220,7 @@ export const separateReadings = (given, versionId, copies, symbolIds) => reading
     }));
     return onVersion(versionId, (version, draft) => {
         shared.forEach(({ symbol, theirs }) => {
-            const path = view.getPath(symbol.id);
+            const path = pathIn(edition, symbol.id);
             const target = path && getAt(path, draft);
             if (target)
                 target.carriers = theirs;

package/lib/ops/commands.d.ts

@@ -1,9 +1,8 @@
-import { EditionView } from "../view/EditionView.js";
 import { PlacementRelation } from "../model/Symbol.js";
 import { EditionOp } from "./draft.js";
 /** States how the follower is placed relative to the reference, in place of any earlier statement. */
-export declare const placeCommand: (view: EditionView, followerId: string, referenceId: string, relation: PlacementRelation) => EditionOp;
-export declare const unplaceCommand: (view: EditionView, followerId: string) => EditionOp;
+export declare const placeCommand: (followerId: string, referenceId: string, relation: PlacementRelation) => EditionOp;
+export declare const unplaceCommand: (followerId: string) => EditionOp;
 /** The pair is stated on `statingId` only, as the format asks. */
-export declare const pairCommands: (view: EditionView, statingId: string, partnerId: string) => EditionOp;
-export declare const unpairCommand: (view: EditionView, statingId: string) => EditionOp;
+export declare const pairCommands: (statingId: string, partnerId: string) => EditionOp;
+export declare const unpairCommand: (statingId: string) => EditionOp;

package/lib/ops/commands.js

@@ -1,29 +1,29 @@
-import { getAt } from "../view/EditionView.js";
+import { getAt, pathIn } from "../lookup/paths.js";
 import { isCommand, placementRelations } from "../model/Symbol.js";
 import { assignReference } from "../model/Assumption.js";
 import { reading } from "./draft.js";
 /**
- * Runs the change on the command the view locates by id, in whichever
- * version inserted it. A statement made there holds in every version
- * that carries the command.
+ * Runs the change on the command with the id, in whichever version
+ * inserted it. A statement made there holds in every version that
+ * carries the command.
  */
-const onCommand = (view, id, op) => reading(view, fresh => draft => {
-    const path = fresh.getPath(id);
+const onCommand = (id, op) => reading(edition => draft => {
+    const path = pathIn(edition, id);
     const symbol = path && getAt(path, draft);
     if (isCommand(symbol))
         op(symbol);
 });
 const clearPlacement = (command) => placementRelations.forEach(relation => { delete command[relation]; });
 /** States how the follower is placed relative to the reference, in place of any earlier statement. */
-export const placeCommand = (view, followerId, referenceId, relation) => onCommand(view, followerId, command => {
+export const placeCommand = (followerId, referenceId, relation) => onCommand(followerId, command => {
     clearPlacement(command);
     command[relation] = assignReference(referenceId);
 });
-export const unplaceCommand = (view, followerId) => onCommand(view, followerId, clearPlacement);
+export const unplaceCommand = (followerId) => onCommand(followerId, clearPlacement);
 /** The pair is stated on `statingId` only, as the format asks. */
-export const pairCommands = (view, statingId, partnerId) => onCommand(view, statingId, command => {
+export const pairCommands = (statingId, partnerId) => onCommand(statingId, command => {
     command.pairedWith = assignReference(partnerId);
 });
-export const unpairCommand = (view, statingId) => onCommand(view, statingId, command => {
+export const unpairCommand = (statingId) => onCommand(statingId, command => {
     delete command.pairedWith;
 });

package/lib/ops/copies.d.ts

@@ -2,7 +2,7 @@
 import { Draft } from "immer";
 import { Edition } from "../model/Edition.js";
 import { AnySymbol } from "../model/Symbol.js";
-import { GeneralRollCondition, RollCopy, ScaleReading, Shift } from "../model/RollCopy.js";
+import { Alignment, GeneralRollCondition, PaperStretch, RollCopy, Tear } from "../model/RollCopy.js";
 import { FeatureSource } from "../model/FeatureSource.js";
 import { Belief, ObjectAssumption, ReferenceAssumption } from "../model/Assumption.js";
 import { Millimeters } from "../model/Quantity.js";
@@ -21,15 +21,38 @@ export declare const createVersion: (copy: RollCopy) => EditionOp;
  */
 export declare const addCopy: (copy: RollCopy) => EditionOp;
 /**
- * Shifts and then scales the copy's features into line with another
- * copy's, and puts the scale down to what the reading says: the paper,
- * or the speed the copy was cut for.
+ * What aligning the copy with the reference copy finds, or nothing
+ * where the two share no run of notes, where there is no reference
+ * copy, or where the copy is the reference itself. The copy is read at
+ * its own places whatever alignment it has, and through its own bar,
+ * which is what lets a copy cut for another system be aligned at all.
  */
-export declare const alignCopy: (copyId: string, shift: Shift, scale: number, reading?: ScaleReading) => EditionOp;
+export declare const alignmentFor: (edition: Edition, copy: RollCopy, date?: Date) => Alignment | undefined;
 /**
- * Puts the copy's features back where they were measured. A paper
- * stretch read off the alignment goes with it; a speed stated stays,
- * being a fact about the copy.
+ * Aligns the copy with the edition's reference copy: finds the shift
+ * and scale that carry its notes onto the reference copy's, and puts
+ * its features and tears onto the axis by them, in place of any
+ * alignment it had. A copy that shares no run of notes with the
+ * reference copy is left as it was.
+ */
+export declare const alignCopy: (copyId: string, date?: Date) => EditionOp;
+/**
+ * Aligns every copy that has features with the reference copy, as
+ * `alignCopy` does one. The reference copy itself is taken off any
+ * alignment it had, its places being the axis.
+ */
+export declare const alignCopies: (date?: Date) => EditionOp;
+/**
+ * Makes the copy the one whose millimetres are the edition's axis, and
+ * aligns every other copy onto it. Every place the edition gives along
+ * the roll moves with this, which is why it is a choice and not
+ * something worked out.
+ */
+export declare const chooseReferenceCopy: (copyId: string, date?: Date) => EditionOp;
+/**
+ * Puts the copy's features back where they were measured, off the
+ * axis. What the alignments say about the paper goes with it, since
+ * that is worked out from them.
  */
 export declare const unalignCopy: (copyId: string) => EditionOp;
 /**
@@ -60,10 +83,24 @@ export declare const stateCarriage: (copyId: string, versionId: string, belief?:
 export declare const clearCarriage: (copyId: string, versionId: string) => EditionOp;
 /**
  * Adds a general condition to the copy, beside whatever is stated of it
- * already. The other condition a copy may be in, a paper stretch, is
- * read off an alignment and stated by `alignCopy`.
+ * already. A paper stretch is added the same way, where one was
+ * measured; what the alignments say of the paper is worked out from
+ * them and stated nowhere.
  */
 export declare const addGeneralCondition: (copyId: string, condition: ObjectAssumption<GeneralRollCondition>) => EditionOp;
+/**
+ * States what the copy's paper was measured to have done, in place of
+ * what was stated before; given nothing, it takes the statement away. A
+ * copy has one paper, so it has one such condition, which may give a
+ * strain in either direction.
+ */
+export declare const statePaperStretch: (copyId: string, stretch?: ObjectAssumption<PaperStretch>) => EditionOp;
+/**
+ * Adds a tear to the copy, beside whatever is stated of it already. The
+ * tear is given on the axis, where the copy's features stand, and moves
+ * with them from then on.
+ */
+export declare const addTear: (copyId: string, tear: ObjectAssumption<Tear>) => EditionOp;
 /** The symbols of the versions that no other copy carries. */
 export declare const symbolsCarriedOnlyBy: (edition: Edition, copyId: string) => AnySymbol[];
 /**