linked-rolls 0.56.0 → 0.58.0

package/lib/io/importJsonLd.js

@@ -0,0 +1,128 @@
+import { derivedKeys } from "./asJsonLd.js";
+import { migrate, plainCopyId } from "./migrate.js";
+import { isDateString } from "../shared/utils.js";
+import schema from "../schema.json" with { type: 'json' };
+export const importDate = (str) => {
+    const [y, m, d] = str.split('-').map(s => parseInt(s, 10));
+    if ([y, m, d].some(n => isNaN(n))) {
+        throw new Error(`Invalid date format: "${str}". Expected "YYYY-MM-DD".`);
+    }
+    return new Date(y, m - 1, d);
+};
+/** The names of the properties the schema holds dates under, wherever they stand in it. */
+const dateKeysIn = (node, keys = new Set()) => {
+    if (Array.isArray(node))
+        node.forEach(item => dateKeysIn(item, keys));
+    else if (node !== null && typeof node === 'object') {
+        Object.entries(node).forEach(([key, value]) => {
+            if (key === 'properties' && value !== null && typeof value === 'object') {
+                Object.entries(value)
+                    .filter(([, property]) => property?.format === 'date')
+                    .forEach(([name]) => keys.add(name));
+            }
+            dateKeysIn(value, keys);
+        });
+    }
+    return keys;
+};
+/**
+ * The keys a date is read under. Only these: a string elsewhere that
+ * happens to read like a date, such as the transcription of a dated
+ * label, is text and stays text.
+ */
+const dateKeys = dateKeysIn(schema);
+/** A value as the edition holds it under the key: a date read, an entity converted, anything else as it stands. */
+const fromJsonLdValue = (key, value) => {
+    if (typeof value === 'string')
+        return dateKeys.has(key) && isDateString(value) ? importDate(value) : value;
+    if (Array.isArray(value))
+        return value.map(item => fromJsonLdValue(key, item));
+    if (value !== null && typeof value === 'object')
+        return fromJsonLdEntity(value);
+    return value;
+};
+/** A node without what the export derived from it: what an act changed follows from where the act stands. */
+const asStated = (json) => Object.keys(json).some(key => derivedKeys.has(key))
+    ? Object.fromEntries(Object.entries(json).filter(([key]) => !derivedKeys.has(key)))
+    : json;
+/**
+ * An entity with its keywords read as plain keys. The input is left as
+ * it is. The `@type` of a value object names the datatype of the value,
+ * not a class, and is dropped. So is a context: a version carries one
+ * naming its system's vocabulary, and it belongs to the serialisation
+ * rather than to the edition, which states the system as data.
+ */
+const fromJsonLdEntity = (json) => {
+    const { '@type': type, '@id': id, '@context': context, ...rest } = asStated(json);
+    const entity = Object.fromEntries(Object.entries(rest).map(([key, value]) => [key, fromJsonLdValue(key, value)]));
+    if (type !== undefined && !('@value' in json))
+        entity.type = type;
+    if (id !== undefined)
+        entity.id = id;
+    return entity;
+};
+// Every entity is named by its id alone. Documents written before that was so
+// prefixed a copy's with `copy/`, and are read here as though they had not.
+const withPlainCopyIds = (json) => ({
+    ...json,
+    copies: (json.copies ?? []).map((copy) => ({
+        ...copy,
+        '@id': typeof copy['@id'] === 'string' ? plainCopyId(copy['@id']) : copy['@id']
+    }))
+});
+/** A statement an export quoted rather than stated: an included node whose id is a triple. */
+const isQuotedStatement = (node) => node !== null && typeof node === 'object' && node['@id'] !== null && typeof node['@id'] === 'object';
+/** The reference a quoted statement made, annotated again with the belief the export set beside it. */
+const referenceOf = (statement) => {
+    const { '@id': { '@id': subject, ...made }, annotation, ...about } = statement;
+    const [key, value] = Object.entries(made)[0];
+    const listed = Array.isArray(value);
+    return {
+        subject,
+        key,
+        listed,
+        reference: {
+            ...(listed ? value[0] : value),
+            '@annotation': { ...(annotation !== undefined && { '@id': annotation }), ...about }
+        }
+    };
+};
+/** Whether the object states anything beside its id, which a reference to a node does not. */
+const isNode = (value) => typeof value['@id'] === 'string' && Object.keys(value).some(key => key !== '@id' && key !== '@annotation');
+/** The document with each quoted reference back on the node that makes it. */
+const withReferencesOn = (value, bySubject) => {
+    if (Array.isArray(value))
+        return value.map(item => withReferencesOn(item, bySubject));
+    if (!value || typeof value !== 'object')
+        return value;
+    const walked = Object.fromEntries(Object.entries(value).map(([key, child]) => [key, withReferencesOn(child, bySubject)]));
+    const references = isNode(value)
+        ? bySubject.get(value['@id']) ?? []
+        : [];
+    return references.reduce((node, { key, listed, reference }) => ({ ...node, [key]: listed ? [...(node[key] ?? []), reference] : reference }), walked);
+};
+/**
+ * Puts back what an export quoted. A reference the edition doubts goes
+ * out as a JSON-LD-star embedded node beside the document, so that RDF
+ * does not state it; in the edition it belongs on the node that makes
+ * it, under its belief. In a list it comes back after the references
+ * that were stated.
+ */
+const withQuotedStatementsInPlace = (edition) => {
+    const included = Array.isArray(edition['@included']) ? edition['@included'] : [];
+    const statements = included.filter(isQuotedStatement);
+    if (statements.length === 0)
+        return edition;
+    const others = included.filter(node => !isQuotedStatement(node));
+    const { '@included': _quoted, ...rest } = edition;
+    const bySubject = Map.groupBy(statements.map(referenceOf), ({ subject }) => subject);
+    return withReferencesOn({ ...rest, ...(others.length > 0 && { '@included': others }) }, bySubject);
+};
+export const importJsonLd = (json) => {
+    const { '@context': context, formatVersion: _revision, ...document } = withPlainCopyIds(migrate(withQuotedStatementsInPlace(json)));
+    const edition = fromJsonLdEntity(document);
+    edition.base = Array.isArray(context)
+        ? context.find((c) => c['@base'])?.['@base'] || ''
+        : '';
+    return edition;
+};

package/lib/{migrate.d.ts → io/migrate.d.ts}

@@ -13,5 +13,14 @@
 type Json = any;
 /** A copy's id without the `copy/` that documents of earlier releases put before it. */
 export declare const plainCopyId: (id: string) => string;
+/**
+ * The revision of the format this release writes, stated in every export
+ * as `formatVersion`. A document stating it is in the current shape and
+ * passes through untouched; one stating none was written before the
+ * revisions were numbered and is brought up by recognising its shapes.
+ * A step added later is to run on the documents of the revisions before
+ * it, and to raise this number.
+ */
+export declare const formatVersion = 1;
 export declare const migrate: (edition: Json) => Json;
 export {};

package/lib/{migrate.js → io/migrate.js}

@@ -1,11 +1,24 @@
-import { conditions, isFeatureType, media, techniques } from "./Feature.js";
-import { rollConditions } from "./RollCopy.js";
-import { systemIdIn, systemOf, translationBetween } from "./TrackerBar.js";
-import { trackerBars } from "./systems/index.js";
-import { welteT100 } from "./systems/welteT100/bar.js";
-import { isDateString } from "./utils.js";
+import { systemIdIn, systemOf, translationBetween } from "../systems/TrackerBar.js";
+import { trackerBars } from "../systems/index.js";
+import { welteT100 } from "../systems/welteT100/bar.js";
+import { isDateString } from "../shared/utils.js";
 const retiredVersionTypes = new Set(['edition', 'unicum']);
-const conditionTypeValues = new Set([...rollConditions, ...Object.values(conditions).flat()]);
+/**
+ * The vocabulary the steps below were written against, as it stood when
+ * the format was first given a revision number. It is copied here rather
+ * than imported from the model, so that changing today's vocabulary
+ * cannot change how an old document is read. The tracker bars are still
+ * asked, being the layout of instruments rather than a choice of the
+ * format.
+ */
+const conditionTypeValues = new Set([
+    'general', 'paper-stretch',
+    'partially-torn', 'missing-perforation', 'illegible', 'faded', 'detaching', 'ripped'
+]);
+const techniques = ['print', 'handwriting', 'stamp'];
+const media = ['ink', 'pencil', 'crayon'];
+const featureTypes = ['HoleChain', 'Writing', 'Mark', 'Patch'];
+const isFeatureType = (value) => typeof value === 'string' && featureTypes.includes(value);
 const renamedKeys = {
     productionEvent: 'production',
     annotates: 'depiction',
@@ -128,6 +141,38 @@ const withScale = (node) => {
     const factor = (node.conditions ?? []).find(isPaperStretch)?.factor;
     return factor === undefined ? node : { ...node, measurements: { ...node.measurements, scale: factor } };
 };
+/**
+ * What each entry of a copy's former `ops` list stands for among its
+ * measurements, and the value that does nothing where the list claimed
+ * an act whose amount was never recorded.
+ */
+const opsInMeasurements = [
+    ['shifted', 'shift', { horizontal: 0, vertical: 0 }],
+    ['stretched', 'scale', 1],
+    ['shortened', 'readerExtension', { length: 0 }]
+];
+/**
+ * A copy listed what had been done to line its features up, which said
+ * again what its measurements state; the measurements now say it alone.
+ * Where the two disagreed, the list is what the alignment went by, so
+ * the measurements are made to say what it said: a measurement it does
+ * not list is dropped, and an act it lists without a recorded amount is
+ * recorded as one that moved nothing. `withScale` has read the list by
+ * the time this runs.
+ */
+const withoutOps = (node) => {
+    if (!Array.isArray(node.ops))
+        return node;
+    const { ops, ...rest } = node;
+    const measurements = { ...rest.measurements };
+    opsInMeasurements.forEach(([op, key, nothing]) => {
+        if (!ops.includes(op))
+            delete measurements[key];
+        else if (measurements[key] === undefined)
+            measurements[key] = nothing;
+    });
+    return { ...rest, measurements };
+};
 /** A copy's id without the `copy/` that documents of earlier releases put before it. */
 export const plainCopyId = (id) => id.replace(/^copy\//, '');
 /**
@@ -156,7 +201,6 @@ const withPerforator = (node) => {
             perforator: {
                 ...perforator,
                 condition: {
-                    '@type': 'ConditionState',
                     conditionType: 'setting',
                     ...perforator.condition,
                     punchDiameter: diameter
@@ -196,6 +240,22 @@ const withoutPattern = (node) => {
     const { pattern: _moved, ...rest } = node;
     return rest;
 };
+/** A version and a condition state once stated their class, which the key they stand under entails. */
+const withoutEntailedType = (node) => {
+    if (node['@type'] !== 'Version' && node['@type'] !== 'ConditionState')
+        return node;
+    const { '@type': _entailed, ...rest } = node;
+    return rest;
+};
+/** An export once stated what a copy or a patch bears, which a reasoner now derives from the acts. */
+const withoutBearings = (node) => {
+    if (!Object.hasOwn(node, 'bears') && !Object.hasOwn(node, 'composedOf'))
+        return node;
+    if (node['@type'] !== 'RollCopy' && node['@type'] !== 'Patch')
+        return node;
+    const { bears: _bears, composedOf: _composedOf, ...rest } = node;
+    return rest;
+};
 /** A derivation written as a single one, before a version could name several. */
 const isSingleDerivation = (basedOn) => basedOn !== null && typeof basedOn === 'object' && !Array.isArray(basedOn);
 const withDerivationList = (node) => isSingleDerivation(node.basedOn) ? { ...node, basedOn: [node.basedOn] } : node;
@@ -312,8 +372,8 @@ const withTimeSpanDates = (node) => {
     return { ...rest, within };
 };
 const migrateNode = (node) => [withRenamedKeys, withTypology, withRenamedType, withoutVersionType, withoutVersionSiglum, withLowerCaseTerms, withSplitMethod, withReferences, withKeeper, withoutEmptyKeeper,
-    withPerforator, withProductionNodes, withTypedPerforator, withScale, withDerivationList, withReadingKind, withTimeSpanDates,
-    withoutFeatureKind, withBorneFeaturesNamed, withFeaturesInActs, withDriveOfStaggering, withoutPattern]
+    withPerforator, withProductionNodes, withTypedPerforator, withScale, withoutOps, withDerivationList, withReadingKind, withTimeSpanDates,
+    withoutFeatureKind, withBorneFeaturesNamed, withFeaturesInActs, 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) => {
@@ -390,6 +450,13 @@ const onOwnBar = (copy, rollSystem) => {
  * roll that named no system was a T-100 roll, and the text a copy's
  * production gave for it is kept as the system's name.
  */
+/** An export once stated the class of the edition, which R17i was created by entails. */
+const withoutEditionType = (edition) => {
+    if (edition['@type'] !== 'Edition')
+        return edition;
+    const { '@type': _entailed, ...rest } = edition;
+    return rest;
+};
 const withSystems = (edition) => {
     if (!edition.roll || !namesSystemOnTheRoll(edition))
         return edition;
@@ -444,51 +511,27 @@ const withDerivationTolerance = (edition) => {
             : version)
     };
 };
-/** A statement an export quoted rather than stated: an included node whose id is a triple. */
-const isQuotedStatement = (node) => node !== null && typeof node === 'object' && node['@id'] !== null && typeof node['@id'] === 'object';
-/** The reference a quoted statement made, annotated again with the belief the export set beside it. */
-const referenceOf = (statement) => {
-    const { '@id': { '@id': subject, ...made }, annotation, ...about } = statement;
-    const [key, value] = Object.entries(made)[0];
-    const listed = Array.isArray(value);
-    return {
-        subject,
-        key,
-        listed,
-        reference: {
-            ...(listed ? value[0] : value),
-            '@annotation': { ...(annotation !== undefined && { '@id': annotation }), ...about }
-        }
-    };
-};
-/** The document with each quoted reference back on the node that makes it, a node being what has a type. */
-const withReferencesOn = (value, bySubject) => {
-    if (Array.isArray(value))
-        return value.map(item => withReferencesOn(item, bySubject));
-    if (!value || typeof value !== 'object')
-        return value;
-    const walked = Object.fromEntries(Object.entries(value).map(([key, child]) => [key, withReferencesOn(child, bySubject)]));
-    const references = typeof value['@id'] === 'string' && value['@type'] !== undefined
-        ? bySubject.get(value['@id']) ?? []
-        : [];
-    return references.reduce((node, { key, listed, reference }) => ({ ...node, [key]: listed ? [...(node[key] ?? []), reference] : reference }), walked);
-};
+const editionSteps = [withoutEditionType, withSystems, withEditors, withDerivationTolerance];
 /**
- * Puts back what an export quoted. A reference the edition doubts goes
- * out as a JSON-LD-star embedded node beside the document, so that RDF
- * does not state it; in the edition it belongs on the node that makes
- * it, under its belief. In a list it comes back after the references
- * that were stated.
+ * The revision of the format this release writes, stated in every export
+ * as `formatVersion`. A document stating it is in the current shape and
+ * passes through untouched; one stating none was written before the
+ * revisions were numbered and is brought up by recognising its shapes.
+ * A step added later is to run on the documents of the revisions before
+ * it, and to raise this number.
  */
-const withQuotedStatementsInPlace = (edition) => {
-    const included = Array.isArray(edition['@included']) ? edition['@included'] : [];
-    const statements = included.filter(isQuotedStatement);
-    if (statements.length === 0)
+export const formatVersion = 1;
+export const migrate = (edition) => {
+    const stated = edition?.formatVersion;
+    if (stated === formatVersion)
         return edition;
-    const others = included.filter(node => !isQuotedStatement(node));
-    const { '@included': _quoted, ...rest } = edition;
-    const bySubject = Map.groupBy(statements.map(referenceOf), ({ subject }) => subject);
-    return withReferencesOn({ ...rest, ...(others.length > 0 && { '@included': others }) }, bySubject);
+    if (typeof stated === 'number' && stated > formatVersion) {
+        throw new Error(`The document is written in revision ${stated} of the format, which this release, reading up to ${formatVersion}, does not know`);
+    }
+    const current = walk(editionSteps.reduce((result, step) => step(result), edition));
+    // What comes out is in the current revision and says so, so that it
+    // passes through untouched when it is migrated again.
+    return current !== null && typeof current === 'object' && !Array.isArray(current)
+        ? { ...current, formatVersion }
+        : current;
 };
-const editionSteps = [withQuotedStatementsInPlace, withSystems, withEditors, withDerivationTolerance];
-export const migrate = (edition) => walk(editionSteps.reduce((result, step) => step(result), edition));

package/lib/{Agent.d.ts → model/Agent.d.ts}

@@ -1,4 +1,4 @@
-import { WithId } from "./utils.js";
+import { WithId } from "../shared/utils.js";
 /**
  * Something with a name and, where one exists, an authority record.
  */

package/lib/{Assumption.d.ts → model/Assumption.d.ts}

@@ -1,4 +1,4 @@
-import { WithNote, WithId } from "./utils.js";
+import { WithNote, WithId } from "../shared/utils.js";
 import { Person, WithActor } from "./Agent.js";
 export declare const certainties: readonly ['true', 'likely', 'possible', 'unlikely', 'false'];
 /**

package/lib/{ConditionState.d.ts → model/ConditionState.d.ts}

@@ -1,11 +1,10 @@
-import { WithType } from "./utils.js";
 /**
  * Physical condition of a roll or
  * of a feature on the roll (e.g. a damaged
  * or unsuccessful perforation).
  * @see crm:E3 Condition State
  */
-export interface ConditionState<T extends string> extends WithType<'ConditionState'> {
+export interface ConditionState<T extends string> {
     /**
      * The kind of condition, from the list the roll or
      * the kind of feature allows.

package/lib/{Edit.d.ts → model/Edit.d.ts}

@@ -1,6 +1,6 @@
 import { Assumption } from "./Assumption.js";
 import { AnySymbol } from "./Symbol.js";
-import { WithId } from "./utils.js";
+import { WithId } from "../shared/utils.js";
 export declare const editTypes: readonly [
 /**
  * An additional accent that can only be encoded with

package/lib/{Edition.d.ts → model/Edition.d.ts}

@@ -1,9 +1,9 @@
 import { RollCopy } from "./RollCopy.js";
 import { Version } from "./Version.js";
-import { CollationTolerance } from "./Collation.js";
+import { CollationTolerance } from "../collation/Collation.js";
 import { DateAssignment, ObjectAssumption } from "./Assumption.js";
 import { Editor, Person, Place } from "./Agent.js";
-import { RollTempo } from "./ReproducingSystem.js";
+import { RollTempo } from "../systems/ReproducingSystem.js";
 /**
  * This type describes the creation of an edition,
  * i.e. the editor, publisher, and publication date.

package/lib/{Feature.d.ts → model/Feature.d.ts}

@@ -1,7 +1,7 @@
 import { ObjectAssumption } from "./Assumption.js";
 import { ConditionState } from "./ConditionState.js";
 import { Text } from "./Symbol.js";
-import { PartialBy, WithId, WithType } from "./utils.js";
+import { PartialBy, WithId, WithType } from "../shared/utils.js";
 import { Measure, Millimeters, Track } from "./Quantity.js";
 /**
  * Describes the horizontal extent of a feature on the roll,
@@ -238,6 +238,8 @@ type Unplaced<T> = T extends FeatureOrPatch ? PartialBy<T, 'horizontal' | 'verti
  * the feature bearing it standing in one.
  */
 export type NestedFeature = Unplaced<FeatureOrPatch>;
+/** Whether the feature states a place of its own, which one a patch bears does not. */
+export declare const isPlaced: (feature: NestedFeature) => feature is FeatureOrPatch;
 export declare const isRollFeature: (obj: object) => obj is FeatureOrPatch;
 export declare const isPatch: <T extends NestedFeature>(feature: T) => feature is T & Patch;
 /** The features a feature bears: a patch those stated as parts of it, any other feature none. */

package/lib/{Feature.js → model/Feature.js}

@@ -8,6 +8,8 @@ export const conditions = {
 };
 export const techniques = ['print', 'handwriting', 'stamp'];
 export const media = ['ink', 'pencil', 'crayon'];
+/** Whether the feature states a place of its own, which one a patch bears does not. */
+export const isPlaced = (feature) => feature.horizontal !== undefined && feature.vertical !== undefined;
 export const isRollFeature = (obj) => {
     return 'type' in obj && isFeatureType(obj.type);
 };

package/lib/{FeatureSource.d.ts → model/FeatureSource.d.ts}

@@ -1,7 +1,7 @@
 import { ActorAssignment, DateAssignment, ObjectAssumption } from "./Assumption.js";
 import { Concept, Named } from "./Agent.js";
 import { ConditionState } from "./ConditionState.js";
-import { WithNote } from "./utils.js";
+import { WithNote } from "../shared/utils.js";
 /**
  * What a copy's features were read from. The kinds run from the paper
  * itself, through files in which the roll has already been read into

package/lib/{Perforator.d.ts → model/Perforator.d.ts}

@@ -1,7 +1,7 @@
 import { ObjectAssumption } from "./Assumption.js";
 import { ConditionState } from "./ConditionState.js";
 import { Measure, Millimeters } from "./Quantity.js";
-import { WithId, WithType } from "./utils.js";
+import { WithId, WithType } from "../shared/utils.js";
 /**
  * The pitch in the engineering sense: the distance along the roll from
  * one punch of a chain to the next, which is the slot one firing cut

package/lib/{RollCopy.d.ts → model/RollCopy.d.ts}

@@ -1,10 +1,10 @@
 import { ConditionState } from "./ConditionState.js";
 import { AnySymbol } from "./Symbol.js";
-import { TrackerBar } from "./TrackerBar.js";
+import { TrackerBar } from "../systems/TrackerBar.js";
 import { TrackCalibration } from "./TrackCalibration.js";
 import { AnyFeature, FeatureOrPatch, Patch } from "./Feature.js";
 import { ActorAssignment, DateAssignment, ObjectAssumption, ReferenceAssumption } from "./Assumption.js";
-import { WithId, WithType } from "./utils.js";
+import { WithId, WithType } from "../shared/utils.js";
 import { Agent, Concept } from "./Agent.js";
 import { FeatureSource } from "./FeatureSource.js";
 import { Measure, Millimeters, Quantity, Track } from "./Quantity.js";
@@ -128,7 +128,7 @@ export interface ProductionEvent {
      * at once and states it here, and a feature an editor reads as the
      * work of a later hand belongs in the act that made it, whichever
      * kind of feature it is.
-     * @see crm:P108 has produced
+     * @see reo:produced
      */
     produced?: AnyFeature[];
 }
@@ -173,7 +173,7 @@ export type Modification = Partial<{
      * paper, a circle in pencil, a hole punched by hand. Any kind of
      * feature may come of a later act, as any kind may come of the
      * punching.
-     * @see crm:P108 has produced
+     * @see reo:produced
      */
     produced: AnyFeature[];
     /**
@@ -203,12 +203,6 @@ export type Modification = Partial<{
  * @see reo:RollCopy
  */
 export interface RollCopy extends WithType<'RollCopy'>, WithId {
-    /**
-     * A list of operations that have been applied to this copy's features
-     * (e.g. 'shifted', 'stretched') to normalize measurements
-     * for comparison with other copies. Not exported to RDF.
-     */
-    ops: Array<'shifted' | 'stretched' | 'shortened'>;
     /**
      * Physical measurements of this roll copy, including
      * dimensions, hole separation, margins, shift corrections,
@@ -403,8 +397,7 @@ export declare const featuresOf: (copy: Pick<RollCopy, 'production' | 'modificat
 export declare const isPaperStretch: (condition: RollConditionAssignment) => boolean;
 /**
  * The bar a copy is read by, which is the one it was cut for. A copy
- * that names no system falls back to the T-100, as every copy was read
- * before the systems were told apart; `reservationsAbout` says so.
+ * that names no system falls back to `defaultTrackerBar`.
  */
 export declare const barOf: (copy: Pick<RollCopy, 'production'>) => TrackerBar;
 /** The diameter of the punch the copy was cut with, where the edition holds it true or likely. */

package/lib/{RollCopy.js → model/RollCopy.js}

@@ -1,6 +1,5 @@
 import { v4 } from "uuid";
-import { welteT100 } from "./systems/welteT100/bar.js";
-import { trackerBarOf } from "./systems/index.js";
+import { defaultTrackerBar, trackerBarOf } from "../systems/index.js";
 import { assignReference, certaintyOf, isAsserted } from "./Assumption.js";
 import { px, track } from "./Quantity.js";
 export const rollConditions = [
@@ -43,10 +42,9 @@ export const featuresOf = (copy) => featuresByAct(copy).flat();
 export const isPaperStretch = (condition) => condition.conditionType === 'paper-stretch';
 /**
  * The bar a copy is read by, which is the one it was cut for. A copy
- * that names no system falls back to the T-100, as every copy was read
- * before the systems were told apart; `reservationsAbout` says so.
+ * that names no system falls back to `defaultTrackerBar`.
  */
-export const barOf = (copy) => trackerBarOf(copy.production?.system) ?? welteT100;
+export const barOf = (copy) => trackerBarOf(copy.production?.system) ?? defaultTrackerBar;
 /** The diameter of the punch the copy was cut with, where the edition holds it true or likely. */
 export const punchDiameterOf = (copy) => {
     const diameter = copy.production?.perforator?.condition?.punchDiameter;

package/lib/{Symbol.d.ts → model/Symbol.d.ts}

@@ -1,5 +1,5 @@
 import { ReferenceAssumption } from "./Assumption.js";
-import { WithId } from "./utils.js";
+import { WithId } from "../shared/utils.js";
 /**
  * A symbol is an abstract musical or textual entity carried by one or more
  * physical features on the roll. Symbols are the result of interpreting

package/lib/{Version.d.ts → model/Version.d.ts}

@@ -1,9 +1,9 @@
 import { Edit } from "./Edit.js";
 import { Concept } from "./Agent.js";
 import { ActorAssignment, Belief, Certainty, DateAssignment, ObjectAssumption, ReferenceAssumption } from "./Assumption.js";
-import { CollationTolerance } from "./Collation.js";
+import { CollationTolerance } from "../collation/Collation.js";
 import { AnySymbol } from "./Symbol.js";
-import { WithId, WithNote, WithType } from "./utils.js";
+import { WithId, WithNote, WithType } from "../shared/utils.js";
 /**
  * A motivation provides a reason or rationale for an editorial change.
  * Motivations are defined at the version level and referenced by edits.
@@ -71,7 +71,7 @@ export interface VersionCreation {
  * it describes.
  * @see lrmoo:F2 Expression
  */
-export interface Version extends WithId, WithType<'Version'> {
+export interface Version extends WithId {
     /**
      * The reproducing system this version is coded for. One roll was
      * often issued for several of them, and a version is a reading in
@@ -131,3 +131,11 @@ export declare const derivationsOf: (version: Readonly<Version>) => {
  * below another's reads the version's edits against another parent.
  */
 export declare const principalDerivationOf: (version: Readonly<Version>) => Readonly<Derivation> | undefined;
+/**
+ * Whether the version derives from the other, directly or through the
+ * versions between them, by any derivation it states, a hypothesis
+ * among them: a hypothesis held more certain becomes the principal one.
+ * A version derives from itself in no statement, and a stemma that
+ * loops is walked once round.
+ */
+export declare const derivesFrom: (versions: readonly Readonly<Version>[], versionId: string, ancestorId: string) => boolean;

package/lib/{Version.js → model/Version.js}

@@ -1,5 +1,5 @@
 import { certainties, certaintyOf, idOf } from "./Assumption.js";
-import { defaultCollationTolerance } from "./Collation.js";
+import { defaultCollationTolerance } from "../collation/Collation.js";
 /** The tolerance the derivation was collated at, or the default where it states none. */
 export const collationToleranceOf = (derivation) => derivation.collationTolerance ?? defaultCollationTolerance;
 /** The edits the version states, none where it leaves its text unstated. */
@@ -26,3 +26,26 @@ const rankOf = (derivation) => certainties.indexOf(certaintyOf(derivation));
 export const principalDerivationOf = (version) => (version.basedOn ?? [])
     .filter(derivation => rankOf(derivation) <= certainties.indexOf('possible'))
     .reduce((principal, derivation) => principal === undefined || rankOf(derivation) < rankOf(principal) ? derivation : principal, undefined);
+/**
+ * Whether the version derives from the other, directly or through the
+ * versions between them, by any derivation it states, a hypothesis
+ * among them: a hypothesis held more certain becomes the principal one.
+ * A version derives from itself in no statement, and a stemma that
+ * loops is walked once round.
+ */
+export const derivesFrom = (versions, versionId, ancestorId) => {
+    const byId = new Map(versions.map(version => [version.id, version]));
+    const seen = new Set();
+    const pending = [versionId];
+    while (pending.length > 0) {
+        const id = pending.pop();
+        if (seen.has(id))
+            continue;
+        seen.add(id);
+        const parents = (byId.get(id)?.basedOn ?? []).map(idOf);
+        if (parents.includes(ancestorId))
+            return true;
+        pending.push(...parents);
+    }
+    return false;
+};

package/lib/{vocabulary.js → model/vocabulary.js}

@@ -1,7 +1,7 @@
 import { drives } from "./Perforator.js";
 import { procedures } from "./procedures.js";
-import { systemOf } from "./TrackerBar.js";
-import { trackerBars } from "./systems/index.js";
+import { systemOf } from "../systems/TrackerBar.js";
+import { trackerBars } from "../systems/index.js";
 /**
  * The concepts the type vocabulary declares, whatever kind they are:
  * the reproducing systems, the procedures and the drives of a

package/lib/ops/beliefs.d.ts

@@ -0,0 +1,9 @@
+import { Path } from "../view/EditionView.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. */
+export declare const createBelief: (path: Path) => EditionOp;
+export declare const clearBelief: (path: Path) => EditionOp;
+export declare const setCertainty: (path: Path, certainty: Certainty) => EditionOp;
+export declare const addReason: (path: Path, reason: AnyArgumentation) => EditionOp;
+export declare const removeReason: (path: Path, index: number) => EditionOp;