linked-rolls 0.74.0 → 0.75.0

package/lib/filiation/record.js

@@ -0,0 +1,120 @@
+/**
+ * What adopting a proposal records of the run that made it: the
+ * proposition set the statements it concluded belong to, held under one
+ * belief, and the reasoning that belief rests on.
+ */
+import { v5 } from "uuid";
+import { linkedRolls } from "../software.js";
+/** The namespace the ids of recorded sets and beliefs are minted in, so that recording the same run again gives them again. */
+const RECORDED = 'b7e2a4d1-5c3f-4e86-9a0b-1d2f3e4c5a67';
+/**
+ * The published rules the proposal of a stemma follows, by IRI, each
+ * under the cost or the step that carries it out. They are the
+ * editorial principles of the edition of WM 225, which are suggested
+ * for the filiation of piano rolls at large.
+ * @category Filiation
+ */
+export const stemmaRules = {
+    /** An addition at the same place is not made twice independently, so a reading arising costs ten times one lost. */
+    sharedAddition: 'https://welte225.org/rules#shared-addition',
+    /** Redundancies are cleaned up in two branches independently, so losing one counts for less. */
+    independentCleanup: 'https://welte225.org/rules#independent-cleanup',
+    /** A re-cut for another system was an editorial pass of its own, so what it lacks counts for less. */
+    recutLoss: 'https://welte225.org/rules#recut-loss',
+    /** A copy may fail to show a reading of the version it carries. */
+    copyDeviation: 'https://welte225.org/rules#copy-deviation',
+    /** A lost state is posited only where shared additions require it. */
+    lostStates: 'https://welte225.org/rules#lost-states',
+    /** Copies of one system that differ in a few readings carry one text. */
+    oneText: 'https://welte225.org/rules#one-text',
+    /** Later versions are the more refined, which orients the root. */
+    refinement: 'https://welte225.org/rules#refinement',
+    /** A version derives from one exemplar, so a stemma is a tree. */
+    noContamination: 'https://welte225.org/rules#no-contamination'
+};
+/**
+ * The published rules the proposal of edits follows, by IRI.
+ * @category Filiation
+ */
+export const editRules = {
+    /** An edit stays at one place: it runs across no command both texts keep. */
+    onePlace: 'https://welte225.org/rules#one-place'
+};
+/**
+ * The proposition set of a run, with its belief and the inference it
+ * rests on. Its id follows from what it is given, so that recording the
+ * same run again gives the same set.
+ */
+export const recorded = (kind, identity, concluded, run) => {
+    const id = `propositions_${v5(JSON.stringify([kind, linkedRolls, identity]), RECORDED)}`;
+    const inference = {
+        type: 'inference',
+        ...(run.actor && { actor: run.actor }),
+        note: concluded.note,
+        premises: concluded.premises,
+        ...(concluded.used.length > 0 && { used: concluded.used }),
+        applies: run.applies ?? concluded.applies,
+        software: [linkedRolls],
+        ...(run.date && { date: run.date })
+    };
+    return {
+        type: 'propositionSet',
+        id,
+        belief: {
+            type: 'belief',
+            id: `belief_${v5(id, RECORDED)}`,
+            certainty: run.certainty ?? 'likely',
+            reasons: [inference]
+        }
+    };
+};
+/** The statement as one of the set: its annotation names the set, and it carries no belief of its own. */
+export const memberOf = (set, statement) => statement['@annotation']?.id === set && statement['@annotation'].belief === undefined
+    ? statement
+    : { ...statement, '@annotation': { id: set } };
+/** The ids every annotation of the value names a set by, and every premise names a belief by. */
+const namedIn = (value, names) => {
+    if (Array.isArray(value)) {
+        value.forEach(item => namedIn(item, names));
+        return;
+    }
+    if (value === null || typeof value !== 'object' || value instanceof Date)
+        return;
+    const record = value;
+    const annotation = record['@annotation'];
+    if (annotation?.id !== undefined && annotation.belief === undefined)
+        names.add(annotation.id);
+    if (Array.isArray(record.premises))
+        record.premises.forEach(premise => typeof premise === 'string' && names.add(premise));
+    Object.values(record).forEach(child => namedIn(child, names));
+};
+/**
+ * The sets the edition keeps, with those given added where it holds none
+ * with their id: a set already recorded stays as it was recorded, by
+ * whom and when it was first concluded. Kept are the sets a statement
+ * belongs to, and those whose belief the reasons of another kept
+ * statement or set name as a premise. A set nothing names any longer is
+ * the record of a run whose conclusions have all been replaced.
+ */
+export const keptSets = (edition, adding) => {
+    const held = edition.propositionSets ?? [];
+    const known = new Set(held.map(set => set.id));
+    const sets = [...held, ...adding.filter(set => !known.has(set.id))];
+    const named = new Set();
+    namedIn({ ...edition, propositionSets: [] }, named);
+    const kept = new Set();
+    for (let grown = true; grown;) {
+        grown = false;
+        for (const set of sets) {
+            if (kept.has(set) || !(named.has(set.id) || named.has(set.belief.id)))
+                continue;
+            kept.add(set);
+            namedIn(set.belief, named);
+            grown = true;
+        }
+    }
+    const keeping = sets.filter(set => kept.has(set));
+    return keeping.length > 0 ? keeping : undefined;
+};
+/** A distance in millimetres as a note gives it. */
+export const inMillimetres = (value) => `${Math.round(value * 100) / 100} mm`;

package/lib/index.d.ts

@@ -61,6 +61,7 @@ export * from './analysis/witnesses.js';
 export { alignFeatures, ALIGNMENT_METHOD, fromAxis, ownFeaturesOf, toAxis, tooShortToShorten, type AlignmentResult } from './collation/alignment.js';
 export * from './collation/statistics.js';
 export * from './model/Edition.js';
+export { linkedRolls } from './software.js';
 export * from './lookup/lookup.js';
 export * from './lookup/paths.js';
 export * from './analysis/stemma.js';

package/lib/index.js

@@ -24,6 +24,7 @@ export * from './analysis/witnesses.js';
 export { alignFeatures, ALIGNMENT_METHOD, fromAxis, ownFeaturesOf, toAxis, tooShortToShorten } from './collation/alignment.js';
 export * from './collation/statistics.js';
 export * from './model/Edition.js';
+export { linkedRolls } from './software.js';
 export * from './lookup/lookup.js';
 export * from './lookup/paths.js';
 export * from './analysis/stemma.js';

package/lib/io/asJsonLd.d.ts

@@ -12,7 +12,11 @@ export declare const exportDate: (date: Date) => string;
  * and every version carries the context of its own reproducing system.
  * A reference the edition holds possible, unlikely or false is quoted
  * rather than stated, so that a reader of the RDF does not take it for
- * a fact. The edition given is not changed.
+ * a fact, and so is one that belongs to a proposition set held so. A
+ * statement that belongs to a set names the set in its annotation,
+ * which in RDF makes the set its reifier, and the set, stated once
+ * beside the document, carries the belief. The edition given is not
+ * changed.
  * @category Reading and writing
  */
 export declare const asJsonLd: (edition: Edition) => any;

package/lib/io/asJsonLd.js

@@ -97,38 +97,57 @@ const withChanges = (edition) => Array.isArray(edition.copies) ? { ...edition, c
 const silentTerms = new Set(Object.entries(context['@context'])
     .filter(([, definition]) => definition === null)
     .map(([term]) => term));
+const doubtedSetsOf = (edition) => new Map((edition.propositionSets ?? [])
+    .filter(set => !isAsserted(set.belief.certainty))
+    .map(set => [set.id, set.belief.id]));
+/** The set a value's annotation names instead of carrying a belief, where the edition doubts it. */
+const doubtedSetOf = (value, doubted) => {
+    const annotation = value['@annotation'];
+    return isRecord(annotation) && annotation.belief === undefined && typeof annotation['@id'] === 'string'
+        ? doubted.get(annotation['@id']) && annotation['@id']
+        : undefined;
+};
 /**
  * A reference its belief does not hold to be so: it names a node, states
- * nothing RDF would read besides, and its belief is below likely.
+ * nothing RDF would read besides, and its belief is below likely, or the
+ * belief of the proposition set it belongs to is.
  */
-const isDoubtedReference = (value) => isRecord(value)
+const isDoubtedReference = (value, doubted) => isRecord(value)
     && typeof value['@id'] === 'string'
     && isRecord(value['@annotation'])
-    && !isAsserted(certaintyOf(value))
+    && (!isAsserted(certaintyOf(value)) || doubtedSetOf(value, doubted) !== undefined)
     && Object.keys(value).every(key => key === '@id' || key === '@annotation' || silentTerms.has(key));
 /**
  * The statement a doubted reference makes, as a JSON-LD-star embedded
  * node: the triple is named without being stated, and the belief is
  * about it. The annotation's own id goes along under a key RDF does not
- * read, so that an import can put it back.
+ * read, so that an import can put it back. A statement that belongs to
+ * a proposition set names the set's belief by its id, which is stated
+ * with the set.
  */
-const quote = (subject, key, reference, listed) => {
+const quote = (subject, key, reference, listed, doubted) => {
     const { '@annotation': { '@id': annotation, ...about }, ...object } = reference;
-    return { '@id': { '@id': subject, [key]: listed ? [object] : object }, annotation, ...about };
+    const set = doubtedSetOf(reference, doubted);
+    return {
+        '@id': { '@id': subject, [key]: listed ? [object] : object },
+        annotation,
+        ...about,
+        ...(set !== undefined && { belief: { '@id': doubted.get(set) } })
+    };
 };
 /** The value a node states under a key, less the doubted references, which go to the quoted. */
-const unquoted = (subject, key, value, quoted) => {
+const unquoted = (subject, key, value, quoted, doubted) => {
     if (Array.isArray(value)) {
         return value.filter(item => {
-            if (!isDoubtedReference(item))
+            if (!isDoubtedReference(item, doubted))
                 return true;
-            quoted.push(quote(subject, key, item, true));
+            quoted.push(quote(subject, key, item, true, doubted));
             return false;
         });
     }
-    if (!isDoubtedReference(value))
+    if (!isDoubtedReference(value, doubted))
         return value;
-    quoted.push(quote(subject, key, value, false));
+    quoted.push(quote(subject, key, value, false, doubted));
     return undefined;
 };
 /**
@@ -141,16 +160,16 @@ const unquoted = (subject, key, value, quoted) => {
  * between nodes are quoted, since only they can be put back where they
  * stood; a doubted date or attribution stays annotated in place.
  */
-const withDoubtedReferencesQuoted = (value, quoted) => {
+const withDoubtedReferencesQuoted = (value, quoted, doubted) => {
     if (Array.isArray(value))
-        return value.map(item => withDoubtedReferencesQuoted(item, quoted));
+        return value.map(item => withDoubtedReferencesQuoted(item, quoted, doubted));
     if (!isRecord(value))
         return value;
     const subject = value['@id'];
     const node = {};
     Object.entries(value).forEach(([key, child]) => {
-        const stated = typeof subject === 'string' && !key.startsWith('@') ? unquoted(subject, key, child, quoted) : child;
-        const below = withDoubtedReferencesQuoted(stated, quoted);
+        const stated = typeof subject === 'string' && !key.startsWith('@') ? unquoted(subject, key, child, quoted, doubted) : child;
+        const below = withDoubtedReferencesQuoted(stated, quoted, doubted);
         if (below !== undefined)
             node[key] = below;
     });
@@ -167,12 +186,16 @@ const atOwnPlacesAll = (edition) => edition.copies.some(copy => copy.measurement
  * and every version carries the context of its own reproducing system.
  * A reference the edition holds possible, unlikely or false is quoted
  * rather than stated, so that a reader of the RDF does not take it for
- * a fact. The edition given is not changed.
+ * a fact, and so is one that belongs to a proposition set held so. A
+ * statement that belongs to a set names the set in its annotation,
+ * which in RDF makes the set its reifier, and the set, stated once
+ * beside the document, carries the belief. The edition given is not
+ * changed.
  * @category Reading and writing
  */
 export const asJsonLd = (edition) => {
     const quoted = [];
-    const node = withDoubtedReferencesQuoted(withSystemContexts(withCreations(withChanges(asJsonLdEntity(atOwnPlacesAll(edition))))), quoted);
+    const node = withDoubtedReferencesQuoted(withSystemContexts(withCreations(withChanges(asJsonLdEntity(atOwnPlacesAll(edition))))), quoted, doubtedSetsOf(edition));
     // The context is the export's own; one carried in from an import must not override it.
     const { base, '@context': carried, ...rest } = node;
     return {

package/lib/io/importJsonLd.js

@@ -83,9 +83,20 @@ const withoutEmptyCreations = (json) => Array.isArray(json.versions)
     : json;
 /** A statement an export quoted rather than stated: an included node whose id is a triple. */
 const isQuotedStatement = (node) => node !== null && typeof node === 'object' && node['@id'] !== null && typeof node['@id'] === 'object';
-/** The reference a quoted statement made, annotated again with the belief the export set beside it. */
+/**
+ * A belief named by its id alone, as a quoted statement names the belief
+ * of the proposition set it belongs to, which is stated with the set.
+ */
+const isNamedBelief = (belief) => belief !== null && typeof belief === 'object' && Object.keys(belief).every(key => key === '@id');
+/**
+ * The reference a quoted statement made, annotated again with the belief
+ * the export set beside it, or where it belongs to a proposition set,
+ * naming the set again.
+ */
 const referenceOf = (statement) => {
-    const { '@id': { '@id': subject, ...made }, annotation, ...about } = statement;
+    const { '@id': { '@id': subject, ...made }, annotation, ...stated } = statement;
+    const { belief, ...rest } = stated;
+    const about = isNamedBelief(belief) ? rest : stated;
     const [key, value] = Object.entries(made)[0];
     const listed = Array.isArray(value);
     return {

package/lib/io/migrate.js

@@ -63,6 +63,35 @@ const renamedEditTypes = {
 const withRenamedEditType = (node) => typeof node.editType === 'string' && Object.hasOwn(renamedEditTypes, node.editType)
     ? { ...node, editType: renamedEditTypes[node.editType] }
     : node;
+/** The motivation a corrected error is stated with, as `correctedErrorMotivation` was when the kind of edit was retired. */
+const correctedErrorMotivation = {
+    '@type': 'motivation',
+    '@id': 'corrected-error',
+    note: 'Puts right an error of the version it derives from.'
+};
+const isTypedCorrectError = (edit) => edit !== null && typeof edit === 'object' && (edit.editType === 'correct-error' || edit.classification === 'correct-error');
+/**
+ * Whether a change corrects an error was once one of the kinds of edit,
+ * though it is not read off the shape of a change but is a reason for
+ * it. An edit typed so states it as its motivation instead, where it
+ * gives none of its own, and the version states what the motivation
+ * means; one that gives a motivation of its own keeps that one. Either
+ * way it states no kind, its shape being left to be read again.
+ */
+const withCorrectedErrorsMotivated = (node) => {
+    if (!Array.isArray(node.edits) || !node.edits.some(isTypedCorrectError))
+        return node;
+    const edits = node.edits.map((edit) => {
+        if (!isTypedCorrectError(edit))
+            return edit;
+        const { editType: _kind, classification: _named, ...rest } = edit;
+        return rest.motivation === undefined || rest.motivation === 'unchecked' ? { ...rest, motivation: correctedErrorMotivation['@id'] } : rest;
+    });
+    const motivations = Array.isArray(node.motivations) ? node.motivations : [];
+    const declare = edits.some((edit) => edit?.motivation === correctedErrorMotivation['@id'])
+        && !motivations.some(motivation => motivation?.['@id'] === correctedErrorMotivation['@id']);
+    return { ...node, edits, ...(declare && { motivations: [...motivations, correctedErrorMotivation] }) };
+};
 const withRenamedType = (node) => Object.hasOwn(renamedTypes, node['@type']) ? { ...node, '@type': renamedTypes[node['@type']] } : node;
 /** Whether the feature is of the class under either name, since a node is migrated before its children are. */
 const isOfType = (type) => (feature) => feature?.['@type'] === type || renamedTypes[feature?.['@type']] === type;
@@ -503,7 +532,7 @@ const withMeasuredByInReasons = (node) => {
         }
     };
 };
-const nodeSteps = [withRenamedKeys, withRenamedEditType, withTypology, withRenamedType, withoutVersionType, withoutVersionSiglum, withLowerCaseTerms, withSplitMethod, withReferences, withKeeper, withoutEmptyKeeper,
+const nodeSteps = [withRenamedKeys, withRenamedEditType, withCorrectedErrorsMotivated, withTypology, withRenamedType, withoutVersionType, withoutVersionSiglum, withLowerCaseTerms, withSplitMethod, withReferences, withKeeper, withoutEmptyKeeper,
     withPerforator, withProductionNodes, withTypedPerforator, withScale, withoutOps, withDerivationList, withReadingKind, withTimeSpanDates,
     withoutFeatureKind, withBorneFeaturesNamed, withFeaturesInActs, withOwnPlaces, withDriveOfStaggering, withoutPattern, withoutBearings, withoutEntailedType,
     withMeasuredByInReasons];

package/lib/model/Assumption.d.ts

@@ -21,7 +21,10 @@ export type Certainty = typeof certainties[number];
  */
 export declare const isAsserted: (certainty: Certainty) => boolean;
 /**
- * The certainty a statement is held with. One that carries no belief is stated plainly, and so held true.
+ * The certainty a statement is held with for itself. One that carries
+ * no belief is stated plainly, and so held true; one that belongs to a
+ * proposition set is held with the set's belief, which `certaintyIn`
+ * reads.
  * @category Assumptions and beliefs
  */
 export declare const certaintyOf: (assumption: Readonly<Assumption>) => Certainty;
@@ -90,6 +93,24 @@ export interface Inference extends Argumentation<'inference'> {
      * @see crminf:J3 applied
      */
     applies?: string[];
+    /**
+     * The programs that drew the conclusion, each with its version,
+     * where a program drew it: a stemma `proposeStemma` found, which the
+     * editor ran and holds. The actor is the one who ran it, since a
+     * program holds no belief. Naming software makes the inference a
+     * digital machine event in the sense of CRMdig, which can be run
+     * again on what it used, and the note states what it was run with.
+     * @see crmdig:L23 used software or firmware
+     */
+    software?: Software[];
+    /**
+     * When the conclusion was drawn. It is part of the reason and
+     * carries no belief of its own, and it tells a run of a program
+     * from the next, since a program may conclude otherwise once it, or
+     * what it used, has changed.
+     * @see crm:P4 has time-span
+     */
+    date?: TimeSpan;
 }
 /**
  * A belief adoption takes over someone else's belief without checking it:
@@ -202,15 +223,77 @@ export interface Assumption {
      * An optional annotation expressing a belief about this assumption.
      * Uses the JSON-LD-star `@annotation` mechanism to attach
      * epistemic metadata (certainty and reasons) to any triple.
+     *
+     * An annotation that carries no belief names, by its `id`, the
+     * proposition set the statement belongs to (`PropositionSet`): the
+     * statement is held with the belief the set states, together with
+     * the other statements that name it.
      */
     '@annotation'?: WithId & {
         /**
-         * The belief held about the annotated statement.
+         * The belief held about the annotated statement, where it is
+         * held for itself rather than as one of a proposition set.
          * @see crminf:J4i is subject of
          */
-        belief: Belief;
+        belief?: Belief;
     };
 }
+/**
+ * Statements held together under one belief, because one reasoning
+ * concluded them together: the derivations and edits of a stemma, which
+ * a search such as `proposeStemma` scores as a whole rather than one
+ * derivation at a time, or the edits a proposal grouped the changes of
+ * versions into. Each statement belongs to the set by naming it in its
+ * annotation, which carries the set's id and no belief of its own, and
+ * the belief is stated here, once, with the reasoning that concluded
+ * it. Read as RDF, the set is the reifier of each statement that names
+ * it, which RDF 1.2 lets reify several.
+ *
+ * A statement the editor takes out of the set by giving it a belief of
+ * its own is the editor's, and its reasons can name the set's belief as
+ * a premise, so that what the editor decided apart from the program
+ * stays apart from it.
+ * @see crminf:I4 Proposition Set
+ * @category Format types
+ */
+export interface PropositionSet extends WithId {
+    type: 'propositionSet';
+    /**
+     * The belief the statements of the set are held with, and the
+     * reasons for it.
+     * @see crminf:J4i is subject of
+     */
+    belief: Belief;
+}
+/**
+ * Whether the statement carries a belief of its own, rather than none
+ * or the belief of the proposition set it belongs to.
+ * @category Assumptions and beliefs
+ */
+export declare const isHeldForItself: (assumption: Readonly<Assumption>) => boolean;
+/**
+ * The id of the proposition set the statement belongs to, where its
+ * annotation names one instead of carrying a belief.
+ * @category Assumptions and beliefs
+ */
+export declare const propositionSetOf: (assumption: Readonly<Assumption>) => string | undefined;
+/**
+ * The belief the statement is held with in the edition: its own, or
+ * that of the proposition set it belongs to.
+ * @category Assumptions and beliefs
+ */
+export declare const beliefIn: (edition: {
+    propositionSets?: readonly PropositionSet[];
+}, assumption: Readonly<Assumption>) => Belief | undefined;
+/**
+ * The certainty the statement is held with in the edition: that of its
+ * own belief, or of the proposition set it belongs to. One that carries
+ * neither is stated plainly, and so held true.
+ * @category Assumptions and beliefs
+ */
+export declare const certaintyIn: (edition: {
+    propositionSets?: readonly PropositionSet[];
+}, assumption: Readonly<Assumption>) => Certainty;
 /**
  * A value assumption wraps a literal value, e.g. a string, a number, a date, with an optional annotation.
  * Used for properties where the value itself may be uncertain,

package/lib/model/Assumption.js

@@ -19,10 +19,47 @@ export const certainties = [
  */
 export const isAsserted = (certainty) => certainty === 'true' || certainty === 'likely';
 /**
- * The certainty a statement is held with. One that carries no belief is stated plainly, and so held true.
+ * The certainty a statement is held with for itself. One that carries
+ * no belief is stated plainly, and so held true; one that belongs to a
+ * proposition set is held with the set's belief, which `certaintyIn`
+ * reads.
  * @category Assumptions and beliefs
  */
-export const certaintyOf = (assumption) => assumption['@annotation']?.belief.certainty ?? 'true';
+export const certaintyOf = (assumption) => assumption['@annotation']?.belief?.certainty ?? 'true';
+/**
+ * Whether the statement carries a belief of its own, rather than none
+ * or the belief of the proposition set it belongs to.
+ * @category Assumptions and beliefs
+ */
+export const isHeldForItself = (assumption) => assumption['@annotation']?.belief !== undefined;
+/**
+ * The id of the proposition set the statement belongs to, where its
+ * annotation names one instead of carrying a belief.
+ * @category Assumptions and beliefs
+ */
+export const propositionSetOf = (assumption) => {
+    const annotation = assumption['@annotation'];
+    return annotation && annotation.belief === undefined ? annotation.id : undefined;
+};
+/**
+ * The belief the statement is held with in the edition: its own, or
+ * that of the proposition set it belongs to.
+ * @category Assumptions and beliefs
+ */
+export const beliefIn = (edition, assumption) => {
+    const own = assumption['@annotation']?.belief;
+    if (own)
+        return own;
+    const set = propositionSetOf(assumption);
+    return set === undefined ? undefined : edition.propositionSets?.find(candidate => candidate.id === set)?.belief;
+};
+/**
+ * The certainty the statement is held with in the edition: that of its
+ * own belief, or of the proposition set it belongs to. One that carries
+ * neither is stated plainly, and so held true.
+ * @category Assumptions and beliefs
+ */
+export const certaintyIn = (edition, assumption) => beliefIn(edition, assumption)?.certainty ?? 'true';
 /**
  * The value the assumption holds, without the belief about it.
  * @category Assumptions and beliefs

package/lib/model/Edit.d.ts

@@ -2,7 +2,10 @@ import { Assumption } from "./Assumption.js";
 import { AnySymbol } from "./Symbol.js";
 import { WithId } from "../shared/utils.js";
 /**
- * The types of editorial change an edit may state.
+ * The types of editorial change an edit may state. Each is read off the
+ * shape of the change, as `proposeEdits` reads it. Whether a change
+ * corrects an error is not: it is a reason for the change, and stated as
+ * its motivation (`correctedError`).
  * @category Vocabulary
  */
 export declare const editTypes: readonly ['additional-accent', 'add-redundancy', 'remove-redundancy', 
@@ -12,11 +15,12 @@ export declare const editTypes: readonly ['additional-accent', 'add-redundancy',
  * a command the other system cannot read struck, or one of its own
  * put in where the first had no word for it.
  */
-'recoding', 'shift', 'correct-error', 'shorten', 'prolong'];
+'recoding', 'shift', 'shorten', 'prolong'];
 /**
  * The type of editorial change applied to a symbol or set of symbols.
- * Classifies the nature of the edit, e.g. whether it corrects an error,
- * adds an accent, shifts a note, or shortens/prolongs a perforation.
+ * Classifies the shape of the edit, e.g. whether it adds an accent,
+ * shifts a note, or shortens/prolongs a perforation. Why it was made is
+ * its motivation.
  * @category Format types
  */
 export type EditType = typeof editTypes[number];
@@ -24,7 +28,7 @@ export type EditType = typeof editTypes[number];
  * A set of edits transforms a version of a roll into another version.
  * Edits insert or delete symbols, or both (= replace).
  * Edits may be motivated by a given set of reasons, e.g.
- * to add an additional accent or to correct an error.
+ * to strengthen an accent or to correct an error.
  * If an edit is the interpretation of a metamark,
  * such as a pencil mark, this should be made explicit
  * using a meaning comprehension on the `@annotation` field.
@@ -38,7 +42,7 @@ export type EditType = typeof editTypes[number];
 export interface Edit extends WithId, Assumption {
     type: 'edit';
     /**
-     * The type of editorial change (e.g. 'correct-error', 'additional-accent').
+     * The type of editorial change, as its shape shows it (e.g. 'shift', 'additional-accent').
      * @see crm:P2 has type
      */
     editType?: EditType;

package/lib/model/Edit.js

@@ -1,5 +1,8 @@
 /**
- * The types of editorial change an edit may state.
+ * The types of editorial change an edit may state. Each is read off the
+ * shape of the change, as `proposeEdits` reads it. Whether a change
+ * corrects an error is not: it is a reason for the change, and stated as
+ * its motivation (`correctedError`).
  * @category Vocabulary
  */
 export const editTypes = [
@@ -14,7 +17,6 @@ export const editTypes = [
      */
     'recoding',
     'shift',
-    'correct-error',
     'shorten',
     'prolong',
 ];

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