linked-rolls 0.75.0 → 0.76.0

package/README.md

@@ -132,22 +132,20 @@ edits the editor wrote, which hold their versions to what they insert
 and delete. Motivations, beliefs and versions known only from a
 recording remain the editor's to state.
 
-What the program concluded is recorded as a program's conclusion. A
-search scores whole stemmata, so the derivations and edits it states
-are one proposition set (CRMinf I4) held under one belief. Each of
-them names the set in its annotation, and the set states the belief
-once. The belief, likely unless the editor says otherwise, rests on an
-inference that names this library and its release, the copies it
-collated, the published rules its costs carry out (`stemmaRules`) and,
-in its note, the costs and settings it ran with and the margin of each
-grouping. Who ran it and when are the editor's to give. A derivation or
-an edit the editor holds for reasons of their own stays theirs, outside
-the set.
+What the program concluded is stated plainly, as an edition states its
+stemma. The edition's creation names how it was found: the published
+rules the costs carry out among its principles (`stemmaRules`), and
+this release of the library among its software, which finds the
+stemma again with the defaults it has. A derivation the editor holds
+under a belief of their own, and an edit that says why it was made,
+stay as they are. Among the versions, derivations and edits, whatever
+carries neither a belief nor a motivation of the editor's is the
+program's.
 
 ```ts
-const run = { actor: editor, date: { within: new Date() } }
-const adopted = produce(edition, adoptStemma(proposal, run))
-adopted.propositionSets // [{ type: 'propositionSet', id, belief: { certainty: 'likely', reasons: [{ type: 'inference', software: [linkedRolls], … }] } }]
+const adopted = produce(edition, adoptStemma(proposal))
+adopted.creation.principles // ['https://welte225.org/rules#shared-addition', …]
+adopted.creation.software   // [{ name: 'linked-rolls', version: '0.76.0' }]
 ```
 
 The costs are those with which the stemma of WM 225 comes out of its
@@ -157,28 +155,26 @@ principles confirm it.
 
 ## Proposing the edits
 
-What a version inserts and deletes can be grouped into edits and typed
-by their shape alone. `proposeEdits` reads a version's changes line by
-line, a latched function, a held one or a pitch, and never across a
-command both texts keep, so that an edit stays at one place. A function
-turned on and off again is one edit, typed an additional accent where
-the bar spells an accent so; a perforation put elsewhere is one move
-with the one it replaces, typed a shift, or shortened or prolonged
-where it begins about where the other did; overlapping notes are one
-edit, a note struck again or two tied; a held command standing for a
-latched pair is one recoding; a command the text makes no use of is a
-redundancy added or removed; cancels punched across lines at one place
-are one row. `adoptEdits` puts the proposal in place of the edits a
-collation or a program's run wrote and nobody has motivated, and keeps
-the rest. The edits it proposes are a proposition set of their own. The
-inference behind its belief names the beliefs the derivations of the
-versions are held with as its premises, so that edits grouped against
-a proposed stemma rest on it.
+What a version inserts and deletes can be grouped into edits, and the
+shape of each read off them alone. `proposeEdits` reads a version's
+changes line by line, a latched function, a held one or a pitch, and
+never across a command both texts keep, so that an edit stays at one
+place. A function turned on and off again is one edit, an additional
+accent where the bar spells an accent so; a perforation put elsewhere
+is one move with the one it replaces, a shift, or shortened or
+prolonged where it begins about where the other did; overlapping notes
+are one edit, a note struck again or two tied; a held command standing
+for a latched pair is one recoding; a command the text makes no use of
+is a redundancy added or removed; cancels punched across lines at one
+place are one row. `adoptEdits` puts the proposal in place of the
+program's edits, those that say nothing of why they were made or only
+that they are musical or technical changes, and keeps the rest. Its creation comes to
+name the rule that keeps an edit at one place among its principles.
 
 ```ts
 import { adoptEdits, adoptStemma, proposeEdits, proposeStemma } from 'linked-rolls'
 
-proposeEdits(edition, versionId)  // [{ insert, delete, editType, grouping }, …]
+proposeEdits(edition, versionId)  // [{ insert, delete, shape, grouping }, …]
 
 // The stemma and the edits of its versions, as one undo step
 const adopted = produce(edition, draft => {
@@ -187,14 +183,26 @@ const adopted = produce(edition, draft => {
 })
 ```
 
-Why an edit was made is not read off its shape, and neither is whether
-a shift corrects an error: what is left to the editor is the
-motivation. Correcting an error is therefore one of the motivations
-(`correctedError`), not one of the edit types, and a document written
-while it was a type is read with that motivation in its place. On
-WM 225 the proposal reproduces 370 of the 414 edits the editor wrote,
-from what each version changes, and every type the editor gave them.
-From the copies alone, through the proposed stemma, it reproduces 326.
+Every change of a version that derives from another states a
+motivation, and the motivation says what kind of change it is
+(`kindOfChange`). A program states it from the shape of the change: a
+redundancy cleaned up or added, or a command recoded for another
+system, is a technical change (`technicalChange`), which the procedure
+of the version's creation explains; an added accent, a shift, a
+shortening or a prolongation is a musical change (`musicalChange`),
+under the rule that later versions are the more refined. The editor
+may say otherwise, and adopting the edits again keeps the kind an edit
+over the same changes states. The editor speculates on the musical
+changes only: a reason of their own, which the edition states once
+(`Edition.motivations`) and any version's edits name, takes the place of
+the generic musical motivation. The edits of a version that derives from none state its
+text, and no motivation.
+
+On WM 225 the proposal reproduces 601 of the 690 edits of the versions
+that derive from another, from what each version changes, and from the
+copies alone, through the proposed stemma, 554. It agrees with the
+editor on what kind of change an edit is but for two, each a reason the
+editor gives for what the program reads as a redundancy.
 
 ## Format
 
@@ -206,12 +214,10 @@ https://pfefferniels.github.io/linked-rolls/, to which the w3id.org
 identifiers redirect.
 
 Beliefs are written as JSON-LD-star annotations (`@annotation`), so you
-need a processor that supports JSON-LD-star to read them. A statement
-that belongs to a proposition set carries no belief of its own: its
-annotation names the set by its `@id`, which makes the set the reifier
-of every statement that names it, as RDF 1.2 allows. The set is stated
-once, under `propositionSets`, as a `crminf:I4_Proposition_Set` with its
-belief.
+need a processor that supports JSON-LD-star to read them. They are kept
+for what the editor doubts; everything else, the stemma and the edits a
+program found among it, is stated plainly and reaches RDF with any
+JSON-LD processor.
 
 ## Development
 
@@ -230,7 +236,7 @@ TypeScript 7 no longer has the compiler API it reads the source with.
 
 Raise the version in `package.json`, in `CITATION.cff`, there with the
 day as `date-released`, and in `src/software.ts`, which names the release
-in the reasonings the library records. Then commit, and push a tag
+in the edition's creation when a proposal is adopted. Then commit, and push a tag
 `v<version>`. The `publish.yml` workflow builds, tests and publishes to
 npm, then makes a GitHub release of the tag, which Zenodo archives with
 a DOI. A test fails while the versions differ.

package/lib/collation/Collation.d.ts

@@ -120,54 +120,20 @@ export type Collation = {
  */
 export declare const collationsOf: (own: readonly Readonly<AnySymbol>[], inherited: readonly Readonly<AnySymbol>[], locate: Locate, tolerance?: CollationTolerance) => Collation[];
 /**
- * The motivation a collation writes on what it makes, saying that
- * nobody has read it yet.
+ * Whether the edit is the program's: one that a collation or a proposal
+ * wrote and nobody has explained, so that collating again or proposing
+ * the edits again may write it anew. It carries no belief and names no
+ * motivation of the editor's: only the kind of change it is, the generic
+ * musical or technical one a program states (`musicalChange`,
+ * `technicalChange`), or none.
  *
- * A collation produces its edits by a rule, and an edition that
- * publishes them unmarked would present a machine's output as an
- * editor's reading. Stating that they are unchecked is the honest
- * middle: the readings are there to be seen and argued with, and a
- * reader can tell which of them anybody has weighed.
+ * Everything else is the editor's and stays: an edit that says why it
+ * was made, or that is held under a belief. A grouping of the editor's stays theirs once it says
+ * why; one that says nothing reads as the program's would.
  *
- * It does not make an edit the editor's. `isCollationsOwn` passes over
- * this motivation exactly, so a collation rewrites what it marked
- * before, and only what somebody has actually written stays.
- * @category Collation and alignment
- */
-export declare const unchecked = "unchecked";
-/**
- * The version's statement of what the unchecked motivation means, to stand in its `motivations`.
- * @category Collation and alignment
- */
-export declare const uncheckedMotivation: {
-    readonly type: 'motivation';
-    readonly id: "unchecked";
-    readonly note: 'Made by collating the two texts and not yet read by an editor.';
-};
-/**
- * Whether the edit is one a collation writes by itself: a bare
- * insertion or a bare deletion saying nothing further, or a recoding
- * that exchanges two systems' spellings for one command.
- *
- * Collating again rewrites these and keeps the rest. An edit that says
- * what the change is, or why it was made, or what it rests on, is an
- * editor's reading of the difference between two texts, and collating
- * the two again is no reason to discard it.
- *
- * Such an exchange counts as the collation's own even where an editor
- * added a motivation to it, because it is derived rather than read:
- * freezing it would leave the transfers, where nearly every edit is
- * one, unable to be collated again at all. What an editor wrote on it
- * is not lost by that, since `connectVersions` keeps an exchange it
- * draws a second time over the very same symbols.
- *
- * A recoding that only inserts or only deletes is the editor's: a
- * collation types no one-sided edit, so one typed so is a reading of
- * the transfer that collating again must not undo.
- *
- * An edit a program proposed and typed is no reading of the editor's
- * either, as long as nobody has motivated it: it says so by belonging
- * to the proposition set the program's run concluded (`adoptEdits`).
+ * An exchange a collation draws again over the very same symbols is
+ * kept as it stands, with its identifier and whatever was written on
+ * it (`connectVersions`).
  * @category Collation and alignment
  */
 export declare const isCollationsOwn: (edit: Readonly<Edit>) => boolean;

package/lib/collation/Collation.js

@@ -1,4 +1,4 @@
-import { isHeldForItself, propositionSetOf } from "../model/Assumption.js";
+import { musicalChange, technicalChange } from "../model/Edit.js";
 import { keyOf } from "../systems/TrackerBar.js";
 import { distance, mm } from "../model/Quantity.js";
 import { partitionPoint } from "../shared/sorted.js";
@@ -107,60 +107,22 @@ export const collationsOf = (own, inherited, locate, tolerance = defaultCollatio
         .sort((a, b) => a.index - b.index)
         .map(({ symbol: counterpart }) => ({ symbol, counterpart })));
 };
-/** The edit type a collation draws by itself, from the two systems' vocabularies rather than off the paper. */
-const drawnByCollation = 'recoding';
 /**
- * The motivation a collation writes on what it makes, saying that
- * nobody has read it yet.
+ * Whether the edit is the program's: one that a collation or a proposal
+ * wrote and nobody has explained, so that collating again or proposing
+ * the edits again may write it anew. It carries no belief and names no
+ * motivation of the editor's: only the kind of change it is, the generic
+ * musical or technical one a program states (`musicalChange`,
+ * `technicalChange`), or none.
  *
- * A collation produces its edits by a rule, and an edition that
- * publishes them unmarked would present a machine's output as an
- * editor's reading. Stating that they are unchecked is the honest
- * middle: the readings are there to be seen and argued with, and a
- * reader can tell which of them anybody has weighed.
+ * Everything else is the editor's and stays: an edit that says why it
+ * was made, or that is held under a belief. A grouping of the editor's stays theirs once it says
+ * why; one that says nothing reads as the program's would.
  *
- * It does not make an edit the editor's. `isCollationsOwn` passes over
- * this motivation exactly, so a collation rewrites what it marked
- * before, and only what somebody has actually written stays.
+ * An exchange a collation draws again over the very same symbols is
+ * kept as it stands, with its identifier and whatever was written on
+ * it (`connectVersions`).
  * @category Collation and alignment
  */
-export const unchecked = 'unchecked';
-/**
- * The version's statement of what the unchecked motivation means, to stand in its `motivations`.
- * @category Collation and alignment
- */
-export const uncheckedMotivation = {
-    type: 'motivation',
-    id: unchecked,
-    note: 'Made by collating the two texts and not yet read by an editor.'
-};
-/**
- * Whether the edit is one a collation writes by itself: a bare
- * insertion or a bare deletion saying nothing further, or a recoding
- * that exchanges two systems' spellings for one command.
- *
- * Collating again rewrites these and keeps the rest. An edit that says
- * what the change is, or why it was made, or what it rests on, is an
- * editor's reading of the difference between two texts, and collating
- * the two again is no reason to discard it.
- *
- * Such an exchange counts as the collation's own even where an editor
- * added a motivation to it, because it is derived rather than read:
- * freezing it would leave the transfers, where nearly every edit is
- * one, unable to be collated again at all. What an editor wrote on it
- * is not lost by that, since `connectVersions` keeps an exchange it
- * draws a second time over the very same symbols.
- *
- * A recoding that only inserts or only deletes is the editor's: a
- * collation types no one-sided edit, so one typed so is a reading of
- * the transfer that collating again must not undo.
- *
- * An edit a program proposed and typed is no reading of the editor's
- * either, as long as nobody has motivated it: it says so by belonging
- * to the proposition set the program's run concluded (`adoptEdits`).
- * @category Collation and alignment
- */
-export const isCollationsOwn = (edit) => (edit.editType === drawnByCollation && !!edit.insert?.length && !!edit.delete?.length)
-    || ((edit.editType === undefined || propositionSetOf(edit) !== undefined)
-        && (edit.motivation === undefined || edit.motivation === unchecked)
-        && !isHeldForItself(edit));
+export const isCollationsOwn = (edit) => edit['@annotation'] === undefined
+    && (edit.motivation === undefined || edit.motivation === musicalChange || edit.motivation === technicalChange);

package/lib/filiation/adoption.d.ts

@@ -1,9 +1,7 @@
 import { Edition } from "../model/Edition.js";
-import { PropositionSet } from "../model/Assumption.js";
 import { Version } from "../model/Version.js";
 import { EditionOp } from "../ops/draft.js";
 import { StemmaProposal, Unpinned } from "./proposal.js";
-import { Run } from "./record.js";
 /**
  * What adopting a proposal makes of the stemma: the versions it puts in
  * place of the edition's, and what of the edition it leaves out.
@@ -18,11 +16,11 @@ export interface Adoption {
     /** The edits the editor wrote that the adoption leaves out, and why. */
     dropped: Unpinned[];
     /**
-     * The record of the run: the proposition set the derivations and
-     * edits the proposal concluded belong to, held under one belief
-     * whose reason is the inference the program drew.
+     * The published rules the proposal follows, as far as its costs and
+     * settings carry them out, which the edition's creation comes to
+     * name among its principles.
      */
-    propositionSet: PropositionSet;
+    principles: string[];
 }
 /**
  * What adopting the proposal makes of the edition's stemma, worked out
@@ -36,35 +34,33 @@ export interface Adoption {
  * the edits the editor wrote that the proposal keeps, as they are, and
  * one edit for each further reading it inserts or deletes, or for each
  * recoding. An edit the version stated before over the very same
- * readings is taken over with its id and what was written on it; the
- * others are new and marked unchecked, as a collation marks its own.
+ * readings is taken over with its id and what was written on it, the
+ * kind of change it states among it, which the editor may have said
+ * otherwise than the program read it; the others are new. An edit that
+ * states no kind has the motivation the shape of the change calls for
+ * (`motivationProposedFor`): the generic musical one, whose reason is
+ * left to the editor, or the technical one, which a recoding always has.
+ * The edits of the root state its text, and no kind of change.
  *
  * A reading that stands for a symbol of the edition keeps that symbol's
  * id and whatever it states beside its carriers. A version of the edition
  * nothing stands for goes, unless it states no edits and derives from a
  * version that stays, as a version known only from a recording does.
  *
- * What the program concluded is recorded as one proposition set, since
- * the search scores whole stemmata and concludes the whole: each
- * derivation it states and each edit it makes belongs to the set, which
- * holds them under one belief, likely unless the run says otherwise,
- * concluded by an inference that names this library and its release,
- * the copies it collated, the rules it followed and, in its note, what
- * it was computed with. A derivation or an edit that is the editor's,
- * held under a belief of its own or saying more than a program says,
- * stays the editor's and outside the set. The run gives who ran the
- * program and when (`Run`).
+ * What the program concluded is stated plainly, as an edition states its
+ * stemma. A derivation the editor holds under a belief of their own
+ * stays as it is, and so does every edit that says why it was made.
  * @category Filiation
  */
-export declare const adoptionOf: (edition: Edition, proposal: StemmaProposal, run?: Run) => Adoption;
+export declare const adoptionOf: (edition: Edition, proposal: StemmaProposal) => Adoption;
 /**
  * Puts the proposed stemma in place of the edition's, as `adoptionOf`
- * describes, with the record of the run, and takes back a copy's
- * statement that it carries a version that goes. The record of an
- * earlier run whose conclusions are all replaced goes with them, and
- * one of the very same run, by the same release on the same copies with
- * the same result, stays as it was first recorded. One operation, and
- * so one undo step.
+ * describes, and takes back a copy's statement that it carries a
+ * version that goes. The edition's creation comes to name the rules the
+ * proposal follows among its principles, in place of those of the
+ * stemma it no longer follows, and this release of the library among its
+ * software, which finds the stemma again with the defaults it has. One
+ * operation, and so one undo step.
  * @category Operations
  */
-export declare const adoptStemma: (proposal: StemmaProposal, run?: Run) => EditionOp;
+export declare const adoptStemma: (proposal: StemmaProposal) => EditionOp;

package/lib/filiation/adoption.js

@@ -1,14 +1,16 @@
 /** Taking a proposed stemma into the edition, as one operation. */
 import { v5 } from "uuid";
-import { assignReference, idOf, isHeldForItself } from "../model/Assumption.js";
+import { musicalChange, technicalChange } from "../model/Edit.js";
+import { isCollationsOwn } from "../collation/Collation.js";
+import { assignReference, idOf } from "../model/Assumption.js";
 import { derivesFrom, editsOf, insertedBy, principalDerivationOf } from "../model/Version.js";
 import { systemOf } from "../systems/TrackerBar.js";
-import { isCollationsOwn, unchecked } from "../collation/Collation.js";
 import { versionIn } from "../lookup/lookup.js";
-import { declaring, reading } from "../ops/draft.js";
+import { reading } from "../ops/draft.js";
 import { dropStatements } from "../ops/copies.js";
 import { barNamed } from "./systems.js";
-import { inMillimetres, keptSets, memberOf, recorded, stemmaRules } from "./record.js";
+import { madeWith, stemmaRules } from "./record.js";
+import { motivationOfChanges, proposedMotivations } from "./edits.js";
 /** The namespace the names of adopted versions and edits are minted in, so that adopting again gives them again. */
 const ADOPTED = '6f1d2c8e-93a4-4f0b-b8a1-2f4c5d7e9a31';
 /** The rules the proposal followed, as far as its costs and settings carry them out. */
@@ -22,35 +24,27 @@ const rulesOf = (proposal) => [
     stemmaRules.refinement,
     stemmaRules.noContamination
 ];
-/** A number as a note gives it: to two places at most. */
-const amount = (value) => String(Math.round(value * 100) / 100);
-/**
- * What the run of `proposeStemma` was, and what it was computed with, in
- * words, so that it can be run again: the copies by siglum, the costs,
- * the settings, and the margin by which the copies decide each grouping.
- */
-const noteOn = (edition, proposal) => {
-    const siglumOf = new Map(edition.copies.map(copy => [copy.id, copy.siglum ?? copy.id]));
-    const named = (copies) => copies.map(copy => siglumOf.get(copy) ?? copy).join(', ');
-    const { costs } = proposal;
-    const supports = proposal.supports.map(support => support.ancestor
-        ? `${named(support.ancestor)} above ${named(support.copies.filter(copy => !support.ancestor.includes(copy)))} by ${amount(support.margin)}`
-        : `${named(support.copies)} together by ${amount(support.margin)}`);
-    return [
-        `The stemma ${proposal.notation}, the best of ${proposal.scored} that ${named(proposal.copies)} admit, at a cost of ${amount(proposal.cost)}.`,
-        `A reading arising costs ${amount(costs.gain)}, a reading lost 1, a redundancy lost ${amount(costs.redundantLoss)}, a reading lost on the way into another system ${amount(costs.transferLoss)}, a copy lacking a reading of its version ${amount(costs.copyDeviation)}, and a lost state ${amount(costs.lostState)}.`,
-        `Copies of one system differing in ${proposal.sameText < 0 ? 'any reading' : `no more than ${proposal.sameText} readings`} are taken for one text; a reading of the same kind within ${inMillimetres(proposal.movedWithin)} on the other side of the root for a moved one; and ${inMillimetres(proposal.margin)} beyond a copy's text or a tear for what the copy cannot show.`,
-        ...(supports.length > 0 ? [`The copies decide its groupings by: ${supports.join('; ')}.`] : [])
-    ].join(' ');
-};
-/** The set the run of `proposeStemma` concluded, held with the belief the run gives it. */
-const stemmaSetOf = (edition, proposal, run) => recorded('stemma', [proposal.copies, proposal.notation, proposal.costs, proposal.sameText, proposal.movedWithin, proposal.margin], { note: noteOn(edition, proposal), premises: [], used: [...proposal.copies], applies: rulesOf(proposal) }, run);
 const exchangeKey = (inserted, deleted) => `${[...inserted].sort().join(',')}/${[...deleted].sort().join(',')}`;
 /** The carriers of the reading, keeping what the edition states of those it held already. */
 const carriersOf = (reading, stated) => {
     const known = new Map(stated.map(carrier => [idOf(carrier), carrier]));
     return reading.carriers.map(id => known.get(id) ?? assignReference(id));
 };
+/** The version with its edits stating its text: no kind of change, though any reason the editor gave. */
+const withoutKinds = (version) => {
+    const kindOnly = (edit) => edit.motivation === musicalChange || edit.motivation === technicalChange;
+    if (!editsOf(version).some(kindOnly))
+        return version;
+    return {
+        ...version,
+        edits: editsOf(version).map(edit => {
+            if (!kindOnly(edit))
+                return edit;
+            const { motivation: _kind, ...text } = edit;
+            return text;
+        })
+    };
+};
 /**
  * What adopting the proposal makes of the edition's stemma, worked out
  * without changing it, so that it can be looked at first.
@@ -63,28 +57,26 @@ const carriersOf = (reading, stated) => {
  * the edits the editor wrote that the proposal keeps, as they are, and
  * one edit for each further reading it inserts or deletes, or for each
  * recoding. An edit the version stated before over the very same
- * readings is taken over with its id and what was written on it; the
- * others are new and marked unchecked, as a collation marks its own.
+ * readings is taken over with its id and what was written on it, the
+ * kind of change it states among it, which the editor may have said
+ * otherwise than the program read it; the others are new. An edit that
+ * states no kind has the motivation the shape of the change calls for
+ * (`motivationProposedFor`): the generic musical one, whose reason is
+ * left to the editor, or the technical one, which a recoding always has.
+ * The edits of the root state its text, and no kind of change.
  *
  * A reading that stands for a symbol of the edition keeps that symbol's
  * id and whatever it states beside its carriers. A version of the edition
  * nothing stands for goes, unless it states no edits and derives from a
  * version that stays, as a version known only from a recording does.
  *
- * What the program concluded is recorded as one proposition set, since
- * the search scores whole stemmata and concludes the whole: each
- * derivation it states and each edit it makes belongs to the set, which
- * holds them under one belief, likely unless the run says otherwise,
- * concluded by an inference that names this library and its release,
- * the copies it collated, the rules it followed and, in its note, what
- * it was computed with. A derivation or an edit that is the editor's,
- * held under a belief of its own or saying more than a program says,
- * stays the editor's and outside the set. The run gives who ran the
- * program and when (`Run`).
+ * What the program concluded is stated plainly, as an edition states its
+ * stemma. A derivation the editor holds under a belief of their own
+ * stays as it is, and so does every edit that says why it was made.
  * @category Filiation
  */
-export const adoptionOf = (edition, proposal, run = {}) => {
-    const set = stemmaSetOf(edition, proposal, run);
+export const adoptionOf = (edition, proposal) => {
+    const fresh = new Set();
     const readingOf = new Map(proposal.collation.readings.map(reading => [reading.id, reading]));
     const symbolIdOf = (reading) => proposal.symbols[reading] ?? reading;
     const existing = new Map(edition.versions.flatMap(insertedBy).map(symbol => [symbol.id, symbol]));
@@ -159,18 +151,15 @@ export const adoptionOf = (edition, proposal, run = {}) => {
             const key = exchangeKey(inserted, deleted);
             const same = statedBefore.get(key);
             const insert = inserts.map(reading => symbolOf(reading, proposed.id));
-            if (same) {
-                const taken = { ...same, ...(insert.length > 0 && { insert }), ...(deleted.length > 0 && { delete: deleted }) };
-                return isCollationsOwn(same) ? memberOf(set.id, taken) : taken;
-            }
-            return memberOf(set.id, {
-                type: 'edit',
-                id: v5(`edit|${id}|${key}`, ADOPTED),
-                ...(recoding && { editType: 'recoding' }),
-                motivation: unchecked,
-                ...(insert.length > 0 && { insert }),
-                ...(deleted.length > 0 && { delete: deleted })
-            });
+            const exchange = { ...(insert.length > 0 && { insert }), ...(deleted.length > 0 && { delete: deleted }) };
+            // An edit over the same changes stays, with the kind of change it states, which the editor may have said.
+            if (same && (!isCollationsOwn(same) || same.motivation !== undefined))
+                return { ...same, ...exchange };
+            const made = { ...(same ?? { type: 'edit', id: v5(`edit|${id}|${key}`, ADOPTED) }), ...(recoding && { motivation: technicalChange }), ...exchange };
+            // A recoding is technical; the motivation of any other change is read off its shape below.
+            if (!recoding)
+                fresh.add(made.id);
+            return made;
         };
         // A recoding an edit of the editor's cuts into is stated reading by reading.
         const whole = proposed.recodings.filter(recoding => ![...recoding.by.map(reading => symbolIdAt(reading, proposed.id)), ...recoding.replaced.map(reading => inheritedAt(reading, proposed.id))]
@@ -182,13 +171,11 @@ export const adoptionOf = (edition, proposal, run = {}) => {
             ...proposed.inserts.filter(reading => !recoded.has(reading)).map(reading => made([reading], [], false)),
             ...proposed.deletes.filter(reading => !recoded.has(reading)).map(reading => made([], [reading], false))
         ].filter((edit) => edit !== undefined);
-        // The derivation is the set's, unless the editor holds it for reasons of their own.
+        // A derivation stated before is kept with what it states, a belief of the editor's among it.
         const parent = proposed.parent ? ids.get(proposed.parent) : undefined;
         const principal = before && principalDerivationOf(before);
         const same = principal && idOf(principal) === parent ? principal : undefined;
-        const derivation = parent === undefined
-            ? undefined
-            : same && isHeldForItself(same) ? same : memberOf(set.id, same ?? assignReference(parent));
+        const derivation = parent === undefined ? undefined : same ?? assignReference(parent);
         const hypotheses = (before?.basedOn ?? [])
             .filter(other => other !== principal && staying.has(idOf(other)) && idOf(other) !== parent);
         const basedOn = [...(derivation ? [derivation] : []), ...hypotheses];
@@ -201,8 +188,7 @@ export const adoptionOf = (edition, proposal, run = {}) => {
             id,
             system,
             ...(basedOn.length > 0 && { basedOn }),
-            edits,
-            motivations: declaring(before?.motivations ?? [], edits)
+            edits
         };
     });
     // A hypothesis may not name a version that now derives from the one stating it.
@@ -222,28 +208,40 @@ export const adoptionOf = (edition, proposal, run = {}) => {
     // The edition's order where a version stays, the new ones after it.
     const rank = new Map(edition.versions.map((version, index) => [version.id, index]));
     const ordered = [...pruned, ...statedOnly].sort((a, b) => (rank.get(a.id) ?? Infinity) - (rank.get(b.id) ?? Infinity));
-    return { versions: ordered, ids: Object.fromEntries(ids), removed, dropped: proposal.unpinned, propositionSet: set };
+    // A new edit's motivation follows from the shape of the change, read in the stemma adopted.
+    const adopted = { ...edition, versions: ordered };
+    const motivated = ordered.map(version => {
+        if (!principalDerivationOf(version))
+            return withoutKinds(version);
+        if (!editsOf(version).some(edit => fresh.has(edit.id)))
+            return version;
+        const motivations = proposedMotivations(adopted, version.id);
+        return {
+            ...version,
+            edits: editsOf(version).map(edit => fresh.has(edit.id)
+                ? { ...edit, motivation: motivationOfChanges(motivations, [...(edit.insert ?? []).map(symbol => symbol.id), ...(edit.delete ?? [])]) }
+                : edit)
+        };
+    });
+    return { versions: motivated, ids: Object.fromEntries(ids), removed, dropped: proposal.unpinned, principles: rulesOf(proposal) };
 };
 /**
  * Puts the proposed stemma in place of the edition's, as `adoptionOf`
- * describes, with the record of the run, and takes back a copy's
- * statement that it carries a version that goes. The record of an
- * earlier run whose conclusions are all replaced goes with them, and
- * one of the very same run, by the same release on the same copies with
- * the same result, stays as it was first recorded. One operation, and
- * so one undo step.
+ * describes, and takes back a copy's statement that it carries a
+ * version that goes. The edition's creation comes to name the rules the
+ * proposal follows among its principles, in place of those of the
+ * stemma it no longer follows, and this release of the library among its
+ * software, which finds the stemma again with the defaults it has. One
+ * operation, and so one undo step.
  * @category Operations
  */
-export const adoptStemma = (proposal, run = {}) => reading(edition => {
-    const { versions, removed, propositionSet } = adoptionOf(edition, proposal, run);
+export const adoptStemma = (proposal) => reading(edition => {
+    const { versions, removed, principles } = adoptionOf(edition, proposal);
     const gone = new Set(removed);
-    const sets = keptSets({ ...edition, versions }, [propositionSet]);
+    const creation = madeWith(edition.creation, principles, Object.values(stemmaRules));
     return draft => {
         draft.versions = versions;
         draft.copies.forEach(copy => dropStatements(copy, statement => gone.has(idOf(statement))));
-        if (sets)
-            draft.propositionSets = sets;
-        else
-            delete draft.propositionSets;
+        draft.creation = creation;
     };
 });