linked-rolls 0.70.0 → 0.72.0

package/lib/model/RollCopy.js

@@ -2,11 +2,19 @@ import { v4 } from "uuid";
 import { defaultTrackerBar, trackerBarOf } from "../systems/index.js";
 import { assignReference, certaintyOf, isAsserted } from "./Assumption.js";
 import { px, track } from "./Quantity.js";
+/**
+ * The kinds of condition a copy may be stated to be in.
+ * @category Vocabulary
+ */
 export const rollConditions = [
     'general',
     'paper-stretch',
     'torn'
 ];
+/**
+ * What a modification of a copy may have been for.
+ * @category Vocabulary
+ */
 export const modificationPurposes = [
     'musical-improvement',
     'technical-improvement',
@@ -16,49 +24,81 @@ export const modificationPurposes = [
     'dating',
     'glossing'
 ];
-/** What an act brought onto the copy: what it produced or glued on, a removal nothing. */
+/**
+ * What an act brought onto the copy: what it produced or glued on, a removal nothing.
+ * @category Lookups
+ */
 export const featuresMadeBy = (modification) => {
     if (modification.type === 'Alteration')
         return modification.produced;
     return modification.type === 'Attachment' ? modification.added : [];
 };
-/** Whether the act is one that modified the copy, rather than the production that punched it. */
+/**
+ * Whether the act is one that modified the copy, rather than the production that punched it.
+ * @category Lookups
+ */
 export const isModification = (act) => 'type' in act;
-/** Whether the act is left stating nothing: it produced, added or removed nothing. */
+/**
+ * Whether the act is left stating nothing: it produced, added or removed nothing.
+ * @category Lookups
+ */
 export const statesNothing = (modification) => modification.type === 'Removal' ? modification.removed.length === 0 : featuresMadeBy(modification).length === 0;
 /**
  * The features of the copy act by act: what the punching produced
  * first, then what each modification produced or glued on. A feature a
  * patch bears states no place of its own and is not among them;
  * `withBorneFeatures` reaches those.
+ * @category Lookups
  */
 export const featuresByAct = (copy) => [copy.production?.produced ?? [], ...copy.modifications.map(featuresMadeBy)];
-/** Every feature the copy states at a place of its own, whichever act made it. */
+/**
+ * Every feature the copy states at a place of its own, whichever act made it.
+ * @category Lookups
+ */
 export const featuresOf = (copy) => featuresByAct(copy).flat();
 /** The measurements of a copy the edition exports, each of which can say what took it. */
 const exportedMeasurementsOf = (copy) => [copy.measurements.dimensions, copy.measurements.holeSeparation, copy.measurements.scanResolution]
     .filter(value => value !== undefined);
-/** The programs the measurements of a copy name as having taken them, each once, as far as they name any. */
+/**
+ * The programs the measurements of a copy name as having taken them, each once, as far as they name any.
+ * @category Lookups
+ */
 export const measuringSoftwareOf = (copy) => {
     const named = exportedMeasurementsOf(copy)
         .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()];
 };
-/** Whether the condition is the stretch or shrinkage of the paper, as measured on the copy. */
+/**
+ * Whether the condition is the stretch or shrinkage of the paper, as measured on the copy.
+ * @category Lookups
+ */
 export const isPaperStretch = (condition) => condition.conditionType === 'paper-stretch';
-/** What the copy's paper was measured to have done, where anything was measured. */
+/**
+ * What the copy's paper was measured to have done, where anything was measured.
+ * @category Lookups
+ */
 export const paperStretchOf = (copy) => copy.conditions.find(isPaperStretch);
-/** Whether the condition is a tear in the paper. */
+/**
+ * Whether the condition is a tear in the paper.
+ * @category Lookups
+ */
 export const isTear = (condition) => condition.conditionType === 'torn';
-/** The tears the copy is stated to have. */
+/**
+ * The tears the copy is stated to have.
+ * @category Lookups
+ */
 export const tearsOf = (copy) => copy.conditions.filter(isTear);
 /**
  * The bar a copy is read by, which is the one it was cut for. A copy
  * that names no system falls back to `defaultTrackerBar`.
+ * @category Systems and emulation
  */
 export const barOf = (copy) => trackerBarOf(copy.production?.system) ?? defaultTrackerBar;
-/** The diameter of the punch the copy was cut with, where the edition holds it true or likely. */
+/**
+ * The diameter of the punch the copy was cut with, where the edition holds it true or likely.
+ * @category Lookups
+ */
 export const punchDiameterOf = (copy) => {
     const diameter = copy.production?.perforator?.condition?.punchDiameter;
     return diameter && isAsserted(certaintyOf(diameter)) ? diameter.value : undefined;
@@ -78,6 +118,7 @@ export const punchDiameterOf = (copy) => {
  * would be 318 notes nobody played. The features stay on the copy,
  * since they are really on the paper and are his calibration of his own
  * scan; it is the reading that stops.
+ * @category Sources
  */
 export function asSymbols(features, bar) {
     const chains = features.filter(feature => feature.type === 'HoleChain');
@@ -97,6 +138,7 @@ export function asSymbols(features, bar) {
  * A non-empty result usually means the scan is calibrated wrongly. A chain
  * lying across several positions is counted against each one the bar
  * cannot read, and not at all where it reads them all.
+ * @category Sources
  */
 export function unreadTracks(features, bar) {
     const counts = new Map();
@@ -116,6 +158,7 @@ export function unreadTracks(features, bar) {
  * were laid out with, and on the rolls measured so far it comes within
  * about a quarter of a track. It is kept for copies imported before the
  * calibration was written down; anything read since carries its own.
+ * @internal
  */
 export const calibrationOf = (copy) => {
     if (copy.measurements.trackCalibration) {

package/lib/model/Symbol.d.ts

@@ -5,6 +5,7 @@ import { WithId } from "../shared/utils.js";
  * physical features on the roll. Symbols are the result of interpreting
  * the physical features (chains of holes, writings, etc.) on the roll copies.
  * @see crm:E90 Symbolic Object
+ * @category Format types
  */
 export interface Symbol<T extends string> extends WithId {
     type: T;
@@ -18,7 +19,16 @@ export interface Symbol<T extends string> extends WithId {
      */
     carriers: ReferenceAssumption[];
 }
+/**
+ * Whether the object is a symbol: a note, an expression or a text.
+ * @category Lookups
+ */
 export declare const isSymbol: (object: any) => object is AnySymbol;
+/**
+ * Whether the symbol is a command, a note or an expression, rather than
+ * a text.
+ * @category Lookups
+ */
 export declare const isCommand: (symbol: object | undefined) => symbol is AnyCommand;
 /**
  * A command is what the tracker bar reads from a chain of holes: the
@@ -26,6 +36,7 @@ export declare const isCommand: (symbol: object | undefined) => symbol is AnyCom
  * by such a chain, but it might also have different physical
  * appearances.
  * @see reo:Command
+ * @category Format types
  */
 export interface Command<T extends string> extends Symbol<T> {
     /**
@@ -63,10 +74,24 @@ export interface Command<T extends string> extends Symbol<T> {
      */
     pairedWith?: ReferenceAssumption;
 }
+/**
+ * The ways a command may be placed relative to another, in the order
+ * `placementsOf` reports them.
+ * @category Vocabulary
+ */
 export declare const placementRelations: readonly ['alignedWith', 'before', 'after'];
-/** The ways a command may be placed relative to another. */
+/**
+ * The ways a command may be placed relative to another.
+ * @category Format types
+ */
 export type PlacementRelation = typeof placementRelations[number];
+/** @inline */
 type Placeable = Partial<Record<PlacementRelation, ReferenceAssumption>>;
+/**
+ * A statement placing a command relative to another: how, and relative
+ * to which.
+ * @category Format types
+ */
 export type Placement = {
     relation: PlacementRelation;
     reference: ReferenceAssumption;
@@ -75,20 +100,24 @@ export type Placement = {
  * The statements placing a command relative to others, alignment first.
  * A command is meant to make one at most; the first is the one a
  * performance applies.
+ * @category Lookups
  */
 export declare const placementsOf: (command: Placeable) => Placement[];
+/** @inline */
 type Pairable = WithId & {
     pairedWith?: ReferenceAssumption;
 };
 /**
  * The pairs among the given commands, each once and in the order the
  * pairing is stated. A pair whose partner is absent is left out.
+ * @category Lookups
  */
 export declare const pairsAmong: <S extends Pairable>(commands: readonly S[]) => [S, S][];
 /**
  * A note symbol, representing a single pitched musical event on the roll.
  * The pitch is encoded via the tracker bar position (track number).
  * @see reo:Note
+ * @category Format types
  */
 export interface Note extends Command<'note'> {
     /**
@@ -101,6 +130,7 @@ export interface Note extends Command<'note'> {
  * The scope of an expression command, indicating whether it applies to
  * the bass or treble register of the piano.
  * @see reo:scope
+ * @category Format types
  */
 export type ExpressionScope = 'bass' | 'treble';
 /**
@@ -109,6 +139,7 @@ export type ExpressionScope = 'bass' | 'treble';
  * than sounding a note. Each expression has a scope (bass or treble)
  * and a specific expression type.
  * @see reo:Expression
+ * @category Format types
  */
 export interface Expression extends Command<'expression'> {
     /**
@@ -128,6 +159,7 @@ export interface Expression extends Command<'expression'> {
 /**
  * A textual symbol, e.g. a label or annotation found on the roll.
  * @see crm:E33 Linguistic Object
+ * @category Format types
  */
 export interface Text extends Symbol<'text'> {
     type: 'text';
@@ -140,7 +172,12 @@ export interface Text extends Symbol<'text'> {
 /**
  * A symbol can be either a note, an expression, or a text.
  * Notes and expressions are commands; texts are carried by writings.
+ * @category Format types
  */
 export type AnySymbol = Note | Expression | Text;
+/**
+ * A command: a note or an expression.
+ * @category Format types
+ */
 export type AnyCommand = Note | Expression;
 export {};

package/lib/model/Symbol.js

@@ -1,14 +1,29 @@
 import { idOf } from "./Assumption.js";
+/**
+ * Whether the object is a symbol: a note, an expression or a text.
+ * @category Lookups
+ */
 export const isSymbol = (object) => {
     return ('type' in object
         && (object.type === 'note' || object.type === 'expression' || object.type === 'text'));
 };
+/**
+ * Whether the symbol is a command, a note or an expression, rather than
+ * a text.
+ * @category Lookups
+ */
 export const isCommand = (symbol) => symbol !== undefined && 'type' in symbol && (symbol.type === 'note' || symbol.type === 'expression');
+/**
+ * The ways a command may be placed relative to another, in the order
+ * `placementsOf` reports them.
+ * @category Vocabulary
+ */
 export const placementRelations = ['alignedWith', 'before', 'after'];
 /**
  * The statements placing a command relative to others, alignment first.
  * A command is meant to make one at most; the first is the one a
  * performance applies.
+ * @category Lookups
  */
 export const placementsOf = (command) => placementRelations.flatMap(relation => {
     const reference = command[relation];
@@ -17,6 +32,7 @@ export const placementsOf = (command) => placementRelations.flatMap(relation =>
 /**
  * The pairs among the given commands, each once and in the order the
  * pairing is stated. A pair whose partner is absent is left out.
+ * @category Lookups
  */
 export const pairsAmong = (commands) => {
     const byId = new Map(commands.map(p => [p.id, p]));

package/lib/model/TrackCalibration.d.ts

@@ -9,6 +9,7 @@ import { Pixels, Track } from "./Quantity.js";
  *
  *     column      = offset + scannerTrack * separation
  *     trackerBar  = scannerTrack + shift
+ * @category Format types
  */
 export interface TrackCalibration {
     unit: 'px';
@@ -19,13 +20,20 @@ export interface TrackCalibration {
     /** Added to the scanning software's numbering to reach the tracker bar. */
     shift: Track;
 }
-/** Image column at the centre of a tracker bar track. */
+/**
+ * Image column at the centre of a tracker bar track.
+ * @internal
+ */
 export declare const columnOf: (position: Track, calibration: TrackCalibration) => Pixels;
-/** Tracker bar track covering an image column, unrounded. */
+/**
+ * Tracker bar track covering an image column, unrounded.
+ * @internal
+ */
 export declare const trackAt: (column: Pixels, calibration: TrackCalibration) => Track;
 /**
  * The columns covered by a run of tracks, from the outer edge of the
  * first to the outer edge of the last.
+ * @internal
  */
 export declare const columnsOf: (from: Track, to: Track, calibration: TrackCalibration) => {
     from: Pixels;

package/lib/model/TrackCalibration.js

@@ -1,11 +1,18 @@
 import { px, subtract, track } from "./Quantity.js";
-/** Image column at the centre of a tracker bar track. */
+/**
+ * Image column at the centre of a tracker bar track.
+ * @internal
+ */
 export const columnOf = (position, calibration) => px(calibration.offset + (position - calibration.shift) * calibration.separation);
-/** Tracker bar track covering an image column, unrounded. */
+/**
+ * Tracker bar track covering an image column, unrounded.
+ * @internal
+ */
 export const trackAt = (column, calibration) => track((column - calibration.offset) / calibration.separation + calibration.shift);
 /**
  * The columns covered by a run of tracks, from the outer edge of the
  * first to the outer edge of the last.
+ * @internal
  */
 export const columnsOf = (from, to, calibration) => {
     const [lower, upper] = from <= to ? [from, to] : [to, from];

package/lib/model/Version.d.ts

@@ -8,6 +8,7 @@ import { WithId, WithNote, WithType } from "../shared/utils.js";
  * A motivation provides a reason or rationale for an editorial change.
  * Motivations are defined at the version level and referenced by edits.
  * @see crm:E33 Linguistic Object
+ * @category Format types
  */
 export type Motivation = WithType<'motivation'> & WithId & WithNote;
 /**
@@ -16,6 +17,7 @@ export type Motivation = WithType<'motivation'> & WithId & WithNote;
  * put a symbol depends on what they are and on how their features were
  * obtained, so the tolerance can differ from derivation to derivation.
  * @see lrmoo:R76 is derivative of
+ * @category Format types
  */
 export type Derivation = ReferenceAssumption & {
     /**
@@ -31,13 +33,17 @@ export type Derivation = ReferenceAssumption & {
      */
     collationTolerance?: ObjectAssumption<CollationTolerance>;
 };
-/** The tolerance the derivation was collated at, or the default where it states none. */
+/**
+ * The tolerance the derivation was collated at, or the default where it states none.
+ * @category Collation and alignment
+ */
 export declare const collationToleranceOf: (derivation: Readonly<Derivation>) => CollationTolerance;
 /**
  * How long a version's paper runs for a length of the paper of the
  * version it derives from: about 0.77 for a Licensee or green re-cut of
  * a red roll, cut for a slower paper speed.
  * @see crm:E54 Dimension
+ * @category Format types
  */
 export interface LengthRatio {
     /**
@@ -60,6 +66,7 @@ export interface LengthRatio {
  * the version's edits carry it out, so the mechanical part of a
  * transfer is stated once instead of being spelled out per note.
  * @see lrmoo:F28 Expression Creation
+ * @category Format types
  */
 export interface VersionCreation {
     /**
@@ -100,6 +107,7 @@ export interface VersionCreation {
  * sigla off the stemma, so that a label never outlives the arrangement
  * it describes.
  * @see lrmoo:F2 Expression
+ * @category Format types
  */
 export interface Version extends WithId {
     /**
@@ -145,15 +153,25 @@ export interface Version extends WithId {
      */
     motivations: Motivation[];
 }
-/** The edits the version states, none where it leaves its text unstated. */
+/**
+ * The edits the version states, none where it leaves its text unstated.
+ * @category Versions and stemma
+ */
 export declare const editsOf: (version: Readonly<Version>) => Edit[];
-/** The symbols the version's edits insert. */
+/**
+ * The symbols the version's edits insert.
+ * @category Versions and stemma
+ */
 export declare const insertedBy: (version: Readonly<Version>) => AnySymbol[];
-/** The ids of the symbols the version's edits delete. */
+/**
+ * The ids of the symbols the version's edits delete.
+ * @category Versions and stemma
+ */
 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.
+ * @category Versions and stemma
  */
 export declare const derivationsOf: (version: Readonly<Version>) => {
     parent: string;
@@ -165,6 +183,7 @@ export declare const derivationsOf: (version: Readonly<Version>) => {
  * held most certain. One held unlikely or false is a rejected hypothesis
  * and gives no text. Lowering the certainty of the principal derivation
  * below another's reads the version's edits against another parent.
+ * @category Versions and stemma
  */
 export declare const principalDerivationOf: (version: Readonly<Version>) => Readonly<Derivation> | undefined;
 /**
@@ -173,5 +192,6 @@ export declare const principalDerivationOf: (version: Readonly<Version>) => Read
  * among them: a hypothesis held more certain becomes the principal one.
  * A version derives from itself in no statement, and a stemma that
  * loops is walked once round.
+ * @category Versions and stemma
  */
 export declare const derivesFrom: (versions: readonly Readonly<Version>[], versionId: string, ancestorId: string) => boolean;

package/lib/model/Version.js

@@ -1,16 +1,29 @@
 import { certainties, certaintyOf, idOf } from "./Assumption.js";
 import { defaultCollationTolerance } from "../collation/Collation.js";
-/** The tolerance the derivation was collated at, or the default where it states none. */
+/**
+ * The tolerance the derivation was collated at, or the default where it states none.
+ * @category Collation and alignment
+ */
 export const collationToleranceOf = (derivation) => derivation.collationTolerance ?? defaultCollationTolerance;
-/** The edits the version states, none where it leaves its text unstated. */
+/**
+ * The edits the version states, none where it leaves its text unstated.
+ * @category Versions and stemma
+ */
 export const editsOf = (version) => version.edits ?? [];
-/** The symbols the version's edits insert. */
+/**
+ * The symbols the version's edits insert.
+ * @category Versions and stemma
+ */
 export const insertedBy = (version) => editsOf(version).flatMap(edit => edit.insert ?? []);
-/** The ids of the symbols the version's edits delete. */
+/**
+ * The ids of the symbols the version's edits delete.
+ * @category Versions and stemma
+ */
 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.
+ * @category Versions and stemma
  */
 export const derivationsOf = (version) => (version.basedOn ?? []).map(derivation => {
     const belief = derivation['@annotation']?.belief;
@@ -22,6 +35,7 @@ const rankOf = (derivation) => certainties.indexOf(certaintyOf(derivation));
  * held most certain. One held unlikely or false is a rejected hypothesis
  * and gives no text. Lowering the certainty of the principal derivation
  * below another's reads the version's edits against another parent.
+ * @category Versions and stemma
  */
 export const principalDerivationOf = (version) => (version.basedOn ?? [])
     .filter(derivation => rankOf(derivation) <= certainties.indexOf('possible'))
@@ -32,6 +46,7 @@ export const principalDerivationOf = (version) => (version.basedOn ?? [])
  * among them: a hypothesis held more certain becomes the principal one.
  * A version derives from itself in no statement, and a stemma that
  * loops is walked once round.
+ * @category Versions and stemma
  */
 export const derivesFrom = (versions, versionId, ancestorId) => {
     const byId = new Map(versions.map(version => [version.id, version]));

package/lib/model/notes.d.ts

@@ -1,3 +1,9 @@
+/**
+ * A piece of a note as it is shown: a stretch of text, or a reference
+ * to an entity by its id, with the words the note puts in its place
+ * where it gives any.
+ * @category Format types
+ */
 export type NotePart = {
     type: 'text';
     text: string;
@@ -6,14 +12,21 @@ export type NotePart = {
     id: string;
     label?: string;
 };
-/** The note in the pieces it is shown in: stretches of text and what they refer to. */
+/**
+ * The note in the pieces it is shown in: stretches of text and what they refer to.
+ * @category Lookups
+ */
 export declare const partsOfNote: (note: string) => NotePart[];
-/** The ids a note refers to, in the order it names them. */
+/**
+ * The ids a note refers to, in the order it names them.
+ * @category Lookups
+ */
 export declare const referencesInNote: (note: string) => string[];
 /**
  * The note as it reads, with every reference resolved to the name the
  * edition gives that entity, or to the words the note puts in its place.
  * A reference nothing answers to keeps its id, so that the gap is visible
  * rather than silent.
+ * @category Lookups
  */
 export declare const resolveNote: (note: string, nameOf: (id: string) => string | undefined) => string;

package/lib/model/notes.js

@@ -10,7 +10,10 @@
  * still follows the stemma and a written-out label cannot freeze it.
  */
 const reference = /\{\{\s*([^{}|\s]+)\s*(?:\|([^{}]*))?\}\}/g;
-/** The note in the pieces it is shown in: stretches of text and what they refer to. */
+/**
+ * The note in the pieces it is shown in: stretches of text and what they refer to.
+ * @category Lookups
+ */
 export const partsOfNote = (note) => {
     const parts = [];
     let read = 0;
@@ -26,13 +29,17 @@ export const partsOfNote = (note) => {
         parts.push({ type: 'text', text: note.slice(read) });
     return parts;
 };
-/** The ids a note refers to, in the order it names them. */
+/**
+ * The ids a note refers to, in the order it names them.
+ * @category Lookups
+ */
 export const referencesInNote = (note) => partsOfNote(note).flatMap(part => part.type === 'reference' ? [part.id] : []);
 /**
  * The note as it reads, with every reference resolved to the name the
  * edition gives that entity, or to the words the note puts in its place.
  * A reference nothing answers to keeps its id, so that the gap is visible
  * rather than silent.
+ * @category Lookups
  */
 export const resolveNote = (note, nameOf) => partsOfNote(note)
     .map(part => part.type === 'text' ? part.text : nameOf(part.id) ?? part.label ?? part.id)

package/lib/model/procedures.d.ts

@@ -8,7 +8,11 @@ import { Concept } from "./Agent.js";
  * `ontology/types.ttl` is the place a procedure is defined. A test holds
  * this list against it.
  * @see crm:E29 Design or Procedure
+ * @category Vocabulary
  */
 export declare const procedures: readonly Concept[];
-/** The procedure of that IRI, where the vocabulary declares one. */
+/**
+ * The procedure of that IRI, where the vocabulary declares one.
+ * @category Vocabulary
+ */
 export declare const procedureOf: (id: string | undefined) => Concept | undefined;

package/lib/model/procedures.js

@@ -8,6 +8,7 @@ const PROCEDURE_IRI = 'https://w3id.org/reo/type/procedure/';
  * `ontology/types.ttl` is the place a procedure is defined. A test holds
  * this list against it.
  * @see crm:E29 Design or Procedure
+ * @category Vocabulary
  */
 export const procedures = [
     {
@@ -26,5 +27,8 @@ export const procedures = [
         sameAs: []
     }
 ];
-/** The procedure of that IRI, where the vocabulary declares one. */
+/**
+ * The procedure of that IRI, where the vocabulary declares one.
+ * @category Vocabulary
+ */
 export const procedureOf = (id) => procedures.find(procedure => procedure.id === id);

package/lib/model/vocabulary.d.ts

@@ -3,13 +3,18 @@ import { Concept } from "./Agent.js";
  * The concepts the type vocabulary declares, whatever kind they are:
  * the reproducing systems, the procedures and the drives of a
  * perforator. An edition names one of them by its IRI alone.
+ * @category Vocabulary
  */
 export declare const vocabulary: readonly Concept[];
-/** The concept of that IRI, where the vocabulary declares one. */
+/**
+ * The concept of that IRI, where the vocabulary declares one.
+ * @category Vocabulary
+ */
 export declare const conceptOf: (id: string | undefined) => Concept | undefined;
 /**
  * What a concept is called: the name it states, else the one the
  * vocabulary gives it, else its IRI, so that a reader always has
  * something to show.
+ * @category Vocabulary
  */
 export declare const nameOf: (concept: Concept) => string;

package/lib/model/vocabulary.js

@@ -6,17 +6,22 @@ import { trackerBars } from "../systems/index.js";
  * The concepts the type vocabulary declares, whatever kind they are:
  * the reproducing systems, the procedures and the drives of a
  * perforator. An edition names one of them by its IRI alone.
+ * @category Vocabulary
  */
 export const vocabulary = [
     ...trackerBars.map(systemOf),
     ...procedures,
     ...drives
 ];
-/** The concept of that IRI, where the vocabulary declares one. */
+/**
+ * The concept of that IRI, where the vocabulary declares one.
+ * @category Vocabulary
+ */
 export const conceptOf = (id) => id === undefined ? undefined : vocabulary.find(concept => concept.id === id);
 /**
  * What a concept is called: the name it states, else the one the
  * vocabulary gives it, else its IRI, so that a reader always has
  * something to show.
+ * @category Vocabulary
  */
 export const nameOf = (concept) => concept.name ?? conceptOf(concept.id)?.name ?? concept.id ?? '';

package/lib/ops/beliefs.d.ts

@@ -1,9 +1,31 @@
 import { Path } from "../lookup/paths.js";
 import { AnyArgumentation, Certainty } from "../model/Assumption.js";
 import { EditionOp } from "./draft.js";
-/** Annotates the assumption at the path with a belief held true, for reasons to be added. */
+/**
+ * Annotates the assumption at the path with a belief held true, for reasons to be added.
+ * @category Operations
+ */
 export declare const createBelief: (path: Path) => EditionOp;
+/**
+ * Takes the belief off the assumption at the path, which leaves the
+ * statement stated plainly.
+ * @category Operations
+ */
 export declare const clearBelief: (path: Path) => EditionOp;
+/**
+ * Sets the certainty the belief on the assumption at the path is held
+ * with.
+ * @category Operations
+ */
 export declare const setCertainty: (path: Path, certainty: Certainty) => EditionOp;
+/**
+ * Adds a reason to the belief on the assumption at the path.
+ * @category Operations
+ */
 export declare const addReason: (path: Path, reason: AnyArgumentation) => EditionOp;
+/**
+ * Takes the reason at the index off the belief on the assumption at the
+ * path.
+ * @category Operations
+ */
 export declare const removeReason: (path: Path, index: number) => EditionOp;