A fast 2D and 3D game engine — TypeScript SDK, C++/WebAssembly core, visual editor. Ship one project to web, desktop, WeChat MiniGames, playable ads, and native Android / iOS.
TypeScript 2d-game-engine3d3d-game-engineandroidcppecsgame-editorgame-enginegamedeviostypescriptwebassemblywebglwebgpuwechat-minigame
feat(outliner): sibling sort modes + drag-between reorder
esenginea65408b640e4
diff --git a/desktop/src/engine/SceneCommands.ts b/desktop/src/engine/SceneCommands.tsindex ba6bf1f9d..236fd8894 100644--- a/desktop/src/engine/SceneCommands.ts+++ b/desktop/src/engine/SceneCommands.ts@@ -554,6 +554,44 @@ export class SceneCommandsImpl {this.history.record(records.length > 1 ? `Move ${records.length} to Folder` : 'Move to Folder', apply, revert);}+ /**+ * Drag-reorder: move an entity to sit immediately before/after a sibling target.+ * Aligns the dragged entity's parent + folder to the target's first (so it+ * becomes a true sibling), then reorders scene order. One undo step; rejects+ * dropping onto its own descendant (cycle) and no-op drops.+ */+ reorderEntity(sourceId: EntityId, targetId: EntityId, before: boolean): void {+ if (sourceId === targetId) return;+ const src = this.model.entityBySource(sourceId);+ const tgt = this.model.entityBySource(targetId);+ if (!src || !tgt) return;+ if (this.isModelAncestor(targetId, sourceId)) return; // target is under source → cycle++ const targetParent = tgt.parent ?? null;+ const targetFolder = targetParent === null ? this.model.folderOf(targetId) : '';+ const beforeOrder = this.model.entityOrder();+ const beforeParent = src.parent ?? null;+ const beforeFolder = this.model.folderOf(sourceId);++ const apply = (): void => {+ if ((this.model.entityBySource(sourceId)?.parent ?? null) !== targetParent) this.model.setParent(sourceId, targetParent);+ if (targetParent === null) this.model.setFolder(sourceId, targetFolder);+ this.model.moveEntityAdjacent(sourceId, targetId, before);+ };+ apply();++ const afterOrder = this.model.entityOrder();+ const orderSame = beforeOrder.length === afterOrder.length && beforeOrder.every((id, i) => id === afterOrder[i]);+ const folderSame = targetParent !== null || beforeFolder === targetFolder;+ if (orderSame && beforeParent === targetParent && folderSame) return; // dropped in place++ this.history.record('Reorder', apply, () => {+ this.model.setEntityOrder(beforeOrder);+ this.model.setFolder(sourceId, beforeFolder);+ this.model.setParent(sourceId, beforeParent);+ });+ }+/** Add a component (with its registered/schema defaults) to an entity. Undoable. */// Apply an add to the model and return its undo op, or null if it's a no-op// (entity gone / component already present). Shared by the single + batch paths.diff --git a/desktop/src/engine/SceneModel.ts b/desktop/src/engine/SceneModel.tsindex cd2752fc5..7175c7f79 100644--- a/desktop/src/engine/SceneModel.ts+++ b/desktop/src/engine/SceneModel.ts@@ -29,7 +29,9 @@ export type ModelEvent =// folds it into the render projection; it never touches component data.| { kind: 'hiddenChanged'; sourceId: number }// An entity's editor lock changed — pure editor state (picking/selection only).- | { kind: 'lockChanged'; sourceId: number };+ | { kind: 'lockChanged'; sourceId: number }+ // Scene entity order changed (sibling drag-reorder) — affects render order only.+ | { kind: 'orderChanged' };type Listener = (ev: ModelEvent) => void;@@ -335,6 +337,42 @@ export class SceneModelImpl {this.emit({ kind: 'lockChanged', sourceId });}+ // ── Sibling order (outliner drag-reorder; render order = `data.entities` order) ──+ // The outliner derives sibling order from each entity's position in+ // `data.entities` (buildSceneTree's parent index preserves it), so reordering is+ // reordering this array. The World is order-agnostic (ECS), so these never reach+ // the Reconciler.++ /** The scene's entity ids in current (render) order. */+ entityOrder(): number[] {+ return this.data ? this.data.entities.map((e) => e.id) : [];+ }++ /** Reorder `data.entities` to match `ids` (ids absent from the list keep their tail order). */+ setEntityOrder(ids: number[]): void {+ if (!this.data) return;+ const rank = new Map(ids.map((id, i) => [id, i]));+ this.data.entities.sort((a, b) => (rank.get(a.id) ?? Infinity) - (rank.get(b.id) ?? Infinity));+ this.emit({ kind: 'orderChanged' });+ }++ /** Move an entity immediately before/after a target in scene order (drag-reorder). */+ moveEntityAdjacent(sourceId: number, targetId: number, before: boolean): void {+ if (!this.data || sourceId === targetId) return;+ const arr = this.data.entities;+ const si = arr.findIndex((e) => e.id === sourceId);+ if (si < 0) return;+ const [moved] = arr.splice(si, 1);+ let ti = arr.findIndex((e) => e.id === targetId);+ if (ti < 0) {+ arr.splice(si, 0, moved); // target vanished — put it back+ return;+ }+ if (!before) ti += 1;+ arr.splice(ti, 0, moved);+ this.emit({ kind: 'orderChanged' });+ }+// ── Source↔runtime map (Reconciler-only writers) ─────────────────────────/** Bind a source id to its current runtime entity (Reconciler, on spawn). */diff --git a/desktop/src/outliner/OutlinerController.ts b/desktop/src/outliner/OutlinerController.tsindex 1fa5b2d0f..9f7f9b266 100644--- a/desktop/src/outliner/OutlinerController.ts+++ b/desktop/src/outliner/OutlinerController.ts@@ -17,7 +17,7 @@import { create } from 'zustand';import { SceneModel, SceneModelImpl } from '@/engine/SceneModel';import type { EntityId } from '@/types';-import { entityKey, folderKey } from './OutlinerModel';+import { entityKey, folderKey, type SortMode } from './OutlinerModel';import { folderPrefixes, normalizeFolder, rebaseFolder } from './folders';interface OutlinerState {@@ -27,6 +27,8 @@ interface OutlinerState {query: string;/** Keyboard-focus row (item key) — drives ↑↓←→ navigation; null = none. */cursor: string | null;+ /** Sibling sort: `manual` (scene order) / `name` / `type`. View-only. */+ sortMode: SortMode;/** Flip one row's expansion (pass an item key). */toggleExpanded: (key: string) => void;@@ -41,6 +43,7 @@ interface OutlinerState {setQuery: (query: string) => void;/** Move the keyboard-focus row. */setCursor: (key: string | null) => void;+ setSortMode: (mode: SortMode) => void;/** Prune a removed entity's key (self-heal on the model's `entityRemoved`). */dropId: (id: EntityId) => void;@@ -54,6 +57,7 @@ export function createOutlinerStore(model: SceneModelImpl) {expanded: new Set<string>(),query: '',cursor: null,+ sortMode: 'manual',toggleExpanded: (key) =>set((s) => {@@ -101,6 +105,7 @@ export function createOutlinerStore(model: SceneModelImpl) {}),setQuery: (query) => set({ query }),setCursor: (cursor) => set({ cursor }),+ setSortMode: (sortMode) => set({ sortMode }),dropId: (id) =>set((s) => {diff --git a/desktop/src/outliner/OutlinerModel.ts b/desktop/src/outliner/OutlinerModel.tsindex 85ef7cd45..c28e375ed 100644--- a/desktop/src/outliner/OutlinerModel.ts+++ b/desktop/src/outliner/OutlinerModel.ts@@ -52,9 +52,14 @@ export const entityKey = (id: EntityId): string => `e${id}`;/** Expansion/identity key for a folder row. */export const folderKey = (path: string): string => `f:${path}`;+/** Sibling sort: `manual` keeps scene (data) order; `name`/`type` are view-only. */+export type SortMode = 'manual' | 'name' | 'type';+export interface BuildOutlinerOpts {/** Expanded item keys. Ignored when `expandAll` (or a filter) is on. */expanded: ReadonlySet<string>;+ /** Sibling sort mode (default `manual` = scene order). */+ sort?: SortMode;/** A root entity's folder path (`""` = scene root). Absent ⇒ no folders (PIE). */folderOf?: (id: EntityId) => string;/** The scene's explicit (incl. empty) folders, so empties still show. */@@ -94,6 +99,15 @@ export function parseQuery(raw: string): ParsedQuery {const queryActive = (q: ParsedQuery): boolean => q.text !== '' || q.types.length > 0 || q.comps.length > 0;+/** Sort a sibling list by mode (manual = unchanged scene order). */+function sortNodes(nodes: SceneNode[], mode: SortMode): SceneNode[] {+ if (mode === 'manual') return nodes;+ const by = mode === 'name'+ ? (a: SceneNode, b: SceneNode) => a.name.localeCompare(b.name)+ : (a: SceneNode, b: SceneNode) => a.kind.localeCompare(b.kind) || a.name.localeCompare(b.name);+ return [...nodes].sort(by);+}+/** Keep a node if it matches `keep`, or any descendant does (matches + ancestors). */function filterNode(node: SceneNode, keep: (n: SceneNode) => boolean): SceneNode | null {if (keep(node)) return node; // self matches → keep the whole subtree@@ -124,6 +138,7 @@ export function buildOutlinerItems(data: SceneData | null, opts: BuildOutlinerOpconst shown = active ? roots.map((n) => filterNode(n, keep)).filter((n): n is SceneNode => n != null) : roots;const expandAll = !!opts.expandAll || active;const folderOf = opts.folderOf ?? (() => ROOT_FOLDER);+ const sort = opts.sort ?? 'manual';// Group the shown roots by their folder path, and gather every folder to show:// each root path's prefixes, plus the scene's explicit folders (only when not@@ -151,7 +166,7 @@ export function buildOutlinerItems(data: SceneData | null, opts: BuildOutlinerOpconst hasChildren = !!node.children?.length;const expanded = expandAll || opts.expanded.has(entityKey(node.id));out.push({ kind: 'entity', key: entityKey(node.id), id: node.id, node, depth, hasChildren, expanded, parentKey });- if (hasChildren && expanded) for (const c of node.children!) emitEntity(c, depth + 1, entityKey(node.id));+ if (hasChildren && expanded) for (const c of sortNodes(node.children!, sort)) emitEntity(c, depth + 1, entityKey(node.id));};// Emit the child folders of `path` (nested) then the entity roots directly in it.@@ -162,7 +177,7 @@ export function buildOutlinerItems(data: SceneData | null, opts: BuildOutlinerOpout.push({ kind: 'folder', key: folderKey(fp), path: fp, name: folderName(fp), count: countUnder(fp), depth, hasChildren: hasKids, expanded, parentKey });if (expanded) emitFolderContents(fp, depth + 1, folderKey(fp));}- for (const root of rootsByFolder.get(path) ?? []) emitEntity(root, depth, parentKey);+ for (const root of sortNodes(rootsByFolder.get(path) ?? [], sort)) emitEntity(root, depth, parentKey);};emitFolderContents(ROOT_FOLDER, 0, null);diff --git a/desktop/src/outliner/OutlinerRow.tsx b/desktop/src/outliner/OutlinerRow.tsxindex bf5efc4f1..650fb831b 100644--- a/desktop/src/outliner/OutlinerRow.tsx+++ b/desktop/src/outliner/OutlinerRow.tsx@@ -52,7 +52,8 @@ export interface OutlinerRowProps {/** Lowercased substring to highlight in the name (the search bare text). */highlight?: string;renaming?: boolean;- isDrop?: boolean;+ /** Active drop indicator: `on` (full row) or a between-rows insertion line. */+ dropPos?: 'before' | 'on' | 'after';/** Prefab-instance member — warm icon tint (entity rows only). */prefab?: boolean;/** When false, the twist is hidden + non-interactive (the always-expanded PIE tree). */@@ -71,7 +72,7 @@ export interface OutlinerRowProps {}export function OutlinerRow(props: OutlinerRowProps) {- const { item, selected, renaming, isDrop, prefab } = props;+ const { item, selected, renaming, dropPos, prefab } = props;const isFolder = item.kind === 'folder';const { depth, hasChildren, expanded } = item;@@ -107,7 +108,9 @@ export function OutlinerRow(props: OutlinerRowProps) {`${locked ? ' locked' : ''}` +`${prefab ? ' prefab' : ''}` +`${isFolder ? ' folder' : ''}` +- `${isDrop ? ' drop' : ''}`+ `${dropPos === 'on' ? ' drop' : ''}` ++ `${dropPos === 'before' ? ' drop-before' : ''}` ++ `${dropPos === 'after' ? ' drop-after' : ''}`}style={{ paddingLeft: depth * 14 }}draggable={props.draggable && !renaming}diff --git a/desktop/src/panels/Outliner.tsx b/desktop/src/panels/Outliner.tsxindex 29bc4526e..2dfd3646a 100644--- a/desktop/src/panels/Outliner.tsx+++ b/desktop/src/panels/Outliner.tsx@@ -1,7 +1,7 @@// SPDX-License-Identifier: LicenseRef-PolyForm-Noncommercial-1.0.0// SPDX-FileCopyrightText: Copyright (c) 2024-present ESEngine Teamimport { useEffect, useMemo, useRef, useState, useSyncExternalStore } from 'react';-import { Search, Plus, FolderPlus } from 'lucide-react';+import { Search, Plus, FolderPlus, ArrowDownUp } from 'lucide-react';import { useEditorStore } from '@/store/editorStore';import { useSelection } from '@/store/selectionStore';import { EngineHost } from '@/engine/EngineHost';@@ -70,6 +70,7 @@ export function Outliner() {const setQuery = useOutliner((s) => s.setQuery);const toggleExpanded = useOutliner((s) => s.toggleExpanded);const cursor = useOutliner((s) => s.cursor);+ const sortMode = useOutliner((s) => s.sortMode);const selectedIds = useSelection((s) => s.selectedIds);const selectedId = useSelection((s) => s.selectedId);const isPlaying = useEditorStore((s) => s.isPlaying);@@ -79,8 +80,9 @@ export function Outliner() {const dragIds = useRef<EntityId[] | null>(null);const [renaming, setRenaming] = useState<string | null>(null); // item key- const [dropId, setDropId] = useState<string | null>(null); // item key+ const [drop, setDrop] = useState<{ key: string; pos: 'before' | 'on' | 'after' } | null>(null);const [ctx, setCtx] = useState<{ x: number; y: number; item: OutlinerItem } | null>(null);+ const [sortMenu, setSortMenu] = useState<{ x: number; y: number } | null>(null);// Controlled scroll for reveal-on-select + keyboard nav (nonce re-fires same index).const [scrollTo, setScrollTo] = useState<{ index: number; nonce: number }>({ index: -1, nonce: 0 });const scrollNonce = useRef(0);@@ -96,11 +98,12 @@ export function Outliner() {? buildOutlinerItems(SceneModel.current, {expanded,query,+ sort: sortMode,folderOf: (id) => SceneModel.folderOf(id),folders: SceneModel.sceneFolders(),}): [],- [engine.status, structRev, expanded, query],+ [engine.status, structRev, expanded, query, sortMode],);const flatIds = useMemo(() => entityIds(items), [items]);const highlight = useMemo(() => parseQuery(query).text, [query]);@@ -289,32 +292,52 @@ export function Outliner() {else if (isAssetDrag(e)) e.dataTransfer.dropEffect = 'copy';else return;e.preventDefault();- if (dropId !== item.key) setDropId(item.key);+ // Hovering the top/bottom quarter of an entity row (manual sort, entity drag)+ // is a between-rows reorder; the middle is a reparent. Folders are always 'on'.+ let pos: 'before' | 'on' | 'after' = 'on';+ if (dragIds.current && item.kind === 'entity' && sortMode === 'manual') {+ const rect = e.currentTarget.getBoundingClientRect();+ const rel = (e.clientY - rect.top) / rect.height;+ pos = rel < 0.25 ? 'before' : rel > 0.75 ? 'after' : 'on';+ }+ if (drop?.key !== item.key || drop?.pos !== pos) setDrop({ key: item.key, pos });};const reparent = (target: EntityId | null) => {const ids = dragIds.current;dragIds.current = null;- setDropId(null);+ setDrop(null);if (!ids) return;for (const child of ids) if (child !== target) SceneCommands.setParent(child, target);};const moveToFolder = (path: string | null) => {const ids = dragIds.current;dragIds.current = null;- setDropId(null);+ setDrop(null);if (ids) SceneCommands.moveToFolder(ids, path);};const onDropRow = (item: OutlinerItem, e: React.DragEvent) => {e.preventDefault();e.stopPropagation();- setDropId(null);+ const pos = drop?.pos ?? 'on';+ setDrop(null);if (item.kind === 'folder') {if (dropPrefabAsset(e, null)) return; // prefab onto a folder → instantiate at rootmoveToFolder(item.path);return;}if (dropPrefabAsset(e, item.id)) return; // prefab onto an entity = under it- reparent(item.id);+ if (pos === 'on') {+ reparent(item.id);+ return;+ }+ // Drop-between → reorder as a sibling of the target ('after' reversed so a+ // multi-drag keeps its relative order).+ const ids = dragIds.current;+ dragIds.current = null;+ if (ids) {+ const ordered = pos === 'before' ? ids : [...ids].reverse();+ for (const id of ordered) if (id !== item.id) SceneCommands.reorderEntity(id, item.id, pos === 'before');+ }};// Empty-space drop = move to the scene root (un-parent + clear folder).@@ -384,7 +407,7 @@ export function Outliner() {cursored={cursor === it.key}highlight={highlight}renaming={renaming === it.key}- isDrop={dropId === it.key}+ dropPos={drop?.key === it.key ? drop.pos : undefined}prefab={it.kind === 'entity' && SceneModel.prefabTag(it.id) != null}draggable={it.kind === 'entity'}onToggle={toggleExpanded}@@ -426,6 +449,17 @@ export function Outliner() {onChange={(e) => setQuery(e.target.value)}/></div>+ <button+ type="button"+ className={`pbtn${sortMode !== 'manual' ? ' on' : ''}`}+ title={`Sort: ${sortMode}`}+ onClick={(e) => {+ const r = e.currentTarget.getBoundingClientRect();+ setSortMenu({ x: r.left, y: r.bottom + 2 });+ }}+ >+ <ArrowDownUp size={14} strokeWidth={2} />+ </button><button type="button" className="pbtn" title="New folder" onClick={() => newFolder('', null)}><FolderPlus size={15} strokeWidth={2} /></button>@@ -473,6 +507,17 @@ export function Outliner() {)}{ctx && !gameMode && <ContextMenu x={ctx.x} y={ctx.y} items={ctxItems} onClose={() => setCtx(null)} />}+ {sortMenu && !gameMode && (+ <ContextMenu+ x={sortMenu.x}+ y={sortMenu.y}+ onClose={() => setSortMenu(null)}+ items={(['manual', 'name', 'type'] as const).map((m) => ({+ label: `Sort: ${m[0].toUpperCase()}${m.slice(1)}`,+ onClick: () => useOutliner.getState().setSortMode(m),+ }))}+ />+ )}</div>);}diff --git a/desktop/src/theme/outliner.css b/desktop/src/theme/outliner.cssindex 5f3573903..451fb17cb 100644--- a/desktop/src/theme/outliner.css+++ b/desktop/src/theme/outliner.css@@ -26,6 +26,7 @@transition: color var(--t-fast), background var(--t-fast);}.pbtn:hover { color: var(--text); background: var(--srf-4); }+.pbtn.on { color: var(--acc); }.pbody { flex: 1; min-height: 0; overflow-y: auto; overflow-x: hidden; }/* Column header strip */@@ -62,6 +63,9 @@.row.sel { background: var(--acc); color: #fff; }.row.sel:hover { background: var(--acc); }.row.drop { background: var(--acc-soft); box-shadow: inset 0 0 0 1px var(--acc); }+/* Between-rows reorder insertion line (top = before, bottom = after). */+.row.drop-before { box-shadow: inset 0 2px 0 0 var(--acc); }+.row.drop-after { box-shadow: inset 0 -2px 0 0 var(--acc); }/* Keyboard-focus ring (distinct from selection; mainly visible on folder rows). */.row.cursor:not(.sel) { box-shadow: inset 0 0 0 1px var(--acc-soft); }.pbody:focus, .pbody:focus-visible { outline: none; }diff --git a/desktop/tests/outliner-model.test.ts b/desktop/tests/outliner-model.test.tsindex 3ccdaf5f4..c98e39381 100644--- a/desktop/tests/outliner-model.test.ts+++ b/desktop/tests/outliner-model.test.ts@@ -160,3 +160,30 @@ describe('token search', () => {expect(queryIds(compScene(), 'type:sprite zzz')).toEqual([]); // name fails → none});});++// kinds: 2=camera, 1/3/4=sprite. names chosen so name-sort ≠ type-sort.+function sortScene(): SceneData {+ return {+ version: '1.0',+ name: 's',+ entities: [+ { id: 1, name: 'Zed', parent: null, children: [], components: [{ type: 'Sprite', data: {} }] },+ { id: 2, name: 'Apple', parent: null, children: [], components: [{ type: 'Camera', data: {} }] },+ { id: 3, name: 'Mid', parent: null, children: [], components: [{ type: 'Sprite', data: {} }] },+ { id: 4, name: 'Aaa', parent: null, children: [], components: [{ type: 'Sprite', data: {} }] },+ ],+ } as unknown as SceneData;+}++describe('sort mode', () => {+ const sortedKeys = (sort: 'manual' | 'name' | 'type') => keys(buildOutlinerItems(sortScene(), { expanded: new Set(), sort }));+ it('manual keeps scene (data) order', () => {+ expect(sortedKeys('manual')).toEqual(['e1', 'e2', 'e3', 'e4']);+ });+ it('name sorts alphabetically', () => {+ expect(sortedKeys('name')).toEqual(['e4', 'e2', 'e3', 'e1']); // Aaa, Apple, Mid, Zed+ });+ it('type sorts by kind then name', () => {+ expect(sortedKeys('type')).toEqual(['e2', 'e4', 'e3', 'e1']); // camera(Apple), then sprites Aaa, Mid, Zed+ });+});diff --git a/desktop/tests/outliner-reorder.test.ts b/desktop/tests/outliner-reorder.test.tsnew file mode 100644index 000000000..625a64fe0--- /dev/null+++ b/desktop/tests/outliner-reorder.test.ts@@ -0,0 +1,56 @@+// SPDX-License-Identifier: LicenseRef-PolyForm-Noncommercial-1.0.0+// SPDX-FileCopyrightText: Copyright (c) 2024-present ESEngine Team+/**+ * @file Outliner sibling drag-reorder (REARCH_OUTLINER P4). Render order derives+ * from `data.entities` order; reorderEntity aligns parent+folder to the+ * target then moves the entity adjacent, undoable. Model+command only.+ */+import { describe, it, expect, beforeEach } from 'vitest';+import type { SceneData } from 'esengine';+import { EditorSession } from '@/engine/EditorSession';++const ent = (id: number, parent: number | null, children: number[]) => ({ id, name: `E${id}`, parent, children, components: [] as unknown[] });+const flat = (): SceneData => ({ version: '1.0', name: 'o', entities: [ent(1, null, []), ent(2, null, []), ent(3, null, [])] }) as unknown as SceneData;++describe('SceneCommands.reorderEntity', () => {+ let S: EditorSession;+ beforeEach(() => {+ S = EditorSession.create();+ S.model.adopt(flat(), new Map());+ });++ it('moves a sibling before a target; undo restores scene order', () => {+ expect(S.model.entityOrder()).toEqual([1, 2, 3]);+ S.commands.reorderEntity(3, 1, true); // drop 3 before 1+ expect(S.model.entityOrder()).toEqual([3, 1, 2]);+ S.history.undo();+ expect(S.model.entityOrder()).toEqual([1, 2, 3]);+ });++ it('moves a sibling after a target', () => {+ S.commands.reorderEntity(1, 3, false); // drop 1 after 3+ expect(S.model.entityOrder()).toEqual([2, 3, 1]);+ });++ it('aligns the dragged entity folder to the target (root drop)', () => {+ S.model.setFolder(1, 'A/B');+ S.commands.reorderEntity(2, 1, true); // 2 before 1 → inherits folder A/B+ expect(S.model.folderOf(2)).toBe('A/B');+ expect(S.model.entityOrder()).toEqual([2, 1, 3]);+ S.history.undo();+ expect(S.model.folderOf(2)).toBe('');+ expect(S.model.entityOrder()).toEqual([1, 2, 3]);+ });++ it('rejects dropping onto its own descendant (cycle)', () => {+ S.model.adopt({ version: '1.0', name: 'o', entities: [ent(1, null, [2]), ent(2, 1, [])] } as unknown as SceneData, new Map());+ S.commands.reorderEntity(1, 2, true); // 1 is 2's ancestor → rejected, order unchanged+ expect(S.model.entityOrder()).toEqual([1, 2]);+ });++ it('a drop in place records nothing (no undo step)', () => {+ const before = S.history.canUndo();+ S.commands.reorderEntity(2, 2, true); // onto self → no-op+ expect(S.history.canUndo()).toBe(before);+ });+});