@driftengine/tools 4.0.0

package/dist/divergence.js

@@ -0,0 +1,36 @@
+/**
+ * Which of two sets of component hashes disagree.
+ *
+ * **Here rather than beside the divergence search, because a shipped game gets this half.** The
+ * search walks a timeline, which only the editor has; comparing what two peers hashed is what an
+ * in-game network panel does the moment a rollback session desynchronises, and that is a panel a
+ * game carries. `editor/src/pie/divergence.ts` holds the search and imports these.
+ */
+/**
+ * Which components two sides hash differently, into `out`. Returns how many.
+ *
+ * A component only one side has is a divergence too, and the loudest kind: it means one peer
+ * created or destroyed something the other did not.
+ */
+export function divergentComponents(ours, theirs, out) {
+    out.length = 0;
+    for (const [name, hash] of ours) {
+        if (theirs.get(name) !== hash)
+            out.push(name);
+    }
+    for (const name of theirs.keys()) {
+        if (!ours.has(name))
+            out.push(name);
+    }
+    return out.length;
+}
+/**
+ * Whether the difference is in something nobody hashed.
+ *
+ * The honest answer when the whole-world fingerprints disagree and every recorded component
+ * agrees: the state that differs was not in the breakdown. Reporting agreement there would be a
+ * panel saying everything is fine on a frame that is provably not.
+ */
+export function divergenceIsUnaccounted(differing, worldsDiffer) {
+    return worldsDiffer && differing === 0;
+}

package/dist/index.d.ts

@@ -0,0 +1,34 @@
+/*! DriftEngine | Copyright 2026 Drift Technologies | Apache-2.0 | https://github.com/drftrun/driftengine */
+/**
+ * The editor panels a shipped game can carry.
+ *
+ * **The argument is the split, not the panels.** An inspector, a console, a profiler and a network
+ * panel are what somebody wants while a game is running — on a tester's machine, on a console
+ * devkit, in a build nobody can attach a debugger to. A scene tree and an asset browser are not:
+ * they need a project, and a shipped game has none. So those two stayed in the editor and these
+ * four became a package, and **a game that never imports this package pays nothing at all** — which
+ * is a claim the size gate makes rather than a claim this paragraph makes.
+ *
+ * **The command stack came with them, because the alternative is an in-game inspector that cannot
+ * undo.** `Panel.route` returns a `Command` or nothing, which is what makes "a panel mutates only
+ * through commands" a signature rather than a convention; a game carrying the panels carries that
+ * rule too, and gets undo for free.
+ *
+ * **`Selection` came with them for the same reason**: the inspector's whole subject is what is
+ * selected, and three panels sharing one selection by reference is how the editor already works.
+ */
+export type { Command, UndoStack } from './command.ts';
+export { createUndoStack } from './command.ts';
+export type { Panel, UiEvent } from './panel.ts';
+export { PANEL_PREFIX, createPanelRoot, emptyPanel, keyEvent, panelIdOf, pointerEvent, treeShape, wheelEvent, } from './panel.ts';
+export type { Selection } from './selection.ts';
+export { addToSelection, clearSelection, createSelection, isSelected, primarySelection, selectOnly, selectRange, selectedEntities, toggleSelection, } from './selection.ts';
+export { divergenceIsUnaccounted, divergentComponents } from './divergence.ts';
+export type { InspectableWorld, InspectorRow, InspectorView, InspectorWorld, RowKind, } from './inspector.ts';
+export { MIXED, addComponentCommand, createInspectorView, fieldEditable, inspectorPanel, inspectorRows, removeComponentCommand, rowText, setFieldCommand, } from './inspector.ts';
+export type { ConsoleView, ConsoleWorld, LogEntry, LogFilter, LogRing, Severity, SourceCursor, } from './console.ts';
+export { DISPLAY_LIMIT, appendLog, consolePanel, createConsoleView, createLogFilter, createLogRing, displayText, filteredEntries, jumpToSourceCommand, logEntries, } from './console.ts';
+export type { FrameHistory, ProfilerRow, ProfilerView, ProfilerWorld } from './profiler.ts';
+export { createFrameHistory, createProfilerView, formatMs, historyValues, occupancy, profilerPanel, profilerRows, pushFrame, } from './profiler.ts';
+export type { NetworkReadout, NetworkView, NetworkWorld, RollbackHistory } from './network.ts';
+export { componentDivergence, createNetworkView, createRollbackHistory, networkPanel, pushRollback, rollbackValues, } from './network.ts';

package/dist/index.js

@@ -0,0 +1,9 @@
+/*! DriftEngine | Copyright 2026 Drift Technologies | Apache-2.0 | https://github.com/drftrun/driftengine */
+export { createUndoStack } from './command.js';
+export { PANEL_PREFIX, createPanelRoot, emptyPanel, keyEvent, panelIdOf, pointerEvent, treeShape, wheelEvent, } from './panel.js';
+export { addToSelection, clearSelection, createSelection, isSelected, primarySelection, selectOnly, selectRange, selectedEntities, toggleSelection, } from './selection.js';
+export { divergenceIsUnaccounted, divergentComponents } from './divergence.js';
+export { MIXED, addComponentCommand, createInspectorView, fieldEditable, inspectorPanel, inspectorRows, removeComponentCommand, rowText, setFieldCommand, } from './inspector.js';
+export { DISPLAY_LIMIT, appendLog, consolePanel, createConsoleView, createLogFilter, createLogRing, displayText, filteredEntries, jumpToSourceCommand, logEntries, } from './console.js';
+export { createFrameHistory, createProfilerView, formatMs, historyValues, occupancy, profilerPanel, profilerRows, pushFrame, } from './profiler.js';
+export { componentDivergence, createNetworkView, createRollbackHistory, networkPanel, pushRollback, rollbackValues, } from './network.js';

package/dist/inspector.d.ts

@@ -0,0 +1,86 @@
+import type { UiNode } from '@driftengine/ui2d';
+import { type FieldKind } from '@driftengine/editor';
+import type { Command } from './command.ts';
+import { type Selection } from './selection.ts';
+import { type Panel } from './panel.ts';
+/**
+ * What the inspector needs of a world.
+ *
+ * **Four reads and three writes**, so a panel can be tested against plain maps — this plan's second
+ * constraint — and so the same panel serves `@driftengine/entities`, a `.drs` file's declarations
+ * and anything else that can answer these. A caller holding a `World` wraps it in seven lines.
+ */
+export interface InspectableWorld {
+    componentsOf(entity: number): readonly string[];
+    schemaOf(component: string): readonly {
+        readonly name: string;
+        readonly type: string;
+    }[];
+    read(entity: number, component: string, field: string): unknown;
+    write(entity: number, component: string, field: string, value: unknown): void;
+    hasComponent(entity: number, component: string): boolean;
+    addComponent(entity: number, component: string): void;
+    removeComponent(entity: number, component: string): void;
+}
+/** What a row's value is when the selected entities disagree about it. */
+export declare const MIXED: unique symbol;
+/** A vector row is three number fields; anything else is one field. */
+export type RowKind = FieldKind | 'vector';
+export interface InspectorRow {
+    readonly component: string;
+    /** What the row is called: a field's name, or the prefix the vector's three share. */
+    readonly label: string;
+    /** The declared type, verbatim. Empty for a vector, which is three of them. */
+    readonly type: string;
+    readonly kind: RowKind;
+    readonly enumName: string;
+    /** The schema fields this row writes, in order. One, or three for a vector. */
+    readonly fields: readonly string[];
+    /** The value, `MIXED` where the selection disagrees. An array of three for a vector. */
+    readonly value: unknown;
+    readonly editable: boolean;
+}
+export declare function fieldEditable(type: string): boolean;
+/**
+ * The rows for a selection: the components every selected entity has, field by field.
+ *
+ * Components are taken from the first entity and then filtered by the rest, so the order is stable
+ * — a row that moved between frames because a set iterated differently is a field somebody clicks
+ * and misses.
+ */
+export declare function inspectorRows(world: InspectableWorld, entities: readonly number[]): InspectorRow[];
+/**
+ * Write one row's fields across the whole selection, as one entry.
+ *
+ * **One entry for the whole selection and for all three of a vector's components.** Editing with
+ * ten entities selected is one act, and undo that took it back one entity at a time would make the
+ * person count. Each entity's own previous value is recorded, so undo does not flatten them onto
+ * whatever the first one held.
+ */
+export declare function setFieldCommand(world: InspectableWorld, entities: readonly number[], component: string, fields: readonly string[], values: readonly unknown[]): Command | null;
+export declare function addComponentCommand(world: InspectableWorld, entities: readonly number[], component: string): Command | null;
+/**
+ * Remove a component, keeping its values so undo can put them back.
+ *
+ * **The values are read before the removal and written after the restore.** A remove that only
+ * remembers "it was there" gives back a component full of zeroes, which reads as undo having
+ * worked and is the worse failure: nothing looks broken.
+ */
+export declare function removeComponentCommand(world: InspectableWorld, entities: readonly number[], component: string): Command | null;
+export interface InspectorWorld {
+    readonly world: InspectableWorld;
+}
+export interface InspectorView {
+    readonly root: UiNode;
+    readonly selection: Selection;
+    /** The rows the last build produced, so routing can find a field by index. */
+    rows: InspectorRow[];
+    rowHeight: number;
+}
+export declare function createInspectorView(options: {
+    selection: Selection;
+    rowHeight?: number;
+}): InspectorView;
+/** What a row shows to the right of its label. `—` is the mark for a disagreement. */
+export declare function rowText(row: InspectorRow): string;
+export declare const inspectorPanel: Panel<InspectorWorld, InspectorView>;

package/dist/inspector.js

@@ -0,0 +1,265 @@
+/**
+ * The components of whatever is selected, generated from the schema.
+ *
+ * **Schema-driven and not a drawer per type**, which is the decision that decides whether an editor
+ * stays maintainable. A drawer per component type means every new component needs editor work, so
+ * components stop being added — and it is the one thing reflection makes unnecessary, because a
+ * component already describes itself. `fieldKindOf` in `@driftengine/editor` already turns a
+ * declared type into what to draw, and this uses it rather than repeating it.
+ *
+ * **A value several entities disagree about is marked, never guessed at.** Showing the first
+ * entity's is how somebody types into a field, sees nothing change, and silently overwrites the
+ * other nine.
+ *
+ * **A type this cannot edit is shown read-only rather than dropped.** A field that is silently not
+ * there is a field somebody spends an afternoon looking for.
+ */
+import { addUiChild, createUiNode } from '@driftengine/ui2d';
+import { fieldKindOf } from '@driftengine/editor';
+import { selectedEntities } from './selection.js';
+import { createPanelRoot, emptyPanel } from './panel.js';
+/** What a row's value is when the selected entities disagree about it. */
+export const MIXED = Symbol('mixed');
+/**
+ * The declared types this can edit.
+ *
+ * **A list rather than `fieldKindOf`'s answer**, because that function's fallback is `number` — it
+ * is asked what *kind* a known type is, not whether a type is known, and `MeshHandle` comes back as
+ * a number that would then be typed into. The two questions are different and the second one is
+ * this file's.
+ */
+const KNOWN = new Set([
+    'f32',
+    'f64',
+    'i8',
+    'i16',
+    'i32',
+    'i64',
+    'u8',
+    'u16',
+    'u32',
+    'u64',
+    'bool',
+    'String',
+    'Entity',
+]);
+export function fieldEditable(type) {
+    const inner = type.startsWith('option:') ? type.slice('option:'.length) : type;
+    return KNOWN.has(inner) || inner.startsWith('enum:');
+}
+/** `position.x` is the `x` of a vector called `position`. Anything else is its own row. */
+function vectorPartOf(name) {
+    const dot = name.lastIndexOf('.');
+    if (dot <= 0)
+        return null;
+    const axis = 'xyz'.indexOf(name.slice(dot + 1));
+    return axis < 0 ? null : { prefix: name.slice(0, dot), axis };
+}
+/** One value across the selection, or `MIXED`. */
+function agreed(world, entities, component, field) {
+    const first = world.read(entities[0], component, field);
+    for (let at = 1; at < entities.length; at += 1) {
+        if (world.read(entities[at], component, field) !== first)
+            return MIXED;
+    }
+    return first;
+}
+/**
+ * The rows for a selection: the components every selected entity has, field by field.
+ *
+ * Components are taken from the first entity and then filtered by the rest, so the order is stable
+ * — a row that moved between frames because a set iterated differently is a field somebody clicks
+ * and misses.
+ */
+export function inspectorRows(world, entities) {
+    const first = entities[0];
+    if (first === undefined)
+        return [];
+    const shared = world
+        .componentsOf(first)
+        .filter((component) => entities.every((entity) => world.hasComponent(entity, component)));
+    const rows = [];
+    for (const component of shared) {
+        const fields = world.schemaOf(component);
+        const vectors = new Map();
+        for (const field of fields) {
+            const part = vectorPartOf(field.name);
+            if (part === null)
+                continue;
+            const slots = vectors.get(part.prefix) ?? ['', '', ''];
+            slots[part.axis] = field.name;
+            vectors.set(part.prefix, slots);
+        }
+        /* Two of three is not a vector; it is two fields that happen to be named that way. */
+        for (const [prefix, slots] of vectors) {
+            if (slots.some((slot) => slot === ''))
+                vectors.delete(prefix);
+        }
+        const claimed = new Set([...vectors.values()].flat());
+        const emitted = new Set();
+        for (const field of fields) {
+            const part = vectorPartOf(field.name);
+            if (part !== null && claimed.has(field.name)) {
+                if (emitted.has(part.prefix))
+                    continue;
+                emitted.add(part.prefix);
+                const slots = vectors.get(part.prefix);
+                rows.push({
+                    component,
+                    label: part.prefix,
+                    type: '',
+                    kind: 'vector',
+                    enumName: '',
+                    fields: slots,
+                    value: slots.map((slot) => agreed(world, entities, component, slot)),
+                    editable: fieldEditable(field.type),
+                });
+                continue;
+            }
+            const { kind, enumName } = fieldKindOf(field.type);
+            rows.push({
+                component,
+                label: field.name,
+                type: field.type,
+                kind,
+                enumName,
+                fields: [field.name],
+                value: agreed(world, entities, component, field.name),
+                editable: fieldEditable(field.type),
+            });
+        }
+    }
+    return rows;
+}
+/**
+ * Write one row's fields across the whole selection, as one entry.
+ *
+ * **One entry for the whole selection and for all three of a vector's components.** Editing with
+ * ten entities selected is one act, and undo that took it back one entity at a time would make the
+ * person count. Each entity's own previous value is recorded, so undo does not flatten them onto
+ * whatever the first one held.
+ */
+export function setFieldCommand(world, entities, component, fields, values) {
+    if (entities.length === 0 || fields.length === 0)
+        return null;
+    if (!entities.every((entity) => world.hasComponent(entity, component)))
+        return null;
+    const before = entities.map((entity) => fields.map((field) => world.read(entity, component, field)));
+    return {
+        label: `${component}.${stripAxis(fields)}`,
+        apply: () => {
+            for (const entity of entities) {
+                fields.forEach((field, at) => world.write(entity, component, field, values[at]));
+            }
+        },
+        revert: () => {
+            entities.forEach((entity, row) => {
+                fields.forEach((field, at) => {
+                    world.write(entity, component, field, before[row][at]);
+                });
+            });
+        },
+    };
+}
+/** A vector's label is what its three fields share, so the undo menu says `position` not `position.x`. */
+function stripAxis(fields) {
+    const first = fields[0];
+    if (fields.length === 1)
+        return first;
+    const part = vectorPartOf(first);
+    return part === null ? first : part.prefix;
+}
+export function addComponentCommand(world, entities, component) {
+    const missing = entities.filter((entity) => !world.hasComponent(entity, component));
+    if (missing.length === 0)
+        return null;
+    return {
+        label: `Add ${component}`,
+        apply: () => {
+            for (const entity of missing)
+                world.addComponent(entity, component);
+        },
+        revert: () => {
+            for (const entity of missing)
+                world.removeComponent(entity, component);
+        },
+    };
+}
+/**
+ * Remove a component, keeping its values so undo can put them back.
+ *
+ * **The values are read before the removal and written after the restore.** A remove that only
+ * remembers "it was there" gives back a component full of zeroes, which reads as undo having
+ * worked and is the worse failure: nothing looks broken.
+ */
+export function removeComponentCommand(world, entities, component) {
+    const present = entities.filter((entity) => world.hasComponent(entity, component));
+    if (present.length === 0)
+        return null;
+    const fields = world.schemaOf(component).map((field) => field.name);
+    const kept = present.map((entity) => fields.map((field) => world.read(entity, component, field)));
+    return {
+        label: `Remove ${component}`,
+        apply: () => {
+            for (const entity of present)
+                world.removeComponent(entity, component);
+        },
+        revert: () => {
+            present.forEach((entity, row) => {
+                world.addComponent(entity, component);
+                fields.forEach((field, at) => {
+                    world.write(entity, component, field, kept[row][at]);
+                });
+            });
+        },
+    };
+}
+export function createInspectorView(options) {
+    return {
+        root: createPanelRoot(inspectorPanel),
+        selection: options.selection,
+        rows: [],
+        rowHeight: options.rowHeight ?? 18,
+    };
+}
+/** What a row shows to the right of its label. `—` is the mark for a disagreement. */
+export function rowText(row) {
+    if (row.value === MIXED)
+        return `${row.label}  —`;
+    if (row.kind === 'vector') {
+        const parts = row.value.map((part) => (part === MIXED ? '—' : String(part)));
+        return `${row.label}  ${parts.join(', ')}`;
+    }
+    if (row.kind === 'boolean')
+        return `${row.label}  ${row.value ? 'true' : 'false'}`;
+    return `${row.label}  ${String(row.value)}`;
+}
+export const inspectorPanel = {
+    id: 'inspector',
+    title: 'Inspector',
+    build(world, view, root) {
+        const entities = selectedEntities(view.selection);
+        view.rows = inspectorRows(world.world, entities);
+        if (view.rows.length === 0) {
+            emptyPanel(root, entities.length === 0 ? 'Nothing selected' : 'No fields in common');
+            return;
+        }
+        root.children.length = 0;
+        for (let at = 0; at < view.rows.length; at += 1) {
+            const row = view.rows[at];
+            addUiChild(root, createUiNode({
+                width: 'grow',
+                height: view.rowHeight,
+                text: rowText(row),
+                interactive: row.editable,
+                focusable: row.editable,
+                name: `field:${at}`,
+            }));
+        }
+    },
+    route() {
+        /* Task 5 wires the field widgets in. Until then the inspector shows and does not edit, which
+           is a state worth having rather than a half-built router that swallows keys. */
+        return null;
+    },
+};

package/dist/network.d.ts

@@ -0,0 +1,58 @@
+import type { UiNode } from '@driftengine/ui2d';
+import type { Desync } from '@driftengine/network';
+import { type Panel } from './panel.ts';
+/**
+ * What the panel needs of a session.
+ *
+ * Supplied rather than read off a `LockstepSession`, for the reason the asset index is supplied:
+ * an editor attached to a session, a recording or a replay wants the same panel, and only two of
+ * those have a session to read.
+ */
+export interface NetworkReadout {
+    readonly inputDelay: number;
+    readonly participants: number;
+    /** Bytes in one snapshot slot. */
+    readonly snapshotBytes: number;
+    /** How many slots the rewind window holds. */
+    readonly snapshotCount: number;
+    /** Everything the session has seen disagree, oldest first. */
+    readonly desyncs: readonly Desync[];
+    /** A per-component breakdown, where the caller has one. See the header. */
+    readonly componentHashes: {
+        readonly ours: ReadonlyMap<string, string>;
+        readonly theirs: ReadonlyMap<string, string>;
+    } | null;
+}
+/**
+ * Which components two peers hash differently, in the order they are first seen.
+ *
+ * **The comparison itself lives in `pie/divergence.ts`**, which is where the divergence search
+ * needs it too. Two copies of "which of these hashes disagree" is two places for the rule about a
+ * component only one side has to be got wrong, and a panel is the wrong owner of a rule — it uses
+ * one. This keeps its own shape, returning a fresh array, because a panel builds a line of text
+ * from it once per rebuild and an out-parameter would be ceremony for nothing.
+ */
+export declare function componentDivergence(ours: ReadonlyMap<string, string>, theirs: ReadonlyMap<string, string>): string[];
+/** A fixed window of how deep each recent frame rewound. */
+export interface RollbackHistory {
+    readonly depth: Int32Array;
+    head: number;
+    filled: number;
+}
+export declare function createRollbackHistory(capacity: number): RollbackHistory;
+export declare function pushRollback(history: RollbackHistory, depth: number): void;
+export declare function rollbackValues(history: RollbackHistory): number[];
+export interface NetworkWorld {
+    /** Null where the editor is not attached to anything. */
+    readonly session: NetworkReadout | null;
+}
+export interface NetworkView {
+    readonly root: UiNode;
+    readonly rollback: RollbackHistory;
+    rowHeight: number;
+}
+export declare function createNetworkView(options: {
+    rowHeight?: number;
+    historyLength?: number;
+}): NetworkView;
+export declare const networkPanel: Panel<NetworkWorld, NetworkView>;

package/dist/network.js

@@ -0,0 +1,120 @@
+/**
+ * Snapshots, rollback depth, and the frame two peers stopped agreeing on.
+ *
+ * **Nobody else has this panel, because nobody else has the state to put in it.** The one that
+ * matters is divergence: `@driftengine/network` already fingerprints every snapshot and reports a
+ * `Desync` carrying the tick, the peer and both digests, and nothing has ever shown it to anybody.
+ *
+ * **An empty divergence list and a missing one must not look the same.** One says the peers agree;
+ * the other says nobody checked. Those are the two answers somebody most needs to tell apart, and
+ * a panel that renders both as blank space is worse than no panel — it reads as agreement. So no
+ * session says "No session", and no divergence says "peers agree" in as many words.
+ *
+ * **Which component differs is answerable only where somebody hashed per component.** `Fingerprint`
+ * digests a whole snapshot, so `Desync` is two sixteen-character strings and nothing finer. Where a
+ * caller supplies a per-component breakdown this names the component; where it does not, it says
+ * the breakdown is absent rather than showing an empty line that reads as "no component differs".
+ */
+import { addUiChild, createUiNode } from '@driftengine/ui2d';
+import { divergentComponents } from './divergence.js';
+import { createPanelRoot, emptyPanel } from './panel.js';
+/**
+ * Which components two peers hash differently, in the order they are first seen.
+ *
+ * **The comparison itself lives in `pie/divergence.ts`**, which is where the divergence search
+ * needs it too. Two copies of "which of these hashes disagree" is two places for the rule about a
+ * component only one side has to be got wrong, and a panel is the wrong owner of a rule — it uses
+ * one. This keeps its own shape, returning a fresh array, because a panel builds a line of text
+ * from it once per rebuild and an out-parameter would be ceremony for nothing.
+ */
+export function componentDivergence(ours, theirs) {
+    const out = [];
+    divergentComponents(ours, theirs, out);
+    return out;
+}
+export function createRollbackHistory(capacity) {
+    return { depth: new Int32Array(Math.max(1, capacity)), head: 0, filled: 0 };
+}
+export function pushRollback(history, depth) {
+    const capacity = history.depth.length;
+    history.depth[history.head] = depth;
+    history.head = (history.head + 1) % capacity;
+    if (history.filled < capacity)
+        history.filled += 1;
+}
+export function rollbackValues(history) {
+    const capacity = history.depth.length;
+    const first = history.filled < capacity ? 0 : history.head;
+    const out = [];
+    for (let at = 0; at < history.filled; at += 1) {
+        out.push(history.depth[(first + at) % capacity]);
+    }
+    return out;
+}
+export function createNetworkView(options) {
+    return {
+        root: createPanelRoot(networkPanel),
+        rollback: createRollbackHistory(options.historyLength ?? 60),
+        rowHeight: options.rowHeight ?? 18,
+    };
+}
+/** Kilobytes to one decimal, which is the resolution a snapshot budget is argued at. */
+function kilobytes(bytes) {
+    return `${(bytes / 1024).toFixed(1)} KB`;
+}
+function lineAt(root, index, text, height) {
+    const existing = root.children[index];
+    if (existing !== undefined) {
+        existing.hidden = false;
+        existing.text = text;
+        return;
+    }
+    addUiChild(root, createUiNode({ width: 'grow', height, text, interactive: false, name: `line:${index}` }));
+}
+export const networkPanel = {
+    id: 'network',
+    title: 'Network',
+    build(world, view, root) {
+        const session = world.session;
+        if (session === null) {
+            emptyPanel(root, 'No session');
+            return;
+        }
+        const lines = [
+            `delay  ${session.inputDelay} ticks`,
+            `peers  ${session.participants}`,
+            `snapshots  ${session.snapshotCount} of ${kilobytes(session.snapshotBytes)} — ${kilobytes(session.snapshotBytes * session.snapshotCount)}`,
+            `rollback  ${rollbackValues(view.rollback).join(' ')}`,
+        ];
+        const first = session.desyncs[0];
+        if (first === undefined) {
+            lines.push('peers agree on every fingerprint so far');
+        }
+        else {
+            lines.push(`diverged at tick ${first.tick} against ${first.peer}`);
+            lines.push(`  ours ${first.ours}`);
+            lines.push(`  theirs ${first.theirs}`);
+            const hashes = session.componentHashes;
+            if (hashes === null) {
+                lines.push('  no per-component hashes were supplied');
+            }
+            else {
+                const differing = componentDivergence(hashes.ours, hashes.theirs);
+                lines.push(differing.length === 0
+                    ? '  every component agrees, so the difference is outside them'
+                    : `  differing: ${differing.join(', ')}`);
+            }
+        }
+        for (let at = 0; at < lines.length; at += 1) {
+            lineAt(root, at, lines[at], view.rowHeight);
+        }
+        for (let at = lines.length; at < root.children.length; at += 1) {
+            root.children[at].hidden = true;
+        }
+    },
+    route() {
+        /* Read-only, and deliberately: there is nothing in a session's diagnostics a person should be
+           able to edit, and a panel that let them would be editing the evidence. */
+        return null;
+    },
+};