linked-rolls 0.74.0 → 0.76.0

package/lib/ops/collation.js

@@ -1,14 +1,18 @@
 import { v4 } from "uuid";
 import { getAt, pathIn } from "../lookup/paths.js";
-import { collationsOf, defaultCollationTolerance, isCollationsOwn, unchecked } from "../collation/Collation.js";
+import { collationsOf, defaultCollationTolerance, isCollationsOwn } from "../collation/Collation.js";
+import { motivationProposedFor, technicalChange } from "../model/Edit.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, insertion, deletion, asUnchecked, declaring, dropInsertions, reading } from "./draft.js";
+import { noChange, onVersion, insertion, deletion, dropInsertions, reading } from "./draft.js";
 import { hypothesesBeside } from "./versions.js";
+import { shapeOf } from "./edits.js";
+import { predecessorOf } from "../analysis/stemma.js";
 import { placeOf, snapshotOf } from "../analysis/text.js";
 import { copyOfFeature, versionIn } from "../lookup/lookup.js";
+import { motivationOfChanges, proposedMotivations } from "../filiation/edits.js";
 /** The carriers of each collated symbol pass to its counterpart. */
 const handOverCarriers = (edition, draft, collations) => collations.forEach(({ symbol, counterpart }) => {
     const path = pathIn(edition, counterpart.id);
@@ -43,15 +47,18 @@ const byExchange = (edits) => new Map(edits.map(edit => [exchangeKey((edit.inser
  * 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
+ * The edits the child already stated are rewritten only as far as they
+ * are the program's (`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.
+ * identifier and whatever was written on it. An insertion or deletion
+ * drawn anew has the motivation its shape calls for
+ * (`motivationProposedFor`): the generic musical one, or the technical
+ * one, which an equivalence drawn anew always has.
  *
  * The child's own text is what it shows less what the parent hands
  * down, so that connecting two versions already connected collates the
@@ -101,31 +108,36 @@ export const connectVersions = (childId, parentId, tolerance = defaultCollationT
         return alreadyStated.get(exchangeKey(inserted, deleted)) ?? {
             type: 'edit',
             id: v4(),
-            editType: 'recoding',
-            motivation: unchecked,
+            motivation: technicalChange,
             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),
+    const bare = [
+        ...own.filter(symbol => !collated.has(symbol.id) && !paired.has(symbol.id)).map(insertion),
         ...inherited
             .filter(symbol => !matched.has(symbol.id) && !paired.has(symbol.id))
-            .map(symbol => asUnchecked(deletion(symbol.id)))
+            .map(symbol => deletion(symbol.id))
     ];
+    const drawn = [...established, ...substituted.map(equivalence), ...bare];
     // Read off the child as it stands, since once its edits are written a
     // reading of it would copy them all.
-    const motivations = declaring(child?.motivations ?? [], edits);
     const basedOn = [
         { ...assignReference(parentId), collationTolerance: tolerance },
         ...(child ? hypothesesBeside(child, parentId) : [])
     ];
+    // What kind of change an insertion or a deletion is depends on what it stands among.
+    const connected = { ...edition, versions: edition.versions.map(version => version.id === childId ? { ...version, edits: drawn, basedOn } : version) };
+    const motivations = proposedMotivations(connected, childId);
+    const anew = new Set(bare.map(edit => edit.id));
+    const edits = drawn.map(edit => {
+        if (!anew.has(edit.id))
+            return edit;
+        return { ...edit, motivation: motivationOfChanges(motivations, [...(edit.insert ?? []).map(symbol => symbol.id), ...(edit.delete ?? [])]) };
+    });
     return onVersion(childId, (version, draft) => {
         handOverCarriers(edition, draft, collations);
         version.edits = edits;
-        version.motivations = motivations;
         version.basedOn = basedOn;
     });
 });
@@ -184,7 +196,8 @@ const sharedWith = (edition, symbol, copies) => {
  * 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.
+ * version states the exchange, with the motivation its shape calls for
+ * (`motivationProposedFor`) where the version derives from another.
  *
  * 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
@@ -217,14 +230,18 @@ export const separateReadings = (versionId, copies, symbolIds) => reading(editio
         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] })
-    }));
+    const derived = predecessorOf(edition, versionId) !== undefined;
+    const separations = shared.map(({ symbol, mine }) => {
+        const separation = {
+            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 derived ? { ...separation, motivation: motivationProposedFor(shapeOf(edition, versionId, separation)) } : separation;
+    });
     return onVersion(versionId, (version, draft) => {
         shared.forEach(({ symbol, theirs }) => {
             const path = pathIn(edition, symbol.id);

package/lib/ops/copies.js

@@ -21,8 +21,7 @@ export const createVersion = (copy) => draft => {
     draft.versions.push({
         id: v4(),
         system: systemOf(bar),
-        edits: asSymbols(featuresOf(copy), bar).map(insertion),
-        motivations: []
+        edits: asSymbols(featuresOf(copy), bar).map(insertion)
     });
 };
 /**

package/lib/ops/draft.d.ts

@@ -3,7 +3,7 @@ import { Draft } from "immer";
 import { Edition } from "../model/Edition.js";
 import { AnySymbol } from "../model/Symbol.js";
 import { Edit } from "../model/Edit.js";
-import { Motivation, Version } from "../model/Version.js";
+import { Version } from "../model/Version.js";
 import { RollCopy } from "../model/RollCopy.js";
 import { Belief, ReferenceAssumption } from "../model/Assumption.js";
 import { FeatureOrPatch } from "../model/Feature.js";
@@ -42,14 +42,6 @@ export declare const droppedIds: (before: readonly WithId[], after: readonly Wit
 export type Ids = ReadonlySet<string>;
 export declare const insertion: (symbol: AnySymbol) => Edit;
 export declare const deletion: (symbolId: string) => Edit;
-/** The edit as a collation leaves it: made by rule, and not yet read by anybody. */
-export declare const asUnchecked: (edit: Edit) => Edit;
-/**
- * The motivations with the unchecked one declared, where any edit
- * names it and the version does not state it yet. An edit naming a
- * motivation the version leaves undeclared points at nothing.
- */
-export declare const declaring: (motivations: Motivation[], edits: readonly Edit[]) => Motivation[];
 export declare const insertedIn: (versions: readonly Version[]) => AnySymbol[];
 /** The edits with the change applied, less those it emptied; the very same array where it changed none. */
 export declare const edited: (edits: Edit[], change: (edit: Edit) => Edit) => Edit[];

package/lib/ops/draft.js

@@ -1,7 +1,6 @@
 /** 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 { 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";
@@ -45,17 +44,6 @@ export const droppedIds = (before, after) => {
 };
 export const insertion = (symbol) => ({ type: 'edit', id: v4(), insert: [symbol] });
 export const deletion = (symbolId) => ({ type: 'edit', id: v4(), delete: [symbolId] });
-/** The edit as a collation leaves it: made by rule, and not yet read by anybody. */
-export const asUnchecked = (edit) => ({ ...edit, motivation: unchecked });
-/**
- * The motivations with the unchecked one declared, where any edit
- * names it and the version does not state it yet. An edit naming a
- * motivation the version leaves undeclared points at nothing.
- */
-export const declaring = (motivations, edits) => edits.some(edit => edit.motivation === unchecked)
-    && !motivations.some(motivation => motivation.id === unchecked)
-    ? [...motivations, uncheckedMotivation]
-    : motivations;
 const isEmpty = (edit) => !edit.insert?.length && !edit.delete?.length;
 export const insertedIn = (versions) => versions.flatMap(insertedBy);
 /** The edits with the change applied, less those it emptied; the very same array where it changed none. */

package/lib/ops/edits.d.ts

@@ -1,13 +1,30 @@
-import { Edit } from "../model/Edit.js";
+import { Edit, EditShape } from "../model/Edit.js";
 import { EditionOp } from "./draft.js";
+import { Edition } from "../model/Edition.js";
+/**
+ * A guess at the shape of an edit, from the symbols it exchanges and
+ * from the systems the version and the one it is based on are coded
+ * for, or nothing where it takes no shape the guess knows. It looks at
+ * the edit alone: a single expression deleted is taken for a redundancy
+ * removed, which `proposeEdits` checks against the text.
+ * @category Lookups
+ */
+export declare const shapeOf: (edition: Edition, versionId: string, edit: Readonly<Edit>) => EditShape | undefined;
 /**
  * Replaces the edits with a single one carrying all their insertions
- * and deletions, classified by a guess at what the exchange does.
+ * and deletions. It keeps the first motivation of the editor's that any
+ * of them states, and where none does, it has the one its shape calls
+ * for (`motivationProposedFor`), so that a merge says it is a musical
+ * or a technical change, unless the version derives from none. A
+ * grouping that says no more is the program's by rule
+ * (`isCollationsOwn`), until the editor says why it was made.
  * @category Operations
  */
 export declare const mergeEdits: (versionId: string, toMerge: readonly Edit[]) => EditionOp;
 /**
- * Replaces the edit with one edit per inserted and one per deleted symbol.
+ * Replaces the edit with one edit per inserted and one per deleted
+ * symbol. Each part keeps the motivation of the edit, since splitting
+ * an edit does not change why it was made.
  * @category Operations
  */
 export declare const splitEdit: (versionId: string, toSplit: Edit) => EditionOp;

package/lib/ops/edits.js

@@ -1,6 +1,8 @@
 /** Merging and splitting the edits of a version. */
 import { v4 } from "uuid";
+import { motivationProposedFor, musicalChange, technicalChange } from "../model/Edit.js";
 import { editsOf } from "../model/Version.js";
+import { keyOf } from "../systems/TrackerBar.js";
 import { trackerBarOf } from "../systems/index.js";
 import { distance, mm, subtract } from "../model/Quantity.js";
 import { noChange, onVersion, insertion, deletion, reading } from "./draft.js";
@@ -15,18 +17,24 @@ 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 = (edition, inserted, deleted) => {
+const replacementShape = (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';
 };
+/** Whether the two symbols say the same thing, as a perforation put elsewhere does. */
+const sameKind = (a, b) => a.type !== 'text' && b.type !== 'text' && keyOf(a) === keyOf(b);
 /**
- * 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.
+ * A guess at the shape of an edit, from the symbols it exchanges and
+ * from the systems the version and the one it is based on are coded
+ * for, or nothing where it takes no shape the guess knows. It looks at
+ * the edit alone: a single expression deleted is taken for a redundancy
+ * removed, which `proposeEdits` checks against the text.
+ * @category Lookups
  */
-const guessEditType = (edition, versionId, edit) => {
+export const shapeOf = (edition, versionId, edit) => {
     const inserts = edit.insert ?? [];
     const deletes = symbolsIn(edition, edit.delete ?? []);
     const inserted = expressionTypesOf(inserts);
@@ -40,8 +48,7 @@ const guessEditType = (edition, versionId, edit) => {
      * SforzandoForte says the same thing in the other system's words, and
      * a red command the green bar cannot read struck, or a green hold put
      * in where the red had no word for it, belongs to the same act. That
-     * is a recoding. Calling it a corrected error would say the editor
-     * made a mistake. Only an insertion spelling the bar's own accent
+     * is a recoding. Only an insertion spelling the bar's own accent
      * reads more narrowly, as the accent it spells.
      */
     const transferred = bar && parentBar && bar.id !== parentBar.id;
@@ -56,38 +63,52 @@ const guessEditType = (edition, versionId, edit) => {
         return 'shift';
     if (inserted.length === 0 && deleted.length === 1)
         return 'remove-redundancy';
-    if (inserts.length === 1 && deletes.length === 1)
-        return replacementType(edition, inserts[0], deletes[0]) ?? 'correct-error';
-    return 'correct-error';
+    if (inserts.length === 1 && deletes.length === 1) {
+        return replacementShape(edition, inserts[0], deletes[0]) ?? (sameKind(inserts[0], deletes[0]) ? 'shift' : undefined);
+    }
+    return undefined;
 };
 /**
  * Replaces the edits with a single one carrying all their insertions
- * and deletions, classified by a guess at what the exchange does.
+ * and deletions. It keeps the first motivation of the editor's that any
+ * of them states, and where none does, it has the one its shape calls
+ * for (`motivationProposedFor`), so that a merge says it is a musical
+ * or a technical change, unless the version derives from none. A
+ * grouping that says no more is the program's by rule
+ * (`isCollationsOwn`), until the editor says why it was made.
  * @category Operations
  */
 export const mergeEdits = (versionId, toMerge) => reading(edition => {
     if (toMerge.length === 0)
         return noChange;
+    const { motivation: _first, ...first } = toMerge[0];
     const merged = {
-        ...toMerge[0],
+        ...first,
         id: v4(),
         insert: toMerge.flatMap(edit => edit.insert ?? []),
         delete: toMerge.flatMap(edit => edit.delete ?? [])
     };
-    merged.editType = guessEditType(edition, versionId, merged);
+    const editors = toMerge.find(edit => edit.motivation !== undefined && edit.motivation !== musicalChange && edit.motivation !== technicalChange);
+    if (editors)
+        merged.motivation = editors.motivation;
+    else if (predecessorOf(edition, versionId))
+        merged.motivation = motivationProposedFor(shapeOf(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];
     });
 });
 /**
- * Replaces the edit with one edit per inserted and one per deleted symbol.
+ * Replaces the edit with one edit per inserted and one per deleted
+ * symbol. Each part keeps the motivation of the edit, since splitting
+ * an edit does not change why it was made.
  * @category Operations
  */
 export const splitEdit = (versionId, toSplit) => {
+    const kept = toSplit.motivation === undefined ? {} : { motivation: toSplit.motivation };
     const parts = [
-        ...(toSplit.insert ?? []).map(insertion),
-        ...(toSplit.delete ?? []).map(deletion)
+        ...(toSplit.insert ?? []).map(symbol => ({ ...insertion(symbol), ...kept })),
+        ...(toSplit.delete ?? []).map(id => ({ ...deletion(id), ...kept }))
     ];
     return onVersion(versionId, version => {
         version.edits = [...editsOf(version).filter(edit => edit.id !== toSplit.id), ...parts];

package/lib/ops/index.d.ts

@@ -8,6 +8,6 @@ export { createVersion, addCopy, alignmentFor, alignCopy, alignCopies, chooseRef
 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";
-export { mergeEdits, splitEdit } from "./edits.js";
+export { mergeEdits, splitEdit, shapeOf } from "./edits.js";
 export { placeCommand, unplaceCommand, pairCommands, unpairCommand } from "./commands.js";
 export { createBelief, clearBelief, setCertainty, addReason, removeReason } from "./beliefs.js";

package/lib/ops/index.js

@@ -8,6 +8,6 @@ export { createVersion, addCopy, alignmentFor, alignCopy, alignCopies, chooseRef
 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";
-export { mergeEdits, splitEdit } from "./edits.js";
+export { mergeEdits, splitEdit, shapeOf } from "./edits.js";
 export { placeCommand, unplaceCommand, pairCommands, unpairCommand } from "./commands.js";
 export { createBelief, clearBelief, setCertainty, addReason, removeReason } from "./beliefs.js";

package/lib/ops/versions.d.ts

@@ -5,8 +5,9 @@ import { EditionOp } from "./draft.js";
 export declare const hypothesesBeside: (version: Readonly<Version>, parentId: string) => Derivation[];
 /**
  * Makes the version stand on its own: what it inherited becomes its
- * own insertions, and its derivations go, the hypotheses among them,
- * with the motivations that belonged to them.
+ * own insertions, and its derivations go, the hypotheses among them.
+ * Its edits now state its text rather than a change, and say nothing of
+ * why they were made.
  * @category Operations
  */
 export declare const detachVersion: (versionId: string) => EditionOp;

package/lib/ops/versions.js

@@ -28,8 +28,9 @@ const dropDerivations = (version, matches) => {
 };
 /**
  * Makes the version stand on its own: what it inherited becomes its
- * own insertions, and its derivations go, the hypotheses among them,
- * with the motivations that belonged to them.
+ * own insertions, and its derivations go, the hypotheses among them.
+ * Its edits now state its text rather than a change, and say nothing of
+ * why they were made.
  * @category Operations
  */
 export const detachVersion = (versionId) => reading(edition => {
@@ -37,7 +38,6 @@ export const detachVersion = (versionId) => reading(edition => {
     return onVersion(versionId, version => {
         version.edits = edits;
         delete version.basedOn;
-        version.motivations = [];
     });
 });
 /**
@@ -76,8 +76,7 @@ export const deriveVersion = (versionId, editIds) => onVersion(versionId, (versi
         id: v4(),
         system: stateOf(version).system,
         basedOn: [assignReference(versionId)],
-        edits: moved,
-        motivations: []
+        edits: moved
     });
 });
 /**