linked-rolls 0.63.0 → 0.64.0

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,5 +1,5 @@
 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";
@@ -7,9 +7,11 @@ 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 { 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)));
@@ -113,7 +115,7 @@ export const connectVersions = (given, childId, parentId, tolerance = defaultCol
             .map(symbol => asUnchecked(deletion(symbol.id)))
     ];
     return onVersion(childId, (child, draft) => {
-        handOverCarriers(view, draft, collations);
+        handOverCarriers(edition, draft, collations);
         child.edits = edits;
         child.motivations = declaring(stateOf(child).motivations, edits);
         child.basedOn = [
@@ -127,17 +129,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 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 +165,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 +198,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 +220,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;

package/lib/ops/commands.js

@@ -1,29 +1,29 @@
-import { getAt } from "../view/EditionView.js";
+import { getAt, pathIn } from "../lookup/paths.js";
 import { isCommand, placementRelations } from "../model/Symbol.js";
 import { assignReference } from "../model/Assumption.js";
 import { reading } from "./draft.js";
 /**
- * Runs the change on the command the view locates by id, in whichever
- * version inserted it. A statement made there holds in every version
- * that carries the command.
+ * Runs the change on the command with the id, in whichever version
+ * inserted it. A statement made there holds in every version that
+ * carries the command.
  */
-const onCommand = (view, id, op) => reading(view, fresh => draft => {
-    const path = fresh.getPath(id);
+const onCommand = (id, op) => reading(edition => draft => {
+    const path = pathIn(edition, id);
     const symbol = path && getAt(path, draft);
     if (isCommand(symbol))
         op(symbol);
 });
 const clearPlacement = (command) => placementRelations.forEach(relation => { delete command[relation]; });
 /** States how the follower is placed relative to the reference, in place of any earlier statement. */
-export const placeCommand = (view, followerId, referenceId, relation) => onCommand(view, followerId, command => {
+export const placeCommand = (followerId, referenceId, relation) => onCommand(followerId, command => {
     clearPlacement(command);
     command[relation] = assignReference(referenceId);
 });
-export const unplaceCommand = (view, followerId) => onCommand(view, followerId, clearPlacement);
+export const unplaceCommand = (followerId) => onCommand(followerId, clearPlacement);
 /** The pair is stated on `statingId` only, as the format asks. */
-export const pairCommands = (view, statingId, partnerId) => onCommand(view, statingId, command => {
+export const pairCommands = (statingId, partnerId) => onCommand(statingId, command => {
     command.pairedWith = assignReference(partnerId);
 });
-export const unpairCommand = (view, statingId) => onCommand(view, statingId, command => {
+export const unpairCommand = (statingId) => onCommand(statingId, command => {
     delete command.pairedWith;
 });

package/lib/ops/draft.d.ts

@@ -1,4 +1,3 @@
-import { EditionView } from "../view/EditionView.js";
 /** What the operations are built from: the type of an operation, how one finds what it writes to on the draft, and the edits it writes. */
 import { Draft } from "immer";
 import { Edition } from "../model/Edition.js";
@@ -12,10 +11,10 @@ import { WithId } from "../shared/utils.js";
 /**
  * A change to an edition, written onto an immer draft of it. One
  * operation is one undo step, so an operation that has to read the
- * edition first takes an `EditionView` of the state it will be
- * applied to and does all its writing in the one function it returns.
- * Where operations run one after another on one draft, the ones after
- * the first read a view of the draft as it then stands (`reading`).
+ * edition reads it as the draft stands when the operation is applied
+ * (`reading`) and does all its writing in the one function it builds
+ * from that. Where operations run one after another on one draft, each
+ * reads what the ones before it wrote.
  */
 export type EditionOp = (draft: Draft<Edition>) => void;
 export declare const noChange: EditionOp;
@@ -23,16 +22,17 @@ export declare const onCopy: (copyId: string, op: (copy: Draft<RollCopy>, draft:
 export declare const onVersion: (versionId: string, op: (version: Draft<Version>, draft: Draft<Edition>) => void) => EditionOp;
 export declare const onFeature: (copyId: string, featureId: string, op: (feature: Draft<FeatureOrPatch>) => void) => EditionOp;
 /**
- * The operation built from a view of the state it is applied to. The
- * view given is used where the draft still stands as the view saw it,
- * and a fresh one is taken of the draft where an operation run before
- * on the same draft has changed it: a path or an index read off the
- * view would otherwise name what stood there before.
+ * The operation built from the state it is applied to: the draft as it
+ * stands, an operation run before on the same draft included. A path
+ * or an index read off an earlier state would name what stood there
+ * before. What is worked out from a state is kept with it, so a draft
+ * nothing has changed yet is read from what is known already.
  */
-export declare const reading: (view: EditionView, build: (view: EditionView) => EditionOp) => EditionOp;
+export declare const reading: (build: (edition: Edition) => EditionOp) => EditionOp;
 /**
  * The state a draft stands at, as plain data. Reading a draft proxies
- * everything it touches, so what is only read is read from this.
+ * everything it touches, so what is only read is read from this, and
+ * what is looked up in an edition is looked up in this (`takenOf`).
  */
 export declare const stateOf: <T>(draft: Draft<T>) => T;
 /** The ids of the items the rewriting left out. */

package/lib/ops/draft.js

@@ -1,12 +1,12 @@
-import { EditionView } from "../view/EditionView.js";
 /** What the operations are built from: the type of an operation, how one finds what it writes to on the draft, and the edits it writes. */
-import { current, isDraft } from "immer";
+import { isDraft } from "immer";
 import { v4 } from "uuid";
 import { unchecked, uncheckedMotivation } from "../collation/Collation.js";
 import { insertedBy } from "../model/Version.js";
 import { featuresOf } from "../model/RollCopy.js";
 import { assignReference } from "../model/Assumption.js";
 import { without, pruned } from "./immutable.js";
+import { takenOf } from "../lookup/perState.js";
 export const noChange = () => undefined;
 export const onCopy = (copyId, op) => draft => {
     const copy = draft.copies.find(c => c.id === copyId);
@@ -24,21 +24,19 @@ export const onFeature = (copyId, featureId, op) => onCopy(copyId, copy => {
         op(feature);
 });
 /**
- * The operation built from a view of the state it is applied to. The
- * view given is used where the draft still stands as the view saw it,
- * and a fresh one is taken of the draft where an operation run before
- * on the same draft has changed it: a path or an index read off the
- * view would otherwise name what stood there before.
+ * The operation built from the state it is applied to: the draft as it
+ * stands, an operation run before on the same draft included. A path
+ * or an index read off an earlier state would name what stood there
+ * before. What is worked out from a state is kept with it, so a draft
+ * nothing has changed yet is read from what is known already.
  */
-export const reading = (view, build) => draft => {
-    const state = stateOf(draft);
-    build(state === view.edition ? view : new EditionView(state))(draft);
-};
+export const reading = (build) => draft => build(stateOf(draft))(draft);
 /**
  * The state a draft stands at, as plain data. Reading a draft proxies
- * everything it touches, so what is only read is read from this.
+ * everything it touches, so what is only read is read from this, and
+ * what is looked up in an edition is looked up in this (`takenOf`).
  */
-export const stateOf = (draft) => isDraft(draft) ? current(draft) : draft;
+export const stateOf = (draft) => isDraft(draft) ? takenOf(draft) : draft;
 /** The ids of the items the rewriting left out. */
 export const droppedIds = (before, after) => {
     const kept = new Set(after.map(item => item.id));

package/lib/ops/edits.d.ts

@@ -1,10 +1,9 @@
-import { EditionView } from "../view/EditionView.js";
 import { Edit } from "../model/Edit.js";
 import { EditionOp } from "./draft.js";
 /**
  * Replaces the edits with a single one carrying all their insertions
  * and deletions, classified by a guess at what the exchange does.
  */
-export declare const mergeEdits: (given: EditionView, versionId: string, toMerge: readonly Edit[]) => EditionOp;
+export declare const mergeEdits: (versionId: string, toMerge: readonly Edit[]) => EditionOp;
 /** Replaces the edit with one edit per inserted and one per deleted symbol. */
 export declare const splitEdit: (versionId: string, toSplit: Edit) => EditionOp;

package/lib/ops/edits.js

@@ -4,6 +4,9 @@ import { editsOf } from "../model/Version.js";
 import { trackerBarOf } from "../systems/index.js";
 import { distance, mm, subtract } from "../model/Quantity.js";
 import { noChange, onVersion, insertion, deletion, reading } from "./draft.js";
+import { predecessorOf } from "../analysis/stemma.js";
+import { placeOf } from "../analysis/text.js";
+import { symbolsIn, versionIn } from "../lookup/lookup.js";
 const sameSequence = (a, b) => a.length === b.length && a.every((value, i) => value === b[i]);
 const expressionTypesOf = (symbols) => symbols.filter((symbol) => symbol.type === 'expression').map(symbol => symbol.expressionType);
 /** The spellings of a single added accent the bar offers, none where no bar is known. */
@@ -12,9 +15,9 @@ const lengthOf = (span) => subtract(span.to, span.from);
 /** How far apart two onsets may lie for the one symbol to count as a replacement of the other. */
 const REPLACEMENT_TOLERANCE = mm(5);
 /** Shorten or prolong, where the inserted symbol starts about where the deleted one did. */
-const replacementType = (view, inserted, deleted) => {
-    const after = view.placeOf(inserted);
-    const before = view.placeOf(deleted);
+const replacementType = (edition, inserted, deleted) => {
+    const after = placeOf(edition, inserted);
+    const before = placeOf(edition, deleted);
     if (!after || !before || distance(after.from, before.from) >= REPLACEMENT_TOLERANCE)
         return undefined;
     return lengthOf(after) < lengthOf(before) ? 'shorten' : 'prolong';
@@ -23,13 +26,13 @@ const replacementType = (view, inserted, deleted) => {
  * A guess at what an edit does, from the symbols it exchanges and from
  * the systems the version and the one it is based on are coded for.
  */
-const guessEditType = (view, versionId, edit) => {
+const guessEditType = (edition, versionId, edit) => {
     const inserts = edit.insert ?? [];
-    const deletes = view.symbols(edit.delete ?? []);
+    const deletes = symbolsIn(edition, edit.delete ?? []);
     const inserted = expressionTypesOf(inserts);
     const deleted = expressionTypesOf(deletes);
-    const bar = trackerBarOf(view.version(versionId)?.system);
-    const parentBar = trackerBarOf(view.predecessorOf(versionId)?.system);
+    const bar = trackerBarOf(versionIn(edition, versionId)?.system);
+    const parentBar = trackerBarOf(predecessorOf(edition, versionId)?.system);
     /**
      * Where the version is coded for another system than its parent,
      * expression matter changed is the transfer being carried out: a red
@@ -54,14 +57,14 @@ const guessEditType = (view, versionId, edit) => {
     if (inserted.length === 0 && deleted.length === 1)
         return 'remove-redundancy';
     if (inserts.length === 1 && deletes.length === 1)
-        return replacementType(view, inserts[0], deletes[0]) ?? 'correct-error';
+        return replacementType(edition, inserts[0], deletes[0]) ?? 'correct-error';
     return 'correct-error';
 };
 /**
  * Replaces the edits with a single one carrying all their insertions
  * and deletions, classified by a guess at what the exchange does.
  */
-export const mergeEdits = (given, versionId, toMerge) => reading(given, view => {
+export const mergeEdits = (versionId, toMerge) => reading(edition => {
     if (toMerge.length === 0)
         return noChange;
     const merged = {
@@ -70,7 +73,7 @@ export const mergeEdits = (given, versionId, toMerge) => reading(given, view =>
         insert: toMerge.flatMap(edit => edit.insert ?? []),
         delete: toMerge.flatMap(edit => edit.delete ?? [])
     };
-    merged.editType = guessEditType(view, versionId, merged);
+    merged.editType = guessEditType(edition, versionId, merged);
     const mergedIds = new Set(toMerge.map(edit => edit.id));
     return onVersion(versionId, version => {
         version.edits = [...editsOf(version).filter(edit => !mergedIds.has(edit.id)), merged];

package/lib/ops/features.d.ts

@@ -1,4 +1,4 @@
-import { EditionView } from "../view/EditionView.js";
+import { Edition } from "../model/Edition.js";
 import { ModificationPurpose } from "../model/RollCopy.js";
 import { FeatureConditionAssignment, FeatureOrPatch, NestedFeature } from "../model/Feature.js";
 import { EditionOp } from "./draft.js";
@@ -62,7 +62,7 @@ export declare const mergeObstacle: (features: readonly FeatureOrPatch[]) => Mer
  * feature is the work of one act, and where the features stand is the
  * edition's business rather than theirs.
  */
-export declare const mergeObstacleIn: (view: EditionView, featureIds: readonly string[]) => MergeObstacle | undefined;
+export declare const mergeObstacleIn: (edition: Edition, featureIds: readonly string[]) => MergeObstacle | undefined;
 /**
  * Replaces the features of the copy with a single one covering them
  * all, where a scan has split what the editor reads as one feature.

package/lib/ops/features.js

@@ -6,6 +6,7 @@ import { mm } from "../model/Quantity.js";
 import { onCopy, onFeature, stateOf } from "./draft.js";
 import { without, mapped, pruned, replacing, isRecord } from "./immutable.js";
 import { renameReferences, forgetFeatures } from "./forget.js";
+import { copyOfFeature } from "../lookup/lookup.js";
 /**
  * Whether the feature's own kind allows a condition of this kind. The
  * type narrowed to is the weaker statement, holding of a condition any
@@ -209,8 +210,8 @@ const obstacleIn = (copy, featureIds) => {
  * feature is the work of one act, and where the features stand is the
  * edition's business rather than theirs.
  */
-export const mergeObstacleIn = (view, featureIds) => {
-    const copy = featureIds.map(id => view.copyOf(id)).find(copy => copy !== undefined);
+export const mergeObstacleIn = (edition, featureIds) => {
+    const copy = featureIds.map(id => copyOfFeature(edition, id)).find(copy => copy !== undefined);
     return copy ? obstacleIn(copy, featureIds) : 'fewer-than-two';
 };
 /** The items with the replacement in the place of the first it stands for, the others dropped. */

package/lib/ops/index.d.ts

@@ -3,7 +3,7 @@
  * They are grouped by what they change under `ops/`; this module names
  * the ones the library offers.
  */
-export type { EditionOp } from "./draft.js";
+export { stateOf, type EditionOp } from "./draft.js";
 export { createVersion, addCopy, alignmentFor, alignCopy, alignCopies, chooseReferenceCopy, unalignCopy, shortenCopy, unshortenCopy, stateSource, clearSource, nameCopy, stateCarriage, clearCarriage, addGeneralCondition, statePaperStretch, addTear, symbolsCarriedOnlyBy, removeCopy } from "./copies.js";
 export { stateFeatureCondition, addFeature, addBorneFeature, removeFeatures, mergeObstacle, mergeObstacleIn, mergeFeatures, type FeatureAct, type MergeObstacle } from "./features.js";
 export { detachVersion, removeVersion, removeSymbols, deriveVersion, stateDerivation, clearDerivation } from "./versions.js";

package/lib/ops/index.js

@@ -1,3 +1,9 @@
+/**
+ * The operations on an edition, each written onto an immer draft of it.
+ * They are grouped by what they change under `ops/`; this module names
+ * the ones the library offers.
+ */
+export { stateOf } from "./draft.js";
 export { createVersion, addCopy, alignmentFor, alignCopy, alignCopies, chooseReferenceCopy, unalignCopy, shortenCopy, unshortenCopy, stateSource, clearSource, nameCopy, stateCarriage, clearCarriage, addGeneralCondition, statePaperStretch, addTear, symbolsCarriedOnlyBy, removeCopy } from "./copies.js";
 export { stateFeatureCondition, addFeature, addBorneFeature, removeFeatures, mergeObstacle, mergeObstacleIn, mergeFeatures } from "./features.js";
 export { detachVersion, removeVersion, removeSymbols, deriveVersion, stateDerivation, clearDerivation } from "./versions.js";

package/lib/ops/versions.d.ts

@@ -1,4 +1,3 @@
-import { EditionView } from "../view/EditionView.js";
 import { Derivation, Version } from "../model/Version.js";
 import { Belief } from "../model/Assumption.js";
 import { EditionOp } from "./draft.js";
@@ -9,13 +8,13 @@ export declare const hypothesesBeside: (version: Readonly<Version>, parentId: st
  * own insertions, and its derivations go, the hypotheses among them,
  * with the motivations that belonged to them.
  */
-export declare const detachVersion: (given: EditionView, versionId: string) => EditionOp;
+export declare const detachVersion: (versionId: string) => EditionOp;
 /**
  * Takes the version out. Whatever read its text against it comes to
  * stand on its own, a hypothesis that something derives from it goes,
  * and so does a copy's statement that it carries the version.
  */
-export declare const removeVersion: (given: EditionView, versionId: string) => EditionOp;
+export declare const removeVersion: (versionId: string) => EditionOp;
 /** Takes the symbols out of the version's own insertions, and the edits that had nothing else. */
 export declare const removeSymbols: (versionId: string, symbolIds: readonly string[]) => EditionOp;
 /** Moves the edits into a new version based on this one. */

package/lib/ops/versions.js

@@ -4,6 +4,7 @@ import { assignReference, idOf } from "../model/Assumption.js";
 import { onVersion, stateOf, insertion, dropInsertions, referenceHeld, withoutReferences, reading } from "./draft.js";
 import { without } from "./immutable.js";
 import { dropStatements } from "./copies.js";
+import { snapshotOf } from "../analysis/text.js";
 /** Whether the version's text is read against the parent, its principal derivation naming it. */
 const readsAgainst = (version, parentId) => {
     const principal = principalDerivationOf(version);
@@ -30,8 +31,8 @@ const dropDerivations = (version, matches) => {
  * own insertions, and its derivations go, the hypotheses among them,
  * with the motivations that belonged to them.
  */
-export const detachVersion = (given, versionId) => reading(given, view => {
-    const edits = view.snapshot(versionId).map(insertion);
+export const detachVersion = (versionId) => reading(edition => {
+    const edits = snapshotOf(edition, versionId).map(insertion);
     return onVersion(versionId, version => {
         version.edits = edits;
         delete version.basedOn;
@@ -43,10 +44,10 @@ export const detachVersion = (given, versionId) => reading(given, view => {
  * stand on its own, a hypothesis that something derives from it goes,
  * and so does a copy's statement that it carries the version.
  */
-export const removeVersion = (given, versionId) => reading(given, view => {
-    const detachments = view.edition.versions
+export const removeVersion = (versionId) => reading(edition => {
+    const detachments = edition.versions
         .filter(version => readsAgainst(version, versionId))
-        .map(version => detachVersion(view, version.id));
+        .map(version => detachVersion(version.id));
     const namesIt = (reference) => idOf(reference) === versionId;
     return draft => {
         detachments.forEach(detach => detach(draft));

package/lib/schema.json

@@ -523,7 +523,7 @@
             "type": "string"
         },
         "Edit": {
-            "description": "A set of edits transforms a version of a roll into another version. Edits insert or delete symbols, or both (= replace). Edits may be motivated by a given set of reasons, e.g. to add an additional accent or to correct an error. 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.",
+            "description": "A set of edits transforms a version of a roll into another version. Edits insert or delete symbols, or both (= replace). Edits may be motivated by a given set of reasons, e.g. to add an additional accent or to correct an error. 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.",
             "properties": {
                 "@annotation": {
                     "description": "An optional annotation expressing a belief about this assumption. Uses the JSON-LD-star `@annotation` mechanism to attach epistemic metadata (certainty and reasons) to any triple.",
@@ -3523,7 +3523,7 @@
                 },
                 "creation": {
                     "$ref": "#/definitions/VersionCreation",
-                    "description": "The act that made this version, where it is known: who carried it out, when, and by what rule.",
+                    "description": "The act that made this version, where it is known: who carried it 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.",
                     "ontology": "lrmoo:R17i was created by"
                 },
                 "edits": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linked-rolls",
-  "version": "0.63.0",
+  "version": "0.64.0",
   "description": "Digital editions of piano rolls: import, collation, editorial assumptions, JSON-LD export, and emulation through a reproducing system",
   "license": "MIT",
   "repository": {