linked-rolls 0.73.0 → 0.75.0

package/README.md

@@ -132,11 +132,70 @@ 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
 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.
+
+```ts
+import { adoptEdits, adoptStemma, proposeEdits, proposeStemma } from 'linked-rolls'
+
+proposeEdits(edition, versionId)  // [{ insert, delete, editType, grouping }, …]
+
+// The stemma and the edits of its versions, as one undo step
+const adopted = produce(edition, draft => {
+    adoptStemma(proposeStemma(edition))(draft)
+    adoptEdits()(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.
+
 ## Format
 
 The export uses the Roll Edition Ontology (REO), namespace
@@ -147,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
 
@@ -164,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

@@ -0,0 +1,145 @@
+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.
+ * @category Filiation
+ */
+export declare const defaultShiftWithin: import("../index.js").Quantity<"mm">;
+/**
+ * How far an Off may follow an On for the two to be one function turned
+ * on and off again, as an accent is. WM 225 has crescendo accents of up
+ * to about 55 mm.
+ * @category Filiation
+ */
+export declare const defaultPairWithin: import("../index.js").Quantity<"mm">;
+/**
+ * How near the onsets of a perforation and the one put in its place lie
+ * for the one to be a longer or shorter version of the other rather than
+ * a moved one. The figure `mergeEdits` guesses with.
+ * @category Filiation
+ */
+export declare const defaultResizeWithin: import("../index.js").Quantity<"mm">;
+/**
+ * How near two perforations lie to stand at one place: the commands of a
+ * cancel row, or an accent's On and the note set off for it.
+ * @category Filiation
+ */
+export declare const defaultSamePlaceWithin: import("../index.js").Quantity<"mm">;
+/**
+ * What a proposal of edits is computed with. Every value has a default,
+ * the one the edits of WM 225 are reproduced with.
+ * @category Filiation
+ */
+export interface EditOptions {
+    /** `defaultShiftWithin` */
+    shiftWithin?: Millimeters;
+    /** `defaultPairWithin` */
+    pairWithin?: Millimeters;
+    /** `defaultResizeWithin` */
+    resizeWithin?: Millimeters;
+    /** `defaultSamePlaceWithin` */
+    samePlaceWithin?: Millimeters;
+}
+/**
+ * Why changes were taken for one edit.
+ * @category Filiation
+ */
+export type EditGrouping = 
+/** A change nothing else on its line goes with. */
+'single'
+/** A latched function turned on and off again shortly after, as an accent is, or off and on again, added or withdrawn. */
+ | 'pair'
+/** Notes of one pitch, or held commands of one function, that overlap: a note struck again, two tied into one, one made longer. */
+ | 'overlap'
+/** What the version deletes on a line, and what it puts nearby in its place. */
+ | 'move'
+/** A held command of the version standing for a latched pair of the parent's. */
+ | 'substitution'
+/** Cancels punched across several lines at one place. */
+ | 'row';
+/**
+ * An edit proposed from the changes of a version.
+ * @category Filiation
+ */
+export interface ProposedEdit {
+    /** The ids of the symbols it inserts, in the order of their places. */
+    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;
+    grouping: EditGrouping;
+}
+/**
+ * The edits of the version, proposed from what its edits insert and
+ * delete, however they group it now. The proposal depends on the
+ * version's changes and the text of its parent alone, so it is the same
+ * whatever order the changes come in.
+ *
+ * Changes are read line by line: a latched function on its side of the
+ * keyboard, a held one, or a pitch. A command or a note both texts keep
+ * divides its line, and no edit runs across one, so that every edit
+ * stays at one place. On a latched line, a function turned on and off
+ * again shortly after is one edit, as an accent is; a pair withdrawn and
+ * put elsewhere whole is one move, and so is a command put elsewhere on
+ * its own, the nearest first; an Off with an On right after it breaks
+ * the function off and takes it up again. Notes, and commands held for
+ * as long as they last, are one edit where they overlap, and one move
+ * where a note is put nearby. Where the version's system has no word for
+ * a command of the parent's, a held command standing for a latched pair
+ * is one edit with it; what has no counterpart stands alone. Cancels
+ * 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
+ * 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
+ * prolonged; a change the text makes no use of is a redundancy added or
+ * removed; and a change the other system has no word for is a recoding.
+ * Whether a shift corrects an error, and why any change was made, is
+ * not read off the shape.
+ *
+ * A version that derives from none states its text, not a change of
+ * another, and each of its symbols stands alone.
+ * @category Filiation
+ */
+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.
+ * @category Filiation
+ */
+export declare const isRegroupable: (edit: Readonly<Edit>) => boolean;
+/**
+ * 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.
+ *
+ * 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, run?: Run) => EditionOp;