linked-rolls 0.56.0 → 0.58.0

package/lib/ops/draft.js

@@ -0,0 +1,81 @@
+import { EditionView } from "../view/EditionView.js";
+/** What the operations are built from: the type of an operation, how one finds what it writes to on the draft, and the edits it writes. */
+import { current, isDraft } from "immer";
+import { v4 } from "uuid";
+import { unchecked, uncheckedMotivation } from "../collation/Collation.js";
+import { insertedBy } from "../model/Version.js";
+import { featuresOf } from "../model/RollCopy.js";
+import { assignReference } from "../model/Assumption.js";
+import { without, pruned } from "./immutable.js";
+export const noChange = () => undefined;
+export const onCopy = (copyId, op) => draft => {
+    const copy = draft.copies.find(c => c.id === copyId);
+    if (copy)
+        op(copy, draft);
+};
+export const onVersion = (versionId, op) => draft => {
+    const version = draft.versions.find(v => v.id === versionId);
+    if (version)
+        op(version, draft);
+};
+export const onFeature = (copyId, featureId, op) => onCopy(copyId, copy => {
+    const feature = featuresOf(copy).find(f => f.id === featureId);
+    if (feature)
+        op(feature);
+});
+/**
+ * The operation built from a view of the state it is applied to. The
+ * view given is used where the draft still stands as the view saw it,
+ * and a fresh one is taken of the draft where an operation run before
+ * on the same draft has changed it: a path or an index read off the
+ * view would otherwise name what stood there before.
+ */
+export const reading = (view, build) => draft => {
+    const state = stateOf(draft);
+    build(state === view.edition ? view : new EditionView(state))(draft);
+};
+/**
+ * The state a draft stands at, as plain data. Reading a draft proxies
+ * everything it touches, so what is only read is read from this.
+ */
+export const stateOf = (draft) => isDraft(draft) ? current(draft) : draft;
+/** The ids of the items the rewriting left out. */
+export const droppedIds = (before, after) => {
+    const kept = new Set(after.map(item => item.id));
+    return before.flatMap(item => kept.has(item.id) ? [] : [item.id]);
+};
+export const insertion = (symbol) => ({ type: 'edit', id: v4(), insert: [symbol] });
+export const deletion = (symbolId) => ({ type: 'edit', id: v4(), delete: [symbolId] });
+/** The edit as a collation leaves it: made by rule, and not yet read by anybody. */
+export const asUnchecked = (edit) => ({ ...edit, motivation: unchecked });
+/**
+ * The motivations with the unchecked one declared, where any edit
+ * names it and the version does not state it yet. An edit naming a
+ * motivation the version leaves undeclared points at nothing.
+ */
+export const declaring = (motivations, edits) => edits.some(edit => edit.motivation === unchecked)
+    && !motivations.some(motivation => motivation.id === unchecked)
+    ? [...motivations, uncheckedMotivation]
+    : motivations;
+const isEmpty = (edit) => !edit.insert?.length && !edit.delete?.length;
+export const insertedIn = (versions) => versions.flatMap(insertedBy);
+/** The edits with the change applied, less those it emptied; the very same array where it changed none. */
+export const edited = (edits, change) => pruned(edits, change, isEmpty);
+/** The edit without the symbols among its insertions, or the very same edit where it inserts none of them. */
+const droppingInsertions = (symbolIds) => (edit) => {
+    const insert = edit.insert && without(edit.insert, symbol => symbolIds.has(symbol.id));
+    return insert === edit.insert ? edit : { ...edit, insert };
+};
+/** Takes the symbols out of the version's own insertions, and the edits that had nothing else. */
+export const dropInsertions = (version, symbolIds) => {
+    const edits = stateOf(version).edits;
+    if (edits)
+        version.edits = edited(edits, droppingInsertions(symbolIds));
+};
+/** A reference under the belief given, where one is given. */
+export const referenceHeld = (id, belief) => ({ ...assignReference(id), ...(belief && { '@annotation': { id: v4(), belief } }) });
+/** The references less those that match, or nothing where none is left. */
+export const withoutReferences = (references, matches) => {
+    const kept = references.filter(reference => !matches(reference));
+    return kept.length > 0 ? kept : undefined;
+};

package/lib/ops/edits.d.ts

@@ -0,0 +1,10 @@
+import { EditionView } from "../view/EditionView.js";
+import { Edit } from "../model/Edit.js";
+import { EditionOp } from "./draft.js";
+/**
+ * Replaces the edits with a single one carrying all their insertions
+ * and deletions, classified by a guess at what the exchange does.
+ */
+export declare const mergeEdits: (given: EditionView, versionId: string, toMerge: readonly Edit[]) => EditionOp;
+/** Replaces the edit with one edit per inserted and one per deleted symbol. */
+export declare const splitEdit: (versionId: string, toSplit: Edit) => EditionOp;

package/lib/ops/edits.js

@@ -0,0 +1,82 @@
+/** Merging and splitting the edits of a version. */
+import { v4 } from "uuid";
+import { editsOf } from "../model/Version.js";
+import { trackerBarOf } from "../systems/index.js";
+import { distance, mm, subtract } from "../model/Quantity.js";
+import { noChange, onVersion, insertion, deletion, reading } from "./draft.js";
+const sameSequence = (a, b) => a.length === b.length && a.every((value, i) => value === b[i]);
+const expressionTypesOf = (symbols) => symbols.filter((symbol) => symbol.type === 'expression').map(symbol => symbol.expressionType);
+/** The spellings of a single added accent the bar offers, none where no bar is known. */
+const accentsOn = (bar) => bar?.accents ?? [];
+const lengthOf = (span) => subtract(span.to, span.from);
+/** How far apart two onsets may lie for the one symbol to count as a replacement of the other. */
+const REPLACEMENT_TOLERANCE = mm(5);
+/** Shorten or prolong, where the inserted symbol starts about where the deleted one did. */
+const replacementType = (view, inserted, deleted) => {
+    const after = view.placeOf(inserted);
+    const before = view.placeOf(deleted);
+    if (!after || !before || distance(after.from, before.from) >= REPLACEMENT_TOLERANCE)
+        return undefined;
+    return lengthOf(after) < lengthOf(before) ? 'shorten' : 'prolong';
+};
+/**
+ * A guess at what an edit does, from the symbols it exchanges and from
+ * the systems the version and the one it is based on are coded for.
+ */
+const guessEditType = (view, versionId, edit) => {
+    const inserts = edit.insert ?? [];
+    const deletes = view.symbols(edit.delete ?? []);
+    const inserted = expressionTypesOf(inserts);
+    const deleted = expressionTypesOf(deletes);
+    const bar = trackerBarOf(view.version(versionId)?.system);
+    const parentBar = trackerBarOf(view.predecessorOf(versionId)?.system);
+    /**
+     * Where the version is coded for another system than its parent, an
+     * exchange of expression matter is the transfer being carried out:
+     * a red ForzandoOn and ForzandoOff pair giving way to one held green
+     * SforzandoForte says the same thing in the other system's words,
+     * which is what 'replace-with-equivalent' is for. Calling it a
+     * corrected error would say the editor made a mistake.
+     */
+    if (bar && parentBar && bar.id !== parentBar.id && inserted.length > 0 && deleted.length > 0) {
+        return 'replace-with-equivalent';
+    }
+    if (deleted.length === 0 && accentsOn(bar).some(accent => sameSequence(inserted, accent)))
+        return 'additional-accent';
+    if (inserted.length > 1 && sameSequence(inserted, deleted))
+        return 'shift';
+    if (inserted.length === 0 && deleted.length === 1)
+        return 'remove-redundancy';
+    if (inserts.length === 1 && deletes.length === 1)
+        return replacementType(view, inserts[0], deletes[0]) ?? 'correct-error';
+    return 'correct-error';
+};
+/**
+ * Replaces the edits with a single one carrying all their insertions
+ * and deletions, classified by a guess at what the exchange does.
+ */
+export const mergeEdits = (given, versionId, toMerge) => reading(given, view => {
+    if (toMerge.length === 0)
+        return noChange;
+    const merged = {
+        ...toMerge[0],
+        id: v4(),
+        insert: toMerge.flatMap(edit => edit.insert ?? []),
+        delete: toMerge.flatMap(edit => edit.delete ?? [])
+    };
+    merged.editType = guessEditType(view, versionId, merged);
+    const mergedIds = new Set(toMerge.map(edit => edit.id));
+    return onVersion(versionId, version => {
+        version.edits = [...editsOf(version).filter(edit => !mergedIds.has(edit.id)), merged];
+    });
+});
+/** Replaces the edit with one edit per inserted and one per deleted symbol. */
+export const splitEdit = (versionId, toSplit) => {
+    const parts = [
+        ...(toSplit.insert ?? []).map(insertion),
+        ...(toSplit.delete ?? []).map(deletion)
+    ];
+    return onVersion(versionId, version => {
+        version.edits = [...editsOf(version).filter(edit => edit.id !== toSplit.id), ...parts];
+    });
+};

package/lib/ops/features.d.ts

@@ -0,0 +1,84 @@
+import { EditionView } from "../view/EditionView.js";
+import { ModificationPurpose } from "../model/RollCopy.js";
+import { FeatureConditionAssignment, FeatureOrPatch, NestedFeature } from "../model/Feature.js";
+import { EditionOp } from "./draft.js";
+/**
+ * States the condition of the feature, in place of any earlier
+ * statement. Throws where the kind of feature is in no such condition;
+ * `conditions` says which conditions each kind of feature may be in.
+ */
+export declare const stateFeatureCondition: (copyId: string, featureId: string, condition: FeatureConditionAssignment) => EditionOp;
+/**
+ * The act a feature an editor states belongs to: the punching of the
+ * copy, the act that brought another feature about, or, where neither
+ * is said, an act of its own for the purpose given. A patch is never
+ * punched, being glued on, so `punched` says nothing of one.
+ */
+export interface FeatureAct {
+    /** The copy came from its punching with it, which is where a reading of a scan puts every chain of holes. */
+    punched?: boolean;
+    /** The act that brought this feature about brought the new one about as well. */
+    beside?: string;
+    /** What the act was for, where a new one is made for the feature. */
+    purpose?: ModificationPurpose;
+}
+/**
+ * States that the copy bears the feature, in the act that brought it
+ * about: a patch was glued on by an attachment, anything else was
+ * produced, by the punching or by a later act. Which act, `FeatureAct`
+ * says; a `beside` that names nothing the copy bears is passed over and
+ * the feature goes into an act of its own.
+ */
+export declare const addFeature: (copyId: string, feature: FeatureOrPatch, act?: FeatureAct) => EditionOp;
+/**
+ * States that the patch bears the feature. What a patch bears came onto
+ * the copy with the patch, so it belongs to no act of its own and
+ * states no place: it stands where the patch stands.
+ */
+export declare const addBorneFeature: (copyId: string, patchId: string, feature: NestedFeature) => EditionOp;
+/**
+ * Takes the features off the copy, and out of the versions with what
+ * only they carried. A feature may be named wherever the copy bears it:
+ * a patch goes with everything glued onto it, and a feature of a patch
+ * may be taken back on its own, the patch staying where it is. An act
+ * left having produced or added nothing goes as well.
+ */
+export declare const removeFeatures: (copyId: string, featureIds: readonly string[]) => EditionOp;
+/** Why several features cannot be replaced by one. */
+export type MergeObstacle = 'fewer-than-two' | 'different-types' | 'different-tracks' | 'differing-conditions' | 'unlike-features' | 'different-acts';
+/**
+ * What stands in the way of reading the features as one, or nothing
+ * where they may be merged. Features may be merged where they differ
+ * in nothing but their place along the roll, their depiction and the
+ * condition at most one of them states. How far apart they lie is not
+ * asked: whether a gap is a bridge of the perforator, a tear or two
+ * perforations of their own is the editor's reading.
+ */
+export declare const mergeObstacle: (features: readonly FeatureOrPatch[]) => MergeObstacle | undefined;
+/**
+ * What stands in the way of reading the features the ids name as one,
+ * as `mergeFeatures` will find it. `mergeObstacle` asks only what the
+ * features themselves say, which cannot reach `different-acts`: one
+ * feature is the work of one act, and where the features stand is the
+ * edition's business rather than theirs.
+ */
+export declare const mergeObstacleIn: (view: EditionView, featureIds: readonly string[]) => MergeObstacle | undefined;
+/**
+ * Replaces the features of the copy with a single one covering them
+ * all, where a scan has split what the editor reads as one feature.
+ * The merged feature takes the place of the first it replaces and
+ * spans from the first to the last, any gap between them included.
+ * What the replaced features carried is carried by the merged one, and
+ * whatever else named them, a modification or a comprehension, names
+ * the merged one in their stead.
+ *
+ * Only the features the copy bears itself are merged. A feature of a
+ * patch states no place along the roll of its own, so there is nothing
+ * for a merge to span, and an id naming one is passed over as an id the
+ * copy does not bear is. Features of two different acts are not merged
+ * either: one feature is the work of one act.
+ *
+ * Throws where the features cannot stand for one; `mergeObstacle`
+ * says beforehand whether they can.
+ */
+export declare const mergeFeatures: (copyId: string, featureIds: readonly string[]) => EditionOp;

package/lib/ops/features.js

@@ -0,0 +1,296 @@
+import { v4 } from "uuid";
+import { featuresByAct, featuresOf, statesNothing } from "../model/RollCopy.js";
+import { idOf } from "../model/Assumption.js";
+import { conditions as conditionsAllowed, featuresBorneBy, isPatch, withBorneFeatures } from "../model/Feature.js";
+import { mm } from "../model/Quantity.js";
+import { onCopy, onFeature, stateOf } from "./draft.js";
+import { without, mapped, pruned, replacing, isRecord } from "./immutable.js";
+import { renameReferences, forgetFeatures } from "./forget.js";
+/**
+ * Whether the feature's own kind allows a condition of this kind. The
+ * type narrowed to is the weaker statement, holding of a condition any
+ * kind of feature may be in.
+ */
+const allows = (feature, condition) => {
+    const allowed = conditionsAllowed[feature.type];
+    return allowed.includes(condition.conditionType);
+};
+/**
+ * States the condition of the feature, in place of any earlier
+ * statement. Throws where the kind of feature is in no such condition;
+ * `conditions` says which conditions each kind of feature may be in.
+ */
+export const stateFeatureCondition = (copyId, featureId, condition) => onFeature(copyId, featureId, feature => {
+    if (!allows(feature, condition)) {
+        throw new Error(`A ${feature.type} is in no '${condition.conditionType}' condition`);
+    }
+    feature.condition = condition;
+});
+/**
+ * The ids of the features named and of everything they bear: a feature
+ * of a patch stands nowhere once the patch is gone.
+ */
+const goneWith = (features, named) => features.flatMap(feature => named.has(feature.id)
+    ? withBorneFeatures(feature).map(borne => borne.id)
+    : goneWith(featuresBorneBy(feature), named));
+/** The feature with the named ones gone from what it bears, or the very same one where it bears none of them. */
+const withoutBorne = (feature, named) => {
+    if (!isPatch(feature) || !feature.features)
+        return feature;
+    const borne = withoutFeatures(feature.features, named);
+    return borne === feature.features ? feature : { ...feature, features: borne };
+};
+/** The features without those named, wherever they lie, and without whatever those bore. */
+const withoutFeatures = (features, named) => mapped(without(features, feature => named.has(feature.id)), feature => withoutBorne(feature, named));
+/** The act with its features rewritten, or the very same one where the rewriting left them. */
+const rewritingAct = (rewrite) => (modification) => {
+    if (modification.type === 'Alteration')
+        return replacing(modification, 'produced', rewrite(modification.produced));
+    if (modification.type === 'Attachment')
+        return replacing(modification, 'added', rewrite(modification.added));
+    return modification;
+};
+/**
+ * Writes the rewriting onto the features of every act of the copy, and
+ * takes out an act it left with nothing to state.
+ */
+const rewriteFeatures = (copy, rewrite) => {
+    const state = stateOf(copy);
+    const produced = state.production?.produced;
+    if (produced && copy.production) {
+        const rewritten = rewrite(produced);
+        if (rewritten !== produced)
+            copy.production.produced = rewritten;
+    }
+    copy.modifications = pruned(state.modifications, rewritingAct(rewrite), statesNothing);
+};
+/** The features of the act that brought the named feature about, where that act produces features. */
+const producedBeside = (copy, featureId) => {
+    const names = (features) => features.some(feature => feature.id === featureId);
+    const punched = copy.production?.produced;
+    if (punched && names(punched))
+        return punched;
+    const act = copy.modifications.find(act => act.type === 'Alteration' && names(act.produced));
+    return act?.type === 'Alteration' ? act.produced : undefined;
+};
+/** The patches of the attachment that glued the named one on. */
+const gluedBeside = (copy, patchId) => {
+    const act = copy.modifications.find(act => act.type === 'Attachment' && act.added.some(patch => patch.id === patchId));
+    return act?.type === 'Attachment' ? act.added : undefined;
+};
+/** The list the copy states a new feature in, making the act it belongs to where there is none. */
+const actFor = (copy, patch, act) => {
+    const beside = act.beside !== undefined
+        ? (patch ? gluedBeside(copy, act.beside) : producedBeside(copy, act.beside))
+        : undefined;
+    if (beside)
+        return beside;
+    if (patch) {
+        const added = [];
+        copy.modifications.push({ type: 'Attachment', added, ...(act.purpose && { purpose: act.purpose }) });
+        return added;
+    }
+    if (act.punched) {
+        if (!copy.production)
+            copy.production = {};
+        if (!copy.production.produced)
+            copy.production.produced = [];
+        return copy.production.produced;
+    }
+    const produced = [];
+    copy.modifications.push({ type: 'Alteration', produced, ...(act.purpose && { purpose: act.purpose }) });
+    return produced;
+};
+/**
+ * States that the copy bears the feature, in the act that brought it
+ * about: a patch was glued on by an attachment, anything else was
+ * produced, by the punching or by a later act. Which act, `FeatureAct`
+ * says; a `beside` that names nothing the copy bears is passed over and
+ * the feature goes into an act of its own.
+ */
+export const addFeature = (copyId, feature, act = {}) => onCopy(copyId, copy => {
+    actFor(copy, isPatch(feature), act).push(feature);
+});
+/**
+ * States that the patch bears the feature. What a patch bears came onto
+ * the copy with the patch, so it belongs to no act of its own and
+ * states no place: it stands where the patch stands.
+ */
+export const addBorneFeature = (copyId, patchId, feature) => onCopy(copyId, copy => {
+    const patch = featuresOf(copy).flatMap(withBorneFeatures).find(borne => borne.id === patchId);
+    if (!patch || !isPatch(patch))
+        return;
+    if (!patch.features)
+        patch.features = [];
+    patch.features.push(feature);
+});
+/**
+ * Takes the features off the copy, and out of the versions with what
+ * only they carried. A feature may be named wherever the copy bears it:
+ * a patch goes with everything glued onto it, and a feature of a patch
+ * may be taken back on its own, the patch staying where it is. An act
+ * left having produced or added nothing goes as well.
+ */
+export const removeFeatures = (copyId, featureIds) => onCopy(copyId, (copy, draft) => {
+    const named = new Set(featureIds);
+    const features = featuresOf(stateOf(copy));
+    rewriteFeatures(copy, (stated) => withoutFeatures(stated, named));
+    forgetFeatures(draft, new Set(goneWith(features, named)));
+});
+/**
+ * Whether two records of the edition state the same, the identity of a
+ * statement left out: two transcriptions reading the same word say the
+ * same, whichever ids they were given.
+ */
+const sayTheSame = (a, b) => {
+    if (a === b)
+        return true;
+    if (!isRecord(a) || !isRecord(b) || Array.isArray(a) !== Array.isArray(b))
+        return false;
+    const keys = new Set([...Object.keys(a), ...Object.keys(b)]);
+    keys.delete('id');
+    return [...keys].every(key => sayTheSame(a[key], b[key]));
+};
+/**
+ * What a feature states beyond its identity, its place along the roll,
+ * its depiction and its condition. What a patch bears counts by
+ * identity: two patches bear the same only where they bear the very
+ * same features, so that no merge takes a feature of a patch away.
+ */
+const nature = (feature) => {
+    const { id, horizontal, depiction, condition, ...rest } = feature;
+    return isPatch(feature) && feature.features
+        ? { ...rest, features: feature.features.map(borne => borne.id) }
+        : rest;
+};
+const conditionsOf = (features) => features.flatMap(feature => feature.condition ? [feature.condition] : []);
+/**
+ * What stands in the way of reading the features as one, or nothing
+ * where they may be merged. Features may be merged where they differ
+ * in nothing but their place along the roll, their depiction and the
+ * condition at most one of them states. How far apart they lie is not
+ * asked: whether a gap is a bridge of the perforator, a tear or two
+ * perforations of their own is the editor's reading.
+ */
+export const mergeObstacle = (features) => {
+    if (features.length < 2)
+        return 'fewer-than-two';
+    const [first, ...rest] = features;
+    if (rest.some(feature => feature.type !== first.type))
+        return 'different-types';
+    if (rest.some(feature => !sayTheSame(feature.vertical, first.vertical)))
+        return 'different-tracks';
+    if (rest.some(feature => !sayTheSame(nature(feature), nature(first))))
+        return 'unlike-features';
+    const conditions = conditionsOf(features);
+    if (conditions.some(condition => !sayTheSame(condition, conditions[0])))
+        return 'differing-conditions';
+    return undefined;
+};
+/** The acts of the copy that state any of the named features. */
+const actsHolding = (copy, named) => featuresByAct(copy).filter(features => features.some(feature => named.has(feature.id)));
+/**
+ * What stands in the way of reading the named features of the copy as
+ * one, which is the whole of what `mergeFeatures` asks: whether one act
+ * brought them all about, and what the features themselves say. An id
+ * the copy does not bear at a place of its own is passed over.
+ */
+const obstacleIn = (copy, featureIds) => {
+    const named = new Set(featureIds);
+    const acts = actsHolding(copy, named);
+    return acts.length > 1
+        ? 'different-acts'
+        : mergeObstacle((acts[0] ?? []).filter(feature => named.has(feature.id)));
+};
+/**
+ * What stands in the way of reading the features the ids name as one,
+ * as `mergeFeatures` will find it. `mergeObstacle` asks only what the
+ * features themselves say, which cannot reach `different-acts`: one
+ * feature is the work of one act, and where the features stand is the
+ * edition's business rather than theirs.
+ */
+export const mergeObstacleIn = (view, featureIds) => {
+    const copy = featureIds.map(id => view.copyOf(id)).find(copy => copy !== undefined);
+    return copy ? obstacleIn(copy, featureIds) : 'fewer-than-two';
+};
+/** The items with the replacement in the place of the first it stands for, the others dropped. */
+const standingFor = (items, stands, replacement) => {
+    const first = items.findIndex(stands);
+    if (first < 0)
+        return items;
+    return items.flatMap((item, i) => i === first ? [replacement] : stands(item) ? [] : [item]);
+};
+const spanning = (features) => ({
+    unit: 'mm',
+    from: mm(Math.min(...features.map(feature => feature.horizontal.from))),
+    to: mm(Math.max(...features.map(feature => feature.horizontal.to)))
+});
+/**
+ * The feature the merged ones give way to. It spans them all and is in
+ * every other respect the one of them that states a condition, the
+ * others being alike in all but their place. The depiction goes: a
+ * region of the scan showing one part depicts no more than that part.
+ */
+const mergedFrom = (features, id) => {
+    const stating = features.find(feature => feature.condition) ?? features[0];
+    const merged = { ...stating, id, horizontal: spanning(features) };
+    delete merged.depiction;
+    return merged;
+};
+/** The symbol carried by the merged feature where it named one of those it replaces, and naming it once. */
+const carriedByMerged = (replaced, mergedId) => (symbol) => {
+    const names = (carrier) => replaced.has(idOf(carrier));
+    const first = symbol.carriers.find(names);
+    if (!first)
+        return symbol;
+    return { ...symbol, carriers: standingFor(symbol.carriers, names, { ...first, id: mergedId }) };
+};
+/** Points the versions at the merged feature wherever they name one it replaces. */
+const carryOver = (draft, replaced, mergedId) => {
+    const recarry = carriedByMerged(replaced, mergedId);
+    const recarrying = (edit) => {
+        const insert = edit.insert && mapped(edit.insert, recarry);
+        return insert === edit.insert ? edit : { ...edit, insert };
+    };
+    const versions = stateOf(draft.versions);
+    draft.versions.forEach((version, i) => {
+        const edits = versions[i].edits;
+        if (edits)
+            version.edits = mapped(edits, recarrying);
+    });
+};
+/**
+ * Replaces the features of the copy with a single one covering them
+ * all, where a scan has split what the editor reads as one feature.
+ * The merged feature takes the place of the first it replaces and
+ * spans from the first to the last, any gap between them included.
+ * What the replaced features carried is carried by the merged one, and
+ * whatever else named them, a modification or a comprehension, names
+ * the merged one in their stead.
+ *
+ * Only the features the copy bears itself are merged. A feature of a
+ * patch states no place along the roll of its own, so there is nothing
+ * for a merge to span, and an id naming one is passed over as an id the
+ * copy does not bear is. Features of two different acts are not merged
+ * either: one feature is the work of one act.
+ *
+ * Throws where the features cannot stand for one; `mergeObstacle`
+ * says beforehand whether they can.
+ */
+export const mergeFeatures = (copyId, featureIds) => onCopy(copyId, (copy, draft) => {
+    const state = stateOf(copy);
+    const obstacle = obstacleIn(state, featureIds);
+    if (obstacle) {
+        throw new Error(`The features of copy ${copyId} cannot be merged: ${obstacle}`);
+    }
+    const named = new Set(featureIds);
+    const toMerge = (actsHolding(state, named)[0] ?? []).filter(feature => named.has(feature.id));
+    const replaced = new Set(toMerge.map(feature => feature.id));
+    const mergedId = v4();
+    rewriteFeatures(copy, (stated) => {
+        const stands = (feature) => replaced.has(feature.id);
+        return stated.some(stands) ? standingFor(stated, stands, mergedFrom(stated.filter(stands), mergedId)) : stated;
+    });
+    carryOver(draft, replaced, mergedId);
+    renameReferences(draft, ids => standingFor(ids, id => replaced.has(id), mergedId));
+});

package/lib/ops/forget.d.ts

@@ -0,0 +1,31 @@
+/** Striking features from the edition, and rewriting the ids by which the edition names them outside the versions. */
+import { Draft } from "immer";
+import { Edition } from "../model/Edition.js";
+import { AnySymbol } from "../model/Symbol.js";
+import { RollCopy } from "../model/RollCopy.js";
+import { Ids } from "./draft.js";
+/** The ids of every feature the copy bears, those a patch bears among them. */
+export declare const featureIdsOf: (copy: RollCopy) => Ids;
+/**
+ * A symbol every carrier of which lies among the features loses its
+ * evidence with them. A symbol without carriers, such as a label,
+ * stands on its own.
+ */
+export declare const carriedOnlyOn: (features: Ids) => (symbol: AnySymbol) => boolean;
+/** The ids a statement names, as the rewriting leaves them. */
+type Rename = (ids: string[]) => string[];
+/**
+ * Rewrites the ids by which the edition names features and symbols
+ * outside the versions. A belief is annotatable anywhere, so the whole
+ * edition is read; what the rewriting leaves alone is left the very
+ * object it was.
+ */
+export declare const renameReferences: (draft: Draft<Edition>, rename: Rename) => void;
+/**
+ * Strikes the features from the edition: their carriers go, a symbol
+ * that had no other carrier goes with them, an edit left exchanging
+ * nothing goes as well, and so does every reference the versions, the
+ * modifications of the copies and the comprehensions made to what went.
+ */
+export declare const forgetFeatures: (draft: Draft<Edition>, features: Ids) => void;
+export {};