@downdraft/engine 0.2.0 → 0.3.1

package/dist/modules/devtools/src/init.js

@@ -5,10 +5,10 @@
 //   1. Creating an IDevToolsDataRenderer adapter
 //   2. Instantiating DevToolsDataBridge (or BaseSceneInspector)
 //   3. Calling init()
-//   4. Wiring sim stats provider, panel extensions, overlay toggles, etc.
+//   4. Wiring sim stats provider, debug overlay provider, etc.
 //
-// Also merges globally-registered panels/feeds/commands from the `devtools`
-// singleton (registered by plugins via ctx.devtools.registerPanel() etc.)
+// Also merges globally-registered feeds/commands from the `devtools`
+// singleton (registered by plugins via ctx.devtools.registerDataFeed() etc.)
 // and from worker manifests (via syncWorkerManifests).
 //
 // Returns the bridge instance for games that need post-init calls
@@ -22,7 +22,7 @@ import { BaseSceneInspector } from "./scene-inspector.js";
 import { syncWorkerManifests } from "./worker-sync.js";
 /**
  * Initialize DevTools with one call. Creates the bridge, wires all providers,
-  merges globally-registered panels/feeds/commands, syncs worker manifests,
+ * merges globally-registered feeds/commands, syncs worker manifests,
  * and exposes the API on window.__sceneInspector.
  *
  * Returns the bridge instance.
@@ -34,19 +34,7 @@ export async function initDevTools(renderer, options = {}) {
     const useSceneInspector = options.sceneInspector
         || !!options.bridgeClass
         || isSceneRenderer(renderer);
-    // 3. Register game-declared panels/toggles into the global registry
-    //    (these merge with plugin-registered ones)
-    if (options.panels) {
-        options.panels.forEach((panel) => {
-            devtools.registerPanel(panel);
-        });
-    }
-    if (options.overlayToggles) {
-        options.overlayToggles.forEach((toggle) => {
-            devtools.registerOverlayToggle(toggle);
-        });
-    }
-    // 4. Sync worker manifests (fetches panels/feeds/commands from sim workers)
+    // 4. Sync worker manifests (fetches feeds/commands from sim workers)
     if (options.workerHosts && options.workerHosts.length > 0) {
         await syncWorkerManifests(options.workerHosts);
     }
@@ -85,10 +73,8 @@ export async function initDevTools(renderer, options = {}) {
     if (options.performanceMetricsProvider) {
         wirePerformanceMetricsProvider(bridge, options.performanceMetricsProvider);
     }
-    // 7. Merge globally-registered panels/toggles/feeds/commands into the bridge
-    //    The bridge's getPanelExtensions()/getOverlayToggles() already returns
-    //    game-declared ones; we augment the __sceneInspector API with
-    //    plugin-registered data feeds and commands.
+    // 7. Merge globally-registered feeds/commands/SAB stats into the bridge —
+    //    augments the __sceneInspector API with plugin-registered methods.
     mergeGlobalRegistrations(bridge);
     // 8. Initialize the profiling system (if enabled)
     if (options.profiling) {
@@ -134,35 +120,15 @@ function wirePerformanceMetricsProvider(bridge, provider) {
     bridge.getPerformanceMetricsProvider = () => provider;
 }
 /**
- * Merge globally-registered panels, data feeds, and commands from the `devtools`
+ * Merge globally-registered data feeds and commands from the `devtools`
  * singleton into the bridge's __sceneInspector API.
  *
- * - Panels: merged into getPanelExtensions() (game panels + plugin panels)
  * - Data feeds: added as methods on __sceneInspector (called synchronously)
  * - Commands: added as methods on __sceneInspector (forwarded to worker or called directly)
  * - SAB stats: added as methods on __sceneInspector (read from SAB)
  */
 function mergeGlobalRegistrations(bridge) {
     const manifest = devtools.getManifest();
-    // Augment getPanelExtensions to merge global registry panels
-    const originalGetPanels = bridge.getPanelExtensions?.bind(bridge);
-    bridge.getPanelExtensions = () => {
-        const gamePanels = originalGetPanels?.() ?? [];
-        // Merge: game panels take precedence on id collisions
-        const merged = new Map();
-        manifest.panels.forEach((p) => { merged.set(p.id, p); ; });
-        gamePanels.forEach((p) => { merged.set(p.id, p); ; });
-        return Array.from(merged.values()).sort((a, b) => (a.order ?? 100) - (b.order ?? 100));
-    };
-    // Augment getOverlayToggles to merge global registry toggles
-    const originalGetToggles = bridge.getOverlayToggles?.bind(bridge);
-    bridge.getOverlayToggles = () => {
-        const gameToggles = originalGetToggles?.() ?? [];
-        const merged = new Map();
-        manifest.toggles.forEach((t) => { merged.set(t.id, t); ; });
-        gameToggles.forEach((t) => { merged.set(t.id, t); ; });
-        return Array.from(merged.values());
-    };
     // Add data feed methods to the __sceneInspector API
     // These are called synchronously by the panel via callInspector()
     const api = window.__sceneInspector;

package/dist/modules/devtools/src/scene-inspector.js

@@ -27,7 +27,6 @@ export class BaseSceneInspector extends DevToolsDataBridge {
     getDebugOverlayProvider() {
         return null;
     }
-    // getPanelExtensions() and getOverlayToggles() inherited from DevToolsDataBridge.
     // --- Init ---
     init(renderer) {
         super.init(renderer);
@@ -510,9 +509,7 @@ export class BaseSceneInspector extends DevToolsDataBridge {
             const cosY = Math.cos(angleY), sinY = Math.sin(angleY);
             const cosX = Math.cos(angleX), sinX = Math.sin(angleX);
             const THUMB_SIZE = 192;
-            const canvas = document.createElement("canvas");
-            canvas.width = THUMB_SIZE;
-            canvas.height = THUMB_SIZE;
+            const canvas = new OffscreenCanvas(THUMB_SIZE, THUMB_SIZE);
             const ctx = canvas.getContext("2d");
             if (!ctx)
                 return null;

package/dist/modules/devtools/src/worker-sync.js

@@ -1,14 +1,13 @@
 // ============================================================================
 // Renderer-side worker manifest sync — fetches the devtools manifest from
-// one or more sim workers via worker RPC, then wires the worker-registered panels,
-// data feeds, and commands into the renderer-side __sceneInspector API.
+// one or more sim workers via worker RPC, then wires the worker-registered
+// data feeds and commands into the renderer-side __sceneInspector API.
 //
 // Data feeds from workers are read from the devtools SAB (zero-copy).
 // Commands are forwarded via worker RPC.
-// Panel declarations are merged into the global registry.
 // ============================================================================
 import { createLogger } from "@downdraft/engine/util/logger";
-import { _devtoolsImpl, devtools } from "./api.js";
+import { _devtoolsImpl } from "./api.js";
 const log = createLogger("info");
 /**
  * Sync manifests from one or more workers into the renderer-side devtools
@@ -54,13 +53,6 @@ async function syncOneWorker(entry) {
             // Worker may not have a devtools SAB (older workers)
         }
     }
-    // Register panels (namespaced by prefix to avoid collisions)
-    manifest.panels.forEach((panel) => {
-        const namespaced = prefix
-            ? { ...panel, id: `${prefix}:${panel.id}` }
-            : panel;
-        devtools.registerPanel(namespaced);
-    });
     // Register data feed readers — these read from the SAB synchronously
     // We register them as main-realm data feeds that read from the worker SAB
     if (sab) {

package/dist/modules/html-ui/src/doc-backend.js

@@ -147,9 +147,32 @@ export function createDocCore(emit, gpuHooks) {
             s.statsLast = now;
         }
     }
+    // Smooth-wheel ease: fraction of the remainder applied per elapsed ms.
+    // τ≈45ms → ~30% per 16ms tick, ~95% drained in ~135ms — snappy but
+    // animated. A 1/MAX_TICKS floor bounds any backlog at ~320ms of drain —
+    // a fast wheel can't make scroll trail input indefinitely. Dispatching
+    // real wheel events keeps Blitz's hit-testing, scroll chaining, scrollbar
+    // reveal, and scroll DOM events intact.
+    const WHEEL_TAU_MS = 45;
+    const WHEEL_MAX_TICKS = 20;
+    function stepWheel(s, now) {
+        const dt = Math.min(50, Math.max(1, now - s.wheelT));
+        s.wheelT = now;
+        const f = Math.max(1 - Math.exp(-dt / WHEEL_TAU_MS), 1 / WHEEL_MAX_TICKS);
+        // Snap the tail: a step below ~¾px/axis applies the whole residue instead
+        // of asymptoting through invisible sub-pixel repaints.
+        const dx = Math.abs(s.wheelRx) * f < 0.75 ? s.wheelRx : s.wheelRx * f;
+        const dy = Math.abs(s.wheelRy) * f < 0.75 ? s.wheelRy : s.wheelRy * f;
+        s.wheelRx -= dx;
+        s.wheelRy -= dy;
+        const k = s.scale;
+        s.doc.wheel(s.wheelX * k, s.wheelY * k, dx * k, dy * k, s.wheelMods);
+    }
     function pump() {
         const now = performance.now();
         for (const [id, s] of docs.entries()) {
+            if (s.smoothWheel && (s.wheelRx !== 0 || s.wheelRy !== 0))
+                stepWheel(s, now);
             const events = s.doc.pollEvents();
             if (events.length)
                 emit({ type: "events", id, events });
@@ -233,6 +256,8 @@ export function createDocCore(emit, gpuHooks) {
                         doc, scale: m.scale, cssW: m.cssW, cssH: m.cssH,
                         maxFps: m.maxFps ?? 0, lastFrame: -1e9,
                         sab: null, sabU32: null, sabDisabled: false, gpuTex: null,
+                        smoothWheel: m.smoothWheel === true,
+                        wheelRx: 0, wheelRy: 0, wheelX: 0, wheelY: 0, wheelT: 0,
                         stats: freshStats(), statsLast: 0,
                     };
                     docs.set(m.id, s);
@@ -245,11 +270,18 @@ export function createDocCore(emit, gpuHooks) {
                         s.maxFps = m.maxFps;
                     break;
                 }
-                case "setHtml":
+                case "setHtml": {
                     if (/float\s*:/.test(m.html))
                         emit({ type: "error", id: m.id, message: "CSS float hangs Blitz layout — use flex instead" });
-                    docs.get(m.id)?.doc.setHtml(m.html);
+                    const s = docs.get(m.id);
+                    if (!s)
+                        break;
+                    // Drop any in-flight smooth-wheel drain — its remainder belongs to
+                    // the document being replaced.
+                    s.wheelRx = s.wheelRy = 0;
+                    s.doc.setHtml(m.html);
                     break;
+                }
                 case "resize": {
                     const s = docs.get(m.id);
                     if (s) {
@@ -374,13 +406,30 @@ export function createDocCore(emit, gpuHooks) {
                             s.doc.pointerMove(msg.x * k, msg.y * k, msg.mods);
                             break;
                         case "down":
+                            // A press interrupts any in-flight wheel scroll (mirrors
+                            // Blitz's interrupt_animation semantics for user input).
+                            s.wheelRx = 0;
+                            s.wheelRy = 0;
                             s.doc.pointerDown(msg.x * k, msg.y * k, msg.button, msg.mods);
                             break;
                         case "up":
                             s.doc.pointerUp(msg.x * k, msg.y * k, msg.button, msg.mods);
                             break;
                         case "wheel":
-                            s.doc.wheel(msg.x * k, msg.y * k, msg.deltaX * k, msg.deltaY * k, msg.mods);
+                            if (s.smoothWheel) {
+                                // A fresh gesture back-dates wheelT so the first pump tick
+                                // applies a full ~16ms step immediately — no dead frame.
+                                if (s.wheelRx === 0 && s.wheelRy === 0)
+                                    s.wheelT = performance.now() - 16;
+                                s.wheelRx += msg.deltaX;
+                                s.wheelRy += msg.deltaY;
+                                s.wheelX = msg.x;
+                                s.wheelY = msg.y;
+                                s.wheelMods = msg.mods;
+                            }
+                            else {
+                                s.doc.wheel(msg.x * k, msg.y * k, msg.deltaX * k, msg.deltaY * k, msg.mods);
+                            }
                             break;
                         case "key":
                             s.doc.key(msg.down, msg.key, msg.code, msg.text, msg.mods);

package/dist/modules/html-ui/src/host.js

@@ -7,6 +7,7 @@
 // ============================================================================
 import { getHostCapabilities, getNativeHost } from "@downdraft/engine/platform/runtime";
 import { createLogger } from "@downdraft/engine/util/logger";
+import { untrackedTimeout } from "@downdraft/engine/util/session-timer";
 import { PanelBlitPass } from "./composite.js";
 import { createLocalBackend, createWorkerBackend } from "./doc-backend.js";
 const log = createLogger("info");
@@ -136,7 +137,7 @@ export class HtmlUiHost {
         this.order.push(id);
         // Doc viewport scale = raster px per CSS px = scale * zoom; layout size
         // is rect/zoom CSS px so the raster still covers rect*scale texture px.
-        this.send({ type: "create", id, cssW: spec.rect.w / zoom, cssH: spec.docH ?? spec.rect.h / zoom, scale: scale * zoom, html: spec.html, maxFps: spec.maxFps });
+        this.send({ type: "create", id, cssW: spec.rect.w / zoom, cssH: spec.docH ?? spec.rect.h / zoom, scale: scale * zoom, html: spec.html, maxFps: spec.maxFps, smoothWheel: spec.smoothWheel });
         // GPU-direct: create the panel texture eagerly so the worker's texBind
         // lands before its first upload — the host knows raster dims at mount.
         if (this.gpuReady)
@@ -301,6 +302,8 @@ export class HtmlUiHost {
     /** Doc-backend capabilities (populated by the `ready` handshake —
      *  `incrementalDom` is false until then, and forever on old cdylibs). */
     get docCaps() { return this.caps; }
+    /** Which doc backend is live — "worker" (raster off-thread) or "local". */
+    get backendKind() { return this.backend.kind; }
     /** Compositor surface for GameRenderer's end-of-frame UI pass. */
     get compositor() {
         return {
@@ -349,7 +352,7 @@ export class HtmlUiHost {
             this.terminating = true;
             this.send({ type: "gpuDetach" });
             const backend = this.backend;
-            setTimeout(() => {
+            untrackedTimeout(() => {
                 if (!this.gpuDetachAcked)
                     backend.dispose();
                 this.destroyRetired();
@@ -775,7 +778,7 @@ export class HtmlUiHost {
                 || (p.postedBindPtr !== null && BigInt(ptr) === p.postedBindPtr));
         if (borrowed) {
             const key = BigInt(ptr);
-            const timer = setTimeout(() => {
+            const timer = untrackedTimeout(() => {
                 if (this.retiredTex.delete(key))
                     t.destroy();
             }, 1000);

package/dist/test/src/vision-test.js

@@ -155,9 +155,7 @@ export class VisionTest {
     }
     async screenshotToDataURL(texture, width, height) {
         const data = await this.captureTexture(texture, width, height);
-        const canvas = document.createElement("canvas");
-        canvas.width = width;
-        canvas.height = height;
+        const canvas = new OffscreenCanvas(width, height);
         const ctx = canvas.getContext("2d");
         const imageData = ctx.createImageData(width, height);
         imageData.data.set(data);

package/libraries/blitz-ui/native/Cargo.toml

@@ -31,3 +31,9 @@ web-time = "1"
 # Workaround copied from blitz examples: disable unicode URL support
 # (see https://github.com/hsivonen/idna_adapter)
 idna_adapter = "=1.0.0"
+
+# Enable the vendored glifo's FreeType mask path (see [patch.crates-io] in the
+# workspace root). Feature unification turns it on inside vello_cpu's copy.
+# Target-gated: freetype-sys compiles bundled C, which wasm32 can't build.
+[target.'cfg(not(target_family = "wasm"))'.dependencies]
+glifo = { version = "0.2", features = ["freetype"] }

package/libraries/blitz-ui/native-osr/Cargo.toml

@@ -13,7 +13,9 @@ crate-type = ["cdylib"]
 blitz-html = { git = "https://github.com/DioxusLabs/blitz", rev = "efef6519fe6520caf66dc82df557580eecbf652b" }
 blitz-dom = { git = "https://github.com/DioxusLabs/blitz", rev = "efef6519fe6520caf66dc82df557580eecbf652b", default-features = false, features = ["woff"] }
 blitz-traits = { git = "https://github.com/DioxusLabs/blitz", rev = "efef6519fe6520caf66dc82df557580eecbf652b" }
-blitz-paint = { git = "https://github.com/DioxusLabs/blitz", rev = "efef6519fe6520caf66dc82df557580eecbf652b", features = ["custom-widget"] }
+# scrollbars: painted overlay thumbs on scroll containers + thumb drag/hover
+# hit-testing (pulls blitz-dom/scrollbars transitively).
+blitz-paint = { git = "https://github.com/DioxusLabs/blitz", rev = "efef6519fe6520caf66dc82df557580eecbf652b", features = ["custom-widget", "scrollbars"] }
 # Enable the vendored glifo's FreeType mask path (see [patch.crates-io] in the
 # workspace root). Feature unification turns it on inside vello_cpu's copy.
 glifo = { version = "0.2", features = ["freetype"] }

package/libraries/blitz-ui/src/native-module.ts

@@ -169,7 +169,14 @@ export function createBlitzUiNativeModule<S>(options: BlitzUiNativeOptions<S>):
                 const device = ctx.getDevice();
                 const view = ensureTexture(device);
                 const context = ctx.getSurface().getContext("webgpu");
-                const targetTex = context?.getCurrentTexture();
+                // Join the in-flight frame, never start one: on a frame the
+                // game skipped (dirty-tracking), acquiring the surface here
+                // would present the UI blit over a blank swapchain image.
+                const peek = (context as { peekCurrentTexture?: () => GPUTexture | null } | null)
+                    ?.peekCurrentTexture;
+                const targetTex = typeof peek === "function"
+                    ? peek.call(context)
+                    : context?.getCurrentTexture() ?? null;
                 const target = targetTex?.createView();
                 if (!view || !target || !targetTex) return;
 

package/libraries/devtools/src/backend.ts

@@ -77,6 +77,12 @@ export class DevtoolsBackend {
   private providers = new Map<number, PanelProvider>();
   private commandHandlers = new Map<number, PanelCommandHandler>();
   private globalCommandHandler: PanelCommandHandler | null = null;
+  /** Dynamically-allocated slots for provider names outside the fixed PANEL
+   *  table — panelSlot() alone collapsed every unknown name onto slot 0
+   *  ("console"), so a second game provider silently replaced the first. */
+  private dynSlots = new Map<string, number>();
+  private dynSlotNames = new Map<number, string>();
+  private nextDynSlot = 100;
   private lastProviderPush = new Map<number, number>();
   providerIntervalMs = 1500;
   /** When non-null, the cadence loop only auto-refreshes this provider
@@ -237,37 +243,57 @@ export class DevtoolsBackend {
 
   // ── Providers / commands ──
 
-  registerProvider(panel: PanelName | number, collect: PanelProvider): void {
-    this.providers.set(panelSlot(panel), collect);
+  /** Resolve a panel id to its slot. Names outside the fixed PANEL table
+   *  get a stable dynamically-allocated slot so bespoke game providers can
+   *  coexist instead of colliding on slot 0. */
+  private slotFor(panel: PanelName | number | string): number {
+    if (typeof panel === "number") return panel;
+    const fixed = PANEL[panel as PanelName];
+    if (fixed !== undefined) return fixed;
+    let s = this.dynSlots.get(panel);
+    if (s === undefined) {
+      s = this.nextDynSlot++;
+      this.dynSlots.set(panel, s);
+      this.dynSlotNames.set(s, panel);
+    }
+    return s;
+  }
+
+  private nameFor(slot: number): string {
+    return this.dynSlotNames.get(slot) ?? slotName(slot);
+  }
+
+  registerProvider(panel: PanelName | number | string, collect: PanelProvider): void {
+    this.providers.set(this.slotFor(panel), collect);
   }
 
-  registerCommandHandler(panel: PanelName | number | "*", handler: PanelCommandHandler): void {
+  registerCommandHandler(panel: PanelName | number | string, handler: PanelCommandHandler): void {
     if (panel === "*") {
       this.globalCommandHandler = handler;
     } else {
-      this.commandHandlers.set(panelSlot(panel), handler);
+      this.commandHandlers.set(this.slotFor(panel), handler);
     }
   }
 
   /** Registered provider slots — the dynamic tab list for frontends. */
   providerSlots(): { slot: number; name: string }[] {
-    return [...this.providers.keys()].map((slot) => ({ slot, name: slotName(slot) }));
+    return [...this.providers.keys()].map((slot) => ({ slot, name: this.nameFor(slot) }));
   }
 
   /** Collect + emit one provider's snapshot immediately. */
-  refreshPanel(panel: PanelName | number): void {
+  refreshPanel(panel: PanelName | number | string): void {
     const trace: number[] = [performance.now()];
-    const slot = panelSlot(panel);
+    const slot = this.slotFor(panel);
     trace.push(performance.now());
     const collect = this.providers.get(slot);
     if (!collect) return;
     const push = (snap: PanelSnapshot | null | undefined) => {
-      if (snap) this.emit("snapshot", { panel: slotName(slot), slot, snap });
+      if (snap) this.emit("snapshot", { panel: this.nameFor(slot), slot, snap });
       this.lastProviderPush.set(slot, performance.now());
     };
     const fail = (err: unknown) => {
       this.emit("snapshot", {
-        panel: slotName(slot), slot,
+        panel: this.nameFor(slot), slot,
         snap: { status: "error", statusMsg: String(err), sections: [] },
       });
       this.lastProviderPush.set(slot, performance.now());
@@ -288,7 +314,7 @@ export class DevtoolsBackend {
     const total = trace[4]! - trace[0]!;
     if (total > 10) {
       const seg = `pre=${(trace[2]! - trace[0]!).toFixed(1)} collect=${(trace[3]! - trace[2]!).toFixed(1)} emit=${(trace[4]! - trace[3]!).toFixed(1)}`;
-      this.diagWarn(`slow provider ${slotName(slot)}: ${total.toFixed(1)}ms [${seg}]`);
+      this.diagWarn(`slow provider ${this.nameFor(slot)}: ${total.toFixed(1)}ms [${seg}]`);
     }
   }
 
@@ -431,7 +457,7 @@ export class DevtoolsBackend {
         return collectThreads(this.ctx, [...this.threadEvals.keys()]);
       case "snapshot": {
         const panel = params.panel;
-        const slot = typeof panel === "number" ? panel : panelSlot(panel as PanelName);
+        const slot = typeof panel === "number" ? panel : this.slotFor(String(panel));
         const collect = this.providers.get(slot);
         if (!collect) return { status: "unsupported", statusMsg: `no provider for ${String(panel)}`, sections: [] };
         try {
@@ -443,7 +469,7 @@ export class DevtoolsBackend {
       }
       case "command": {
         const panel = params.panel;
-        const slot = typeof panel === "number" ? panel : panelSlot((panel as PanelName) ?? "console");
+        const slot = typeof panel === "number" ? panel : this.slotFor(String(panel ?? "console"));
         this.dispatchCommand({ panel: slot, action: String(params.action ?? ""), payload: String(params.payload ?? "") });
         return true;
       }

package/libraries/devtools/src/collectors.ts

@@ -18,6 +18,11 @@ export interface ThreadInfo { id: string; name: string; kind: number }
 export interface TreeRow {
   id: number; parentId: number; depth: number; childCount: number;
   kind: number; label: string; detail: string;
+  /** Stable node identity for pick/inspect — scene-store id, stage node id,
+   *  or ECS entity index ("ent-N") when the collector can provide one. The
+   *  numeric `id` is ephemeral (re-assigned per collect); `nodeId` survives
+   *  refreshes and is what `inspector.call` methods take. */
+  nodeId?: string;
 }
 export interface GpuInfoJson {
   entries: { key: string; value: string; isHeader: boolean }[];
@@ -100,30 +105,77 @@ export async function collectThreads(
   return threads;
 }
 
-/** Scene-graph tree (label + ctor + child counts). */
+function sceneInspectorApi(): Record<string, any> | null {
+  const g = globalThis as Record<string, any>;
+  return (g.window?.__sceneInspector ?? g.__sceneInspector ?? null) as Record<string, any> | null;
+}
+
+/** Scene-graph tree (label + ctor + child counts). Prefers a live
+ *  `gameScene.stage` walk; falls back to the SceneInspector's scene store
+ *  (`__sceneInspector.getSceneTree`) so games without a DOM-like stage still
+ *  get a populated tree — with stable nodeIds for pick/details. */
 export function collectSceneTree(ctx: CollectorContext): TreeRow[] {
   const stage = ctx.gameScene?.stage;
-  if (!stage) return [];
-  const nodes: TreeRow[] = [];
-  let idCounter = 1;
-  const collect = (node: any, parentId: number, depth: number): void => {
-    const id = idCounter++;
-    // Prefer `label` (some scene-graph hosts warn on `name` access); fall
-    // back to `name` for hosts that only set that.
-    const nodeLabel = typeof node.label === "string" ? node.label
-      : typeof node.name === "string" ? node.name : "";
-    const ctorName = node.constructor?.name ?? "Node";
-    nodes.push({
-      id, parentId, depth,
-      childCount: node.children?.length ?? 0,
-      kind: 0,
-      label: nodeLabel || ctorName,
-      detail: nodeLabel ? ctorName : "",
-    });
-    node.children?.forEach((child: any) => collect(child, id, depth + 1));
-  };
-  collect(stage, -1, 0);
-  return nodes;
+  if (stage) {
+    const nodes: TreeRow[] = [];
+    let idCounter = 1;
+    const collect = (node: any, parentId: number, depth: number): void => {
+      const id = idCounter++;
+      // Prefer `label` (some scene-graph hosts warn on `name` access); fall
+      // back to `name` for hosts that only set that.
+      const nodeLabel = typeof node.label === "string" ? node.label
+        : typeof node.name === "string" ? node.name : "";
+      const ctorName = node.constructor?.name ?? "Node";
+      nodes.push({
+        id, parentId, depth,
+        childCount: node.children?.length ?? 0,
+        kind: 0,
+        label: nodeLabel || ctorName,
+        detail: nodeLabel ? ctorName : "",
+        nodeId: typeof node.id === "string" ? node.id : undefined,
+      });
+      node.children?.forEach((child: any) => collect(child, id, depth + 1));
+    };
+    collect(stage, -1, 0);
+    return nodes;
+  }
+
+  // Scene-store fallback — the same snapshot the inspector's getSceneTree
+  // exposes. Nodes are flat with id/parentId links; walk roots → children.
+  try {
+    const snap = sceneInspectorApi()?.getSceneTree?.();
+    const storeNodes = snap?.nodes;
+    if (!Array.isArray(storeNodes) || !storeNodes.length) return [];
+    const byId = new Map<string, any>(storeNodes.map((n: any) => [n.id, n]));
+    const roots = storeNodes.filter((n: any) => n.parentId === null || !byId.has(n.parentId));
+    const rows: TreeRow[] = [];
+    const visited = new Set<string>();
+    let idCounter = 1;
+    const walk = (n: any, parentId: number, depth: number): void => {
+      if (visited.has(n.id)) return; // corrupted parent/child links — don't loop
+      visited.add(n.id);
+      const id = idCounter++;
+      const p = n.position;
+      rows.push({
+        id, parentId, depth,
+        childCount: n.children?.length ?? 0,
+        kind: 0,
+        label: String(n.name ?? n.id),
+        detail: `${n.type ?? "node"}${Array.isArray(p) ? ` (${p.map((v: number) => (+v).toFixed(1)).join(", ")})` : ""}`,
+        nodeId: String(n.id),
+      });
+      for (const cid of n.children ?? []) {
+        const c = byId.get(cid);
+        if (c) walk(c, id, depth + 1);
+      }
+    };
+    roots.forEach((n: any) => walk(n, -1, 0));
+    // Orphans (every node has a parent but no root resolves) — still show them.
+    for (const n of storeNodes) if (!visited.has(n.id)) walk(n, -1, 0);
+    return rows;
+  } catch {
+    return [];
+  }
 }
 
 /** DOM tree: scene-graph stage or ECS entities depending on mode. */
@@ -148,6 +200,7 @@ export function collectDomTree(ctx: CollectorContext, mode: "scene" | "ecs"): Tr
         id, parentId: -1, depth: 0, childCount: 0, kind: 1,
         label: `Entity ${ent.idx}`,
         detail: `type=${entityType} pos=(${x.toFixed(1)},${y.toFixed(1)},${z.toFixed(1)})`,
+        nodeId: `ent-${ent.idx}`,
       });
     });
   } catch { /* sim reader hiccup */ }

package/libraries/devtools/src/native-providers.ts

@@ -525,8 +525,6 @@ async function collectWorkers(ctx: EngineProviderContext): Promise<PanelSnapshot
                     kind: "kv",
                     name: `Worker manifest (v${m.manifestVersion ?? "?"})`,
                     rows: [
-                        kv("Panels", (m.panels ?? []).map((p: any) => p.id ?? p.name ?? "?").join(", ") || "(none)"),
-                        kv("Toggles", (m.toggles ?? []).map((t: any) => t.id ?? "?").join(", ") || "(none)"),
                         kv("Data feeds", (m.dataFeeds ?? []).map((f: any) => `${f.name}@${f.writeRateHz}hz`).join(", ") || "(none)"),
                         kv("Commands", (m.commands ?? []).join(", ") || "(none)"),
                     ],