linked-rolls 0.36.0 → 0.38.0

package/lib/editionOps.d.ts

@@ -4,10 +4,10 @@ import { Edition } from "./Edition";
 import { AnySymbol, PlacementRelation } from "./Symbol";
 import { CollationTolerance } from "./Collation";
 import { Edit } from "./Edit";
-import { GeneralRollCondition, RollCopy, ScaleReading, Shift } from "./RollCopy";
+import { GeneralRollCondition, ModificationPurpose, RollCopy, ScaleReading, Shift } from "./RollCopy";
 import { FeatureSource } from "./FeatureSource";
 import { AnyArgumentation, Belief, Certainty, ObjectAssumption } from "./Assumption";
-import { AnyFeature, FeatureConditionAssignment } from "./Feature";
+import { FeatureConditionAssignment, FeatureOrPatch, NestedFeature } from "./Feature";
 /**
  * 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
@@ -70,11 +70,40 @@ export declare const addGeneralCondition: (copyId: string, condition: ObjectAssu
 export declare const stateFeatureCondition: (copyId: string, featureId: string, condition: FeatureConditionAssignment) => EditionOp;
 /** The symbols of the versions that no other copy carries. */
 export declare const symbolsCarriedOnlyBy: (edition: Edition, copyId: string) => AnySymbol[];
+/**
+ * The act a feature an editor states belongs to: the punching of the
+ * copy, the act that brought another feature about, or, where neither
+ * is said, an act of its own for the purpose given. A patch is never
+ * punched, being glued on, so `punched` says nothing of one.
+ */
+export interface FeatureAct {
+    /** The copy was punched with it, which is where a reading of a scan puts every hole. */
+    punched?: boolean;
+    /** The act that brought this feature about brought the new one about as well. */
+    beside?: string;
+    /** What the act was for, where a new one is made for the feature. */
+    purpose?: ModificationPurpose;
+}
+/**
+ * States that the copy bears the feature, in the act that brought it
+ * about: a patch was glued on by an attachment, anything else was
+ * produced, by the punching or by a later act. Which act, `FeatureAct`
+ * says; a `beside` that names nothing the copy bears is passed over and
+ * the feature goes into an act of its own.
+ */
+export declare const addFeature: (copyId: string, feature: FeatureOrPatch, act?: FeatureAct) => EditionOp;
+/**
+ * States that the patch bears the feature. What a patch bears came onto
+ * the copy with the patch, so it belongs to no act of its own and
+ * states no place: it stands where the patch stands.
+ */
+export declare const addBorneFeature: (copyId: string, patchId: string, feature: NestedFeature) => EditionOp;
 /**
  * Takes the features off the copy, and out of the versions with what
  * only they carried. A feature may be named wherever the copy bears it:
  * a patch goes with everything glued onto it, and a feature of a patch
- * may be taken back on its own, the patch staying where it is.
+ * may be taken back on its own, the patch staying where it is. An act
+ * left having produced or added nothing goes as well.
  */
 export declare const removeFeatures: (copyId: string, featureIds: readonly string[]) => EditionOp;
 /**
@@ -84,7 +113,7 @@ export declare const removeFeatures: (copyId: string, featureIds: readonly strin
  */
 export declare const removeCopy: (copyId: string) => EditionOp;
 /** Why several features cannot be replaced by one. */
-export type MergeObstacle = 'fewer-than-two' | 'different-types' | 'different-tracks' | 'differing-conditions' | 'unlike-features';
+export type MergeObstacle = 'fewer-than-two' | 'different-types' | 'different-tracks' | 'differing-conditions' | 'unlike-features' | 'different-acts';
 /**
  * What stands in the way of reading the features as one, or nothing
  * where they may be merged. Features may be merged where they differ
@@ -93,7 +122,7 @@ export type MergeObstacle = 'fewer-than-two' | 'different-types' | 'different-tr
  * asked: whether a gap is a bridge of the perforator, a tear or two
  * perforations of their own is the editor's reading.
  */
-export declare const mergeObstacle: (features: readonly AnyFeature[]) => MergeObstacle | undefined;
+export declare const mergeObstacle: (features: readonly FeatureOrPatch[]) => 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.
@@ -106,7 +135,8 @@ export declare const mergeObstacle: (features: readonly AnyFeature[]) => MergeOb
  * Only the features the copy bears itself are merged. A feature of a
  * patch states no place along the roll of its own, so there is nothing
  * for a merge to span, and an id naming one is passed over as an id the
- * copy does not bear is.
+ * copy does not bear is. Features of two different acts are not merged
+ * either: one feature is the work of one act.
  *
  * Throws where the features cannot stand for one; `mergeObstacle`
  * says beforehand whether they can.

package/lib/editionOps.js

@@ -4,7 +4,7 @@ import { getAt } from "./EditionView";
 import { isPerforation, placementRelations } from "./Symbol";
 import { collationsOf, defaultCollationTolerance } from "./Collation";
 import { collationToleranceOf, editsOf, insertedBy, principalDerivationOf } from "./Version";
-import { asSymbols, barOf, isPaperStretch } from "./RollCopy";
+import { asSymbols, barOf, featuresByAct, featuresOf, isPaperStretch, statesNothing } from "./RollCopy";
 import { systemOf } from "./TrackerBar";
 import { substitutionsBetween } from "./substitution";
 import { trackerBarOf } from "./systems";
@@ -24,7 +24,7 @@ const onVersion = (versionId, op) => draft => {
         op(version, draft);
 };
 const onFeature = (copyId, featureId, op) => onCopy(copyId, copy => {
-    const feature = copy.features.find(f => f.id === featureId);
+    const feature = featuresOf(copy).find(f => f.id === featureId);
     if (feature)
         op(feature);
 });
@@ -82,7 +82,7 @@ export const createVersion = (copy) => draft => {
         type: 'Version',
         id: v4(),
         system: systemOf(bar),
-        edits: asSymbols(copy.features, bar).map(insertion),
+        edits: asSymbols(featuresOf(copy), bar).map(insertion),
         motivations: []
     });
 };
@@ -203,7 +203,7 @@ export const stateFeatureCondition = (copyId, featureId, condition) => onFeature
     feature.condition = condition;
 });
 /** The ids of every feature the copy bears, those a patch bears among them. */
-const featureIdsOf = (copy) => new Set(copy.features.flatMap(withBorneFeatures).map(feature => feature.id));
+const featureIdsOf = (copy) => new Set(featuresOf(copy).flatMap(withBorneFeatures).map(feature => feature.id));
 /**
  * A symbol every carrier of which lies among the features loses its
  * evidence with them. A symbol without carriers, such as a label,
@@ -279,26 +279,27 @@ const writeInto = (draft, before, after) => Object.entries(after).forEach(([key,
 const isCopy = (record) => 'type' in record && record.type === 'RollCopy';
 const isBelief = (record) => 'type' in record && record.type === 'belief';
 const isComprehension = (reason) => reason.type === 'meaningComprehension';
-/** What the modification names, be it as added or as removed. */
-const membersOf = (modification) => modification.type === 'Addition' ? modification.added : modification.removed;
-const namesNothing = (modification) => membersOf(modification).length === 0;
 const comprehendsNothing = (reason) => isComprehension(reason) && reason.comprehends.length === 0;
-/** The modification with what it names rewritten, or the very same one where that leaves it as it was. */
-const renamingMembers = (rename) => (modification) => modification.type === 'Addition'
-    ? replacing(modification, 'added', rename(modification.added))
-    : replacing(modification, 'removed', rename(modification.removed));
+/**
+ * The modification with what it names rewritten, or the very same one
+ * where that leaves it as it was. Only a removal names anything by id:
+ * what an act produced or glued on it states itself.
+ */
+const renamingMembers = (rename) => (modification) => modification.type === 'Removal'
+    ? replacing(modification, 'removed', rename(modification.removed))
+    : modification;
 /** The reason with what a comprehension comprehends rewritten; any other reason names nothing of the kind. */
 const renamingComprehended = (rename) => (reason) => isComprehension(reason) ? replacing(reason, 'comprehends', rename(reason.comprehends)) : reason;
 /**
- * The record with the ids it names rewritten: what a copy's
- * modifications added or removed, and what the comprehensions among a
- * belief's reasons comprehend. A modification or a comprehension the
- * rewriting emptied goes with what it named; one that named nothing
- * before stays, as an edit that was empty before it does.
+ * The record with the ids it names rewritten: what a copy's removals
+ * removed, and what the comprehensions among a belief's reasons
+ * comprehend. A removal or a comprehension the rewriting emptied goes
+ * with what it named; one that named nothing before stays, as an edit
+ * that was empty before it does.
  */
 const renaming = (rename) => (record) => {
     if (isCopy(record)) {
-        return replacing(record, 'modifications', pruned(record.modifications, renamingMembers(rename), namesNothing));
+        return replacing(record, 'modifications', pruned(record.modifications, renamingMembers(rename), statesNothing));
     }
     if (isBelief(record)) {
         return replacing(record, 'reasons', pruned(record.reasons, renamingComprehended(rename), comprehendsNothing));
@@ -356,16 +357,99 @@ const withoutBorne = (feature, named) => {
 };
 /** The features without those named, wherever they lie, and without whatever those bore. */
 const withoutFeatures = (features, named) => mapped(without(features, feature => named.has(feature.id)), feature => withoutBorne(feature, named));
+/** The act with its features rewritten, or the very same one where the rewriting left them. */
+const rewritingAct = (rewrite) => (modification) => {
+    if (modification.type === 'Alteration')
+        return replacing(modification, 'produced', rewrite(modification.produced));
+    if (modification.type === 'Attachment')
+        return replacing(modification, 'added', rewrite(modification.added));
+    return modification;
+};
+/**
+ * Writes the rewriting onto the features of every act of the copy, and
+ * takes out an act it left with nothing to state.
+ */
+const rewriteFeatures = (copy, rewrite) => {
+    const state = stateOf(copy);
+    const produced = state.production?.produced;
+    if (produced && copy.production) {
+        const rewritten = rewrite(produced);
+        if (rewritten !== produced)
+            copy.production.produced = rewritten;
+    }
+    copy.modifications = pruned(state.modifications, rewritingAct(rewrite), statesNothing);
+};
+/** The features of the act that brought the named feature about, where that act produces features. */
+const producedBeside = (copy, featureId) => {
+    const names = (features) => features.some(feature => feature.id === featureId);
+    const punched = copy.production?.produced;
+    if (punched && names(punched))
+        return punched;
+    const act = copy.modifications.find(act => act.type === 'Alteration' && names(act.produced));
+    return act?.type === 'Alteration' ? act.produced : undefined;
+};
+/** The patches of the attachment that glued the named one on. */
+const gluedBeside = (copy, patchId) => {
+    const act = copy.modifications.find(act => act.type === 'Attachment' && act.added.some(patch => patch.id === patchId));
+    return act?.type === 'Attachment' ? act.added : undefined;
+};
+/** The list the copy states a new feature in, making the act it belongs to where there is none. */
+const actFor = (copy, patch, act) => {
+    const beside = act.beside !== undefined
+        ? (patch ? gluedBeside(copy, act.beside) : producedBeside(copy, act.beside))
+        : undefined;
+    if (beside)
+        return beside;
+    if (patch) {
+        const added = [];
+        copy.modifications.push({ type: 'Attachment', added, ...(act.purpose && { purpose: act.purpose }) });
+        return added;
+    }
+    if (act.punched) {
+        if (!copy.production)
+            copy.production = {};
+        if (!copy.production.produced)
+            copy.production.produced = [];
+        return copy.production.produced;
+    }
+    const produced = [];
+    copy.modifications.push({ type: 'Alteration', produced, ...(act.purpose && { purpose: act.purpose }) });
+    return produced;
+};
+/**
+ * States that the copy bears the feature, in the act that brought it
+ * about: a patch was glued on by an attachment, anything else was
+ * produced, by the punching or by a later act. Which act, `FeatureAct`
+ * says; a `beside` that names nothing the copy bears is passed over and
+ * the feature goes into an act of its own.
+ */
+export const addFeature = (copyId, feature, act = {}) => onCopy(copyId, copy => {
+    actFor(copy, isGluedOn(feature), act).push(feature);
+});
+/**
+ * States that the patch bears the feature. What a patch bears came onto
+ * the copy with the patch, so it belongs to no act of its own and
+ * states no place: it stands where the patch stands.
+ */
+export const addBorneFeature = (copyId, patchId, feature) => onCopy(copyId, copy => {
+    const patch = featuresOf(copy).flatMap(withBorneFeatures).find(borne => borne.id === patchId);
+    if (!patch || !isGluedOn(patch))
+        return;
+    if (!patch.features)
+        patch.features = [];
+    patch.features.push(feature);
+});
 /**
  * Takes the features off the copy, and out of the versions with what
  * only they carried. A feature may be named wherever the copy bears it:
  * a patch goes with everything glued onto it, and a feature of a patch
- * may be taken back on its own, the patch staying where it is.
+ * may be taken back on its own, the patch staying where it is. An act
+ * left having produced or added nothing goes as well.
  */
 export const removeFeatures = (copyId, featureIds) => onCopy(copyId, (copy, draft) => {
     const named = new Set(featureIds);
-    const features = stateOf(copy.features);
-    copy.features = withoutFeatures(features, named);
+    const features = featuresOf(stateOf(copy));
+    rewriteFeatures(copy, (stated) => withoutFeatures(stated, named));
     forgetFeatures(draft, new Set(goneWith(features, named)));
 });
 /**
@@ -445,9 +529,9 @@ const spanning = (features) => ({
  * others being alike in all but their place. The depiction goes: a
  * region of the scan showing one part depicts no more than that part.
  */
-const mergedFrom = (features) => {
+const mergedFrom = (features, id) => {
     const stating = features.find(feature => feature.condition) ?? features[0];
-    const merged = { ...stating, id: v4(), horizontal: spanning(features) };
+    const merged = { ...stating, id, horizontal: spanning(features) };
     delete merged.depiction;
     return merged;
 };
@@ -485,24 +569,29 @@ const carryOver = (draft, replaced, mergedId) => {
  * Only the features the copy bears itself are merged. A feature of a
  * patch states no place along the roll of its own, so there is nothing
  * for a merge to span, and an id naming one is passed over as an id the
- * copy does not bear is.
+ * copy does not bear is. Features of two different acts are not merged
+ * either: one feature is the work of one act.
  *
  * Throws where the features cannot stand for one; `mergeObstacle`
  * says beforehand whether they can.
  */
 export const mergeFeatures = (copyId, featureIds) => onCopy(copyId, (copy, draft) => {
     const named = new Set(featureIds);
-    const features = stateOf(copy.features);
-    const toMerge = features.filter(feature => named.has(feature.id));
-    const obstacle = mergeObstacle(toMerge);
+    const holds = (features) => features.some(feature => named.has(feature.id));
+    const acts = featuresByAct(stateOf(copy)).filter(holds);
+    const toMerge = (acts[0] ?? []).filter(feature => named.has(feature.id));
+    const obstacle = acts.length > 1 ? 'different-acts' : mergeObstacle(toMerge);
     if (obstacle) {
         throw new Error(`The features of copy ${copyId} cannot be merged: ${obstacle}`);
     }
     const replaced = new Set(toMerge.map(feature => feature.id));
-    const merged = mergedFrom(toMerge);
-    copy.features = standingFor(features, feature => replaced.has(feature.id), merged);
-    carryOver(draft, replaced, merged.id);
-    renameReferences(draft, ids => standingFor(ids, id => replaced.has(id), merged.id));
+    const mergedId = v4();
+    rewriteFeatures(copy, (stated) => {
+        const stands = (feature) => replaced.has(feature.id);
+        return stated.some(stands) ? standingFor(stated, stands, mergedFrom(stated.filter(stands), mergedId)) : stated;
+    });
+    carryOver(draft, replaced, mergedId);
+    renameReferences(draft, ids => standingFor(ids, id => replaced.has(id), mergedId));
 });
 /** The carriers of each collated symbol pass to its counterpart. */
 const handOverCarriers = (view, draft, collations) => collations.forEach(({ symbol, counterpart }) => {

package/lib/importJsonLd.js

@@ -1,3 +1,4 @@
+import { derivedKeys } from "./asJsonLd";
 import { migrate } from "./migrate";
 import { isDateString } from "./utils";
 export const importDate = (str) => {
@@ -17,6 +18,15 @@ const fromJsonLdValue = (value) => {
         return fromJsonLdEntity(value);
     return value;
 };
+/**
+ * A node without what the export derived from it. A copy bears the
+ * features its acts brought about, and the graph has to be told so.
+ * In the edition the act that made a feature is the one place it
+ * 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,
@@ -25,7 +35,7 @@ const fromJsonLdValue = (value) => {
  * rather than to the edition, which states the system as data.
  */
 const fromJsonLdEntity = (json) => {
-    const { '@type': type, '@id': id, '@context': context, ...rest } = json;
+    const { '@type': type, '@id': id, '@context': context, ...rest } = asStated(json);
     const entity = Object.fromEntries(Object.entries(rest).map(([key, value]) => [key, fromJsonLdValue(value)]));
     if (type !== undefined && !('@value' in json))
         entity.type = type;

package/lib/migrate.js

@@ -1,4 +1,4 @@
-import { conditions } from "./Feature";
+import { conditions, isFeatureType } from "./Feature";
 import { rollConditions } from "./RollCopy";
 import { systemIdIn, systemOf, translationBetween } from "./TrackerBar";
 import { trackerBars } from "./systems";
@@ -12,6 +12,14 @@ const renamedKeys = {
     classification: 'editType'
 };
 const referenceKeys = ['alignedWith', 'pairedWith', 'basedOn'];
+/**
+ * The five type terms that were capitalised while the rest of the
+ * vocabulary was not, under the keys that carry them.
+ */
+const lowerCasedTerms = {
+    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]))
@@ -32,6 +40,10 @@ const withoutVersionType = (node) => {
     const { versionType: _retired, ...rest } = node;
     return rest;
 };
+const withLowerCaseTerms = (node) => Object.entries(lowerCasedTerms).reduce((result, [key, terms]) => {
+    const lowered = terms[result[key]];
+    return lowered ? { ...result, [key]: lowered } : result;
+}, node);
 const withReferences = (node) => referenceKeys.reduce((result, key) => {
     const reference = result[key];
     if (reference && typeof reference === 'object' && '@value' in reference) {
@@ -79,15 +91,100 @@ const withScale = (node) => {
 /** 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;
+/** The features a copy states at a place of its own, in either shape. */
+const featuresOf = (copy) => [
+    ...(Array.isArray(copy.features) ? copy.features : []),
+    ...(Array.isArray(copy.production?.produced) ? copy.production.produced : [])
+];
 /**
  * A copy read on a roll reader was stated as a recording before a sound
  * recording could be one. A sound recording gives no holes, so a recording
  * with holes is a reading.
  */
-const withReadingKind = (node) => node.readFrom?.kind === 'recording' && Array.isArray(node.features)
-    && node.features.some((feature) => feature?.['@type'] === 'Hole')
+const withReadingKind = (node) => node.readFrom?.kind === 'recording'
+    && featuresOf(node).some((feature) => feature?.['@type'] === 'Hole')
     ? { ...node, readFrom: { ...node.readFrom, kind: 'reading' } }
     : node;
+/** A feature written while the kind of a feature was a type beside its class. */
+const withoutFeatureKind = (node) => {
+    if (!isFeatureType(node['@type']) || !Object.hasOwn(node, 'kind'))
+        return node;
+    const { kind: _typed, ...rest } = node;
+    return rest;
+};
+const isPatch = (feature) => feature?.['@type'] === 'GluedOn';
+/**
+ * A feature a patch bears was sometimes written without an id, and what
+ * has no id can be referred to from nowhere: neither by a reading of it
+ * nor by the statement that the copy bears it. It is named after the
+ * patch and the place it stands in.
+ */
+const withBorneFeaturesNamed = (node) => {
+    const bearer = node['@id'];
+    if (typeof bearer !== 'string' || !Array.isArray(node.features))
+        return node;
+    if (node.features.every((feature) => typeof feature?.['@id'] === 'string'))
+        return node;
+    return {
+        ...node,
+        features: node.features.map((feature, index) => feature && typeof feature === 'object' && typeof feature['@id'] !== 'string'
+            ? { '@id': `${bearer}-${index + 1}`, ...feature }
+            : feature)
+    };
+};
+/**
+ * A copy held its features in one list and a modification named by id
+ * what it had added. Each feature now stands in the act that brought it
+ * about: a patch in an attachment, a feature an act names in an
+ * alteration, and everything else in the production of the copy, which
+ * is the punching. An addition naming both a patch and a feature
+ * becomes two acts, since gluing something on and drawing something are
+ * not one act.
+ *
+ * A feature a patch bears is not moved: it has no place of its own, and
+ * it came onto the copy with the patch.
+ */
+const withFeaturesInActs = (node) => {
+    if (node['@type'] !== 'RollCopy' || !Array.isArray(node.features))
+        return node;
+    const { features, modifications, ...rest } = node;
+    const byId = new Map(features
+        .filter((feature) => typeof feature?.['@id'] === 'string')
+        .map((feature) => [feature['@id'], feature]));
+    const taken = new Set();
+    /** The features the modification named, each going to the first act that names it. */
+    const namedBy = (modification) => (Array.isArray(modification.added) ? modification.added : [])
+        .flatMap((id) => {
+        if (typeof id !== 'string' || taken.has(id) || !byId.has(id))
+            return [];
+        taken.add(id);
+        return [byId.get(id)];
+    });
+    const acts = (Array.isArray(modifications) ? modifications : []).flatMap((modification) => {
+        if (modification?.['@type'] !== 'Addition')
+            return [modification];
+        const { added: _named, ...act } = modification;
+        const held = namedBy(modification);
+        const glued = held.filter(isPatch);
+        const made = held.filter(feature => !isPatch(feature));
+        if (glued.length === 0)
+            return [{ ...act, '@type': 'Alteration', produced: made }];
+        return [
+            ...(made.length > 0 ? [{ ...act, '@type': 'Alteration', produced: made }] : []),
+            { ...act, '@type': 'Attachment', added: glued }
+        ];
+    });
+    const left = features.filter((feature) => !taken.has(feature?.['@id']));
+    const punched = left.filter((feature) => !isPatch(feature));
+    const loose = left.filter(isPatch);
+    return {
+        ...rest,
+        ...((rest.production || punched.length > 0) && {
+            production: { ...rest.production, ...(punched.length > 0 && { produced: punched }) }
+        }),
+        modifications: [...acts, ...(loose.length > 0 ? [{ '@type': 'Attachment', added: loose }] : [])]
+    };
+};
 /** A keeper nobody could name was written as an empty one before a copy could leave it out. */
 const withoutEmptyKeeper = (node) => {
     if (node.keeper?.name !== '' || node.keeper.sameAs?.length)
@@ -106,8 +203,9 @@ const withTimeSpanDates = (node) => {
     const { '@value': within, '@type': _typed, ...rest } = node;
     return { ...rest, within };
 };
-const migrateNode = (node) => [withRenamedKeys, withTypology, withoutVersionType, withReferences, withKeeper, withoutEmptyKeeper, withProductionNodes, withScale,
-    withDerivationList, withReadingKind, withTimeSpanDates]
+const migrateNode = (node) => [withRenamedKeys, withTypology, withoutVersionType, withLowerCaseTerms, withReferences, withKeeper, withoutEmptyKeeper,
+    withProductionNodes, withScale, withDerivationList, withReadingKind, withTimeSpanDates, withoutFeatureKind,
+    withBorneFeaturesNamed, withFeaturesInActs]
     .reduce((result, step) => step(result), node);
 /** The items each walked, or the very same list where the walk changed none. */
 const walked = (items) => {

package/lib/readers/phillipsEroll.js

@@ -148,9 +148,8 @@ export function readFromPhillipsEroll(buffer, { system = welteT100, controlOffse
         ops: [],
         conditions: [],
         measurements: {},
-        production: { system: systemOf(system) },
+        production: { system: systemOf(system), produced: features },
         modifications: [],
-        features,
         readFrom: {
             kind: 'reading',
             actor: assignObject({ name: 'Phillips, Peter', sameAs: [] }),

package/lib/readers/spencerBar.js

@@ -114,9 +114,8 @@ export function readFromSpencerBar(buffer, { rowsPerInch = SPENCER_ROWS_PER_INCH
         ops: [],
         conditions: [],
         measurements: {},
-        production: { system: systemOf(system) },
-        modifications: [],
-        features
+        production: { system: systemOf(system), produced: features },
+        modifications: []
     };
 }
 /**

package/lib/readers/stanfordAton.js

@@ -157,7 +157,7 @@ export function readFromStanfordAton(atonString, { trackShift, system = welteT10
         id: v4(),
         ops: [],
         conditions: [],
-        production: { system: systemOf(system) },
+        production: { system: systemOf(system), produced: features },
         modifications: [],
         ...((scan ?? stanford) && { scan: scan ?? stanford?.scan }),
         measurements: {
@@ -183,7 +183,6 @@ export function readFromStanfordAton(atonString, { trackShift, system = welteT10
             }),
             trackCalibration: calibration,
             ...(measuredBy && { measuredBy })
-        },
-        features
+        }
     };
 }

package/lib/reservations.js

@@ -1,5 +1,5 @@
 import { bearsPhysicalEvidence, isMeasured, sourceLabels } from "./FeatureSource";
-import { calibrationOf } from "./RollCopy";
+import { calibrationOf, featuresOf } from "./RollCopy";
 import { trackerBarOf } from "./systems";
 import { witnessesOf } from "./witnesses";
 export const reservationTypes = [
@@ -81,7 +81,7 @@ const keeperKnown = copy => copy.keeper ? undefined : {
     note: 'Nobody is known to hold the copy, so its paper cannot be consulted.'
 };
 /** A check on what a copy's features leave open, which has nothing to say of a copy without any. */
-const onFeatures = (check) => copy => copy.features.length > 0 ? check(copy) : undefined;
+const onFeatures = (check) => copy => featuresOf(copy).length > 0 ? check(copy) : undefined;
 const checks = [
     sourceStated,
     sourceDocumented,