linked-rolls 0.57.0 → 0.59.0

package/lib/{RollCopy.js → model/RollCopy.js}

@@ -1,6 +1,5 @@
 import { v4 } from "uuid";
-import { welteT100 } from "./systems/welteT100/bar.js";
-import { trackerBarOf } from "./systems/index.js";
+import { defaultTrackerBar, trackerBarOf } from "../systems/index.js";
 import { assignReference, certaintyOf, isAsserted } from "./Assumption.js";
 import { px, track } from "./Quantity.js";
 export const rollConditions = [
@@ -43,10 +42,9 @@ export const featuresOf = (copy) => featuresByAct(copy).flat();
 export const isPaperStretch = (condition) => condition.conditionType === 'paper-stretch';
 /**
  * The bar a copy is read by, which is the one it was cut for. A copy
- * that names no system falls back to the T-100, as every copy was read
- * before the systems were told apart; `reservationsAbout` says so.
+ * that names no system falls back to `defaultTrackerBar`.
  */
-export const barOf = (copy) => trackerBarOf(copy.production?.system) ?? welteT100;
+export const barOf = (copy) => trackerBarOf(copy.production?.system) ?? defaultTrackerBar;
 /** The diameter of the punch the copy was cut with, where the edition holds it true or likely. */
 export const punchDiameterOf = (copy) => {
     const diameter = copy.production?.perforator?.condition?.punchDiameter;

package/lib/{Symbol.d.ts → model/Symbol.d.ts}

@@ -1,5 +1,5 @@
 import { ReferenceAssumption } from "./Assumption.js";
-import { WithId } from "./utils.js";
+import { WithId } from "../shared/utils.js";
 /**
  * A symbol is an abstract musical or textual entity carried by one or more
  * physical features on the roll. Symbols are the result of interpreting

package/lib/{Version.d.ts → model/Version.d.ts}

@@ -1,9 +1,9 @@
 import { Edit } from "./Edit.js";
 import { Concept } from "./Agent.js";
 import { ActorAssignment, Belief, Certainty, DateAssignment, ObjectAssumption, ReferenceAssumption } from "./Assumption.js";
-import { CollationTolerance } from "./Collation.js";
+import { CollationTolerance } from "../collation/Collation.js";
 import { AnySymbol } from "./Symbol.js";
-import { WithId, WithNote, WithType } from "./utils.js";
+import { WithId, WithNote, WithType } from "../shared/utils.js";
 /**
  * A motivation provides a reason or rationale for an editorial change.
  * Motivations are defined at the version level and referenced by edits.
@@ -131,3 +131,11 @@ export declare const derivationsOf: (version: Readonly<Version>) => {
  * below another's reads the version's edits against another parent.
  */
 export declare const principalDerivationOf: (version: Readonly<Version>) => Readonly<Derivation> | undefined;
+/**
+ * Whether the version derives from the other, directly or through the
+ * versions between them, by any derivation it states, a hypothesis
+ * among them: a hypothesis held more certain becomes the principal one.
+ * A version derives from itself in no statement, and a stemma that
+ * loops is walked once round.
+ */
+export declare const derivesFrom: (versions: readonly Readonly<Version>[], versionId: string, ancestorId: string) => boolean;

package/lib/{Version.js → model/Version.js}

@@ -1,5 +1,5 @@
 import { certainties, certaintyOf, idOf } from "./Assumption.js";
-import { defaultCollationTolerance } from "./Collation.js";
+import { defaultCollationTolerance } from "../collation/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. */
@@ -26,3 +26,26 @@ const rankOf = (derivation) => certainties.indexOf(certaintyOf(derivation));
 export const principalDerivationOf = (version) => (version.basedOn ?? [])
     .filter(derivation => rankOf(derivation) <= certainties.indexOf('possible'))
     .reduce((principal, derivation) => principal === undefined || rankOf(derivation) < rankOf(principal) ? derivation : principal, undefined);
+/**
+ * Whether the version derives from the other, directly or through the
+ * versions between them, by any derivation it states, a hypothesis
+ * among them: a hypothesis held more certain becomes the principal one.
+ * A version derives from itself in no statement, and a stemma that
+ * loops is walked once round.
+ */
+export const derivesFrom = (versions, versionId, ancestorId) => {
+    const byId = new Map(versions.map(version => [version.id, version]));
+    const seen = new Set();
+    const pending = [versionId];
+    while (pending.length > 0) {
+        const id = pending.pop();
+        if (seen.has(id))
+            continue;
+        seen.add(id);
+        const parents = (byId.get(id)?.basedOn ?? []).map(idOf);
+        if (parents.includes(ancestorId))
+            return true;
+        pending.push(...parents);
+    }
+    return false;
+};

package/lib/{vocabulary.js → model/vocabulary.js}

@@ -1,7 +1,7 @@
 import { drives } from "./Perforator.js";
 import { procedures } from "./procedures.js";
-import { systemOf } from "./TrackerBar.js";
-import { trackerBars } from "./systems/index.js";
+import { systemOf } from "../systems/TrackerBar.js";
+import { trackerBars } from "../systems/index.js";
 /**
  * The concepts the type vocabulary declares, whatever kind they are:
  * the reproducing systems, the procedures and the drives of a

package/lib/ops/beliefs.d.ts

@@ -0,0 +1,9 @@
+import { Path } from "../view/EditionView.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. */
+export declare const createBelief: (path: Path) => EditionOp;
+export declare const clearBelief: (path: Path) => EditionOp;
+export declare const setCertainty: (path: Path, certainty: Certainty) => EditionOp;
+export declare const addReason: (path: Path, reason: AnyArgumentation) => EditionOp;
+export declare const removeReason: (path: Path, index: number) => EditionOp;

package/lib/ops/beliefs.js

@@ -0,0 +1,31 @@
+import { v4 } from "uuid";
+import { getAt } from "../view/EditionView.js";
+const onAssumptionAt = (path, op) => draft => {
+    const assumption = getAt(path, draft);
+    if (assumption)
+        op(assumption);
+};
+const onBeliefAt = (path, op) => onAssumptionAt(path, assumption => {
+    const belief = assumption['@annotation']?.belief;
+    if (belief)
+        op(belief);
+});
+/** Annotates the assumption at the path with a belief held true, for reasons to be added. */
+export const createBelief = (path) => onAssumptionAt(path, assumption => {
+    assumption['@annotation'] = {
+        id: v4(),
+        belief: { type: 'belief', id: v4(), certainty: 'true', reasons: [] }
+    };
+});
+export const clearBelief = (path) => onAssumptionAt(path, assumption => {
+    delete assumption['@annotation'];
+});
+export const setCertainty = (path, certainty) => onBeliefAt(path, belief => {
+    belief.certainty = certainty;
+});
+export const addReason = (path, reason) => onBeliefAt(path, belief => {
+    belief.reasons.push(reason);
+});
+export const removeReason = (path, index) => onBeliefAt(path, belief => {
+    belief.reasons.splice(index, 1);
+});

package/lib/ops/collation.d.ts

@@ -0,0 +1,62 @@
+import { EditionView } from "../view/EditionView.js";
+import { CollationTolerance } from "../collation/Collation.js";
+import { ObjectAssumption } from "../model/Assumption.js";
+import { EditionOp } from "./draft.js";
+/**
+ * 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
+ * rest become the child's insertions, and what the parent hands down
+ * 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.
+ *
+ * A version is based on itself or on one of its own descendants in no
+ * 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;
+/**
+ * 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;
+/**
+ * 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
+ * version's own, the remaining 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.
+ *
+ * The copies named are one **side** of the derivation, the same side a
+ * window is measured over, and `sidesOf` is what says which they are.
+ * Naming one copy of a side that has several does not separate that
+ * side: what stays behind is the rest of it, mixed with the other
+ * side's copies, and a collation then compares one copy against that
+ * mixture rather than the two texts against each other.
+ *
+ * Symbols the named copies alone carry 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 whole reading.
+ */
+export declare const separateReadings: (given: EditionView, versionId: string, copies: ReadonlySet<string>, symbolIds?: readonly string[]) => EditionOp;

package/lib/ops/collation.js

@@ -0,0 +1,228 @@
+import { v4 } from "uuid";
+import { getAt } from "../view/EditionView.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";
+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";
+/** 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 target = path && getAt(path, draft);
+    target?.carriers.push(...symbol.carriers);
+});
+/** Whether the two versions are coded for different reproducing systems. */
+const differ = (child, parent) => {
+    const one = trackerBarOf(child?.system);
+    const other = trackerBarOf(parent?.system);
+    return one !== undefined && other !== undefined && one.id !== other.id;
+};
+/** 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
+ * rest become the child's insertions, and what the parent hands down
+ * 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.
+ *
+ * A version is based on itself or on one of its own descendants in no
+ * 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))
+        return noChange;
+    const child = view.version(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));
+    const matched = new Set(collations.map(({ counterpart }) => counterpart.id));
+    /**
+     * Where the child is coded for another system, a held command of
+     * its own often stands for a latched pair of the parent's. Saying so
+     * as one edit is the transfer being carried out, and leaving the two
+     * apart would make the apparatus a list of unexplained losses beside
+     * a list of unexplained gains.
+     */
+    const substituted = differ(child, view.version(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 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',
+            motivation: unchecked,
+            insert: [...by],
+            delete: deleted
+        };
+    };
+    const edits = [
+        ...established,
+        ...substituted.map(equivalence),
+        ...own.filter(symbol => !collated.has(symbol.id) && !paired.has(symbol.id)).map(insertion).map(asUnchecked),
+        ...inherited
+            .filter(symbol => !matched.has(symbol.id) && !paired.has(symbol.id))
+            .map(symbol => asUnchecked(deletion(symbol.id)))
+    ];
+    return onVersion(childId, (child, draft) => {
+        handOverCarriers(view, draft, collations);
+        child.edits = edits;
+        child.motivations = declaring(stateOf(child).motivations, edits);
+        child.basedOn = [
+            { ...assignReference(parentId), collationTolerance: tolerance },
+            ...hypothesesBeside(stateOf(child), parentId)
+        ];
+    });
+});
+/**
+ * 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 const collateSymbols = (given, versionId, symbolIds, tolerance) => reading(given, view => {
+    const version = view.version(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 collated = new Set(collations.map(({ symbol }) => symbol.id));
+    return onVersion(versionId, (version, draft) => {
+        handOverCarriers(view, draft, collations);
+        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 named copies and at least one other carry it,
+ * with the carriers of each side.
+ *
+ * A symbol the named copies alone carry has no other side to be
+ * separated from and is passed over. That covers the insertions, and it
+ * covers a symbol an ancestor holds on one branch's witness alone,
+ * where the two versions do not disagree and there is nothing to take
+ * apart.
+ */
+const sharedWith = (view, symbol, copies) => {
+    const onNamedCopy = (carrier) => {
+        const copy = view.copyOf(idOf(carrier));
+        return copy !== undefined && copies.has(copy.id);
+    };
+    const mine = symbol.carriers.filter(onNamedCopy);
+    const theirs = symbol.carriers.filter(carrier => !onNamedCopy(carrier));
+    return mine.length > 0 && theirs.length > 0 ? [{ symbol, mine, theirs }] : [];
+};
+/**
+ * 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
+ * version's own, the remaining 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.
+ *
+ * The copies named are one **side** of the derivation, the same side a
+ * window is measured over, and `sidesOf` is what says which they are.
+ * Naming one copy of a side that has several does not separate that
+ * side: what stays behind is the rest of it, mixed with the other
+ * side's copies, and a collation then compares one copy against that
+ * mixture rather than the two texts against each other.
+ *
+ * Symbols the named copies alone carry 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 whole reading.
+ */
+export const separateReadings = (given, versionId, copies, symbolIds) => reading(given, view => {
+    const version = view.version(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, copies));
+    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];
+    });
+});

package/lib/ops/commands.d.ts

@@ -0,0 +1,9 @@
+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;
+/** 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;

package/lib/ops/commands.js

@@ -0,0 +1,29 @@
+import { getAt } from "../view/EditionView.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.
+ */
+const onCommand = (view, id, op) => reading(view, fresh => draft => {
+    const path = fresh.getPath(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 => {
+    clearPlacement(command);
+    command[relation] = assignReference(referenceId);
+});
+export const unplaceCommand = (view, followerId) => onCommand(view, followerId, clearPlacement);
+/** The pair is stated on `statingId` only, as the format asks. */
+export const pairCommands = (view, statingId, partnerId) => onCommand(view, statingId, command => {
+    command.pairedWith = assignReference(partnerId);
+});
+export const unpairCommand = (view, statingId) => onCommand(view, statingId, command => {
+    delete command.pairedWith;
+});

package/lib/ops/copies.d.ts

@@ -0,0 +1,74 @@
+/** Operations on the copies: adding and aligning them, and what they state of their source, their carriage and their condition. */
+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 { FeatureSource } from "../model/FeatureSource.js";
+import { Belief, ObjectAssumption, ReferenceAssumption } from "../model/Assumption.js";
+import { Millimeters } from "../model/Quantity.js";
+import { EditionOp } from "./draft.js";
+/**
+ * Puts the copy into the edition with a version of its own, which
+ * inserts every symbol the copy's own tracker bar reads on it. The
+ * version is a reading in that system's words, so it is coded for the
+ * system the copy was cut for.
+ */
+export declare const createVersion: (copy: RollCopy) => EditionOp;
+/**
+ * Puts the copy into the edition without a version of its own, as for a
+ * copy whose features are not read into symbols: one known only from a
+ * recording states instead which versions it carries.
+ */
+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.
+ */
+export declare const alignCopy: (copyId: string, shift: Shift, scale: number, reading?: ScaleReading) => EditionOp;
+/**
+ * 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.
+ */
+export declare const unalignCopy: (copyId: string) => EditionOp;
+/**
+ * Takes the extension a pneumatic reader adds off the ends of the
+ * copy's chains of holes, and records how much was taken, so that their lengths
+ * can be compared with a scanned copy's at all.
+ */
+export declare const shortenCopy: (copyId: string, extension: Millimeters, leaving?: ReadonlySet<string>) => EditionOp;
+/** Puts the reader's extension back on the copy's chains of holes. */
+export declare const unshortenCopy: (copyId: string) => EditionOp;
+/** States what the copy's features were read from, in place of any earlier statement. */
+export declare const stateSource: (copyId: string, source: FeatureSource) => EditionOp;
+/** Takes back the statement, leaving the copy silent about its source again. */
+export declare const clearSource: (copyId: string) => EditionOp;
+/** Gives the copy the siglum it is referred to by, or takes it away where the siglum given is blank. */
+export declare const nameCopy: (copyId: string, siglum: string) => EditionOp;
+/** Takes out the copy's statements that match, and the list itself where none is left. */
+export declare const dropStatements: (copy: Draft<RollCopy>, matches: (statement: Readonly<ReferenceAssumption>) => boolean) => void;
+/**
+ * States that the copy carries the version, under the belief given. It
+ * is meant for a copy whose features are not read into symbols, such as
+ * one known only from a recording, and `carriageProblems` reports it
+ * where features carry symbols already. A second statement about one
+ * version is none.
+ */
+export declare const stateCarriage: (copyId: string, versionId: string, belief?: Belief) => EditionOp;
+/** Takes back the copy's statement that it carries the version. */
+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`.
+ */
+export declare const addGeneralCondition: (copyId: string, condition: ObjectAssumption<GeneralRollCondition>) => EditionOp;
+/** The symbols of the versions that no other copy carries. */
+export declare const symbolsCarriedOnlyBy: (edition: Edition, copyId: string) => AnySymbol[];
+/**
+ * Takes the copy out of the edition together with the symbols only it
+ * carries, and with every reference the versions and the argumentations
+ * made to those symbols.
+ */
+export declare const removeCopy: (copyId: string) => EditionOp;