linked-rolls 0.69.0 → 0.71.0

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;

package/lib/ops/beliefs.js

@@ -10,22 +10,44 @@ const onBeliefAt = (path, op) => onAssumptionAt(path, assumption => {
     if (belief)
         op(belief);
 });
-/** 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 const createBelief = (path) => onAssumptionAt(path, assumption => {
     assumption['@annotation'] = {
         id: v4(),
         belief: { type: 'belief', id: v4(), certainty: 'true', reasons: [] }
     };
 });
+/**
+ * Takes the belief off the assumption at the path, which leaves the
+ * statement stated plainly.
+ * @category Operations
+ */
 export const clearBelief = (path) => onAssumptionAt(path, assumption => {
     delete assumption['@annotation'];
 });
+/**
+ * Sets the certainty the belief on the assumption at the path is held
+ * with.
+ * @category Operations
+ */
 export const setCertainty = (path, certainty) => onBeliefAt(path, belief => {
     belief.certainty = certainty;
 });
+/**
+ * Adds a reason to the belief on the assumption at the path.
+ * @category Operations
+ */
 export const addReason = (path, reason) => onBeliefAt(path, belief => {
     belief.reasons.push(reason);
 });
+/**
+ * Takes the reason at the index off the belief on the assumption at the
+ * path.
+ * @category Operations
+ */
 export const removeReason = (path, index) => onBeliefAt(path, belief => {
     belief.reasons.splice(index, 1);
 });

package/lib/ops/collation.d.ts

@@ -26,12 +26,14 @@ import { EditionOp } from "./draft.js";
  * A version is based on itself or on one of its own descendants in no
  * statement, since the stemma would loop; asked for that, nothing
  * changes.
+ * @category Operations
  */
 export declare const connectVersions: (childId: string, parentId: string, tolerance?: ObjectAssumption<CollationTolerance>) => EditionOp;
 /**
  * Folds the version's own symbols into those it inherits and collates
  * with: the carriers pass over, and the insertions go. Collates at the
  * tolerance of the derivation, where the caller names none.
+ * @category Operations
  */
 export declare const collateSymbols: (versionId: string, symbolIds: readonly string[], tolerance?: CollationTolerance) => EditionOp;
 /**
@@ -57,5 +59,6 @@ export declare const collateSymbols: (versionId: string, symbolIds: readonly str
  * and are passed over, so a reading somebody has separated by hand
  * keeps its identifier and the edit that speaks for it. Named symbols
  * narrow the act to those; naming none separates the whole reading.
+ * @category Operations
  */
 export declare const separateReadings: (versionId: string, copies: ReadonlySet<string>, symbolIds?: readonly string[]) => EditionOp;

package/lib/ops/collation.js

@@ -60,6 +60,7 @@ const byExchange = (edits) => new Map(edits.map(edit => [exchangeKey((edit.inser
  * A version is based on itself or on one of its own descendants in no
  * statement, since the stemma would loop; asked for that, nothing
  * changes.
+ * @category Operations
  */
 export const connectVersions = (childId, parentId, tolerance = defaultCollationTolerance) => reading(edition => {
     if (childId === parentId || derivesFrom(edition.versions, parentId, childId))
@@ -132,6 +133,7 @@ export const connectVersions = (childId, parentId, tolerance = defaultCollationT
  * Folds the version's own symbols into those it inherits and collates
  * with: the carriers pass over, and the insertions go. Collates at the
  * tolerance of the derivation, where the caller names none.
+ * @category Operations
  */
 export const collateSymbols = (versionId, symbolIds, tolerance) => reading(edition => {
     const version = versionIn(edition, versionId);
@@ -201,6 +203,7 @@ const sharedWith = (edition, symbol, copies) => {
  * and are passed over, so a reading somebody has separated by hand
  * keeps its identifier and the edit that speaks for it. Named symbols
  * narrow the act to those; naming none separates the whole reading.
+ * @category Operations
  */
 export const separateReadings = (versionId, copies, symbolIds) => reading(edition => {
     const version = versionIn(edition, versionId);

package/lib/ops/commands.d.ts

@@ -1,8 +1,23 @@
 import { PlacementRelation } from "../model/Symbol.js";
 import { EditionOp } from "./draft.js";
-/** States how the follower is placed relative to the reference, in place of any earlier statement. */
+/**
+ * States how the follower is placed relative to the reference, in place of any earlier statement.
+ * @category Operations
+ */
 export declare const placeCommand: (followerId: string, referenceId: string, relation: PlacementRelation) => EditionOp;
+/**
+ * Withdraws the statement placing the command relative to another,
+ * whichever relation it states.
+ * @category Operations
+ */
 export declare const unplaceCommand: (followerId: string) => EditionOp;
-/** The pair is stated on `statingId` only, as the format asks. */
+/**
+ * The pair is stated on `statingId` only, as the format asks.
+ * @category Operations
+ */
 export declare const pairCommands: (statingId: string, partnerId: string) => EditionOp;
+/**
+ * Withdraws the pairing the command states.
+ * @category Operations
+ */
 export declare const unpairCommand: (statingId: string) => EditionOp;

package/lib/ops/commands.js

@@ -14,16 +14,31 @@ const onCommand = (id, op) => reading(edition => draft => {
         op(symbol);
 });
 const clearPlacement = (command) => placementRelations.forEach(relation => { delete command[relation]; });
-/** States how the follower is placed relative to the reference, in place of any earlier statement. */
+/**
+ * States how the follower is placed relative to the reference, in place of any earlier statement.
+ * @category Operations
+ */
 export const placeCommand = (followerId, referenceId, relation) => onCommand(followerId, command => {
     clearPlacement(command);
     command[relation] = assignReference(referenceId);
 });
+/**
+ * Withdraws the statement placing the command relative to another,
+ * whichever relation it states.
+ * @category Operations
+ */
 export const unplaceCommand = (followerId) => onCommand(followerId, clearPlacement);
-/** The pair is stated on `statingId` only, as the format asks. */
+/**
+ * The pair is stated on `statingId` only, as the format asks.
+ * @category Operations
+ */
 export const pairCommands = (statingId, partnerId) => onCommand(statingId, command => {
     command.pairedWith = assignReference(partnerId);
 });
+/**
+ * Withdraws the pairing the command states.
+ * @category Operations
+ */
 export const unpairCommand = (statingId) => onCommand(statingId, command => {
     delete command.pairedWith;
 });

package/lib/ops/copies.d.ts

@@ -12,12 +12,14 @@ import { EditionOp } from "./draft.js";
  * inserts every symbol the copy's own tracker bar reads on it. The
  * version is a reading in that system's words, so it is coded for the
  * system the copy was cut for.
+ * @category Operations
  */
 export declare const createVersion: (copy: RollCopy) => EditionOp;
 /**
  * Puts the copy into the edition without a version of its own, as for a
  * copy whose features are not read into symbols: one known only from a
  * recording states instead which versions it carries.
+ * @category Operations
  */
 export declare const addCopy: (copy: RollCopy) => EditionOp;
 /**
@@ -26,6 +28,7 @@ export declare const addCopy: (copy: RollCopy) => EditionOp;
  * copy, or where the copy is the reference itself. The copy is read at
  * its own places whatever alignment it has, and through its own bar,
  * which is what lets a copy cut for another system be aligned at all.
+ * @category Operations
  */
 export declare const alignmentFor: (edition: Edition, copy: RollCopy, date?: Date) => Alignment | undefined;
 /**
@@ -34,12 +37,14 @@ export declare const alignmentFor: (edition: Edition, copy: RollCopy, date?: Dat
  * its features and tears onto the axis by them, in place of any
  * alignment it had. A copy that shares no run of notes with the
  * reference copy is left as it was.
+ * @category Operations
  */
 export declare const alignCopy: (copyId: string, date?: Date) => EditionOp;
 /**
  * Aligns every copy that has features with the reference copy, as
  * `alignCopy` does one. The reference copy itself is taken off any
  * alignment it had, its places being the axis.
+ * @category Operations
  */
 export declare const alignCopies: (date?: Date) => EditionOp;
 /**
@@ -47,27 +52,42 @@ export declare const alignCopies: (date?: Date) => EditionOp;
  * aligns every other copy onto it. Every place the edition gives along
  * the roll moves with this, which is why it is a choice and not
  * something worked out.
+ * @category Operations
  */
 export declare const chooseReferenceCopy: (copyId: string, date?: Date) => EditionOp;
 /**
  * Puts the copy's features back where they were measured, off the
  * axis. What the alignments say about the paper goes with it, since
  * that is worked out from them.
+ * @category Operations
  */
 export declare const unalignCopy: (copyId: string) => EditionOp;
 /**
  * Takes the extension a pneumatic reader adds off the ends of the
  * copy's chains of holes, and records how much was taken, so that their lengths
  * can be compared with a scanned copy's at all.
+ * @category Operations
  */
 export declare const shortenCopy: (copyId: string, extension: Millimeters, leaving?: ReadonlySet<string>) => EditionOp;
-/** Puts the reader's extension back on the copy's chains of holes. */
+/**
+ * Puts the reader's extension back on the copy's chains of holes.
+ * @category Operations
+ */
 export declare const unshortenCopy: (copyId: string) => EditionOp;
-/** States what the copy's features were read from, in place of any earlier statement. */
+/**
+ * States what the copy's features were read from, in place of any earlier statement.
+ * @category Operations
+ */
 export declare const stateSource: (copyId: string, source: FeatureSource) => EditionOp;
-/** Takes back the statement, leaving the copy silent about its source again. */
+/**
+ * Takes back the statement, leaving the copy silent about its source again.
+ * @category Operations
+ */
 export declare const clearSource: (copyId: string) => EditionOp;
-/** Gives the copy the siglum it is referred to by, or takes it away where the siglum given is blank. */
+/**
+ * Gives the copy the siglum it is referred to by, or takes it away where the siglum given is blank.
+ * @category Operations
+ */
 export declare const nameCopy: (copyId: string, siglum: string) => EditionOp;
 /** Takes out the copy's statements that match, and the list itself where none is left. */
 export declare const dropStatements: (copy: Draft<RollCopy>, matches: (statement: Readonly<ReferenceAssumption>) => boolean) => void;
@@ -77,15 +97,20 @@ export declare const dropStatements: (copy: Draft<RollCopy>, matches: (statement
  * one known only from a recording, and `carriageProblems` reports it
  * where features carry symbols already. A second statement about one
  * version is none.
+ * @category Operations
  */
 export declare const stateCarriage: (copyId: string, versionId: string, belief?: Belief) => EditionOp;
-/** Takes back the copy's statement that it carries the version. */
+/**
+ * Takes back the copy's statement that it carries the version.
+ * @category Operations
+ */
 export declare const clearCarriage: (copyId: string, versionId: string) => EditionOp;
 /**
  * Adds a general condition to the copy, beside whatever is stated of it
  * already. A paper stretch is added the same way, where one was
  * measured; what the alignments say of the paper is worked out from
  * them and stated nowhere.
+ * @category Operations
  */
 export declare const addGeneralCondition: (copyId: string, condition: ObjectAssumption<GeneralRollCondition>) => EditionOp;
 /**
@@ -93,19 +118,25 @@ export declare const addGeneralCondition: (copyId: string, condition: ObjectAssu
  * what was stated before; given nothing, it takes the statement away. A
  * copy has one paper, so it has one such condition, which may give a
  * strain in either direction.
+ * @category Operations
  */
 export declare const statePaperStretch: (copyId: string, stretch?: ObjectAssumption<PaperStretch>) => EditionOp;
 /**
  * Adds a tear to the copy, beside whatever is stated of it already. The
  * tear is given on the axis, where the copy's features stand, and moves
  * with them from then on.
+ * @category Operations
  */
 export declare const addTear: (copyId: string, tear: ObjectAssumption<Tear>) => EditionOp;
-/** The symbols of the versions that no other copy carries. */
+/**
+ * The symbols of the versions that no other copy carries.
+ * @category Operations
+ */
 export declare const symbolsCarriedOnlyBy: (edition: Edition, copyId: string) => AnySymbol[];
 /**
  * Takes the copy out of the edition together with the symbols only it
  * carries, and with every reference the versions and the argumentations
  * made to those symbols.
+ * @category Operations
  */
 export declare const removeCopy: (copyId: string) => EditionOp;