@downdraft/engine 0.1.1 → 0.1.2-alpha.5

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/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,
@@ -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) {

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

@@ -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/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.

package/mcp/src/client.ts

@@ -48,9 +48,17 @@ export function mcpPortDir(): string {
 
 export interface GameInstance {
     pid: number;
-    port: number;
+    /** Automation endpoint port (host tools + game harness), from the
+     *  `<pid>` file. Absent when the instance only advertises an editor
+     *  endpoint. */
+    port?: number;
     /** Bearer token from `<pid>.token`, when the instance wrote one. */
     token?: string;
+    /** Editor toolset endpoint port (`createMcpModule({ transport: "http" })`),
+     *  from the `<pid>.editor` sibling file. */
+    editorPort?: number;
+    /** Bearer token from `<pid>.editor.token`, when present. */
+    editorToken?: string;
     /** PID-file mtime — newest instance wins when no selector is given. */
     mtimeMs: number;
     /** The instance's appId when it can be recovered (Linux /proc only). */
@@ -98,11 +106,40 @@ export function listGameInstances(sel: InstanceSelector = {}): GameInstance[] {
         return [];
     }
     const out: GameInstance[] = [];
+    // Group files by PID: "<pid>" is the automation endpoint, "<pid>.editor"
+    // the editor toolset endpoint (createMcpModule http transport). Token
+    // siblings "<pid>.token" / "<pid>.editor.token" don't match the regex.
+    const byPid = new Map<number, { automation?: string; editor?: string }>();
     for (let _i = 0, _it = entries, _n = _it.length; _i < _n; _i++) { const name = _it[_i];
-        if (!/^\d+$/.test(name)) continue;
-        const pid = Number(name);
+        const m = /^(\d+)(\.editor)?$/.exec(name);
+        if (!m) continue;
+        const rec = byPid.get(Number(m[1])) ?? {};
+        if (m[2]) rec.editor = name; else rec.automation = name;
+        byPid.set(Number(m[1]), rec);
+    }
+    const readPort = (file?: string): number | undefined => {
+        if (!file) return undefined;
+        try {
+            const raw = readFileSync(join(mcpPortDir(), file), "utf8").trim();
+            return /^\d+$/.test(raw) ? Number(raw) : undefined;
+        } catch {
+            return undefined;
+        }
+    };
+    const readToken = (file?: string): string | undefined => {
+        if (!file) return undefined;
+        try {
+            return readFileSync(join(mcpPortDir(), `${file}.token`), "utf8").trim() || undefined;
+        } catch { /* no token file — auth not required */ }
+        return undefined;
+    };
+    for (const [pid, files] of byPid.entries()) {
         if (!isAlive(pid)) {
-            try { unlinkSync(join(mcpPortDir(), name)); } catch { /* gone */ }
+            [files.automation, files.editor].forEach((f) => {
+                if (!f) return;
+                try { unlinkSync(join(mcpPortDir(), f)); } catch { /* gone */ }
+                try { unlinkSync(join(mcpPortDir(), `${f}.token`)); } catch { /* gone */ }
+            });
             continue;
         }
         if (sel.pid !== undefined && pid !== sel.pid) continue;
@@ -110,23 +147,23 @@ export function listGameInstances(sel: InstanceSelector = {}): GameInstance[] {
         if (sel.appId !== undefined && appId !== undefined && appId !== sel.appId) continue;
         if (sel.appId !== undefined && appId === undefined && process.platform === "linux") continue;
 
-        let port: number;
-        try {
-            const raw = readFileSync(join(mcpPortDir(), name), "utf8").trim();
-            if (!/^\d+$/.test(raw)) continue;
-            port = Number(raw);
-        } catch {
-            continue;
-        }
-        let token: string | undefined;
-        try {
-            token = readFileSync(join(mcpPortDir(), `${name}.token`), "utf8").trim() || undefined;
-        } catch { /* no token file — auth not required */ }
+        const port = readPort(files.automation);
+        const editorPort = readPort(files.editor);
+        if (port === undefined && editorPort === undefined) continue;
         let mtimeMs = 0;
-        try {
-            mtimeMs = statSync(join(mcpPortDir(), name)).mtimeMs;
-        } catch { /* treat as oldest */ }
-        out.push({ pid, port, token, mtimeMs, appId });
+        [files.automation, files.editor].forEach((f) => {
+            if (!f) return;
+            try { mtimeMs = Math.max(mtimeMs, statSync(join(mcpPortDir(), f)).mtimeMs); } catch { /* treat as oldest */ }
+        });
+        out.push({
+            pid,
+            port,
+            editorPort,
+            token: readToken(files.automation),
+            editorToken: readToken(files.editor),
+            mtimeMs,
+            appId,
+        });
     }
     out.sort((a, b) => b.mtimeMs - a.mtimeMs);
     return out;
@@ -151,6 +188,12 @@ export interface GameClientOptions {
     url?: string;
     /** Bearer token; auto-read from <pid>.token on discovery. */
     token?: string;
+    /** Which of the instance's endpoints to connect to: "automation"
+     *  (default — `<pid>` file: host tools + game harness) or "editor"
+     *  (`<pid>.editor` file: createMcpModule http transport's full editor
+     *  toolset). DOWNDRAFT_MCP_ENDPOINT=editor works too. Ignored when
+     *  `url` is given. */
+    endpoint?: "automation" | "editor";
     /** Per-request timeout in ms (default 120s). */
     timeoutMs?: number;
 }
@@ -206,6 +249,7 @@ export class GameClient {
         let pid = opts.pid ?? (Number.isFinite(envPid) && envPid > 0 ? envPid : undefined);
         let url = opts.url ?? process.env.DOWNDRAFT_MCP_URL ?? process.env.MCP_HTTP_URL;
         let token = opts.token ?? process.env.DOWNDRAFT_MCP_TOKEN ?? process.env.MCP_TOKEN;
+        const endpoint = opts.endpoint ?? (process.env.DOWNDRAFT_MCP_ENDPOINT === "editor" ? "editor" : "automation");
         if (!url) {
             const inst = discoverGameInstance({ appId, pid });
             if (!inst) {
@@ -219,8 +263,17 @@ export class GameClient {
                     `Start a game first (e.g. \`draft dev\`), or pass url / set DOWNDRAFT_MCP_URL.`,
                 );
             }
-            url = `http://localhost:${inst.port}/mcp`;
-            token ??= inst.token;
+            const instPort = endpoint === "editor" ? inst.editorPort : inst.port;
+            if (instPort === undefined) {
+                throw new McpClientError(
+                    `Instance ${inst.pid} has no ${endpoint} MCP endpoint in ${mcpPortDir()}` +
+                    (endpoint === "editor"
+                        ? ` — register createMcpModule({ transport: "http" }) in the game, or drop the editor endpoint selection.`
+                        : "."),
+                );
+            }
+            url = `http://localhost:${instPort}/mcp`;
+            token ??= endpoint === "editor" ? (inst.editorToken ?? inst.token) : inst.token;
             pid = inst.pid;
         }
         const client = new GameClient(url, token, pid, opts.timeoutMs ?? DEFAULT_TIMEOUT_MS);

package/mcp/src/undo-redo.ts

@@ -35,7 +35,7 @@ export class UndoRedoManager {
       this.redoStack.push(action);
       return true;
     } catch (e) {
-      log.error("UndoRedo", `Undo failed: ${e}`);
+      log.error("undo-redo", `Undo failed: ${e}`);
       this.undoStack.push(action);
       return false;
     }
@@ -49,7 +49,7 @@ export class UndoRedoManager {
       this.undoStack.push(action);
       return true;
     } catch (e) {
-      log.error("UndoRedo", `Redo failed: ${e}`);
+      log.error("undo-redo", `Redo failed: ${e}`);
       this.redoStack.push(action);
       return false;
     }