linked-rolls 0.56.0 → 0.57.0

package/README.md

@@ -230,15 +230,21 @@ 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.
+productions (E12), which state what they made with `reo:produced`, a
+subproperty of P108 has produced.
 
-The export states what that shape only implies. A copy bears every
+The format states nothing a reasoner can derive. That 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.
+rather than a feature) follows from property chains in `reo.ttl`, all
+within OWL 2 RL. The chain for the punching runs over `reo:produced`
+rather than P108, because R28 produced is itself a subproperty of P108
+(LRMoo 1.0, p. 44), and a chain over P108 would have the copy bear
+itself. That an attachment augments the copy and a removal diminishes
+it depends on the class of the act, which no chain can test. These two
+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
 

package/lib/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/EditionView.d.ts

@@ -1,5 +1,5 @@
 import { Edition } from "./Edition.js";
-import { HorizontalSpan, FeatureOrPatch } from "./Feature.js";
+import { FeatureOrPatch, HorizontalSpan, NestedFeature } from "./Feature.js";
 import { AnySymbol, Expression, Note } from "./Symbol.js";
 import { Version } from "./Version.js";
 import { NegotiatedEvent } from "./ReproducingSystem.js";
@@ -10,10 +10,6 @@ export type Path = (string | number)[];
 export declare const getAt: <T>(path: Path, obj: unknown) => T | undefined;
 export declare class EditionView {
     readonly edition: Edition;
-    /**
-     * Map from id to object
-     */
-    private readonly byId;
     /**
      * Map from id to its path within the edition
      */
@@ -24,17 +20,35 @@ export declare class EditionView {
     private readonly links;
     /** Built when a copy is first asked for, the walk not recording it. */
     private copiesByFeature?;
+    /**
+     * One index for each kind of entity, built from where the edition
+     * holds it. The index an entity is found in says what it is, so a
+     * lookup needs neither a type discriminator nor a cast.
+     */
+    private readonly versionsById;
+    private readonly copiesById;
+    private readonly symbolsById;
+    private featuresById?;
     constructor(edition: Edition);
     atPath<T>(path: Path): T | null;
     indexObjects(): void;
-    get<T>(anyId: string): T | undefined;
-    getAll<T>(anyIds: readonly string[]): T[];
+    version(id: string): Readonly<Version> | undefined;
+    copy(id: string): Readonly<RollCopy> | undefined;
+    symbol(id: string): Readonly<AnySymbol> | undefined;
+    /** The symbols under the ids, leaving out an id that names none. */
+    symbols(ids: readonly string[]): Readonly<AnySymbol>[];
+    /** A feature or a patch on any copy, one a patch bears included. */
+    feature(id: string): Readonly<NestedFeature> | undefined;
+    /** The features and patches under the ids, leaving out an id that names none. */
+    features(ids: readonly string[]): Readonly<NestedFeature>[];
     getPath(anyId: string): Path | undefined;
     linksTo(anyId: string): Path[];
     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<FeatureOrPatch>[];
+    carriersOf(symbol: AnySymbol): Readonly<NestedFeature>[];
+    /** The carriers that state a place of their own, which a feature on a patch does not. */
+    placedCarriersOf(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,4 +1,4 @@
-import { withBorneFeatures } from "./Feature.js";
+import { isPlaced, withBorneFeatures } from "./Feature.js";
 import { deletedBy, insertedBy, principalDerivationOf } from "./Version.js";
 import { systemIdOf } from "./TrackerBar.js";
 import { featuresMadeBy, featuresOf, isPaperStretch } from "./RollCopy.js";
@@ -15,6 +15,7 @@ export const getAt = (path, obj) => {
 };
 /** Keys under which an object names others by id, singly or in a list. */
 const referenceKeys = ['delete', 'comprehends', 'motivation', 'premises', 'used'];
+const byIdIn = (entities) => new Map(entities.map(entity => [entity.id, entity]));
 const isObject = (v) => v !== null && typeof v === "object";
 /** What a reference may state besides the id: a belief about it, and the tolerance a derivation was collated at. */
 const referenceOwnKeys = new Set(['id', '@annotation', 'collationTolerance']);
@@ -34,15 +35,6 @@ export class EditionView {
             writable: true,
             value: void 0
         });
-        /**
-         * Map from id to object
-         */
-        Object.defineProperty(this, "byId", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Map()
-        });
         /**
          * Map from id to its path within the edition
          */
@@ -68,7 +60,39 @@ export class EditionView {
             writable: true,
             value: void 0
         });
+        /**
+         * One index for each kind of entity, built from where the edition
+         * holds it. The index an entity is found in says what it is, so a
+         * lookup needs neither a type discriminator nor a cast.
+         */
+        Object.defineProperty(this, "versionsById", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "copiesById", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "symbolsById", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "featuresById", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.edition = edition;
+        this.versionsById = byIdIn(edition.versions);
+        this.copiesById = byIdIn(edition.copies);
+        this.symbolsById = byIdIn(edition.versions.flatMap(insertedBy));
         this.indexObjects();
     }
     atPath(path) {
@@ -89,8 +113,7 @@ export class EditionView {
                 return;
             if (isReferenceOnly(keys))
                 link(record.id, { key: 'id', up: trail });
-            else if (!this.byId.has(record.id)) {
-                this.byId.set(record.id, record);
+            else if (!this.paths.has(record.id)) {
                 this.paths.set(record.id, trail);
             }
         };
@@ -120,11 +143,27 @@ export class EditionView {
         };
         traverse(this.edition, null);
     }
-    get(anyId) {
-        return this.byId.get(anyId);
+    version(id) {
+        return this.versionsById.get(id);
+    }
+    copy(id) {
+        return this.copiesById.get(id);
     }
-    getAll(anyIds) {
-        return anyIds.map(id => this.get(id)).filter((v) => !!v);
+    symbol(id) {
+        return this.symbolsById.get(id);
+    }
+    /** The symbols under the ids, leaving out an id that names none. */
+    symbols(ids) {
+        return ids.flatMap(id => this.symbol(id) ?? []);
+    }
+    /** A feature or a patch on any copy, one a patch bears included. */
+    feature(id) {
+        this.featuresById ?? (this.featuresById = byIdIn(this.edition.copies.flatMap(copy => featuresOf(copy).flatMap(withBorneFeatures))));
+        return this.featuresById.get(id);
+    }
+    /** The features and patches under the ids, leaving out an id that names none. */
+    features(ids) {
+        return ids.flatMap(id => this.feature(id) ?? []);
     }
     getPath(anyId) {
         const trail = this.paths.get(anyId);
@@ -134,7 +173,7 @@ export class EditionView {
         return (this.links.get(anyId) ?? []).map(pathOf);
     }
     travelUp(versionId, callback) {
-        const v = this.get(versionId);
+        const v = this.version(versionId);
         if (!v)
             return;
         callback(v);
@@ -150,7 +189,11 @@ export class EditionView {
         return lineage;
     }
     carriersOf(symbol) {
-        return this.getAll(idsOf(symbol.carriers));
+        return this.features(idsOf(symbol.carriers));
+    }
+    /** The carriers that state a place of their own, which a feature on a patch does not. */
+    placedCarriersOf(symbol) {
+        return this.carriersOf(symbol).filter(isPlaced);
     }
     /** The copy a feature sits on, a patch and everything it bears included. */
     copyOf(featureId) {
@@ -220,9 +263,9 @@ export class EditionView {
     }
     /** The version the given one's text is read against, by its principal derivation. */
     predecessorOf(versionId) {
-        const v = this.get(versionId);
+        const v = this.version(versionId);
         const principal = v && principalDerivationOf(v);
-        return principal && this.get(idOf(principal));
+        return principal && this.version(idOf(principal));
     }
     /**
      * Where along the roll the symbol lies, as its carriers put it, or
@@ -238,7 +281,7 @@ export class EditionView {
      * position a semitone away on either bar.
      */
     placeOf(symbol) {
-        const carriers = this.getAll(idsOf(symbol.carriers));
+        const carriers = this.placedCarriersOf(symbol);
         if (carriers.length === 0)
             return;
         return {
@@ -282,7 +325,7 @@ export class EditionView {
             if (inStack.has(id)) {
                 throw new Error(`Cycle detected involving node '${id}'. Check parentId links.`);
             }
-            const node = this.get(id);
+            const node = this.version(id);
             if (!node) {
                 memo.set(id, 0);
                 return 0;
@@ -294,7 +337,7 @@ export class EditionView {
             if (basedOn === undefined) {
                 gen = 0; // root
             }
-            else if (!this.get(basedOn)) {
+            else if (!this.version(basedOn)) {
                 // Orphaned parent reference — treat boundary as root
                 gen = 0;
             }

package/lib/Emulation.js

@@ -17,10 +17,10 @@ const propertiesOf = (view, version) => ({
 });
 /** The onset a symbol has on each copy carrying it, by the copy's index, as the mean of its chains there. */
 const onsetsByCopy = (view, symbolId) => {
-    const symbol = view.get(symbolId);
+    const symbol = view.symbol(symbolId);
     if (!symbol)
         return new Map();
-    const onsets = view.carriersOf(symbol).flatMap((carrier) => {
+    const onsets = view.placedCarriersOf(symbol).flatMap((carrier) => {
         const copy = view.getPath(carrier.id)?.[1];
         return typeof copy === 'number' ? [[copy, carrier.horizontal.from]] : [];
     });

package/lib/Feature.d.ts

@@ -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

@@ -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/RollCopy.d.ts

@@ -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[];
     /**

package/lib/Version.d.ts

@@ -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

package/lib/asJsonLd.js

@@ -5,7 +5,7 @@ import context from "./spec/context.json" with { type: '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 derivedKeys = new Set(['augmented', 'diminished']);
 export const exportDate = (date) => {
     const year = date.getFullYear();
     const month = String(date.getMonth() + 1).padStart(2, "0");
@@ -53,32 +53,12 @@ const asJsonLdEntity = (obj) => {
  * reading as whichever came last. An embedded context merges with the
  * active one, so the shared prefixes survive.
  */
-const withSystemContexts = (node) => {
-    if (Array.isArray(node))
-        return node.map(withSystemContexts);
-    if (node === null || typeof node !== 'object')
-        return node;
-    const walked = Object.fromEntries(Object.entries(node).map(([key, value]) => [key, withSystemContexts(value)]));
-    const system = node['@type'] === 'Version'
-        ? systemIdIn(node.system?.['@id'])
-        : undefined;
-    return system
-        ? { '@context': `https://w3id.org/reo/${system}/context.jsonld`, ...walked }
-        : walked;
+const withSystemContext = (version) => {
+    const system = systemIdIn(version?.system?.['@id']);
+    return system ? { '@context': `https://w3id.org/reo/${system}/context.jsonld`, ...version } : version;
 };
+const withSystemContexts = (edition) => Array.isArray(edition.versions) ? { ...edition, versions: edition.versions.map(withSystemContext) } : edition;
 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'] === 'Patch') === 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))
@@ -90,31 +70,21 @@ const changing = (copyId) => (act) => {
     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.
+ * The document with what each act changed stated. Which of P110
+ * augmented and P112 diminished applies depends on the class of the
+ * act, which no property chain in OWL 2 RL can test, so the export
+ * states it. What a copy or a patch bears is left to a reasoner (see
+ * the entailments in reo.ttl).
  */
-const withBearings = (value) => {
+const withChanges = (value) => {
     if (Array.isArray(value))
-        return value.map(withBearings);
+        return value.map(withChanges);
     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'] === 'Patch')
-        return { ...node, ...stating('bears', featuresAmong(nodesIn(node.features))) };
-    return node;
+    const node = Object.fromEntries(Object.entries(value).map(([key, child]) => [key, withChanges(child)]));
+    return node['@type'] === 'RollCopy' && Array.isArray(node.modifications)
+        ? { ...node, modifications: node.modifications.map(changing(node['@id'])) }
+        : 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'])
@@ -182,7 +152,7 @@ const withDoubtedReferencesQuoted = (value) => {
     };
 };
 export const asJsonLd = (edition) => {
-    const { node, quoted } = withDoubtedReferencesQuoted(withSystemContexts(withBearings(asJsonLdEntity(edition))));
+    const { node, quoted } = withDoubtedReferencesQuoted(withSystemContexts(withChanges(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 {
@@ -192,7 +162,6 @@ export const asJsonLd = (edition) => {
                 '@base': edition.base
             }
         ],
-        '@type': "Edition",
         '@id': edition.base,
         ...rest,
         ...(quoted.length > 0 && { '@included': quoted })

package/lib/constraints.js

@@ -86,7 +86,7 @@ const carriersOffTheirMeaning = (view, version, commands) => {
             .some(meaning => keyOf(meaning) === keyOf(symbol));
     };
     return commands
-        .filter(symbol => view.carriersOf(symbol).some(carrier => misread(carrier, symbol)))
+        .filter(symbol => view.placedCarriersOf(symbol).some(carrier => misread(carrier, symbol)))
         .map(symbol => ({ version, symbol: symbol.id, problem: 'carrier-on-another-track' }));
 };
 /**

package/lib/editionOps.js

@@ -90,7 +90,6 @@ export const createVersion = (copy) => draft => {
     const bar = barOf(copy);
     draft.copies.push(copy);
     draft.versions.push({
-        type: 'Version',
         id: v4(),
         system: systemOf(bar),
         edits: asSymbols(featuresOf(copy), bar).map(insertion),
@@ -707,7 +706,7 @@ const byExchange = (edits) => new Map(edits.map(edit => [exchangeKey((edit.inser
  * child's symbols and not the parent's with themselves.
  */
 export const connectVersions = (view, childId, parentId, tolerance = defaultCollationTolerance) => {
-    const child = view.get(childId);
+    const child = view.version(childId);
     const stated = child ? editsOf(child) : [];
     const established = stated.filter(edit => !isCollationsOwn(edit));
     const spokenFor = spokenForBy(established);
@@ -732,7 +731,7 @@ export const connectVersions = (view, childId, parentId, tolerance = defaultColl
      * apart would make the apparatus a list of unexplained losses beside
      * a list of unexplained gains.
      */
-    const substituted = differ(child, view.get(parentId))
+    const substituted = differ(child, view.version(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)));
@@ -773,7 +772,7 @@ export const connectVersions = (view, childId, parentId, tolerance = defaultColl
  * tolerance of the derivation, where the caller names none.
  */
 export const collateSymbols = (view, versionId, symbolIds, tolerance) => {
-    const version = view.get(versionId);
+    const version = view.version(versionId);
     const principal = version && principalDerivationOf(version);
     if (!version || !principal)
         return noChange;
@@ -843,7 +842,7 @@ const sharedWith = (view, symbol, copies) => {
  * narrow the act to those; naming none separates the whole reading.
  */
 export const separateReadings = (view, versionId, copies, symbolIds) => {
-    const version = view.get(versionId);
+    const version = view.version(versionId);
     if (!version)
         return noChange;
     const chosen = symbolIds && new Set(symbolIds);
@@ -911,7 +910,6 @@ export const deriveVersion = (versionId, editIds) => onVersion(versionId, (versi
     if (version.edits)
         version.edits = without(version.edits, edit => chosen.has(edit.id));
     draft.versions.push({
-        type: 'Version',
         id: v4(),
         system: stateOf(version).system,
         basedOn: [assignReference(versionId)],
@@ -970,10 +968,10 @@ const replacementType = (view, inserted, deleted) => {
  */
 const guessEditType = (view, versionId, edit) => {
     const inserts = edit.insert ?? [];
-    const deletes = view.getAll(edit.delete ?? []);
+    const deletes = view.symbols(edit.delete ?? []);
     const inserted = expressionTypesOf(inserts);
     const deleted = expressionTypesOf(deletes);
-    const bar = trackerBarOf(view.get(versionId)?.system);
+    const bar = trackerBarOf(view.version(versionId)?.system);
     const parentBar = trackerBarOf(view.predecessorOf(versionId)?.system);
     /**
      * Where the version is coded for another system than its parent, an

package/lib/importJsonLd.js

@@ -18,12 +18,7 @@ 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.
- */
+/** 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;

package/lib/migrate.js

@@ -156,7 +156,6 @@ const withPerforator = (node) => {
             perforator: {
                 ...perforator,
                 condition: {
-                    '@type': 'ConditionState',
                     conditionType: 'setting',
                     ...perforator.condition,
                     punchDiameter: diameter
@@ -196,6 +195,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;
@@ -313,7 +328,7 @@ const withTimeSpanDates = (node) => {
 };
 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]
+    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 +405,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;
@@ -461,14 +483,16 @@ const referenceOf = (statement) => {
         }
     };
 };
-/** The document with each quoted reference back on the node that makes it, a node being what has a type. */
+/** 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 = typeof value['@id'] === 'string' && value['@type'] !== undefined
+    const references = isNode(value)
         ? bySubject.get(value['@id']) ?? []
         : [];
     return references.reduce((node, { key, listed, reference }) => ({ ...node, [key]: listed ? [...(node[key] ?? []), reference] : reference }), walked);
@@ -490,5 +514,5 @@ const withQuotedStatementsInPlace = (edition) => {
     const bySubject = Map.groupBy(statements.map(referenceOf), ({ subject }) => subject);
     return withReferencesOn({ ...rest, ...(others.length > 0 && { '@included': others }) }, bySubject);
 };
-const editionSteps = [withQuotedStatementsInPlace, withSystems, withEditors, withDerivationTolerance];
+const editionSteps = [withoutEditionType, withQuotedStatementsInPlace, withSystems, withEditors, withDerivationTolerance];
 export const migrate = (edition) => walk(editionSteps.reduce((result, step) => step(result), edition));

package/lib/readers/stanfordAton.js

@@ -164,7 +164,6 @@ export function readFromStanfordAton(atonString, { trackShift, system = welteT10
                     type: 'Perforator',
                     id: `perforator_${v4()}`,
                     condition: {
-                        type: 'ConditionState',
                         conditionType: 'setting',
                         punchDiameter: { value: punchDiameter, unit: 'mm' }
                     }

package/lib/scatter.js

@@ -37,7 +37,7 @@ const sitsOn = (view, copies) => (feature) => {
 export const readingsOf = (view, symbols, copies) => {
     const tested = sitsOn(view, copies);
     return symbols.flatMap((symbol) => {
-        const carriers = view.carriersOf(symbol);
+        const carriers = view.placedCarriersOf(symbol);
         const here = carriers.filter(tested);
         const there = carriers.filter(carrier => !tested(carrier));
         if (here.length === 0 || there.length === 0)
@@ -220,12 +220,12 @@ const copiesBearing = (view, symbols) => {
  * stopped saying and an editor has to.
  */
 export const sidesOf = (view, versionId) => {
-    const version = view.get(versionId);
+    const version = view.version(versionId);
     if (!version)
         return undefined;
     return {
         child: copiesBearing(view, insertedBy(version)),
-        parent: copiesBearing(view, view.getAll(deletedBy(version)))
+        parent: copiesBearing(view, view.symbols(deletedBy(version)))
     };
 };
 const inMillimetres = (value) => `${value.toFixed(2)} mm`;

package/lib/schema.json

@@ -1221,7 +1221,7 @@
                                 "$ref": "#/definitions/AnyFeature"
                             },
                             "type": "array",
-                            "ontology": "crm:P108 has produced"
+                            "ontology": "reo:produced"
                         },
                         "purpose": {
                             "$ref": "#/definitions/ModificationPurpose",
@@ -1566,22 +1566,6 @@
                             "description": "The type discriminator for this object.",
                             "type": "string",
                             "ontology": "rdf:type"
-                        },
-                        "bears": {
-                            "type": "array",
-                            "items": {
-                                "type": "object",
-                                "properties": {
-                                    "@id": {
-                                        "type": "string"
-                                    }
-                                },
-                                "required": [
-                                    "@id"
-                                ]
-                            },
-                            "description": "The features the patch bears. Derived on export.",
-                            "ontology": "crm:P56 bears feature"
                         }
                     },
                     "required": [
@@ -1682,17 +1666,10 @@
                             "description": "A free-text description of the condition, providing details beyond the type classification.",
                             "type": "string",
                             "ontology": "crm:P3 has note"
-                        },
-                        "@type": {
-                            "const": "ConditionState",
-                            "description": "The type discriminator for this object.",
-                            "type": "string",
-                            "ontology": "rdf:type"
                         }
                     },
                     "required": [
-                        "conditionType",
-                        "@type"
+                        "conditionType"
                     ],
                     "type": "object"
                 },
@@ -1732,18 +1709,11 @@
                             "description": "The stretch factor, e.g. 1.02 means the paper has stretched by 2% compared to its original dimensions.",
                             "type": "number",
                             "ontology": "rdf:value"
-                        },
-                        "@type": {
-                            "const": "ConditionState",
-                            "description": "The type discriminator for this object.",
-                            "type": "string",
-                            "ontology": "rdf:type"
                         }
                     },
                     "required": [
                         "conditionType",
-                        "factor",
-                        "@type"
+                        "factor"
                     ],
                     "type": "object"
                 }
@@ -1986,17 +1956,10 @@
                     "description": "A free-text description of the condition, providing details beyond the type classification.",
                     "type": "string",
                     "ontology": "crm:P3 has note"
-                },
-                "@type": {
-                    "const": "ConditionState",
-                    "description": "The type discriminator for this object.",
-                    "type": "string",
-                    "ontology": "rdf:type"
                 }
             },
             "required": [
-                "conditionType",
-                "@type"
+                "conditionType"
             ],
             "type": "object"
         },
@@ -2035,17 +1998,10 @@
                     "description": "A free-text description of the condition, providing details beyond the type classification.",
                     "type": "string",
                     "ontology": "crm:P3 has note"
-                },
-                "@type": {
-                    "const": "ConditionState",
-                    "description": "The type discriminator for this object.",
-                    "type": "string",
-                    "ontology": "rdf:type"
                 }
             },
             "required": [
-                "conditionType",
-                "@type"
+                "conditionType"
             ],
             "type": "object"
         },
@@ -2081,17 +2037,10 @@
                     "description": "A free-text description of the condition, providing details beyond the type classification.",
                     "type": "string",
                     "ontology": "crm:P3 has note"
-                },
-                "@type": {
-                    "const": "ConditionState",
-                    "description": "The type discriminator for this object.",
-                    "type": "string",
-                    "ontology": "rdf:type"
                 }
             },
             "required": [
-                "conditionType",
-                "@type"
+                "conditionType"
             ],
             "type": "object"
         },
@@ -2127,17 +2076,10 @@
                     "description": "A free-text description of the condition, providing details beyond the type classification.",
                     "type": "string",
                     "ontology": "crm:P3 has note"
-                },
-                "@type": {
-                    "const": "ConditionState",
-                    "description": "The type discriminator for this object.",
-                    "type": "string",
-                    "ontology": "rdf:type"
                 }
             },
             "required": [
-                "conditionType",
-                "@type"
+                "conditionType"
             ],
             "type": "object"
         },
@@ -2176,17 +2118,10 @@
                     "description": "A free-text description of the condition, providing details beyond the type classification.",
                     "type": "string",
                     "ontology": "crm:P3 has note"
-                },
-                "@type": {
-                    "const": "ConditionState",
-                    "description": "The type discriminator for this object.",
-                    "type": "string",
-                    "ontology": "rdf:type"
                 }
             },
             "required": [
-                "conditionType",
-                "@type"
+                "conditionType"
             ],
             "type": "object"
         },
@@ -2650,22 +2585,6 @@
                     "description": "The type discriminator for this object.",
                     "type": "string",
                     "ontology": "rdf:type"
-                },
-                "bears": {
-                    "type": "array",
-                    "items": {
-                        "type": "object",
-                        "properties": {
-                            "@id": {
-                                "type": "string"
-                            }
-                        },
-                        "required": [
-                            "@id"
-                        ]
-                    },
-                    "description": "The features the patch bears. Derived on export.",
-                    "ontology": "crm:P56 bears feature"
                 }
             },
             "required": [
@@ -2734,17 +2653,10 @@
                     "$ref": "#/definitions/ObjectAssumption%3CMeasure%3C%22mm%22%3E%3E",
                     "description": "The diameter of the round punch. Taken across the roll, it is the one value of the setting that neither the scale along the roll nor the shrinkage of the paper enters.",
                     "ontology": "reo:punchDiameter"
-                },
-                "@type": {
-                    "const": "ConditionState",
-                    "description": "The type discriminator for this object.",
-                    "type": "string",
-                    "ontology": "rdf:type"
                 }
             },
             "required": [
-                "conditionType",
-                "@type"
+                "conditionType"
             ],
             "type": "object",
             "ontology": "crm:E3 Condition State"
@@ -2813,7 +2725,7 @@
                         "$ref": "#/definitions/AnyFeature"
                     },
                     "type": "array",
-                    "ontology": "crm:P108 has produced"
+                    "ontology": "reo:produced"
                 },
                 "speed": {
                     "$ref": "#/definitions/ObjectAssumption%3CPaperSpeed%3E",
@@ -3152,38 +3064,6 @@
                     "description": "The type discriminator for this object.",
                     "type": "string",
                     "ontology": "rdf:type"
-                },
-                "bears": {
-                    "type": "array",
-                    "items": {
-                        "type": "object",
-                        "properties": {
-                            "@id": {
-                                "type": "string"
-                            }
-                        },
-                        "required": [
-                            "@id"
-                        ]
-                    },
-                    "description": "The features the copy bears, whichever of its acts brought them about. Derived on export.",
-                    "ontology": "crm:P56 bears feature"
-                },
-                "composedOf": {
-                    "type": "array",
-                    "items": {
-                        "type": "object",
-                        "properties": {
-                            "@id": {
-                                "type": "string"
-                            }
-                        },
-                        "required": [
-                            "@id"
-                        ]
-                    },
-                    "description": "The patches glued onto the copy. A patch is an object rather than a feature, so it is stated as a part. Derived on export.",
-                    "ontology": "crm:P46 is composed of"
                 }
             },
             "required": [
@@ -3361,19 +3241,12 @@
                 "@id": {
                     "description": "A unique identifier for this object.",
                     "type": "string"
-                },
-                "@type": {
-                    "const": "Version",
-                    "description": "The type discriminator for this object.",
-                    "type": "string",
-                    "ontology": "rdf:type"
                 }
             },
             "required": [
                 "@id",
                 "motivations",
-                "system",
-                "@type"
+                "system"
             ],
             "type": "object",
             "ontology": "lrmoo:F2 Expression"

package/lib/spec/context.json

@@ -11,8 +11,6 @@
         "crminf": "http://www.cidoc-crm.org/extensions/crminf/",
         "lrmoo": "http://iflastandards.info/ns/lrm/lrmoo/",
         "reo": "https://w3id.org/reo/",
-        "Edition": "lrmoo:F2_Expression",
-        "Version": "lrmoo:F2_Expression",
         "RollCopy": "reo:RollCopy",
         "HoleChain": "reo:HoleChain",
         "Mark": "reo:Mark",
@@ -22,7 +20,6 @@
         "Removal": "crm:E80_Part_Removal",
         "Alteration": "crm:E12_Production",
         "Perforator": "crm:E22_Human-Made_Object",
-        "ConditionState": "crm:E3_Condition_State",
         "note": "reo:Note",
         "expression": "reo:Expression",
         "text": {
@@ -280,7 +277,7 @@
             }
         },
         "actor": "crm:P14_carried_out_by",
-        "produced": "crm:P108_has_produced",
+        "produced": "reo:produced",
         "added": "crm:P111_added",
         "removed": {
             "@id": "crm:P113_removed",
@@ -291,14 +288,6 @@
             "@type": "@vocab",
             "@context": { "@vocab": "https://w3id.org/reo/type/" }
         },
-        "bears": {
-            "@id": "crm:P56_bears_feature",
-            "@type": "@id"
-        },
-        "composedOf": {
-            "@id": "crm:P46_is_composed_of",
-            "@type": "@id"
-        },
         "augmented": {
             "@id": "crm:P110_augmented",
             "@type": "@id"

package/lib/witnesses.js

@@ -70,7 +70,7 @@ const witnessesIn = (carriers, view, versionId) => {
  * reported as it stands. A version whose edits are not stated inserts
  * nothing and is witnessed by statement alone.
  */
-export const witnessesOf = (view, versionId) => view.get(versionId) ? witnessesIn(carriersIn(view), view, versionId) : [];
+export const witnessesOf = (view, versionId) => view.version(versionId) ? witnessesIn(carriersIn(view), view, versionId) : [];
 /**
  * The versions the copy bears witness to, each with how, in the order the
  * edition lists its versions.
@@ -92,7 +92,7 @@ export const carriageProblems = (view) => {
         const version = idOf(statement);
         return [
             ...(carrying.has(copy.id) ? [{ copy: copy.id, version, problem: 'stated-beside-carriers' }] : []),
-            ...(view.get(version)?.type === 'Version' ? [] : [{ copy: copy.id, version, problem: 'version-missing' }])
+            ...(view.version(version) ? [] : [{ copy: copy.id, version, problem: 'version-missing' }])
         ];
     }));
 };

package/package.json

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