@downdraft/engine 0.3.0 → 0.3.1

package/dist/libraries/networking/src/ws-server.js

@@ -0,0 +1,387 @@
+// ============================================================================
+// ws-server.ts — minimal tri-runtime WebSocket server for host-authoritative
+// LAN/WAN sessions. The networking library ships client transports
+// (WebSocketTransport, WebRTCTransport) but had no listener — this fills the
+// host side so a game instance can accept direct connections without any
+// external service.
+//
+// Runtime selection is capability-based (see platform/runtime.ts):
+//   Bun  → Bun.serve({ fetch, websocket })
+//   Deno → Deno.serve + Deno.upgradeWebSocket
+//   Node → node:http + a hand-rolled RFC6455 handshake/framer (pure JS,
+//          no native deps — also the fallback for any runtime with node:http)
+//
+// Semantics intentionally mirror the browser WebSocket surface: text frames
+// arrive as `string`, binary frames as `Uint8Array`. Ping/pong/close and
+// fragmented-frame reassembly are handled internally. Message cap matches
+// WebSocketTransport's 16 MiB.
+// ============================================================================
+import { createLogger } from "@downdraft/engine/util/logger";
+const log = createLogger();
+const WS_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+const MAX_MESSAGE_SIZE = 16 * 1024 * 1024;
+function makeServerBase(handlers) {
+    const conns = new Set();
+    let nextId = 1;
+    const deliver = (conn, data) => {
+        const size = typeof data === "string" ? data.length : data.byteLength;
+        if (size > MAX_MESSAGE_SIZE) {
+            conn.close(1009, "message too large");
+            return;
+        }
+        try {
+            handlers.onMessage?.(conn, data);
+        }
+        catch (e) {
+            log.error("WsServer", `onMessage threw: ${e}`);
+        }
+    };
+    const drop = (conn, code, reason) => {
+        if (!conns.delete(conn))
+            return;
+        try {
+            handlers.onClose?.(conn, code, reason);
+        }
+        catch (e) {
+            log.error("WsServer", `onClose threw: ${e}`);
+        }
+    };
+    return { conns, nextId: () => nextId++, deliver, drop };
+}
+// ---------------------------------------------------------------------------
+// Bun — Bun.serve with the `websocket` handler map
+// ---------------------------------------------------------------------------
+function startBunServer(opts) {
+    const Bun = globalThis.Bun;
+    const base = makeServerBase(opts);
+    const server = Bun.serve({
+        port: opts.port,
+        hostname: opts.host ?? "0.0.0.0",
+        fetch(req, srv) {
+            const ip = srv.requestIP(req);
+            const conn = {
+                id: base.nextId(),
+                remoteAddress: `${ip?.address ?? "?"}:${ip?.port ?? "?"}`,
+                raw: null,
+                send(data) { if (this.raw)
+                    this.raw.send(data instanceof ArrayBuffer ? new Uint8Array(data) : data); },
+                close(code = 1000, reason = "") { if (this.raw)
+                    this.raw.close(code, reason); },
+            };
+            return srv.upgrade(req, { data: { conn } }) ? undefined : new Response("WebSocket upgrade required", { status: 426 });
+        },
+        websocket: {
+            open(ws) {
+                const conn = ws.data.conn;
+                conn.raw = ws;
+                base.conns.add(conn);
+                try {
+                    opts.onConnection?.(conn);
+                }
+                catch (e) {
+                    log.error("WsServer", `onConnection threw: ${e}`);
+                }
+            },
+            message(ws, msg) {
+                const conn = ws.data.conn;
+                base.deliver(conn, typeof msg === "string" ? msg : new Uint8Array(msg));
+            },
+            close(ws, code, reason) {
+                base.drop(ws.data.conn, code, reason);
+            },
+        },
+    });
+    return Promise.resolve({
+        port: server.port,
+        host: opts.host ?? "0.0.0.0",
+        connections: () => [...base.conns],
+        async close() {
+            [...base.conns].forEach((c) => c.close(1001, "server shutdown"));
+            await server.stop(true);
+        },
+    });
+}
+// ---------------------------------------------------------------------------
+// Deno — Deno.serve + Deno.upgradeWebSocket
+// ---------------------------------------------------------------------------
+function startDenoServer(opts) {
+    const Deno = globalThis.Deno;
+    const base = makeServerBase(opts);
+    const server = Deno.serve({ port: opts.port, hostname: opts.host ?? "0.0.0.0" }, (req, info) => {
+        if (req.headers.get("upgrade")?.toLowerCase() !== "websocket") {
+            return new Response("WebSocket upgrade required", { status: 426 });
+        }
+        const { socket, response } = Deno.upgradeWebSocket(req);
+        const conn = {
+            id: base.nextId(),
+            remoteAddress: info?.remoteAddr ? `${info.remoteAddr.hostname}:${info.remoteAddr.port}` : "?",
+            raw: socket,
+            send(data) { try {
+                socket.send(data);
+            }
+            catch { /* closing */ } },
+            close(code = 1000, reason = "") { try {
+                socket.close(code, reason);
+            }
+            catch { /* already closed */ } },
+        };
+        socket.binaryType = "arraybuffer";
+        socket.onopen = () => {
+            base.conns.add(conn);
+            try {
+                opts.onConnection?.(conn);
+            }
+            catch (e) {
+                log.error("WsServer", `onConnection threw: ${e}`);
+            }
+        };
+        socket.onmessage = (e) => {
+            base.deliver(conn, typeof e.data === "string" ? e.data : new Uint8Array(e.data));
+        };
+        socket.onclose = (e) => base.drop(conn, e.code, e.reason);
+        socket.onerror = () => base.drop(conn, 1006, "socket error");
+        return response;
+    });
+    const bound = server.addr;
+    return Promise.resolve({
+        port: bound.port,
+        host: bound.hostname,
+        connections: () => [...base.conns],
+        async close() {
+            [...base.conns].forEach((c) => c.close(1001, "server shutdown"));
+            await server.shutdown();
+        },
+    });
+}
+// ---------------------------------------------------------------------------
+// Node (and generic fallback) — node:http + hand-rolled RFC6455
+// ---------------------------------------------------------------------------
+/** Encode one server→client frame. Server frames are never masked. */
+function encodeWsFrame(opcode, payload) {
+    const len = payload.byteLength;
+    let header;
+    if (len < 126) {
+        header = new Uint8Array(2);
+        header[1] = len;
+    }
+    else if (len <= 0xffff) {
+        header = new Uint8Array(4);
+        header[1] = 126;
+        header[2] = len >>> 8;
+        header[3] = len & 0xff;
+    }
+    else {
+        header = new Uint8Array(10);
+        header[1] = 127;
+        const dv = new DataView(header.buffer);
+        dv.setUint32(2, Math.floor(len / 0x100000000));
+        dv.setUint32(6, len >>> 0);
+    }
+    header[0] = 0x80 | (opcode & 0x0f);
+    const out = new Uint8Array(header.length + len);
+    out.set(header, 0);
+    out.set(payload, header.length);
+    return out;
+}
+const OP_CONT = 0x0, OP_TEXT = 0x1, OP_BIN = 0x2, OP_CLOSE = 0x8, OP_PING = 0x9, OP_PONG = 0xa;
+async function startNodeServer(opts) {
+    const http = await import("node:http");
+    const crypto = await import("node:crypto");
+    const base = makeServerBase(opts);
+    const httpServer = http.createServer((_req, res) => {
+        res.writeHead(426, { "Content-Type": "text/plain" });
+        res.end("WebSocket upgrade required");
+    });
+    httpServer.on("upgrade", (req, socket) => {
+        socket.setNoDelay(true);
+        const key = req.headers["sec-websocket-key"];
+        const upgrade = req.headers.upgrade?.toLowerCase();
+        if (upgrade !== "websocket" || typeof key !== "string") {
+            socket.write("HTTP/1.1 400 Bad Request\r\n\r\n");
+            socket.destroy();
+            return;
+        }
+        const accept = crypto.createHash("sha1").update(key + WS_GUID).digest("base64");
+        socket.write("HTTP/1.1 101 Switching Protocols\r\n" +
+            "Upgrade: websocket\r\n" +
+            "Connection: Upgrade\r\n" +
+            `Sec-WebSocket-Accept: ${accept}\r\n\r\n`);
+        let closed = false;
+        const conn = {
+            id: base.nextId(),
+            remoteAddress: `${socket.remoteAddress ?? "?"}:${socket.remotePort ?? "?"}`,
+            raw: socket,
+            send(data) {
+                if (closed || socket.destroyed)
+                    return;
+                if (typeof data === "string") {
+                    socket.write(Buffer.from(encodeWsFrame(OP_TEXT, Buffer.from(data, "utf8"))));
+                }
+                else {
+                    const bytes = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
+                    socket.write(Buffer.from(encodeWsFrame(OP_BIN, bytes)));
+                }
+            },
+            close(code = 1000, reason = "") {
+                if (closed)
+                    return;
+                closed = true;
+                const payload = new Uint8Array(2 + reason.length);
+                payload[0] = code >>> 8;
+                payload[1] = code & 0xff;
+                payload.set(new TextEncoder().encode(reason), 2);
+                try {
+                    socket.write(Buffer.from(encodeWsFrame(OP_CLOSE, payload)));
+                    socket.end();
+                }
+                catch { /* socket already gone */ }
+            },
+        };
+        // ── Incremental frame parser ──
+        let buf = Buffer.alloc(0);
+        let fragOp = -1;
+        const frags = [];
+        const finishMessage = (op, payload) => {
+            if (payload.byteLength > MAX_MESSAGE_SIZE) {
+                conn.close(1009, "message too large");
+                return;
+            }
+            if (op === OP_TEXT)
+                base.deliver(conn, payload.toString("utf8"));
+            else
+                base.deliver(conn, new Uint8Array(payload.buffer, payload.byteOffset, payload.byteLength));
+        };
+        const handleFrame = (fin, op, payload) => {
+            if (op === OP_CLOSE) {
+                const code = payload.byteLength >= 2 ? payload.readUInt16BE(0) : 1000;
+                const reason = payload.byteLength > 2 ? payload.subarray(2).toString("utf8") : "";
+                conn.close(code, reason);
+                base.drop(conn, code, reason);
+                return;
+            }
+            if (op === OP_PING) {
+                if (!closed && !socket.destroyed)
+                    socket.write(Buffer.from(encodeWsFrame(OP_PONG, payload)));
+                return;
+            }
+            if (op === OP_PONG)
+                return;
+            if (op === OP_CONT && fragOp < 0) {
+                conn.close(1002, "unexpected continuation");
+                return;
+            }
+            if ((op === OP_TEXT || op === OP_BIN) && fragOp >= 0) {
+                conn.close(1002, "interleaved frame");
+                return;
+            }
+            if (op !== OP_CONT)
+                fragOp = op;
+            frags.push(payload);
+            if (!fin)
+                return;
+            const full = Buffer.concat(frags);
+            frags.length = 0;
+            const finalOp = fragOp;
+            fragOp = -1;
+            finishMessage(finalOp, full);
+        };
+        socket.on("data", (chunk) => {
+            buf = buf.byteLength ? Buffer.concat([buf, chunk]) : chunk;
+            // Parse as many complete frames as the buffer holds.
+            for (;;) {
+                if (buf.byteLength < 2)
+                    return;
+                const b0 = buf[0], b1 = buf[1];
+                const fin = (b0 & 0x80) !== 0;
+                const op = b0 & 0x0f;
+                const masked = (b1 & 0x80) !== 0;
+                let len = b1 & 0x7f;
+                let off = 2;
+                if (len === 126) {
+                    if (buf.byteLength < off + 2)
+                        return;
+                    len = buf.readUInt16BE(off);
+                    off += 2;
+                }
+                else if (len === 127) {
+                    if (buf.byteLength < off + 8)
+                        return;
+                    const hi = buf.readUInt32BE(off), lo = buf.readUInt32BE(off + 4);
+                    off += 8;
+                    if (hi > 0 || lo > MAX_MESSAGE_SIZE) {
+                        conn.close(1009, "message too large");
+                        return;
+                    }
+                    len = lo;
+                }
+                const maskLen = masked ? 4 : 0;
+                if (buf.byteLength < off + maskLen + len)
+                    return;
+                let payload = buf.subarray(off + maskLen, off + maskLen + len);
+                if (masked) {
+                    const mask = buf.subarray(off, off + 4);
+                    const unmasked = Buffer.allocUnsafe(payload.byteLength);
+                    for (let i = 0; i < payload.byteLength; i++)
+                        unmasked[i] = payload[i] ^ mask[i & 3];
+                    payload = unmasked;
+                }
+                else {
+                    payload = Buffer.from(payload); // detach — subarray aliases buf
+                }
+                buf = buf.subarray(off + maskLen + len);
+                handleFrame(fin, op, payload);
+                if (closed)
+                    return;
+            }
+        });
+        const onSocketEnd = () => base.drop(conn, 1006, "socket closed");
+        socket.on("close", onSocketEnd);
+        socket.on("error", onSocketEnd);
+        base.conns.add(conn);
+        try {
+            opts.onConnection?.(conn);
+        }
+        catch (e) {
+            log.error("WsServer", `onConnection threw: ${e}`);
+        }
+    });
+    await new Promise((resolve, reject) => {
+        httpServer.once("error", reject);
+        httpServer.listen(opts.port, opts.host ?? "0.0.0.0", () => {
+            httpServer.removeListener("error", reject);
+            resolve();
+        });
+    });
+    const addr = httpServer.address();
+    const boundPort = typeof addr === "object" && addr ? addr.port : opts.port;
+    return {
+        port: boundPort,
+        host: opts.host ?? "0.0.0.0",
+        connections: () => [...base.conns],
+        async close() {
+            [...base.conns].forEach((c) => c.close(1001, "server shutdown"));
+            await new Promise((resolve) => httpServer.close(() => resolve()));
+            // httpServer.close waits for open sockets; force-destroy stragglers.
+            [...base.conns].forEach((c) => c.raw.destroy());
+            base.conns.clear();
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// Entry point
+// ---------------------------------------------------------------------------
+/**
+ * Start a WebSocket server. Resolves once the socket is bound and listening.
+ * Runtime is picked by capability: Bun.serve → Deno.serve → node:http.
+ */
+export function createWebSocketServer(opts) {
+    const g = globalThis;
+    const bun = g.Bun;
+    if (typeof bun?.serve === "function")
+        return startBunServer(opts);
+    const deno = g.Deno;
+    if (typeof deno?.serve === "function" && typeof deno.upgradeWebSocket === "function") {
+        return startDenoServer(opts);
+    }
+    return startNodeServer(opts);
+}

package/dist/libraries/physics-rapier/src/api.js

@@ -235,6 +235,21 @@ export class UniversalPhysicsAPI {
     setIntegrationDt(realmId, dt) {
         this.backend.setIntegrationDt(realmId, dt);
     }
+    /**
+     * Change gravity across all realms (applies to near/mid/far). Best-effort:
+     * backends that can't mutate realm gravity omit `setRealmGravity`, in which
+     * case callers should fall back to per-body `gravityScale` in BodyDesc.
+     */
+    setGravity(gravity) {
+        [RealmTier.Near, RealmTier.Mid, RealmTier.Far].forEach((tier) => {
+            try {
+                const realm = this.realmManager.getRealm(tier);
+                this.backend.setRealmGravity?.(realm.id, gravity);
+            }
+            catch { /* realm tier not initialized */ }
+        });
+        this.config.gravity = gravity;
+    }
     // --- Realm ---
     getRealmTier(body) {
         return this.realmManager.getRealmForBody(body);

package/dist/libraries/physics-rapier/src/backend.js

@@ -442,6 +442,21 @@ export class RapierPhysicsBackend {
             this.lib.setIntegrationDt(realmId, dt);
         }
     }
+    /**
+     * Change a live realm's gravity. Updates the stored realm config (the
+     * no-lib JS fallback stepper reads it) and forwards to the lib when it
+     * supports runtime gravity (the WASM Rapier world.gravity is mutable; the
+     * native FFI lib may not implement it — callers should treat this as
+     * best-effort).
+     */
+    setRealmGravity(realmId, gravity) {
+        const realm = this.realms.get(realmId);
+        if (realm)
+            realm.config.gravity = gravity;
+        if (this.lib && this.lib.setRealmGravity) {
+            this.lib.setRealmGravity(realmId, gravity);
+        }
+    }
     setSleepThresholds(realmId, linearThreshold, angularThreshold) {
         if (this.lib) {
             this.lib.setSleepThresholds(realmId, linearThreshold, angularThreshold);

package/dist/libraries/physics-rapier/src/rapier-backend.js

@@ -154,6 +154,11 @@ async function doLoadPhysicsLib() {
                 entityByBodyHandle.delete(id);
                 bodyIdByHandle.delete(id);
             },
+            setRealmGravity(id, gravity) {
+                const world = realms.get(id);
+                if (world)
+                    world.gravity = { x: gravity[0], y: gravity[1], z: gravity[2] };
+            },
             createBody(realmId, bodyId, desc, entity) {
                 const world = realms.get(realmId);
                 if (!world)

package/dist/libraries/postfx/src/post-process-stack.js

@@ -443,9 +443,7 @@ export class PostProcessStack {
     createGlyphAtlas() {
         const chars = " .:-=+*#%@";
         const gw = 16, gh = 16, cols = chars.length;
-        const canvas = document.createElement("canvas");
-        canvas.width = cols * gw;
-        canvas.height = gh;
+        const canvas = new OffscreenCanvas(cols * gw, gh);
         const ctx = canvas.getContext("2d");
         ctx.fillStyle = "black";
         ctx.fillRect(0, 0, canvas.width, canvas.height);

package/dist/libraries/sand/src/materials.js

@@ -72,32 +72,18 @@ export var Material;
     // --- Ingredients ---
     // Ice (frozen water — produced by cooling)
     Material[Material["Ice"] = 64] = "Ice";
+    // (IDs 67–68, 71–73, 76–77, 79–81, 83–88 were inert alchemy materials —
+    // retired; keep the gaps so old saves don't remap onto new materials.)
     // Liquids
     Material[Material["Ether"] = 65] = "Ether";
     Material[Material["Blood"] = 66] = "Blood";
-    Material[Material["Syrup"] = 67] = "Syrup";
-    Material[Material["NightshadeExtract"] = 68] = "NightshadeExtract";
     Material[Material["TrollBlood"] = 69] = "TrollBlood";
     Material[Material["LiquidShadow"] = 70] = "LiquidShadow";
-    Material[Material["LoveEssence"] = 71] = "LoveEssence";
-    Material[Material["HateEssence"] = 72] = "HateEssence";
-    Material[Material["DreamMist"] = 73] = "DreamMist";
     Material[Material["VoidEssence"] = 74] = "VoidEssence";
     // Powders (solid, fall)
     Material[Material["Sulfur"] = 75] = "Sulfur";
-    Material[Material["GroundEyeOfNewt"] = 76] = "GroundEyeOfNewt";
-    Material[Material["GroundBatWing"] = 77] = "GroundBatWing";
     Material[Material["BoneDust"] = 78] = "BoneDust";
-    Material[Material["IronFilings"] = 79] = "IronFilings";
-    Material[Material["MoonstoneDust"] = 80] = "MoonstoneDust";
-    Material[Material["CrystalDust"] = 81] = "CrystalDust";
     Material[Material["MushroomSpores"] = 82] = "MushroomSpores";
-    Material[Material["DragonScale"] = 83] = "DragonScale";
-    Material[Material["PhoenixFeather"] = 84] = "PhoenixFeather";
-    Material[Material["UnicornHorn"] = 85] = "UnicornHorn";
-    Material[Material["MandrakeRoot"] = 86] = "MandrakeRoot";
-    Material[Material["SpiderSilk"] = 87] = "SpiderSilk";
-    Material[Material["GraveDust"] = 88] = "GraveDust";
     Material[Material["StarShard"] = 89] = "StarShard";
     Material[Material["TimeSand"] = 90] = "TimeSand";
     // Gases
@@ -232,29 +218,13 @@ export const MATERIALS = {
     // --- Liquids ---
     [Material.Ether]: def(65, "Ether", [0.55, 0.45, 0.85, 0.8], { gravity: 1.5, gravityDir: 1, density: 0.7, liquid: true, flammable: true, burnTime: 40, albedo: 0.2, reflectivity: 0.4, brightness: 1.1 }),
     [Material.Blood]: def(66, "Blood", [0.7, 0.05, 0.05, 0.95], { gravity: 2, gravityDir: 1, density: 1.06, liquid: true, albedo: 0.3, reflectivity: 0.2, brightness: 0.8 }),
-    [Material.Syrup]: def(67, "Syrup", [0.6, 0.4, 0.15, 0.95], { gravity: 1, gravityDir: 1, density: 1.4, liquid: true, albedo: 0.3, reflectivity: 0.3, brightness: 0.9 }),
-    [Material.NightshadeExtract]: def(68, "Nightshade Extract", [0.3, 0.05, 0.35, 0.95], { gravity: 2, gravityDir: 1, density: 1.1, liquid: true, albedo: 0.2, reflectivity: 0.1, brightness: 0.7 }),
     [Material.TrollBlood]: def(69, "Troll Blood", [0.4, 0.2, 0.15, 0.95], { gravity: 2, gravityDir: 1, density: 1.2, liquid: true, albedo: 0.25, reflectivity: 0.15, brightness: 0.8 }),
     [Material.LiquidShadow]: def(70, "Liquid Shadow", [0.05, 0.05, 0.12, 0.98], { gravity: 3, gravityDir: 1, density: 2.0, liquid: true, albedo: 0.0, reflectivity: 0.0, brightness: 0.3 }),
-    [Material.LoveEssence]: def(71, "Love Essence", [0.95, 0.4, 0.6, 0.9], { gravity: 1.5, gravityDir: 1, density: 0.9, liquid: true, albedo: 0.3, reflectivity: 0.4, brightness: 1.0 }),
-    [Material.HateEssence]: def(72, "Hate Essence", [0.2, 0.1, 0.15, 0.9], { gravity: 2, gravityDir: 1, density: 1.3, liquid: true, albedo: 0.2, reflectivity: 0.2, brightness: 0.7 }),
-    [Material.DreamMist]: def(73, "Dream Mist", [0.6, 0.7, 0.95, 0.6], { gravity: 1, gravityDir: -1, density: 0.3, liquid: true, albedo: 0.2, reflectivity: 0.5, brightness: 1.2 }),
     [Material.VoidEssence]: def(74, "Void Essence", [0.1, 0.0, 0.2, 0.95], { gravity: 4, gravityDir: 1, density: 3.0, liquid: true, albedo: 0.0, reflectivity: 0.1, brightness: 0.5 }),
     // --- Alchemy game: powders (solid, fall) ---
     [Material.Sulfur]: def(75, "Sulfur", [0.9, 0.85, 0.2, 1.0], { gravity: 1, gravityDir: 1, density: 2.0, solid: true, flammable: true, burnTime: 60, albedo: 0.5, reflectivity: 0.1, brightness: 0.9 }),
-    [Material.GroundEyeOfNewt]: def(76, "Ground Eye of Newt", [0.5, 0.35, 0.2, 1.0], { gravity: 1, gravityDir: 1, density: 1.2, solid: true, albedo: 0.4, brightness: 0.8 }),
-    [Material.GroundBatWing]: def(77, "Ground Bat Wing", [0.3, 0.25, 0.35, 1.0], { gravity: 0.8, gravityDir: 1, density: 0.6, solid: true, albedo: 0.3, brightness: 0.7 }),
     [Material.BoneDust]: def(78, "Bone Dust", [0.85, 0.82, 0.75, 1.0], { gravity: 1, gravityDir: 1, density: 1.5, solid: true, albedo: 0.5, brightness: 0.8 }),
-    [Material.IronFilings]: def(79, "Iron Filings", [0.55, 0.55, 0.6, 1.0], { gravity: 1.5, gravityDir: 1, density: 7.8, solid: true, magnetic: true, albedo: 0.5, reflectivity: 0.3 }),
-    [Material.MoonstoneDust]: def(80, "Moonstone Dust", [0.8, 0.85, 0.95, 1.0], { gravity: 1, gravityDir: 1, density: 1.0, solid: true, albedo: 0.4, reflectivity: 0.5, brightness: 1.3 }),
-    [Material.CrystalDust]: def(81, "Crystal Dust", [0.6, 0.9, 0.95, 1.0], { gravity: 1, gravityDir: 1, density: 2.5, solid: true, albedo: 0.3, reflectivity: 0.6, brightness: 1.2 }),
     [Material.MushroomSpores]: def(82, "Mushroom Spores", [0.6, 0.5, 0.4, 0.9], { gravity: 0.5, gravityDir: 1, density: 0.4, solid: true, albedo: 0.3, brightness: 0.8 }),
-    [Material.DragonScale]: def(83, "Dragon Scale", [0.5, 0.15, 0.1, 1.0], { gravity: 1.5, gravityDir: 1, density: 5.0, solid: true, albedo: 0.4, reflectivity: 0.3, brightness: 1.0 }),
-    [Material.PhoenixFeather]: def(84, "Phoenix Feather", [0.95, 0.5, 0.15, 0.9], { gravity: 0.3, gravityDir: 1, density: 0.3, solid: true, flammable: true, burnTime: 200, albedo: 0.4, brightness: 1.4 }),
-    [Material.UnicornHorn]: def(85, "Unicorn Horn", [0.95, 0.9, 1.0, 1.0], { gravity: 1, gravityDir: 1, density: 1.8, solid: true, albedo: 0.5, reflectivity: 0.5, brightness: 1.5 }),
-    [Material.MandrakeRoot]: def(86, "Mandrake Root", [0.5, 0.4, 0.25, 1.0], { gravity: 1, gravityDir: 1, density: 1.3, solid: true, albedo: 0.4, brightness: 0.7 }),
-    [Material.SpiderSilk]: def(87, "Spider Silk", [0.9, 0.9, 0.85, 0.8], { gravity: 0.2, gravityDir: 1, density: 0.2, solid: true, albedo: 0.4, reflectivity: 0.2, brightness: 0.9 }),
-    [Material.GraveDust]: def(88, "Grave Dust", [0.3, 0.28, 0.25, 1.0], { gravity: 1, gravityDir: 1, density: 1.8, solid: true, albedo: 0.3, brightness: 0.6 }),
     [Material.StarShard]: def(89, "Star Shard", [0.7, 0.8, 1.0, 1.0], { gravity: 1, gravityDir: 1, density: 2.0, solid: true, albedo: 0.3, reflectivity: 0.7, brightness: 1.6 }),
     [Material.TimeSand]: def(90, "Time Sand", [0.4, 0.3, 0.6, 0.9], { gravity: 1, gravityDir: 1, density: 1.5, solid: true, albedo: 0.3, reflectivity: 0.4, brightness: 1.2 }),
     // --- Alchemy game: gases + byproducts ---

package/dist/libraries/sand/src/sand-world.js

@@ -2207,9 +2207,6 @@ export class SandWorld {
                     continue;
                 }
             }
-            // --- PhoenixFeather near fire/lava: glows brighter, resists burning ---
-            // (flammable but long burnTime already set; here we just let it shimmer)
-            // --- DragonScale: very dense, sinks through liquids (handled by density) ---
             // --- LiquidShadow + light source (fire/plasma) → dissipates to smoke ---
             if (mat === Material.LiquidShadow) {
                 let lightNi = -1;

package/dist/modules/devtools/src/api.js

@@ -3,16 +3,15 @@
 // engine systems, regardless of which thread they run on.
 //
 // Realm detection determines transport:
-//   - Main realm: panels/feeds/commands registered directly on
+//   - Main realm: feeds/commands registered directly on
 //     window.__sceneInspector via DevToolsDataBridge.
-//   - Worker realm: panels/feeds/commands registered in a worker-side
-//     registry. Data feeds are written to a devtools SAB region (zero-copy,
-//     synchronous reads). Commands are forwarded via worker RPC. Panel
-//     declarations are synced to the renderer via a one-time manifest RPC.
+//   - Worker realm: feeds/commands registered in a worker-side registry.
+//     Data feeds are written to a devtools SAB region (zero-copy,
+//     synchronous reads). Commands are forwarded via worker RPC.
 //
 // Plugins import `devtools` from @downdraft/engine/modules/devtools and call
-// registerPanel/registerDataFeed/registerCommand/registerSABStat — the same
-// API works in both realms.
+// registerDataFeed/registerCommand/registerSABStat — the same API works in
+// both realms.
 // ============================================================================
 import { resourceToken } from "@downdraft/engine/ecs/resource";
 import { createLogger } from "@downdraft/engine/util/logger";
@@ -50,7 +49,7 @@ export const DEVTOOLS_REALM = detectRealm();
 // synchronously. No RPC polling needed.
 //
 // Layout:
-//   [0..3]   manifestVersion: Uint32  (bumped when panels/feeds change)
+//   [0..3]   manifestVersion: Uint32  (bumped when feeds/commands change)
 //   [4..7]   feedCount: Uint32
 //   [8..]    feed entries: each is [lengthBytes: Uint32][JSON bytes...]
 //            (lengthBytes = 0 means "not yet written" / "unavailable")
@@ -81,8 +80,6 @@ export function allocateDevToolsSAB(maxFeedBlobBytes, statsBytes) {
 }
 class DevToolsAPIImpl {
     realm;
-    panels = new Map();
-    toggles = new Map();
     dataFeeds = new Map();
     dataFeedNames = []; // ordered list for feedIndex assignment
     commands = new Map();
@@ -99,14 +96,6 @@ class DevToolsAPIImpl {
     constructor(realm) {
         this.realm = realm;
     }
-    registerPanel(ext) {
-        this.panels.set(ext.id, ext);
-        this.bumpManifest();
-    }
-    registerOverlayToggle(toggle) {
-        this.toggles.set(toggle.id, toggle);
-        this.bumpManifest();
-    }
     registerDataFeed(name, fn, writeRateHz = 10) {
         if (this.dataFeeds.has(name)) {
             // Update fn/rate, keep feedIndex and hasWritten
@@ -183,8 +172,6 @@ class DevToolsAPIImpl {
     }
     getManifest() {
         return {
-            panels: Array.from(this.panels.values()),
-            toggles: Array.from(this.toggles.values()),
             dataFeeds: this.dataFeedNames.map((name, i) => ({
                 name,
                 feedIndex: i,
@@ -276,8 +263,6 @@ class DevToolsAPIImpl {
         return Array.from(this.sabStats.keys());
     }
     clear() {
-        this.panels.clear();
-        this.toggles.clear();
         this.dataFeeds.clear();
         this.dataFeedNames = [];
         this.commands.clear();
@@ -301,7 +286,7 @@ const _devtools = new DevToolsAPIImpl(DEVTOOLS_REALM);
  * the appropriate transport for data feeds (direct call vs SAB) and
  * commands (direct call vs RPC forwarding).
  *
- * Plugins import this and call registerPanel/registerDataFeed/registerCommand.
+ * Plugins import this and call registerDataFeed/registerCommand.
  * The same code works in both realms.
  */
 export const devtools = _devtools;

package/dist/modules/devtools/src/data-bridge.js

@@ -28,14 +28,6 @@ export class DevToolsDataBridge {
     getPerformanceMetricsProvider() {
         return null;
     }
-    /** Games override this to declare custom DevTools panel tabs. */
-    getPanelExtensions() {
-        return [];
-    }
-    /** Games override this to declare custom overlay toggles. */
-    getOverlayToggles() {
-        return [];
-    }
     /** Games override this to expose sim stats + controls (pause/step/speed/clear). */
     getSimStatsProvider() {
         return null;
@@ -208,9 +200,6 @@ export class DevToolsDataBridge {
             getGPUAdapterInfo: () => {
                 return this.cachedGpuAdapterInfo;
             },
-            // --- Panel extensions (game-specific tabs and overlay toggles) ---
-            getPanelExtensions: () => this.getPanelExtensions(),
-            getOverlayToggles: () => this.getOverlayToggles(),
             // --- Sim stats & controls (optional — games implement ISimStatsProvider) ---
             getSimStats: () => this.getSimStatsProvider()?.getSimStats() ?? null,
             pauseSim: () => { this.getSimStatsProvider()?.pauseSim(); },

package/dist/modules/devtools/src/index.js

@@ -8,17 +8,13 @@ export { SkeletonRenderer } from "./skeleton-renderer.js";
 export { useDebugStore } from "./debug-store.js";
 export { useSceneStore } from "./scene-store.js";
 // Debug overlays (generic rendering, game provides data via interfaces)
-export { DebugOverlay } from "./debug-overlay.js";
 export { DebugRaycast } from "./debug-raycast.js";
-export { LabelOverlay } from "./label-overlay.js";
 export { SceneSync } from "./scene-sync.js";
 // Asset utilities
 export { asyncFetchArrayBuffer, bufferCache, evictThumbnailCache, findBinForGLTF, findMTLForOBJ, syncFetchArrayBuffer, thumbnailCache } from "./asset-utils.js";
 // Data bridge (non-abstract, data-feeds only) & base inspector & interfaces
 export { DevToolsDataBridge } from "./data-bridge.js";
-export { createDoctorPanelExtension } from "./doctor-panel.js";
 export { BaseSceneInspector } from "./scene-inspector.js";
-export { createSimStatsPanelExtension } from "./sim-stats-panel.js";
 // Unified DevTools API — single registration surface for plugins, games, and
 // engine systems. Auto-detects realm (main vs worker) and chooses transport.
 export { allocateDevToolsSAB, computeDevToolsSABLayout, devtools, DEVTOOLS_REALM, DEVTOOLS_SAB_MAX_FEEDS } from "./api.js";
@@ -39,8 +35,6 @@ export { ProfilingBridge } from "./profiling-bridge.js";
 export { wireProfilingBridge } from "./profiling-hooks.js";
 // Debug view descriptors — declarative registration of profiler overlay views
 export { BUILTIN_VIEW_DESCRIPTORS } from "./debug-view-descriptors.js";
-// Material stats panel — reusable DevTools tab for the material system
-export { createMaterialStatsPanelExtension } from "./material-stats-panel.js";
 // Blitz devtools — docked in-window DevTools UI (F12)
 export { BlitzDevtoolsHost, createSelfHostedDevtoolsUi } from "./blitz/host.js";
 export { BlitzDevtoolsTok, createDevtoolsUiModule } from "./blitz/module.js";