@driftengine/editor 3.61.0

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+/*! DriftEngine | Copyright 2026 Drift Technologies | Apache-2.0 | https://github.com/drftrun/driftengine */
+/**
+ * `@driftengine/editor` — the model of a scene editor.
+ *
+ * A tree of what exists, an inspector over what is selected, and play-in-editor. No pixels: the
+ * panel builders produce `@driftengine/ui2d` nodes and the consumer draws them, the way `DebugLines`
+ * produces segments and `drawLines` draws them.
+ *
+ * **A package rather than part of core**, because it imports `@driftengine/entities` and core does
+ * not — that package imports no other engine package, deliberately, and having core reach it to
+ * serve an editor would invert that for every game that never opens one.
+ */
+export { SceneTree } from './sceneTree.ts';
+export type { TreeRow } from './sceneTree.ts';
+export { Inspector, fieldKindOf } from './inspector.ts';
+export type { FieldKind, InspectorField } from './inspector.ts';
+export { EditorHost } from './editorHost.ts';
+export type { EditorMode, EditorWorld } from './editorHost.ts';
+export { FIELD_ROW_PREFIX, TREE_ROW_PREFIX, buildInspectorPanel, buildTreePanel, formatValue, rowIndexOf, } from './panel.ts';

package/dist/index.js

@@ -0,0 +1,16 @@
+/*! DriftEngine | Copyright 2026 Drift Technologies | Apache-2.0 | https://github.com/drftrun/driftengine */
+/**
+ * `@driftengine/editor` — the model of a scene editor.
+ *
+ * A tree of what exists, an inspector over what is selected, and play-in-editor. No pixels: the
+ * panel builders produce `@driftengine/ui2d` nodes and the consumer draws them, the way `DebugLines`
+ * produces segments and `drawLines` draws them.
+ *
+ * **A package rather than part of core**, because it imports `@driftengine/entities` and core does
+ * not — that package imports no other engine package, deliberately, and having core reach it to
+ * serve an editor would invert that for every game that never opens one.
+ */
+export { SceneTree } from './sceneTree.js';
+export { Inspector, fieldKindOf } from './inspector.js';
+export { EditorHost } from './editorHost.js';
+export { FIELD_ROW_PREFIX, TREE_ROW_PREFIX, buildInspectorPanel, buildTreePanel, formatValue, rowIndexOf, } from './panel.js';

package/dist/inspector.d.ts

@@ -0,0 +1,103 @@
+/**
+ * What is selected, field by field, and how to write one back.
+ *
+ * **Reflection and nothing else.** A component already describes itself — `ComponentType.schema`
+ * carries `{ id, name, type }` per field, and `World.read`/`World.write` take a field by name — so
+ * an inspector over an entity is a walk of that schema. It needs no registry, no decorators and no
+ * code per component, which is the property that makes it work for a component a `.drs` file
+ * declared and this package has never heard of.
+ *
+ * **A node's transform is the other half**, and it is written back through `setPosition`, `setScale`
+ * and `markMoved` rather than into the arrays: writing an array leaves `worldMatrix` stale and the
+ * node keeps drawing where it used to be, silently and with a plausible matrix.
+ */
+import type { SceneNode } from '@driftengine/core';
+import type { ComponentType, Entity, World } from '@driftengine/entities';
+/**
+ * What a field *is*, derived from its declared type rather than from what a read returned.
+ *
+ * A read cannot tell them apart: `bool` arrives as 0 or 1, an `enum:` discriminant as an integer,
+ * and an `Entity` as a number. The declaration can, and it is what a panel needs to know whether to
+ * draw a checkbox, a stepper or a menu.
+ */
+export type FieldKind = 'number' | 'integer' | 'boolean' | 'text' | 'entity' | 'enum';
+export interface InspectorField {
+    /** What this field belongs to: a component's name, or `transform` for a node. */
+    group: string;
+    /** The field's own name, as it was declared. */
+    label: string;
+    /** The declared type, verbatim — `f32`, `enum:Mood`, `Entity`. */
+    type: string;
+    kind: FieldKind;
+    /** For `enum`, the name after the colon. Empty otherwise; this package has no variant list. */
+    enumName: string;
+    /** Whether the field is an option, which the store spells as an `option:` prefix. */
+    optional: boolean;
+    /**
+     * What the store holds, not a friendlier version of it.
+     *
+     * **A `bool` column is a `Uint8Array`, so a boolean field reads back as 0 or 1.** `kind` is what
+     * tells a panel to draw a checkbox; converting the value here would make this disagree with
+     * `world.read` for one type out of thirteen, which is a worse surprise than the number.
+     */
+    value: unknown;
+}
+/**
+ * The kind a declared type is inspected as.
+ *
+ * **An enum is reported as an enum and carries its name**, which is as far as this package can
+ * honestly go: the variant list belongs to the module that declared it, and `defineComponent` is
+ * handed `enum:Mood` — a name and no variants. A panel that has the list shows the names; one that
+ * does not shows the integer, which is what the discriminant is.
+ */
+export declare function fieldKindOf(type: string): {
+    kind: FieldKind;
+    enumName: string;
+    optional: boolean;
+};
+export declare class Inspector {
+    private readonly pool;
+    private readonly live;
+    private node;
+    private world;
+    private entity;
+    private types;
+    /** The fields of whatever is being shown. Reused between calls; copy what you keep. */
+    get fields(): readonly InspectorField[];
+    /** What is being shown: a `SceneNode`, an `Entity`, or nothing. */
+    get showing(): 'node' | 'entity' | 'nothing';
+    showNothing(): void;
+    showNode(node: SceneNode): void;
+    /**
+     * Show an entity's components — every one of `types` it actually has.
+     *
+     * The types are passed rather than discovered for the reason `serializeWorld` gives: a world holds
+     * a store for every type anything ever asked it about, empty ones included, so what to show is a
+     * decision rather than everything that happens to exist.
+     */
+    showEntity(world: World, entity: Entity, types: readonly ComponentType[]): void;
+    /**
+     * Re-read the values without rebuilding the list.
+     *
+     * The list is stable while the selection is and the values are not, so a panel holding a row by
+     * index keeps holding the same field across a frame. Rebuilding every frame would also allocate.
+     */
+    refresh(): void;
+    /**
+     * Write a field back. `false` where the index is not a field, or the value is the wrong shape.
+     *
+     * **A refusal rather than a throw**, because the caller is a panel inside a frame and a typed box
+     * that rejects what was typed into it is an ordinary thing for a panel to have to show.
+     */
+    set(index: number, value: unknown): boolean;
+    private readTransform;
+    /**
+     * Write one transform field.
+     *
+     * **Through the setters, and `markMoved` for the rotation**, because writing `position` directly
+     * leaves `worldMatrix` describing where the node used to be — with no error, a plausible matrix,
+     * and geometry drawn in the wrong place until something else happens to move it.
+     */
+    private writeTransform;
+    private take;
+}

package/dist/inspector.js

@@ -0,0 +1,219 @@
+/**
+ * `option:f32` is an option of `f32`. Mirrors `optionInner` in the entity store.
+ *
+ * **A prefix and not a `?` suffix**, which is worth a line because the suffix is the obvious guess
+ * and it is wrong: the store's own comment explains that a field type is a *key* compared for
+ * equality by a migration, so the option is spelled into the key rather than carried beside it.
+ */
+function unwrapOption(type) {
+    return type.startsWith('option:')
+        ? { inner: type.slice('option:'.length), optional: true }
+        : { inner: type, optional: false };
+}
+const INTEGERS = new Set(['i8', 'i16', 'i32', 'i64', 'u8', 'u16', 'u32', 'u64']);
+/**
+ * The kind a declared type is inspected as.
+ *
+ * **An enum is reported as an enum and carries its name**, which is as far as this package can
+ * honestly go: the variant list belongs to the module that declared it, and `defineComponent` is
+ * handed `enum:Mood` — a name and no variants. A panel that has the list shows the names; one that
+ * does not shows the integer, which is what the discriminant is.
+ */
+export function fieldKindOf(type) {
+    const { inner, optional } = unwrapOption(type);
+    if (inner.startsWith('enum:'))
+        return { kind: 'enum', enumName: inner.slice(5), optional };
+    if (inner === 'bool')
+        return { kind: 'boolean', enumName: '', optional };
+    if (inner === 'String')
+        return { kind: 'text', enumName: '', optional };
+    if (inner === 'Entity')
+        return { kind: 'entity', enumName: '', optional };
+    if (INTEGERS.has(inner))
+        return { kind: 'integer', enumName: '', optional };
+    return { kind: 'number', enumName: '', optional };
+}
+/** The ten fields a node's transform has, in the order they read. */
+const TRANSFORM = [
+    ['position.x', 0, 'position'],
+    ['position.y', 1, 'position'],
+    ['position.z', 2, 'position'],
+    ['rotation.x', 0, 'rotation'],
+    ['rotation.y', 1, 'rotation'],
+    ['rotation.z', 2, 'rotation'],
+    ['scale.x', 0, 'scale'],
+    ['scale.y', 1, 'scale'],
+    ['scale.z', 2, 'scale'],
+];
+/** A rotation's `w`, which has no axis and so is not in the table above. */
+const ROTATION_W = 'rotation.w';
+export class Inspector {
+    pool = [];
+    live = [];
+    node = null;
+    world = null;
+    entity = null;
+    types = [];
+    /** The fields of whatever is being shown. Reused between calls; copy what you keep. */
+    get fields() {
+        return this.live;
+    }
+    /** What is being shown: a `SceneNode`, an `Entity`, or nothing. */
+    get showing() {
+        if (this.node !== null)
+            return 'node';
+        return this.entity !== null ? 'entity' : 'nothing';
+    }
+    showNothing() {
+        this.node = null;
+        this.world = null;
+        this.entity = null;
+        this.types = [];
+        this.live.length = 0;
+    }
+    showNode(node) {
+        this.showNothing();
+        this.node = node;
+        this.refresh();
+    }
+    /**
+     * Show an entity's components — every one of `types` it actually has.
+     *
+     * The types are passed rather than discovered for the reason `serializeWorld` gives: a world holds
+     * a store for every type anything ever asked it about, empty ones included, so what to show is a
+     * decision rather than everything that happens to exist.
+     */
+    showEntity(world, entity, types) {
+        this.showNothing();
+        this.world = world;
+        this.entity = entity;
+        this.types = types;
+        this.refresh();
+    }
+    /**
+     * Re-read the values without rebuilding the list.
+     *
+     * The list is stable while the selection is and the values are not, so a panel holding a row by
+     * index keeps holding the same field across a frame. Rebuilding every frame would also allocate.
+     */
+    refresh() {
+        this.live.length = 0;
+        if (this.node !== null) {
+            this.readTransform(this.node);
+            return;
+        }
+        if (this.world === null || this.entity === null)
+            return;
+        for (const type of this.types) {
+            if (!this.world.has(this.entity, type))
+                continue;
+            for (const field of type.schema.fields) {
+                const { kind, enumName, optional } = fieldKindOf(field.type);
+                const at = this.take();
+                at.group = type.name;
+                at.label = field.name;
+                at.type = field.type;
+                at.kind = kind;
+                at.enumName = enumName;
+                at.optional = optional;
+                at.value = this.world.read(this.entity, type, field.name);
+            }
+        }
+    }
+    /**
+     * Write a field back. `false` where the index is not a field, or the value is the wrong shape.
+     *
+     * **A refusal rather than a throw**, because the caller is a panel inside a frame and a typed box
+     * that rejects what was typed into it is an ordinary thing for a panel to have to show.
+     */
+    set(index, value) {
+        const field = this.live[index];
+        if (field === undefined)
+            return false;
+        if (this.node !== null)
+            return this.writeTransform(this.node, field, value);
+        if (this.world === null || this.entity === null)
+            return false;
+        const type = this.types.find((candidate) => candidate.name === field.group);
+        if (type === undefined)
+            return false;
+        if (field.kind !== 'text' &&
+            field.kind !== 'entity' &&
+            typeof value !== 'number' &&
+            typeof value !== 'boolean') {
+            return false;
+        }
+        this.world.write(this.entity, type, field.label, value);
+        field.value = this.world.read(this.entity, type, field.label);
+        return true;
+    }
+    readTransform(node) {
+        for (const [label, axis, part] of TRANSFORM) {
+            const at = this.take();
+            at.group = 'transform';
+            at.label = label;
+            at.type = 'f32';
+            at.kind = 'number';
+            at.enumName = '';
+            at.optional = false;
+            at.value = node[part][axis] ?? 0;
+        }
+        const w = this.take();
+        w.group = 'transform';
+        w.label = ROTATION_W;
+        w.type = 'f32';
+        w.kind = 'number';
+        w.enumName = '';
+        w.optional = false;
+        w.value = node.rotation[3] ?? 1;
+    }
+    /**
+     * Write one transform field.
+     *
+     * **Through the setters, and `markMoved` for the rotation**, because writing `position` directly
+     * leaves `worldMatrix` describing where the node used to be — with no error, a plausible matrix,
+     * and geometry drawn in the wrong place until something else happens to move it.
+     */
+    writeTransform(node, field, value) {
+        if (typeof value !== 'number' || !Number.isFinite(value))
+            return false;
+        const [part, component] = field.label.split('.');
+        const axis = component === 'x' ? 0 : component === 'y' ? 1 : component === 'z' ? 2 : 3;
+        if (part === 'position') {
+            const next = [node.position[0] ?? 0, node.position[1] ?? 0, node.position[2] ?? 0];
+            next[axis] = value;
+            node.setPosition(next[0], next[1], next[2]);
+        }
+        else if (part === 'scale') {
+            const next = [node.scale[0] ?? 1, node.scale[1] ?? 1, node.scale[2] ?? 1];
+            next[axis] = value;
+            node.setScale(next[0], next[1], next[2]);
+        }
+        else {
+            node.rotation[axis] = value;
+            node.markMoved();
+        }
+        field.value = value;
+        return true;
+    }
+    take() {
+        const at = this.live.length;
+        const existing = this.pool[at];
+        if (existing !== undefined) {
+            this.live.push(existing);
+            return existing;
+        }
+        const made = {
+            group: '',
+            label: '',
+            type: '',
+            kind: 'number',
+            enumName: '',
+            optional: false,
+            value: 0,
+        };
+        this.pool.push(made);
+        this.live.push(made);
+        return made;
+    }
+}

package/dist/panel.d.ts

@@ -0,0 +1,43 @@
+import type { UiNode } from '@driftengine/ui2d';
+import type { Inspector } from './inspector.ts';
+import type { SceneTree } from './sceneTree.ts';
+/** The prefix a tree row's name carries, and the one an inspector field's carries. */
+export declare const TREE_ROW_PREFIX = "row:";
+export declare const FIELD_ROW_PREFIX = "field:";
+/**
+ * Which row a node is, or `-1` for a node that is not one.
+ *
+ * Takes the node `routeUiPointer` returned, so a caller writes
+ * `const at = rowIndexOf(routeUiPointer(...), TREE_ROW_PREFIX)` and has the row it clicked.
+ */
+export declare function rowIndexOf(node: UiNode | null, prefix: string): number;
+/**
+ * Fill `into` with one row per line of the tree's last rebuild.
+ *
+ * **The indent is padding rather than a spacer node**, which halves the node count and means a hit
+ * test on a row covers the indent too — clicking to the left of a deep row's label selects that row,
+ * which is what every tree does and what a spacer would have broken.
+ *
+ * **Nothing here marks the selected row and `UiNode` grows no field for it.** A `selected` flag on
+ * every node in every interface in every game, to serve a panel most of them never build, is the
+ * same trade this package refused when it put node names in `SceneTree` instead of on `SceneNode`.
+ * `tree.rowOf(tree.selected)` is the index, the caller already has the tree, and how a selected row
+ * looks is a decision about a consumer's palette rather than about an editor.
+ */
+export declare function buildTreePanel(tree: SceneTree, into: UiNode): number;
+/**
+ * Fill `into` with one row per inspector field.
+ *
+ * The label carries the group where a field belongs to a component, because two components can
+ * declare the same field name and a panel showing `health` twice with no way to tell them apart is
+ * worse than one that is a little wordier.
+ */
+export declare function buildInspectorPanel(inspector: Inspector, into: UiNode): number;
+/**
+ * A value as a row shows it.
+ *
+ * **A boolean reads as a word and an enum as its number**, which is as far as this can honestly go:
+ * the variant list belongs to the module that declared the enum, and a component is handed
+ * `enum:Mood` — a name and no variants. A consumer holding the list formats its own.
+ */
+export declare function formatValue(value: unknown, kind: string): string;

package/dist/panel.js

@@ -0,0 +1,124 @@
+/**
+ * The tree and the inspector as `UiNode` trees a consumer lays out, routes and draws.
+ *
+ * **Nodes and not pixels.** `@driftengine/ui2d` already has the layout engine, the hit test, the
+ * focus order and the pointer router; what was missing was anything turning what an editor *holds*
+ * into nodes for it. That is the same shape `DebugLines` has against `drawLines`, one level up.
+ *
+ * **Text is set and not drawn.** `drawUiTree` reports a node with text to a `UiContentSink` and
+ * draws none itself, because core already has two text renderers and ui2d's own header calls that
+ * the honest seam. This does the same thing: the row carries the string, the consumer's sink draws
+ * it with whichever renderer it uses.
+ *
+ * **Rows are rebuilt in place.** A builder that made fresh nodes every frame would allocate in a
+ * frame path, which `AGENTS.md` forbids. These reuse the children they made last time and only ever
+ * grow, so a panel settles after the largest tree it has shown.
+ *
+ * **Every row carries a name**, `row:<index>` or `field:<index>`, so `routeUiPointer` hands back the
+ * node that was activated and `rowIndexOf` turns it into the row. That is one parse rather than a
+ * map from node to row that has to be kept in step with the tree.
+ */
+import { addUiChild, createUiNode } from '@driftengine/ui2d';
+/** How far one level of depth indents a tree row, in layout units. */
+const INDENT = 12;
+/** The prefix a tree row's name carries, and the one an inspector field's carries. */
+export const TREE_ROW_PREFIX = 'row:';
+export const FIELD_ROW_PREFIX = 'field:';
+/**
+ * Which row a node is, or `-1` for a node that is not one.
+ *
+ * Takes the node `routeUiPointer` returned, so a caller writes
+ * `const at = rowIndexOf(routeUiPointer(...), TREE_ROW_PREFIX)` and has the row it clicked.
+ */
+export function rowIndexOf(node, prefix) {
+    if (node === null || !node.name.startsWith(prefix))
+        return -1;
+    const at = Number.parseInt(node.name.slice(prefix.length), 10);
+    return Number.isInteger(at) && at >= 0 ? at : -1;
+}
+/** A row that exists, reused; or a new one appended. */
+function rowAt(into, index, prefix) {
+    const existing = into.children[index];
+    if (existing !== undefined) {
+        existing.hidden = false;
+        return existing;
+    }
+    const made = createUiNode({
+        direction: 'row',
+        width: 'grow',
+        height: 18,
+        interactive: true,
+        focusable: true,
+        name: `${prefix}${index}`,
+    });
+    addUiChild(into, made);
+    return made;
+}
+/** Rows past what is needed are hidden rather than removed, so the pool survives. */
+function hideFrom(into, index) {
+    for (let at = index; at < into.children.length; at++) {
+        into.children[at].hidden = true;
+    }
+}
+/**
+ * Fill `into` with one row per line of the tree's last rebuild.
+ *
+ * **The indent is padding rather than a spacer node**, which halves the node count and means a hit
+ * test on a row covers the indent too — clicking to the left of a deep row's label selects that row,
+ * which is what every tree does and what a spacer would have broken.
+ *
+ * **Nothing here marks the selected row and `UiNode` grows no field for it.** A `selected` flag on
+ * every node in every interface in every game, to serve a panel most of them never build, is the
+ * same trade this package refused when it put node names in `SceneTree` instead of on `SceneNode`.
+ * `tree.rowOf(tree.selected)` is the index, the caller already has the tree, and how a selected row
+ * looks is a decision about a consumer's palette rather than about an editor.
+ */
+export function buildTreePanel(tree, into) {
+    const rows = tree.rows;
+    for (let at = 0; at < rows.length; at++) {
+        const row = rows[at];
+        const node = rowAt(into, at, TREE_ROW_PREFIX);
+        node.paddingLeft = row.depth * INDENT;
+        node.text = row.hasChildren ? `${row.expanded ? '-' : '+'} ${row.name}` : `  ${row.name}`;
+    }
+    hideFrom(into, rows.length);
+    return rows.length;
+}
+/**
+ * Fill `into` with one row per inspector field.
+ *
+ * The label carries the group where a field belongs to a component, because two components can
+ * declare the same field name and a panel showing `health` twice with no way to tell them apart is
+ * worse than one that is a little wordier.
+ */
+export function buildInspectorPanel(inspector, into) {
+    const fields = inspector.fields;
+    for (let at = 0; at < fields.length; at++) {
+        const field = fields[at];
+        const node = rowAt(into, at, FIELD_ROW_PREFIX);
+        const label = field.group === 'transform' ? field.label : `${field.group}.${field.label}`;
+        node.text = `${label}  ${formatValue(field.value, field.kind)}`;
+    }
+    hideFrom(into, fields.length);
+    return fields.length;
+}
+/**
+ * A value as a row shows it.
+ *
+ * **A boolean reads as a word and an enum as its number**, which is as far as this can honestly go:
+ * the variant list belongs to the module that declared the enum, and a component is handed
+ * `enum:Mood` — a name and no variants. A consumer holding the list formats its own.
+ */
+export function formatValue(value, kind) {
+    if (value === null || value === undefined)
+        return '—';
+    if (kind === 'boolean')
+        return value ? 'true' : 'false';
+    if (kind === 'text')
+        return String(value);
+    if (typeof value !== 'number')
+        return String(value);
+    if (kind === 'integer' || kind === 'enum' || kind === 'entity')
+        return String(Math.trunc(value));
+    return Number.isInteger(value) ? value.toFixed(1) : value.toFixed(3);
+}

package/dist/sceneTree.d.ts

@@ -0,0 +1,74 @@
+/**
+ * A flattened, collapsible, named view of a `SceneNode` hierarchy.
+ *
+ * **A view and not a second scene graph.** The hierarchy belongs to `@driftengine/core`; this holds
+ * what an editor needs on top of it — which rows are showing, which is selected, and what each one
+ * is called — and nothing that a game running without an editor should carry.
+ *
+ * **The names live here, and that is the one real decision in this file.** `SceneNode` has none. A
+ * string on every node would be paid by every game, in every serialised scene and every allocation
+ * of a node, to serve an editor most of them never open. A map here is paid by whoever builds a
+ * tree.
+ */
+import type { SceneNode } from '@driftengine/core';
+/** One line of the flattened tree. Reused between rebuilds; copy what you keep. */
+export interface TreeRow {
+    node: SceneNode;
+    /** How deep, with the root at zero. What a panel indents by. */
+    depth: number;
+    /** Whether this node has children at all, which is what draws a twisty. */
+    hasChildren: boolean;
+    /** Whether its children are showing. Meaningless when `hasChildren` is false. */
+    expanded: boolean;
+    name: string;
+}
+export declare class SceneTree {
+    /** What is selected, or null. Assigning is fine; nothing here caches it. */
+    selected: SceneNode | null;
+    private readonly names;
+    private readonly collapsed;
+    /**
+     * Rows, reused.
+     *
+     * `rowCount` is how many of them are live, so a rebuild that produces fewer rows than the last
+     * one does not allocate and does not have to clear the tail. `rows` slices to the live ones.
+     */
+    private readonly pool;
+    private rowCount;
+    private readonly live;
+    /** The rows the last `rebuild` produced, in the order they draw. */
+    get rows(): readonly TreeRow[];
+    /** What a node is called. Nodes are `node` until something names them. */
+    name(node: SceneNode): string;
+    setName(node: SceneNode, name: string): void;
+    /** Whether a node's children are showing. Everything starts expanded. */
+    expanded(node: SceneNode): boolean;
+    setExpanded(node: SceneNode, expanded: boolean): void;
+    toggle(node: SceneNode): void;
+    /**
+     * Walk the hierarchy into rows, honouring collapse.
+     *
+     * A collapsed node contributes its own row and nothing beneath it, which is what collapsing is;
+     * its children keep whatever expansion state they had, so expanding a branch again shows what was
+     * showing before rather than a flattened one.
+     *
+     * Cheap enough to call every frame, and it allocates nothing once the deepest tree it has seen
+     * has been seen.
+     */
+    rebuild(root: SceneNode): void;
+    /** Where a node sits in the last rebuild's rows, or `-1`. */
+    rowOf(node: SceneNode): number;
+    /**
+     * Move a node under a new parent. `false` where the hierarchy refuses.
+     *
+     * **The refusal is `SceneNode`'s and is not re-implemented here**, which was checked rather than
+     * assumed: `attachChild` already rejects a node as its own child and any ancestor as its own
+     * descendant. What this adds is answering rather than throwing, because the caller is a drag in a
+     * frame and an exception there takes down the frame somebody is dragging in.
+     */
+    reparent(child: SceneNode, parent: SceneNode): boolean;
+    /** Forget a node's name and expansion, for a node that has left the tree. */
+    forget(node: SceneNode): void;
+    private visit;
+    private rowAt;
+}