linked-rolls 0.74.0 → 0.75.0

package/README.md

@@ -132,6 +132,24 @@ 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.
+
+```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], … }] } }]
+```
+
 The costs are those with which the stemma of WM 225 comes out of its
 six copies. They were found by searching for such values, so they show
 that the stemma is consistent with these principles, not that the
@@ -151,7 +169,11 @@ 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 wrote and nobody has motivated, and keeps the rest.
+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.
 
 ```ts
 import { adoptEdits, adoptStemma, proposeEdits, proposeStemma } from 'linked-rolls'
@@ -167,10 +189,12 @@ 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. On WM 225 the proposal reproduces 370 of the 414 edits the
-editor wrote, from what each version changes, and all of their types
-but the shifts the editor took for corrected errors. From the copies
-alone, through the proposed stemma, it reproduces 326.
+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.
 
 ## Format
 
@@ -182,7 +206,12 @@ 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.
+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.
 
 ## Development
 
@@ -199,11 +228,12 @@ TypeScript 7 no longer has the compiler API it reads the source with.
 
 ## Releasing
 
-Raise the version in `package.json` and in `CITATION.cff`, there with
-the day as `date-released`, 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 two versions differ.
+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
+`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.
 
 ## About
 

package/lib/collation/Collation.d.ts

@@ -164,6 +164,10 @@ export declare const uncheckedMotivation: {
  * 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 declare const isCollationsOwn: (edit: Readonly<Edit>) => boolean;

package/lib/collation/Collation.js

@@ -1,3 +1,4 @@
+import { isHeldForItself, propositionSetOf } from "../model/Assumption.js";
 import { keyOf } from "../systems/TrackerBar.js";
 import { distance, mm } from "../model/Quantity.js";
 import { partitionPoint } from "../shared/sorted.js";
@@ -153,9 +154,13 @@ export const uncheckedMotivation = {
  * 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
+    || ((edit.editType === undefined || propositionSetOf(edit) !== undefined)
         && (edit.motivation === undefined || edit.motivation === unchecked)
-        && edit['@annotation'] === undefined);
+        && !isHeldForItself(edit));

package/lib/filiation/adoption.d.ts

@@ -1,7 +1,9 @@
 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.
@@ -15,6 +17,12 @@ export interface Adoption {
     removed: string[];
     /** 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.
+     */
+    propositionSet: PropositionSet;
 }
 /**
  * What adopting the proposal makes of the edition's stemma, worked out
@@ -35,13 +43,28 @@ export interface Adoption {
  * 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`).
  * @category Filiation
  */
-export declare const adoptionOf: (edition: Edition, proposal: StemmaProposal) => Adoption;
+export declare const adoptionOf: (edition: Edition, proposal: StemmaProposal, run?: Run) => Adoption;
 /**
  * Puts the proposed stemma in place of the edition's, as `adoptionOf`
- * describes, and takes back a copy's statement that it carries a version
- * that goes. One operation, and so one undo step.
+ * 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.
  * @category Operations
  */
-export declare const adoptStemma: (proposal: StemmaProposal) => EditionOp;
+export declare const adoptStemma: (proposal: StemmaProposal, run?: Run) => EditionOp;

package/lib/filiation/adoption.js

@@ -1,15 +1,50 @@
 /** Taking a proposed stemma into the edition, as one operation. */
 import { v5 } from "uuid";
-import { assignReference, idOf } from "../model/Assumption.js";
+import { assignReference, idOf, isHeldForItself } from "../model/Assumption.js";
 import { derivesFrom, editsOf, insertedBy, principalDerivationOf } from "../model/Version.js";
 import { systemOf } from "../systems/TrackerBar.js";
-import { unchecked } from "../collation/Collation.js";
+import { isCollationsOwn, unchecked } from "../collation/Collation.js";
 import { versionIn } from "../lookup/lookup.js";
 import { declaring, 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";
 /** 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. */
+const rulesOf = (proposal) => [
+    ...(proposal.costs.gain > 1 ? [stemmaRules.sharedAddition] : []),
+    ...(proposal.costs.redundantLoss < 1 ? [stemmaRules.independentCleanup] : []),
+    ...(proposal.costs.transferLoss < 1 ? [stemmaRules.recutLoss] : []),
+    ...(Number.isFinite(proposal.costs.copyDeviation) ? [stemmaRules.copyDeviation] : []),
+    ...(proposal.costs.lostState > 0 ? [stemmaRules.lostStates] : []),
+    ...(proposal.sameText >= 0 ? [stemmaRules.oneText] : []),
+    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) => {
@@ -35,9 +70,21 @@ const carriersOf = (reading, stated) => {
  * 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`).
  * @category Filiation
  */
-export const adoptionOf = (edition, proposal) => {
+export const adoptionOf = (edition, proposal, run = {}) => {
+    const set = stemmaSetOf(edition, proposal, run);
     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]));
@@ -112,16 +159,18 @@ export const adoptionOf = (edition, proposal) => {
             const key = exchangeKey(inserted, deleted);
             const same = statedBefore.get(key);
             const insert = inserts.map(reading => symbolOf(reading, proposed.id));
-            if (same)
-                return { ...same, ...(insert.length > 0 && { insert }), ...(deleted.length > 0 && { delete: deleted }) };
-            return {
+            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 })
-            };
+            });
         };
         // 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))]
@@ -133,11 +182,13 @@ export const adoptionOf = (edition, proposal) => {
             ...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.
         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
-            : principal && idOf(principal) === parent ? principal : assignReference(parent);
+            : same && isHeldForItself(same) ? same : memberOf(set.id, same ?? assignReference(parent));
         const hypotheses = (before?.basedOn ?? [])
             .filter(other => other !== principal && staying.has(idOf(other)) && idOf(other) !== parent);
         const basedOn = [...(derivation ? [derivation] : []), ...hypotheses];
@@ -171,19 +222,28 @@ export const adoptionOf = (edition, proposal) => {
     // 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 };
+    return { versions: ordered, ids: Object.fromEntries(ids), removed, dropped: proposal.unpinned, propositionSet: set };
 };
 /**
  * Puts the proposed stemma in place of the edition's, as `adoptionOf`
- * describes, and takes back a copy's statement that it carries a version
- * that goes. One operation, and so one undo step.
+ * 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.
  * @category Operations
  */
-export const adoptStemma = (proposal) => reading(edition => {
-    const { versions, removed } = adoptionOf(edition, proposal);
+export const adoptStemma = (proposal, run = {}) => reading(edition => {
+    const { versions, removed, propositionSet } = adoptionOf(edition, proposal, run);
     const gone = new Set(removed);
+    const sets = keptSets({ ...edition, versions }, [propositionSet]);
     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;
     };
 });

package/lib/filiation/edits.d.ts

@@ -2,6 +2,7 @@ import { Edition } from "../model/Edition.js";
 import { Edit, EditType } from "../model/Edit.js";
 import { Millimeters } from "../model/Quantity.js";
 import { EditionOp } from "../ops/draft.js";
+import { Run } from "./record.js";
 /**
  * How far a perforation may be put from where it stood for the two to be
  * one move. WM 225 moves commands by up to about 60 mm.
@@ -129,6 +130,16 @@ export declare const isRegroupable: (edit: Readonly<Edit>) => boolean;
  *
  * Applied on the same draft after `adoptStemma`, it proposes the edits of
  * the stemma adopted, as one undo step.
+ *
+ * The edits it proposes are recorded as one proposition set, held under
+ * one belief, likely unless the run says otherwise, whose reason is the
+ * inference the program drew: it names this library and its release,
+ * the versions it read, the rule that keeps an edit at one place and, in
+ * its note, the distances it grouped with, and it rests on the beliefs
+ * the derivations of the versions are held with. An edit of the set
+ * that nobody has motivated is the program's, typed and all, and a
+ * later proposal groups it again. The run gives who ran the program and
+ * when (`Run`).
  * @category Operations
  */
-export declare const adoptEdits: (versionIds?: readonly string[], options?: EditOptions) => EditionOp;
+export declare const adoptEdits: (versionIds?: readonly string[], options?: EditOptions, run?: Run) => EditionOp;

package/lib/filiation/edits.js

@@ -4,7 +4,8 @@
  * group is. Why a change was made is left to the editor.
  */
 import { v5 } from "uuid";
-import { deletedBy, editsOf, insertedBy } from "../model/Version.js";
+import { beliefIn } from "../model/Assumption.js";
+import { deletedBy, editsOf, insertedBy, principalDerivationOf } from "../model/Version.js";
 import { distance, mm, subtract } from "../model/Quantity.js";
 import { trackerBarOf } from "../systems/index.js";
 import { operationOf, substitutionsBetween } from "../collation/substitution.js";
@@ -16,6 +17,7 @@ import { groupBy } from "../shared/utils.js";
 import { declaring, reading } from "../ops/draft.js";
 import { ineffectiveAmong } from "./presence.js";
 import { reads } from "./readings.js";
+import { editRules, inMillimetres, keptSets, memberOf, recorded } from "./record.js";
 /**
  * How far a perforation may be put from where it stood for the two to be
  * one move. WM 225 moves commands by up to about 60 mm.
@@ -479,8 +481,17 @@ const adoptedEditsOf = (edition, version, options) => {
         // What an edit that stays leaves of a proposed one stands symbol by symbol.
         return [...inserted.map(id => made([id], [])), ...deleted.map(id => made([], [id]))];
     });
-    return [...held, ...proposed];
+    return { held, proposed };
 };
+/**
+ * What the run of `proposeEdits` was computed with, in words, so that it
+ * can be run again.
+ */
+const noteOn = (settings) => 'The changes of each version against the version it derives from, grouped line by line and never across a command both texts keep. '
+    + `A perforation put elsewhere within ${inMillimetres(settings.shiftWithin)} is one move with the one it replaces, `
+    + `an Off within ${inMillimetres(settings.pairWithin)} of an On one function turned on and off again, `
+    + `a perforation beginning within ${inMillimetres(settings.resizeWithin)} of the one it replaces a shortened or prolonged one, `
+    + `and perforations within ${inMillimetres(settings.samePlaceWithin)} of each other at one place.`;
 /**
  * Puts the proposed edits (`proposeEdits`) in place of those of the
  * versions that a collation or an adoption wrote and nobody has given a
@@ -495,19 +506,35 @@ const adoptedEditsOf = (edition, version, options) => {
  *
  * Applied on the same draft after `adoptStemma`, it proposes the edits of
  * the stemma adopted, as one undo step.
+ *
+ * The edits it proposes are recorded as one proposition set, held under
+ * one belief, likely unless the run says otherwise, whose reason is the
+ * inference the program drew: it names this library and its release,
+ * the versions it read, the rule that keeps an edit at one place and, in
+ * its note, the distances it grouped with, and it rests on the beliefs
+ * the derivations of the versions are held with. An edit of the set
+ * that nobody has motivated is the program's, typed and all, and a
+ * later proposal groups it again. The run gives who ran the program and
+ * when (`Run`).
  * @category Operations
  */
-export const adoptEdits = (versionIds, options = {}) => reading(edition => {
+export const adoptEdits = (versionIds, options = {}, run = {}) => reading(edition => {
     const targets = (versionIds ?? edition.versions.map(version => version.id))
         .map(id => versionIn(edition, id))
         .filter((version) => version !== undefined && predecessorOf(edition, version.id) !== undefined);
-    const adopted = new Map(targets.flatMap(version => {
-        const edits = adoptedEditsOf(edition, version, options);
+    const regrouped = targets.map(version => ({ version, ...adoptedEditsOf(edition, version, options) }));
+    const set = editSetOf(edition, regrouped, options, run);
+    const adopted = new Map(regrouped.flatMap(({ version, held, proposed }) => {
+        const edits = [...held, ...proposed.map(edit => memberOf(set.id, edit))];
         const stated = editsOf(version);
         if (edits.length === stated.length && edits.every((edit, index) => edit === stated[index]))
             return [];
         return [[version.id, { ...version, edits, motivations: declaring(version.motivations, edits) }]];
     }));
+    const sets = keptSets({
+        ...edition,
+        versions: edition.versions.map(version => adopted.get(version.id) ?? version)
+    }, [set]);
     // Each version is put in place whole: one that an operation before put
     // on the same draft, as adopting a stemma does, is no draft to write to.
     return draft => {
@@ -516,5 +543,27 @@ export const adoptEdits = (versionIds, options = {}) => reading(edition => {
             if (changed)
                 draft.versions[index] = changed;
         });
+        if (sets)
+            draft.propositionSets = sets;
+        else
+            delete draft.propositionSets;
     };
 });
+/**
+ * The set the run of `proposeEdits` concluded: the edits it proposed for
+ * the versions, held with the belief the run gives them. Its premises
+ * are the beliefs the derivations of those versions are held with, since
+ * what a version changes is read against the version it derives from: a
+ * proposed stemma's, where the derivation belongs to one.
+ */
+const editSetOf = (edition, regrouped, options, run) => {
+    const settings = settingsOf(options);
+    const proposing = regrouped.filter(({ proposed }) => proposed.length > 0);
+    const premises = [...new Set(proposing.flatMap(({ version }) => {
+            const derivation = principalDerivationOf(version);
+            const belief = derivation && beliefIn(edition, derivation);
+            return belief ? [belief.id] : [];
+        }))];
+    const used = [...new Set(proposing.flatMap(({ version }) => [predecessorOf(edition, version.id).id, version.id]))];
+    return recorded('edits', [settings, premises, proposing.map(({ version, proposed }) => [version.id, proposed.map(edit => edit.id)])], { note: noteOn(settings), premises, used, applies: [editRules.onePlace] }, run);
+};

package/lib/filiation/index.d.ts

@@ -9,6 +9,7 @@ export { defaultCosts, type Costs, type Scored, type Support } from "./search.js
 export { transfersOf, systemAbove } from "./systems.js";
 export { proposeStemma, defaultMovedWithin, type FiliationOptions, type ProposedVersion, type StemmaProposal, type Unpinned } from "./proposal.js";
 export { adoptionOf, adoptStemma, type Adoption } from "./adoption.js";
+export { stemmaRules, editRules, type Run } from "./record.js";
 export { stemmaChanges, type VersionChange } from "./changes.js";
 export { sharedTexts, differencesBetween, defaultSameText, type SharedText, type KeptApart } from "./texts.js";
 export { proposeEdits, adoptEdits, isRegroupable, defaultShiftWithin, defaultPairWithin, defaultResizeWithin, defaultSamePlaceWithin, type EditOptions, type EditGrouping, type ProposedEdit } from "./edits.js";

package/lib/filiation/index.js

@@ -9,6 +9,7 @@ export { defaultCosts } from "./search.js";
 export { transfersOf, systemAbove } from "./systems.js";
 export { proposeStemma, defaultMovedWithin } from "./proposal.js";
 export { adoptionOf, adoptStemma } from "./adoption.js";
+export { stemmaRules, editRules } from "./record.js";
 export { stemmaChanges } from "./changes.js";
 export { sharedTexts, differencesBetween, defaultSameText } from "./texts.js";
 export { proposeEdits, adoptEdits, isRegroupable, defaultShiftWithin, defaultPairWithin, defaultResizeWithin, defaultSamePlaceWithin } from "./edits.js";

package/lib/filiation/record.d.ts

@@ -0,0 +1,79 @@
+import { ActorAssignment, Assumption, Certainty, PropositionSet, TimeSpan } from "../model/Assumption.js";
+import { Edition } from "../model/Edition.js";
+/**
+ * The published rules the proposal of a stemma follows, by IRI, each
+ * under the cost or the step that carries it out. They are the
+ * editorial principles of the edition of WM 225, which are suggested
+ * for the filiation of piano rolls at large.
+ * @category Filiation
+ */
+export declare const stemmaRules: {
+    /** An addition at the same place is not made twice independently, so a reading arising costs ten times one lost. */
+    readonly sharedAddition: 'https://welte225.org/rules#shared-addition';
+    /** Redundancies are cleaned up in two branches independently, so losing one counts for less. */
+    readonly independentCleanup: 'https://welte225.org/rules#independent-cleanup';
+    /** A re-cut for another system was an editorial pass of its own, so what it lacks counts for less. */
+    readonly recutLoss: 'https://welte225.org/rules#recut-loss';
+    /** A copy may fail to show a reading of the version it carries. */
+    readonly copyDeviation: 'https://welte225.org/rules#copy-deviation';
+    /** A lost state is posited only where shared additions require it. */
+    readonly lostStates: 'https://welte225.org/rules#lost-states';
+    /** Copies of one system that differ in a few readings carry one text. */
+    readonly oneText: 'https://welte225.org/rules#one-text';
+    /** Later versions are the more refined, which orients the root. */
+    readonly refinement: 'https://welte225.org/rules#refinement';
+    /** A version derives from one exemplar, so a stemma is a tree. */
+    readonly noContamination: 'https://welte225.org/rules#no-contamination';
+};
+/**
+ * The published rules the proposal of edits follows, by IRI.
+ * @category Filiation
+ */
+export declare const editRules: {
+    /** An edit stays at one place: it runs across no command both texts keep. */
+    readonly onePlace: 'https://welte225.org/rules#one-place';
+};
+/**
+ * What is known of a run of a program beside what it computed: who ran
+ * it, when, how firmly what it concluded is held, and by which
+ * published rules. An adoption records the run with it; whatever is left
+ * out is not stated.
+ * @category Filiation
+ */
+export interface Run {
+    /** Who ran the program and so holds what it concluded: the editor. */
+    actor?: ActorAssignment;
+    /** When it ran. */
+    date?: TimeSpan;
+    /** How firmly what it concluded is held: likely, where nothing else is said. */
+    certainty?: Certainty;
+    /** The rules it followed, by IRI, in place of those the library names (`stemmaRules`, `editRules`). */
+    applies?: string[];
+}
+/** What a recorded run concluded besides its statements: what the inference says of itself. */
+export interface Concluded {
+    /** What the run is, and what it was computed with, in words. */
+    note: string;
+    premises: string[];
+    used: string[];
+    applies: string[];
+}
+/**
+ * The proposition set of a run, with its belief and the inference it
+ * rests on. Its id follows from what it is given, so that recording the
+ * same run again gives the same set.
+ */
+export declare const recorded: (kind: string, identity: unknown, concluded: Concluded, run: Run) => PropositionSet;
+/** The statement as one of the set: its annotation names the set, and it carries no belief of its own. */
+export declare const memberOf: <T extends Assumption>(set: string, statement: T) => T;
+/**
+ * The sets the edition keeps, with those given added where it holds none
+ * with their id: a set already recorded stays as it was recorded, by
+ * whom and when it was first concluded. Kept are the sets a statement
+ * belongs to, and those whose belief the reasons of another kept
+ * statement or set name as a premise. A set nothing names any longer is
+ * the record of a run whose conclusions have all been replaced.
+ */
+export declare const keptSets: (edition: Edition, adding: readonly PropositionSet[]) => PropositionSet[] | undefined;
+/** A distance in millimetres as a note gives it. */
+export declare const inMillimetres: (value: number) => string;