linked-rolls 0.75.0 → 0.76.0

package/lib/filiation/edits.d.ts

@@ -1,8 +1,7 @@
 import { Edition } from "../model/Edition.js";
-import { Edit, EditType } from "../model/Edit.js";
+import { EditShape } 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.
@@ -70,8 +69,8 @@ export interface ProposedEdit {
     insert: string[];
     /** The ids of the symbols it deletes, in the order of their places. */
     delete: string[];
-    /** The kind of change, where its shape says. */
-    editType?: EditType;
+    /** The shape of the change, where it takes one the program knows. */
+    shape?: EditShape;
     grouping: EditGrouping;
 }
 /**
@@ -95,8 +94,8 @@ export interface ProposedEdit {
  * punched across three lines or more at one place are one edit, as a
  * cancel row is.
  *
- * The type is read off the shape: a pair the bar spells an accent with is
- * an additional accent, as is a note set off from its chord by a few
+ * The shape is read off the group: a pair the bar spells an accent with
+ * is an additional accent, as is a note set off from its chord by a few
  * millimetres where the version puts an accent's On; a perforation put
  * elsewhere is a shift, or where it begins about where the other did,
  * shortened or prolonged; a note struck again is shortened, two tied
@@ -111,35 +110,41 @@ export interface ProposedEdit {
  */
 export declare const proposeEdits: (edition: Edition, versionId: string, options?: EditOptions) => ProposedEdit[];
 /**
- * Whether the edit is left for a proposal to group again: one a
- * collation or an adoption wrote, that nobody has given a motivation.
+ * The motivation a program states for each change the version makes,
+ * by the id of the symbol it inserts or deletes: the one the shape of
+ * the proposed edit it belongs to calls for (`motivationProposedFor`),
+ * musical or technical. A version that derives from none makes no
+ * change, and its symbols are given none.
  * @category Filiation
  */
-export declare const isRegroupable: (edit: Readonly<Edit>) => boolean;
+export declare const proposedMotivations: (edition: Edition, versionId: string, options?: EditOptions) => ReadonlyMap<string, string>;
 /**
- * Puts the proposed edits (`proposeEdits`) in place of those of the
- * versions that a collation or an adoption wrote and nobody has given a
- * motivation, every version but the root where none are named. An edit
- * someone motivated, typed beyond what a collation types, or held under a
- * belief stays as it is, and what a proposed edit shares with it stands
- * symbol by symbol beside it. An edit stated already over the very same
- * symbols as a proposed one is kept with its id and what was written on
- * it, the proposed type filled in where it states none; the others are
- * new, with ids that adopting again gives again, and marked unchecked,
- * so that what is left to the editor is to say why.
+ * The motivation a program states for an edit making these changes:
+ * the generic musical one where any of them is a musical change, or one
+ * the proposal does not see, and the technical one where all are
+ * technical.
+ */
+export declare const motivationOfChanges: (motivations: ReadonlyMap<string, string>, symbolIds: readonly string[]) => string;
+/**
+ * Puts the proposed edits (`proposeEdits`) in place of the program's
+ * edits of the versions, every version but the root where none are
+ * named: those that say nothing of why they were made, or only that they
+ * are musical or technical changes (`isCollationsOwn`). An edit with a
+ * motivation of the editor's or held under a belief stays as it is, and
+ * what a proposed edit shares with it stands symbol by symbol beside it.
+ * An edit stated already over the very same symbols as a proposed one
+ * is kept with its id and the kind of change it states, which the
+ * editor may have said otherwise than the program read it; the others
+ * are new, with ids that adopting again gives again. An edit that
+ * states no kind has the motivation its shape calls for
+ * (`motivationProposedFor`): the generic musical one for a musical
+ * change, whose reason is left to the editor, and the technical one for
+ * a technical change.
  *
  * 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`).
+ * the stemma adopted, as one undo step. The edition's creation comes to
+ * name the rule that keeps an edit at one place among its principles,
+ * and this release among its software.
  * @category Operations
  */
-export declare const adoptEdits: (versionIds?: readonly string[], options?: EditOptions, run?: Run) => EditionOp;
+export declare const adoptEdits: (versionIds?: readonly string[], options?: EditOptions) => EditionOp;

package/lib/filiation/edits.js

@@ -1,23 +1,24 @@
 /**
  * The edits of a version, proposed from what it inserts and deletes:
- * which of its changes belong together, and what kind of change each
- * group is. Why a change was made is left to the editor.
+ * which of its changes belong together, and what shape each group
+ * takes, from which the motivation a program can give it follows. Why
+ * a musical change was made is left to the editor.
  */
 import { v5 } from "uuid";
-import { beliefIn } from "../model/Assumption.js";
-import { deletedBy, editsOf, insertedBy, principalDerivationOf } from "../model/Version.js";
+import { motivationProposedFor, musicalChange, technicalChange } from "../model/Edit.js";
+import { deletedBy, editsOf, insertedBy } 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";
-import { isCollationsOwn, unchecked } from "../collation/Collation.js";
+import { isCollationsOwn } from "../collation/Collation.js";
 import { predecessorOf } from "../analysis/stemma.js";
 import { placeOf, snapshotOf } from "../analysis/text.js";
 import { symbolsIn, versionIn } from "../lookup/lookup.js";
 import { groupBy } from "../shared/utils.js";
-import { declaring, reading } from "../ops/draft.js";
+import { reading } from "../ops/draft.js";
 import { ineffectiveAmong } from "./presence.js";
 import { reads } from "./readings.js";
-import { editRules, inMillimetres, keptSets, memberOf, recorded } from "./record.js";
+import { editRules, madeWith } 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.
@@ -280,8 +281,8 @@ const rowsAmong = (groups, within) => {
 };
 /** Whether the bar spells an accent with exactly these commands. */
 const spellsAccent = (bar, types) => (bar?.accents ?? []).some(accent => sameSequence(types, accent));
-/** What kind of change a group is, where its shape says. */
-const typeOf = (group, bar, accentsAt, options) => {
+/** The shape a group of changes takes, where it is one the program knows. */
+const shapeOfGroup = (group, bar, accentsAt, options) => {
     const inserted = inOrder(ofSide(group.changes, 'insert'));
     const deleted = inOrder(ofSide(group.changes, 'delete'));
     if (group.grouping === 'substitution' || group.changes.some(change => change.foreign))
@@ -345,8 +346,8 @@ const settingsOf = (options) => ({
  * punched across three lines or more at one place are one edit, as a
  * cancel row is.
  *
- * The type is read off the shape: a pair the bar spells an accent with is
- * an additional accent, as is a note set off from its chord by a few
+ * The shape is read off the group: a pair the bar spells an accent with
+ * is an additional accent, as is a note set off from its chord by a few
  * millimetres where the version puts an accent's On; a perforation put
  * elsewhere is a shift, or where it begins about where the other did,
  * shortened or prolonged; a note struck again is shortened, two tied
@@ -429,11 +430,11 @@ export const proposeEdits = (edition, versionId, options = {}) => {
     const proposed = [...substituted, ...recoded, ...lines, ...rows]
         .sort((a, b) => byPlace(inOrder(a.changes)[0], inOrder(b.changes)[0]))
         .map((group) => {
-        const editType = typeOf(group, bar, accentsAt, settings);
+        const shape = shapeOfGroup(group, bar, accentsAt, settings);
         return {
             insert: inOrder(ofSide(group.changes, 'insert')).map(change => change.symbol.id),
             delete: inOrder(ofSide(group.changes, 'delete')).map(change => change.symbol.id),
-            ...(editType && { editType }),
+            ...(shape && { shape }),
             grouping: group.grouping
         };
     });
@@ -443,98 +444,102 @@ export const proposeEdits = (edition, versionId, options = {}) => {
 const EDITS = '3c9e0f62-1d4b-4a7e-9b55-8e2f7a6d1c04';
 const exchangeKey = (inserted, deleted) => `${[...inserted].sort().join(',')}/${[...deleted].sort().join(',')}`;
 /**
- * Whether the edit is left for a proposal to group again: one a
- * collation or an adoption wrote, that nobody has given a motivation.
+ * The motivation a program states for each change the version makes,
+ * by the id of the symbol it inserts or deletes: the one the shape of
+ * the proposed edit it belongs to calls for (`motivationProposedFor`),
+ * musical or technical. A version that derives from none makes no
+ * change, and its symbols are given none.
  * @category Filiation
  */
-export const isRegroupable = (edit) => isCollationsOwn(edit) && (edit.motivation === undefined || edit.motivation === unchecked);
+export const proposedMotivations = (edition, versionId, options = {}) => {
+    const motivations = new Map();
+    if (!predecessorOf(edition, versionId))
+        return motivations;
+    for (const edit of proposeEdits(edition, versionId, options)) {
+        const motivation = motivationProposedFor(edit.shape);
+        for (const id of [...edit.insert, ...edit.delete])
+            motivations.set(id, motivation);
+    }
+    return motivations;
+};
+/**
+ * The motivation a program states for an edit making these changes:
+ * the generic musical one where any of them is a musical change, or one
+ * the proposal does not see, and the technical one where all are
+ * technical.
+ */
+export const motivationOfChanges = (motivations, symbolIds) => symbolIds.some(id => (motivations.get(id) ?? musicalChange) === musicalChange) ? musicalChange : technicalChange;
 /**
  * The edits the version comes to state when the proposal is adopted:
  * those it keeps, and those put in place of the rest.
  */
 const adoptedEditsOf = (edition, version, options) => {
     const edits = editsOf(version);
-    const held = edits.filter(edit => !isRegroupable(edit));
+    const held = edits.filter(edit => !isCollationsOwn(edit));
     const spoken = new Set(held.flatMap(edit => [...(edit.insert ?? []).map(symbol => symbol.id), ...(edit.delete ?? [])]));
     const symbolOf = new Map(insertedBy(version).map(symbol => [symbol.id, symbol]));
     const stated = new Map(edits.map(edit => [exchangeKey((edit.insert ?? []).map(symbol => symbol.id), edit.delete ?? []), edit]));
-    const made = (inserted, deleted, editType) => {
+    const made = (inserted, deleted, motivation) => {
         const key = exchangeKey(inserted, deleted);
         const same = stated.get(key);
+        // An edit over the same changes stays, with the kind of change it states, which the editor may have said.
         if (same)
-            return same.editType || !editType ? same : { ...same, editType };
+            return same.motivation === undefined ? { ...same, motivation } : same;
         return {
             type: 'edit',
             id: v5(`edit|${version.id}|${key}`, EDITS),
-            ...(editType && { editType }),
-            motivation: unchecked,
+            motivation,
             ...(inserted.length > 0 && { insert: inserted.map(id => symbolOf.get(id)) }),
             ...(deleted.length > 0 && { delete: [...deleted] })
         };
     };
     const proposed = proposeEdits(edition, version.id, options).flatMap(edit => {
+        const motivation = motivationProposedFor(edit.shape);
         const free = (ids) => ids.filter(id => !spoken.has(id));
         const [inserted, deleted] = [free(edit.insert), free(edit.delete)];
         if (inserted.length === edit.insert.length && deleted.length === edit.delete.length) {
-            return [made(inserted, deleted, edit.editType)];
+            return [made(inserted, deleted, motivation)];
         }
         // 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 [...inserted.map(id => made([id], [], motivation)), ...deleted.map(id => made([], [id], motivation))];
     });
     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
- * motivation, every version but the root where none are named. An edit
- * someone motivated, typed beyond what a collation types, or held under a
- * belief stays as it is, and what a proposed edit shares with it stands
- * symbol by symbol beside it. An edit stated already over the very same
- * symbols as a proposed one is kept with its id and what was written on
- * it, the proposed type filled in where it states none; the others are
- * new, with ids that adopting again gives again, and marked unchecked,
- * so that what is left to the editor is to say why.
+ * Puts the proposed edits (`proposeEdits`) in place of the program's
+ * edits of the versions, every version but the root where none are
+ * named: those that say nothing of why they were made, or only that they
+ * are musical or technical changes (`isCollationsOwn`). An edit with a
+ * motivation of the editor's or held under a belief stays as it is, and
+ * what a proposed edit shares with it stands symbol by symbol beside it.
+ * An edit stated already over the very same symbols as a proposed one
+ * is kept with its id and the kind of change it states, which the
+ * editor may have said otherwise than the program read it; the others
+ * are new, with ids that adopting again gives again. An edit that
+ * states no kind has the motivation its shape calls for
+ * (`motivationProposedFor`): the generic musical one for a musical
+ * change, whose reason is left to the editor, and the technical one for
+ * a technical change.
  *
  * 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`).
+ * the stemma adopted, as one undo step. The edition's creation comes to
+ * name the rule that keeps an edit at one place among its principles,
+ * and this release among its software.
  * @category Operations
  */
-export const adoptEdits = (versionIds, options = {}, run = {}) => reading(edition => {
+export const adoptEdits = (versionIds, options = {}) => 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 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 adopted = new Map(targets.flatMap(version => {
+        const { held, proposed } = adoptedEditsOf(edition, version, options);
+        const edits = [...held, ...proposed];
         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) }]];
+        return [[version.id, { ...version, edits }]];
     }));
-    const sets = keptSets({
-        ...edition,
-        versions: edition.versions.map(version => adopted.get(version.id) ?? version)
-    }, [set]);
+    const creation = madeWith(edition.creation, [editRules.onePlace]);
     // 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 => {
@@ -543,27 +548,7 @@ export const adoptEdits = (versionIds, options = {}, run = {}) => reading(editio
             if (changed)
                 draft.versions[index] = changed;
         });
-        if (sets)
-            draft.propositionSets = sets;
-        else
-            delete draft.propositionSets;
+        if (adopted.size > 0)
+            draft.creation = creation;
     };
 });
-/**
- * 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,7 +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 { stemmaRules, editRules } 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";
+export { proposeEdits, adoptEdits, proposedMotivations, defaultShiftWithin, defaultPairWithin, defaultResizeWithin, defaultSamePlaceWithin, type EditOptions, type EditGrouping, type ProposedEdit } from "./edits.js";

package/lib/filiation/index.js

@@ -12,4 +12,4 @@ 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";
+export { proposeEdits, adoptEdits, proposedMotivations, defaultShiftWithin, defaultPairWithin, defaultResizeWithin, defaultSamePlaceWithin } from "./edits.js";

package/lib/filiation/record.d.ts

@@ -1,5 +1,9 @@
-import { ActorAssignment, Assumption, Certainty, PropositionSet, TimeSpan } from "../model/Assumption.js";
-import { Edition } from "../model/Edition.js";
+/**
+ * What adopting a proposal records of how it was found: the published
+ * rules the proposal follows, among the principles of the edition, and
+ * the release of this library, among the software it was made with.
+ */
+import { EditionCreation } 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
@@ -34,46 +38,12 @@ export declare const editRules: {
     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.
+ * The edition's creation as adopting a proposal leaves it. Its
+ * principles come to name the rules the proposal follows, in place of
+ * those given to be replaced, which are the rules of the same kind that
+ * it no longer follows; the principles the editor named stay. Its
+ * software comes to name this release of the library, in place of any
+ * other release of it, so that the release named finds again what the
+ * edition states.
  */
-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;
+export declare const madeWith: (creation: Readonly<EditionCreation>, rules: readonly string[], replacing?: readonly string[]) => EditionCreation;

package/lib/filiation/record.js

@@ -1,12 +1,4 @@
-/**
- * What adopting a proposal records of the run that made it: the
- * proposition set the statements it concluded belong to, held under one
- * belief, and the reasoning that belief rests on.
- */
-import { v5 } from "uuid";
 import { linkedRolls } from "../software.js";
-/** The namespace the ids of recorded sets and beliefs are minted in, so that recording the same run again gives them again. */
-const RECORDED = 'b7e2a4d1-5c3f-4e86-9a0b-1d2f3e4c5a67';
 /**
  * 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
@@ -41,80 +33,17 @@ export const editRules = {
     onePlace: 'https://welte225.org/rules#one-place'
 };
 /**
- * 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 const recorded = (kind, identity, concluded, run) => {
-    const id = `propositions_${v5(JSON.stringify([kind, linkedRolls, identity]), RECORDED)}`;
-    const inference = {
-        type: 'inference',
-        ...(run.actor && { actor: run.actor }),
-        note: concluded.note,
-        premises: concluded.premises,
-        ...(concluded.used.length > 0 && { used: concluded.used }),
-        applies: run.applies ?? concluded.applies,
-        software: [linkedRolls],
-        ...(run.date && { date: run.date })
-    };
-    return {
-        type: 'propositionSet',
-        id,
-        belief: {
-            type: 'belief',
-            id: `belief_${v5(id, RECORDED)}`,
-            certainty: run.certainty ?? 'likely',
-            reasons: [inference]
-        }
-    };
-};
-/** The statement as one of the set: its annotation names the set, and it carries no belief of its own. */
-export const memberOf = (set, statement) => statement['@annotation']?.id === set && statement['@annotation'].belief === undefined
-    ? statement
-    : { ...statement, '@annotation': { id: set } };
-/** The ids every annotation of the value names a set by, and every premise names a belief by. */
-const namedIn = (value, names) => {
-    if (Array.isArray(value)) {
-        value.forEach(item => namedIn(item, names));
-        return;
-    }
-    if (value === null || typeof value !== 'object' || value instanceof Date)
-        return;
-    const record = value;
-    const annotation = record['@annotation'];
-    if (annotation?.id !== undefined && annotation.belief === undefined)
-        names.add(annotation.id);
-    if (Array.isArray(record.premises))
-        record.premises.forEach(premise => typeof premise === 'string' && names.add(premise));
-    Object.values(record).forEach(child => namedIn(child, names));
-};
-/**
- * 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.
+ * The edition's creation as adopting a proposal leaves it. Its
+ * principles come to name the rules the proposal follows, in place of
+ * those given to be replaced, which are the rules of the same kind that
+ * it no longer follows; the principles the editor named stay. Its
+ * software comes to name this release of the library, in place of any
+ * other release of it, so that the release named finds again what the
+ * edition states.
  */
-export const keptSets = (edition, adding) => {
-    const held = edition.propositionSets ?? [];
-    const known = new Set(held.map(set => set.id));
-    const sets = [...held, ...adding.filter(set => !known.has(set.id))];
-    const named = new Set();
-    namedIn({ ...edition, propositionSets: [] }, named);
-    const kept = new Set();
-    for (let grown = true; grown;) {
-        grown = false;
-        for (const set of sets) {
-            if (kept.has(set) || !(named.has(set.id) || named.has(set.belief.id)))
-                continue;
-            kept.add(set);
-            namedIn(set.belief, named);
-            grown = true;
-        }
-    }
-    const keeping = sets.filter(set => kept.has(set));
-    return keeping.length > 0 ? keeping : undefined;
+export const madeWith = (creation, rules, replacing = []) => {
+    const replaced = new Set(replacing);
+    const principles = [...new Set([...(creation.principles ?? []).filter(rule => !replaced.has(rule)), ...rules])];
+    const software = [...(creation.software ?? []).filter(program => program.name !== linkedRolls.name), linkedRolls];
+    return { ...creation, principles, software };
 };
-/** A distance in millimetres as a note gives it. */
-export const inMillimetres = (value) => `${Math.round(value * 100) / 100} mm`;

package/lib/io/asJsonLd.d.ts

@@ -12,11 +12,7 @@ export declare const exportDate: (date: Date) => string;
  * and every version carries the context of its own reproducing system.
  * A reference the edition holds possible, unlikely or false is quoted
  * rather than stated, so that a reader of the RDF does not take it for
- * a fact, and so is one that belongs to a proposition set held so. A
- * statement that belongs to a set names the set in its annotation,
- * which in RDF makes the set its reifier, and the set, stated once
- * beside the document, carries the belief. The edition given is not
- * changed.
+ * a fact. The edition given is not changed.
  * @category Reading and writing
  */
 export declare const asJsonLd: (edition: Edition) => any;