@downdraft/engine 0.1.1 → 0.1.2-alpha.5

package/core/src/module/host.ts

@@ -187,7 +187,7 @@ export class ModuleHost implements ModuleContext {
     this.active.set(plugin.name, active);
     this.currentModuleName = plugin.name;
     try {
-      plugin.register(this);
+      plugin.register(this.makeContext(plugin.name, active));
     } catch (err) {
       // Roll back partial activation: the module must not stay "active"
       // with half-wired resources. Clean up anything it provided or
@@ -200,7 +200,7 @@ export class ModuleHost implements ModuleContext {
         try {
           active.disposeFns[i]();
         } catch (disposeErr) {
-          log.error("ModuleHost", `Dispose error rolling back plugin "${plugin.name}": ${disposeErr}`);
+          log.error("module-host", `Dispose error rolling back plugin "${plugin.name}": ${disposeErr}`);
         }
       }
       // Remove systems the module registered before throwing.
@@ -238,7 +238,7 @@ export class ModuleHost implements ModuleContext {
       try {
         active.disposeFns[i]();
       } catch (err) {
-        log.error("ModuleHost", `Dispose error in plugin "${name}": ${err}`);
+        log.error("module-host", `Dispose error in plugin "${name}": ${err}`);
       }
     }
     // Remove the module's systems from the world schedule — otherwise they
@@ -309,7 +309,7 @@ export class ModuleHost implements ModuleContext {
       try {
         this.unattributedDisposeFns[i]();
       } catch (err) {
-        log.error("ModuleHost", `Unattributed dispose error: ${err}`);
+        log.error("module-host", `Unattributed dispose error: ${err}`);
       }
     }
     this.unattributedDisposeFns.length = 0;
@@ -321,17 +321,21 @@ export class ModuleHost implements ModuleContext {
 
   registerSystem(stage: Stage, system: SystemFn): void {
     if (!this.currentModuleName) {
-      log.warn("ModuleHost", "registerSystem called outside a module register() lifecycle — the system will not be attributed to any module");
+      log.warn("module-host", "registerSystem called outside a module register() lifecycle — the system will not be attributed to any module");
     }
+    this.registerSystemFor(this.currentModuleName || "unattributed", stage, system);
+  }
+
+  private registerSystemFor(owner: string, stage: Stage, system: SystemFn): void {
     this.systemCounter++;
-    const name = `module:${this.currentModuleName || "unattributed"}:${this.systemCounter}`;
+    const name = `module:${owner}:${this.systemCounter}`;
     this.world.schedule.add({
       name,
       stage,
       fn: system,
       queries: [],
     });
-    const active = this.active.get(this.currentModuleName);
+    const active = this.active.get(owner);
     if (active) {
       active.systemNames.push(name);
     } else {
@@ -341,10 +345,14 @@ export class ModuleHost implements ModuleContext {
 
   registerSystemObject(system: System): void {
     if (!this.currentModuleName) {
-      log.warn("ModuleHost", `registerSystemObject("${system.name}") called outside a module register() lifecycle — the system will not be attributed to any module`);
+      log.warn("module-host", `registerSystemObject("${system.name}") called outside a module register() lifecycle — the system will not be attributed to any module`);
     }
+    this.registerSystemObjectFor(this.currentModuleName, system);
+  }
+
+  private registerSystemObjectFor(owner: string, system: System): void {
     this.world.schedule.add(system);
-    const active = this.active.get(this.currentModuleName);
+    const active = this.active.get(owner);
     if (active) {
       active.systemNames.push(system.name);
     } else {
@@ -354,10 +362,14 @@ export class ModuleHost implements ModuleContext {
 
   allocateSABChannel(name: string, size: number): SABChannel {
     if (!this.currentModuleName) {
-      log.warn("ModuleHost", `allocateSABChannel("${name}") called outside a module register() lifecycle — the channel is untracked and won't be cleaned up on unload`);
+      log.warn("module-host", `allocateSABChannel("${name}") called outside a module register() lifecycle — the channel is untracked and won't be cleaned up on unload`);
     }
+    return this.allocateSABChannelFor(this.currentModuleName, name, size);
+  }
+
+  private allocateSABChannelFor(owner: string, name: string, size: number): SABChannel {
     const buffer = new SharedArrayBuffer(size);
-    const active = this.active.get(this.currentModuleName);
+    const active = this.active.get(owner);
     if (active) {
       active.sabChannels.set(name, buffer);
     }
@@ -366,14 +378,18 @@ export class ModuleHost implements ModuleContext {
 
   provide<T>(token: ResourceToken<T>, value: T): void {
     if (!this.currentModuleName) {
-      log.warn("ModuleHost", `provide("${token.key}") called outside a module register() lifecycle — the resource won't be cleaned up on unload`);
+      log.warn("module-host", `provide("${token.key}") called outside a module register() lifecycle — the resource won't be cleaned up on unload`);
     }
+    this.provideFor(this.currentModuleName, token, value);
+  }
+
+  private provideFor<T>(owner: string, token: ResourceToken<T>, value: T): void {
     if (isStrict()) {
-      assertNoDuplicate(this.providers, token as ResourceToken<unknown>, this.currentModuleName);
+      assertNoDuplicate(this.providers, token as ResourceToken<unknown>, owner);
     }
     this.resources.set(token.key, { token: token as ResourceToken<unknown>, value });
-    this.providers.set(token.key, this.currentModuleName);
-    const active = this.active.get(this.currentModuleName);
+    this.providers.set(token.key, owner);
+    const active = this.active.get(owner);
     if (active) {
       active.providedKeys.add(token.key);
     }
@@ -393,11 +409,15 @@ export class ModuleHost implements ModuleContext {
   }
 
   inject<T>(token: ResourceToken<T>): T {
+    return this.injectFor(this.currentModuleName, token);
+  }
+
+  private injectFor<T>(owner: string, token: ResourceToken<T>): T {
     const entry = this.resources.get(token.key);
     if (!entry) {
       throw new Error(
-        `Module "${this.currentModuleName}" injects "${token.key}" which is not provided. ` +
-          `Add a plugin that provides it, or use injectOptional() for safe reads.`,
+        `Module "${owner}" injects "${token.key}" which is not provided. ` +
+          `Add a module that provides it, or use injectOptional() for safe reads.`,
       );
     }
     return entry.value as T;
@@ -423,7 +443,7 @@ export class ModuleHost implements ModuleContext {
     } else {
       // Don't drop the callback silently — run it at disposeAll() so
       // resources registered outside a lifecycle still get cleaned up.
-      log.warn("ModuleHost", "onDispose called outside a module register() lifecycle — the callback will run at disposeAll() instead of being attributed to a module");
+      log.warn("module-host", "onDispose called outside a module register() lifecycle — the callback will run at disposeAll() instead of being attributed to a module");
       this.unattributedDisposeFns.push(fn);
     }
   }
@@ -438,6 +458,33 @@ export class ModuleHost implements ModuleContext {
   setCurrentPlugin(name: string): void {
     this.currentModuleName = name;
   }
+
+  /**
+   * Per-module context facade handed to `register()`. Lifecycle calls are
+   * bound to the owning module at creation time — a module that retains its
+   * ctx and calls it later (async callback, or during another module's
+   * register()) stays correctly attributed instead of leaking onto whatever
+   * module happens to be activating. Mirrors RendererModuleHost.makeContext.
+   */
+  private makeContext(name: string, active: ActiveModule): ModuleContext {
+    const devtoolsApi = () => this.devtools;
+    return {
+      // Lazy — the DevTools API may be injected after register() runs;
+      // resolving per-access keeps late wiring (setDevToolsAPI) working.
+      get devtools() { return devtoolsApi(); },
+      registerComponent: (n, s) => this.registerComponent(n, s),
+      registerSystem: (stage, system) => this.registerSystemFor(name, stage, system),
+      registerSystemObject: (system) => this.registerSystemObjectFor(name, system),
+      allocateSABChannel: (n, size) => this.allocateSABChannelFor(name, n, size),
+      provide: (token, value) => this.provideFor(name, token, value),
+      inject: (token) => this.injectFor(name, token),
+      injectOptional: (token) => this.injectOptional(token),
+      registerMigration: (fromVersion, fn) => this.registerMigration(fromVersion, fn),
+      onDispose: (fn) => {
+        active.disposeFns.push(fn);
+      },
+    };
+  }
 }
 
 // No-op DevTools API stub — used when setDevToolsAPI() hasn't been called.

package/core/src/module/index.ts

@@ -16,6 +16,7 @@ export type {
     PointerHandler, RendererInputBus,
     RendererModule,
     RendererModuleContext, RenderPassHook, ResizeHook,
+    ScreenUiCompositor,
     WheelHandler
 } from "./renderer-module";
 export { TsModuleLoader } from "./ts-loader";

package/core/src/module/module.ts

@@ -66,24 +66,30 @@ export interface ModuleDevToolsAPI {
 }
 
 export interface ModuleContext {
+  /**
+   * Register a component name and return its ComponentId.
+   * NOTE: `schema` is currently unused — the id is interned by name only
+   * (no defaults/definition are registered; use `component()` from the ecs
+   * barrel for a full definition). Reserved for future schema validation.
+   */
   registerComponent<T>(name: string, schema: T): ComponentId;
   registerSystem(stage: Stage, system: SystemFn): void;
   /** Register a pre-built System object (with queries) to the world schedule. */
   registerSystemObject(system: System): void;
   allocateSABChannel(name: string, size: number): SABChannel;
   /**
-   * Provide a typed resource to the plugin graph. Other plugins can
+   * Provide a typed resource to the module graph. Other modules can
    * `inject()` it by the same token. In DOWNDRAFT_STRICT mode, duplicate
    * provides of the same token throw a DiagnosticError.
    */
   provide<T>(token: ResourceToken<T>, value: T): void;
   /**
-   * Read a typed resource provided by another plugin. Throws if the token
+   * Read a typed resource provided by another module. Throws if the token
    * has no provider (use `injectOptional` for safe reads).
    */
   inject<T>(token: ResourceToken<T>): T;
   /**
-   * Read a typed resource, returning `undefined` if no plugin provides it.
+   * Read a typed resource, returning `undefined` if no module provides it.
    */
   injectOptional<T>(token: ResourceToken<T>): T | undefined;
   registerMigration(fromVersion: number, fn: (data: unknown) => unknown): void;
@@ -100,9 +106,9 @@ export interface Module {
   name: string;
   version: string;
   dependencies?: string[];
-  /** Typed tokens this plugin provides to the graph. Validated at activation. */
+  /** Typed tokens this module provides to the graph. Validated at activation. */
   provides?: ResourceToken<unknown>[];
-  /** Typed tokens this plugin requires from the graph. Validated at activation. */
+  /** Typed tokens this module requires from the graph. Validated at activation. */
   requires?: ResourceToken<unknown>[];
   register(ctx: ModuleContext): void;
 }

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

@@ -125,6 +125,9 @@ export interface ScreenUiCompositor {
   render(pass: GPURenderPassEncoder, surfaceWidth: number, surfaceHeight: number): void;
   /** When false for all compositors, no UI pass is opened. */
   hasContent(): boolean;
+  /** Draw order — higher renders later (on top). Default 0; the devtools
+   *  dock uses a large value so it overlays fullscreen game UI panels. */
+  order?: number;
 }
 
 // ── Renderer plugin context ──
@@ -164,6 +167,18 @@ export interface RendererModuleContext {
    */
   registerUiCompositor?(c: ScreenUiCompositor): () => void;
 
+  /**
+   * The native host's worker-pass mailbox — workers finish command buffers
+   * on a shared-device view and postPass() them into named slots; the
+   * renderer drains each slot into the matching submit batch every frame
+   * (refs arriving between drains land in the next frame — passes are
+   * stale-tolerant, never rendezvous'd). Null off native / before the host
+   * boots. Well-known slots: "preSubmit" (joins the frame batch submitted
+   * after viewports+postfx), "preUi" (submitted ahead of the UI-composite
+   * pass so worker output is visible to the compositor the same frame).
+   */
+  getGpuPassMailbox(): import("../platform/runtime").GpuPassMailboxLike | null;
+
   // ── Frame / resize hooks ──
   onFrame(phase: FramePhase, fn: FrameHook): () => void;
   onResize(fn: ResizeHook): () => void;

package/core/src/physics/safety.ts

@@ -241,7 +241,7 @@ export class SafetyLayer {
       throw new Error(`[Physics Safety] ${msg}`);
     } else {
       // Shipped: log and continue (never crash)
-      log.warn("Physics Safety", msg);
+      log.warn("physics-safety", msg);
     }
   }
 }

package/core/src/platform/bun-preload.ts

@@ -111,9 +111,14 @@ if (typeof (globalThis as any).Bun !== "undefined" && typeof (globalThis as any)
       // namespace gets cached as a package-looking specifier: re-resolution
       // wraps it in another "dd-css:<dir>" layer per ancestor walked, looping
       // forever at "/" until ENAMETOOLONG.
-      const stub = resolve(import.meta.dir, "css-stub.ts");
-      // NOTE: the stub is a .ts file specifically so the baked specifier never
+      // Prefer the .ts sibling in source layouts; the transpiled npm dist
+      // ships css-stub.js. Both are safe baked specifiers — neither
       // re-matches this /\.css$/ filter.
+      const { existsSync } = require("node:fs");
+      const tsStub = resolve(import.meta.dir, "css-stub.ts");
+      const stub = existsSync(tsStub)
+        ? tsStub
+        : resolve(import.meta.dir, "css-stub.js");
       build.onResolve({ filter: /\.css$/ }, () => ({ path: stub }));
       // Transpile-cache entries written by older versions still carry
       // "dd-css:<...>" specifiers — Bun routes those straight to the namespace

package/core/src/platform/glob-polyfill.ts

@@ -72,10 +72,13 @@ export function createGlob(callerDir: string): (pattern: string, options?: any)
 
     allFiles.forEach((file) => {
       const relPath = relative(fsCallerDir, file).replace(/\\/g, "/");
-      const prefixedPath = relPath.startsWith("..") ? relPath : "./" + relPath;
-      if (matchRegex.test(relPath) || matchRegex.test(prefixedPath)) {
+      // Vite-style keys: `./x` for same-dir/child paths, `../x` for parent
+      // traversal — NOT `./../x`. Callers match on these keys (startsWith
+      // on the pattern's literal prefix, endsWith on subpaths).
+      const key = relPath.startsWith("..") ? relPath : "./" + relPath;
+      if (matchRegex.test(relPath) || matchRegex.test(key)) {
         // For ?url queries, return the file:// URL
-        result["./" + relPath] = pathToFileURL(file).href;
+        result[key] = pathToFileURL(file).href;
       }
     });
     return result;
@@ -95,11 +98,15 @@ export function createGlob(callerDir: string): (pattern: string, options?: any)
 // converged on:
 //   1. `__nativeGlob` — installed by the native host (platform-native's
 //      installAssetGlob); caller-relative via the baseDir argument.
-//   2. `import.meta.glob` — present only under a Vite transform that injected
-//      it; a plain property read is undefined on native, so this is a safe
-//      second probe.
+//   2. `import.meta.glob` — a real implementation only ever exists when a
+//      Vite transform rewrote a LITERAL `import.meta.glob(` call at the call
+//      site; a passed-around meta object can't carry it. On Vite's
+//      ModuleRunner the meta object DOES expose a `glob` property — but it
+//      is a stub that throws ("statically replaced during file
+//      transformation"), so the probe must tolerate the throw.
 //   3. `createGlob(callerDir)` — filesystem glob relative to the caller's
-//      module dir (packaged binaries, bare runtimes without the host global).
+//      module dir (packaged binaries, bare runtimes without the host global,
+//      and the dev ModuleRunner where `meta.glob` is the throwing stub).
 //
 // Usage:
 //   const models = globAssets("../assets/models/*.glb", import.meta);
@@ -118,7 +125,9 @@ export function globAssets(
     return (native as (p: string, o?: unknown, baseDir?: string) => Record<string, string>)(pattern, opts, callerDir);
   }
   if (typeof meta.glob === "function") {
-    return (meta.glob as (p: string, o?: unknown) => Record<string, string>)(pattern, opts);
+    try {
+      return (meta.glob as (p: string, o?: unknown) => Record<string, string>)(pattern, opts);
+    } catch { /* ModuleRunner stub — fall through to the filesystem glob */ }
   }
   return createGlob(callerDir)(pattern, opts);
 }

package/core/src/platform/pkg-root.ts

@@ -0,0 +1,27 @@
+// ============================================================================
+// pkg-root.ts — package-root resolution for module-relative paths
+//
+// Modules that resolve package-relative paths (native crate dirs, staged
+// asset roots) must anchor at the package root rather than hardcoding a
+// ".." segment count: the transpiled npm dist/ nests modules one level
+// deeper than src/, so source-relative math escapes into dist/.
+// ============================================================================
+
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+/**
+ * Nearest ancestor directory containing a package.json, walking up from
+ * `fromDir`. Layout-agnostic — a module under src/ and its transpiled copy
+ * under dist/src/ resolve to the same package root. Falls back to
+ * `fromDir` when no package.json ancestor exists (bare file imports).
+ */
+export function findPackageRoot(fromDir: string): string {
+  let dir = fromDir;
+  for (;;) {
+    if (existsSync(join(dir, "package.json"))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) return fromDir;
+    dir = parent;
+  }
+}

package/core/src/platform/runtime.ts

@@ -113,12 +113,41 @@ export function getHostCapabilities(): HostCapabilities {
   return DOM_HOST_CAPABILITIES;
 }
 
+/** Structural view of the native host's per-device shared-GPU broker —
+ *  typed here because platform-native is an optional peer. payload() yields
+ *  the {gpu, cells} attach payload a worker needs for attachSharedDevice(). */
+export interface GpuShareBrokerLike {
+  payload(): { gpu: unknown; cells: SharedArrayBuffer };
+  attached(): number;
+  isAlive(): boolean;
+  markLost(): void;
+  retire(timeoutMs?: number): Promise<boolean>;
+}
+
+/** Structural view of the native host's worker-pass mailbox — the renderer
+ *  drains named slots into its submit batches; producers postPass() into
+ *  them. See gpu/pass-channel.ts for slot conventions. */
+export interface GpuPassMailboxLike {
+  /** Listen for gpuPass messages on a worker's message stream. */
+  watch(worker: { addEventListener(type: "message", fn: (e: { data: unknown }) => void): void; removeEventListener(type: "message", fn: (e: { data: unknown }) => void): void }): () => void;
+  /** Feed a raw message — for workers whose stream is owned elsewhere. */
+  feed(msg: unknown): boolean;
+  /** Import all pending refs for `slot` into owning command buffers —
+   *  renderer-only; call right before the submit they should join. */
+  drain(slot: string): GPUCommandBuffer[];
+}
+
 /** The subset of the live native host object games legitimately reach for —
  *  primarily its GPU handles until the renderer gets an injected device
  *  (Phase 2 of the native re-architecture). */
 export interface NativeHostHandle {
   device?: GPUDevice;
   adapter?: GPUAdapter;
+  /** Per-device shared-GPU broker (native only) — workers attach through
+   *  payload() so one liveness cells set reaches every consumer. */
+  gpuShare?: GpuShareBrokerLike;
+  /** Mailbox for worker-produced command buffers drained by the renderer. */
+  passMailbox?: GpuPassMailboxLike;
   [key: string]: unknown;
 }
 

package/core/src/plugin/discovery.ts

@@ -66,7 +66,7 @@ export async function discoverPlugins(
     const r = host.discover(manifest, baseUrl);
     if (!r.ok) {
       rejected.push({ id: manifest.id, errors: r.errors });
-      log.warn("PluginHost", `Rejected manifest "${manifest.id}": ${r.errors.join("; ")}`);
+      log.warn("plugin-host", `Rejected manifest "${manifest.id}": ${r.errors.join("; ")}`);
     }
   });
   await host.loadAll();

package/core/src/plugin/extension-loaders.ts

@@ -71,16 +71,18 @@ export function createAssetLoader(registry: AssetRegistry): ExtensionLoader {
       const id = a.id;
       switch (a.kind) {
         case "mesh":
-          await registry.registerMesh(id, a.path, manifestId, a as Record<string, unknown>);
+          // Pathless mesh = procedural primitive prop (shape/physics meta
+          // only). Pass "" so the registry registers an empty URL.
+          await registry.registerMesh(id, a.path ?? "", manifestId, a as Record<string, unknown>);
           return () => { registry.unregisterMesh(id); };
         case "texture":
-          await registry.registerTexture(id, a.path, manifestId, a as Record<string, unknown>);
+          await registry.registerTexture(id, a.path ?? "", manifestId, a as Record<string, unknown>);
           return () => { registry.unregisterTexture(id); };
         case "pbr-material":
-          await registry.registerPBRMaterial(id, a.path, manifestId, a);
+          await registry.registerPBRMaterial(id, a.path ?? "", manifestId, a);
           return () => { registry.unregisterPBRMaterial(id); };
         case "texture-pipeline":
-          await registry.registerTexturePipeline(id, a.path, manifestId, a);
+          await registry.registerTexturePipeline(id, a.path ?? "", manifestId, a);
           return () => { registry.unregisterTexturePipeline(id); };
         default:
           throw new Error(`Unknown asset kind: ${(a as any).kind}`);

package/core/src/plugin/host.ts

@@ -175,7 +175,7 @@ export class PluginHost {
    */
   publishEvent(event: string, data: unknown): void {
     if (this.opts.eventCatalog && !(event in this.opts.eventCatalog)) {
-      log.warn("PluginHost", `publishEvent("${event}") — not in the game's event catalog; delivering anyway`);
+      log.warn("plugin-host", `publishEvent("${event}") — not in the game's event catalog; delivering anyway`);
     }
     this.eventBus.publish(event, data);
   }
@@ -190,7 +190,7 @@ export class PluginHost {
       try {
         drain(dt, elapsedTime);
       } catch (e) {
-        log.error("PluginHost", `Plugin tick error: ${(e as Error).message}`);
+        log.error("plugin-host", `Plugin tick error: ${(e as Error).message}`);
       }
     }
     for (const loader of this.loaders.values()) {
@@ -252,7 +252,7 @@ export class PluginHost {
     try {
       order = this.registry.resolveOrder();
     } catch (e) {
-      log.error("PluginHost", `Dependency resolution failed: ${(e as Error).message}`);
+      log.error("plugin-host", `Dependency resolution failed: ${(e as Error).message}`);
       // Mark all discovered as errored.
       for (const [id, d] of this.discovered.entries()) {
         this.active.set(id, {
@@ -286,7 +286,7 @@ export class PluginHost {
           error: "a dependency failed to load",
           source: d.source,
         });
-        log.warn("PluginHost", `Skipping "${id}" — dependency failed`);
+        log.warn("plugin-host", `Skipping "${id}" — dependency failed`);
         continue;
       }
       await this.loadOne(id);
@@ -313,7 +313,7 @@ export class PluginHost {
         error: `no loader registered for format "${logicFormat}"`,
         source: d.source,
       });
-      log.error("PluginHost", `No loader for "${id}" (format ${logicFormat})`);
+      log.error("plugin-host", `No loader for "${id}" (format ${logicFormat})`);
       return;
     }
     const granted = resolvePermissions(
@@ -346,7 +346,7 @@ export class PluginHost {
       for (let _i = 0, _it = exts, _n = _it.length; _i < _n; _i++) { const ext = _it[_i];
         const extLoader = this.extensionLoaders.get(ext.bucket);
         if (!extLoader) {
-          log.warn("PluginHost", `No extension loader for bucket "${ext.bucket}" (mod "${id}") — skipping`);
+          log.warn("plugin-host", `No extension loader for bucket "${ext.bucket}" (mod "${id}") — skipping`);
           continue;
         }
         try {
@@ -356,17 +356,17 @@ export class PluginHost {
             a.disposeFns.push(dispose);
           }
         } catch (e) {
-          log.error("PluginHost", `Extension load error in "${id}" (${ext.bucket}): ${(e as Error).message}`);
+          log.error("plugin-host", `Extension load error in "${id}" (${ext.bucket}): ${(e as Error).message}`);
         }
       }
       const a = this.active.get(id)!;
       a.status = "active";
-      log.info("PluginHost", `Loaded mod "${id}" (${logicFormat ?? "data"}/${m.tier})`);
+      log.info("plugin-host", `Loaded mod "${id}" (${logicFormat ?? "data"}/${m.tier})`);
     } catch (e) {
       const a = this.active.get(id)!;
       a.status = "error";
       a.error = (e as Error).message;
-      log.error("PluginHost", `Failed to load mod "${id}": ${(e as Error).message}`);
+      log.error("plugin-host", `Failed to load mod "${id}": ${(e as Error).message}`);
     }
   }
 
@@ -442,7 +442,7 @@ export class PluginHost {
     const catalog = this.opts.eventCatalog;
     const check = (event: string, op: string) => {
       if (catalog && !(event in catalog)) {
-        log.warn("PluginHost", `plugin "${pluginId}" ${op} unknown event "${event}" (not in catalog)`);
+        log.warn("plugin-host", `plugin "${pluginId}" ${op} unknown event "${event}" (not in catalog)`);
       }
     };
     return {
@@ -466,7 +466,7 @@ export class PluginHost {
       try {
         a.disposeFns[i]();
       } catch (e) {
-        log.error("PluginHost", `Dispose error in plugin "${id}": ${(e as Error).message}`);
+        log.error("plugin-host", `Dispose error in plugin "${id}": ${(e as Error).message}`);
       }
     }
     this.active.delete(id);
@@ -488,7 +488,7 @@ export class PluginHost {
   async reload(id: string): Promise<void> {
     const d = this.discovered.get(id);
     if (!d) {
-      log.warn("PluginHost", `reload: "${id}" not discovered`);
+      log.warn("plugin-host", `reload: "${id}" not discovered`);
       return;
     }
     this.unload(id);
@@ -649,7 +649,7 @@ function fmt(msg: string, args: unknown[]): string {
 }
 
 function makeLogger(_pluginId: string): PluginLogger {
-  const prefix = `[plugin:${_pluginId}]`;
+  const prefix = `plugin:${_pluginId}`;
   return {
     info: (msg, ...args) => log.info(prefix, fmt(msg, args)),
     warn: (msg, ...args) => log.warn(prefix, fmt(msg, args)),

package/core/src/plugin/loader-asset.ts

@@ -67,7 +67,7 @@ export class AssetPluginLoader implements PluginLoader {
         await am.load(path);
         loaded.push(path);
       } catch (e) {
-        log.error("AssetPluginLoader", `Failed to load texture "${path}" for plugin "${manifest.id}": ${(e as Error).message}`);
+        log.error("asset-plugin-loader", `Failed to load texture "${path}" for plugin "${manifest.id}": ${(e as Error).message}`);
       }
     }
     for (let _i = 0, _it = assets.audio ?? [], _n = _it.length; _i < _n; _i++) { const path = _it[_i];
@@ -75,7 +75,7 @@ export class AssetPluginLoader implements PluginLoader {
         await am.load(path);
         loaded.push(path);
       } catch (e) {
-        log.error("AssetPluginLoader", `Failed to load audio "${path}" for plugin "${manifest.id}": ${(e as Error).message}`);
+        log.error("asset-plugin-loader", `Failed to load audio "${path}" for plugin "${manifest.id}": ${(e as Error).message}`);
       }
     }
     for (let _i = 0, _it = assets.meshes ?? [], _n = _it.length; _i < _n; _i++) { const path = _it[_i];
@@ -83,7 +83,7 @@ export class AssetPluginLoader implements PluginLoader {
         await am.load(path);
         loaded.push(path);
       } catch (e) {
-        log.error("AssetPluginLoader", `Failed to load mesh "${path}" for plugin "${manifest.id}": ${(e as Error).message}`);
+        log.error("asset-plugin-loader", `Failed to load mesh "${path}" for plugin "${manifest.id}": ${(e as Error).message}`);
       }
     }
     // Data files (JSON etc.) — loaded as raw text via the generic loader.
@@ -92,12 +92,12 @@ export class AssetPluginLoader implements PluginLoader {
         await am.load(path);
         loaded.push(path);
       } catch (e) {
-        log.error("AssetPluginLoader", `Failed to load data "${path}" for plugin "${manifest.id}": ${(e as Error).message}`);
+        log.error("asset-plugin-loader", `Failed to load data "${path}" for plugin "${manifest.id}": ${(e as Error).message}`);
       }
     }
 
     this.loadedUris.set(manifest.id, loaded);
-    log.info("AssetPluginLoader", `Loaded ${loaded.length} asset(s) for plugin "${manifest.id}" from ${base}`);
+    log.info("asset-plugin-loader", `Loaded ${loaded.length} asset(s) for plugin "${manifest.id}" from ${base}`);
 
     return () => this.dispose(manifest.id);
   }

package/core/src/plugin/loader-quickjs.ts

@@ -69,7 +69,7 @@ export class QuickjsPluginLoader implements PluginLoader {
     bridge.eval(`register(ddPlugin);`, `${entryUrl}#register`);
 
     bridge.drainJobs();
-    log.info("QuickjsPluginLoader", `Loaded QuickJS plugin "${manifest.id}"`);
+    log.info("quickjs-plugin-loader", `Loaded QuickJS plugin "${manifest.id}"`);
 
     return () => {
       bridge.dispose();

package/core/src/plugin/loader-wasm.ts

@@ -267,7 +267,7 @@ export class InlineWasmPluginLoader implements PluginLoader {
       (subscriptions as any).__tickUnsub = unsub;
     }
 
-    log.info("InlineWasmPluginLoader", `Loaded WASM plugin "${manifest.id}"`);
+    log.info("inline-wasm-plugin-loader", `Loaded WASM plugin "${manifest.id}"`);
 
     return () => {
       const unsubTick = (subscriptions as any).__tickUnsub;
@@ -319,7 +319,7 @@ export class WasmPluginLoader implements PluginLoader {
     });
 
     worker.onerror = (e) => {
-      log.error("WasmPluginLoader", `worker error for "${manifest.id}": ${e.message}`);
+      log.error("wasm-plugin-loader", `worker error for "${manifest.id}": ${e.message}`);
     };
 
     // Send init message with the WASM URL.
@@ -395,7 +395,7 @@ export class WasmPluginLoader implements PluginLoader {
     });
 
     await ready;
-    log.info("WasmPluginLoader", `Loaded WASM plugin "${manifest.id}" in dedicated worker`);
+    log.info("wasm-plugin-loader", `Loaded WASM plugin "${manifest.id}" in dedicated worker`);
 
     return () => {
       worker.postMessage({ __wasmDispose: true });

package/core/src/plugin/loader-worker.ts

@@ -73,7 +73,7 @@ export class WorkerPluginLoader implements PluginLoader {
       // sim-thread worker-js plugins are loaded by the sim worker's own host
       // via direct dynamic import (not this loader). Renderer-side host skips.
       log.info(
-        "WorkerPluginLoader",
+        "worker-plugin-loader",
         `plugin "${manifest.id}" thread=${manifest.thread} — skipping on this host (sim-side host loads it)`,
       );
       return;