linked-rolls 0.75.0 → 0.76.0

package/lib/io/asJsonLd.js

@@ -97,57 +97,42 @@ 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, or the
- * belief of the proposition set it belongs to is.
+ * nothing RDF would read besides, and its belief is below likely.
  */
-const isDoubtedReference = (value, doubted) => isRecord(value)
+const isDoubtedReference = (value) => isRecord(value)
     && typeof value['@id'] === 'string'
     && isRecord(value['@annotation'])
-    && (!isAsserted(certaintyOf(value)) || doubtedSetOf(value, doubted) !== undefined)
+    && !isAsserted(certaintyOf(value))
     && 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. A statement that belongs to
- * a proposition set names the set's belief by its id, which is stated
- * with the set.
+ * read, so that an import can put it back.
  */
-const quote = (subject, key, reference, listed, doubted) => {
+const quote = (subject, key, reference, listed) => {
     const { '@annotation': { '@id': annotation, ...about }, ...object } = reference;
-    const set = doubtedSetOf(reference, doubted);
     return {
         '@id': { '@id': subject, [key]: listed ? [object] : object },
         annotation,
-        ...about,
-        ...(set !== undefined && { belief: { '@id': doubted.get(set) } })
+        ...about
     };
 };
 /** The value a node states under a key, less the doubted references, which go to the quoted. */
-const unquoted = (subject, key, value, quoted, doubted) => {
+const unquoted = (subject, key, value, quoted) => {
     if (Array.isArray(value)) {
         return value.filter(item => {
-            if (!isDoubtedReference(item, doubted))
+            if (!isDoubtedReference(item))
                 return true;
-            quoted.push(quote(subject, key, item, true, doubted));
+            quoted.push(quote(subject, key, item, true));
             return false;
         });
     }
-    if (!isDoubtedReference(value, doubted))
+    if (!isDoubtedReference(value))
         return value;
-    quoted.push(quote(subject, key, value, false, doubted));
+    quoted.push(quote(subject, key, value, false));
     return undefined;
 };
 /**
@@ -160,16 +145,16 @@ const unquoted = (subject, key, value, quoted, doubted) => {
  * 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, doubted) => {
+const withDoubtedReferencesQuoted = (value, quoted) => {
     if (Array.isArray(value))
-        return value.map(item => withDoubtedReferencesQuoted(item, quoted, doubted));
+        return value.map(item => withDoubtedReferencesQuoted(item, quoted));
     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, doubted) : child;
-        const below = withDoubtedReferencesQuoted(stated, quoted, doubted);
+        const stated = typeof subject === 'string' && !key.startsWith('@') ? unquoted(subject, key, child, quoted) : child;
+        const below = withDoubtedReferencesQuoted(stated, quoted);
         if (below !== undefined)
             node[key] = below;
     });
@@ -186,16 +171,12 @@ 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, 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.
+ * a fact. 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, doubtedSetsOf(edition));
+    const node = withDoubtedReferencesQuoted(withSystemContexts(withCreations(withChanges(asJsonLdEntity(atOwnPlacesAll(edition))))), quoted);
     // 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

@@ -1,7 +1,9 @@
 import { derivedKeys } from "./asJsonLd.js";
-import { migrate, plainCopyId } from "./migrate.js";
+import { migrate, plainCopyId, uncheckedMotivation } from "./migrate.js";
 import { isDateString } from "../shared/utils.js";
 import { putOnAxis } from "../collation/alignment.js";
+import { editsOf } from "../model/Version.js";
+import { motivationOfChanges, proposedMotivations } from "../filiation/edits.js";
 import schema from "../schema.json" with { type: 'json' };
 export const importDate = (str) => {
     const [y, m, d] = str.split('-').map(s => parseInt(s, 10));
@@ -84,14 +86,15 @@ const withoutEmptyCreations = (json) => Array.isArray(json.versions)
 /** 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';
 /**
- * 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.
+ * A belief named by its id alone, as a quoted statement of a document
+ * written before 0.76 named the belief of the proposition set it
+ * belonged to, which was stated with the set (`migrate`).
  */
 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.
+ * the export set beside it, or where it belonged to a proposition set,
+ * naming the set again for `migrate` to resolve.
  */
 const referenceOf = (statement) => {
     const { '@id': { '@id': subject, ...made }, annotation, ...stated } = statement;
@@ -153,5 +156,29 @@ export const importJsonLd = (json) => {
         ? context.find((c) => c['@base'])?.['@base'] || ''
         : '';
     (edition.copies ?? []).forEach(putOnAxis);
-    return edition;
+    return withKindsReadOffShapes(edition);
+};
+/**
+ * Gives an edit that a document written before 0.76 left unchecked the
+ * motivation its shape calls for, read in the edition as it stands: the
+ * generic musical one or the technical one (`migrate`). The
+ * shapes are read off a copy, since what reads an edition settles it
+ * for good, and the edition an import returns is the caller's to change.
+ */
+const withKindsReadOffShapes = (edition) => {
+    if (!(edition.versions ?? []).some(version => editsOf(version).some(edit => edit.motivation === uncheckedMotivation)))
+        return edition;
+    const probe = structuredClone(edition);
+    const versions = edition.versions.map(version => {
+        if (!editsOf(version).some(edit => edit.motivation === uncheckedMotivation))
+            return version;
+        const motivations = proposedMotivations(probe, version.id);
+        return {
+            ...version,
+            edits: editsOf(version).map(edit => edit.motivation === uncheckedMotivation
+                ? { ...edit, motivation: motivationOfChanges(motivations, [...(edit.insert ?? []).map(symbol => symbol.id), ...(edit.delete ?? [])]) }
+                : edit)
+        };
+    });
+    return { ...edition, versions };
 };

package/lib/io/migrate.d.ts

@@ -13,6 +13,13 @@
 type Json = any;
 /** A copy's id without the `copy/` that documents of earlier releases put before it. */
 export declare const plainCopyId: (id: string) => string;
+/**
+ * The motivation an edit of a version that derives from another is left
+ * with where only the edition can tell what kind of change it is: one
+ * that states neither a kind nor a reason, as a collation once left
+ * them. `importJsonLd` reads its kind off its shape (`proposedMotivations`).
+ */
+export declare const uncheckedMotivation = "unchecked";
 /**
  * Brings the JSON of an edition written by an earlier release of the
  * format up to the current shape. A document that is current already

package/lib/io/migrate.js

@@ -4,6 +4,7 @@ import { trackerBars } from "../systems/index.js";
 import { welteT100 } from "../systems/welteT100/bar.js";
 import { isDateString } from "../shared/utils.js";
 import { mapped, withValues } from "../ops/immutable.js";
+import { musicalChange, technicalChange } from "../model/Edit.js";
 const retiredVersionTypes = new Set(['edition', 'unicum']);
 /**
  * The vocabulary the steps below were written against, as it stood in
@@ -76,7 +77,9 @@ const isTypedCorrectError = (edit) => edit !== null && typeof edit === 'object'
  * 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.
+ * way it states no kind, its shape being left to be read again. Once
+ * motivations are the edition's, a corrected error is a musical change
+ * (`withMotivationsOfTheEdition`).
  */
 const withCorrectedErrorsMotivated = (node) => {
     if (!Array.isArray(node.edits) || !node.edits.some(isTypedCorrectError))
@@ -706,6 +709,168 @@ const withReferenceCopy = (edition) => {
         : edition;
 };
 const editionSteps = [withoutFormatVersion, withoutTempoAdjustment, withoutEditionType, withSystems, withEditors, withDerivationTolerance, withReferenceCopy];
+/**
+ * The motivation an edit of a version that derives from another is left
+ * with where only the edition can tell what kind of change it is: one
+ * that states neither a kind nor a reason, as a collation once left
+ * them. `importJsonLd` reads its kind off its shape (`proposedMotivations`).
+ */
+export const uncheckedMotivation = 'unchecked';
+/** The kinds of edit, as they were stated once, whose shape is a musical decision. */
+const musicalEditTypes = new Set(['additional-accent', 'shift', 'shorten', 'prolong']);
+/** The kinds of edit, as they were stated once, whose shape is a technical change. */
+const technicalEditTypes = new Set(['recoding', 'remove-redundancy', 'add-redundancy']);
+const isRecord = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+/** Whether the version derives from another, so that its edits are changes rather than its text. */
+const derives = (version) => Array.isArray(version?.basedOn) ? version.basedOn.length > 0 : version?.basedOn !== undefined;
+/**
+ * The motivation an edit states once motivations say what kind of
+ * change it is, from the kind it was given and the reason it gave.
+ */
+const motivationOfEdit = (editType, motivation, derived) => {
+    // A corrected error put back a perforation in its place, and so made a musical change.
+    const stated = motivation === 'corrected-error' ? musicalChange : motivation;
+    if (!derived)
+        return stated === uncheckedMotivation || stated === musicalChange ? undefined : stated;
+    const technical = typeof editType === 'string' && technicalEditTypes.has(editType);
+    // A reason given for a technical change explained what the change or the procedure says already.
+    if (technical)
+        return technicalChange;
+    if (stated === undefined || stated === uncheckedMotivation) {
+        return typeof editType === 'string' && musicalEditTypes.has(editType) ? musicalChange : uncheckedMotivation;
+    }
+    return stated;
+};
+/** Whether the document still states what motivations and kinds of edit were before 0.76. */
+const statesMotivationsPerVersion = (versions) => versions.some(version => Array.isArray(version?.motivations)
+    || (Array.isArray(version?.edits) && version.edits.some((edit) => isRecord(edit) && (Object.hasOwn(edit, 'editType') || edit.motivation === 'corrected-error'))));
+/**
+ * Before 0.76 each version stated the motivations its edits named, and
+ * an edit stated its kind beside its reason. The motivations are the
+ * edition's now, once each, and the motivation alone says what kind of
+ * change an edit is (`kindOfChange`):
+ *
+ * - A motivation two versions stated under one id with different notes
+ *   is kept under an id of its own for the second.
+ * - The unchecked motivation goes, and so does the declaration of a
+ *   corrected error: it put a perforation back in its place, and so is
+ *   a musical change whose reason is not given.
+ * - An edit of a version that derives from another, that gave no reason
+ *   or only that it was unchecked, is a musical change whose reason is
+ *   not given where its kind was an added accent, a shift, a shortening
+ *   or a prolongation, and a technical change where it was a recoding or
+ *   a redundancy removed or added. One that stated no kind is left
+ *   unchecked, for an import to read its kind off its shape.
+ * - A reason given for a recoding or a redundancy goes, since a
+ *   technical change needs none, and a motivation nothing names any
+ *   longer goes with it. Every other reason stays, and makes the change
+ *   a musical one.
+ * - The edits of a version that derives from none state its text and
+ *   keep no motivation but a reason someone gave.
+ */
+const withMotivationsOfTheEdition = (edition) => {
+    const versions = listAt(edition, 'versions');
+    if (!versions || !statesMotivationsPerVersion(versions))
+        return edition;
+    const notes = new Map((listAt(edition, 'motivations') ?? []).filter(isRecord).map(motivation => [motivation['@id'], motivation]));
+    const referencedBefore = new Set();
+    const migrated = versions.map((version, index) => {
+        if (!isRecord(version))
+            return version;
+        const renamed = new Map();
+        for (const motivation of Array.isArray(version.motivations) ? version.motivations.filter(isRecord) : []) {
+            const id = motivation['@id'];
+            if (typeof id !== 'string' || id === uncheckedMotivation || id === 'corrected-error')
+                continue;
+            const known = notes.get(id);
+            if (!known)
+                notes.set(id, motivation);
+            else if (known.note !== motivation.note) {
+                const own = `${id}-${index}`;
+                renamed.set(id, own);
+                notes.set(own, { ...motivation, '@id': own });
+            }
+        }
+        const derived = derives(version);
+        const { motivations: _declared, ...rest } = version;
+        if (!Array.isArray(version.edits))
+            return rest;
+        return {
+            ...rest,
+            edits: version.edits.map((edit) => {
+                if (!isRecord(edit))
+                    return edit;
+                const { editType, motivation: given, ...stated } = edit;
+                const named = typeof given === 'string' ? renamed.get(given) ?? given : given;
+                if (typeof named === 'string')
+                    referencedBefore.add(named);
+                const motivation = motivationOfEdit(editType, named, derived);
+                return motivation === undefined ? stated : { ...stated, motivation };
+            })
+        };
+    });
+    const referenced = new Set(migrated.flatMap((version) => (Array.isArray(version?.edits) ? version.edits : []).map((edit) => edit?.motivation).filter((id) => typeof id === 'string')));
+    const motivations = [...notes.values()].filter(motivation => referenced.has(motivation['@id']) || !referencedBefore.has(motivation['@id']));
+    const { motivations: _stated, ...rest } = edition;
+    return { ...rest, versions: migrated, ...(motivations.length > 0 && { motivations }) };
+};
+/**
+ * Before 0.76 an adopted proposal was recorded as a proposition set: each
+ * statement of it named the set in its annotation, and the set held them
+ * under one belief whose inference named the release that found them and
+ * the rules it followed. The edition states what a program concluded
+ * plainly now, and its creation names the rules among its principles and
+ * the release among its software. A statement of a set the edition held
+ * below likely keeps the doubt, under a belief of its own that is the
+ * set's.
+ */
+const withoutPropositionSets = (edition) => {
+    const sets = listAt(edition, 'propositionSets');
+    if (!sets)
+        return edition;
+    const beliefOf = new Map(sets.filter(isRecord).map(set => [set['@id'], set.belief]));
+    const inferences = sets.filter(isRecord).flatMap(set => Array.isArray(set.belief?.reasons) ? set.belief.reasons : []);
+    const rules = inferences.flatMap(inference => Array.isArray(inference?.applies) ? inference.applies : []);
+    const programs = inferences.flatMap(inference => Array.isArray(inference?.software) ? inference.software : []);
+    let held = 0;
+    const unset = (value) => {
+        if (Array.isArray(value))
+            return mapped(value, unset);
+        if (!isRecord(value))
+            return value;
+        const annotation = value['@annotation'];
+        const set = isRecord(annotation) && typeof annotation['@id'] === 'string' ? beliefOf.get(annotation['@id']) : undefined;
+        if (!set || (isRecord(annotation.belief) && Object.keys(annotation.belief).some(key => key !== '@id')))
+            return withValues(value, unset);
+        const { '@annotation': _member, ...rest } = value;
+        if (set.certainty === 'true' || set.certainty === 'likely')
+            return withValues(rest, unset);
+        held += 1;
+        return withValues({
+            ...rest,
+            '@annotation': { '@id': `${annotation['@id']}/${held}`, belief: { ...set, '@id': `${set['@id']}/${held}` } }
+        }, unset);
+    };
+    const { propositionSets: _recorded, ...rest } = edition;
+    const unsetted = unset(rest);
+    const creation = isRecord(unsetted.creation) ? unsetted.creation : undefined;
+    if (!creation)
+        return unsetted;
+    const principles = [...new Set([...(Array.isArray(creation.principles) ? creation.principles : []), ...rules])];
+    const known = Array.isArray(creation.software) ? creation.software : [];
+    const software = [...known, ...programs.filter((program, index) => !known.some((other) => other?.name === program?.name && other?.version === program?.version)
+            && programs.findIndex(other => other?.name === program?.name && other?.version === program?.version) === index)];
+    return {
+        ...unsetted,
+        creation: {
+            ...creation,
+            ...(principles.length > 0 && { principles }),
+            ...(software.length > 0 && { software })
+        }
+    };
+};
+/** Steps that read the document as the node steps leave it, an old document's kinds of edit renamed. */
+const finalSteps = [withoutPropositionSets, withMotivationsOfTheEdition];
 /**
  * Brings the JSON of an edition written by an earlier release of the
  * format up to the current shape. A document that is current already
@@ -714,4 +879,4 @@ const editionSteps = [withoutFormatVersion, withoutTempoAdjustment, withoutEditi
  * to look at an old document as JSON.
  * @category Reading and writing
  */
-export const migrate = (edition) => walk(editionSteps.reduce((result, step) => step(result), edition));
+export const migrate = (edition) => finalSteps.reduce((result, step) => step(result), walk(editionSteps.reduce((result, step) => step(result), edition)));

package/lib/model/Agent.d.ts

@@ -107,7 +107,9 @@ export type Concept = (WithId & Partial<Named>) | (Named & Partial<WithId>);
 /**
  * Software that captured a copy or measured it: the transcriber that
  * read a recording into notes, the emulator that wrote a MIDI file, the
- * program that found the holes on a scan or aligned two copies.
+ * program that found the holes on a scan or aligned two copies. Or the
+ * software an edition was made with, such as the release of this
+ * library that found its stemma.
  * @see crmdig:D14 Software
  * @category Format types
  */

package/lib/model/Assumption.d.ts

@@ -21,10 +21,8 @@ export type Certainty = typeof certainties[number];
  */
 export declare const isAsserted: (certainty: Certainty) => boolean;
 /**
- * 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.
+ * The certainty a statement is held with. One that carries no belief is
+ * stated plainly, and so held true.
  * @category Assumptions and beliefs
  */
 export declare const certaintyOf: (assumption: Readonly<Assumption>) => Certainty;
@@ -93,24 +91,6 @@ 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:
@@ -224,76 +204,20 @@ export interface 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.
+     * A statement that carries none is stated plainly, and what a
+     * program concluded is stated so too: an edition asserts its stemma
+     * and its edits, as a printed edition does, and its creation names
+     * the principles and the release they were found by
+     * (`EditionCreation`). A belief is kept for what the editor doubts.
      */
     '@annotation'?: WithId & {
         /**
-         * The belief held about the annotated statement, where it is
-         * held for itself rather than as one of a proposition set.
+         * The belief held about the annotated statement.
          * @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,47 +19,11 @@ export const certainties = [
  */
 export const isAsserted = (certainty) => certainty === 'true' || certainty === 'likely';
 /**
- * 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.
+ * The certainty a statement is held with. One that carries no belief is
+ * stated plainly, and so held true.
  * @category Assumptions and beliefs
  */
-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';
+export const certaintyOf = (assumption) => assumption['@annotation']?.belief.certainty ?? 'true';
 /**
  * The value the assumption holds, without the belief about it.
  * @category Assumptions and beliefs