linked-rolls 0.73.0 → 0.75.0

package/lib/model/Edition.d.ts

@@ -1,6 +1,6 @@
 import { RollCopy } from "./RollCopy.js";
 import { Version } from "./Version.js";
-import { DateAssignment } from "./Assumption.js";
+import { DateAssignment, PropositionSet } from "./Assumption.js";
 import { Editor, Person, Place } from "./Agent.js";
 /**
  * This type describes the creation of an edition,
@@ -159,6 +159,15 @@ export interface Edition {
      * @see lrmoo:R75 incorporates
      */
     versions: Version[];
+    /**
+     * The statements the edition holds together under one belief, each
+     * set with the reasoning that concluded it: a stemma a program
+     * proposed and the editor adopted, the edits it grouped. A statement
+     * belongs to a set by naming it in its annotation. An edition that
+     * holds no such set leaves it out.
+     * @see crminf:I4 Proposition Set
+     */
+    propositionSets?: PropositionSet[];
 }
 /**
  * What an edition states about itself rather than about the copies and

package/lib/model/RollCopy.js

@@ -65,7 +65,7 @@ const exportedMeasurementsOf = (copy) => [copy.measurements.dimensions, copy.mea
  */
 export const measuringSoftwareOf = (copy) => {
     const named = exportedMeasurementsOf(copy)
-        .flatMap(value => value['@annotation']?.belief.reasons ?? [])
+        .flatMap(value => value['@annotation']?.belief?.reasons ?? [])
         .flatMap(reason => reason.type === 'measurement' ? reason.software ?? [] : []);
     return [...new Map(named.map(software => [`${software.name}\u0000${software.version ?? ''}`, software])).values()];
 };

package/lib/model/Version.d.ts

@@ -1,6 +1,6 @@
 import { Edit } from "./Edit.js";
 import { Concept } from "./Agent.js";
-import { ActorAssignment, Belief, Certainty, DateAssignment, ObjectAssumption, ReferenceAssumption } from "./Assumption.js";
+import { ActorAssignment, Belief, Certainty, DateAssignment, ObjectAssumption, PropositionSet, ReferenceAssumption } from "./Assumption.js";
 import { CollationTolerance } from "../collation/Collation.js";
 import { AnySymbol } from "./Symbol.js";
 import { WithId, WithNote, WithType } from "../shared/utils.js";
@@ -11,6 +11,26 @@ import { WithId, WithNote, WithType } from "../shared/utils.js";
  * @category Format types
  */
 export type Motivation = WithType<'motivation'> & WithId & WithNote;
+/**
+ * The motivation of an edit that puts right what the version it derives
+ * from got wrong: a perforation put in the wrong place, struck or left
+ * out. Whether a change corrects an error is not read off its shape, as
+ * its type is, but is a reason for it, and so the editor's to give.
+ * The edit types held it once, and a document written then is read with
+ * this motivation in place of that type.
+ * @category Versions and stemma
+ */
+export declare const correctedError = "corrected-error";
+/**
+ * The version's statement of what the motivation of a corrected error
+ * means, to stand in its `motivations`.
+ * @category Versions and stemma
+ */
+export declare const correctedErrorMotivation: {
+    readonly type: 'motivation';
+    readonly id: "corrected-error";
+    readonly note: 'Puts right an error of the version it derives from.';
+};
 /**
  * A derivation names the version another one was derived from, together
  * with the tolerance the two were collated at. How precisely the copies
@@ -170,13 +190,19 @@ export declare const insertedBy: (version: Readonly<Version>) => AnySymbol[];
 export declare const deletedBy: (version: Readonly<Version>) => string[];
 /**
  * The parents the version names, in the order of `basedOn`, each with the
- * certainty its derivation is held with and the belief it rests on.
+ * certainty its derivation is held with and the belief it rests on. Given
+ * the edition, a derivation that belongs to a proposition set, as an
+ * adopted stemma's do, is read with the belief of the set, and names it
+ * (`propositionSet`); without it, only a belief of its own is read.
  * @category Versions and stemma
  */
-export declare const derivationsOf: (version: Readonly<Version>) => {
+export declare const derivationsOf: (version: Readonly<Version>, edition?: {
+    propositionSets?: readonly PropositionSet[];
+}) => {
     parent: string;
     certainty: Certainty;
     belief?: Belief;
+    propositionSet?: string;
 }[];
 /**
  * The derivation the version's text is read against: the first of those

package/lib/model/Version.js

@@ -1,5 +1,25 @@
-import { certainties, certaintyOf, idOf } from "./Assumption.js";
+import { beliefIn, certainties, certaintyOf, idOf } from "./Assumption.js";
 import { defaultCollationTolerance } from "../collation/Collation.js";
+/**
+ * The motivation of an edit that puts right what the version it derives
+ * from got wrong: a perforation put in the wrong place, struck or left
+ * out. Whether a change corrects an error is not read off its shape, as
+ * its type is, but is a reason for it, and so the editor's to give.
+ * The edit types held it once, and a document written then is read with
+ * this motivation in place of that type.
+ * @category Versions and stemma
+ */
+export const correctedError = 'corrected-error';
+/**
+ * The version's statement of what the motivation of a corrected error
+ * means, to stand in its `motivations`.
+ * @category Versions and stemma
+ */
+export const correctedErrorMotivation = {
+    type: 'motivation',
+    id: correctedError,
+    note: 'Puts right an error of the version it derives from.'
+};
 /**
  * The tolerance the derivation was collated at, or the default where it states none.
  * @category Collation and alignment
@@ -22,12 +42,21 @@ export const insertedBy = (version) => editsOf(version).flatMap(edit => edit.ins
 export const deletedBy = (version) => editsOf(version).flatMap(edit => edit.delete ?? []);
 /**
  * The parents the version names, in the order of `basedOn`, each with the
- * certainty its derivation is held with and the belief it rests on.
+ * certainty its derivation is held with and the belief it rests on. Given
+ * the edition, a derivation that belongs to a proposition set, as an
+ * adopted stemma's do, is read with the belief of the set, and names it
+ * (`propositionSet`); without it, only a belief of its own is read.
  * @category Versions and stemma
  */
-export const derivationsOf = (version) => (version.basedOn ?? []).map(derivation => {
-    const belief = derivation['@annotation']?.belief;
-    return { parent: idOf(derivation), certainty: certaintyOf(derivation), ...(belief && { belief }) };
+export const derivationsOf = (version, edition = {}) => (version.basedOn ?? []).map(derivation => {
+    const belief = beliefIn(edition, derivation);
+    const set = derivation['@annotation']?.belief === undefined ? derivation['@annotation']?.id : undefined;
+    return {
+        parent: idOf(derivation),
+        certainty: belief?.certainty ?? 'true',
+        ...(belief && { belief }),
+        ...(set !== undefined && { propositionSet: set })
+    };
 });
 const rankOf = (derivation) => certainties.indexOf(certaintyOf(derivation));
 /**

package/lib/ops/edits.d.ts

@@ -2,7 +2,9 @@ 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.
+ * and deletions, classified by a guess at what the exchange does, where
+ * its shape says. The edit is the editor's: it belongs to no proposition
+ * set a program's run concluded, as one of those merged may have.
  * @category Operations
  */
 export declare const mergeEdits: (versionId: string, toMerge: readonly Edit[]) => EditionOp;

package/lib/ops/edits.js

@@ -1,6 +1,7 @@
 /** Merging and splitting the edits of a version. */
 import { v4 } from "uuid";
 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";
@@ -22,9 +23,13 @@ const replacementType = (edition, inserted, deleted) => {
         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.
+ * the systems the version and the one it is based on are coded for, or
+ * nothing where its shape does not say. Whether it corrects an error is
+ * not guessed: that is a motivation, the editor's to give.
  */
 const guessEditType = (edition, versionId, edit) => {
     const inserts = edit.insert ?? [];
@@ -56,25 +61,33 @@ 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 replacementType(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, classified by a guess at what the exchange does, where
+ * its shape says. The edit is the editor's: it belongs to no proposition
+ * set a program's run concluded, as one of those merged may have.
  * @category Operations
  */
 export const mergeEdits = (versionId, toMerge) => reading(edition => {
     if (toMerge.length === 0)
         return noChange;
+    // The edit is the editor's grouping, whatever set of a program's the first one belonged to.
+    const { editType: _guessed, '@annotation': annotation, ...first } = toMerge[0];
     const merged = {
-        ...toMerge[0],
+        ...first,
+        ...(annotation?.belief && { '@annotation': annotation }),
         id: v4(),
         insert: toMerge.flatMap(edit => edit.insert ?? []),
         delete: toMerge.flatMap(edit => edit.delete ?? [])
     };
-    merged.editType = guessEditType(edition, versionId, merged);
+    const editType = guessEditType(edition, versionId, merged);
+    if (editType)
+        merged.editType = editType;
     const mergedIds = new Set(toMerge.map(edit => edit.id));
     return onVersion(versionId, version => {
         version.edits = [...editsOf(version).filter(edit => !mergedIds.has(edit.id)), merged];