linked-rolls 0.70.0 → 0.72.0

package/lib/filiation/presence.d.ts

@@ -0,0 +1,50 @@
+/** Which copies carry which collated reading, which lack it, and where a copy cannot say. */
+import { Edition } from "../model/Edition.js";
+import { HorizontalSpan } from "../model/Feature.js";
+import { Millimeters } from "../model/Quantity.js";
+import { TrackerBar, TrackMeaning } from "../systems/TrackerBar.js";
+import { CopyCollation } from "./readings.js";
+/**
+ * What a copy says of a reading: it carries it, it lacks it, or it
+ * cannot tell, because it is torn there, its text does not reach so
+ * far, or its system has no word for the reading.
+ * @category Filiation
+ */
+export type Presence = 'present' | 'absent' | 'unknown';
+/**
+ * The presence of every collated reading in every copy, and the readings
+ * that are ineffective in a copy carrying them.
+ * @category Filiation
+ */
+export interface PresenceMatrix {
+    copies: string[];
+    /** By reading, by copy. */
+    presence: Record<string, Record<string, Presence>>;
+    /** The readings that are ineffective where a copy carries them: a latched function set again, or cancelled again. */
+    redundant: string[];
+}
+/** How far beyond the end of its text, or the edge of a tear, a copy cannot say what it lacks. */
+export declare const defaultMargin: import("../index.js").Quantity<"mm">;
+/**
+ * The readings a latched function makes no use of in the text given: a
+ * command setting what is set already, or cancelling what is cancelled.
+ * Commands at one place are taken cancel first, as the valves take them.
+ * @category Filiation
+ */
+export declare const ineffectiveAmong: (bar: TrackerBar, readings: readonly {
+    id: string;
+    meaning: TrackMeaning;
+    place: HorizontalSpan;
+}[]) => Set<string>;
+/**
+ * The presence of every reading in every copy of the collation.
+ *
+ * A copy lacking a reading is taken to lack it only where it could show
+ * it: inside its text, away from its tears, and in its own system's
+ * words. A copy re-cut for a system that holds what another latches
+ * carries a latched pair where one of its held commands stands for it;
+ * where it holds the same function nearby without standing for the pair,
+ * or where the pair was ineffective anyway, it cannot say.
+ * @category Filiation
+ */
+export declare const presenceIn: (edition: Pick<Edition, 'copies'>, collation: CopyCollation, margin?: Millimeters) => PresenceMatrix;

package/lib/filiation/presence.js

@@ -0,0 +1,122 @@
+import { barOf, tearsOf } from "../model/RollCopy.js";
+import { mm } from "../model/Quantity.js";
+import { reads } from "./readings.js";
+/** How far beyond the end of its text, or the edge of a tear, a copy cannot say what it lacks. */
+export const defaultMargin = mm(3);
+/** How far from a held command of the same function a copy cannot say whether it holds a latched pair. */
+const HELD_REACH = mm(5);
+/** The function a latching command sets or cancels, and whether it sets it, or nothing for any other. */
+const latchOf = (bar, meaning) => {
+    if (meaning.type !== 'expression')
+        return undefined;
+    const operation = bar.operationOf(meaning.expressionType);
+    if (!operation || operation.spelling === 'held')
+        return undefined;
+    return {
+        latch: operation.sided ? `${operation.operates} ${meaning.scope}` : operation.operates,
+        on: operation.spelling === 'on'
+    };
+};
+/** The function a command operates, the side included where it counts, whatever its spelling. */
+const functionOf = (bar, meaning) => {
+    if (meaning.type !== 'expression')
+        return undefined;
+    const operation = bar.operationOf(meaning.expressionType);
+    return operation && (operation.sided ? `${operation.operates} ${meaning.scope}` : operation.operates);
+};
+/**
+ * The readings a latched function makes no use of in the text given: a
+ * command setting what is set already, or cancelling what is cancelled.
+ * Commands at one place are taken cancel first, as the valves take them.
+ * @category Filiation
+ */
+export const ineffectiveAmong = (bar, readings) => {
+    const byLatch = new Map();
+    for (const reading of readings) {
+        const latch = latchOf(bar, reading.meaning);
+        if (!latch)
+            continue;
+        const commands = byLatch.get(latch.latch) ?? [];
+        commands.push({ id: reading.id, at: reading.place.from, on: latch.on });
+        byLatch.set(latch.latch, commands);
+    }
+    const ineffective = new Set();
+    for (const commands of byLatch.values()) {
+        commands.sort((a, b) => a.at - b.at || Number(a.on) - Number(b.on));
+        let on = false;
+        for (const command of commands) {
+            if (command.on === on)
+                ineffective.add(command.id);
+            on = command.on;
+        }
+    }
+    return ineffective;
+};
+const within = (at, span, margin) => at >= span.from - margin && at <= span.to + margin;
+/**
+ * The presence of every reading in every copy of the collation.
+ *
+ * A copy lacking a reading is taken to lack it only where it could show
+ * it: inside its text, away from its tears, and in its own system's
+ * words. A copy re-cut for a system that holds what another latches
+ * carries a latched pair where one of its held commands stands for it;
+ * where it holds the same function nearby without standing for the pair,
+ * or where the pair was ineffective anyway, it cannot say.
+ * @category Filiation
+ */
+export const presenceIn = (edition, collation, margin = defaultMargin) => {
+    const copyOf = new Map(edition.copies.map(copy => [copy.id, copy]));
+    const barFor = new Map(collation.copies.map(id => [id, barOf(copyOf.get(id))]));
+    const placeOf = new Map();
+    for (const id of collation.copies) {
+        for (const feature of copyOf.get(id).production?.produced ?? []) {
+            if ('horizontal' in feature && feature.horizontal)
+                placeOf.set(feature.id, feature.horizontal);
+        }
+    }
+    const redundant = new Set();
+    for (const copy of collation.copies) {
+        const carried = collation.readings.flatMap(reading => {
+            const index = reading.copies.indexOf(copy);
+            if (index < 0)
+                return [];
+            return [{ id: reading.id, meaning: reading.meaning, place: placeOf.get(reading.carriers[index]) ?? reading.place }];
+        });
+        ineffectiveAmong(barFor.get(copy), carried).forEach(id => redundant.add(id));
+    }
+    const standsFor = new Map();
+    for (const recoding of collation.recodings) {
+        for (const replaced of recoding.replaced)
+            standsFor.set(replaced, [...(standsFor.get(replaced) ?? []), ...recoding.by]);
+    }
+    const copiesOf = new Map(collation.readings.map(reading => [reading.id, new Set(reading.copies)]));
+    const heldBy = new Map(collation.copies.map(copy => [copy, collation.readings.filter(reading => reading.meaning.type === 'expression' && copiesOf.get(reading.id).has(copy))]));
+    const tears = new Map(collation.copies.map(copy => [copy, tearsOf(copyOf.get(copy)).map(tear => tear.horizontal)]));
+    const presenceOf = (reading, copy) => {
+        if (copiesOf.get(reading.id).has(copy))
+            return 'present';
+        const at = reading.place.from;
+        if (!within(at, collation.extent[copy], margin))
+            return 'unknown';
+        if (tears.get(copy).some(tear => within(at, tear, margin)))
+            return 'unknown';
+        const bar = barFor.get(copy);
+        if (reads(bar, reading.meaning))
+            return 'absent';
+        if (reading.meaning.type !== 'expression')
+            return 'unknown';
+        if ((standsFor.get(reading.id) ?? []).some(by => copiesOf.get(by)?.has(copy)))
+            return 'present';
+        if (redundant.has(reading.id))
+            return 'unknown';
+        const wanted = functionOf(barFor.get(reading.copies[0]), reading.meaning);
+        const held = heldBy.get(copy).some(other => functionOf(bar, other.meaning) === wanted
+            && at >= other.place.from - HELD_REACH && at <= other.place.to + HELD_REACH);
+        return held ? 'unknown' : 'absent';
+    };
+    const presence = {};
+    for (const reading of collation.readings) {
+        presence[reading.id] = Object.fromEntries(collation.copies.map(copy => [copy, presenceOf(reading, copy)]));
+    }
+    return { copies: [...collation.copies], presence, redundant: [...redundant].sort() };
+};

package/lib/filiation/proposal.d.ts

@@ -0,0 +1,132 @@
+/**
+ * A stemma proposed from the copies alone: which versions there are,
+ * lost ones included, how they derive from each other, and which
+ * readings each inserts and deletes.
+ */
+import { Edition } from "../model/Edition.js";
+import { Millimeters } from "../model/Quantity.js";
+import { CopyCollation, Recoding } from "./readings.js";
+import { PresenceMatrix } from "./presence.js";
+import { Costs, Scored, Support } from "./search.js";
+/**
+ * How near a reading of the same kind on the other side of the root
+ * makes a reading on the less refined side a moved one, where nothing
+ * else is said. Hits up to about this distance are more than chance; a
+ * wider window agrees with the edition of WM 225 more often, but largely
+ * by convention.
+ * @category Filiation
+ */
+export declare const defaultMovedWithin: import("../index.js").Quantity<"mm">;
+/**
+ * What a proposal is computed with. Every value has a default, the one
+ * the edition of WM 225 is reproduced with.
+ * @category Filiation
+ */
+export interface FiliationOptions {
+    /** The copies whose features are collated; by default every copy with features of its punching. */
+    copies?: readonly string[];
+    /** What the search counts against a stemma (`defaultCosts`). */
+    costs?: Partial<Costs>;
+    /**
+     * How near a reading of the same kind on the other side of the root
+     * makes a reading on the less refined side a moved one (`defaultMovedWithin`).
+     */
+    movedWithin?: Millimeters;
+    /** How far beyond its text, or the edge of a tear, a copy cannot say what it lacks (3 mm). */
+    margin?: Millimeters;
+    /** Whether the edits the editor wrote hold their versions to what they insert and delete (yes). */
+    pin?: boolean;
+    /** How many runners-up to report (5). */
+    alternatives?: number;
+}
+/**
+ * A version the proposal posits.
+ * @category Filiation
+ */
+export interface ProposedVersion {
+    /** A name within the proposal: the versions are numbered from the root down. */
+    id: string;
+    /** The copy carrying the version at first hand; none for a lost state. */
+    copy?: string;
+    /** The system the version is coded for, by its identifier. */
+    system: string;
+    /** The version it derives from, by its name within the proposal. */
+    parent?: string;
+    /** The version of the edition it stands for, where one does. */
+    version?: string;
+    /** The collated readings the version inserts. */
+    inserts: string[];
+    /** The collated readings the version deletes. */
+    deletes: string[];
+    /** The held commands that stand for a latched pair, among what the version inserts and deletes. */
+    recodings: Recoding[];
+    /** The readings the version holds that the copy carrying it lacks. */
+    deviations: string[];
+    /** The edits the editor wrote on `version` that the proposal keeps as they are. */
+    pinned: string[];
+}
+/**
+ * Why an edit the editor wrote is not kept.
+ * @category Filiation
+ */
+export type Unpinned = {
+    edit: string;
+    version: string;
+    reason: 'version-gone' | 'reading-gone' | 'contradicts-copies';
+};
+/**
+ * A stemma proposed from the copies, with what it rests on: the
+ * collation, the presence of every reading in every copy, the cost of
+ * the best stemma and of the runners-up, and the margin by which the
+ * copies decide each of its groupings.
+ * @category Filiation
+ */
+export interface StemmaProposal {
+    copies: string[];
+    costs: Costs;
+    movedWithin: Millimeters;
+    margin: Millimeters;
+    collation: CopyCollation;
+    matrix: PresenceMatrix;
+    /** From the root down. */
+    versions: ProposedVersion[];
+    /** The stemma in the notation `Scored` uses, the copies by siglum. */
+    notation: string;
+    cost: number;
+    /** How many admissible stemmata were scored. */
+    scored: number;
+    alternatives: Scored[];
+    supports: Support[];
+    /** The readings the stemma lets arise more than once, with the versions inserting them. */
+    conflicts: {
+        reading: string;
+        versions: string[];
+    }[];
+    /** The readings on the less refined side of the root taken for the base text, as moved or cleaned up by the other side. */
+    baseText: string[];
+    /** By collated reading, the symbol of the edition it stands for, where one does. */
+    symbols: Record<string, string>;
+    unpinned: Unpinned[];
+}
+/**
+ * Proposes a stemma from the copies.
+ *
+ * The copies are collated all at once (`collateCopies`), and every
+ * reading becomes a character that each copy has, lacks or cannot speak
+ * to (`presenceIn`). Every stemma of the copies that the systems admit,
+ * up to seven copies, is scored by what it has to let arise and be lost
+ * (`Costs`), and the least costly is taken, ties going to fewer lost
+ * states. On it, each reading arises in the latest version all copies
+ * carrying it descend from, and is deleted where a branch lacks it. A
+ * reading only the less refined side of the root carries is taken for
+ * the base text where the other side has it moved or cleaned up.
+ *
+ * Where the edition has versions already, a version of the proposal
+ * that a copy carries at first hand stands for the version that copy
+ * carries in the edition, and a lost one for the version inserting most
+ * of the same readings. An edit the editor wrote on such a version, one
+ * a collation would not have written, holds the version to what it
+ * inserts and deletes, unless the copies cannot be read so.
+ * @category Filiation
+ */
+export declare const proposeStemma: (edition: Edition, options?: FiliationOptions) => StemmaProposal;

package/lib/filiation/proposal.js

@@ -0,0 +1,376 @@
+import { barOf } from "../model/RollCopy.js";
+import { idOf } from "../model/Assumption.js";
+import { editsOf, insertedBy } from "../model/Version.js";
+import { mm } from "../model/Quantity.js";
+import { keyOf } from "../systems/TrackerBar.js";
+import { isCollationsOwn } from "../collation/Collation.js";
+import { versionsWitnessedBy } from "../analysis/witnesses.js";
+import { collateCopies, reads } from "./readings.js";
+import { defaultMargin, presenceIn } from "./presence.js";
+import { defaultCosts, searchStemmata, statesOf } from "./search.js";
+import { barNamed, transfersOf } from "./systems.js";
+import { MAX_COPIES } from "./trees.js";
+/**
+ * How near a reading of the same kind on the other side of the root
+ * makes a reading on the less refined side a moved one, where nothing
+ * else is said. Hits up to about this distance are more than chance; a
+ * wider window agrees with the edition of WM 225 more often, but largely
+ * by convention.
+ * @category Filiation
+ */
+export const defaultMovedWithin = mm(25);
+/** The copies with features of their own punching, in the order the edition lists them. */
+const transcribed = (edition) => edition.copies
+    .filter(copy => (copy.production?.produced ?? []).some(feature => feature.type === 'HoleChain'))
+    .map(copy => copy.id);
+const keyOfSymbol = (symbol) => symbol.type === 'text' ? undefined : keyOf(symbol);
+/**
+ * By collated reading, the symbol of the edition it stands for: the one
+ * of the same meaning sharing most of its carriers, each symbol given to
+ * one reading at most. A reading whose carriers grew or shrank keeps the
+ * symbol's name, so that a collation repeated does not rename what it
+ * finds again.
+ */
+const symbolsFor = (edition, readings) => {
+    const byCarrier = new Map();
+    for (const reading of readings) {
+        for (const carrier of reading.carriers)
+            byCarrier.set(carrier, [...(byCarrier.get(carrier) ?? []), reading]);
+    }
+    const candidates = [];
+    let order = 0;
+    for (const version of edition.versions) {
+        for (const symbol of insertedBy(version)) {
+            order++;
+            const key = keyOfSymbol(symbol);
+            if (!key)
+                continue;
+            const carriers = symbol.carriers.map(idOf);
+            const counts = new Map();
+            for (const carrier of carriers) {
+                for (const reading of byCarrier.get(carrier) ?? []) {
+                    if (reading.key === key)
+                        counts.set(reading, (counts.get(reading) ?? 0) + 1);
+                }
+            }
+            for (const [reading, shared] of counts) {
+                const exact = shared === carriers.length && shared === reading.carriers.length;
+                candidates.push({ symbol: symbol.id, reading: reading.id, shared, exact, order });
+            }
+        }
+    }
+    candidates.sort((a, b) => Number(b.exact) - Number(a.exact) || b.shared - a.shared || a.order - b.order || (a.reading < b.reading ? -1 : 1));
+    const symbols = {};
+    const taken = new Set();
+    for (const { symbol, reading } of candidates) {
+        if (taken.has(symbol) || symbols[reading])
+            continue;
+        symbols[reading] = symbol;
+        taken.add(symbol);
+    }
+    return symbols;
+};
+const childrenOf = (tree) => {
+    const children = Array.from({ length: tree.copy.length }, () => []);
+    tree.parent.forEach((parent, child) => { if (parent >= 0)
+        children[parent].push(child); });
+    return children;
+};
+/** The nodes from the root down, each before the nodes derived from it. */
+const fromRoot = (tree) => {
+    const children = childrenOf(tree);
+    const order = [];
+    const visit = (v) => {
+        order.push(v);
+        children[v].forEach(visit);
+    };
+    visit(tree.copy.length - 1);
+    return order;
+};
+const inserting = (tree, states, v) => states[v] && (tree.parent[v] < 0 || !states[tree.parent[v]]);
+const deleting = (tree, states, v) => !states[v] && tree.parent[v] >= 0 && states[tree.parent[v]];
+/**
+ * The readings on the less refined side of the root that the other side
+ * moved or cleaned up, rather than that this side added.
+ *
+ * Where the root has two branches, presence alone cannot tell a reading
+ * one branch added from a reading of the base text the other changed.
+ * Refinement orients the root: the branch whose copies carry fewer
+ * dynamic perforations is the earlier text. A reading only that branch
+ * carries is then taken for the base text where the other branch carries
+ * a reading of the same kind within the window and this branch does not
+ * (moved), or where it is ineffective (cleaned up, as redundancies are).
+ */
+const baseTextOf = (tree, readings, matrix, placement, held, within, systems) => {
+    const root = tree.copy.length - 1;
+    const children = childrenOf(tree)[root];
+    if (tree.copy[root] >= 0 || children.length !== 2)
+        return [];
+    const copiesBelow = (v) => matrix.copies.filter((_, c) => tree.below[v] & (1 << c));
+    const rootSystem = tree.system[root];
+    /** How many dynamic perforations the copies of the root's system below the node carry, on average. */
+    const densityOf = (v) => {
+        const copies = matrix.copies.filter((_, c) => (tree.below[v] & (1 << c)) && systems[c] === rootSystem);
+        if (copies.length === 0)
+            return Infinity;
+        const counts = copies.map(copy => readings.filter(reading => reading.meaning.type === 'expression' && matrix.presence[reading.id][copy] === 'present').length);
+        return counts.reduce((sum, count) => sum + count, 0) / counts.length;
+    };
+    const [one, other] = children;
+    const [side, refined] = densityOf(one) < densityOf(other) ? [one, other] : densityOf(other) < densityOf(one) ? [other, one] : [-1, -1];
+    if (side < 0)
+        return [];
+    const sideCopies = copiesBelow(side);
+    const refinedCopies = copiesBelow(refined);
+    const redundant = new Set(matrix.redundant);
+    const byKey = new Map();
+    for (const reading of readings)
+        byKey.set(reading.key, [...(byKey.get(reading.key) ?? []), reading]);
+    const moved = [];
+    for (const reading of readings) {
+        if (held.has(reading.id))
+            continue;
+        const states = placement.get(reading.id);
+        if (!inserting(tree, states, side))
+            continue;
+        const near = (byKey.get(reading.key) ?? []).some(other => other.id !== reading.id
+            && Math.abs(other.place.from - reading.place.from) <= within
+            && refinedCopies.some(copy => matrix.presence[other.id][copy] === 'present')
+            && !sideCopies.some(copy => matrix.presence[other.id][copy] === 'present'));
+        if (!near && !redundant.has(reading.id))
+            continue;
+        states[root] = true;
+        moved.push(reading.id);
+    }
+    return moved;
+};
+/**
+ * Where a version is coded for a system whose bar has no word for a
+ * reading it inherits, the reading does not go on: the re-cut deletes
+ * it, and what stands for it there is a reading of its own.
+ */
+const recode = (tree, readings, placement) => {
+    const order = fromRoot(tree);
+    for (const reading of readings) {
+        const states = placement.get(reading.id);
+        for (const v of order) {
+            const bar = barNamed(tree.system[v]);
+            if (states[v] && bar && !reads(bar, reading.meaning))
+                states[v] = false;
+        }
+    }
+};
+/**
+ * Proposes a stemma from the copies.
+ *
+ * The copies are collated all at once (`collateCopies`), and every
+ * reading becomes a character that each copy has, lacks or cannot speak
+ * to (`presenceIn`). Every stemma of the copies that the systems admit,
+ * up to seven copies, is scored by what it has to let arise and be lost
+ * (`Costs`), and the least costly is taken, ties going to fewer lost
+ * states. On it, each reading arises in the latest version all copies
+ * carrying it descend from, and is deleted where a branch lacks it. A
+ * reading only the less refined side of the root carries is taken for
+ * the base text where the other side has it moved or cleaned up.
+ *
+ * Where the edition has versions already, a version of the proposal
+ * that a copy carries at first hand stands for the version that copy
+ * carries in the edition, and a lost one for the version inserting most
+ * of the same readings. An edit the editor wrote on such a version, one
+ * a collation would not have written, holds the version to what it
+ * inserts and deletes, unless the copies cannot be read so.
+ * @category Filiation
+ */
+export const proposeStemma = (edition, options = {}) => {
+    const copies = transcribed(edition).filter(id => !options.copies || options.copies.includes(id));
+    if (copies.length < 2)
+        throw new Error('A stemma needs at least two copies with features');
+    if (copies.length > MAX_COPIES)
+        throw new Error(`The exhaustive search covers at most ${MAX_COPIES} copies`);
+    const costs = { ...defaultCosts, ...options.costs };
+    const movedWithin = options.movedWithin ?? defaultMovedWithin;
+    const margin = options.margin ?? defaultMargin;
+    const copyOf = new Map(edition.copies.map(copy => [copy.id, copy]));
+    const names = copies.map(id => copyOf.get(id).siglum ?? id);
+    const systems = copies.map(id => barOf(copyOf.get(id)).id);
+    const transfers = transfersOf();
+    const collation = collateCopies(edition, copies);
+    const matrix = presenceIn(edition, collation, margin);
+    const redundant = new Set(matrix.redundant);
+    const rows = collation.readings.map(reading => ({
+        presence: copies.map(copy => matrix.presence[reading.id][copy]),
+        redundant: redundant.has(reading.id)
+    }));
+    const search = searchStemmata(copies, names, systems, rows, costs, transfers, options.alternatives ?? 5);
+    const tree = search.best;
+    const size = tree.copy.length;
+    const place = (fixed) => {
+        const placement = new Map();
+        const failed = new Set();
+        collation.readings.forEach((reading, index) => {
+            const pinned = fixed.get(reading.id);
+            let states = statesOf(tree, rows[index].presence, rows[index].redundant, costs, pinned);
+            if (!states) {
+                failed.add(reading.id);
+                states = statesOf(tree, rows[index].presence, rows[index].redundant, costs);
+            }
+            placement.set(reading.id, states);
+        });
+        return { placement, failed };
+    };
+    const symbols = symbolsFor(edition, collation.readings);
+    const readingOf = new Map(Object.entries(symbols).map(([reading, symbol]) => [symbol, reading]));
+    // A first placement, free of the editor's edits, tells which version a lost node stands for.
+    const free = place(new Map());
+    recode(tree, collation.readings, free.placement);
+    const standsFor = new Map();
+    const claimed = new Set();
+    for (let v = 0; v < size; v++) {
+        const copy = tree.copy[v];
+        if (copy < 0)
+            continue;
+        const firstHand = versionsWitnessedBy(edition, copies[copy])
+            .find(witness => witness.by === 'carriers' && witness.through === undefined);
+        if (firstHand && !claimed.has(firstHand.version)) {
+            standsFor.set(v, firstHand.version);
+            claimed.add(firstHand.version);
+        }
+    }
+    const insertsAt = (placement, v) => collation.readings.filter(reading => inserting(tree, placement.get(reading.id), v)).map(reading => symbols[reading.id] ?? reading.id);
+    const lostMatches = [];
+    for (let v = 0; v < size; v++) {
+        if (tree.copy[v] >= 0)
+            continue;
+        const proposed = new Set(insertsAt(free.placement, v));
+        for (const version of edition.versions) {
+            if (claimed.has(version.id))
+                continue;
+            const stated = insertedBy(version).map(symbol => symbol.id);
+            const shared = stated.filter(id => proposed.has(id)).length;
+            const union = new Set([...stated, ...proposed]).size;
+            if (shared > 0)
+                lostMatches.push({ v, version: version.id, overlap: shared / union });
+        }
+    }
+    lostMatches.sort((a, b) => b.overlap - a.overlap || a.v - b.v);
+    for (const { v, version } of lostMatches) {
+        if (standsFor.has(v) || claimed.has(version))
+            continue;
+        standsFor.set(v, version);
+        claimed.add(version);
+    }
+    // The editor's edits hold their versions, as far as the copies allow.
+    const unpinned = [];
+    const pins = new Map();
+    const fixed = new Map();
+    const nodeOf = new Map([...standsFor].map(([v, version]) => [version, v]));
+    const meaningOf = new Map(collation.readings.map(reading => [reading.id, reading.meaning]));
+    if (options.pin !== false) {
+        for (const version of edition.versions) {
+            const established = editsOf(version).filter(edit => !isCollationsOwn(edit));
+            const v = nodeOf.get(version.id);
+            for (const edit of established) {
+                if (v === undefined) {
+                    unpinned.push({ edit: edit.id, version: version.id, reason: 'version-gone' });
+                    continue;
+                }
+                const inserted = (edit.insert ?? []).map(symbol => readingOf.get(symbol.id));
+                const deleted = (edit.delete ?? []).map(id => readingOf.get(id));
+                if ([...inserted, ...deleted].some(reading => reading === undefined)) {
+                    unpinned.push({ edit: edit.id, version: version.id, reason: 'reading-gone' });
+                    continue;
+                }
+                const bar = barNamed(tree.system[v]);
+                const hold = (reading, node, state) => {
+                    const states = fixed.get(reading) ?? new Map();
+                    states.set(node, state);
+                    fixed.set(reading, states);
+                };
+                for (const reading of inserted) {
+                    if (bar && !reads(bar, meaningOf.get(reading)))
+                        continue;
+                    hold(reading, v, true);
+                    if (tree.parent[v] >= 0)
+                        hold(reading, tree.parent[v], false);
+                }
+                for (const reading of deleted) {
+                    if (bar && !reads(bar, meaningOf.get(reading)))
+                        continue;
+                    hold(reading, v, false);
+                    if (tree.parent[v] >= 0)
+                        hold(reading, tree.parent[v], true);
+                }
+                pins.set(v, [...(pins.get(v) ?? []), { edit: edit.id, readings: [...inserted, ...deleted] }]);
+            }
+        }
+    }
+    const { placement, failed } = place(fixed);
+    const held = new Set([...fixed.keys()].filter(reading => !failed.has(reading)));
+    const baseText = baseTextOf(tree, collation.readings, matrix, placement, held, movedWithin, systems);
+    recode(tree, collation.readings, placement);
+    for (const [v, edits] of pins) {
+        for (const { edit, readings } of edits) {
+            if (readings.some(reading => failed.has(reading))) {
+                unpinned.push({ edit, version: standsFor.get(v), reason: 'contradicts-copies' });
+            }
+        }
+    }
+    const released = new Set(unpinned.map(({ edit }) => edit));
+    // Pre-order numbering, so that the root is p0.
+    const order = fromRoot(tree);
+    const nameOf = new Map(order.map((v, index) => [v, `p${index}`]));
+    const versions = order.map((v) => {
+        const inserts = collation.readings.filter(reading => inserting(tree, placement.get(reading.id), v)).map(reading => reading.id);
+        const deletes = collation.readings.filter(reading => deleting(tree, placement.get(reading.id), v)).map(reading => reading.id);
+        const inserted = new Set(inserts);
+        const deleted = new Set(deletes);
+        const used = new Set();
+        const recodings = tree.parent[v] >= 0 && tree.transfer[v]
+            ? collation.recodings.filter(recoding => {
+                const fits = recoding.by.every(id => inserted.has(id) && !used.has(id))
+                    && recoding.replaced.every(id => deleted.has(id) && !used.has(id));
+                if (fits)
+                    [...recoding.by, ...recoding.replaced].forEach(id => used.add(id));
+                return fits;
+            })
+            : [];
+        const copy = tree.copy[v];
+        const inner = copy >= 0 && tree.below[v] !== 1 << copy;
+        const deviations = inner
+            ? collation.readings.filter(reading => placement.get(reading.id)[v] && matrix.presence[reading.id][copies[copy]] === 'absent').map(reading => reading.id)
+            : [];
+        return {
+            id: nameOf.get(v),
+            ...(copy >= 0 && { copy: copies[copy] }),
+            system: tree.system[v],
+            ...(tree.parent[v] >= 0 && { parent: nameOf.get(tree.parent[v]) }),
+            ...(standsFor.has(v) && { version: standsFor.get(v) }),
+            inserts,
+            deletes,
+            recodings,
+            deviations,
+            pinned: (pins.get(v) ?? []).map(({ edit }) => edit).filter(edit => !released.has(edit))
+        };
+    });
+    const conflicts = collation.readings
+        .map(reading => ({ reading: reading.id, versions: versions.filter(version => version.inserts.includes(reading.id)).map(version => version.id) }))
+        .filter(({ versions }) => versions.length > 1);
+    return {
+        copies,
+        costs,
+        movedWithin,
+        margin,
+        collation,
+        matrix,
+        versions,
+        notation: tree.notation,
+        cost: search.cost,
+        scored: search.scored,
+        alternatives: search.alternatives,
+        supports: search.supports,
+        conflicts,
+        baseText,
+        symbols,
+        unpinned
+    };
+};