linked-rolls 0.62.0 → 0.64.0

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/draft.d.ts

@@ -1,4 +1,3 @@
-import { EditionView } from "../view/EditionView.js";
 /** What the operations are built from: the type of an operation, how one finds what it writes to on the draft, and the edits it writes. */
 import { Draft } from "immer";
 import { Edition } from "../model/Edition.js";
@@ -12,10 +11,10 @@ import { WithId } from "../shared/utils.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
- * edition first takes an `EditionView` of the state it will be
- * applied to and does all its writing in the one function it returns.
- * Where operations run one after another on one draft, the ones after
- * the first read a view of the draft as it then stands (`reading`).
+ * edition reads it as the draft stands when the operation is applied
+ * (`reading`) and does all its writing in the one function it builds
+ * from that. Where operations run one after another on one draft, each
+ * reads what the ones before it wrote.
  */
 export type EditionOp = (draft: Draft<Edition>) => void;
 export declare const noChange: EditionOp;
@@ -23,16 +22,17 @@ export declare const onCopy: (copyId: string, op: (copy: Draft<RollCopy>, draft:
 export declare const onVersion: (versionId: string, op: (version: Draft<Version>, draft: Draft<Edition>) => void) => EditionOp;
 export declare const onFeature: (copyId: string, featureId: string, op: (feature: Draft<FeatureOrPatch>) => void) => EditionOp;
 /**
- * The operation built from a view of the state it is applied to. The
- * view given is used where the draft still stands as the view saw it,
- * and a fresh one is taken of the draft where an operation run before
- * on the same draft has changed it: a path or an index read off the
- * view would otherwise name what stood there before.
+ * The operation built from the state it is applied to: the draft as it
+ * stands, an operation run before on the same draft included. A path
+ * or an index read off an earlier state would name what stood there
+ * before. What is worked out from a state is kept with it, so a draft
+ * nothing has changed yet is read from what is known already.
  */
-export declare const reading: (view: EditionView, build: (view: EditionView) => EditionOp) => EditionOp;
+export declare const reading: (build: (edition: Edition) => EditionOp) => EditionOp;
 /**
  * The state a draft stands at, as plain data. Reading a draft proxies
- * everything it touches, so what is only read is read from this.
+ * everything it touches, so what is only read is read from this, and
+ * what is looked up in an edition is looked up in this (`takenOf`).
  */
 export declare const stateOf: <T>(draft: Draft<T>) => T;
 /** The ids of the items the rewriting left out. */

package/lib/ops/draft.js

@@ -1,12 +1,12 @@
-import { EditionView } from "../view/EditionView.js";
 /** What the operations are built from: the type of an operation, how one finds what it writes to on the draft, and the edits it writes. */
-import { current, isDraft } from "immer";
+import { isDraft } from "immer";
 import { v4 } from "uuid";
 import { unchecked, uncheckedMotivation } from "../collation/Collation.js";
 import { insertedBy } from "../model/Version.js";
 import { featuresOf } from "../model/RollCopy.js";
 import { assignReference } from "../model/Assumption.js";
 import { without, pruned } from "./immutable.js";
+import { takenOf } from "../lookup/perState.js";
 export const noChange = () => undefined;
 export const onCopy = (copyId, op) => draft => {
     const copy = draft.copies.find(c => c.id === copyId);
@@ -24,21 +24,19 @@ export const onFeature = (copyId, featureId, op) => onCopy(copyId, copy => {
         op(feature);
 });
 /**
- * The operation built from a view of the state it is applied to. The
- * view given is used where the draft still stands as the view saw it,
- * and a fresh one is taken of the draft where an operation run before
- * on the same draft has changed it: a path or an index read off the
- * view would otherwise name what stood there before.
+ * The operation built from the state it is applied to: the draft as it
+ * stands, an operation run before on the same draft included. A path
+ * or an index read off an earlier state would name what stood there
+ * before. What is worked out from a state is kept with it, so a draft
+ * nothing has changed yet is read from what is known already.
  */
-export const reading = (view, build) => draft => {
-    const state = stateOf(draft);
-    build(state === view.edition ? view : new EditionView(state))(draft);
-};
+export const reading = (build) => draft => build(stateOf(draft))(draft);
 /**
  * The state a draft stands at, as plain data. Reading a draft proxies
- * everything it touches, so what is only read is read from this.
+ * everything it touches, so what is only read is read from this, and
+ * what is looked up in an edition is looked up in this (`takenOf`).
  */
-export const stateOf = (draft) => isDraft(draft) ? current(draft) : draft;
+export const stateOf = (draft) => isDraft(draft) ? takenOf(draft) : draft;
 /** The ids of the items the rewriting left out. */
 export const droppedIds = (before, after) => {
     const kept = new Set(after.map(item => item.id));

package/lib/ops/edits.d.ts

@@ -1,10 +1,9 @@
-import { EditionView } from "../view/EditionView.js";
 import { Edit } from "../model/Edit.js";
 import { EditionOp } from "./draft.js";
 /**
  * Replaces the edits with a single one carrying all their insertions
  * and deletions, classified by a guess at what the exchange does.
  */
-export declare const mergeEdits: (given: EditionView, versionId: string, toMerge: readonly Edit[]) => EditionOp;
+export declare const mergeEdits: (versionId: string, toMerge: readonly Edit[]) => EditionOp;
 /** Replaces the edit with one edit per inserted and one per deleted symbol. */
 export declare const splitEdit: (versionId: string, toSplit: Edit) => EditionOp;

package/lib/ops/edits.js

@@ -4,6 +4,9 @@ import { editsOf } from "../model/Version.js";
 import { trackerBarOf } from "../systems/index.js";
 import { distance, mm, subtract } from "../model/Quantity.js";
 import { noChange, onVersion, insertion, deletion, reading } from "./draft.js";
+import { predecessorOf } from "../analysis/stemma.js";
+import { placeOf } from "../analysis/text.js";
+import { symbolsIn, versionIn } from "../lookup/lookup.js";
 const sameSequence = (a, b) => a.length === b.length && a.every((value, i) => value === b[i]);
 const expressionTypesOf = (symbols) => symbols.filter((symbol) => symbol.type === 'expression').map(symbol => symbol.expressionType);
 /** The spellings of a single added accent the bar offers, none where no bar is known. */
@@ -12,9 +15,9 @@ const lengthOf = (span) => subtract(span.to, span.from);
 /** How far apart two onsets may lie for the one symbol to count as a replacement of the other. */
 const REPLACEMENT_TOLERANCE = mm(5);
 /** Shorten or prolong, where the inserted symbol starts about where the deleted one did. */
-const replacementType = (view, inserted, deleted) => {
-    const after = view.placeOf(inserted);
-    const before = view.placeOf(deleted);
+const replacementType = (edition, inserted, deleted) => {
+    const after = placeOf(edition, inserted);
+    const before = placeOf(edition, deleted);
     if (!after || !before || distance(after.from, before.from) >= REPLACEMENT_TOLERANCE)
         return undefined;
     return lengthOf(after) < lengthOf(before) ? 'shorten' : 'prolong';
@@ -23,13 +26,13 @@ const replacementType = (view, inserted, deleted) => {
  * A guess at what an edit does, from the symbols it exchanges and from
  * the systems the version and the one it is based on are coded for.
  */
-const guessEditType = (view, versionId, edit) => {
+const guessEditType = (edition, versionId, edit) => {
     const inserts = edit.insert ?? [];
-    const deletes = view.symbols(edit.delete ?? []);
+    const deletes = symbolsIn(edition, edit.delete ?? []);
     const inserted = expressionTypesOf(inserts);
     const deleted = expressionTypesOf(deletes);
-    const bar = trackerBarOf(view.version(versionId)?.system);
-    const parentBar = trackerBarOf(view.predecessorOf(versionId)?.system);
+    const bar = trackerBarOf(versionIn(edition, versionId)?.system);
+    const parentBar = trackerBarOf(predecessorOf(edition, versionId)?.system);
     /**
      * Where the version is coded for another system than its parent,
      * expression matter changed is the transfer being carried out: a red
@@ -54,14 +57,14 @@ const guessEditType = (view, versionId, edit) => {
     if (inserted.length === 0 && deleted.length === 1)
         return 'remove-redundancy';
     if (inserts.length === 1 && deletes.length === 1)
-        return replacementType(view, inserts[0], deletes[0]) ?? 'correct-error';
+        return replacementType(edition, inserts[0], deletes[0]) ?? 'correct-error';
     return 'correct-error';
 };
 /**
  * Replaces the edits with a single one carrying all their insertions
  * and deletions, classified by a guess at what the exchange does.
  */
-export const mergeEdits = (given, versionId, toMerge) => reading(given, view => {
+export const mergeEdits = (versionId, toMerge) => reading(edition => {
     if (toMerge.length === 0)
         return noChange;
     const merged = {
@@ -70,7 +73,7 @@ export const mergeEdits = (given, versionId, toMerge) => reading(given, view =>
         insert: toMerge.flatMap(edit => edit.insert ?? []),
         delete: toMerge.flatMap(edit => edit.delete ?? [])
     };
-    merged.editType = guessEditType(view, versionId, merged);
+    merged.editType = guessEditType(edition, versionId, merged);
     const mergedIds = new Set(toMerge.map(edit => edit.id));
     return onVersion(versionId, version => {
         version.edits = [...editsOf(version).filter(edit => !mergedIds.has(edit.id)), merged];

package/lib/ops/features.d.ts

@@ -1,4 +1,4 @@
-import { EditionView } from "../view/EditionView.js";
+import { Edition } from "../model/Edition.js";
 import { ModificationPurpose } from "../model/RollCopy.js";
 import { FeatureConditionAssignment, FeatureOrPatch, NestedFeature } from "../model/Feature.js";
 import { EditionOp } from "./draft.js";
@@ -62,7 +62,7 @@ export declare const mergeObstacle: (features: readonly FeatureOrPatch[]) => Mer
  * feature is the work of one act, and where the features stand is the
  * edition's business rather than theirs.
  */
-export declare const mergeObstacleIn: (view: EditionView, featureIds: readonly string[]) => MergeObstacle | undefined;
+export declare const mergeObstacleIn: (edition: Edition, featureIds: readonly string[]) => MergeObstacle | undefined;
 /**
  * Replaces the features of the copy with a single one covering them
  * all, where a scan has split what the editor reads as one feature.

package/lib/ops/features.js

@@ -6,6 +6,7 @@ import { mm } from "../model/Quantity.js";
 import { onCopy, onFeature, stateOf } from "./draft.js";
 import { without, mapped, pruned, replacing, isRecord } from "./immutable.js";
 import { renameReferences, forgetFeatures } from "./forget.js";
+import { copyOfFeature } from "../lookup/lookup.js";
 /**
  * Whether the feature's own kind allows a condition of this kind. The
  * type narrowed to is the weaker statement, holding of a condition any
@@ -209,8 +210,8 @@ const obstacleIn = (copy, featureIds) => {
  * feature is the work of one act, and where the features stand is the
  * edition's business rather than theirs.
  */
-export const mergeObstacleIn = (view, featureIds) => {
-    const copy = featureIds.map(id => view.copyOf(id)).find(copy => copy !== undefined);
+export const mergeObstacleIn = (edition, featureIds) => {
+    const copy = featureIds.map(id => copyOfFeature(edition, id)).find(copy => copy !== undefined);
     return copy ? obstacleIn(copy, featureIds) : 'fewer-than-two';
 };
 /** The items with the replacement in the place of the first it stands for, the others dropped. */

package/lib/ops/index.d.ts

@@ -3,8 +3,8 @@
  * They are grouped by what they change under `ops/`; this module names
  * 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 { stateOf, type EditionOp } from "./draft.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,10 @@
-export { createVersion, addCopy, alignCopy, unalignCopy, shortenCopy, unshortenCopy, stateSource, clearSource, nameCopy, stateCarriage, clearCarriage, addGeneralCondition, symbolsCarriedOnlyBy, removeCopy } from "./copies.js";
+/**
+ * The operations on an edition, each written onto an immer draft of it.
+ * They are grouped by what they change under `ops/`; this module names
+ * the ones the library offers.
+ */
+export { stateOf } from "./draft.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/ops/versions.d.ts

@@ -1,4 +1,3 @@
-import { EditionView } from "../view/EditionView.js";
 import { Derivation, Version } from "../model/Version.js";
 import { Belief } from "../model/Assumption.js";
 import { EditionOp } from "./draft.js";
@@ -9,13 +8,13 @@ export declare const hypothesesBeside: (version: Readonly<Version>, parentId: st
  * own insertions, and its derivations go, the hypotheses among them,
  * with the motivations that belonged to them.
  */
-export declare const detachVersion: (given: EditionView, versionId: string) => EditionOp;
+export declare const detachVersion: (versionId: string) => EditionOp;
 /**
  * Takes the version out. Whatever read its text against it comes to
  * stand on its own, a hypothesis that something derives from it goes,
  * and so does a copy's statement that it carries the version.
  */
-export declare const removeVersion: (given: EditionView, versionId: string) => EditionOp;
+export declare const removeVersion: (versionId: string) => EditionOp;
 /** Takes the symbols out of the version's own insertions, and the edits that had nothing else. */
 export declare const removeSymbols: (versionId: string, symbolIds: readonly string[]) => EditionOp;
 /** Moves the edits into a new version based on this one. */

package/lib/ops/versions.js

@@ -4,6 +4,7 @@ import { assignReference, idOf } from "../model/Assumption.js";
 import { onVersion, stateOf, insertion, dropInsertions, referenceHeld, withoutReferences, reading } from "./draft.js";
 import { without } from "./immutable.js";
 import { dropStatements } from "./copies.js";
+import { snapshotOf } from "../analysis/text.js";
 /** Whether the version's text is read against the parent, its principal derivation naming it. */
 const readsAgainst = (version, parentId) => {
     const principal = principalDerivationOf(version);
@@ -30,8 +31,8 @@ const dropDerivations = (version, matches) => {
  * own insertions, and its derivations go, the hypotheses among them,
  * with the motivations that belonged to them.
  */
-export const detachVersion = (given, versionId) => reading(given, view => {
-    const edits = view.snapshot(versionId).map(insertion);
+export const detachVersion = (versionId) => reading(edition => {
+    const edits = snapshotOf(edition, versionId).map(insertion);
     return onVersion(versionId, version => {
         version.edits = edits;
         delete version.basedOn;
@@ -43,10 +44,10 @@ export const detachVersion = (given, versionId) => reading(given, view => {
  * stand on its own, a hypothesis that something derives from it goes,
  * and so does a copy's statement that it carries the version.
  */
-export const removeVersion = (given, versionId) => reading(given, view => {
-    const detachments = view.edition.versions
+export const removeVersion = (versionId) => reading(edition => {
+    const detachments = edition.versions
         .filter(version => readsAgainst(version, versionId))
-        .map(version => detachVersion(view, version.id));
+        .map(version => detachVersion(version.id));
     const namesIt = (reference) => idOf(reference) === versionId;
     return draft => {
         detachments.forEach(detach => detach(draft));

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 && {