linked-rolls 0.62.0 → 0.63.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/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[];
 /**

package/lib/ops/copies.js

@@ -1,8 +1,10 @@
 import { v4 } from "uuid";
+import { referenceCopyOf } from "../model/Edition.js";
 import { asSymbols, barOf, featuresOf, isPaperStretch } from "../model/RollCopy.js";
 import { systemOf } from "../systems/TrackerBar.js";
-import { applyShift, applyScale, revertShift, revertScale, revertShortening, shortenChains } from "../collation/alignment.js";
+import { alignFeatures, ALIGNMENT_METHOD, applyAlignment, ownFeaturesOf, revertAlignment, revertShortening, shortenChains } from "../collation/alignment.js";
 import { idOf } from "../model/Assumption.js";
+import { track } from "../model/Quantity.js";
 import { onCopy, stateOf, insertion, insertedIn, referenceHeld, withoutReferences } from "./draft.js";
 import { without } from "./immutable.js";
 import { featureIdsOf, carriedOnlyOn, forgetFeatures } from "./forget.js";
@@ -30,36 +32,80 @@ export const createVersion = (copy) => draft => {
 export const addCopy = (copy) => draft => {
     draft.copies.push(copy);
 };
-/** States what the scale is put down to, in place of an earlier reading. */
-const readScale = (copy, reading) => {
-    if (reading.cause === 'paper') {
-        copy.conditions = [...copy.conditions.filter(condition => !isPaperStretch(condition)), reading.condition];
+/**
+ * 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 const alignmentFor = (edition, copy, date = new Date()) => {
+    const reference = referenceCopyOf(edition);
+    if (!reference || reference.id === copy.id)
+        return undefined;
+    const found = alignFeatures(ownFeaturesOf(copy), featuresOf(reference), barOf(copy), barOf(reference));
+    if (!found)
+        return undefined;
+    return {
+        against: reference.id,
+        shift: { horizontal: found.shift, vertical: track(0) },
+        scale: found.scale,
+        matched: found.matched,
+        residual: found.residual,
+        scaleError: found.scaleError,
+        foundBy: { ...ALIGNMENT_METHOD, date }
+    };
+};
+/**
+ * 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 const alignCopy = (copyId, date = new Date()) => draft => {
+    const state = stateOf(draft);
+    const copy = state.copies.find(c => c.id === copyId);
+    const alignment = copy && alignmentFor(state, copy, date);
+    const target = draft.copies.find(c => c.id === copyId);
+    if (alignment && target)
+        applyAlignment(alignment, target);
+};
+/**
+ * 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 const alignCopies = (date = new Date()) => draft => {
+    const reference = referenceCopyOf(stateOf(draft));
+    if (!reference)
         return;
-    }
-    if (!copy.production)
-        copy.production = {};
-    copy.production.speed = reading.speed;
+    const own = draft.copies.find(c => c.id === reference.id);
+    if (own)
+        revertAlignment(own);
+    stateOf(draft).copies
+        .filter(copy => copy.id !== reference.id && featuresOf(copy).length > 0)
+        .forEach(copy => alignCopy(copy.id, date)(draft));
 };
 /**
- * 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.
+ * 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 const alignCopy = (copyId, shift, scale, reading) => onCopy(copyId, copy => {
-    applyShift(shift, copy);
-    applyScale(scale, copy);
-    if (reading)
-        readScale(copy, reading);
-});
+export const chooseReferenceCopy = (copyId, date = new Date()) => draft => {
+    if (!draft.copies.some(copy => copy.id === copyId))
+        return;
+    draft.referenceCopy = copyId;
+    alignCopies(date)(draft);
+};
 /**
- * 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.
+ * 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 const unalignCopy = (copyId) => onCopy(copyId, copy => {
-    revertScale(copy);
-    revertShift(copy);
-    copy.conditions = without(copy.conditions, isPaperStretch);
+    revertAlignment(copy);
 });
 /**
  * Takes the extension a pneumatic reader adds off the ends of the
@@ -113,12 +159,30 @@ export const stateCarriage = (copyId, versionId, belief) => onCopy(copyId, copy
 export const clearCarriage = (copyId, versionId) => onCopy(copyId, copy => dropStatements(copy, statement => idOf(statement) === versionId));
 /**
  * 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 const addGeneralCondition = (copyId, condition) => onCopy(copyId, copy => {
     copy.conditions.push(condition);
 });
+/**
+ * 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 const statePaperStretch = (copyId, stretch) => onCopy(copyId, copy => {
+    copy.conditions = [...without(copy.conditions, isPaperStretch), ...(stretch ? [stretch] : [])];
+});
+/**
+ * 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 const addTear = (copyId, tear) => onCopy(copyId, copy => {
+    copy.conditions.push(tear);
+});
 /** The symbols of the versions that no other copy carries. */
 export const symbolsCarriedOnlyBy = (edition, copyId) => {
     const copy = edition.copies.find(c => c.id === copyId);
@@ -132,4 +196,6 @@ export const symbolsCarriedOnlyBy = (edition, copyId) => {
 export const removeCopy = (copyId) => onCopy(copyId, (copy, draft) => {
     forgetFeatures(draft, featureIdsOf(copy));
     draft.copies = draft.copies.filter(c => c.id !== copyId);
+    if (draft.referenceCopy === copyId)
+        delete draft.referenceCopy;
 });

package/lib/ops/index.d.ts

@@ -4,7 +4,7 @@
  * the ones the library offers.
  */
 export type { EditionOp } from "./draft.js";
-export { createVersion, addCopy, alignCopy, unalignCopy, shortenCopy, unshortenCopy, stateSource, clearSource, nameCopy, stateCarriage, clearCarriage, addGeneralCondition, symbolsCarriedOnlyBy, removeCopy } from "./copies.js";
+export { createVersion, addCopy, alignmentFor, alignCopy, alignCopies, chooseReferenceCopy, unalignCopy, shortenCopy, unshortenCopy, stateSource, clearSource, nameCopy, stateCarriage, clearCarriage, addGeneralCondition, statePaperStretch, addTear, symbolsCarriedOnlyBy, removeCopy } from "./copies.js";
 export { stateFeatureCondition, addFeature, addBorneFeature, removeFeatures, mergeObstacle, mergeObstacleIn, mergeFeatures, type FeatureAct, type MergeObstacle } from "./features.js";
 export { detachVersion, removeVersion, removeSymbols, deriveVersion, stateDerivation, clearDerivation } from "./versions.js";
 export { connectVersions, collateSymbols, separateReadings } from "./collation.js";

package/lib/ops/index.js

@@ -1,4 +1,4 @@
-export { createVersion, addCopy, alignCopy, unalignCopy, shortenCopy, unshortenCopy, stateSource, clearSource, nameCopy, stateCarriage, clearCarriage, addGeneralCondition, symbolsCarriedOnlyBy, removeCopy } from "./copies.js";
+export { createVersion, addCopy, alignmentFor, alignCopy, alignCopies, chooseReferenceCopy, unalignCopy, shortenCopy, unshortenCopy, stateSource, clearSource, nameCopy, stateCarriage, clearCarriage, addGeneralCondition, statePaperStretch, addTear, symbolsCarriedOnlyBy, removeCopy } from "./copies.js";
 export { stateFeatureCondition, addFeature, addBorneFeature, removeFeatures, mergeObstacle, mergeObstacleIn, mergeFeatures } from "./features.js";
 export { detachVersion, removeVersion, removeSymbols, deriveVersion, stateDerivation, clearDerivation } from "./versions.js";
 export { connectVersions, collateSymbols, separateReadings } from "./collation.js";

package/lib/readers/stanfordAton.js

@@ -96,6 +96,33 @@ const stanfordScan = (druid) => ({
     scan: `https://stacks.stanford.edu/image/iiif/${druid}%2F${druid}_0001/`,
     depictionOf: (column, row, width, height) => `https://stacks.stanford.edu/image/iiif/${druid}/${druid}_0001/${column},${row},${width},${height}/128,/270/default.jpg`
 });
+/**
+ * The edge tears the analysis found, one condition each. The analysis
+ * lists only those that reach deeper into the paper than a tenth of an
+ * inch, and measures each by the box around it, so the tear runs across
+ * the roll as far as the box is wide.
+ */
+const tearsIn = (tears, dpi, depictionOf) => {
+    const onEdge = (edge, listed) => listOf(listed).map((tear) => {
+        const row = readPx(tear.ORIGIN_ROW);
+        const length = readPx(tear.WIDTH_ROW);
+        const column = readPx(tear.ORIGIN_COL);
+        const depth = readPx(tear.WIDTH_COL);
+        return {
+            conditionType: 'torn',
+            horizontal: {
+                unit: 'mm',
+                from: inMillimeters(row, dpi),
+                to: inMillimeters(px(row + length), dpi)
+            },
+            edge,
+            depth: { value: inMillimeters(depth, dpi), unit: 'mm' },
+            ...(depictionOf && { depiction: depictionOf(column, row, depth, length) })
+        };
+    });
+    return [...onEdge('bass', tears?.BASS_TEARS?.TEAR), ...onEdge('treble', tears?.TREBLE_TEARS?.TEAR)]
+        .sort((a, b) => a.horizontal.from - b.horizontal.from);
+};
 /**
  * The software behind an analysis and when it was run, as the
  * analysis file states them.
@@ -155,7 +182,7 @@ export function readFromStanfordAton(atonString, { trackShift, system = welteT10
     return {
         type: 'RollCopy',
         id: v4(),
-        conditions: [],
+        conditions: tearsIn(json.ROLLINFO.TEARS, dpi, stanford?.depictionOf),
         production: {
             system: systemOf(system),
             ...(punchDiameter !== undefined && {