linked-rolls 0.5.0 → 0.5.1

package/lib/RollCopy.js

@@ -1,77 +1,10 @@
-import { AtonParser } from "./aton/AtonParser";
 import { v4 } from "uuid";
-import { read } from "midifile-ts";
-import { asSpans } from "./asMIDISpans";
-import { welteT100 } from "./TrackerBar";
-import { assignReference, idsOf } from "./Assumption";
+import { welteT100 } from "./systems/welteT100/bar";
+import { assignReference } from "./Assumption";
 export const rollConditions = [
     'general',
     'paper-stretch'
 ];
-export const applyShift = (shift, copy) => {
-    if (copy.ops.includes('shifted'))
-        return;
-    const to = copy.features;
-    for (const event of to) {
-        event.horizontal.from += shift.horizontal;
-        if (event.horizontal.to) {
-            event.horizontal.to += shift.horizontal;
-        }
-        event.vertical.from += shift.vertical;
-        if (event.vertical.to) {
-            event.vertical.to += shift.vertical;
-        }
-    }
-    copy.ops = [...copy.ops, 'shifted'];
-    copy.measurements.shift = shift;
-};
-export const applyStretch = (paperStretch, copy) => {
-    if (copy.ops.includes('stretched'))
-        return;
-    const stretch = paperStretch.factor;
-    const to = copy.features;
-    for (const event of to) {
-        event.horizontal.from *= stretch;
-        if (event.horizontal.to) {
-            event.horizontal.to *= stretch;
-        }
-    }
-    copy.ops = [...copy.ops, 'stretched'];
-    copy.conditions.push(paperStretch);
-};
-/** Takes the shift off the copy's features again, as far as one was applied. */
-export const revertShift = (copy) => {
-    const shift = copy.measurements.shift;
-    if (!copy.ops.includes('shifted') || !shift)
-        return;
-    copy.features.forEach(feature => {
-        feature.horizontal.from -= shift.horizontal;
-        if (feature.horizontal.to) {
-            feature.horizontal.to -= shift.horizontal;
-        }
-        feature.vertical.from -= shift.vertical;
-        if (feature.vertical.to) {
-            feature.vertical.to -= shift.vertical;
-        }
-    });
-    copy.ops = copy.ops.filter(op => op !== 'shifted');
-    delete copy.measurements.shift;
-};
-const isPaperStretch = (condition) => condition.conditionType === 'paper-stretch';
-/** Takes the stretch off the copy's features again, as far as one was applied. */
-export const revertStretch = (copy) => {
-    const stretch = copy.conditions.find(isPaperStretch);
-    if (!copy.ops.includes('stretched') || !stretch)
-        return;
-    copy.features.forEach(feature => {
-        feature.horizontal.from /= stretch.factor;
-        if (feature.horizontal.to) {
-            feature.horizontal.to /= stretch.factor;
-        }
-    });
-    copy.ops = copy.ops.filter(op => op !== 'stretched');
-    copy.conditions = copy.conditions.filter(condition => !isPaperStretch(condition));
-};
 /**
  * Reads the features of a copy as the tracker bar would read them.
  * Holes on a position the bar does not read carry no symbol and are
@@ -131,237 +64,3 @@ export const calibrationOf = (copy) => {
         shift: 0
     };
 };
-/** Values in these files carry their unit as a suffix, e.g. "37.7646px". */
-const px = (value) => parseFloat(value);
-/** The parser writes one record as an object and several as an array. */
-const listOf = (value) => value === undefined ? [] : Array.isArray(value) ? value : [value];
-/**
- * Holes the parser set aside as suspicious after it had already chained
- * them into a note: the head of such a chain is usually a punch that
- * came out a little short, and leaving it out would lose the whole
- * chain. They carry no track number of their own, so the column says
- * which track they sit on.
- */
-const chainedBadHoles = (holes, calibration) => holes
-    .filter(hole => hole.NOTE_ATTACK && hole.OFF_TIME)
-    .map(hole => ({
-    ...hole,
-    TRACKER_HOLE: `${Math.round((px(hole.CENTROID_COL) - calibration.offset) / calibration.separation)}`
-}));
-const millimeters = (pixels, dpi) => pixels / dpi * 25.4;
-const median = (values) => {
-    const sorted = [...values].sort((a, b) => a - b);
-    const middle = Math.floor(sorted.length / 2);
-    return sorted.length % 2 ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2;
-};
-const mostFrequent = (values) => {
-    const counts = values.reduce((acc, value) => acc.set(value, (acc.get(value) || 0) + 1), new Map());
-    return [...counts].sort(([, a], [, b]) => b - a)[0]?.[0];
-};
-/**
- * Only the first hole of a chain carries an attack and an off time;
- * the rest continue it. The rewind perforation carries neither, and it
- * is the last thing punched on the roll, so whatever the holes past the
- * final musical attack sit on is the rewind track.
- */
-const rewindTrackIn = (holes) => {
-    const lastMusical = holes.findLastIndex(hole => hole.NOTE_ATTACK);
-    const trailing = holes.slice(lastMusical + 1).map(hole => +hole.TRACKER_HOLE);
-    return mostFrequent(trailing);
-};
-/**
- * The phase of the tracker grid within the image. The analysis file
- * usually states it; where it does not, the holes themselves give it away,
- * since each sits close to the centre of its column.
- */
-const gridOffsetOf = (holes, separation, stated) => {
-    if (stated !== undefined)
-        return px(stated);
-    return median(holes.map(hole => px(hole.CENTROID_COL) - +hole.TRACKER_HOLE * separation));
-};
-const punchDiameterOf = (holes, dpi) => {
-    const circular = holes
-        .filter(hole => px(hole.CIRCULARITY) > 0.95)
-        .map(hole => millimeters(px(hole.PERIMETER), dpi) / Math.PI);
-    if (!circular.length)
-        return undefined;
-    return circular.reduce((sum, diameter) => sum + diameter, 0) / circular.length;
-};
-/**
- * The image service Stanford keeps for a scan, and a crop of a
- * feature from it.
- */
-const stanfordScan = (druid) => ({
-    scan: `https://stacks.stanford.edu/image/iiif/${druid}%2F${druid}_0001/`,
-    depictionOf: (column, row, width, height) => `https://stacks.stanford.edu/image/iiif/${druid}/${druid}_0001/${column},${row},${width},${height}/128,/270/default.jpg`
-});
-/**
- * The software behind an analysis and when it was run, as the
- * analysis file states them.
- */
-const measuredByOf = (rollinfo) => {
-    const date = new Date(rollinfo.ANALYSIS_DATE);
-    if (!rollinfo.HOLE_SOFTWARE || isNaN(date.getTime()))
-        return undefined;
-    return {
-        software: rollinfo.HOLE_SOFTWARE,
-        version: rollinfo.SOFTWARE_DATE ?? '',
-        date
-    };
-};
-export function readFromStanfordAton(atonString, { trackShift, bar = welteT100, scan } = {}) {
-    const parser = new AtonParser();
-    const json = parser.parse(atonString);
-    const holes = json.ROLLINFO.HOLES.HOLE;
-    const druid = json.ROLLINFO.DRUID;
-    const stanford = druid ? stanfordScan(druid) : undefined;
-    const separation = px(json.ROLLINFO.HOLE_SEPARATION);
-    const dpi = parseFloat(json.ROLLINFO.LENGTH_DPI);
-    const measuredBy = measuredByOf(json.ROLLINFO);
-    const rewindTrack = rewindTrackIn(holes);
-    const shift = trackShift
-        ?? (rewindTrack === undefined ? 0 : bar.rewindTrack - rewindTrack);
-    const calibration = {
-        unit: 'px',
-        offset: gridOffsetOf(holes, separation, json.ROLLINFO.HOLE_OFFSET),
-        separation,
-        shift
-    };
-    const punchDiameter = punchDiameterOf(holes, dpi);
-    const chains = [...holes, ...chainedBadHoles(listOf(json.ROLLINFO.BADHOLES?.HOLE), calibration)]
-        .filter(hole => hole.NOTE_ATTACK && hole.OFF_TIME)
-        .sort((a, b) => px(a.NOTE_ATTACK) - px(b.NOTE_ATTACK));
-    const features = chains
-        .map((hole) => {
-        const attack = px(hole.NOTE_ATTACK);
-        const release = px(hole.OFF_TIME);
-        const column = px(hole.ORIGIN_COL);
-        const columnWidth = px(hole.WIDTH_COL);
-        return {
-            type: 'Hole',
-            id: v4(),
-            ...(stanford && {
-                depiction: stanford.depictionOf(column, attack, columnWidth, release - attack)
-            }),
-            vertical: {
-                from: +hole.TRACKER_HOLE + shift,
-                unit: 'track'
-            },
-            horizontal: {
-                unit: 'mm',
-                from: millimeters(attack, dpi),
-                to: millimeters(release, dpi)
-            }
-        };
-    });
-    return {
-        type: 'RollCopy',
-        id: v4(),
-        ops: [],
-        conditions: [],
-        keeper: { name: '', sameAs: [] },
-        modifications: [],
-        ...((scan ?? stanford) && { scan: scan ?? stanford?.scan }),
-        measurements: {
-            dimensions: {
-                width: millimeters(px(json.ROLLINFO.ROLL_WIDTH), dpi),
-                height: millimeters(px(json.ROLLINFO.IMAGE_LENGTH), dpi),
-                unit: 'mm'
-            },
-            ...(punchDiameter !== undefined && {
-                punchDiameter: { value: punchDiameter, unit: 'mm' }
-            }),
-            holeSeparation: {
-                value: separation,
-                unit: 'px'
-            },
-            margins: {
-                treble: px(json.ROLLINFO.HARD_MARGIN_TREBLE),
-                bass: px(json.ROLLINFO.HARD_MARGIN_BASS),
-                unit: 'px'
-            },
-            trackCalibration: calibration,
-            ...(measuredBy && { measuredBy })
-        },
-        features
-    };
-}
-/**
- * How a MIDI key number in one of Spencer Chase's roll files names a
- * tracker bar track.
- *
- * The note block follows the obvious rule, `pitch - 13`, which puts
- * track 11 on MIDI 24 as the T100 compass requires. The bass expression
- * block does not: it reads two tracks high, and subtracting two is what
- * has made these files come out right so far.
- *
- * The boundary between the two rules is unresolved. Taken literally the
- * rules leave tracks 8 and 9 unreachable and jump from track 7 to track 10,
- * which no lateral offset can produce, so at least one of them is
- * approximate. Settling it needs a Spencer file whose expression holes
- * can be checked against the roll, hence the option to override.
- */
-export const spencerTrackOf = (pitch) => {
-    const track = pitch - 13;
-    return track < 10 ? track - 2 : track;
-};
-const MM_PER_FOOT = 304.8;
-/**
- * Spencer Chase's rolls seem to be scanned at a roll speed of
- * 83 (=8.3 feet per minute). A scanner feeds the paper at one
- * speed, so time in his files is proportional to place.
- */
-export const SPENCER_FEET_PER_MINUTE = 8.3;
-/** Place on the roll in mm after `seconds` at a constant `feetPerMinute`. */
-export const atConstantSpeed = (feetPerMinute) => (seconds) => feetPerMinute * MM_PER_FOOT / 60 * seconds;
-export function readFromSpencerMIDI(midiBuffer, placeAt = atConstantSpeed(SPENCER_FEET_PER_MINUTE), trackOf = spencerTrackOf) {
-    const features = asSpans(read(midiBuffer))
-        .filter(span => span.type === 'note')
-        .map((span) => ({
-        type: 'Hole',
-        id: v4(),
-        vertical: {
-            from: trackOf(span.pitch),
-            unit: 'track'
-        },
-        horizontal: {
-            from: placeAt(span.onsetMs / 1000),
-            to: placeAt(span.offsetMs / 1000),
-            unit: 'mm'
-        }
-    }));
-    return {
-        type: 'RollCopy',
-        id: v4(),
-        ops: [],
-        conditions: [],
-        keeper: { name: '', sameAs: [] },
-        measurements: {},
-        modifications: [],
-        features
-    };
-}
-/**
- * Moves features across the tracker bar. What the new position means is
- * left to the tracker bar to say, since meaning belongs to the symbols
- * read off a copy rather than to the holes themselves.
- */
-export function shiftVertically(features, amount) {
-    features.forEach(feature => {
-        feature.vertical.from += amount;
-        if (feature.vertical.to !== undefined) {
-            feature.vertical.to += amount;
-        }
-    });
-}
-export const findCopiesCarrying = (sources, symbol) => {
-    const result = new Set();
-    for (const feature of idsOf(symbol.carriers)) {
-        for (const copy of sources) {
-            if (copy.features.findIndex(f => f.id === feature)) {
-                result.add(copy.id);
-            }
-        }
-    }
-    return result;
-};

package/lib/TrackerBar.d.ts

@@ -1,4 +1,4 @@
-import type { Concept } from "./Edition";
+import type { Concept } from "./Agent";
 import { Expression, Note } from "./Symbol";
 /**
  * What a tracker bar position does: sound a note, or operate one of
@@ -58,16 +58,18 @@ export interface TrackerBar {
 export declare const systemOf: (bar: TrackerBar) => Concept;
 /** The identifier of a system the type vocabulary knows, from its concept. */
 export declare const systemIdOf: (system: Concept | undefined) => string | undefined;
-/**
- * The commands of the Welte-Mignon T-100, as its tracker bar reads them.
- */
-export declare const welteT100ExpressionTypes: readonly ["SustainPedalOn", "SustainPedalOff", "SoftPedalOn", "SoftPedalOff", "MezzoforteOff", "MezzoforteOn", "SlowCrescendoOn", "SlowCrescendoOff", "ForzandoOn", "ForzandoOff", "MotorOff", "MotorOn", "Rewind", "ElectricCutOff"];
-export type WelteT100ExpressionType = typeof welteT100ExpressionTypes[number];
-/**
- * Welte-Mignon T-100 ("red Welte"), cf. Hagmann, pp. 75 and 178.
- *
- * The note block spans 80 positions from C1 to g⁴, i.e. MIDI 24 to 103.
- * The expression valves are duplicated, bass below the note block and
- * treble above it, in mirrored order.
- */
-export declare const welteT100: TrackerBar;
+export interface TrackerBarSpec {
+    id: string;
+    name: string;
+    width: number;
+    trackCount: number;
+    /** The contiguous block of note positions. */
+    notes: {
+        from: number;
+        to: number;
+        lowestPitch: number;
+    };
+    /** Every position outside the note block, keyed by track. */
+    expressions: ReadonlyMap<number, string>;
+}
+export declare const describeTrackerBar: (spec: TrackerBarSpec) => TrackerBar;

package/lib/TrackerBar.js

@@ -9,7 +9,7 @@ const areasOf = ({ notes, trackCount }) => [
     { role: 'treble-expression', from: notes.to + 1, to: trackCount }
 ];
 const scopeOf = (role) => role === 'bass-expression' ? 'bass' : 'treble';
-const describe = (spec) => {
+export const describeTrackerBar = (spec) => {
     const areas = areasOf(spec);
     const roleOf = (track) => areas.find(area => track >= area.from && track <= area.to)?.role;
     const meaningOf = (track) => {
@@ -44,58 +44,3 @@ const describe = (spec) => {
         roleOf
     };
 };
-/**
- * The commands of the Welte-Mignon T-100, as its tracker bar reads them.
- */
-export const welteT100ExpressionTypes = [
-    'SustainPedalOn',
-    'SustainPedalOff',
-    'SoftPedalOn',
-    'SoftPedalOff',
-    'MezzoforteOff',
-    'MezzoforteOn',
-    'SlowCrescendoOn',
-    'SlowCrescendoOff',
-    'ForzandoOn',
-    'ForzandoOff',
-    'MotorOff',
-    'MotorOn',
-    'Rewind',
-    'ElectricCutOff'
-];
-/**
- * Welte-Mignon T-100 ("red Welte"), cf. Hagmann, pp. 75 and 178.
- *
- * The note block spans 80 positions from C1 to g⁴, i.e. MIDI 24 to 103.
- * The expression valves are duplicated, bass below the note block and
- * treble above it, in mirrored order.
- */
-export const welteT100 = describe({
-    id: 'welte-t100',
-    name: 'Welte-Mignon T100',
-    width: 328,
-    trackCount: 100,
-    notes: { from: 11, to: 90, lowestPitch: 24 },
-    expressions: new Map([
-        [1, 'MezzoforteOff'],
-        [2, 'MezzoforteOn'],
-        [3, 'SlowCrescendoOff'],
-        [4, 'SlowCrescendoOn'],
-        [5, 'ForzandoOff'],
-        [6, 'ForzandoOn'],
-        [7, 'SoftPedalOff'],
-        [8, 'SoftPedalOn'],
-        [9, 'MotorOff'],
-        [10, 'MotorOn'],
-        [91, 'Rewind'],
-        [92, 'ElectricCutOff'],
-        [93, 'SustainPedalOn'],
-        [94, 'SustainPedalOff'],
-        [95, 'ForzandoOn'],
-        [96, 'ForzandoOff'],
-        [97, 'SlowCrescendoOn'],
-        [98, 'SlowCrescendoOff'],
-        [99, 'MezzoforteOn'],
-        [100, 'MezzoforteOff']
-    ])
-});

package/lib/alignment.d.ts

@@ -0,0 +1,21 @@
+import { ObjectAssumption } from "./Assumption";
+import { AnyFeature } from "./Feature";
+import { PaperStretch, RollCopy, Shift } from "./RollCopy";
+import { TrackerBar } from "./TrackerBar";
+export declare const applyShift: (shift: Shift, copy: RollCopy) => void;
+export declare const applyStretch: (paperStretch: ObjectAssumption<PaperStretch>, copy: RollCopy) => void;
+/** Takes the shift off the copy's features again, as far as one was applied. */
+export declare const revertShift: (copy: RollCopy) => void;
+/** Takes the stretch off the copy's features again, as far as one was applied. */
+export declare const revertStretch: (copy: RollCopy) => void;
+type AlignmentResult = {
+    /** Shift in mm, applied before the stretch. */
+    shift: number;
+    stretch: number;
+};
+/**
+ * Align two rolls by computing independent linear fits of each roll's note-onset positions
+ * using only the first and last segments, then deriving a transform x2 = (x1 + shift) * stretch.
+ */
+export declare function alignFeatures(rollA: AnyFeature[], rollB: AnyFeature[], bar?: TrackerBar): AlignmentResult;
+export {};

package/lib/alignment.js

@@ -0,0 +1,117 @@
+import { welteT100 } from "./systems/welteT100/bar";
+export const applyShift = (shift, copy) => {
+    if (copy.ops.includes('shifted'))
+        return;
+    copy.features.forEach(feature => {
+        feature.horizontal.from += shift.horizontal;
+        if (feature.horizontal.to) {
+            feature.horizontal.to += shift.horizontal;
+        }
+        feature.vertical.from += shift.vertical;
+        if (feature.vertical.to) {
+            feature.vertical.to += shift.vertical;
+        }
+    });
+    copy.ops = [...copy.ops, 'shifted'];
+    copy.measurements.shift = shift;
+};
+export const applyStretch = (paperStretch, copy) => {
+    if (copy.ops.includes('stretched'))
+        return;
+    const stretch = paperStretch.factor;
+    copy.features.forEach(feature => {
+        feature.horizontal.from *= stretch;
+        if (feature.horizontal.to) {
+            feature.horizontal.to *= stretch;
+        }
+    });
+    copy.ops = [...copy.ops, 'stretched'];
+    copy.conditions.push(paperStretch);
+};
+/** Takes the shift off the copy's features again, as far as one was applied. */
+export const revertShift = (copy) => {
+    const shift = copy.measurements.shift;
+    if (!copy.ops.includes('shifted') || !shift)
+        return;
+    copy.features.forEach(feature => {
+        feature.horizontal.from -= shift.horizontal;
+        if (feature.horizontal.to) {
+            feature.horizontal.to -= shift.horizontal;
+        }
+        feature.vertical.from -= shift.vertical;
+        if (feature.vertical.to) {
+            feature.vertical.to -= shift.vertical;
+        }
+    });
+    copy.ops = copy.ops.filter(op => op !== 'shifted');
+    delete copy.measurements.shift;
+};
+const isPaperStretch = (condition) => condition.conditionType === 'paper-stretch';
+/** Takes the stretch off the copy's features again, as far as one was applied. */
+export const revertStretch = (copy) => {
+    const stretch = copy.conditions.find(isPaperStretch);
+    if (!copy.ops.includes('stretched') || !stretch)
+        return;
+    copy.features.forEach(feature => {
+        feature.horizontal.from /= stretch.factor;
+        if (feature.horizontal.to) {
+            feature.horizontal.to /= stretch.factor;
+        }
+    });
+    copy.ops = copy.ops.filter(op => op !== 'stretched');
+    copy.conditions = copy.conditions.filter(condition => !isPaperStretch(condition));
+};
+const isNoteOn = (bar) => (feature) => {
+    return feature.type === 'Hole' && bar.meaningOf(feature.vertical.from)?.type === 'note';
+};
+/**
+ * Fit a line: position = alpha * index + beta via least squares.
+ */
+function fitIndexToPosition(indices, positions) {
+    const n = indices.length;
+    const meanIdx = indices.reduce((s, i) => s + i, 0) / n;
+    const meanPos = positions.reduce((s, p) => s + p, 0) / n;
+    let num = 0;
+    let den = 0;
+    for (let i = 0; i < n; i++) {
+        const d = indices[i] - meanIdx;
+        num += d * (positions[i] - meanPos);
+        den += d * d;
+    }
+    const alpha = den === 0 ? 1 : num / den;
+    const beta = meanPos - alpha * meanIdx;
+    return { alpha, beta };
+}
+/**
+ * Selects the first and last N elements of an array (or fewer if length is smaller).
+ */
+function selectEnds(arr, count) {
+    const n = arr.length;
+    if (count * 2 >= n)
+        return arr.slice();
+    return arr.slice(0, count).concat(arr.slice(n - count, n));
+}
+/**
+ * Align two rolls by computing independent linear fits of each roll's note-onset positions
+ * using only the first and last segments, then deriving a transform x2 = (x1 + shift) * stretch.
+ */
+export function alignFeatures(rollA, rollB, bar = welteT100) {
+    // 1. Extract note-onset positions
+    const isNote = isNoteOn(bar);
+    const allXA = rollA.filter(isNote).map(f => f.horizontal.from);
+    const allXB = rollB.filter(isNote).map(f => f.horizontal.from);
+    // 2. Determine segment size (e.g. 10% of notes, min 5)
+    const segCount = Math.max(5, Math.floor(allXA.length * 0.1));
+    // 3. Select only first and last segments
+    const XA = selectEnds(allXA, segCount);
+    const idxA = XA.map((_, i) => i);
+    const XB = selectEnds(allXB, segCount);
+    const idxB = XB.map((_, i) => i);
+    // 4. Fit index->position for each roll on selected ends
+    const { alpha: alphaA, beta: betaA } = fitIndexToPosition(idxA, XA);
+    const { alpha: alphaB, beta: betaB } = fitIndexToPosition(idxB, XB);
+    // 5. Derive stretch and shift such that x2 = (x1 + shift) * stretch
+    const stretch = alphaB / alphaA;
+    const shift = betaB / stretch - betaA;
+    return { stretch, shift };
+}

package/lib/constraints.d.ts

@@ -0,0 +1,27 @@
+import { EditionView } from "./EditionView";
+import { TrackerBar } from "./TrackerBar";
+export type ConstraintProblem = {
+    version: string;
+    symbol: string;
+    problem: 'alignment-reference-missing' | 'before-reference-missing' | 'after-reference-missing' | 'placed-relative-to-itself' | 'placed-several-ways' | 'partner-missing' | 'paired-with-itself' | 'in-several-pairs' | 'pair-placed-on-both-sides';
+};
+/**
+ * Where the placements and pairings of the edition cannot hold as
+ * stated, version by version: a reference or partner absent from the
+ * version, a perforation placed relative to itself or in several ways
+ * at once, one claimed by several pairs, or a pair whose members are
+ * both placed and so cannot keep their distance and follow their
+ * references at once.
+ */
+export declare const constraintProblems: (view: EditionView) => ConstraintProblem[];
+export type UnknownExpressionType = {
+    version: string;
+    symbol: string;
+    expressionType: string;
+};
+/**
+ * The expressions of the edition whose type the tracker bar does not
+ * read, version by version. The roll names its system; a type from
+ * another system, or a misspelt one, means nothing on it.
+ */
+export declare const unknownExpressionTypes: (view: EditionView, bar: TrackerBar) => UnknownExpressionType[];

package/lib/constraints.js

@@ -0,0 +1,61 @@
+import { idOf } from "./Assumption";
+import { isPerforation, pairsAmong, placementsOf } from "./Symbol";
+const missingReference = {
+    alignedWith: 'alignment-reference-missing',
+    before: 'before-reference-missing',
+    after: 'after-reference-missing'
+};
+const problemsIn = (version, perforations) => {
+    const ids = new Set(perforations.map(p => p.id));
+    const report = (symbol, problem) => ({ version, symbol, problem });
+    const missingReferences = perforations
+        .flatMap(p => placementsOf(p)
+        .filter(({ reference }) => !ids.has(idOf(reference)))
+        .map(({ relation }) => report(p.id, missingReference[relation])));
+    const selfPlaced = perforations
+        .filter(p => placementsOf(p).some(({ reference }) => idOf(reference) === p.id))
+        .map(p => report(p.id, 'placed-relative-to-itself'));
+    const placedSeveralWays = perforations
+        .filter(p => placementsOf(p).length > 1)
+        .map(p => report(p.id, 'placed-several-ways'));
+    const missingPartners = perforations
+        .filter(p => p.pairedWith && !ids.has(idOf(p.pairedWith)))
+        .map(p => report(p.id, 'partner-missing'));
+    const selfPaired = perforations
+        .filter(p => p.pairedWith && idOf(p.pairedWith) === p.id)
+        .map(p => report(p.id, 'paired-with-itself'));
+    const pairs = pairsAmong(perforations);
+    const pairsOf = (p) => pairs.filter(pair => pair.includes(p));
+    const inSeveralPairs = perforations
+        .filter(p => pairsOf(p).length > 1)
+        .map(p => report(p.id, 'in-several-pairs'));
+    const placedOnBothSides = pairs
+        .filter(([one, other]) => placementsOf(one).length > 0 && placementsOf(other).length > 0)
+        .flatMap(pair => pair.map(p => report(p.id, 'pair-placed-on-both-sides')));
+    return [
+        ...missingReferences, ...selfPlaced, ...placedSeveralWays,
+        ...missingPartners, ...selfPaired, ...inSeveralPairs, ...placedOnBothSides
+    ];
+};
+/**
+ * Where the placements and pairings of the edition cannot hold as
+ * stated, version by version: a reference or partner absent from the
+ * version, a perforation placed relative to itself or in several ways
+ * at once, one claimed by several pairs, or a pair whose members are
+ * both placed and so cannot keep their distance and follow their
+ * references at once.
+ */
+export const constraintProblems = (view) => view.edition.versions.flatMap(version => problemsIn(version.id, view.snapshot(version.id).filter(isPerforation)));
+const isExpression = (symbol) => symbol.type === 'expression';
+/**
+ * The expressions of the edition whose type the tracker bar does not
+ * read, version by version. The roll names its system; a type from
+ * another system, or a misspelt one, means nothing on it.
+ */
+export const unknownExpressionTypes = (view, bar) => {
+    const known = new Set(bar.expressionTypes);
+    return view.edition.versions.flatMap(version => view.snapshot(version.id)
+        .filter(isExpression)
+        .filter(symbol => !known.has(symbol.expressionType))
+        .map(symbol => ({ version: version.id, symbol: symbol.id, expressionType: symbol.expressionType })));
+};