linked-rolls 0.55.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

@@ -53,12 +53,12 @@ export interface VerticalSpan {
      */
     to?: Track;
 }
-export declare const featureTypes: readonly ['HoleChain', 'Writing', 'Mark', 'GluedOn'];
+export declare const featureTypes: readonly ['HoleChain', 'Writing', 'Mark', 'Patch'];
 export type FeatureType = typeof featureTypes[number];
 export declare const isFeatureType: (value: unknown) => value is FeatureType;
 /**
  * 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
+ * patch, defined by its horizontal and vertical position and
  * extent. Each kind of feature is a class of its own, which its type
  * names.
  */
@@ -89,7 +89,7 @@ export declare const conditions: {
     readonly HoleChain: readonly ["partially-torn", "missing-perforation"];
     readonly Writing: readonly ["illegible"];
     readonly Mark: readonly ["faded"];
-    readonly GluedOn: readonly ["detaching", "ripped"];
+    readonly Patch: readonly ["detaching", "ripped"];
 };
 /** The kinds of condition a feature may be in, whichever kind of feature it is. */
 export type FeatureConditionType = typeof conditions[FeatureType][number];
@@ -191,15 +191,14 @@ export interface Writing extends Trace<'Writing'> {
 export interface Mark extends Trace<'Mark'> {
 }
 /**
- * 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 reo:GluedOn
+ * A piece of paper or tape glued onto the roll: a label naming it, a
+ * strip covering perforations, or a patch reinforcing a tear. A patch
+ * may itself carry other features, such as writings or holes.
+ * @see reo:Patch
  */
-export interface GluedOn extends RollFeature<'GluedOn', typeof conditions.GluedOn[number]>, OnAFace {
+export interface Patch extends RollFeature<'Patch', typeof conditions.Patch[number]>, OnAFace {
     /**
-     * The material of the glued-on feature.
+     * What the patch is made of.
      * @see crm:P45 consists of
      */
     material: 'paper' | 'tape';
@@ -211,8 +210,8 @@ export interface GluedOn extends RollFeature<'GluedOn', typeof conditions.GluedO
      */
     rotation?: Measure<'deg'>;
     /**
-     * A glued-on feature itself may carry other features.
-     * Nested features do not need to be positioned explicitly.
+     * The features the patch itself carries. They need not be
+     * positioned explicitly.
      * @see crm:P46 is composed of
      */
     features?: NestedFeature[];
@@ -225,10 +224,10 @@ export interface GluedOn extends RollFeature<'GluedOn', typeof conditions.GluedO
 export type AnyFeature = HoleChain | 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.
+ * patch. E24 Physical Human-Made Thing is the class both fall under,
+ * E22 and E25 being its subclasses.
  */
-export type FeatureOrPatch = AnyFeature | GluedOn;
+export type FeatureOrPatch = AnyFeature | Patch;
 /**
  * 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.
@@ -239,8 +238,10 @@ 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 isGluedOn: <T extends NestedFeature>(feature: T) => feature is T & GluedOn;
+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. */
 export declare const featuresBorneBy: (feature: NestedFeature) => NestedFeature[];
 /** The feature together with everything it bears, as deep as a patch on a patch goes. */

package/lib/Feature.js

@@ -1,18 +1,20 @@
-export const featureTypes = ['HoleChain', 'Writing', 'Mark', 'GluedOn'];
+export const featureTypes = ['HoleChain', 'Writing', 'Mark', 'Patch'];
 export const isFeatureType = (value) => featureTypes.includes(value);
 export const conditions = {
     HoleChain: ['partially-torn', 'missing-perforation'],
     Writing: ['illegible'],
     Mark: ['faded'],
-    GluedOn: ['detaching', 'ripped']
+    Patch: ['detaching', 'ripped']
 };
 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);
 };
-export const isGluedOn = (feature) => feature.type === 'GluedOn';
+export const isPatch = (feature) => feature.type === 'Patch';
 /** The features a feature bears: a patch those stated as parts of it, any other feature none. */
-export const featuresBorneBy = (feature) => isGluedOn(feature) ? feature.features ?? [] : [];
+export const featuresBorneBy = (feature) => isPatch(feature) ? feature.features ?? [] : [];
 /** The feature together with everything it bears, as deep as a patch on a patch goes. */
 export const withBorneFeatures = (feature) => [feature, ...featuresBorneBy(feature).flatMap(withBorneFeatures)];

package/lib/RollCopy.d.ts

@@ -2,7 +2,7 @@ import { ConditionState } from "./ConditionState.js";
 import { AnySymbol } from "./Symbol.js";
 import { TrackerBar } from "./TrackerBar.js";
 import { TrackCalibration } from "./TrackCalibration.js";
-import { AnyFeature, FeatureOrPatch, GluedOn } from "./Feature.js";
+import { AnyFeature, FeatureOrPatch, Patch } from "./Feature.js";
 import { ActorAssignment, DateAssignment, ObjectAssumption, ReferenceAssumption } from "./Assumption.js";
 import { WithId, WithType } from "./utils.js";
 import { Agent, Concept } from "./Agent.js";
@@ -128,7 +128,7 @@ export interface ProductionEvent {
      * at once and states it here, and a feature an editor reads as the
      * work of a later hand belongs in the act that made it, whichever
      * kind of feature it is.
-     * @see crm:P108 has produced
+     * @see reo:produced
      */
     produced?: AnyFeature[];
 }
@@ -161,7 +161,7 @@ export type Modification = Partial<{
      * The patches glued onto the copy, each with whatever it bears.
      * @see crm:P111 added
      */
-    added: GluedOn[];
+    added: Patch[];
     /**
      * @see crm:P21 had general purpose
      */
@@ -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'] === '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))
@@ -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'] === 'GluedOn')
-        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' }));
 };
 /**