linked-rolls 0.4.1 → 0.5.1

package/lib/readers/stanfordAton.js

@@ -0,0 +1,158 @@
+import { v4 } from "uuid";
+import { AtonParser } from "./AtonParser";
+import { welteT100 } from "../systems/welteT100/bar";
+/** Values in these files carry their unit as a suffix, e.g. "37.7646px". */
+const px = (value) => parseFloat(value);
+/** The parser writes one record as an object and several as an array. */
+const listOf = (value) => value === undefined ? [] : Array.isArray(value) ? value : [value];
+/**
+ * Holes the parser set aside as suspicious after it had already chained
+ * them into a note: the head of such a chain is usually a punch that
+ * came out a little short, and leaving it out would lose the whole
+ * chain. They carry no track number of their own, so the column says
+ * which track they sit on.
+ */
+const chainedBadHoles = (holes, calibration) => holes
+    .filter(hole => hole.NOTE_ATTACK && hole.OFF_TIME)
+    .map(hole => ({
+    ...hole,
+    TRACKER_HOLE: `${Math.round((px(hole.CENTROID_COL) - calibration.offset) / calibration.separation)}`
+}));
+const millimeters = (pixels, dpi) => pixels / dpi * 25.4;
+const median = (values) => {
+    const sorted = [...values].sort((a, b) => a - b);
+    const middle = Math.floor(sorted.length / 2);
+    return sorted.length % 2 ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2;
+};
+const mostFrequent = (values) => {
+    const counts = values.reduce((acc, value) => acc.set(value, (acc.get(value) || 0) + 1), new Map());
+    return [...counts].sort(([, a], [, b]) => b - a)[0]?.[0];
+};
+/**
+ * Only the first hole of a chain carries an attack and an off time;
+ * the rest continue it. The rewind perforation carries neither, and it
+ * is the last thing punched on the roll, so whatever the holes past the
+ * final musical attack sit on is the rewind track.
+ */
+const rewindTrackIn = (holes) => {
+    const lastMusical = holes.findLastIndex(hole => hole.NOTE_ATTACK);
+    const trailing = holes.slice(lastMusical + 1).map(hole => +hole.TRACKER_HOLE);
+    return mostFrequent(trailing);
+};
+/**
+ * The phase of the tracker grid within the image. The analysis file
+ * usually states it; where it does not, the holes themselves give it away,
+ * since each sits close to the centre of its column.
+ */
+const gridOffsetOf = (holes, separation, stated) => {
+    if (stated !== undefined)
+        return px(stated);
+    return median(holes.map(hole => px(hole.CENTROID_COL) - +hole.TRACKER_HOLE * separation));
+};
+const punchDiameterOf = (holes, dpi) => {
+    const circular = holes
+        .filter(hole => px(hole.CIRCULARITY) > 0.95)
+        .map(hole => millimeters(px(hole.PERIMETER), dpi) / Math.PI);
+    if (!circular.length)
+        return undefined;
+    return circular.reduce((sum, diameter) => sum + diameter, 0) / circular.length;
+};
+/**
+ * The image service Stanford keeps for a scan, and a crop of a
+ * feature from it.
+ */
+const stanfordScan = (druid) => ({
+    scan: `https://stacks.stanford.edu/image/iiif/${druid}%2F${druid}_0001/`,
+    depictionOf: (column, row, width, height) => `https://stacks.stanford.edu/image/iiif/${druid}/${druid}_0001/${column},${row},${width},${height}/128,/270/default.jpg`
+});
+/**
+ * The software behind an analysis and when it was run, as the
+ * analysis file states them.
+ */
+const measuredByOf = (rollinfo) => {
+    const date = new Date(rollinfo.ANALYSIS_DATE);
+    if (!rollinfo.HOLE_SOFTWARE || isNaN(date.getTime()))
+        return undefined;
+    return {
+        software: rollinfo.HOLE_SOFTWARE,
+        version: rollinfo.SOFTWARE_DATE ?? '',
+        date
+    };
+};
+export function readFromStanfordAton(atonString, { trackShift, bar = welteT100, scan } = {}) {
+    const parser = new AtonParser();
+    const json = parser.parse(atonString);
+    const holes = json.ROLLINFO.HOLES.HOLE;
+    const druid = json.ROLLINFO.DRUID;
+    const stanford = druid ? stanfordScan(druid) : undefined;
+    const separation = px(json.ROLLINFO.HOLE_SEPARATION);
+    const dpi = parseFloat(json.ROLLINFO.LENGTH_DPI);
+    const measuredBy = measuredByOf(json.ROLLINFO);
+    const rewindTrack = rewindTrackIn(holes);
+    const shift = trackShift
+        ?? (rewindTrack === undefined ? 0 : bar.rewindTrack - rewindTrack);
+    const calibration = {
+        unit: 'px',
+        offset: gridOffsetOf(holes, separation, json.ROLLINFO.HOLE_OFFSET),
+        separation,
+        shift
+    };
+    const punchDiameter = punchDiameterOf(holes, dpi);
+    const chains = [...holes, ...chainedBadHoles(listOf(json.ROLLINFO.BADHOLES?.HOLE), calibration)]
+        .filter(hole => hole.NOTE_ATTACK && hole.OFF_TIME)
+        .sort((a, b) => px(a.NOTE_ATTACK) - px(b.NOTE_ATTACK));
+    const features = chains
+        .map((hole) => {
+        const attack = px(hole.NOTE_ATTACK);
+        const release = px(hole.OFF_TIME);
+        const column = px(hole.ORIGIN_COL);
+        const columnWidth = px(hole.WIDTH_COL);
+        return {
+            type: 'Hole',
+            id: v4(),
+            ...(stanford && {
+                depiction: stanford.depictionOf(column, attack, columnWidth, release - attack)
+            }),
+            vertical: {
+                from: +hole.TRACKER_HOLE + shift,
+                unit: 'track'
+            },
+            horizontal: {
+                unit: 'mm',
+                from: millimeters(attack, dpi),
+                to: millimeters(release, dpi)
+            }
+        };
+    });
+    return {
+        type: 'RollCopy',
+        id: v4(),
+        ops: [],
+        conditions: [],
+        keeper: { name: '', sameAs: [] },
+        modifications: [],
+        ...((scan ?? stanford) && { scan: scan ?? stanford?.scan }),
+        measurements: {
+            dimensions: {
+                width: millimeters(px(json.ROLLINFO.ROLL_WIDTH), dpi),
+                height: millimeters(px(json.ROLLINFO.IMAGE_LENGTH), dpi),
+                unit: 'mm'
+            },
+            ...(punchDiameter !== undefined && {
+                punchDiameter: { value: punchDiameter, unit: 'mm' }
+            }),
+            holeSeparation: {
+                value: separation,
+                unit: 'px'
+            },
+            margins: {
+                treble: px(json.ROLLINFO.HARD_MARGIN_TREBLE),
+                bass: px(json.ROLLINFO.HARD_MARGIN_BASS),
+                unit: 'px'
+            },
+            trackCalibration: calibration,
+            ...(measuredBy && { measuredBy })
+        },
+        features
+    };
+}

package/lib/schema.json

@@ -1189,7 +1189,7 @@
             ],
             "type": "object"
         },
-        "ObjectAssumption<alias-731470504-73739-73887-731470504-0-217694<def-interface-src_Symbol.ts-5670-6034-src_Symbol.ts-0-6242400334313,\"carriers\">>": {
+        "ObjectAssumption<alias-731470504-73739-73887-731470504-0-217694<def-interface-src_Symbol.ts-5758-6122-src_Symbol.ts-0-6378400334313,\"carriers\">>": {
             "description": "An object assumption wraps a complex object with an optional annotation. Used for structured values (e.g. persons, conditions) whose properties may be uncertain.",
             "properties": {
                 "@annotation": {
@@ -1760,7 +1760,7 @@
                     "description": "The method by which this writing was produced (e.g. through print, handwriting, or stamping). [ontology: crm:P2 has type]"
                 },
                 "transcription": {
-                    "$ref": "#/definitions/ObjectAssumption%3Calias-731470504-73739-73887-731470504-0-217694%3Cdef-interface-src_Symbol.ts-5670-6034-src_Symbol.ts-0-6242400334313%2C%22carriers%22%3E%3E",
+                    "$ref": "#/definitions/ObjectAssumption%3Calias-731470504-73739-73887-731470504-0-217694%3Cdef-interface-src_Symbol.ts-5758-6122-src_Symbol.ts-0-6378400334313%2C%22carriers%22%3E%3E",
                     "description": "A transcription of the text content of the writing. This is an object assumption so that the transcription can be annotated with a belief about its correctness. [ontology: crm:P128 carries]"
                 },
                 "vertical": {

package/lib/systems/welteT100/bar.d.ts

@@ -0,0 +1,14 @@
+import { TrackerBar } from "../../TrackerBar";
+/**
+ * The commands of the Welte-Mignon T-100, as its tracker bar reads them.
+ */
+export declare const welteT100ExpressionTypes: readonly ["SustainPedalOn", "SustainPedalOff", "SoftPedalOn", "SoftPedalOff", "MezzoforteOff", "MezzoforteOn", "SlowCrescendoOn", "SlowCrescendoOff", "ForzandoOn", "ForzandoOff", "MotorOff", "MotorOn", "Rewind", "ElectricCutOff"];
+export type WelteT100ExpressionType = typeof welteT100ExpressionTypes[number];
+/**
+ * Welte-Mignon T-100 ("red Welte"), cf. Hagmann, pp. 75 and 178.
+ *
+ * The note block spans 80 positions from C1 to g⁴, i.e. MIDI 24 to 103.
+ * The expression valves are duplicated, bass below the note block and
+ * treble above it, in mirrored order.
+ */
+export declare const welteT100: TrackerBar;

package/lib/systems/welteT100/bar.js

@@ -0,0 +1,56 @@
+import { describeTrackerBar } from "../../TrackerBar";
+/**
+ * The commands of the Welte-Mignon T-100, as its tracker bar reads them.
+ */
+export const welteT100ExpressionTypes = [
+    'SustainPedalOn',
+    'SustainPedalOff',
+    'SoftPedalOn',
+    'SoftPedalOff',
+    'MezzoforteOff',
+    'MezzoforteOn',
+    'SlowCrescendoOn',
+    'SlowCrescendoOff',
+    'ForzandoOn',
+    'ForzandoOff',
+    'MotorOff',
+    'MotorOn',
+    'Rewind',
+    'ElectricCutOff'
+];
+/**
+ * Welte-Mignon T-100 ("red Welte"), cf. Hagmann, pp. 75 and 178.
+ *
+ * The note block spans 80 positions from C1 to g⁴, i.e. MIDI 24 to 103.
+ * The expression valves are duplicated, bass below the note block and
+ * treble above it, in mirrored order.
+ */
+export const welteT100 = describeTrackerBar({
+    id: 'welte-t100',
+    name: 'Welte-Mignon T100',
+    width: 328,
+    trackCount: 100,
+    notes: { from: 11, to: 90, lowestPitch: 24 },
+    expressions: new Map([
+        [1, 'MezzoforteOff'],
+        [2, 'MezzoforteOn'],
+        [3, 'SlowCrescendoOff'],
+        [4, 'SlowCrescendoOn'],
+        [5, 'ForzandoOff'],
+        [6, 'ForzandoOn'],
+        [7, 'SoftPedalOff'],
+        [8, 'SoftPedalOn'],
+        [9, 'MotorOff'],
+        [10, 'MotorOn'],
+        [91, 'Rewind'],
+        [92, 'ElectricCutOff'],
+        [93, 'SustainPedalOn'],
+        [94, 'SustainPedalOff'],
+        [95, 'ForzandoOn'],
+        [96, 'ForzandoOff'],
+        [97, 'SlowCrescendoOn'],
+        [98, 'SlowCrescendoOff'],
+        [99, 'MezzoforteOn'],
+        [100, 'MezzoforteOff']
+    ])
+});

package/lib/systems/{welteT100.d.ts → welteT100/system.d.ts}

@@ -1,5 +1,5 @@
 import { Half, Parameters, PedalMode, Spool } from "welte-t100-emulator";
-import { ReproducingSystem } from "../ReproducingSystem";
+import { ReproducingSystem } from "../../ReproducingSystem";
 /**
  * MIDI velocity at the open rail of the Nuancierbalg, at the Mezzoforte pin,
  * and at the closed rail, joined linearly in between. Nothing in the

package/lib/systems/{welteT100.js → welteT100/system.js}

@@ -1,5 +1,5 @@
 import { aperturePorts, DEFAULT_PUNCH_MM, geometryInMm, Grid, levelChanges, mezzoforteTravel, paperSeconds, pedalDefaults, playbackParameters, pneumaticModel, ROWS_PER_MM, runPedals, TRACKER_BORE_MM, travelBetweenRails, WELTE_SPOOL, } from "welte-t100-emulator";
-import { welteT100 } from "../TrackerBar";
+import { welteT100 } from "./bar";
 export const defaultWelteT100Options = {
     spool: WELTE_SPOOL,
     nuance: {

package/lib/utils.d.ts

@@ -1,4 +1,3 @@
-import { Person } from "./Edition";
 export type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 export type WithType<T extends string> = {
     /**
@@ -13,13 +12,6 @@ export type WithId = {
      */
     readonly id: string;
 };
-export type WithActor = {
-    /**
-     * The person who carried out this activity.
-     * @see crm:P14 carried out by
-     */
-    actor?: Person;
-};
 export type WithNote = {
     /**
      * A free-text note providing additional context.

package/lib/validate.d.ts

@@ -1,30 +1,3 @@
 import { Edition } from "./Edition";
-import { EditionView } from "./EditionView";
-import { TrackerBar } from "./TrackerBar";
 declare const validate: import("ajv").ValidateFunction<Edition>;
 export { validate };
-export type ConstraintProblem = {
-    version: string;
-    symbol: string;
-    problem: 'alignment-reference-missing' | 'before-reference-missing' | 'after-reference-missing' | 'placed-relative-to-itself' | 'placed-several-ways' | 'partner-missing' | 'paired-with-itself' | 'in-several-pairs' | 'pair-placed-on-both-sides';
-};
-/**
- * Where the placements and pairings of the edition cannot hold as
- * stated, version by version: a reference or partner absent from the
- * version, a perforation placed relative to itself or in several ways
- * at once, one claimed by several pairs, or a pair whose members are
- * both placed and so cannot keep their distance and follow their
- * references at once.
- */
-export declare const constraintProblems: (view: EditionView) => ConstraintProblem[];
-export type UnknownExpressionType = {
-    version: string;
-    symbol: string;
-    expressionType: string;
-};
-/**
- * The expressions of the edition whose type the tracker bar does not
- * read, version by version. The roll names its system; a type from
- * another system, or a misspelt one, means nothing on it.
- */
-export declare const unknownExpressionTypes: (view: EditionView, bar: TrackerBar) => UnknownExpressionType[];

package/lib/validate.js

@@ -1,7 +1,5 @@
 import Ajv from "ajv";
 import * as schema from "./schema.json";
-import { idOf } from "./Assumption";
-import { isPerforation, pairsAmong, placementsOf } from "./Symbol";
 const ajv = new Ajv({
     strict: false,
     formats: {
@@ -10,62 +8,3 @@ const ajv = new Ajv({
 });
 const validate = ajv.compile(schema);
 export { validate };
-const missingReference = {
-    alignedWith: 'alignment-reference-missing',
-    before: 'before-reference-missing',
-    after: 'after-reference-missing'
-};
-const problemsIn = (version, perforations) => {
-    const ids = new Set(perforations.map(p => p.id));
-    const report = (symbol, problem) => ({ version, symbol, problem });
-    const missingReferences = perforations
-        .flatMap(p => placementsOf(p)
-        .filter(({ reference }) => !ids.has(idOf(reference)))
-        .map(({ relation }) => report(p.id, missingReference[relation])));
-    const selfPlaced = perforations
-        .filter(p => placementsOf(p).some(({ reference }) => idOf(reference) === p.id))
-        .map(p => report(p.id, 'placed-relative-to-itself'));
-    const placedSeveralWays = perforations
-        .filter(p => placementsOf(p).length > 1)
-        .map(p => report(p.id, 'placed-several-ways'));
-    const missingPartners = perforations
-        .filter(p => p.pairedWith && !ids.has(idOf(p.pairedWith)))
-        .map(p => report(p.id, 'partner-missing'));
-    const selfPaired = perforations
-        .filter(p => p.pairedWith && idOf(p.pairedWith) === p.id)
-        .map(p => report(p.id, 'paired-with-itself'));
-    const pairs = pairsAmong(perforations);
-    const pairsOf = (p) => pairs.filter(pair => pair.includes(p));
-    const inSeveralPairs = perforations
-        .filter(p => pairsOf(p).length > 1)
-        .map(p => report(p.id, 'in-several-pairs'));
-    const placedOnBothSides = pairs
-        .filter(([one, other]) => placementsOf(one).length > 0 && placementsOf(other).length > 0)
-        .flatMap(pair => pair.map(p => report(p.id, 'pair-placed-on-both-sides')));
-    return [
-        ...missingReferences, ...selfPlaced, ...placedSeveralWays,
-        ...missingPartners, ...selfPaired, ...inSeveralPairs, ...placedOnBothSides
-    ];
-};
-/**
- * Where the placements and pairings of the edition cannot hold as
- * stated, version by version: a reference or partner absent from the
- * version, a perforation placed relative to itself or in several ways
- * at once, one claimed by several pairs, or a pair whose members are
- * both placed and so cannot keep their distance and follow their
- * references at once.
- */
-export const constraintProblems = (view) => view.edition.versions.flatMap(version => problemsIn(version.id, view.snapshot(version.id).filter(isPerforation)));
-const isExpression = (symbol) => symbol.type === 'expression';
-/**
- * The expressions of the edition whose type the tracker bar does not
- * read, version by version. The roll names its system; a type from
- * another system, or a misspelt one, means nothing on it.
- */
-export const unknownExpressionTypes = (view, bar) => {
-    const known = new Set(bar.expressionTypes);
-    return view.edition.versions.flatMap(version => view.snapshot(version.id)
-        .filter(isExpression)
-        .filter(symbol => !known.has(symbol.expressionType))
-        .map(symbol => ({ version: version.id, symbol: symbol.id, expressionType: symbol.expressionType })));
-};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linked-rolls",
-  "version": "0.4.1",
+  "version": "0.5.1",
   "description": "Digital editions of piano rolls: import, collation, editorial assumptions, JSON-LD export, and emulation through a reproducing system",
   "license": "MIT",
   "repository": {
@@ -16,8 +16,8 @@
       "default": "./lib/index.js"
     },
     "./welte-t100": {
-      "types": "./lib/systems/welteT100.d.ts",
-      "default": "./lib/systems/welteT100.js"
+      "types": "./lib/systems/welteT100/system.d.ts",
+      "default": "./lib/systems/welteT100/system.js"
     },
     "./lib/*": "./lib/*",
     "./package.json": "./package.json"

package/lib/Plan.d.ts

@@ -1,198 +0,0 @@
-import { Draft } from "immer";
-import { EditionView } from "./EditionView";
-import { Edition } from "./Edition";
-import { AnySymbol } from "./Symbol";
-import { CollationTolerance } from "./Collation";
-import { Edit } from "./Edit";
-import { RollCopy } from "./RollCopy";
-export type EditionOp = (d: Draft<Edition>) => void;
-export interface Plan {
-    build(): EditionOp[];
-    setView: (view: EditionView) => void;
-}
-export declare const isPlan: (obj: any) => obj is Plan;
-export declare abstract class BasePlan implements Plan {
-    protected view: EditionView | null;
-    setView: (view: EditionView) => void;
-    abstract build(): EditionOp[];
-}
-/**
- * Walks through the versions. If it finds a symbol that is still
- * part of the tradition (i.e. it is included in the current snapshot)
- * and is equivalent with the given symbol, it will add the feature
- * carrying the symbol to the collated symbol. Otherwise, the
- * given symbol will be added to the current version's insertions.
- *
- * All symbols of the tradition that are not included in the given
- * symbols are considered to be deleted.
- *
- * @param creation
- * @param symbols
- * @returns
- */
-export declare class ConnectVersions extends BasePlan {
-    private childId;
-    private parentId;
-    private tolerance;
-    constructor(childId: string, parentId: string, tolerance?: CollationTolerance);
-    build(): EditionOp[];
-}
-/**
- * Walks through the versions. If it finds a symbol that is still
- * part of the tradition (i.e. it is included in the current snapshot)
- * and is equivalent with the given symbol, it will add the feature
- * carrying the symbol to the collated symbol. Otherwise, the
- * given symbol will be added to the current version's insertions.
- *
- * All symbols of the tradition that are not included in the given
- * symbols are considered to be deleted.
- *
- * @param creation
- * @param symbols
- * @returns
- */
-export declare class CreateVersion extends BasePlan {
-    private siglum;
-    private copy;
-    constructor(siglum: string, copy: RollCopy);
-    build(): EditionOp[];
-}
-/**
- * Creates a new version based on the given version
- * calculating the effect of a cover on existing symbols.
- 
-export class CoverPerforation extends BasePlan {
-    constructor(
-        private copyId: string,
-        private versionId: string,
-        private coverDimension: { horizontal: HorizontalSpan, vertical: VerticalSpan },
-        private material: string | undefined = undefined,
-    ) {
-        super()
-    }
-
-    build(): EditionOp[] {
-        const view = this.view
-        if (!view) return []
-
-        return [
-            (draft: Draft<Edition>): void => {
-                const version = draft.versions.find(v => v.id === this.versionId)
-                const copy = draft.copies.find(c => c.id === this.copyId)
-                if (!version || !copy) return
-
-                // find perforations in the snapshot that
-                // overlap with the cover
-                const overlappingSymbols =
-                    view.snapshot(this.versionId)
-                        .filter(symbol => {
-                            const dimension = view.dimensionOf(symbol)
-                            if (!dimension) return false
-
-                            return (
-                                (symbol.type === 'note' || symbol.type === 'expression') &&
-                                overlaps(dimension, this.coverDimension)
-                            )
-                        })
-
-                if (!overlappingSymbols.length) return undefined
-
-                const deepClone = JSON.parse(JSON.stringify(overlappingSymbols)) as AnySymbol[]
-
-                for (const symbol of deepClone) {
-                    //symbol.id = v4();
-                    const dimension = structuredClone(view.dimensionOf(symbol))
-                    if (!dimension) continue
-
-                    // check if the cover partially covers the beginning
-                    if (dimension.horizontal.from >= this.coverDimension.horizontal.from &&
-                        dimension.horizontal.from <= this.coverDimension.horizontal.to
-                    ) {
-                        dimension.horizontal.from = this.coverDimension.horizontal.to
-                    }
-
-                    // check if the cover partially covers the ending
-                    if (dimension.horizontal.to >= this.coverDimension.horizontal.from &&
-                        dimension.horizontal.to <= this.coverDimension.horizontal.to
-                    ) {
-                        dimension.horizontal.to = this.coverDimension.horizontal.from
-                    }
-
-                    const newFeature: RollFeature = {
-                        ...dimension,
-                        id: v4(),
-                    }
-
-                    copy.features.push(newFeature)
-                    symbol.id = `symbol-${v4().slice(0, 8)}`
-                    symbol.carriers = [assignReference(newFeature.id)]
-                }
-
-                const coverId = `cover-${v4().slice(0, 8)}`
-                copy.features.push({
-                    ...this.coverDimension,
-                    id: coverId,
-                })
-
-                const edit: Edit = {
-                    type: 'edit',
-                    id: v4(),
-                    delete: overlappingSymbols.map(s => s.id),
-                    insert: deepClone,
-                    intentionOf: [{
-                        type: 'cover',
-                        id: v4(),
-                        note: this.material,
-                        carriers: [assignReference(coverId)],
-                    }]
-                }
-
-                draft.versions.push({
-                    edits: [edit],
-                    id: v4(),
-                    basedOn: assignReference(version.id),
-                    siglum: version.siglum + ' rev',
-                    type: 'authorised-revision',
-                    motivations: [
-                        {
-                            type: 'motivation',
-                            note: 'Stanzfehler korrigiert',
-                            id: v4(),
-                        }
-                    ],
-                })
-            }]
-    }
-}
-    */
-export declare class DetachVersion extends BasePlan {
-    private versionId;
-    constructor(versionId: string);
-    build(): EditionOp[];
-}
-export declare class RemoveFeature extends BasePlan {
-    private copyID;
-    private featureIDs;
-    constructor(copyID: string, featureIDs: string[]);
-    build(): EditionOp[];
-}
-/** The symbols of the versions that no other copy carries. */
-export declare const symbolsCarriedOnlyBy: (edition: Edition, copyId: string) => AnySymbol[];
-/**
- * Takes the copy out of the edition together with the symbols only it
- * carries, and with every reference the versions made to those symbols.
- */
-export declare const removeCopy: (copyId: string) => EditionOp;
-export declare class MergeEdits extends BasePlan {
-    private versionId;
-    private toMerge;
-    constructor(versionId: string, toMerge: Edit[]);
-    private guessMotivation;
-    build(): EditionOp[];
-}
-export declare class SplitEdit extends BasePlan {
-    private versionId;
-    private toSplit;
-    constructor(versionId: string, toSplit: Edit);
-    build(): EditionOp[];
-}