linked-rolls 0.36.0 → 0.37.0

package/README.md

@@ -42,7 +42,10 @@ which versions and conditions carry a typology key beside their type,
 the keeper and the production metadata are nodes with a name and
 authority links, and the roll names its reproducing system. A date
 written as a value of its own is read as the day the event falls
-within. Exports are always in the current format.
+within. A copy that held its features in one list, naming by id what a
+modification had added, has each feature put into the act that brought
+it about, and a feature a patch bears that was left unnamed is named
+after the patch. Exports are always in the current format.
 
 ## How a date is stated
 
@@ -72,6 +75,30 @@ at. It then reads as the version it derives from, and
 `reservationsAboutVersion` says so. A file that names a single
 derivation loads as a list of one.
 
+## What brought a feature about
+
+A copy states no list of features. Each feature stands in the act that
+brought it about: the perforations in the copy's own production, a
+writing or a mark in the `Alteration` that made it, a patch in the
+`Attachment` that glued it on. A `Removal` names by id what was taken
+off, which stood there before the act. A feature no later act is known
+to have made belongs to the punching, which is where a reading of a
+scan puts every hole it finds.
+
+Three kinds of act rather than two, because the CRM tells them apart.
+E79 Part Addition asks that what is added be "a separate identifiable
+whole prior to" the act, which a glued-on label is and a pencil line is
+not: drawing, writing and punching bring a feature into being and are
+productions (E12), which state what they made with P108 has produced.
+
+The export states what that shape only implies. A copy bears every
+feature its acts brought about (P56 bears feature) and is composed of
+the patches glued onto it (P46 is composed of, a patch being an object
+rather than a feature); an attachment augments the copy and a removal
+diminishes it. The four keys are derived on the way out and read off
+again on the way in, so they are no part of the edition, and they are
+the one place where the JSON tree and the graph differ in shape.
+
 ## Where a copy's features come from
 
 `readFrom` states what a copy's features were read from: the roll

package/lib/EditionView.d.ts

@@ -1,5 +1,5 @@
 import { Edition } from "./Edition";
-import { HorizontalSpan, AnyFeature } from "./Feature";
+import { HorizontalSpan, FeatureOrPatch } from "./Feature";
 import { AnySymbol, Expression, Note } from "./Symbol";
 import { Version } from "./Version";
 import { NegotiatedEvent } from "./ReproducingSystem";
@@ -34,7 +34,7 @@ export declare class EditionView {
     travelUp(versionId: string, callback: (version: Readonly<Version>) => void): void;
     /** The version and its ancestors along the principal line, from the version up to the root. */
     lineageOf(versionId: string): Readonly<Version>[];
-    carriersOf(symbol: AnySymbol): Readonly<AnyFeature>[];
+    carriersOf(symbol: AnySymbol): Readonly<FeatureOrPatch>[];
     /** The copy a feature sits on, a patch and everything it bears included. */
     copyOf(featureId: string): Readonly<RollCopy> | undefined;
     /**

package/lib/EditionView.js

@@ -1,7 +1,7 @@
 import { withBorneFeatures } from "./Feature";
 import { deletedBy, insertedBy, principalDerivationOf } from "./Version";
 import { systemIdOf } from "./TrackerBar";
-import { isPaperStretch } from "./RollCopy";
+import { featuresOf, isPaperStretch } from "./RollCopy";
 import { idOf, idsOf } from "./Assumption";
 import { mean } from "./Quantity";
 export const getAt = (path, obj) => {
@@ -155,7 +155,7 @@ export class EditionView {
     /** The copy a feature sits on, a patch and everything it bears included. */
     copyOf(featureId) {
         if (!this.copiesByFeature) {
-            this.copiesByFeature = new Map(this.edition.copies.flatMap(copy => copy.features
+            this.copiesByFeature = new Map(this.edition.copies.flatMap(copy => featuresOf(copy)
                 .flatMap(withBorneFeatures)
                 .map(feature => [feature.id, copy])));
         }

package/lib/Feature.d.ts

@@ -55,10 +55,12 @@ export interface VerticalSpan {
 }
 export declare const featureTypes: readonly ['Hole', 'Writing', 'Mark', 'GluedOn'];
 export type FeatureType = typeof featureTypes[number];
+export declare const isFeatureType: (value: unknown) => value is FeatureType;
 /**
- * A physical feature on the roll, e.g. a perforation, a tear, a mark, etc.,
- * defined by its horizontal and vertical position and extent.
- * @see crm:E26 Physical Feature
+ * A feature on the roll, e.g. a perforation, a writing, a mark or a
+ * glued-on patch, defined by its horizontal and vertical position and
+ * extent. Each kind of feature is a class of its own, which its type
+ * names.
  */
 export interface RollFeature<T extends FeatureType, DamageT extends string> extends WithId, WithType<T> {
     /**
@@ -101,6 +103,10 @@ export type FeatureConditionAssignment = ObjectAssumption<ConditionState<Feature
  * A hole (perforation) in the roll paper. Holes are the primary
  * carriers of musical information on piano rolls, as they trigger
  * notes and expression controls when passing over the tracker bar.
+ * A punched hole is a human-made feature: CRM counts "the information
+ * encoding features on mechanical or digital carriers" among the
+ * features purposely created by human activity.
+ * @see reo:Hole
  */
 export interface Hole extends RollFeature<'Hole', typeof conditions.Hole[number]> {
     /**
@@ -119,25 +125,28 @@ export interface Hole extends RollFeature<'Hole', typeof conditions.Hole[number]
  */
 export interface Trace<T extends FeatureType> extends RollFeature<T, typeof conditions[T][number]> {
 }
-export declare const writingMethods: readonly ['Print', 'Handwriting', 'Stamp'];
+export declare const writingMethods: readonly ['print', 'handwriting', 'stamp'];
 /**
  * The method by which a writing was produced on the roll:
  * printed, handwritten, or stamped.
  */
 export type WritingMethod = typeof writingMethods[number];
+export declare const markMethods: readonly ['ink', 'pencil', 'crayon'];
+/** The medium a mark was drawn in. */
+export type MarkMethod = typeof markMethods[number];
 /** The text a writing carries. It names no carriers of its own, the writing being its carrier. */
 export type Transcription = Omit<Text, 'carriers'>;
 /**
  * A piece of writing found on the roll, such as a label,
  * catalogue number, or annotation. Writings have a method
  * of production and a transcription of their content.
- * @see crm:E25 Human-Made Feature
+ * @see reo:Writing
  */
 export interface Writing extends Trace<'Writing'> {
     /**
      * The method by which this writing was produced
      * (e.g. through print, handwriting, or stamping).
-     * @see crm:P2 has type
+     * @see reo:method
      */
     method: WritingMethod;
     /**
@@ -149,46 +158,65 @@ export interface Writing extends Trace<'Writing'> {
     transcription: ObjectAssumption<Transcription>;
 }
 /**
- * A visible mark on the roll, such as a pencil mark,
- * ink mark, or other non-textual annotation.
- * @see crm:E25 Human-Made Feature
+ * A visible mark on the roll, such as a pencil circle, an ink stroke,
+ * or other non-textual annotation. What a mark was meant to say is a
+ * reading of it (crminf:I16 Meaning Comprehension) rather than a
+ * property of the feature, so its shape is not stated here.
+ * @see reo:Mark
  */
 export interface Mark extends Trace<'Mark'> {
+    /**
+     * The medium the mark was drawn in, where it can be told.
+     * @see reo:method
+     */
+    method?: MarkMethod;
 }
 /**
  * A piece of material (paper or tape) glued onto the roll surface.
  * Glued-on features are typically used to cover perforations (for corrections)
  * or to reinforce damaged areas. They may themselves carry other features
  * such as writings or additional holes.
- * @see crm:E22 Human-Made Object
+ * @see reo:GluedOn
  */
 export interface GluedOn extends RollFeature<'GluedOn', typeof conditions.GluedOn[number]> {
     /**
      * The material of the glued-on feature.
      * @see crm:P45 consists of
      */
-    material: 'Paper' | 'Tape';
+    material: 'paper' | 'tape';
     /**
      * A glued-on feature itself may carry other features.
      * Nested features do not need to be positioned explicitly.
-     * @see crm:P56 bears feature
+     * @see crm:P46 is composed of
      */
     features?: NestedFeature[];
 }
 /**
- * The union of all physical feature types that can appear on a roll:
- * holes (perforations), writings (labels, annotations), marks (pencil, ink),
- * and glued-on patches (paper, tape).
+ * The features proper: a hole, a writing and a mark are all human-made
+ * features, and each of them is borne by whatever it sits on. A patch
+ * is an object glued onto the paper and stands apart from them.
+ */
+export type AnyFeature = Hole | Writing | Mark;
+/**
+ * Anything found at a place of its own on the roll: a feature or a
+ * glued-on patch. E24 Physical Human-Made Thing is the class both fall
+ * under, E22 and E25 being its subclasses.
+ */
+export type FeatureOrPatch = AnyFeature | GluedOn;
+/**
+ * A feature without the place it would state of its own. The union is
+ * distributed over, so that each kind of feature keeps its own keys.
  */
-export type AnyFeature = Hole | Writing | Mark | GluedOn;
+type Unplaced<T> = T extends FeatureOrPatch ? PartialBy<T, 'horizontal' | 'vertical'> : never;
 /**
  * A feature borne by another feature. It states no place of its own,
  * the feature bearing it standing in one.
  */
-export type NestedFeature = PartialBy<AnyFeature, 'horizontal' | 'vertical'>;
-export declare const isRollFeature: (obj: object) => obj is AnyFeature;
+export type NestedFeature = Unplaced<FeatureOrPatch>;
+export declare const isRollFeature: (obj: object) => obj is FeatureOrPatch;
 export declare const isGluedOn: <T extends NestedFeature>(feature: T) => feature is T & GluedOn;
 /** The features a feature bears: a patch those stated as parts of it, any other feature none. */
 export declare const featuresBorneBy: (feature: NestedFeature) => NestedFeature[];
 /** The feature together with everything it bears, as deep as a patch on a patch goes. */
 export declare const withBorneFeatures: (feature: NestedFeature) => NestedFeature[];
+export {};

package/lib/Feature.js

@@ -1,13 +1,15 @@
 export const featureTypes = ['Hole', 'Writing', 'Mark', 'GluedOn'];
+export const isFeatureType = (value) => featureTypes.includes(value);
 export const conditions = {
     Hole: ['partially-torn', 'missing-perforation'],
     Writing: ['illegible'],
     Mark: ['faded'],
     GluedOn: ['detaching', 'ripped']
 };
-export const writingMethods = ['Print', 'Handwriting', 'Stamp'];
+export const writingMethods = ['print', 'handwriting', 'stamp'];
+export const markMethods = ['ink', 'pencil', 'crayon'];
 export const isRollFeature = (obj) => {
-    return 'type' in obj && featureTypes.includes(obj.type);
+    return 'type' in obj && isFeatureType(obj.type);
 };
 export const isGluedOn = (feature) => feature.type === 'GluedOn';
 /** The features a feature bears: a patch those stated as parts of it, any other feature none. */

package/lib/RollCopy.d.ts

@@ -2,7 +2,7 @@ import { ConditionState } from "./ConditionState";
 import { AnySymbol } from "./Symbol";
 import { TrackerBar } from "./TrackerBar";
 import { TrackCalibration } from "./TrackCalibration";
-import { AnyFeature } from "./Feature";
+import { AnyFeature, FeatureOrPatch, GluedOn } from "./Feature";
 import { ActorAssignment, DateAssignment, ObjectAssumption, ReferenceAssumption } from "./Assumption";
 import { WithId, WithType } from "./utils";
 import { Agent, Concept } from "./Agent";
@@ -114,12 +114,26 @@ export interface ProductionEvent {
      * @see reo:paperSpeed
      */
     speed?: ObjectAssumption<PaperSpeed>;
+    /**
+     * The features the punching brought into being, which are the note
+     * and expression perforations. A reading of a scan finds every hole
+     * on the paper at once and states it here. A hole an editor reads as
+     * punched later belongs in the act that made it.
+     * @see crm:P108 has produced
+     */
+    produced?: AnyFeature[];
 }
+export declare const modificationPurposes: readonly ['musical-improvement', 'technical-improvement', 'repair', 'labeling', 'control', 'dating', 'glossing'];
+/** What a modification of a copy was for, as far as it can be told. */
+export type ModificationPurpose = typeof modificationPurposes[number];
 /**
- * This type denotes identifiable activities that modified
- * the roll copy after its production, e.g. annotations, repairs,
- * etc.
- * @see crm:E79 Part Addition, crm:E80 Part Removal
+ * An identifiable act that changed the roll copy after it was punched.
+ * Three kinds of act are told apart, because the CRM tells them apart.
+ * E79 Part Addition asks that what is added be "a separate identifiable
+ * whole prior to" the act, which a label glued on is and a pencil line
+ * is not: drawing, writing and punching bring a feature into being and
+ * are productions.
+ * @see crm:E79 Part Addition, crm:E80 Part Removal, crm:E12 Production
  */
 export type Modification = Partial<{
     /**
@@ -133,36 +147,49 @@ export type Modification = Partial<{
      */
     date: DateAssignment;
 }> & ({
-    type: 'Addition';
+    type: 'Attachment';
     /**
+     * The patches glued onto the copy, each with whatever it bears.
      * @see crm:P111 added
      */
-    added: string[];
+    added: GluedOn[];
+    /**
+     * @see crm:P21 had general purpose
+     */
+    purpose?: ModificationPurpose;
+} | {
+    type: 'Alteration';
+    /**
+     * The features the act brought into being: a date written on the
+     * paper, a circle in pencil, a hole punched by hand.
+     * @see crm:P108 has produced
+     */
+    produced: AnyFeature[];
     /**
      * @see crm:P21 had general purpose
      */
-    purpose: 'musical-improvement' | 'technical-improvement' | 'repair' | 'labeling' | 'control' | 'dating' | 'glossing';
+    purpose?: ModificationPurpose;
 } | {
     type: 'Removal';
     /**
+     * What was taken off the copy, by id. It stood there before the act
+     * and is named rather than stated here. Removals are read from what
+     * they leave behind, such as a bright spot where a label sat.
      * @see crm:P113 removed
      */
     removed: string[];
     /**
-     * Usually, roll features are being added.
-     * Sometimes however, we may see traces of features
-     * that have been removed, e.g. through bright spots on
-     * the roll.
      * @see crm:P21 had general purpose
      */
-    purpose: 'delabeling';
+    purpose?: 'delabeling';
 });
 /**
- * A physical copy of a roll, held at a specific location.
- * Each roll copy has its own set of features, measurements,
- * conditions, and modifications. Multiple copies of the same
- * roll may exist across different archives or collections.
- * @see lrmoo:F5 Item
+ * A physical copy of a roll, held at a specific location. Each roll
+ * copy has its own measurements, conditions and modifications, and
+ * states its features in the act that brought each of them about.
+ * Multiple copies of the same roll may exist across different archives
+ * or collections.
+ * @see reo:RollCopy
  */
 export interface RollCopy extends WithType<'RollCopy'>, WithId {
     /**
@@ -295,12 +322,6 @@ export interface RollCopy extends WithType<'RollCopy'>, WithId {
      * @see crm:P50 has current keeper
      */
     keeper?: KeeperAssignment;
-    /**
-     * The physical features found on this copy, with shift
-     * and stretch already applied when `ops` says so.
-     * @see crm:P56 bears feature
-     */
-    features: AnyFeature[];
     /**
      * @see crm:P31i was modified by
      */
@@ -325,6 +346,17 @@ export interface RollCopy extends WithType<'RollCopy'>, WithId {
      */
     carries?: ReferenceAssumption[];
 }
+/** Whether the act is left stating nothing: it produced, added or removed nothing. */
+export declare const statesNothing: (modification: Modification) => boolean;
+/**
+ * The features of the copy act by act: what the punching produced
+ * first, then what each modification produced or glued on. A feature a
+ * patch bears states no place of its own and is not among them;
+ * `withBorneFeatures` reaches those.
+ */
+export declare const featuresByAct: (copy: Pick<RollCopy, 'production' | 'modifications'>) => FeatureOrPatch[][];
+/** Every feature the copy states at a place of its own, whichever act made it. */
+export declare const featuresOf: (copy: Pick<RollCopy, 'production' | 'modifications'>) => FeatureOrPatch[];
 /**
  * Whether the condition is the stretch or shrinkage of the paper. A
  * scale put down to this belongs to the one exemplar and says nothing
@@ -353,14 +385,14 @@ export declare const barOf: (copy: Pick<RollCopy, 'production'>) => TrackerBar;
  * since they are really on the paper and are his calibration of his own
  * scan; it is the reading that stops.
  */
-export declare function asSymbols(features: AnyFeature[], bar: TrackerBar): AnySymbol[];
+export declare function asSymbols(features: readonly FeatureOrPatch[], bar: TrackerBar): AnySymbol[];
 /**
  * The tracks a copy carries holes on that the tracker bar does not read.
  * A non-empty result usually means the scan is calibrated wrongly. A hole
  * lying across several positions is counted against each one the bar
  * cannot read, and not at all where it reads them all.
  */
-export declare function unreadTracks(features: AnyFeature[], bar: TrackerBar): Map<Track, number>;
+export declare function unreadTracks(features: readonly FeatureOrPatch[], bar: TrackerBar): Map<Track, number>;
 /**
  * Falls back to the way the scan geometry was reconstructed before the
  * calibration was recorded: the bass hard margin stood in for the phase

package/lib/RollCopy.js

@@ -7,6 +7,32 @@ export const rollConditions = [
     'general',
     'paper-stretch'
 ];
+export const modificationPurposes = [
+    'musical-improvement',
+    'technical-improvement',
+    'repair',
+    'labeling',
+    'control',
+    'dating',
+    'glossing'
+];
+/** What an act brought onto the copy: what it produced or glued on, a removal nothing. */
+const madeBy = (modification) => {
+    if (modification.type === 'Alteration')
+        return modification.produced;
+    return modification.type === 'Attachment' ? modification.added : [];
+};
+/** Whether the act is left stating nothing: it produced, added or removed nothing. */
+export const statesNothing = (modification) => modification.type === 'Removal' ? modification.removed.length === 0 : madeBy(modification).length === 0;
+/**
+ * The features of the copy act by act: what the punching produced
+ * first, then what each modification produced or glued on. A feature a
+ * patch bears states no place of its own and is not among them;
+ * `withBorneFeatures` reaches those.
+ */
+export const featuresByAct = (copy) => [copy.production?.produced ?? [], ...copy.modifications.map(madeBy)];
+/** Every feature the copy states at a place of its own, whichever act made it. */
+export const featuresOf = (copy) => featuresByAct(copy).flat();
 /**
  * Whether the condition is the stretch or shrinkage of the paper. A
  * scale put down to this belongs to the one exemplar and says nothing

package/lib/alignment.d.ts

@@ -1,4 +1,4 @@
-import { AnyFeature } from "./Feature";
+import { FeatureOrPatch } from "./Feature";
 import { RollCopy, Shift } from "./RollCopy";
 import { TrackerBar } from "./TrackerBar";
 import { Millimeters } from "./Quantity";
@@ -38,4 +38,4 @@ export interface AlignmentResult {
  * sounds, and it is the pitches that are matched. Where a copy's holes
  * have already been put onto the edition's bar, that bar reads it.
  */
-export declare function alignFeatures(rollA: readonly AnyFeature[], rollB: readonly AnyFeature[], barA?: TrackerBar, barB?: TrackerBar): AlignmentResult | undefined;
+export declare function alignFeatures(rollA: readonly FeatureOrPatch[], rollB: readonly FeatureOrPatch[], barA?: TrackerBar, barB?: TrackerBar): AlignmentResult | undefined;

package/lib/alignment.js

@@ -1,3 +1,4 @@
+import { featuresOf } from "./RollCopy";
 import { welteT100 } from "./systems/welteT100/bar";
 import { add, mm, scale } from "./Quantity";
 /** Moves both ends of a span, the far end only where the span has one. */
@@ -16,7 +17,7 @@ const back = (shift) => ({ horizontal: scale(shift.horizontal, -1), vertical: sc
 export const applyShift = (shift, copy) => {
     if (copy.ops.includes('shifted'))
         return;
-    copy.features.forEach(feature => {
+    featuresOf(copy).forEach(feature => {
         move(feature.horizontal, shift.horizontal);
         move(feature.vertical, shift.vertical);
     });
@@ -27,7 +28,7 @@ export const applyShift = (shift, copy) => {
 export const applyScale = (factor, copy) => {
     if (copy.ops.includes('stretched'))
         return;
-    copy.features.forEach(feature => stretch(feature.horizontal, factor));
+    featuresOf(copy).forEach(feature => stretch(feature.horizontal, factor));
     copy.ops = [...copy.ops, 'stretched'];
     copy.measurements.scale = factor;
 };
@@ -37,7 +38,7 @@ export const revertShift = (copy) => {
     if (!copy.ops.includes('shifted') || !shift)
         return;
     const reversed = back(shift);
-    copy.features.forEach(feature => {
+    featuresOf(copy).forEach(feature => {
         move(feature.horizontal, reversed.horizontal);
         move(feature.vertical, reversed.vertical);
     });
@@ -49,7 +50,7 @@ export const revertScale = (copy) => {
     const factor = copy.measurements.scale;
     if (!copy.ops.includes('stretched') || factor === undefined)
         return;
-    copy.features.forEach(feature => stretch(feature.horizontal, 1 / factor));
+    featuresOf(copy).forEach(feature => stretch(feature.horizontal, 1 / factor));
     copy.ops = copy.ops.filter(op => op !== 'stretched');
     delete copy.measurements.scale;
 };

package/lib/asJsonLd.d.ts

@@ -1,3 +1,8 @@
 import { Edition } from "./Edition";
+/**
+ * The keys an export derives from the tree, which no node of the
+ * edition states itself. An import reads them off again.
+ */
+export declare const derivedKeys: ReadonlySet<string>;
 export declare const exportDate: (date: Date) => string;
 export declare const asJsonLd: (edition: Edition) => any;

package/lib/asJsonLd.js

@@ -1,6 +1,11 @@
 import { systemIdIn } from "./TrackerBar";
 import { certaintyOf, isAsserted } from "./Assumption";
 import context from "./spec/context.json";
+/**
+ * The keys an export derives from the tree, which no node of the
+ * edition states itself. An import reads them off again.
+ */
+export const derivedKeys = new Set(['bears', 'composedOf', 'augmented', 'diminished']);
 export const exportDate = (date) => {
     const year = date.getFullYear();
     const month = String(date.getMonth() + 1).padStart(2, "0");
@@ -62,6 +67,55 @@ const withSystemContexts = (node) => {
         : walked;
 };
 const isRecord = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+const nodesIn = (value) => Array.isArray(value) ? value.filter(isRecord) : [];
+/** What the acts of a copy brought onto it: the features they produced and the patches they glued on. */
+const madeOn = (copy) => [
+    ...nodesIn(copy.production?.produced),
+    ...nodesIn(copy.modifications).flatMap(act => [...nodesIn(act.produced), ...nodesIn(act.added)])
+];
+const referencing = (nodes, patches) => nodes.filter(node => (node['@type'] === 'GluedOn') === patches && typeof node['@id'] === 'string')
+    .map(node => ({ '@id': node['@id'] }));
+const featuresAmong = (nodes) => referencing(nodes, false);
+const patchesAmong = (nodes) => referencing(nodes, true);
+/** The key, where there is anything to state under it. */
+const stating = (key, references) => references.length > 0 ? { [key]: references } : {};
+/** The act with what it changed named: an attachment augments the copy, a removal diminishes it. */
+const changing = (copyId) => (act) => {
+    if (typeof copyId !== 'string' || !isRecord(act))
+        return act;
+    if (act['@type'] === 'Attachment')
+        return { ...act, augmented: { '@id': copyId } };
+    if (act['@type'] === 'Removal')
+        return { ...act, diminished: { '@id': copyId } };
+    return act;
+};
+/**
+ * The document with every bearing stated that its tree only implies. A
+ * copy bears the features its acts brought about and is composed of the
+ * patches they glued on, a patch bears the features glued onto it in
+ * turn. Each feature stands in the act that made it and nothing reads a
+ * bearing off that, so the export states it; a patch is no feature, and
+ * P56 bears feature takes only features, so a patch is stated as a part.
+ */
+const withBearings = (value) => {
+    if (Array.isArray(value))
+        return value.map(withBearings);
+    if (!isRecord(value))
+        return value;
+    const node = Object.fromEntries(Object.entries(value).map(([key, child]) => [key, withBearings(child)]));
+    if (node['@type'] === 'RollCopy') {
+        const made = madeOn(node);
+        return {
+            ...node,
+            ...(Array.isArray(node.modifications) && { modifications: node.modifications.map(changing(node['@id'])) }),
+            ...stating('bears', featuresAmong(made)),
+            ...stating('composedOf', patchesAmong(made))
+        };
+    }
+    if (node['@type'] === 'GluedOn')
+        return { ...node, ...stating('bears', featuresAmong(nodesIn(node.features))) };
+    return node;
+};
 /** Terms the context sets to null, which say nothing when the edition is read as RDF. */
 const silentTerms = new Set(Object.entries(context['@context'])
     .filter(([, definition]) => definition === null)
@@ -128,7 +182,7 @@ const withDoubtedReferencesQuoted = (value) => {
     };
 };
 export const asJsonLd = (edition) => {
-    const { node, quoted } = withDoubtedReferencesQuoted(withSystemContexts(asJsonLdEntity(edition)));
+    const { node, quoted } = withDoubtedReferencesQuoted(withSystemContexts(withBearings(asJsonLdEntity(edition))));
     // The context is the export's own; one carried in from an import must not override it.
     const { base, '@context': carried, ...rest } = node;
     return {

package/lib/editionOps.d.ts

@@ -7,7 +7,7 @@ import { Edit } from "./Edit";
 import { GeneralRollCondition, RollCopy, ScaleReading, Shift } from "./RollCopy";
 import { FeatureSource } from "./FeatureSource";
 import { AnyArgumentation, Belief, Certainty, ObjectAssumption } from "./Assumption";
-import { AnyFeature, FeatureConditionAssignment } from "./Feature";
+import { FeatureConditionAssignment, FeatureOrPatch } 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
@@ -74,7 +74,8 @@ export declare const symbolsCarriedOnlyBy: (edition: Edition, copyId: string) =>
  * 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 +85,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 +94,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 +107,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.