@downdraft/engine 0.1.1 → 0.1.2-alpha.5

package/core/src/save/migration-registry.ts

@@ -49,7 +49,7 @@ export class MigrationRegistryImpl implements IMigrationRegistry {
     const entry = this.components.get(component);
     if (!entry) {
       if (fromVersion === 1) return { data, version: 1 };
-      log.warn("MigrationRegistry", `Unknown component "${component}" with version ${fromVersion}`);
+      log.warn("migration-registry", `Unknown component "${component}" with version ${fromVersion}`);
       return null;
     }
 
@@ -59,7 +59,7 @@ export class MigrationRegistryImpl implements IMigrationRegistry {
 
     if (fromVersion > entry.currentVersion) {
       log.warn(
-        "MigrationRegistry",
+        "migration-registry",
         `Component "${component}" save version ${fromVersion} > current ${entry.currentVersion} — forward incompatible`,
       );
       return null;
@@ -72,7 +72,7 @@ export class MigrationRegistryImpl implements IMigrationRegistry {
       const step = entry.migrations.get(version);
       if (!step) {
         log.warn(
-          "MigrationRegistry",
+          "migration-registry",
           `Missing migration for "${component}" v${version}→v${version + 1} — marking as abandoned`,
         );
         return null;
@@ -82,7 +82,7 @@ export class MigrationRegistryImpl implements IMigrationRegistry {
         version = step.toVersion;
       } catch (e) {
         log.warn(
-          "MigrationRegistry",
+          "migration-registry",
           `Migration failed for "${component}" v${version}→v${step.toVersion}: ${e}`,
         );
         return null;

package/core/src/save/schema.ts

@@ -31,7 +31,7 @@ export class SchemaRegistry {
       try {
         current = fn(current);
       } catch (e) {
-        log.warn("SchemaRegistry", `Migration v${version}→v${version + 1} failed: ${e} — returning data at v${version}`);
+        log.warn("schema-registry", `Migration v${version}→v${version + 1} failed: ${e} — returning data at v${version}`);
         return current;
       }
       version++;

package/core/src/scene/prefab.ts

@@ -30,7 +30,7 @@ export class PrefabRegistry {
 
   register(prefab: Prefab): void {
     if (this.prefabs.has(prefab.name)) {
-      log.warn("PrefabRegistry", `Overwriting prefab "${prefab.name}"`);
+      log.warn("prefab-registry", `Overwriting prefab "${prefab.name}"`);
     }
     this.prefabs.set(prefab.name, prefab);
   }

package/core/src/scene/scene-manager.ts

@@ -17,7 +17,7 @@ export class SceneManager {
 
   register(scene: Scene): void {
     if (this.scenes.has(scene.name)) {
-      log.warn("SceneManager", `Overwriting scene "${scene.name}"`);
+      log.warn("scene-manager", `Overwriting scene "${scene.name}"`);
     }
     this.scenes.set(scene.name, scene);
   }
@@ -108,7 +108,7 @@ export class SceneManager {
     next.activate();
     this.activeScenes.add(name);
     this._currentScene = next;
-    log.info("SceneManager", `Transitioned to "${name}"`);
+    log.info("scene-manager", `Transitioned to "${name}"`);
   }
 
   // ── Additive Loading ───────────────────────────────────────────

package/core/src/scene/scene.ts

@@ -95,7 +95,7 @@ export class Scene {
 
   async load(): Promise<void> {
     if (this.state !== "unloaded") {
-      log.warn("Scene", `Cannot load "${this.name}" — current state: ${this.state}`);
+      log.warn("scene", `Cannot load "${this.name}" — current state: ${this.state}`);
       return;
     }
     this.state = "loading";
@@ -105,7 +105,7 @@ export class Scene {
     }
 
     this.state = "loaded";
-    log.info("Scene", `Loaded "${this.name}" (${this._entities.length} entities)`);
+    log.info("scene", `Loaded "${this.name}" (${this._entities.length} entities)`);
   }
 
   unload(): void {
@@ -122,12 +122,12 @@ export class Scene {
     this._entities = [];
     this._entitySet.clear();
     this.state = "unloaded";
-    log.info("Scene", `Unloaded "${this.name}"`);
+    log.info("scene", `Unloaded "${this.name}"`);
   }
 
   activate(): void {
     if (this.state === "unloaded" || this.state === "loading") {
-      log.warn("Scene", `Cannot activate "${this.name}" — not loaded`);
+      log.warn("scene", `Cannot activate "${this.name}" — not loaded`);
       return;
     }
     this.state = "active";

package/core/src/scene/streaming.ts

@@ -198,12 +198,12 @@ export class WorldStreamer {
       } catch (err) {
         const retries = this.retryCounts.get(key) ?? 0;
         if (retries >= MAX_CHUNK_RETRIES) {
-          log.error("WorldStreamer", `Chunk ${key} failed after ${MAX_CHUNK_RETRIES} retries: ${err}`);
+          log.error("world-streamer", `Chunk ${key} failed after ${MAX_CHUNK_RETRIES} retries: ${err}`);
           this.retryCounts.delete(key);
         } else {
           const delay = INITIAL_RETRY_DELAY_MS * (1 << retries);
           this.retryCounts.set(key, retries + 1);
-          log.warn("WorldStreamer", `Chunk ${key} load failed (retry ${retries + 1}/${MAX_CHUNK_RETRIES}), retrying in ${delay}ms: ${err}`);
+          log.warn("world-streamer", `Chunk ${key} load failed (retry ${retries + 1}/${MAX_CHUNK_RETRIES}), retrying in ${delay}ms: ${err}`);
           setTimeout(() => {
             this.loadQueue.push({
               coord,

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

@@ -70,7 +70,7 @@ export class HotReloader {
       try {
         entry.cleanups[i]();
       } catch (err) {
-        log.error("HotReloader", `Cleanup error for "${name}": ${err}`);
+        log.error("hot-reloader", `Cleanup error for "${name}": ${err}`);
       }
     }
     entry.cleanups = [];
@@ -79,7 +79,7 @@ export class HotReloader {
       await this.scripting.hotReload(name, path);
       if (entry.onReload) entry.onReload(path);
     } catch (err) {
-      log.error("HotReloader", `Reload error for "${name}": ${err}`);
+      log.error("hot-reloader", `Reload error for "${name}": ${err}`);
     }
   }
 

package/core/src/sim/hot-reload-pipeline.ts

@@ -11,6 +11,30 @@ import type { IWorkerManager } from "./types";
 
 const log = createLogger();
 
+// Per-step bounds. A wedged worker must not hang the pipeline forever — the
+// dev shell escalates unresponsive swaps to a session restart, and an
+// unbounded hotReload promise keeps the dying session (worker host, SABs,
+// module graph) pinned. `start` gets the largest budget: dev cold-transform
+// of a cache-busted worker module can legitimately take tens of seconds.
+const SAVE_TIMEOUT_MS = 15_000;
+const STOP_TIMEOUT_MS = 15_000;
+const START_TIMEOUT_MS = 90_000;
+const RESTORE_TIMEOUT_MS = 30_000;
+
+async function withTimeout<T>(p: Promise<T>, ms: number, label: string): Promise<T> {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  try {
+    return await Promise.race([
+      p,
+      new Promise<never>((_, rej) => {
+        timer = setTimeout(() => rej(new Error(`${label} timed out after ${ms}ms`)), ms);
+      }),
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
 export class HotReloadPipeline {
   private workerManager: IWorkerManager;
 
@@ -24,25 +48,25 @@ export class HotReloadPipeline {
     // 1. Save state if preserving
     if (preserveState) {
       try {
-        const result = await this.workerManager.save("hot-reload");
+        const result = await withTimeout(this.workerManager.save("hot-reload"), SAVE_TIMEOUT_MS, "save");
         if (result?.stateJson) stateJson = result.stateJson;
       } catch (err) {
-        log.warn("HotReloadPipeline", `State save failed, reloading without preservation: ${err}`);
+        log.warn("hot-reload-pipeline", `State save failed, reloading without preservation: ${err}`);
       }
     }
 
     // 2. Stop current worker
-    await this.workerManager.stop();
+    await withTimeout(this.workerManager.stop(), STOP_TIMEOUT_MS, "worker stop");
 
     // 3. Start new worker
-    await this.workerManager.start(config);
+    await withTimeout(this.workerManager.start(config), START_TIMEOUT_MS, "worker start");
 
     // 4. Restore state if preserving
     if (preserveState && stateJson) {
       try {
-        await this.workerManager.restoreFromState(stateJson);
+        await withTimeout(this.workerManager.restoreFromState(stateJson), RESTORE_TIMEOUT_MS, "state restore");
       } catch (err) {
-        log.error("HotReloadPipeline", `State restore failed: ${err}. Starting fresh.`);
+        log.error("hot-reload-pipeline", `State restore failed: ${err}. Starting fresh.`);
       }
     }
   }

package/core/src/sim/sim-state-helper.ts

@@ -34,7 +34,7 @@ export class SimStateHelper {
       this.registry.stripTransientFlags(state);
       return JSON.stringify(state);
     } catch (err) {
-      log.error("SimStateHelper", `Failed to strip transient flags: ${err}`);
+      log.error("sim-state-helper", `Failed to strip transient flags: ${err}`);
       return stateJson;
     }
   }

package/core/src/sim/transient-state-registry.ts

@@ -57,7 +57,7 @@ export class TransientStateRegistry {
       try {
         this.resetCallbacks[i]();
       } catch (err) {
-        log.error("TransientStateRegistry", `Reset callback ${i} failed: ${err}`);
+        log.error("transient-state-registry", `Reset callback ${i} failed: ${err}`);
       }
     }
   }

package/core/src/sim/worker-loop.ts

@@ -187,7 +187,7 @@ export class SimWorkerLoop {
               const nowMs = performance.now();
               if (nowMs - this.lastClampWarn > 5000) {
                 this.lastClampWarn = nowMs;
-                log.warn("SimWorkerLoop", `Clamped to ${this.maxStepsPerFrame} ticks this frame (sim falling behind, accumulator=${this.tickAccumulator.toFixed(1)})`);
+                log.warn("sim-worker-loop", `Clamped to ${this.maxStepsPerFrame} ticks this frame (sim falling behind, accumulator=${this.tickAccumulator.toFixed(1)})`);
               }
               this.tickAccumulator = 0;
             }
@@ -195,7 +195,7 @@ export class SimWorkerLoop {
           }
         } catch (err) {
           const error = err as Error;
-          log.error("SimWorkerLoop", `Tick crashed at tick ${this.tickCount}: ${error.message}\n${error.stack}`);
+          log.error("sim-worker-loop", `Tick crashed at tick ${this.tickCount}: ${error.message}\n${error.stack}`);
           this.onErrorCb?.(error);
           this.running = false;
           return;

package/core/src/telemetry/gpu-profiler.ts

@@ -159,7 +159,7 @@ export class GPUProfiler {
       if (!state) {
         // First occurrence — log immediately and start a throttle window.
         self.errorThrottle.set(key, { count: 1, firstSeen: now, lastLogged: now, suppressed: 0 });
-        log.error("GPU", `${label ? label + " " : ""}WebGPU uncaptured error: ${message}`);
+        log.error("gpu", `${label ? label + " " : ""}WebGPU uncaptured error: ${message}`);
         return;
       }
       state.count++;
@@ -172,7 +172,7 @@ export class GPUProfiler {
       // Window elapsed — emit a summary of suppressed duplicates and reset.
       const suppressed = state.suppressed + 1; // +1 for this occurrence
       log.error(
-        "GPU",
+        "gpu",
         `${label ? label + " " : ""}WebGPU uncaptured error: ${message} ` +
           `(repeated ${suppressed}× in ${Math.round(elapsed)}ms)`,
       );
@@ -182,7 +182,7 @@ export class GPUProfiler {
 
     device.lost.then((info: GPUDeviceLostInfo) => {
       self.deviceLost = true;
-      log.error("GPU", `WebGPU device lost: ${info?.reason ?? "unknown"} — ${info?.message ?? ""}`);
+      log.error("gpu", `WebGPU device lost: ${info?.reason ?? "unknown"} — ${info?.message ?? ""}`);
     });
   }
 

package/core/src/util/index.ts

@@ -12,6 +12,6 @@ export {
     formatBytesShort
 } from "./feature-log";
 export type { FeatureLogData } from "./feature-log";
-export { addLogSink, ConsoleLogger, createLogger, getRecentLogs, setThreadTag } from "./logger";
+export { addLogSink, ConsoleLogger, createLogger, getLogTheme, getRecentLogs, setThreadTag } from "./logger";
 export type { Logger, LogSink, LogSinkEntry } from "./logger";
 

package/core/src/util/logger.ts

@@ -29,7 +29,7 @@ if (proc?.stderr?.on) proc.stderr.on("error", swallowStreamError);
 
 // ── Log sinks (for the native devtools console bridge) ──
 // Sinks receive every log line (ANSI-stripped) so an external consumer like
-// the native egui devtools console can display logs that bypass console.log
+// the devtools console can display logs that bypass console.log
 // (the native logger writes directly to process.stdout, which CDP never sees).
 export interface LogSinkEntry {
     level: string;      // "trace"|"debug"|"info"|"warn"|"error"|"fatal"
@@ -207,6 +207,21 @@ function linkifyModule(module: string): string {
     return makeFileLink(module);
 }
 
+/** Normalize a module tag to the lowercase-kebab convention
+ *  ("GameRenderer" → "game-renderer", "SIM WORKER" → "sim-worker").
+ *  Only word-style names are rewritten — anything with heavier
+ *  separators (paths, "plugin:x", "dev/hmr", bundle names like
+ *  "chunk-5H6VXLYO.js:2419") already carries its own format and
+ *  passes through untouched. */
+function normalizeModuleTag(module: string): string {
+    if (!/^[A-Za-z0-9][A-Za-z0-9 _]*$/.test(module)) return module;
+    return module
+        .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
+        .replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2")
+        .replace(/[\s_]+/g, "-")
+        .toLowerCase();
+}
+
 function getJsonColors(theme: "light" | "dark") {
     const t = THEMES[theme];
     return {
@@ -430,6 +445,14 @@ let _theme: "light" | "dark" | undefined;
 function getTheme(): "light" | "dark" {
     if (_theme) return _theme;
 
+    // DD_LOG_THEME — `draft` detects the theme once (its stdout is the real
+    // TTY, so the OSC-11 probe works) and stamps it into the env of every
+    // spawned child. Piped-stdout processes (dev shell, games, workers)
+    // skip the subprocess probes — which would guess via gsettings/dbus and
+    // can disagree with the actual terminal background.
+    const forced = proc.env.DD_LOG_THEME;
+    if (forced === "dark" || forced === "light") return (_theme = forced);
+
     const colorfgbg = proc.env.COLORFGBG;
     if (colorfgbg) {
         const parts = colorfgbg.split(";");
@@ -511,6 +534,13 @@ function getTheme(): "light" | "dark" {
     return (_theme = "dark");
 }
 
+/** The resolved log theme (env override → terminal/desktop probes → "dark").
+ *  Resolved once and cached — CLIs stamp it into DD_LOG_THEME so spawned
+ *  children inherit it without re-running the probes. */
+export function getLogTheme(): "light" | "dark" {
+    return getTheme();
+}
+
 export class ConsoleLogger implements Logger {
     private readonly palette: (typeof THEMES)["dark"];
 
@@ -522,12 +552,13 @@ export class ConsoleLogger implements Logger {
         const cleanMsg = msg.replace(/\n+$/, "");
         const color = (this.palette as any)[level];
         const timestamp = new Date().toTimeString().slice(0, 8);
-        const linkedModule = linkifyModule(module);
+        const moduleName = normalizeModuleTag(module);
+        const linkedModule = linkifyModule(moduleName);
         let moduleStr: string;
-        if (isPathLike(module)) {
+        if (isPathLike(moduleName)) {
             moduleStr = linkedModule;
         } else {
-            moduleStr = `${this.palette.module}${module}`;
+            moduleStr = `${this.palette.module}${moduleName}`;
         }
         const tag = getThreadTag();
         const tagColor = (this.palette.thread as Record<string, string>)[tag] ?? this.palette.module;
@@ -539,7 +570,7 @@ export class ConsoleLogger implements Logger {
         // Notify log sinks (native devtools console bridge) with clean text.
         emitToSinks({
             level,
-            module,
+            module: moduleName,
             message: stripAnsi(cleanMsg),
             thread: tag,
             timestamp: (typeof performance !== "undefined" ? performance.now() : Date.now()),

package/core/src/version.ts

@@ -0,0 +1,13 @@
+// ============================================================================
+// version.ts — ENGINE_VERSION as a leaf module.
+//
+// Lives outside the root barrel (index.ts re-exports it) so startup-critical
+// consumers — platform-native's createNativeHost, the shared feature-log —
+// can take a @downdraft/engine/version edge instead of pulling the whole
+// barrel subtree into the dev transform graph.
+// ============================================================================
+
+import pkg from "../../package.json" with { type: "json" };
+
+/** Engine semver — single source of truth is package.json. */
+export const ENGINE_VERSION: string = pkg.version;

package/core/src/worker/base-worker-host.ts

@@ -36,6 +36,7 @@ export abstract class BaseWorkerHost<TApi extends WorkerApi> {
   protected ready = false;
   private unsubEvents: (() => void) | null = null;
   private syncHost: BufferSyncHost | null = null;
+  private lifecycleLock: Promise<void> | null = null;
 
   constructor(sab: SharedArrayBuffer) {
     this.sab = sab;
@@ -56,6 +57,36 @@ export abstract class BaseWorkerHost<TApi extends WorkerApi> {
     return this.proxy;
   }
 
+  /**
+   * Serialize start()/stop() — a hot-reload save→stop→start cycle racing a
+   * second caller (overlapping swap events, session teardown) must not
+   * interleave worker/proxy swaps, or workers get orphaned mid-flight.
+   * FIFO mutex; uncontended calls invoke fn synchronously so start() wires
+   * the worker in the caller's own tick (post-await subscribers rely on it).
+   */
+  private serialized<T>(fn: () => Promise<T>): Promise<T> {
+    let release!: () => void;
+    const mine = new Promise<void>((r) => (release = r));
+    const prev = this.lifecycleLock;
+    this.lifecycleLock = mine;
+    const settle = () => {
+      if (this.lifecycleLock === mine) this.lifecycleLock = null;
+      release();
+    };
+    if (!prev) {
+      const result = Promise.resolve(fn());
+      void result.finally(settle);
+      return result;
+    }
+    return prev.then(async () => {
+      try {
+        return await fn();
+      } finally {
+        settle();
+      }
+    });
+  }
+
   /**
    * Spawn the worker and call its init RPC.
    *
@@ -68,32 +99,47 @@ export abstract class BaseWorkerHost<TApi extends WorkerApi> {
    * override getSyncConfig() to declare the region layout.
    */
   async start(): Promise<void> {
-    this.worker = this.createWorker();
-    // 120s rather than the 30s default: in dev, vite's cold transform of a
-    // large worker module can exceed 30s, killing init with a spurious
-    // timeout while the worker is still legitimately loading.
-    this.proxy = wrap<TApi>(this.worker, { timeoutMs: 120_000 });
-
-    this.worker.onerror = (e: ErrorEvent) => {
-      this.onError(e);
-    };
-
-    this.unsubEvents = this.proxy.onEvents((kind: string, data?: unknown) => {
-      this.onEvent(kind, data);
-    });
-
-    // SAB polyfill: start buffer sync host before onInit so input sync begins
-    // as soon as the worker is ready. The host uses rAF to sync input regions.
-    if (!usingRealSAB && this.getSyncConfig()) {
-      const { BufferSyncHost: BSH } = await import("./buffer-sync");
-      this.syncHost = new BSH(this.worker, this.getSyncConfig()!);
-      this.syncHost.start();
-    }
+    return this.serialized(async () => {
+      // Re-entrant start while a worker is live (overlapping hot reloads,
+      // teardown racing a respawn) must not orphan the old worker.
+      if (this.worker || this.proxy) await this.stopInner();
+
+      this.worker = this.createWorker();
+      // A live worker must never be the only handle pinning the process —
+      // window-close teardown stops it explicitly (sim.stop()), but a worker
+      // that slips through (error path, missing stop impl) shouldn't hold
+      // the runtime open forever. No-op where unref doesn't exist (Deno).
+      (this.worker as any).unref?.();
+      // 120s rather than the 30s default: in dev, vite's cold transform of a
+      // large worker module can exceed 30s, killing init with a spurious
+      // timeout while the worker is still legitimately loading.
+      this.proxy = wrap<TApi>(this.worker, { timeoutMs: 120_000 });
+      // Tag the Worker with its RPC proxy so external force-terminates (dev
+      // session teardown) reject pending calls instead of leaving them to
+      // hang until their timeout — a hanging caller pins the dying session.
+      (this.worker as any).__ddWorkerProxy = this.proxy;
+
+      this.worker.onerror = (e: ErrorEvent) => {
+        this.onError(e);
+      };
+
+      this.unsubEvents = this.proxy.onEvents((kind: string, data?: unknown) => {
+        this.onEvent(kind, data);
+      });
+
+      // SAB polyfill: start buffer sync host before onInit so input sync begins
+      // as soon as the worker is ready. The host uses rAF to sync input regions.
+      if (!usingRealSAB && this.getSyncConfig()) {
+        const { BufferSyncHost: BSH } = await import("./buffer-sync");
+        this.syncHost = new BSH(this.worker, this.getSyncConfig()!);
+        this.syncHost.start();
+      }
 
-    // Hook for subclasses to run setup before onInit (e.g. attaching profiling SAB).
-    await this.beforeInit();
+      // Hook for subclasses to run setup before onInit (e.g. attaching profiling SAB).
+      await this.beforeInit();
 
-    await this.onInit();
+      await this.onInit();
+    });
   }
 
   /**
@@ -110,11 +156,27 @@ export abstract class BaseWorkerHost<TApi extends WorkerApi> {
    * Safe to call multiple times.
    */
   async stop(): Promise<void> {
+    return this.serialized(() => this.stopInner());
+  }
+
+  private async stopInner(): Promise<void> {
     this.syncHost?.stop();
     this.syncHost = null;
     if (this.proxy) {
       try {
-        await this.proxy.proxy.shutdown();
+        // Bounded graceful shutdown — a wedged worker must not hang stop()
+        // (and through it, hot-reload pipelines and session teardown).
+        let timer: ReturnType<typeof setTimeout> | undefined;
+        try {
+          await Promise.race([
+            this.proxy.proxy.shutdown(),
+            new Promise((_, rej) => {
+              timer = setTimeout(() => rej(new Error("shutdown RPC timed out")), 2_000);
+            }),
+          ]);
+        } finally {
+          clearTimeout(timer);
+        }
       } catch {
         // Worker may already be dead
       }

package/core/src/worker/buffer-sync.ts

@@ -190,7 +190,7 @@ class SyncProfiler {
       const avgKB = (e.totalBytes / e.count / 1024).toFixed(1);
       lines.push(`  ${label}: ${e.count}x avg=${avgMs}ms max=${maxMs}ms avgSize=${avgKB}KB total=${totalKB}KB`);
     }
-    log.warn("BufferSync", `Profiling: ${this.samples.length} samples over last ${this.logInterval}ms:\n${lines.join("\n")}`);
+    log.warn("buffer-sync", `Profiling: ${this.samples.length} samples over last ${this.logInterval}ms:\n${lines.join("\n")}`);
     this.samples = [];
   }
 }

package/core/src/worker/crash-recovery.ts

@@ -103,7 +103,7 @@ export class CrashRecoveryManager {
         key: name,
         data: saveData,
       }).catch((err) => {
-        log.error("CrashRecovery", `Failed to persist checkpoint: ${err}`);
+        log.error("crash-recovery", `Failed to persist checkpoint: ${err}`);
       });
     }
 
@@ -152,7 +152,7 @@ export class CrashRecoveryManager {
       this.state.isRecovering = false;
       return true;
     } catch (err) {
-      log.error("CrashRecovery", `Recovery failed: ${err}`);
+      log.error("crash-recovery", `Recovery failed: ${err}`);
       this.state.isRecovering = false;
       return false;
     }

package/core/src/worker/instrumented-worker-host.ts

@@ -85,7 +85,7 @@ export abstract class InstrumentedWorkerHost<TApi extends WorkerApi> extends Bas
         },
       );
     } catch (err) {
-      log.warn("InstrumentedWorkerHost", `__profilingAttach failed for "${opts.workerTag}": ${err}`);
+      log.warn("instrumented-worker-host", `__profilingAttach failed for "${opts.workerTag}": ${err}`);
     }
   }
 
@@ -98,7 +98,7 @@ export abstract class InstrumentedWorkerHost<TApi extends WorkerApi> extends Bas
     try {
       await (proxy.proxy as any).__profilingAddRule(rule);
     } catch (err) {
-      log.warn("InstrumentedWorkerHost", `__profilingAddRule failed: ${err}`);
+      log.warn("instrumented-worker-host", `__profilingAddRule failed: ${err}`);
     }
   }
 
@@ -118,7 +118,7 @@ export abstract class InstrumentedWorkerHost<TApi extends WorkerApi> extends Bas
       await (proxy.proxy as any).__profilingOnWarning();
       return unsub;
     } catch (err) {
-      log.warn("InstrumentedWorkerHost", `__profilingOnWarning failed: ${err}`);
+      log.warn("instrumented-worker-host", `__profilingOnWarning failed: ${err}`);
       return () => {};
     }
   }