linked-rolls 0.63.0 → 0.65.0

package/lib/io/migrate.js

@@ -2,6 +2,7 @@ import { systemIdIn, systemOf, translationBetween } from "../systems/TrackerBar.
 import { trackerBars } from "../systems/index.js";
 import { welteT100 } from "../systems/welteT100/bar.js";
 import { isDateString } from "../shared/utils.js";
+import { mapped, withValues } from "../ops/immutable.js";
 const retiredVersionTypes = new Set(['edition', 'unicum']);
 /**
  * The vocabulary the steps below were written against, as it stood in
@@ -37,10 +38,10 @@ const referenceKeys = ['alignedWith', 'pairedWith', 'basedOn'];
  * The five type terms that were capitalised while the rest of the
  * vocabulary was not, under the keys that carried them then.
  */
-const lowerCasedTerms = {
+const lowerCasedTerms = Object.entries({
     method: { Print: 'print', Handwriting: 'handwriting', Stamp: 'stamp' },
     material: { Paper: 'paper', Tape: 'tape' }
-};
+});
 const named = (name) => ({ name, sameAs: [] });
 const withRenamedKeys = (node) => Object.keys(node).some(key => Object.hasOwn(renamedKeys, key))
     ? Object.fromEntries(Object.entries(node).map(([key, value]) => [renamedKeys[key] ?? key, value]))
@@ -82,7 +83,7 @@ const withoutVersionSiglum = (node) => {
     const { siglum: _labelled, ...rest } = node;
     return rest;
 };
-const withLowerCaseTerms = (node) => Object.entries(lowerCasedTerms).reduce((result, [key, terms]) => {
+const withLowerCaseTerms = (node) => lowerCasedTerms.reduce((result, [key, terms]) => {
     const lowered = terms[result[key]];
     return lowered ? { ...result, [key]: lowered } : result;
 }, node);
@@ -450,26 +451,16 @@ const withTimeSpanDates = (node) => {
     const { '@value': within, '@type': _typed, ...rest } = node;
     return { ...rest, within };
 };
-const migrateNode = (node) => [withRenamedKeys, withRenamedEditType, withTypology, withRenamedType, withoutVersionType, withoutVersionSiglum, withLowerCaseTerms, withSplitMethod, withReferences, withKeeper, withoutEmptyKeeper,
+const nodeSteps = [withRenamedKeys, withRenamedEditType, withTypology, withRenamedType, withoutVersionType, withoutVersionSiglum, withLowerCaseTerms, withSplitMethod, withReferences, withKeeper, withoutEmptyKeeper,
     withPerforator, withProductionNodes, withTypedPerforator, withScale, withoutOps, withDerivationList, withReadingKind, withTimeSpanDates,
-    withoutFeatureKind, withBorneFeaturesNamed, withFeaturesInActs, withOwnPlaces, withDriveOfStaggering, withoutPattern, withoutBearings, withoutEntailedType]
-    .reduce((result, step) => step(result), node);
-/** The items each walked, or the very same list where the walk changed none. */
-const walked = (items) => {
-    const result = items.map(walk);
-    return result.every((item, i) => item === items[i]) ? items : result;
-};
-/** The node with each child walked, or the very same node where the walk changed none. */
-const withWalkedChildren = (node) => {
-    const entries = Object.entries(node);
-    const result = entries.map(([key, child]) => [key, walk(child)]);
-    return result.every(([, child], i) => child === entries[i][1]) ? node : Object.fromEntries(result);
-};
+    withoutFeatureKind, withBorneFeaturesNamed, withFeaturesInActs, withOwnPlaces, withDriveOfStaggering, withoutPattern, withoutBearings, withoutEntailedType];
+const migrateNode = (node) => nodeSteps.reduce((result, step) => step(result), node);
+/** The value with every node in it migrated, a node before its children; the very same value where nothing changed. */
 const walk = (value) => {
     if (Array.isArray(value))
-        return walked(value);
+        return mapped(value, walk);
     if (value && typeof value === 'object')
-        return withWalkedChildren(migrateNode(value));
+        return withValues(migrateNode(value), walk);
     return value;
 };
 /** The production of a copy, under whichever of its two names it carries. */
@@ -576,18 +567,21 @@ const statesNoTolerance = (version) => isSingleDerivation(version.basedOn) && !v
  * The collation tolerance was the edition's before it was stated on
  * each derivation. An edition written then collated every version at
  * that one value, so it is written onto every derivation that gives
- * none of its own.
+ * none of its own, and the edition states it no longer.
  */
 const withDerivationTolerance = (edition) => {
-    const collationTolerance = edition.creation?.collationTolerance;
-    const versions = Array.isArray(edition.versions) ? edition.versions : [];
-    if (!collationTolerance || !versions.some(statesNoTolerance))
+    if (!edition.creation || !Object.hasOwn(edition.creation, 'collationTolerance'))
         return edition;
+    const { collationTolerance, ...creation } = edition.creation;
+    const versions = listAt(edition, 'versions');
     return {
         ...edition,
-        versions: versions.map(version => statesNoTolerance(version)
-            ? { ...version, basedOn: { ...version.basedOn, collationTolerance } }
-            : version)
+        creation,
+        ...(collationTolerance && versions && {
+            versions: versions.map(version => statesNoTolerance(version)
+                ? { ...version, basedOn: { ...version.basedOn, collationTolerance } }
+                : version)
+        })
     };
 };
 /** Release 0.58.0 stated a revision of the format, which the format does not state. */

package/lib/lookup/lookup.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Finding what an edition holds by its id. Each kind of entity has an
+ * index of its own, built from where the edition holds it when first
+ * asked for and kept for as long as the state is (`perState`). The index
+ * an entity is found in says what it is, so a lookup needs neither a
+ * type discriminator nor a cast.
+ */
+import { Edition } from "../model/Edition.js";
+import { NestedFeature } from "../model/Feature.js";
+import { AnySymbol } from "../model/Symbol.js";
+import { Version } from "../model/Version.js";
+import { Modification, ProductionEvent, RollCopy } from "../model/RollCopy.js";
+export declare const versionIn: (edition: Pick<Edition, 'versions'>, id: string) => Readonly<Version> | undefined;
+export declare const copyIn: (edition: Pick<Edition, 'copies'>, id: string) => Readonly<RollCopy> | undefined;
+/** A symbol any version inserts. */
+export declare const symbolIn: (edition: Pick<Edition, 'versions'>, id: string) => Readonly<AnySymbol> | undefined;
+/** The symbols under the ids, leaving out an id that names none. */
+export declare const symbolsIn: (edition: Pick<Edition, 'versions'>, ids: readonly string[]) => Readonly<AnySymbol>[];
+/** A feature or a patch on any copy, one a patch bears included. */
+export declare const featureIn: (edition: Pick<Edition, 'copies'>, id: string) => Readonly<NestedFeature> | undefined;
+/** The features and patches under the ids, leaving out an id that names none. */
+export declare const featuresIn: (edition: Pick<Edition, 'copies'>, ids: readonly string[]) => Readonly<NestedFeature>[];
+/** The copy a feature sits on, a patch and everything it bears included. */
+export declare const copyOfFeature: (edition: Pick<Edition, 'copies'>, featureId: string) => Readonly<RollCopy> | undefined;
+/**
+ * The act a copy states a feature in: the production event that
+ * punched it, or the modification that brought it about. A feature
+ * a patch bears came onto the copy with the patch, so the act is
+ * the one that glued the patch on. Two features stand in one act
+ * where this returns the very same object.
+ */
+export declare const actOf: (edition: Pick<Edition, 'copies'>, featureId: string) => Readonly<ProductionEvent | Modification> | undefined;

package/lib/lookup/lookup.js

@@ -0,0 +1,40 @@
+import { withBorneFeatures } from "../model/Feature.js";
+import { insertedBy } from "../model/Version.js";
+import { featuresMadeBy, featuresOf } from "../model/RollCopy.js";
+import { perState } from "./perState.js";
+const byIdIn = (entities) => new Map(entities.map(entity => [entity.id, entity]));
+const versionsById = perState((edition) => byIdIn(edition.versions));
+const copiesById = perState((edition) => byIdIn(edition.copies));
+const symbolsById = perState((edition) => byIdIn(edition.versions.flatMap(insertedBy)));
+/** Every feature and patch on the copies, those a patch bears included. */
+const featuresOnCopies = (edition) => edition.copies.flatMap(copy => featuresOf(copy).flatMap(withBorneFeatures).map(feature => ({ feature, copy })));
+const featuresById = perState((edition) => new Map(featuresOnCopies(edition).map(({ feature }) => [feature.id, feature])));
+const copiesByFeature = perState((edition) => new Map(featuresOnCopies(edition).map(({ feature, copy }) => [feature.id, copy])));
+export const versionIn = (edition, id) => versionsById(edition).get(id);
+export const copyIn = (edition, id) => copiesById(edition).get(id);
+/** A symbol any version inserts. */
+export const symbolIn = (edition, id) => symbolsById(edition).get(id);
+/** The symbols under the ids, leaving out an id that names none. */
+export const symbolsIn = (edition, ids) => ids.flatMap(id => symbolIn(edition, id) ?? []);
+/** A feature or a patch on any copy, one a patch bears included. */
+export const featureIn = (edition, id) => featuresById(edition).get(id);
+/** The features and patches under the ids, leaving out an id that names none. */
+export const featuresIn = (edition, ids) => ids.flatMap(id => featureIn(edition, id) ?? []);
+/** The copy a feature sits on, a patch and everything it bears included. */
+export const copyOfFeature = (edition, featureId) => copiesByFeature(edition).get(featureId);
+/**
+ * The act a copy states a feature in: the production event that
+ * punched it, or the modification that brought it about. A feature
+ * a patch bears came onto the copy with the patch, so the act is
+ * the one that glued the patch on. Two features stand in one act
+ * where this returns the very same object.
+ */
+export const actOf = (edition, featureId) => {
+    const copy = copyOfFeature(edition, featureId);
+    if (!copy)
+        return undefined;
+    const states = (features) => features.flatMap(withBorneFeatures).some(feature => feature.id === featureId);
+    if (states(copy.production?.produced ?? []))
+        return copy.production;
+    return copy.modifications.find(act => states(featuresMadeBy(act)));
+};

package/lib/lookup/paths.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Where in an edition each id stands and where it is referenced, as
+ * paths an operation can follow into a draft of it.
+ */
+import { Edition } from "../model/Edition.js";
+export type Path = (string | number)[];
+export declare const getAt: <T>(path: Path, obj: unknown) => T | undefined;
+/** Where the entity with the id stands in the edition, or nothing where it holds none. */
+export declare const pathIn: (edition: Edition, id: string) => Path | undefined;
+/** Where the edition references the id. */
+export declare const linksTo: (edition: Edition, id: string) => Path[];

package/lib/lookup/paths.js

@@ -0,0 +1,78 @@
+import { perState } from "./perState.js";
+export const getAt = (path, obj) => {
+    let node = obj;
+    for (const key of path) {
+        if (node == null)
+            return undefined;
+        node = node[key];
+    }
+    return node;
+};
+/** Keys under which an object names others by id, singly or in a list. */
+const referenceKeys = ['delete', 'comprehends', 'motivation', 'premises', 'used'];
+const isObject = (v) => v !== null && typeof v === "object";
+/** What a reference may state besides the id: a belief about it, and the tolerance a derivation was collated at. */
+const referenceOwnKeys = new Set(['id', '@annotation', 'collationTolerance']);
+/** An object that names another by its id and says nothing of its own beyond that. */
+const isReferenceOnly = (keys) => keys.every(key => referenceOwnKeys.has(key));
+const laidOut = (trail) => {
+    const path = [];
+    for (let link = trail; link !== null; link = link.up)
+        path.push(link.key);
+    return path.reverse();
+};
+/** Walks the edition and records where each id stands and where it is referenced. */
+const placesIn = perState((edition) => {
+    const paths = new Map();
+    const links = new Map();
+    const visited = new WeakSet();
+    const link = (id, trail) => {
+        const trails = links.get(id);
+        if (trails)
+            trails.push(trail);
+        else
+            links.set(id, [trail]);
+    };
+    const index = (record, keys, trail) => {
+        if (typeof record.id !== "string")
+            return;
+        if (isReferenceOnly(keys))
+            link(record.id, { key: 'id', up: trail });
+        else if (!paths.has(record.id)) {
+            paths.set(record.id, trail);
+        }
+    };
+    const linkReferences = (record, trail) => referenceKeys.forEach(key => {
+        const ref = record[key];
+        if (typeof ref === "string")
+            link(ref, { key, up: trail });
+        else if (Array.isArray(ref))
+            ref.forEach((r, i) => {
+                if (typeof r === "string")
+                    link(r, { key: i, up: { key, up: trail } });
+            });
+    });
+    const traverse = (node, trail) => {
+        if (!isObject(node) || visited.has(node))
+            return;
+        visited.add(node);
+        if (Array.isArray(node)) {
+            node.forEach((item, i) => traverse(item, { key: i, up: trail }));
+            return;
+        }
+        const record = node;
+        const keys = Object.keys(record);
+        index(record, keys, trail);
+        linkReferences(record, trail);
+        keys.forEach(key => traverse(record[key], { key, up: trail }));
+    };
+    traverse(edition, null);
+    return { paths, links };
+});
+/** Where the entity with the id stands in the edition, or nothing where it holds none. */
+export const pathIn = (edition, id) => {
+    const trail = placesIn(edition).paths.get(id);
+    return trail === undefined ? undefined : laidOut(trail);
+};
+/** Where the edition references the id. */
+export const linksTo = (edition, id) => (placesIn(edition).links.get(id) ?? []).map(laidOut);

package/lib/lookup/perState.d.ts

@@ -0,0 +1,32 @@
+import { Draft } from "immer";
+/**
+ * The draft as it stands, as plain data: the state it was drafted from
+ * while nothing has changed it, and a copy of it as it now stands once
+ * something has.
+ */
+export declare const takenOf: <T extends object>(draft: Draft<T>) => T;
+/**
+ * The edition as a state that no longer changes. It is frozen, deeply
+ * and once, as immer freezes what it produces, since what is worked out
+ * from a state is kept for as long as the state is: changed in place
+ * afterwards, it would leave that behind unnoticed, and frozen, the
+ * change throws instead. An edition immer produced is frozen already,
+ * and freezing stops at whatever is. A copy taken of a draft is left as
+ * it is (`takenOf`).
+ *
+ * A draft is no such state, since the next write changes it. It is read
+ * as it stands by taking `stateOf(draft)` first, once for all that is
+ * asked of it; asked of directly, it would have to be copied for every
+ * question.
+ */
+export declare const settled: <T extends object>(edition: T) => T;
+/**
+ * What is worked out from an edition, once for each state of it.
+ *
+ * Every change to an edition yields a new object, immer's produce
+ * included, so the state an object stands for never changes and what
+ * was worked out from it holds for as long as the object is around.
+ * Nothing is worked out before it is first asked for, and nothing is
+ * kept once the state is gone.
+ */
+export declare const perState: <E extends object, T>(work: (edition: E) => T) => ((edition: E) => T);

package/lib/lookup/perState.js

@@ -0,0 +1,63 @@
+import { current, freeze, isDraft, original } from "immer";
+/**
+ * Copies taken of a draft as it stood, for an operation to read. Such a
+ * copy is the operation's alone and is not frozen: what the operation
+ * reads from it may go into the draft, and a later operation on the same
+ * draft may go on to change it there, as it may anything written there.
+ */
+const takenOfDrafts = new WeakSet();
+/**
+ * The draft as it stands, as plain data: the state it was drafted from
+ * while nothing has changed it, and a copy of it as it now stands once
+ * something has.
+ */
+export const takenOf = (draft) => {
+    const state = current(draft);
+    if (state !== original(draft))
+        takenOfDrafts.add(state);
+    return state;
+};
+/**
+ * The edition as a state that no longer changes. It is frozen, deeply
+ * and once, as immer freezes what it produces, since what is worked out
+ * from a state is kept for as long as the state is: changed in place
+ * afterwards, it would leave that behind unnoticed, and frozen, the
+ * change throws instead. An edition immer produced is frozen already,
+ * and freezing stops at whatever is. A copy taken of a draft is left as
+ * it is (`takenOf`).
+ *
+ * A draft is no such state, since the next write changes it. It is read
+ * as it stands by taking `stateOf(draft)` first, once for all that is
+ * asked of it; asked of directly, it would have to be copied for every
+ * question.
+ */
+export const settled = (edition) => {
+    if (isDraft(edition)) {
+        throw new Error('An edition is asked about as a state, not as a draft: take stateOf(draft) first.');
+    }
+    return takenOfDrafts.has(edition) ? edition : freeze(edition, true);
+};
+/**
+ * What is worked out from an edition, once for each state of it.
+ *
+ * Every change to an edition yields a new object, immer's produce
+ * included, so the state an object stands for never changes and what
+ * was worked out from it holds for as long as the object is around.
+ * Nothing is worked out before it is first asked for, and nothing is
+ * kept once the state is gone.
+ */
+export const perState = (work) => {
+    const known = new WeakMap();
+    return edition => {
+        // A state known already was settled when it became known, and a
+        // draft never is, so only what is asked of for the first time
+        // needs settling.
+        const kept = known.get(edition);
+        if (kept)
+            return kept.value;
+        const state = settled(edition);
+        const entry = { value: work(state) };
+        known.set(state, entry);
+        return entry.value;
+    };
+};

package/lib/model/Edit.d.ts

@@ -23,6 +23,10 @@ export type EditType = typeof editTypes[number];
  * If an edit is the interpretation of a metamark,
  * such as a pencil mark, this should be made explicit
  * using a meaning comprehension on the `@annotation` field.
+ * An edit states no date. That it ended no later than the act that
+ * made a feature carrying a symbol it inserts, a reasoner derives with
+ * the axioms of reo.ttl; which of those dates bounds it closest is for
+ * a query to pick.
  * @see reo:Edit
  */
 export interface Edit extends WithId, Assumption {

package/lib/model/Edition.d.ts

@@ -1,6 +1,5 @@
 import { RollCopy } from "./RollCopy.js";
 import { Version } from "./Version.js";
-import { CollationTolerance } from "../collation/Collation.js";
 import { DateAssignment, ObjectAssumption } from "./Assumption.js";
 import { Editor, Person, Place } from "./Agent.js";
 import { RollTempo } from "../systems/ReproducingSystem.js";
@@ -28,18 +27,6 @@ export interface EditionCreation {
      * @see dcterms:date
      */
     publicationDate: Date;
-    /**
-     * The tolerance every version of the edition was collated at,
-     * before each derivation stated its own. How precisely two copies
-     * place a symbol depends on which two they are, so the tolerance
-     * belongs to the derivation, `Derivation.collationTolerance`, and
-     * migration writes this one onto every derivation that gives none.
-     * Nothing else reads it. A window's offset is the displacement
-     * between two particular copies and so can never be stated here.
-     * Not exported to RDF.
-     * @deprecated
-     */
-    collationTolerance?: CollationTolerance;
 }
 /**
  * Describes the event of recording and documents

package/lib/model/Version.d.ts

@@ -93,7 +93,13 @@ export interface Version extends WithId {
     basedOn?: Derivation[];
     /**
      * The act that made this version, where it is known: who carried it
-     * out, when, and by what rule.
+     * out, when, and by what rule. The export states the act for every
+     * version, stating nothing of it where nothing is known, so that the
+     * axioms of reo.ttl can place it in time: it started after the
+     * recording and the creation of every version it derives from had
+     * started, and ended no later than the punching of any copy carrying
+     * a symbol it added. A date stated here stands beside those; which of
+     * them bounds the act closest is for a query to pick.
      * @see lrmoo:R17i was created by
      */
     creation?: VersionCreation;

package/lib/ops/beliefs.d.ts

@@ -1,4 +1,4 @@
-import { Path } from "../view/EditionView.js";
+import { Path } from "../lookup/paths.js";
 import { AnyArgumentation, Certainty } from "../model/Assumption.js";
 import { EditionOp } from "./draft.js";
 /** Annotates the assumption at the path with a belief held true, for reasons to be added. */

package/lib/ops/beliefs.js

@@ -1,5 +1,5 @@
 import { v4 } from "uuid";
-import { getAt } from "../view/EditionView.js";
+import { getAt } from "../lookup/paths.js";
 const onAssumptionAt = (path, op) => draft => {
     const assumption = getAt(path, draft);
     if (assumption)

package/lib/ops/collation.d.ts

@@ -1,4 +1,3 @@
-import { EditionView } from "../view/EditionView.js";
 import { CollationTolerance } from "../collation/Collation.js";
 import { ObjectAssumption } from "../model/Assumption.js";
 import { EditionOp } from "./draft.js";
@@ -28,13 +27,13 @@ import { EditionOp } from "./draft.js";
  * statement, since the stemma would loop; asked for that, nothing
  * changes.
  */
-export declare const connectVersions: (given: EditionView, childId: string, parentId: string, tolerance?: ObjectAssumption<CollationTolerance>) => EditionOp;
+export declare const connectVersions: (childId: string, parentId: string, tolerance?: ObjectAssumption<CollationTolerance>) => EditionOp;
 /**
  * Folds the version's own symbols into those it inherits and collates
  * with: the carriers pass over, and the insertions go. Collates at the
  * tolerance of the derivation, where the caller names none.
  */
-export declare const collateSymbols: (given: EditionView, versionId: string, symbolIds: readonly string[], tolerance?: CollationTolerance) => EditionOp;
+export declare const collateSymbols: (versionId: string, symbolIds: readonly string[], tolerance?: CollationTolerance) => EditionOp;
 /**
  * Takes the named copies' reading of a symbol back out of the symbol it
  * was collated into: their carriers pass to a new symbol of the
@@ -59,4 +58,4 @@ export declare const collateSymbols: (given: EditionView, versionId: string, sym
  * keeps its identifier and the edit that speaks for it. Named symbols
  * narrow the act to those; naming none separates the whole reading.
  */
-export declare const separateReadings: (given: EditionView, versionId: string, copies: ReadonlySet<string>, symbolIds?: readonly string[]) => EditionOp;
+export declare const separateReadings: (versionId: string, copies: ReadonlySet<string>, symbolIds?: readonly string[]) => EditionOp;

package/lib/ops/collation.js

@@ -1,15 +1,17 @@
 import { v4 } from "uuid";
-import { getAt } from "../view/EditionView.js";
+import { getAt, pathIn } from "../lookup/paths.js";
 import { collationsOf, defaultCollationTolerance, isCollationsOwn, unchecked } from "../collation/Collation.js";
 import { collationToleranceOf, derivesFrom, editsOf, insertedBy, principalDerivationOf } from "../model/Version.js";
 import { substitutionsBetween } from "../collation/substitution.js";
 import { trackerBarOf } from "../systems/index.js";
 import { assignReference, idOf } from "../model/Assumption.js";
-import { noChange, onVersion, stateOf, insertion, deletion, asUnchecked, declaring, insertedIn, dropInsertions, reading } from "./draft.js";
+import { noChange, onVersion, insertion, deletion, asUnchecked, declaring, dropInsertions, reading } from "./draft.js";
 import { hypothesesBeside } from "./versions.js";
+import { placeOf, snapshotOf } from "../analysis/text.js";
+import { copyOfFeature, versionIn } from "../lookup/lookup.js";
 /** The carriers of each collated symbol pass to its counterpart. */
-const handOverCarriers = (view, draft, collations) => collations.forEach(({ symbol, counterpart }) => {
-    const path = view.getPath(counterpart.id);
+const handOverCarriers = (edition, draft, collations) => collations.forEach(({ symbol, counterpart }) => {
+    const path = pathIn(edition, counterpart.id);
     const target = path && getAt(path, draft);
     target?.carriers.push(...symbol.carriers);
 });
@@ -59,10 +61,10 @@ const byExchange = (edits) => new Map(edits.map(edit => [exchangeKey((edit.inser
  * statement, since the stemma would loop; asked for that, nothing
  * changes.
  */
-export const connectVersions = (given, childId, parentId, tolerance = defaultCollationTolerance) => reading(given, view => {
-    if (childId === parentId || derivesFrom(view.edition.versions, parentId, childId))
+export const connectVersions = (childId, parentId, tolerance = defaultCollationTolerance) => reading(edition => {
+    if (childId === parentId || derivesFrom(edition.versions, parentId, childId))
         return noChange;
-    const child = view.version(childId);
+    const child = versionIn(edition, childId);
     const stated = child ? editsOf(child) : [];
     const established = stated.filter(edit => !isCollationsOwn(edit));
     const spokenFor = spokenForBy(established);
@@ -71,12 +73,12 @@ export const connectVersions = (given, childId, parentId, tolerance = defaultCol
     // through: it is neither the child's own symbol nor one it lacks.
     // Without that, connecting a pair already connected would collate
     // the inherited symbols with themselves and double their carriers.
-    const handedDown = view.snapshot(parentId).filter(unspoken);
-    const shown = new Set(view.snapshot(childId).map(symbol => symbol.id));
+    const handedDown = snapshotOf(edition, parentId).filter(unspoken);
+    const shown = new Set(snapshotOf(edition, childId).map(symbol => symbol.id));
     const inheritedIds = new Set(handedDown.map(symbol => symbol.id));
     const inherited = handedDown.filter(symbol => !shown.has(symbol.id));
-    const own = view.snapshot(childId).filter(symbol => unspoken(symbol) && !inheritedIds.has(symbol.id));
-    const locate = (symbol) => view.placeOf(symbol);
+    const own = snapshotOf(edition, childId).filter(symbol => unspoken(symbol) && !inheritedIds.has(symbol.id));
+    const locate = (symbol) => placeOf(edition, symbol);
     const collations = collationsOf(own, inherited, locate, tolerance);
     const collated = new Set(collations.map(({ symbol }) => symbol.id));
     const matched = new Set(collations.map(({ counterpart }) => counterpart.id));
@@ -87,7 +89,7 @@ export const connectVersions = (given, childId, parentId, tolerance = defaultCol
      * apart would make the apparatus a list of unexplained losses beside
      * a list of unexplained gains.
      */
-    const substituted = differ(child, view.version(parentId))
+    const substituted = differ(child, versionIn(edition, parentId))
         ? substitutionsBetween(own.filter(symbol => !collated.has(symbol.id)), inherited.filter(symbol => !matched.has(symbol.id)), locate, tolerance)
         : [];
     const paired = new Set(substituted.flatMap(({ replaced, by }) => [...by, ...replaced].map(symbol => symbol.id)));
@@ -112,14 +114,18 @@ export const connectVersions = (given, childId, parentId, tolerance = defaultCol
             .filter(symbol => !matched.has(symbol.id) && !paired.has(symbol.id))
             .map(symbol => asUnchecked(deletion(symbol.id)))
     ];
-    return onVersion(childId, (child, draft) => {
-        handOverCarriers(view, draft, collations);
-        child.edits = edits;
-        child.motivations = declaring(stateOf(child).motivations, edits);
-        child.basedOn = [
-            { ...assignReference(parentId), collationTolerance: tolerance },
-            ...hypothesesBeside(stateOf(child), parentId)
-        ];
+    // Read off the child as it stands, since once its edits are written a
+    // reading of it would copy them all.
+    const motivations = declaring(child?.motivations ?? [], edits);
+    const basedOn = [
+        { ...assignReference(parentId), collationTolerance: tolerance },
+        ...(child ? hypothesesBeside(child, parentId) : [])
+    ];
+    return onVersion(childId, (version, draft) => {
+        handOverCarriers(edition, draft, collations);
+        version.edits = edits;
+        version.motivations = motivations;
+        version.basedOn = basedOn;
     });
 });
 /**
@@ -127,17 +133,17 @@ export const connectVersions = (given, childId, parentId, tolerance = defaultCol
  * with: the carriers pass over, and the insertions go. Collates at the
  * tolerance of the derivation, where the caller names none.
  */
-export const collateSymbols = (given, versionId, symbolIds, tolerance) => reading(given, view => {
-    const version = view.version(versionId);
+export const collateSymbols = (versionId, symbolIds, tolerance) => reading(edition => {
+    const version = versionIn(edition, versionId);
     const principal = version && principalDerivationOf(version);
     if (!version || !principal)
         return noChange;
     const chosen = new Set(symbolIds);
-    const own = insertedIn([version]).filter(symbol => chosen.has(symbol.id));
-    const collations = collationsOf(own, view.snapshot(idOf(principal)), symbol => view.placeOf(symbol), tolerance ?? collationToleranceOf(principal));
+    const own = insertedBy(version).filter(symbol => chosen.has(symbol.id));
+    const collations = collationsOf(own, snapshotOf(edition, idOf(principal)), symbol => placeOf(edition, symbol), tolerance ?? collationToleranceOf(principal));
     const collated = new Set(collations.map(({ symbol }) => symbol.id));
     return onVersion(versionId, (version, draft) => {
-        handOverCarriers(view, draft, collations);
+        handOverCarriers(edition, draft, collations);
         dropInsertions(version, collated);
     });
 });
@@ -163,9 +169,9 @@ const readingOf = (symbol, carriers) => {
  * where the two versions do not disagree and there is nothing to take
  * apart.
  */
-const sharedWith = (view, symbol, copies) => {
+const sharedWith = (edition, symbol, copies) => {
     const onNamedCopy = (carrier) => {
-        const copy = view.copyOf(idOf(carrier));
+        const copy = copyOfFeature(edition, idOf(carrier));
         return copy !== undefined && copies.has(copy.id);
     };
     const mine = symbol.carriers.filter(onNamedCopy);
@@ -196,14 +202,14 @@ const sharedWith = (view, symbol, copies) => {
  * keeps its identifier and the edit that speaks for it. Named symbols
  * narrow the act to those; naming none separates the whole reading.
  */
-export const separateReadings = (given, versionId, copies, symbolIds) => reading(given, view => {
-    const version = view.version(versionId);
+export const separateReadings = (versionId, copies, symbolIds) => reading(edition => {
+    const version = versionIn(edition, versionId);
     if (!version)
         return noChange;
     const chosen = symbolIds && new Set(symbolIds);
-    const shared = view.snapshot(versionId)
+    const shared = snapshotOf(edition, versionId)
         .filter(symbol => chosen === undefined || chosen.has(symbol.id))
-        .flatMap(symbol => sharedWith(view, symbol, copies));
+        .flatMap(symbol => sharedWith(edition, symbol, copies));
     if (shared.length === 0)
         return noChange;
     const inserted = new Set(insertedBy(version).map(symbol => symbol.id));
@@ -218,7 +224,7 @@ export const separateReadings = (given, versionId, copies, symbolIds) => reading
     }));
     return onVersion(versionId, (version, draft) => {
         shared.forEach(({ symbol, theirs }) => {
-            const path = view.getPath(symbol.id);
+            const path = pathIn(edition, symbol.id);
             const target = path && getAt(path, draft);
             if (target)
                 target.carriers = theirs;

package/lib/ops/commands.d.ts

@@ -1,9 +1,8 @@
-import { EditionView } from "../view/EditionView.js";
 import { PlacementRelation } from "../model/Symbol.js";
 import { EditionOp } from "./draft.js";
 /** States how the follower is placed relative to the reference, in place of any earlier statement. */
-export declare const placeCommand: (view: EditionView, followerId: string, referenceId: string, relation: PlacementRelation) => EditionOp;
-export declare const unplaceCommand: (view: EditionView, followerId: string) => EditionOp;
+export declare const placeCommand: (followerId: string, referenceId: string, relation: PlacementRelation) => EditionOp;
+export declare const unplaceCommand: (followerId: string) => EditionOp;
 /** The pair is stated on `statingId` only, as the format asks. */
-export declare const pairCommands: (view: EditionView, statingId: string, partnerId: string) => EditionOp;
-export declare const unpairCommand: (view: EditionView, statingId: string) => EditionOp;
+export declare const pairCommands: (statingId: string, partnerId: string) => EditionOp;
+export declare const unpairCommand: (statingId: string) => EditionOp;