@downdraft/engine 0.1.0 → 0.1.2-alpha.5

package/dist/libraries/devtools/src/snapshot.js

@@ -0,0 +1,35 @@
+// ============================================================================
+// snapshot.ts — transport-neutral devtools data model.
+//
+// Provider panels return a `PanelSnapshot` — a status plus sections of
+// key/value rows, tables, f32 series, text lines, and interactive controls.
+// Both frontends render the same model: WebDevtoolsMirror sends it as JSON
+// over the devtools WebSocket; the Blitz devtools renders it into an
+// html-ui document. Commands flow back the other way when the user
+// activates a control.
+// ============================================================================
+export const SNAP_STATUS = { ok: 0, loading: 1, unsupported: 2, error: 3 };
+/** Row/line flag bits — header rows, warn/error styling. */
+export const SNAP_FLAG = { header: 1, warn: 2, error: 4 };
+// ── Panel slot ids ──
+// Stable ids shared by every frontend (tab labels, provider registry,
+// command routing). New engine panels append at the end; game panels use
+// the "game" slot (or numeric slots ≥ 16 for bespoke panels).
+export const PANEL = {
+    console: 0,
+    scene: 1,
+    gpu: 2,
+    "perf-recorder": 3,
+    "perf-metrics": 4,
+    "dom-tree": 5,
+    sim: 6,
+    memory: 7,
+    "render-graph": 8,
+    materials: 9,
+    doctor: 10,
+    workers: 11,
+    input: 12,
+    postfx: 13,
+    assets: 14,
+    game: 15,
+};

package/dist/libraries/devtools/src/verify.js

@@ -0,0 +1,139 @@
+// ============================================================================
+// verify.ts — Screenshot + pixel-verification + notify-send helpers.
+//
+// Used by the debugger to capture screenshots of the composited frame
+// (which includes the debug overlay) and verify panels render correctly
+// by sampling specific pixels.
+// ============================================================================
+import { createLogger } from "@downdraft/engine/util/logger";
+import { existsSync } from "node:fs";
+const log = createLogger("info");
+// ── notify-send (Linux desktop notification) ──
+/** Send a Linux desktop notification via notify-send. */
+export function notify(title, body) {
+    try {
+        const { execSync } = require("node:child_process");
+        execSync(`notify-send -a "Devin" -i dialog-information "${title.replace(/"/g, "'")}" "${body.replace(/"/g, "'")}"`, {
+            stdio: "ignore",
+            timeout: 5000,
+        });
+    }
+    catch {
+        // ignore — notify-send may not be available in all environments
+    }
+}
+/**
+ * Read a PNG file and return its pixel data. Uses node:zlib to inflate IDAT.
+ * Supports 8-bit RGBA (color type 6) and 8-bit RGB (color type 2) PNGs.
+ */
+export function readPng(path) {
+    if (!existsSync(path))
+        return null;
+    const { readFileSync } = require("node:fs");
+    const { inflateSync } = require("node:zlib");
+    const buf = readFileSync(path);
+    // Verify PNG signature
+    const sig = [137, 80, 78, 71, 13, 10, 26, 10];
+    for (let i = 0; i < 8; i++) {
+        if (buf[i] !== sig[i])
+            return null;
+    }
+    let offset = 8;
+    let width = 0, height = 0, bitDepth = 0, colorType = 0;
+    let idatData = [];
+    while (offset < buf.length) {
+        const length = buf.readUInt32BE(offset);
+        const type = buf.toString("ascii", offset + 4, offset + 8);
+        const dataStart = offset + 8;
+        if (type === "IHDR") {
+            width = buf.readUInt32BE(dataStart);
+            height = buf.readUInt32BE(dataStart + 4);
+            bitDepth = buf[dataStart + 8];
+            colorType = buf[dataStart + 9];
+        }
+        else if (type === "IDAT") {
+            idatData.push(buf.subarray(dataStart, dataStart + length));
+        }
+        else if (type === "IEND") {
+            break;
+        }
+        offset = dataStart + length + 4; // skip data + CRC
+    }
+    if (idatData.length === 0)
+        return null;
+    const compressed = Buffer.concat(idatData);
+    const raw = inflateSync(compressed);
+    // Determine bytes per pixel
+    const bpp = colorType === 6 ? 4 : colorType === 2 ? 3 : 4;
+    const stride = width * bpp;
+    const rgba = new Uint8Array(width * height * 4);
+    let srcIdx = 0;
+    for (let y = 0; y < height; y++) {
+        const filter = raw[srcIdx++]; // filter byte (0 = none)
+        for (let x = 0; x < stride; x++) {
+            // For simplicity, only handle filter 0 (none). Most screenshots use it.
+            if (filter !== 0) {
+                // Defilter: Paeth for filter 4, etc. For now, copy raw (works for filter 0).
+            }
+            const byte = raw[srcIdx + x];
+            const px = Math.floor(x / bpp);
+            const channel = x % bpp;
+            const dstIdx = (y * width + px) * 4 + channel;
+            if (channel < 3)
+                rgba[dstIdx] = byte;
+            else if (bpp === 4)
+                rgba[dstIdx] = byte;
+            else
+                rgba[dstIdx] = 255; // opaque for RGB
+        }
+        srcIdx += stride;
+    }
+    return { width, height, rgba };
+}
+/**
+ * Verify a pixel in a PNG file matches the expected RGBA within tolerance.
+ * Returns true if the pixel matches.
+ */
+export function verifyPixel(pngPath, x, y, expected, tolerance = 15) {
+    const png = readPng(pngPath);
+    if (!png) {
+        log.error("verify", `Could not read PNG: ${pngPath}`);
+        return false;
+    }
+    if (x < 0 || x >= png.width || y < 0 || y >= png.height) {
+        log.error("verify", `Pixel (${x},${y}) out of bounds (${png.width}x${png.height})`);
+        return false;
+    }
+    const idx = (y * png.width + x) * 4;
+    const actual = [png.rgba[idx], png.rgba[idx + 1], png.rgba[idx + 2], png.rgba[idx + 3]];
+    for (let i = 0; i < expected.length; i++) {
+        if (Math.abs(actual[i] - expected[i]) > tolerance) {
+            log.error("verify", `Pixel (${x},${y}) channel ${i}: expected ${expected[i]}, got ${actual[i]} (tolerance ${tolerance})`);
+            return false;
+        }
+    }
+    log.info("verify", `Pixel (${x},${y}) OK: rgba(${actual.join(",")})`);
+    return true;
+}
+/**
+ * Run multiple pixel checks against a PNG. Returns the number of failures.
+ */
+export function verifyPixels(pngPath, checks) {
+    let failures = 0;
+    checks.forEach((check) => {
+        if (!verifyPixel(pngPath, check.x, check.y, check.expected, check.tolerance)) {
+            failures++;
+        }
+    });
+    return failures;
+}
+// ── Checkpoint (notify + screenshot path) ──
+/**
+ * Emit a checkpoint: notify the user + log. The caller is responsible for
+ * capturing the screenshot (the host's captureScreenshot method) and committing.
+ */
+export function checkpoint(name, screenshotPath) {
+    const body = screenshotPath ? `${name} — screenshot: ${screenshotPath}` : name;
+    notify("Devin Checkpoint", body);
+    log.info("checkpoint", body);
+}

package/dist/libraries/devtools/src/web/browser.js

@@ -0,0 +1,94 @@
+// ============================================================================
+// browser.ts — launches the devtools UI in a desktop browser.
+//
+// Priority: chromium-family with --app mode (chromeless window) first, then
+// anything else we can find. Falls back to the OS default opener.
+// ============================================================================
+import { createLogger } from "@downdraft/engine/util/logger";
+import { spawn } from "node:child_process";
+const log = createLogger("info");
+const CANDIDATES = [
+    { names: ["chromium", "chromium-browser"], appMode: true },
+    { names: ["brave-browser", "brave"], appMode: true },
+    { names: ["vivaldi", "vivaldi-stable"], appMode: true },
+    { names: ["firefox"], appMode: false },
+    { names: ["google-chrome", "google-chrome-stable"], appMode: true },
+    { names: ["microsoft-edge", "msedge"], appMode: true },
+];
+function which(bin) {
+    const dirs = (process.env.PATH ?? "").split(":");
+    for (let i = 0; i < dirs.length; i++) {
+        const p = `${dirs[i]}/${bin}`;
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const { accessSync, constants } = require("node:fs");
+            accessSync(p, constants.X_OK);
+            return p;
+        }
+        catch { /* next dir */ }
+    }
+    return null;
+}
+let resolved;
+function resolveBrowser() {
+    if (resolved !== undefined)
+        return resolved;
+    const override = process.env.DOWNDRAFT_DEVTOOLS_BROWSER;
+    if (override) {
+        resolved = { bin: which(override) ?? override, appMode: override.includes("chrom") };
+        return resolved;
+    }
+    for (let i = 0; i < CANDIDATES.length; i++) {
+        const c = CANDIDATES[i];
+        for (let j = 0; j < c.names.length; j++) {
+            const bin = which(c.names[j]);
+            if (bin) {
+                resolved = { bin, appMode: c.appMode };
+                return resolved;
+            }
+        }
+    }
+    resolved = null;
+    return null;
+}
+/**
+ * Open `url` in the best available browser. Returns true if a process was
+ * spawned; false when no browser was found (caller should log the URL).
+ */
+export function openDevToolsUrl(url) {
+    const b = resolveBrowser();
+    if (b) {
+        const args = b.appMode
+            ? [`--app=${url}`, "--disable-session-crashed-bubble", "--no-first-run"]
+            : [url];
+        try {
+            const child = spawn(b.bin, args, {
+                detached: true, stdio: "ignore",
+                env: { ...process.env },
+            });
+            child.unref();
+            child.on("error", (err) => {
+                log.warn("devtools-browser", `failed to launch ${b.bin}: ${err}`);
+            });
+            log.info("devtools-browser", `opened ${b.bin}`);
+            return true;
+        }
+        catch (err) {
+            log.warn("devtools-browser", `spawn failed for ${b.bin}: ${err}`);
+        }
+    }
+    // OS default opener fallback.
+    const openers = ["xdg-open", "open"];
+    for (let i = 0; i < openers.length; i++) {
+        const bin = which(openers[i]);
+        if (!bin)
+            continue;
+        try {
+            const child = spawn(bin, [url], { detached: true, stdio: "ignore" });
+            child.unref();
+            return true;
+        }
+        catch { /* try next */ }
+    }
+    return false;
+}

package/dist/libraries/devtools/src/web/host.js

@@ -0,0 +1,183 @@
+// ============================================================================
+// web/host.ts — WebDevtoolsHost: the web-based devtools backend.
+//
+// The browser-hosted devtools frontend. It runs a loopback devtools
+// server (Bun.serve: HTTP static + WS JSON-RPC) and opens the browser-based
+// devtools UI when toggled (F12).
+//
+// Public surface: `visible`, `toggle/show/hide`, `update()`,
+// `devtoolsMirror`, `debuggerScene`, `registerThreadEval`,
+// `setPerfRecording`, input handlers (all no-ops: a separate browser window
+// receives input, nothing in-game). The in-window counterpart is the
+// docked Blitz devtools host.
+// ============================================================================
+import { createLogger } from "@downdraft/engine/util/logger";
+import { CdpBridge } from "../cdp-bridge.js";
+import { openDevToolsUrl } from "./browser.js";
+import { WebDevtoolsMirror } from "./mirror.js";
+import { DevToolsServer } from "./server.js";
+const log = createLogger("info");
+export class WebDevtoolsHost {
+    opts;
+    cdp;
+    server;
+    mirror;
+    sceneShim;
+    _ready = false;
+    disposed = false;
+    browserOpened = false;
+    constructor(opts) {
+        this.opts = opts;
+        this.cdp = new CdpBridge();
+        // The server's RPC dispatcher closes over `this.mirror` — assigned just
+        // below, before any client can connect.
+        this.server = new DevToolsServer({
+            webRoot: opts.webRoot,
+            extraRoutes: opts.extraRoutes,
+            call: (method, params) => this.mirror.dispatch(method, params),
+        });
+        this.mirror = new WebDevtoolsMirror({
+            server: this.server,
+            cdp: this.cdp,
+            renderer: opts.renderer,
+            gameScene: opts.gameScene,
+            profilingSAB: opts.profilingSAB ?? null,
+        });
+        this.sceneShim = new WebDebuggerSceneShim(this);
+    }
+    /** Whether the devtools UI is "visible" — i.e. a browser client is attached. */
+    get visible() { return this.server.clientCount > 0; }
+    get ready() { return this._ready; }
+    get cdpBridge() { return this.cdp; }
+    get devtoolsMirror() { return this.mirror; }
+    get debuggerScene() { return this.sceneShim; }
+    get app() { return null; }
+    /** The URL a browser would connect to (for tests / manual open). */
+    get url() { return this.server.url; }
+    /** Start the loopback server + mirror + CDP session. */
+    async start() {
+        if (this._ready || this.disposed)
+            return;
+        try {
+            await this.server.start();
+        }
+        catch (err) {
+            log.warn("web-devtools-host", `devtools server failed to start: ${err}`);
+            // Still bring up mirror/cdp so the RPC surface exists for embedded
+            // callers (e.g. tests); the browser UI just won't be reachable.
+        }
+        this.mirror.start();
+        this.mirror.attachLoggerBridge();
+        this.cdp.start();
+        this._ready = true;
+        log.info("web-devtools-host", `Web devtools ready (F12 opens ${this.server.url})`);
+    }
+    /** F12: open (or refocus) the devtools browser window. */
+    toggle() {
+        if (!this._ready)
+            return;
+        if (this.visible) {
+            // Already open — ask the frontend to close its window (it can only
+            // succeed if the window was script-opened, which --app mode satisfies
+            // on some browsers; worst case the user closes it normally).
+            this.server.emit("devtools.close", {});
+            log.info("web-devtools-host", "Devtools close requested");
+            return;
+        }
+        this.open();
+    }
+    /** Open the devtools browser window (idempotent while a client is up). */
+    open() {
+        if (!this._ready)
+            return;
+        if (this.visible) {
+            this.server.emit("devtools.focus", {});
+            return;
+        }
+        const url = this.server.url;
+        if (!url.includes(":0")) {
+            if (openDevToolsUrl(url)) {
+                this.browserOpened = true;
+                this.mirror.resetFirstUpdate();
+            }
+            else {
+                log.warn("web-devtools-host", `No browser found — open manually: ${url}`);
+            }
+        }
+    }
+    show() { this.open(); }
+    hide() { this.server.emit("devtools.close", {}); }
+    /** Per-frame pump (call from the render loop). */
+    update(_externalEncoder) {
+        if (!this._ready || this.disposed)
+            return;
+        try {
+            this.mirror.update();
+        }
+        catch (err) {
+            log.error("web-devtools-host", `mirror update error: ${err}`);
+        }
+    }
+    registerThreadEval(threadName, evalFn) {
+        this.mirror.registerThreadEval(threadName, evalFn);
+    }
+    /** Track the frontend's active panel (reported via inspector calls; best-effort). */
+    activePanel = "";
+    setActivePanel(panel) { this.activePanel = panel; }
+    getActivePanel() { return this.activePanel; }
+    setPerfRecording(start) {
+        this.mirror.setPerfRecording(start);
+    }
+    // ── Input handlers: all no-ops (the devtools live in a separate window) ──
+    handlePointerDown(_x, _y, _button, _mods) { return false; }
+    handlePointerMove(_x, _y, _button, _mods) { return false; }
+    handlePointerUp(_x, _y, _button, _mods) { return false; }
+    handleWheel(_x, _y, _deltaY) { return false; }
+    handleTextInput(_text) { return false; }
+    handleKeyDown(_key, _keyCode) { return false; }
+    isTextInputActive() { return false; }
+    setModifiers(_alt, _ctrl, _shift) { }
+    resize(_w, _h) { }
+    getUiTextureView() { return null; }
+    blit(_encoder, _targetView) { }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        try {
+            this.mirror.dispose();
+        }
+        catch { /* ignore */ }
+        try {
+            this.cdp.dispose();
+        }
+        catch { /* ignore */ }
+        void this.server.stop().catch(() => { });
+        this._ready = false;
+        this.browserOpened = false;
+    }
+}
+/** `debuggerScene` compatibility shim for native-entry.ts call sites. */
+export class WebDebuggerSceneShim {
+    host;
+    constructor(host) { this.host = host; }
+    registerThreadEval(threadName, evalFn) {
+        this.host.registerThreadEval(threadName, evalFn);
+    }
+    setActivePanel(panel) { this.host.setActivePanel(panel); }
+    getActivePanel() { return this.host.getActivePanel(); }
+    setPerfRecording(start) { this.host.setPerfRecording(start); }
+    // Legacy DEBUGGER_TEST stubs (the web UI is tested via WS, not clicks).
+    handlePointerDown(_x, _y) { return false; }
+    handlePointerUp(_x, _y) { return false; }
+    handlePointerMove(_x, _y) { return false; }
+    handleWheel(_x, _y, _d) { return false; }
+    handleKeyDown(_k, _kc) { return false; }
+    handleTextInput(_t) { return false; }
+    isTextInputActive() { return false; }
+    getFocusedWidget() { return null; }
+    getConsoleReplInput() { return ""; }
+    getDockX() { return 0; }
+    get dockWidth() { return 0; }
+    getHits() { return { regions: [] }; }
+}

package/dist/libraries/devtools/src/web/mirror.js

@@ -0,0 +1,26 @@
+// ============================================================================
+// web/mirror.ts — WebDevtoolsMirror: the web transport for devtools data.
+//
+// Same provider/command surface as the Blitz devtools host — all the work
+// lives in the shared DevtoolsBackend; this subclass just wires the emit
+// sink to the DevToolsServer WebSocket and reports client presence.
+// ============================================================================
+import { DevtoolsBackend, slotName } from "../backend.js";
+export { slotName };
+export class WebDevtoolsMirror extends DevtoolsBackend {
+    constructor(opts) {
+        super({
+            emit: (event, data) => opts.server.emit(event, data),
+            hasClient: () => opts.server.clientCount > 0,
+            cdp: opts.cdp,
+            renderer: opts.renderer,
+            gameScene: opts.gameScene,
+            profilingSAB: opts.profilingSAB,
+        });
+        opts.server.setHello(() => ({
+            version: 1,
+            panels: this.providerSlots(),
+            inspector: this.inspectorMethodNames(),
+        }));
+    }
+}

package/dist/libraries/devtools/src/web/server.js

@@ -0,0 +1,187 @@
+// ============================================================================
+// server.ts — DevToolsServer: the web-devtools loopback endpoint.
+//
+// Development-only. Binds 127.0.0.1:0 (ephemeral), serves the devtools-web
+// frontend over HTTP and the JSON-RPC channel over WebSocket. A bearer token
+// is required on the WS upgrade; discovery is via ~/.downdraft/devtools/<pid>
+// (mirrors the MCP ~/.downdraft/port convention).
+//
+// Wire protocol (JSON, single WS connection):
+//   client → {id, method, params}
+//   server → {id, result} | {id, error: {message}}
+//   server → {event, data}            (unsolicited pushes: console, metrics…)
+//   server → {event:"hello", data:{version, panels, inspectorMethods}}
+// ============================================================================
+import { createLogger } from "@downdraft/engine/util/logger";
+import { findPackageRoot } from "@downdraft/engine/platform/pkg-root";
+import { randomBytes } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, extname, join, normalize } from "node:path";
+import { fileURLToPath } from "node:url";
+const log = createLogger("info");
+const MIME = {
+    ".html": "text/html; charset=utf-8",
+    ".js": "text/javascript; charset=utf-8",
+    ".mjs": "text/javascript; charset=utf-8",
+    ".css": "text/css; charset=utf-8",
+    ".json": "application/json",
+    ".svg": "image/svg+xml",
+    ".png": "image/png",
+    ".woff2": "font/woff2",
+};
+export class DevToolsServer {
+    port = 0;
+    token = randomBytes(16).toString("hex");
+    server = null;
+    sockets = new Set();
+    opts;
+    cleanupPid = null;
+    nextId = 1;
+    constructor(opts = {}) {
+        this.opts = opts;
+    }
+    /** The websocket-capable URL handed to the browser launcher. */
+    get url() {
+        return `http://127.0.0.1:${this.port}/?t=${this.token}`;
+    }
+    get clientCount() { return this.sockets.size; }
+    async start() {
+        if (this.server)
+            return;
+        const BunG = globalThis.Bun;
+        if (!BunG || typeof BunG.serve !== "function") {
+            throw new Error("DevToolsServer requires Bun.serve (Bun runtime)");
+        }
+        const webRoot = this.opts.webRoot ?? join(findPackageRoot(dirname(fileURLToPath(import.meta.url))), "..", "devtools-web");
+        const srv = BunG.serve({
+            hostname: "127.0.0.1",
+            port: 0,
+            fetch: (req, server) => {
+                const url = new URL(req.url);
+                // ── WS upgrade (token via query — browsers can't set headers on WS) ──
+                if (url.pathname === "/ws") {
+                    if (url.searchParams.get("t") !== this.token) {
+                        return new Response("unauthorized", { status: 401 });
+                    }
+                    if (server.upgrade(req, { data: {} }))
+                        return undefined;
+                    return new Response("upgrade failed", { status: 400 });
+                }
+                if (url.pathname === "/health") {
+                    return Response.json({ status: "ok", clients: this.sockets.size, port: this.port });
+                }
+                // ── Static: extra routes (generated) then webRoot files ──
+                const extra = this.opts.extraRoutes?.[url.pathname];
+                if (extra !== undefined) {
+                    return new Response(extra, { headers: { "content-type": "text/css; charset=utf-8" } });
+                }
+                let rel = url.pathname === "/" ? "/index.html" : url.pathname;
+                rel = normalize(rel);
+                if (rel.includes(".."))
+                    return new Response("no", { status: 403 });
+                const file = join(webRoot, rel);
+                if (!existsSync(file))
+                    return new Response("not found", { status: 404 });
+                const body = readFileSync(file);
+                return new Response(body, {
+                    headers: { "content-type": MIME[extname(file)] ?? "application/octet-stream" },
+                });
+            },
+            websocket: {
+                open: (ws) => {
+                    this.sockets.add(ws);
+                    this.opts.onClientsChanged?.(this.sockets.size);
+                    ws.send(JSON.stringify({ event: "hello", data: this.helloData() }));
+                },
+                message: async (ws, raw) => {
+                    let msg;
+                    try {
+                        msg = JSON.parse(String(raw));
+                    }
+                    catch {
+                        ws.send(JSON.stringify({ id: 0, error: { message: "parse error" } }));
+                        return;
+                    }
+                    if (!msg.method)
+                        return;
+                    const id = msg.id ?? this.nextId++;
+                    try {
+                        const result = await this.callRpc(msg.method, msg.params ?? {});
+                        ws.send(JSON.stringify({ id, result }));
+                    }
+                    catch (err) {
+                        ws.send(JSON.stringify({ id, error: { message: String(err) } }));
+                    }
+                },
+                close: (ws) => {
+                    this.sockets.delete(ws);
+                    this.opts.onClientsChanged?.(this.sockets.size);
+                },
+            },
+        });
+        this.server = srv;
+        this.port = srv.port;
+        this.writeDiscoveryFile();
+        log.info("dev-tools-server", `devtools at ${this.url}`);
+    }
+    helloData() {
+        const hello = this.opts.hello;
+        return hello?.() ?? { version: 1 };
+    }
+    /** Provide the "hello" payload producer (panel list, inspector methods). */
+    setHello(fn) {
+        this.opts.hello = fn;
+    }
+    async callRpc(method, params) {
+        if (method === "ping")
+            return "pong";
+        if (!this.opts.call)
+            throw new Error(`no dispatcher for ${method}`);
+        return this.opts.call(method, params);
+    }
+    /** Push an event to every connected client. */
+    emit(event, data) {
+        if (this.sockets.size === 0)
+            return;
+        const msg = JSON.stringify({ event, data });
+        this.sockets.forEach((ws) => {
+            try {
+                ws.send(msg);
+            }
+            catch { /* dropping client errors */ }
+        });
+    }
+    writeDiscoveryFile() {
+        const dir = join(homedir(), ".downdraft", "devtools");
+        try {
+            mkdirSync(dir, { recursive: true });
+            const file = join(dir, `${process.pid}.json`);
+            writeFileSync(file, JSON.stringify({
+                pid: process.pid, port: this.port, token: this.token,
+                url: this.url, startedAt: Date.now(),
+            }), { mode: 0o600 });
+            this.cleanupPid = () => { try {
+                unlinkSync(file);
+            }
+            catch { /* gone */ } };
+        }
+        catch (err) {
+            log.warn("dev-tools-server", `discovery file failed: ${err}`);
+        }
+    }
+    async stop() {
+        this.sockets.forEach((ws) => { try {
+            ws.close();
+        }
+        catch { /* ignore */ } });
+        this.sockets.clear();
+        try {
+            this.server?.stop();
+        }
+        catch { /* ignore */ }
+        this.server = null;
+        this.cleanupPid?.();
+        this.cleanupPid = null;
+    }
+}

package/dist/libraries/entities/src/index.js

@@ -0,0 +1,3 @@
+export { ModelRenderer } from "./model-renderer.js";
+// Engine library descriptor
+export { EntitiesLib, ModelRendererTok } from "./library.js";