@downdraft/engine 0.1.1 → 0.2.0

package/libraries/marching-cubes/src/streaming-manager.ts

@@ -179,15 +179,15 @@ export class TerrainStreamingManager {
   ): void {
     if (radius <= 0) return;
     if (!Number.isFinite(worldX) || !Number.isFinite(worldY) || !Number.isFinite(worldZ)) {
-      log.warn("Streaming", `registerIsland(${id}) rejected: non-finite world coords (${worldX}, ${worldY}, ${worldZ})`);
+      log.warn("streaming", `registerIsland(${id}) rejected: non-finite world coords (${worldX}, ${worldY}, ${worldZ})`);
       return;
     }
     if (!Number.isFinite(biome) || biome < 0) {
-      log.warn("Streaming", `registerIsland(${id}) rejected: invalid biome ${biome}`);
+      log.warn("streaming", `registerIsland(${id}) rejected: invalid biome ${biome}`);
       return;
     }
     if (!Number.isFinite(islandSize) || islandSize < 0) {
-      log.warn("Streaming", `registerIsland(${id}) rejected: invalid islandSize ${islandSize}`);
+      log.warn("streaming", `registerIsland(${id}) rejected: invalid islandSize ${islandSize}`);
       return;
     }
 
@@ -405,7 +405,7 @@ export class TerrainStreamingManager {
         terrain.dirty = true;
         terrain.deformCount++;
       } catch (err) {
-        log.error("Streaming", `Deformation ${i} (id=${def.id}) failed: ${err}`);
+        log.error("streaming", `Deformation ${i} (id=${def.id}) failed: ${err}`);
       }
     }
 

package/libraries/models/src/bind-unskinned-meshes.ts

@@ -0,0 +1,131 @@
+// ============================================================================
+// Bind Unskinned Meshes — rigid-bind meshes without skin weights to the
+// nearest bone of the model's skeleton.
+//
+// Character asset packs (e.g. Unity/VRChat avatars round-tripped through FBX)
+// frequently contain accessory meshes — hair, glasses, hats, shoes, pants —
+// that carry no skin deformer because the DCC/prefab attached them as rigid
+// children of a bone, a relationship FBX cannot represent in the geometry.
+// Left unskinned they render at bind pose forever, visibly detached from the
+// animated skeleton (a hat floating where the head started, pants stuck at
+// the feet while the legs walk away).
+//
+// bindUnskinnedMeshes assigns every vertex of each unskinned mesh to the bone
+// whose bind-pose segment (joint → preferred child joint; leaf bones extend
+// along their own parent→joint axis so extremities still map correctly) is
+// nearest to the vertex — weight 1.0, matching the rigid-attachment semantics
+// the asset was authored with.
+// ============================================================================
+
+import { invertMat4 } from "@downdraft/engine";
+import type { ModelData } from "./types";
+
+/** Bone-name pattern for the "axial continuation" child that defines a bone's
+ *  segment direction (spine→spine, hand→middle finger, foot→toe, …). */
+const AXIAL_CHILD = /spine|neck|head|middle|ball|toe/i;
+
+/**
+ * Rigid-bind every mesh that lacks usable skin weights to the nearest
+ * bind-pose bone segment.
+ *
+ * Call after normalization: mesh vertices must be in the same space as the
+ * rendered model (i.e. post-normalizeModel). Bone bind positions are derived
+ * from `inverse(inverseBindMatrix)` — the bind world transform in source
+ * space — then mapped through `skin.normalizationMatrix` so they compare
+ * against normalized vertices.
+ *
+ * @returns the number of meshes that received synthesized skin weights.
+ */
+export function bindUnskinnedMeshes(modelData: ModelData): number {
+    const skin = modelData.skin;
+    if (!skin || skin.bones.length === 0 || !modelData.meshes?.length) return 0;
+
+    const bones = skin.bones;
+    const boneCount = bones.length;
+
+    // Bone joint positions at bind, in normalized vertex space.
+    const T = skin.normalizationMatrix ?? null;
+    const bindPos = new Float32Array(boneCount * 3);
+    for (let i = 0; i < boneCount; i++) {
+        const w = invertMat4(bones[i].inverseBindMatrix);
+        let x = w[12], y = w[13], z = w[14];
+        if (T) {
+            const nx = T[0] * x + T[4] * y + T[8] * z + T[12];
+            const ny = T[1] * x + T[5] * y + T[9] * z + T[13];
+            const nz = T[2] * x + T[6] * y + T[10] * z + T[14];
+            x = nx; y = ny; z = nz;
+        }
+        bindPos[i * 3] = x; bindPos[i * 3 + 1] = y; bindPos[i * 3 + 2] = z;
+    }
+
+    // Bone segments: joint → "tip". The tip is the axial-continuation child
+    // joint; leaf bones extend one bone-length along their own axis.
+    const children = new Map<number, number[]>();
+    for (let i = 0; i < boneCount; i++) {
+        const p = bones[i].parentIndex;
+        if (p < 0) continue;
+        let list = children.get(p);
+        if (!list) { list = []; children.set(p, list); }
+        list.push(i);
+    }
+    const segA = new Float32Array(boneCount * 3);
+    const segB = new Float32Array(boneCount * 3);
+    for (let i = 0; i < boneCount; i++) {
+        const ax = bindPos[i * 3], ay = bindPos[i * 3 + 1], az = bindPos[i * 3 + 2];
+        let bx = ax, by = ay, bz = az;
+        const kids = children.get(i);
+        if (kids && kids.length > 0) {
+            const tip = kids.find((k) => AXIAL_CHILD.test(bones[k].name)) ?? kids[0];
+            bx = bindPos[tip * 3]; by = bindPos[tip * 3 + 1]; bz = bindPos[tip * 3 + 2];
+        } else {
+            const p = bones[i].parentIndex;
+            if (p >= 0) {
+                bx = ax + (ax - bindPos[p * 3]);
+                by = ay + (ay - bindPos[p * 3 + 1]);
+                bz = az + (az - bindPos[p * 3 + 2]);
+            }
+        }
+        segA[i * 3] = ax; segA[i * 3 + 1] = ay; segA[i * 3 + 2] = az;
+        segB[i * 3] = bx; segB[i * 3 + 1] = by; segB[i * 3 + 2] = bz;
+    }
+
+    let bound = 0;
+    for (let _i = 0, _it = modelData.meshes, _n = _it.length; _i < _n; _i++) { const mesh = _it[_i];
+        // Matches the renderer's own test for "has skinning data".
+        if (mesh.joints && mesh.weights && mesh.joints.length >= mesh.vertexCount * 4) continue;
+        const vc = mesh.vertexCount;
+        const verts = mesh.vertices;
+        const stride = vc > 0 ? Math.floor(verts.length / vc) : 0;
+        if (stride < 3) continue;
+
+        const joints =
+            boneCount <= 255 ? new Uint8Array(vc * 4) :
+            boneCount <= 65535 ? new Uint16Array(vc * 4) :
+            new Uint32Array(vc * 4);
+        const weights = new Float32Array(vc * 4);
+
+        for (let v = 0; v < vc; v++) {
+            const px = verts[v * stride], py = verts[v * stride + 1], pz = verts[v * stride + 2];
+            let best = 0;
+            let bestD = Infinity;
+            for (let b = 0; b < boneCount; b++) {
+                const ax = segA[b * 3], ay = segA[b * 3 + 1], az = segA[b * 3 + 2];
+                const abx = segB[b * 3] - ax, aby = segB[b * 3 + 1] - ay, abz = segB[b * 3 + 2] - az;
+                const len2 = abx * abx + aby * aby + abz * abz;
+                let t = len2 > 1e-12 ? ((px - ax) * abx + (py - ay) * aby + (pz - az) * abz) / len2 : 0;
+                if (t < 0) t = 0; else if (t > 1) t = 1;
+                const dx = px - (ax + t * abx);
+                const dy = py - (ay + t * aby);
+                const dz = pz - (az + t * abz);
+                const d2 = dx * dx + dy * dy + dz * dz;
+                if (d2 < bestD) { bestD = d2; best = b; }
+            }
+            joints[v * 4] = best;
+            weights[v * 4] = 1;
+        }
+        mesh.joints = joints;
+        mesh.weights = weights;
+        bound++;
+    }
+    return bound;
+}

package/libraries/models/src/index.ts

@@ -54,6 +54,7 @@ export type { ModelLoaderOptions } from "./loader";
 
 // Model normalization — import-time correction (up-axis, units, node transforms, bounds)
 export { bakeNodeTransforms } from "./bake-node-transforms";
+export { bindUnskinnedMeshes } from "./bind-unskinned-meshes";
 export { normalizeModel, normalizeModelWithResolution, resolveImportSettings, resolveImportSettingsSync } from "./normalize";
 export type { ResolveOptions } from "./sidecar/resolver";
 export { synthesizeSkeletonSkin } from "./skeleton-synthesis";

package/libraries/models/src/types.ts

@@ -18,6 +18,28 @@ export interface MeshData {
   morphTargetNames?: string[];
   /** KHR_materials_variants: per-primitive variant → material mappings. */
   variantMappings?: { variant: number; material: number }[];
+  /** Inward vertex offset along the bind-space normal, in model units,
+   *  applied at upload (equivalent to a post-skinning normal push — the
+   *  skin matrix is linear). Used by modular-character kits to tuck
+   *  "under-layer" meshes (legs/hands) beneath outer layers so overlapping
+   *  garments don't clip or z-fight at seams. */
+  surfaceOffset?: number;
+  /** Per-vertex horizontal girth deformation applied at upload: each
+   *  vertex's position on `axes` scales about `centers` by
+   *  `1 + factor * weights[v]`. Weights are a body-region field derived
+   *  from skin weights (≈1 at pelvis/spine, ≈0 at head/hands/feet), so
+   *  skin and garment meshes deform identically — garments keep fitting
+   *  the widened body and seams stay watertight. */
+  surfaceGirth?: {
+    /** Scale delta at weight=1 (0.25 = +25% on the girth axes). */
+    factor: number;
+    /** Per-vertex region weight (0..1). */
+    weights: Float32Array;
+    /** The two scaled (horizontal) axes, as xyz indices. */
+    axes: readonly [number, number];
+    /** Pivot coordinate on each scaled axis (body-center line). */
+    centers: readonly [number, number];
+  };
 }
 
 export interface TextureTransform {

package/libraries/networking/src/discovery.ts

@@ -206,19 +206,19 @@ export class LanDiscovery {
     const existing = this.peers.get(pkt.id);
     const peer: LanPeer = { ...pkt, host: rinfo.address, lastSeenMs: this.opts.now() };
     this.peers.set(pkt.id, peer);
-    if (!existing) for (const f of this.listeners.join) f(peer);
+    if (!existing) for (const f of this.listeners.join.values()) f(peer);
     else if (existing.name !== peer.name || existing.port !== peer.port
         || JSON.stringify(existing.meta) !== JSON.stringify(peer.meta)) {
-      for (const f of this.listeners.update) f(peer);
+      for (const f of this.listeners.update.values()) f(peer);
     }
   }
 
   private expire() {
     const cutoff = this.opts.now() - this.opts.ttlMs;
-    for (const [id, p] of this.peers) {
+    for (const [id, p] of this.peers.entries()) {
       if (p.lastSeenMs < cutoff) {
         this.peers.delete(id);
-        for (const f of this.listeners.leave) f(p);
+        for (const f of this.listeners.leave.values()) f(p);
       }
     }
   }
@@ -292,7 +292,7 @@ export class MdnsBrowser {
   }
 
   private requery() {
-    for (const t of this.watched) this.sendQuery(t);
+    for (const t of this.watched.values()) this.sendQuery(t);
     this.expire();
   }
 
@@ -320,7 +320,7 @@ export class MdnsBrowser {
 
   private expire() {
     const now = this.opts.now();
-    for (const [k, s] of this.table) {
+    for (const [k, s] of this.table.entries()) {
       if (s.lastSeenMs + s.ttlMs < now) this.table.delete(k);
     }
   }
@@ -334,7 +334,7 @@ export class MdnsBrowser {
       .filter((r): r is Extract<typeof r, { data: unknown }> => "data" in r);
     const now = this.opts.now();
     // PTR gives instance names; SRV/TXT/A for the same instance fill detail.
-    for (const r of recs) {
+    for (const r of recs.values()) {
       if (r.type !== "PTR" || !this.watched.has(r.name)) continue;
       const instance = r.data as string;
       const key = `${instance}@${r.name}`;
@@ -350,7 +350,7 @@ export class MdnsBrowser {
       );
       const txtMap: Record<string, string> = {};
       if (txt) {
-        for (const item of (txt.data as Buffer[])) {
+        for (const item of (txt.data as Buffer[]).values()) {
           const s = item.toString("utf8");
           const eq = s.indexOf("=");
           txtMap[eq < 0 ? s : s.slice(0, eq)] = eq < 0 ? "" : s.slice(eq + 1);

package/libraries/persistence/src/autosave-manager.ts

@@ -82,7 +82,7 @@ export class AutosaveManager {
     try {
       await this.runSave();
     } catch (e) {
-      log.error("AutosaveManager", `Save failed: ${e}`);
+      log.error("autosave-manager", `Save failed: ${e}`);
     }
   }
 

package/libraries/persistence/src/binary-record-store.ts

@@ -72,7 +72,7 @@ export class BinaryRecordStore implements IBinaryRecordStore {
   private tag: string;
 
   constructor(private opts: BinaryRecordStoreOptions) {
-    this.tag = (opts.logTag ?? "BinaryRecordStore").replace(/^\[|\]$/g, "");
+    this.tag = (opts.logTag ?? "binary-record-store").replace(/^\[|\]$/g, "");
   }
 
   private nodeRoot: Promise<FileSystemDirectoryHandle | null> | null = null;

package/libraries/persistence/src/file-save-store.ts

@@ -12,7 +12,7 @@
 // Forward incompatibility: saves from a newer engine version are refused.
 // Consumers should implement version backups for unstable releases.
 
-import { safeJsonParse } from "@downdraft/engine";
+import { safeJsonParse } from "@downdraft/engine/safety/json";
 import {
     encodeHeader,
     engineVersionString,
@@ -205,7 +205,7 @@ export class FileSaveStore implements ISaveStore {
       if (opts?.blobs && Object.keys(opts.blobs).length > 0) {
         await fs.mkdir(tmpBlobsDir, { recursive: true });
         for (let _i = 0, _it = Object.entries(opts.blobs) as Array<[string, ArrayBuffer]>, _n = _it.length; _i < _n; _i++) { const [key, buf] = _it[_i];
-          const safeKey = key.replace(/[^a-zA-Z0-9_\-]/g, "_");
+          const safeKey = key.replace(/[^a-zA-Z0-9_-]/g, "_");
           await fs.writeFile(join(tmpBlobsDir, safeKey), new Uint8Array(buf));
           blobBytes += buf.byteLength;
         }
@@ -250,10 +250,10 @@ export class FileSaveStore implements ISaveStore {
         await fs.writeFile(this.propsPath(slot), JSON.stringify(opts.properties, null, 2));
       }
 
-      log.debug("FileSaveStore", `Saved slot '${slot}' (${fileBuf.length + blobBytes} bytes)`);
+      log.debug("file-save-store", `Saved slot '${slot}' (${fileBuf.length + blobBytes} bytes)`);
       return { success: true, bytes: fileBuf.length + blobBytes, gen: 1 };
     } catch (err) {
-      log.error("FileSaveStore", `Save failed for slot '${slot}': ${err}`);
+      log.error("file-save-store", `Save failed for slot '${slot}': ${err}`);
       return { success: false, bytes: 0 };
     }
   }
@@ -358,7 +358,7 @@ export class FileSaveStore implements ISaveStore {
         },
       };
 
-      log.info("FileSaveStore", `Loaded slot '${slot}'`);
+      log.info("file-save-store", `Loaded slot '${slot}'`);
       // Load blobs if requested
       let blobs: Record<string, ArrayBuffer> | undefined;
       if (includeBlobs) {
@@ -524,22 +524,22 @@ export class FileSaveStore implements ISaveStore {
 
   private slotPath(slot: string): string {
     // Sanitize slot name to prevent path traversal
-    const safe = slot.replace(/[^a-zA-Z0-9_\-]/g, "_");
+    const safe = slot.replace(/[^a-zA-Z0-9_-]/g, "_");
     return join(this.saveDir, safe + SAVE_EXT);
   }
 
   private blobsDirPath(slot: string): string {
-    const safe = slot.replace(/[^a-zA-Z0-9_\-]/g, "_");
+    const safe = slot.replace(/[^a-zA-Z0-9_-]/g, "_");
     return join(this.saveDir, safe + BLOBS_DIR_SUFFIX);
   }
 
   private thumbPath(slot: string): string {
-    const safe = slot.replace(/[^a-zA-Z0-9_\-]/g, "_");
+    const safe = slot.replace(/[^a-zA-Z0-9_-]/g, "_");
     return join(this.saveDir, safe + THUMB_EXT);
   }
 
   private propsPath(slot: string): string {
-    const safe = slot.replace(/[^a-zA-Z0-9_\-]/g, "_");
+    const safe = slot.replace(/[^a-zA-Z0-9_-]/g, "_");
     return join(this.saveDir, safe + PROPS_EXT);
   }
 

package/libraries/persistence/src/library.ts

@@ -52,7 +52,7 @@ export const PersistenceLib: EngineLibrary<PersistenceLibConfig> = {
       // it in onReady if needed. The store is safe to provide immediately;
       // save/load calls will throw until init() resolves.
       store.init().catch((err) => {
-        log.error("PersistenceLib", `OpfsSaveStore init failed: ${err}`);
+        log.error("persistence-lib", `OpfsSaveStore init failed: ${err}`);
       });
       ctx.provide(PersistenceTok, store);
       return store;

package/libraries/persistence/src/opfs-save-store.ts

@@ -262,7 +262,7 @@ export class OpfsSaveStore implements ISaveStore {
   // ── Path helpers ────────────────────────────────────────────────────────
 
   private sanitizeSlot(slot: string): string {
-    return slot.replace(/[^a-zA-Z0-9_\-]/g, "_");
+    return slot.replace(/[^a-zA-Z0-9_-]/g, "_");
   }
 
   private genDirName(gen: number): string {
@@ -371,7 +371,7 @@ export class OpfsSaveStore implements ISaveStore {
       if (opts?.blobs && Object.keys(opts.blobs).length > 0) {
         const blobsDir = await this.getBlobsDir(genDir, true);
         for (const [key, buf] of Object.entries(opts.blobs)) {
-          const safeKey = key.replace(/[^a-zA-Z0-9_\-]/g, "_");
+          const safeKey = key.replace(/[^a-zA-Z0-9_-]/g, "_");
           await this.writeBinaryFile(blobsDir, safeKey, new Uint8Array(buf));
           blobCount++;
         }
@@ -419,7 +419,7 @@ export class OpfsSaveStore implements ISaveStore {
       const totalBytes = compressed.length + hashBytes.length + (opts?.blobs ? Object.values(opts.blobs).reduce((s, b) => s + b.byteLength, 0) : 0);
       return { success: true, bytes: totalBytes, gen: currentGen };
     } catch (err) {
-      log.error("OpfsSaveStore", `Save failed for slot '${slot}': ${err}`);
+      log.error("opfs-save-store", `Save failed for slot '${slot}': ${err}`);
       return { success: false, bytes: 0 };
     }
   }
@@ -451,7 +451,7 @@ export class OpfsSaveStore implements ISaveStore {
         this.warn({ kind: "no_saves_found", slot, message: `No save slot '${slot}' found` });
         return { state: null };
       }
-      log.error("OpfsSaveStore", `Failed to access slot '${slot}': ${err}`);
+      log.error("opfs-save-store", `Failed to access slot '${slot}': ${err}`);
       return { state: null };
     }
     try {
@@ -487,7 +487,7 @@ export class OpfsSaveStore implements ISaveStore {
       this.warn({ kind: "no_saves_found", slot, message: `No valid save found for slot '${slot}'` });
       return { state: null };
     } catch (err) {
-      log.error("OpfsSaveStore", `Load failed for slot '${slot}': ${err}`);
+      log.error("opfs-save-store", `Load failed for slot '${slot}': ${err}`);
       return { state: null };
     }
   }
@@ -576,7 +576,7 @@ export class OpfsSaveStore implements ISaveStore {
 
       return { state, blobs };
     } catch (err) {
-      log.warn("OpfsSaveStore", `loadFromGen ${genMeta.gen} failed: ${err}`);
+      log.warn("opfs-save-store", `loadFromGen ${genMeta.gen} failed: ${err}`);
       return { state: null };
     }
   }
@@ -644,7 +644,7 @@ export class OpfsSaveStore implements ISaveStore {
       const saves = this.ensureInit();
       const safeSlot = this.sanitizeSlot(slot);
       await this.removeRecursive(saves, safeSlot);
-      log.info("OpfsSaveStore", `Deleted slot '${slot}'`);
+      log.info("opfs-save-store", `Deleted slot '${slot}'`);
       return true;
     } catch {
       return false;

package/libraries/persistence/src/save-worker.ts

@@ -8,21 +8,19 @@
 //
 // Uses the engine's RPC layer (expose/exposeEvents) for typed communication.
 
-import { expose } from "@downdraft/engine/worker/rpc";
-import { OpfsSaveStore, type OpfsSaveStoreOptions } from "./opfs-save-store";
 import type {
-  ISaveStore,
-  LoadOptions,
-  LoadResult,
-  SaveGenerationInfo,
-  SaveOptions,
-  SaveResult,
-  SaveSlotInfo,
-  SaveState,
-  SaveWarning,
+    ISaveStore,
+    LoadOptions,
+    LoadResult,
+    SaveGenerationInfo,
+    SaveOptions,
+    SaveResult,
+    SaveSlotInfo,
+    SaveState,
+    SaveWarning,
 } from "@downdraft/engine";
-
-(globalThis as any).__ddThreadTag = "S1";
+import { expose } from "@downdraft/engine/worker/rpc";
+import { OpfsSaveStore, type OpfsSaveStoreOptions } from "./opfs-save-store";
 
 let store: OpfsSaveStore | null = null;
 
@@ -96,4 +94,5 @@ expose(api);
 
 // Also export the type for the proxy side
 export type SaveWorkerApi = typeof api;
-export type { ISaveStore, SaveState, SaveOptions, LoadOptions, SaveResult, LoadResult, SaveSlotInfo, SaveGenerationInfo, SaveWarning };
+export type { ISaveStore, LoadOptions, LoadResult, SaveGenerationInfo, SaveOptions, SaveResult, SaveSlotInfo, SaveState, SaveWarning };
+

package/libraries/physics-rapier/src/ffi-lib.ts

@@ -25,6 +25,7 @@ import type {
     IslandInfo
 } from "@downdraft/engine";
 import { dlopen, ptr, resolveNativeLibrary, type CFunction } from "@downdraft/platform-native";
+import { findPackageRoot } from "@downdraft/engine/platform/pkg-root";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import type { PhysicsLib } from "./rapier-backend";
@@ -37,7 +38,7 @@ const _dirname =
 function findPhysicsLibrary(): string {
   return resolveNativeLibrary("downdraft_physics", {
     envVars: ["DOWNDRAFT_PHYSICS_LIB", "PHYSICS_NATIVE_PATH"],
-    crateDir: join(_dirname, "..", "..", "physics-native", "native"),
+    crateDir: join(findPackageRoot(_dirname), "libraries", "physics-native", "native"),
     buildHint: 'run "bun run build:native" from the repo root',
   });
 }

package/libraries/physics-rapier/src/realm-worker-script.ts

@@ -233,5 +233,5 @@ self.onmessage = async (e: MessageEvent) => {
   }
 };
 
-export { };
+
 

package/libraries/postfx/src/post-process-stack.ts

@@ -659,7 +659,7 @@ export class PostProcessStack {
     try {
       pipeline = this.makePipeline(effect.wgsl, this.ccLayout, HDR_FORMAT);
     } catch (e) {
-      log.error("PostProcessStack", `Failed to compile custom effect "${effect.id}": ${e}`);
+      log.error("post-process-stack", `Failed to compile custom effect "${effect.id}": ${e}`);
       throw e;
     }
     this.customEffects.set(effect.id, { effect, pipeline, uniform, uniformValues: null, enabled: false });

package/libraries/sand/src/sand-step-pool.ts

@@ -216,6 +216,11 @@ export class SandStepPool {
       const worker = this.workerUrl
         ? new Worker(this.workerUrl, { type: "module" })
         : new Worker(new URL("./sand-step-worker.ts", import.meta.url), { type: "module" });
+      // Nested workers are process-scoped, not parent-scoped — a sim worker
+      // force-terminated before pool.shutdown() would orphan these and pin
+      // process exit. unref keeps a leaked pool worker from holding the
+      // runtime open.
+      (worker as any).unref?.();
       this.workers.push(worker);
       const strip = this.strips[i];
       initPromises.push(new Promise<void>((resolve, reject) => {

package/libraries/water/src/water-renderer.ts

@@ -660,7 +660,7 @@ export class WaterRenderer {
     });
 
     this.initialized = true;
-    log.info("WaterRenderer", "Initialized flat-shaded low-poly water");
+    log.info("water-renderer", "Initialized flat-shaded low-poly water");
   }
 
   setLightBindGroup(bg: GPUBindGroup): void {

package/libraries/weatherfx/src/cloud-system.ts

@@ -167,7 +167,7 @@ export class CloudSystem {
       });
     });
 
-    log.info("CloudSystem", `Initialized with ${this.layers.length} layers`);
+    log.info("cloud-system", `Initialized with ${this.layers.length} layers`);
   }
 
   update(
@@ -242,11 +242,11 @@ export class CloudSystem {
         if (v > maxD) maxD = v;
         if (v < field.isoLevel) solidCount++;
       }
-      log.warn("CloudSystem", `Empty mesh for layer=${layer.layerType} iso=${field.isoLevel} densityRange=[${minD.toFixed(3)}, ${maxD.toFixed(3)}] solidVoxels=${solidCount}/${field.data.length} (${(solidCount/field.data.length*100).toFixed(1)}%)`);
+      log.warn("cloud-system", `Empty mesh for layer=${layer.layerType} iso=${field.isoLevel} densityRange=[${minD.toFixed(3)}, ${maxD.toFixed(3)}] solidVoxels=${solidCount}/${field.data.length} (${(solidCount/field.data.length*100).toFixed(1)}%)`);
       return;
     }
 
-    log.info("CloudSystem", `Generated layer ${layer.layerType}: ${extracted.verts.length / 9} verts, ${extracted.indices.length} indices`);
+    log.info("cloud-system", `Generated layer ${layer.layerType}: ${extracted.verts.length / 9} verts, ${extracted.indices.length} indices`);
 
     // Vertices are in world space relative to field origin (centered at 0,0,0)
     const verts = extracted.verts;

package/mcp/README.md

@@ -0,0 +1,20 @@
+# `@downdraft/engine/mcp`
+
+Model Context Protocol automation server for Downdraft — exposes engine state, entities, assets, and screenshots as MCP tools for AI-driven testing and inspection.
+
+## Install
+
+```sh
+bun add @downdraft/engine/mcp
+```
+
+## Key exports
+
+- `EngineContext`
+- `MCPServer`
+- `UndoRedoManager`
+- `errorResult`
+- `jsonResult`
+- `textResult`
+
+See the [Downdraft engine repository](https://github.com/knackstedt/downdraft) for architecture docs and examples.