@downdraft/engine 0.1.1 → 0.1.2-alpha.5

package/core/src/plugin/manifest.ts

@@ -71,8 +71,10 @@ export interface ModAssetExtension {
   kind: "mesh" | "texture" | "pbr-material" | "texture-pipeline";
   /** Logical asset id (namespaced, e.g. "my-mod:crate"). */
   id: string;
-  /** Path to the file relative to the mod dir. */
-  path: string;
+  /** Path to the file relative to the mod dir. Required for all kinds except
+   *  "mesh" — a pathless mesh registers a procedural primitive prop whose
+   *  shape/physics come entirely from the extension's meta fields. */
+  path?: string;
   /** pbr-material: descriptor fields (baseColor, metallic, roughness, texture refs). */
   /** texture-pipeline: pipeline descriptor. Extra fields are pass-through. */
   [key: string]: unknown;
@@ -561,7 +563,10 @@ function validateAssetExtension(a: unknown, i: number, errors: string[]): void {
   if (typeof ext.id !== "string" || !ext.id) {
     errors.push(`extensions.assets[${i}].id: required string`);
   }
-  if (typeof ext.path !== "string" || !ext.path) {
+  // `path` is optional for mesh assets: a pathless mesh means "procedural
+  // primitive prop" (shape/physics meta only, no file). All other kinds
+  // still require a file path.
+  if (ext.kind !== "mesh" && (typeof ext.path !== "string" || !ext.path)) {
     errors.push(`extensions.assets[${i}].path: required string`);
   }
 }

package/core/src/plugin/workshop.ts

@@ -78,18 +78,18 @@ export class WorkshopFetcher {
       try {
         rawManifest = await source.store.get(source.manifestKey);
       } catch (e) {
-        log.error("WorkshopFetcher", `Failed to fetch workshop manifest: ${(e as Error).message}`);
+        log.error("workshop-fetcher", `Failed to fetch workshop manifest: ${(e as Error).message}`);
         continue;
       }
       let parsed: unknown;
       try {
         parsed = JSON.parse(new TextDecoder().decode(rawManifest));
       } catch (e) {
-        log.error("WorkshopFetcher", `Workshop manifest is not valid JSON: ${(e as Error).message}`);
+        log.error("workshop-fetcher", `Workshop manifest is not valid JSON: ${(e as Error).message}`);
         continue;
       }
       if (!validateManifest(parsed)) {
-        log.error("WorkshopFetcher", `Workshop manifest failed schema validation`);
+        log.error("workshop-fetcher", `Workshop manifest failed schema validation`);
         continue;
       }
       const assetManifest = parsed as AssetManifest;

package/core/src/profiling/index.ts

@@ -8,7 +8,7 @@
 // SAB layout + reader/writer
 export {
     allocateProfilingSAB,
-    claimSlot, computeProfilingSABLayout, fnv1a32, METRIC_CPU_PERCENT, METRIC_CUSTOM, METRIC_GC_PAUSE, METRIC_GPU_TIME, METRIC_HEAP_PERCENT, METRIC_HEAP_USAGE, METRIC_IOPS_LATENCY, METRIC_LONGTASK, METRIC_RAF_JITTER, METRIC_TASK_LATENCY, METRIC_TICK_LATENCY, PROFILING_IOPS_RING_CAP, PROFILING_MAGIC, PROFILING_MAX_SLOTS, PROFILING_STRING_MAX_LEN, PROFILING_STRING_TABLE_CAP, PROFILING_VERSION, PROFILING_WARNING_RING_CAP, ProfilingSABReader, ProfilingSABWriter, releaseSlot, RUNTIME_JS,
+    claimSlot, computeProfilingSABLayout, fnv1a32, METRIC_CPU_PERCENT, METRIC_CUSTOM, METRIC_GC_PAUSE, METRIC_GPU_TIME, METRIC_HEAP_PERCENT, METRIC_HEAP_USAGE, METRIC_IOPS_LATENCY, METRIC_LONGTASK, METRIC_RAF_JITTER, METRIC_TASK_LATENCY, METRIC_TICK_LATENCY, PROFILING_IOPS_RING_CAP, PROFILING_MAGIC, PROFILING_MAX_SLOTS, PROFILING_STRING_MAX_LEN, PROFILING_STRING_TABLE_CAP, PROFILING_VERSION, PROFILING_WARNING_RING_CAP, profilingLayoutFromSab, ProfilingSABReader, ProfilingSABWriter, releaseSlot, RUNTIME_JS,
     RUNTIME_QUICKJS,
     RUNTIME_WASM, SEVERITY_CRITICAL, SEVERITY_ERROR, SEVERITY_INFO,
     SEVERITY_WARN, STORE_IDB, STORE_OPFS

package/core/src/profiling/profiling-sab.ts

@@ -322,6 +322,25 @@ export function allocateProfilingSAB(
   return { sab, layout };
 }
 
+/**
+ * Derive the SAB layout from a live buffer's header — readers should prefer
+ * this over computeProfilingSABLayout() defaults so they work regardless of
+ * the allocator's maxSlots. Returns null when the buffer isn't a valid
+ * ProfilingSAB. Ring/table caps aren't stored in the header — they must
+ * match the engine defaults (allocateProfilingSAB / ProfilingBridge use them).
+ */
+export function profilingLayoutFromSab(sab: SharedArrayBuffer): ProfilingSABLayout | null {
+  if (sab.byteLength < HEADER_SIZE) return null;
+  const u32 = new Uint32Array(sab);
+  if (u32[HDR.MAGIC] !== PROFILING_MAGIC) return null;
+  const maxSlots = u32[HDR.MAX_SLOTS];
+  if (maxSlots <= 0 || maxSlots > 4096) return null;
+  const layout = computeProfilingSABLayout(maxSlots);
+  // Strict match: a custom ring/table cap shifts every slot offset — reading
+  // with the wrong layout produces garbage rather than a clean miss.
+  return layout.byteLength === sab.byteLength ? layout : null;
+}
+
 // ─── ProfilingSABWriter (worker side) ───────────────────────────────────────
 
 /**

package/core/src/profiling/warnings.ts

@@ -284,7 +284,7 @@ export class WarningEngine {
         cb(record, ctx);
       } catch (err) {
         // Don't let a callback error stop other callbacks
-        log.error("WarningEngine", `callback error for rule "${rule.id}": ${err}`);
+        log.error("warning-engine", `callback error for rule "${rule.id}": ${err}`);
       }
     });
   }

package/core/src/profiling/worker-prelude.ts

@@ -2,7 +2,7 @@
 // Worker prelude — imported at the top of every instrumented worker.
 //
 // On load (worker realm only):
-//   1. Detects worker tag (from __ddThreadTag if set, else assigns auto-<n>).
+//   1. Takes the worker tag passed by the host's attachProfilingSAB RPC.
 //   2. If a ProfilingSAB has been attached (via attachProfilingSAB called from
 //      the host's init RPC), claims a slot, initializes ThreadMetricsWriter +
 //      IopsRingWriter + worker-side WarningEngine + EventLoopMonitor.

package/core/src/render/bindless/frame-bindings.ts

@@ -143,7 +143,7 @@ export class BindlessFrameBindings {
     this.bindGroup = this.device.createBindGroup({ layout, entries });
     this.cachedLayoutVersion = layoutVersion;
     this.cachedBufferVersion = bufferVersion;
-    log.debug("Bindless", `material bind group rebuilt (layout v${layoutVersion}, buffer v${bufferVersion})`);
+    log.debug("bindless", `material bind group rebuilt (layout v${layoutVersion}, buffer v${bufferVersion})`);
     return this.bindGroup;
   }
 

package/core/src/render/bindless/material-manager.ts

@@ -146,7 +146,7 @@ export class BindlessMaterialManager {
   /** Update an existing material's params in place (no reallocation). */
   updateMaterial(index: number, params: MaterialParams): void {
     if (index < 0 || index >= this.nextSlot) {
-      log.warn("Bindless", `updateMaterial: index ${index} out of range (nextSlot=${this.nextSlot})`);
+      log.warn("bindless", `updateMaterial: index ${index} out of range (nextSlot=${this.nextSlot})`);
       return;
     }
     this.writeMaterial(index, params);
@@ -243,7 +243,7 @@ export class BindlessMaterialManager {
     this.backingU32 = new Uint32Array(newBacking.buffer);
     this.capacity = newCapacity;
     this.bufferVersion++;
-    log.debug("Bindless", `material SSBO grew to capacity ${newCapacity}`);
+    log.debug("bindless", `material SSBO grew to capacity ${newCapacity}`);
   }
 }
 

package/core/src/render/bindless/texture-registry.ts

@@ -190,7 +190,7 @@ export class BindlessTextureRegistry {
       const reg = b.sources.get(sourceId);
       if (!reg) continue;
       if (b.key.width !== bitmap.width || b.key.height !== bitmap.height) {
-        log.warn("Bindless", `updateFromImageBitmap dimension mismatch for ${String(sourceId)}: bucket ${b.key.width}x${b.key.height} vs bitmap ${bitmap.width}x${bitmap.height}`);
+        log.warn("bindless", `updateFromImageBitmap dimension mismatch for ${String(sourceId)}: bucket ${b.key.width}x${b.key.height} vs bitmap ${bitmap.width}x${bitmap.height}`);
         return false;
       }
       this.copyImageBitmapIntoLayer(bitmap, b, reg.pageIndex, reg.layerIndex, b.key);
@@ -510,7 +510,7 @@ fn fs(@builtin(position) pos: vec4f) -> @location(0) vec4f {
 
   private appendPage(b: Bucket): void {
     if (b.pages.length >= this.maxPagesPerBucket) {
-      log.error("Bindless", `bucket ${b.keyStr} exhausted maxPages=${this.maxPagesPerBucket}; texture registration failed`);
+      log.error("bindless", `bucket ${b.keyStr} exhausted maxPages=${this.maxPagesPerBucket}; texture registration failed`);
       throw new Error(`BindlessTextureRegistry: bucket ${b.keyStr} full (maxPages=${this.maxPagesPerBucket})`);
     }
     const tex = this.device.createTexture({

package/core/src/render/device.ts

@@ -42,7 +42,7 @@ export class GPUDeviceManager {
 
   async requestDevice(): Promise<GPUDevice | null> {
     if (!navigator.gpu) {
-      log.error("DownDraft", "WebGPU not available");
+      log.error("gpu", "WebGPU not available");
       return null;
     }
 
@@ -51,7 +51,7 @@ export class GPUDeviceManager {
     });
 
     if (!this.adapter) {
-      log.error("DownDraft", "No suitable GPU adapter found");
+      log.error("gpu", "No suitable GPU adapter found");
       return null;
     }
 
@@ -67,12 +67,12 @@ export class GPUDeviceManager {
 
       this.device.lost.then((info: GPUDeviceLostInfo) => {
         this.deviceLost = true;
-        log.error("DownDraft", `GPU device lost: ${info?.message ?? "unknown reason"}. Application should attempt recovery or notify the user.`);
+        log.error("gpu", `GPU device lost: ${info?.message ?? "unknown reason"}. Application should attempt recovery or notify the user.`);
         for (let i = 0; i < this.lostHandlers.length; i++) {
           try {
             this.lostHandlers[i](info);
           } catch (err) {
-            log.error("DownDraft", `Device lost handler threw: ${err}`);
+            log.error("gpu", `Device lost handler threw: ${err}`);
           }
         }
       });
@@ -98,7 +98,7 @@ export class GPUDeviceManager {
   }
 
   async reinit(): Promise<GPUDevice | null> {
-    log.warn("DownDraft", "Device lost — reinitializing GPU device. Pass-specific resources (pipelines, bind groups, textures) are NOT recreated and must be rebuilt by the application.");
+    log.warn("gpu", "Device lost — reinitializing GPU device. Pass-specific resources (pipelines, bind groups, textures) are NOT recreated and must be rebuilt by the application.");
     this.deviceLost = false;
     this.device = null;
     this.adapter = null;

package/core/src/render/frame-graph.ts

@@ -722,7 +722,7 @@ export class FrameGraph {
     }
 
     if (result.length !== n) {
-      log.error("FrameGraph", "Cycle detected in render graph, falling back to registration order");
+      log.error("frame-graph", "Cycle detected in render graph, falling back to registration order");
       return this.passes;
     }
 
@@ -745,7 +745,7 @@ export class FrameGraph {
     });
 
     if (errors.length > 0) {
-      log.warn("FrameGraph", `Validation errors:\n${errors.join("\n")}`);
+      log.warn("frame-graph", `Validation errors:\n${errors.join("\n")}`);
     }
   }
 

package/core/src/render/game-renderer.ts

@@ -52,11 +52,19 @@ export interface GameRendererLike {
   /** Render one frame on demand while the loop is stopped (or running). */
   renderOnce?(): void;
   getSurface?(): RenderSurface;
+  /** @deprecated Use getSurface — the surface is not necessarily a DOM canvas. */
   getCanvas?(): RenderSurface;
   getDevice?(): GPUDevice | null;
   getFormat?(): GPUTextureFormat;
   getFPS?(): number;
   useRendererModule?(module: RendererModule): void;
+  /**
+   * The renderer's module host, when the renderer supports renderer modules.
+   * `startGame()` uses it to wire EngineLibrary DI provides — renderers
+   * that omit it silently drop library-provided resources (a warning is
+   * logged when libraries are declared but no host exists).
+   */
+  getRendererModuleHost?(): RendererModuleHost | null;
   getWorkerHost?(): unknown;
 }
 
@@ -342,7 +350,7 @@ export class GameRenderer implements CanvasResizeHandler {
       // below).
       const adapter = borrowedAdapter ?? await this.requestAdapterWithFallback();
       if (!adapter && !borrowedDevice) {
-        log.error("GameRenderer", "No GPU adapter found — check GPU drivers and /dev/dri permissions");
+        log.error("game-renderer", "No GPU adapter found — check GPU drivers and /dev/dri permissions");
         return false;
       }
       this.device = borrowedDevice ?? await this.requestDeviceFromAdapter(adapter!);
@@ -367,7 +375,7 @@ export class GameRenderer implements CanvasResizeHandler {
       this.format = navigator.gpu.getPreferredCanvasFormat();
       this.gpuProfiler = new GPUProfiler();
       this.gpuProfiler.init(this.device, adapterInfo, this.format, 32);
-      log.info("GameRenderer", `GPU timer pool supported: ${this.gpuProfiler.isGpuTimerSupported()} features: ${Array.from(this.device.features).join(", ")}`);
+      log.debug("game-renderer", `GPU timer pool supported: ${this.gpuProfiler.isGpuTimerSupported()} features: ${Array.from(this.device.features).join(", ")}`);
 
       // Device lost handler
       this.device.lost.then((info: GPUDeviceLostInfo) => {
@@ -426,10 +434,10 @@ export class GameRenderer implements CanvasResizeHandler {
       // Initial viewport layout
       this.updateViewports(1);
 
-      log.info("GameRenderer", "initialized");
+      log.info("game-renderer", "initialized");
       return true;
     } catch (err) {
-      log.error("GameRenderer", `Init failed: ${err}`);
+      log.error("game-renderer", `Init failed: ${err}`);
       return false;
     }
   }
@@ -442,13 +450,13 @@ export class GameRenderer implements CanvasResizeHandler {
       powerPreference: "high-performance",
     });
     if (!adapter) {
-      log.warn("GameRenderer", "No high-performance GPU adapter, trying low-power...");
+      log.warn("game-renderer", "No high-performance GPU adapter, trying low-power...");
       adapter = await navigator.gpu.requestAdapter({
         powerPreference: "low-power",
       });
     }
     if (!adapter) {
-      log.warn("GameRenderer", "No low-power adapter, trying any...");
+      log.warn("game-renderer", "No low-power adapter, trying any...");
       adapter = await navigator.gpu.requestAdapter({});
     }
     return adapter;
@@ -471,9 +479,9 @@ export class GameRenderer implements CanvasResizeHandler {
   private handleDeviceLost(info: GPUDeviceLostInfo): void {
     if (this.deviceLost || this.recoveringDevice) return; // already handled
     this.deviceLost = true;
-    log.error("GameRenderer", `WebGPU device lost: ${info?.reason ?? "unknown"} — ${info?.message ?? ""}`);
+    log.error("game-renderer", `WebGPU device lost: ${info?.reason ?? "unknown"} — ${info?.message ?? ""}`);
     try { this.callbacks.onDeviceLost?.(info); } catch (err) {
-      log.error("GameRenderer", `onDeviceLost callback threw: ${err}`);
+      log.error("game-renderer", `onDeviceLost callback threw: ${err}`);
     }
 
     if (
@@ -516,7 +524,7 @@ export class GameRenderer implements CanvasResizeHandler {
         try { nativeWin.requestQuit?.(); } catch { /* best-effort */ }
         return;
       }
-      log.warn("GameRenderer", "Attempting page reload for GPU recovery...");
+      log.warn("game-renderer", "Attempting page reload for GPU recovery...");
       window.location.reload();
     }, 2000);
   }
@@ -567,9 +575,9 @@ export class GameRenderer implements CanvasResizeHandler {
       await this.callbacks.onDeviceRecovered?.(device);
 
       this.deviceLost = false;
-      log.warn("GameRenderer", "GPU device recovered — rendering resumed without reload");
+      log.warn("game-renderer", "GPU device recovered — rendering resumed without reload");
     } catch (err) {
-      log.error("GameRenderer", `Device recovery failed: ${err}`);
+      log.error("game-renderer", `Device recovery failed: ${err}`);
       this.reloadForDeviceLoss();
     } finally {
       this.recoveringDevice = false;
@@ -606,7 +614,7 @@ export class GameRenderer implements CanvasResizeHandler {
       // an offscreen-render + upscale path to work here; for now it is a
       // no-op rather than a brick.
       if (this.resolutionScale < 1) {
-        log.warn("GameRenderer", "resolutionScale is not supported on the native surface (swapchain must match the window size) — ignoring");
+        log.warn("game-renderer", "resolutionScale is not supported on the native surface (swapchain must match the window size) — ignoring");
       }
     }
     if (this.lastCssW > 0) this.onResize(this.lastCssW, this.lastCssH, this.lastRawDpr);
@@ -789,7 +797,7 @@ export class GameRenderer implements CanvasResizeHandler {
     try {
       this.renderFrame();
     } catch (err) {
-      log.error("GameRenderer", `Render loop error: ${(err as Error).message}\n${(err as Error).stack}`);
+      log.error("game-renderer", `Render loop error: ${(err as Error).message}\n${(err as Error).stack}`);
       if (this.device?.lost) {
         this.device.lost.then((info: GPUDeviceLostInfo) => {
           this.handleDeviceLost(info);
@@ -904,6 +912,16 @@ export class GameRenderer implements CanvasResizeHandler {
     this.callbacks.afterViewports?.(dt, this.elapsedTime);
     this.rendererModuleHost?.dispatchFrame("afterViewports", dt, this.elapsedTime);
 
+    // Worker-produced passes (postPass → "preSubmit" slot on the native
+    // host's GpuPassMailbox) join this frame's submit batch — refs that
+    // arrived since the last drain execute after the owner's buffers.
+    // Stale-tolerant by design: a worker that misses the drain lands next
+    // frame instead of rendezvousing the render thread.
+    const passMailbox = getNativeHost()?.passMailbox;
+    if (passMailbox) {
+      frameCommandBuffers.push(...passMailbox.drain("preSubmit"));
+    }
+
     // Submit all command buffers for this frame in a single queue.submit() call
     if (frameCommandBuffers.length > 0) {
       this.device!.queue.submit(frameCommandBuffers);
@@ -972,7 +990,9 @@ export class GameRenderer implements CanvasResizeHandler {
     // the afterFrame callback, so drawing UI earlier would put it underneath
     // their clear pass.
     if (!gpuError && this.device && this.context) {
-      const compositors = [...this.uiCompositors].filter((c) => c.hasContent());
+      const compositors = [...this.uiCompositors]
+        .filter((c) => c.hasContent())
+        .sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
       const uiCanvasView = compositors.length > 0
         ? this.getSurfaceTexture()?.createView()
         : undefined;
@@ -988,7 +1008,9 @@ export class GameRenderer implements CanvasResizeHandler {
         });
         compositors.forEach((c) => { c.render(uiPass, this.canvas.width, this.canvas.height); });
         uiPass.end();
-        this.device.queue.submit([uiEncoder.finish()]);
+        // "preUi" slot — worker passes ordered ahead of the UI-composite
+        // submit so their output is visible to the compositor this frame.
+        this.device.queue.submit([...(passMailbox?.drain("preUi") ?? []), uiEncoder.finish()]);
       }
     }
 
@@ -1000,7 +1022,7 @@ export class GameRenderer implements CanvasResizeHandler {
     }
 
     const __rfTotal = performance.now() - now;
-    if (this.config.debugTimingWarnings && __rfTotal > 20) log.warn("GameRenderer", `renderFrame took ${__rfTotal.toFixed(1)}ms`);
+    if (this.config.debugTimingWarnings && __rfTotal > 20) log.warn("game-renderer", `renderFrame took ${__rfTotal.toFixed(1)}ms`);
     // NOTE: renderFrame() intentionally does NOT schedule the next frame —
     // render() owns the rAF chain so one-shot callers (renderOnce, MCP
     // screenshot capture) can't leak parallel loops.
@@ -1087,7 +1109,7 @@ export class GameRenderer implements CanvasResizeHandler {
     // window, transient failure) — skip this viewport's GPU work; game
     // callbacks already ran above and the loop stays alive for next frame.
     if (!colorView) return null;
-    if (this.config.debugTimingWarnings && __ctMs > 20) log.warn("GameRenderer", `getCurrentTexture took ${__ctMs.toFixed(1)}ms`);
+    if (this.config.debugTimingWarnings && __ctMs > 20) log.warn("game-renderer", `getCurrentTexture took ${__ctMs.toFixed(1)}ms`);
 
     const depthView = xrProvider
       ? xrProvider.getDepthView(viewportIdx, origViewport.w, origViewport.h)
@@ -1292,7 +1314,9 @@ export class GameRenderer implements CanvasResizeHandler {
    * this helper only runs the compositors.
    */
   protected renderScreenUiCompositors(): void {
-    const compositors = [...this.uiCompositors].filter((c) => c.hasContent());
+    const compositors = [...this.uiCompositors]
+      .filter((c) => c.hasContent())
+      .sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
     if (compositors.length === 0 || !this.device || !this.context) return;
     const canvasView = this.getSurfaceTexture()?.createView();
     if (!canvasView) return;

package/core/src/render/hot-reload.ts

@@ -200,7 +200,7 @@ export class MaterialHotReloader {
         this.pipelineCache.invalidate(material.pipelineKey);
       }
     } catch (e) {
-      log.warn("HotReloader", `Failed to reload shader: ${path} ${e}`);
+      log.warn("hot-reloader", `Failed to reload shader: ${path} ${e}`);
     }
   }
 
@@ -214,7 +214,7 @@ export class MaterialHotReloader {
         onReload(result.meshes[0]);
       }
     } catch (e) {
-      log.warn("HotReloader", `Failed to reload mesh: ${path} ${e}`);
+      log.warn("hot-reloader", `Failed to reload mesh: ${path} ${e}`);
     }
   }
 
@@ -243,7 +243,7 @@ export class MaterialHotReloader {
       );
       watched.onReload(gpuTexture);
     } catch (e) {
-      log.warn("HotReloader", `Failed to reload texture: ${path} ${e}`);
+      log.warn("hot-reloader", `Failed to reload texture: ${path} ${e}`);
     }
   }
 

package/core/src/render/renderer-module-host.ts

@@ -28,6 +28,7 @@ import type {
     ResizeHook,
 } from "../module/renderer-module";
 import type { RenderSurface } from "../platform/render-surface";
+import { getNativeHost } from "../platform/runtime";
 import { createLogger } from "../util/logger";
 import type { CameraState } from "./camera";
 import type { FrameGraph, SlotRegistry } from "./frame-graph";
@@ -101,7 +102,11 @@ export class RendererModuleHost {
   private renderPassHooks: OwnedRenderPassHook[] = [];
 
   private cameraController: CameraControllerLike | null = null;
+  /** Name of the module that installed the current camera controller (for unload cleanup). */
+  private cameraControllerOwner: string | null = null;
   private viewportCameraProvider: ((viewportIdx: number, dt: number, elapsedTime: number) => CameraViewportInfo | null) | null = null;
+  /** Name of the module that installed the current viewport camera provider (for unload cleanup). */
+  private viewportCameraProviderOwner: string | null = null;
   private _devtools: ModuleDevToolsAPI | null = null;
 
   constructor(canvas: RenderSurface, callbacks: RendererModuleHostCallbacks) {
@@ -328,7 +333,7 @@ export class RendererModuleHost {
       try {
         active.disposeFns[i]();
       } catch (err) {
-        log.error("RendererModuleHost", `Dispose error in plugin "${name}": ${err}`);
+        log.error("renderer-module-host", `Dispose error in plugin "${name}": ${err}`);
       }
     }
     // Remove this plugin's hooks.
@@ -338,11 +343,17 @@ export class RendererModuleHost {
     this.frameHooks.afterFrame = this.frameHooks.afterFrame.filter((h) => h.owner !== name);
     this.resizeHooks = this.resizeHooks.filter((h) => h.owner !== name);
     this.renderPassHooks = this.renderPassHooks.filter((h) => h.owner !== name);
-    // If this plugin owned the camera controller, clear it.
-    // (We can't tell who set it; clear conservatively if the plugin name
-    // matches a convention. For now, leave the controller in place — a
-    // well-behaved plugin should null it in its dispose fn. We also call
-    // onDispose before clearing hooks, so the plugin's dispose fn can do it.)
+    // If this plugin owned the camera controller / viewport camera provider,
+    // clear it so a disposed object isn't invoked on the next frame. (If
+    // another plugin overwrote the slot later, its ownership is preserved.)
+    if (this.cameraControllerOwner === name) {
+      this.cameraController = null;
+      this.cameraControllerOwner = null;
+    }
+    if (this.viewportCameraProviderOwner === name) {
+      this.viewportCameraProvider = null;
+      this.viewportCameraProviderOwner = null;
+    }
     this.active.delete(name);
     this.plugins.delete(name);
     this.pending.delete(name);
@@ -356,6 +367,9 @@ export class RendererModuleHost {
     names.forEach((name) => { this.unloadModule(name);; });
     this.inputBus.destroy();
     this.cameraController = null;
+    this.cameraControllerOwner = null;
+    this.viewportCameraProvider = null;
+    this.viewportCameraProviderOwner = null;
   }
 
   // ── Getters ──
@@ -419,7 +433,7 @@ export class RendererModuleHost {
       try {
         hooks[i].fn(dt, elapsedTime);
       } catch (err) {
-        log.error("RendererModuleHost", `Frame hook error (${phase}) in "${hooks[i].owner}": ${err}`);
+        log.error("renderer-module-host", `Frame hook error (${phase}) in "${hooks[i].owner}": ${err}`);
       }
     }
   }
@@ -429,7 +443,7 @@ export class RendererModuleHost {
       try {
         this.resizeHooks[i].fn(cssWidth, cssHeight, dpr);
       } catch (err) {
-        log.error("RendererModuleHost", `Resize hook error in "${this.resizeHooks[i].owner}": ${err}`);
+        log.error("renderer-module-host", `Resize hook error in "${this.resizeHooks[i].owner}": ${err}`);
       }
     }
     this.cameraController?.setAspect(
@@ -447,7 +461,7 @@ export class RendererModuleHost {
       try {
         this.renderPassHooks[i].fn(passEncoder, camera, viewportIdx);
       } catch (err) {
-        log.error("RendererModuleHost", `Render-pass hook error in "${this.renderPassHooks[i].owner}": ${err}`);
+        log.error("renderer-module-host", `Render-pass hook error in "${this.renderPassHooks[i].owner}": ${err}`);
       }
     }
   }
@@ -462,7 +476,7 @@ export class RendererModuleHost {
     try {
       return this.cameraController.getCameraState(viewportIdx);
     } catch (err) {
-      log.error("RendererModuleHost", `Camera controller error: ${err}`);
+      log.error("renderer-module-host", `Camera controller error: ${err}`);
       return null;
     }
   }
@@ -478,7 +492,7 @@ export class RendererModuleHost {
     try {
       return this.viewportCameraProvider(viewportIdx, dt, elapsedTime);
     } catch (err) {
-      log.error("RendererModuleHost", `Viewport camera provider error: ${err}`);
+      log.error("renderer-module-host", `Viewport camera provider error: ${err}`);
       return null;
     }
   }
@@ -538,6 +552,7 @@ export class RendererModuleHost {
   // ── Per-plugin context facade ──
 
   private makeContext(name: string, active: ActiveRendererModule): RendererModuleContext {
+    const devtoolsApi = () => this._devtools ?? NoopRendererDevToolsAPI;
     return {
       name,
 
@@ -554,6 +569,8 @@ export class RendererModuleHost {
       registerUiCompositor: this.callbacks.registerUiCompositor
         ? (c) => this.callbacks.registerUiCompositor!(c)
         : undefined,
+      // The mailbox lives on the native host — null on browser/standalone.
+      getGpuPassMailbox: () => getNativeHost()?.passMailbox ?? null,
 
       onFrame: (phase, fn) => {
         const entry: OwnedFrameHook = { owner: name, fn };
@@ -587,11 +604,13 @@ export class RendererModuleHost {
         // Only one active controller at a time. Last writer wins; a plugin
         // should null this in its dispose fn if it wants to release the slot.
         this.cameraController = controller;
+        this.cameraControllerOwner = controller ? name : null;
       },
       getCameraController: () => this.cameraController,
 
       setViewportCameraProvider: (provider) => {
         this.viewportCameraProvider = provider;
+        this.viewportCameraProviderOwner = provider ? name : null;
       },
 
       setViewportCount: (count) => this.callbacks.setViewportCount(count),
@@ -600,7 +619,8 @@ export class RendererModuleHost {
       setRenderTargetProvider: (provider) => this.callbacks.setRenderTargetProvider(provider),
       setRAFSource: (src, cancel) => this.callbacks.setRAFSource(src, cancel),
 
-      devtools: this._devtools ?? NoopRendererDevToolsAPI,
+      // Lazy — the DevTools API may be injected after register() runs.
+      get devtools() { return devtoolsApi(); },
 
       provide: <T>(token: ResourceToken<T>, value: T) => this.provideResource(name, token, value, active),
       inject: <T>(token: ResourceToken<T>): T => this.injectResource(token),

package/core/src/render/shader-validator.ts

@@ -76,17 +76,17 @@ function processCompilationInfo(
         const fullMsg = `[${label}] ${msg.message}${location}`;
 
         if (msg.type === "error") {
-          log.fatal("Shader", fullMsg);
+          log.fatal("shader", fullMsg);
           errors.push(fullMsg);
         } else if (msg.type === "warning") {
-          log.warn("Shader", fullMsg);
+          log.warn("shader", fullMsg);
         } else {
-          log.debug("Shader", fullMsg);
+          log.debug("shader", fullMsg);
         }
       }
 
       if (suppressedCount > 0 && suppressedCount % SUPPRESS_THRESHOLD === 0) {
-        log.warn("Shader", `[${label}] ${suppressedCount} duplicate shader messages suppressed`);
+        log.warn("shader", `[${label}] ${suppressedCount} duplicate shader messages suppressed`);
       }
     })
     .catch(() => {
@@ -145,12 +145,12 @@ export async function createValidatedShaderModuleAsync(
       const fullMsg = `[${label}] ${msg.message}${location}`;
 
       if (msg.type === "error") {
-        log.fatal("Shader", fullMsg);
+        log.fatal("shader", fullMsg);
         errors.push(fullMsg);
       } else if (msg.type === "warning") {
-        log.warn("Shader", fullMsg);
+        log.warn("shader", fullMsg);
       } else {
-        log.debug("Shader", fullMsg);
+        log.debug("shader", fullMsg);
       }
     }
 

package/core/src/render/surface.ts

@@ -25,7 +25,7 @@ export class SurfaceManager {
     this.canvas = canvas;
     this.context = canvas.getContext("webgpu") as GPUCanvasContext;
     if (!this.context) {
-      log.error("DownDraft", "Failed to get WebGPU context from canvas");
+      log.error("gpu", "Failed to get WebGPU context from canvas");
       return;
     }
 

package/core/src/sab/errors.ts

@@ -17,7 +17,7 @@ export function isDebug(): boolean {
 export function warnOnce(key: string, msg: string): void {
   if (warned.has(key)) return;
   warned.add(key);
-  log.warn("SAB", msg);
+  log.warn("sab", msg);
 }
 
 export function resetWarnings(): void {

package/core/src/sab/sab-polyfill.ts

@@ -48,7 +48,7 @@ if (!usingRealSAB) {
   // Debug identifier — detectable from console/devtools.
   (globalThis as any).__DOWNDRAFT_SAB_POLYFILL = true;
   log.warn(
-    "SAB Polyfill",
+    "sab-polyfill",
     "SharedArrayBuffer is not available — using copy-based buffer sync protocol.\n" +
     "If you see this on a runtime that should have real SABs, COOP/COEP\n" +
     "headers may be missing.",