@mavonengine/cli 0.0.0-stage → 0.0.2

package/dist/index.js

@@ -0,0 +1,2501 @@
+#!/usr/bin/env node
+import {
+  DEFAULT_DOCS_URL,
+  MCP_CONFIG_FILE,
+  version,
+  writeMcpConfig
+} from "./chunk-TNN4S5K4.js";
+
+// src/index.ts
+import process9 from "process";
+
+// src/commands/build.ts
+import { spawn as spawn3 } from "child_process";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { join as join3, resolve as resolve3 } from "path";
+import process4 from "process";
+import { parseArgs as parseArgs3 } from "util";
+
+// ../core/dist/Plugins/ProjectConfig.js
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { dirname, isAbsolute, join, relative, resolve } from "path";
+var CONFIG_FILE = "mavonengine.json";
+var TARGETS = ["client", "server", "both"];
+var PluginConfigError = class extends Error {
+};
+function configPath(root) {
+  return join(root, CONFIG_FILE);
+}
+function readConfig(root) {
+  const path = configPath(root);
+  if (!existsSync(path))
+    return { plugins: {} };
+  let config;
+  try {
+    config = JSON.parse(readFileSync(path, "utf8"));
+  } catch (err) {
+    throw new PluginConfigError(`${path} is not valid JSON: ${err.message}`);
+  }
+  if (!config || typeof config !== "object" || Array.isArray(config))
+    throw new PluginConfigError(`${path} must contain a JSON object`);
+  const result = config;
+  if (result.plugins === void 0)
+    result.plugins = {};
+  else if (!result.plugins || typeof result.plugins !== "object" || Array.isArray(result.plugins))
+    throw new PluginConfigError(`"plugins" in ${path} must be an object`);
+  return result;
+}
+function writeConfig(root, config) {
+  writeFileSync(configPath(root), `${JSON.stringify(config, null, 2)}
+`);
+}
+function updateConfig(root, change) {
+  const config = readConfig(root);
+  if (!change(config))
+    return false;
+  writeConfig(root, config);
+  return true;
+}
+function addPluginToConfig(root, pkg) {
+  return updateConfig(root, (config) => {
+    const existing = config.plugins[pkg];
+    if (existing && existing.enabled !== false)
+      return false;
+    config.plugins[pkg] = existing ? { ...existing, enabled: true } : { enabled: true };
+    return true;
+  });
+}
+function findPackageDir(root, pkg) {
+  for (let dir = resolve(root); ; dir = dirname(dir)) {
+    const candidate = join(dir, "node_modules", pkg);
+    if (existsSync(join(candidate, "package.json")))
+      return candidate;
+    if (dirname(dir) === dir)
+      return void 0;
+  }
+}
+function validateManifest(pkg, value) {
+  if (!value || typeof value !== "object")
+    throw new PluginConfigError(`${pkg}: "mavonengine" in package.json must be an object`);
+  const manifest = value;
+  if (!TARGETS.includes(manifest.target))
+    throw new PluginConfigError(`${pkg}: "mavonengine.target" must be one of ${TARGETS.join(", ")}`);
+  for (const side of ["client", "server"]) {
+    if (runsOn(manifest.target, side) && typeof manifest[side] !== "string")
+      throw new PluginConfigError(`${pkg}: "mavonengine.${side}" is required for target "${manifest.target}"`);
+  }
+  return manifest;
+}
+function readPluginManifest(root, pkg) {
+  const dir = findPackageDir(root, pkg);
+  if (!dir)
+    return void 0;
+  const packageJson = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+  if (packageJson.mavonengine === void 0)
+    return void 0;
+  return { package: pkg, version: packageJson.version, dir, manifest: validateManifest(pkg, packageJson.mavonengine) };
+}
+function runsOn(target, side) {
+  return target === "both" || target === side;
+}
+function resolveInside(base, path) {
+  const full = resolve(base, path);
+  const inside = relative(base, full);
+  return inside && !inside.startsWith("..") && !isAbsolute(inside) ? full : void 0;
+}
+function assetsDir(plugin) {
+  return resolve(plugin.dir, plugin.manifest.assets?.dir ?? "assets");
+}
+function enabledPlugins(root, side) {
+  const plugins = [];
+  const warnings = [];
+  for (const [pkg, entry] of Object.entries(readConfig(root).plugins)) {
+    if (entry?.enabled === false)
+      continue;
+    let installed;
+    try {
+      installed = readPluginManifest(root, pkg);
+    } catch (err) {
+      warnings.push(err.message);
+      continue;
+    }
+    if (!installed) {
+      warnings.push(`${pkg} is listed in ${CONFIG_FILE} but is not installed or is not a MavonEngine plugin`);
+      continue;
+    }
+    if (!runsOn(installed.manifest.target, side))
+      continue;
+    const entryPath = resolveInside(installed.dir, installed.manifest[side]);
+    if (!entryPath || !existsSync(entryPath)) {
+      warnings.push(`${pkg}: ${side} entry ${installed.manifest[side]} not found, is the plugin built?`);
+      continue;
+    }
+    plugins.push({
+      ...installed,
+      options: entry?.options ?? {},
+      prefabs: Array.isArray(entry?.prefabs) ? entry.prefabs : [],
+      entry: entryPath
+    });
+  }
+  return { plugins, warnings };
+}
+function shippedAssetPaths(manifest, usedPrefabs) {
+  const assets = manifest.assets;
+  const paths = [...assets?.shared ?? []];
+  for (const prefab of usedPrefabs)
+    paths.push(...assets?.prefabs?.[prefab] ?? []);
+  return [...new Set(paths)];
+}
+function releaseAssets(root) {
+  const { plugins, warnings } = enabledPlugins(root, "client");
+  const assets = [];
+  for (const plugin of plugins) {
+    const base = assetsDir(plugin);
+    for (const path of shippedAssetPaths(plugin.manifest, plugin.prefabs)) {
+      const from = resolveInside(base, path);
+      if (!from) {
+        warnings.push(`${plugin.package}: asset ${path} points outside its assets directory`);
+        continue;
+      }
+      if (!existsSync(from)) {
+        warnings.push(`${plugin.package}: asset ${path} not found`);
+        continue;
+      }
+      assets.push({ package: plugin.package, from, to: `plugins/${plugin.package}/${path}`, path });
+    }
+  }
+  return { assets, warnings };
+}
+
+// src/commands/dashboard.ts
+import process2 from "process";
+import { parseArgs } from "util";
+
+// src/browser.ts
+import { spawn } from "child_process";
+import process from "process";
+var AMPERSAND_RE = /&/g;
+function openCommand(url, platform = process.platform) {
+  if (platform === "darwin")
+    return ["open", [url]];
+  if (platform === "win32")
+    return ["cmd", ["/c", "start", '""', url.replace(AMPERSAND_RE, "^&")]];
+  return ["xdg-open", [url]];
+}
+function openBrowser(url) {
+  const [command, args] = openCommand(url);
+  try {
+    const child = spawn(command, args, { stdio: "ignore", detached: true, windowsHide: true });
+    child.on("error", () => {
+    });
+    child.unref();
+  } catch {
+  }
+}
+function canOpenBrowserHere(env = process.env) {
+  return !env.SSH_CONNECTION && !env.SSH_TTY;
+}
+async function servesPage(url, { timeoutMs = 3e3, fetch = globalThis.fetch } = {}) {
+  try {
+    const res = await fetch(url, { signal: AbortSignal.timeout(timeoutMs) });
+    await res.body?.cancel();
+    return res.ok && (res.headers.get("content-type") ?? "").includes("text/html");
+  } catch {
+    return false;
+  }
+}
+
+// src/dashboard/snapshot.ts
+var SUPPORTED_SCHEMA_VERSION = 1;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function num(value, fallback = 0) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function str(value, fallback = "") {
+  return typeof value === "string" ? value : fallback;
+}
+function numOrNull(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function strOrNull(value) {
+  return typeof value === "string" ? value : null;
+}
+function arr(value, map) {
+  return Array.isArray(value) ? value.filter(isRecord).map(map) : [];
+}
+function section(value) {
+  return isRecord(value) ? value : {};
+}
+function tickSample(t) {
+  return {
+    timestamp: num(t.timestamp),
+    ticks: num(t.ticks),
+    ticksPerSecond: num(t.ticksPerSecond),
+    avgMs: num(t.avgMs),
+    maxMs: num(t.maxMs),
+    commandsPerSecond: num(t.commandsPerSecond),
+    maxCommandsPerTick: num(t.maxCommandsPerTick)
+  };
+}
+function normalizeSnapshot(raw) {
+  const s = section(raw);
+  const world = section(s.world);
+  const cpu = section(s.cpu);
+  const bandwidth = section(s.bandwidth);
+  const tick = section(s.tick);
+  const memory = section(s.memory);
+  const physics = isRecord(s.physics) ? s.physics : null;
+  const latency = isRecord(s.latencySimulation) ? s.latencySimulation : null;
+  return {
+    schemaVersion: num(s.schemaVersion, SUPPORTED_SCHEMA_VERSION),
+    engineVersion: str(s.engineVersion, "unknown"),
+    serverTime: str(s.serverTime),
+    uptime: num(s.uptime),
+    sampleIntervalMs: num(s.sampleIntervalMs, 1e3) || 1e3,
+    tickRate: num(s.tickRate),
+    players: arr(s.players, (p) => {
+      const position = section(p.position);
+      const connection = isRecord(p.connection) ? p.connection : null;
+      const id = str(p.id, "?");
+      return {
+        id,
+        // Older servers don't send a name
+        displayName: str(p.displayName, id),
+        position: { x: num(position.x), y: num(position.y), z: num(position.z) },
+        lastProcessedSequenceId: num(p.lastProcessedSequenceId),
+        trackedEntities: num(p.trackedEntities),
+        connectedFor: num(p.connectedFor),
+        connection: connection ? {
+          address: strOrNull(connection.address),
+          rttMs: numOrNull(connection.rttMs),
+          bytesSent: num(connection.bytesSent),
+          bytesReceived: num(connection.bytesReceived)
+        } : null
+      };
+    }),
+    world: {
+      entities: num(world.entities)
+    },
+    physics: physics ? { bodies: num(physics.bodies), colliders: num(physics.colliders) } : null,
+    cpu: {
+      current: num(cpu.current),
+      avg1s: num(cpu.avg1s),
+      avg10s: num(cpu.avg10s),
+      avg60s: num(cpu.avg60s),
+      history: arr(cpu.history, (h) => ({ timestamp: num(h.timestamp), cpuPercentage: num(h.cpuPercentage) }))
+    },
+    bandwidth: {
+      sentPerSecond: num(bandwidth.sentPerSecond),
+      receivedPerSecond: num(bandwidth.receivedPerSecond),
+      history: arr(bandwidth.history, (b) => ({ timestamp: num(b.timestamp), sent: num(b.sent), received: num(b.received) }))
+    },
+    tick: {
+      budgetMs: num(tick.budgetMs),
+      latest: isRecord(tick.latest) ? tickSample(tick.latest) : null,
+      history: arr(tick.history, tickSample)
+    },
+    memory: {
+      rss: num(memory.rss),
+      heapUsed: num(memory.heapUsed),
+      heapTotal: num(memory.heapTotal),
+      external: num(memory.external)
+    },
+    latencySimulation: latency ? { fixedLatency: num(latency.fixedLatency), jitter: num(latency.jitter), packetLoss: num(latency.packetLoss) } : null
+  };
+}
+function normalizeLogs(raw) {
+  const r = section(raw);
+  const entries = arr(r.entries, (e) => ({
+    id: num(e.id),
+    timestamp: num(e.timestamp),
+    level: str(e.level, "info"),
+    message: str(e.message)
+  }));
+  return {
+    entries,
+    latestId: num(r.latestId, entries.at(-1)?.id ?? 0)
+  };
+}
+function normalizeRequests(raw) {
+  const r = section(raw);
+  const entries = arr(r.entries, (e) => ({
+    id: num(e.id),
+    timestamp: num(e.timestamp),
+    method: str(e.method, "?"),
+    path: str(e.path),
+    status: numOrNull(e.status),
+    durationMs: num(e.durationMs),
+    bytes: num(e.bytes),
+    address: strOrNull(e.address)
+  }));
+  return {
+    entries,
+    latestId: num(r.latestId, entries.at(-1)?.id ?? 0)
+  };
+}
+
+// src/dashboard/MetricsClient.ts
+var MAX_LOG_LINES = 1e3;
+var MAX_REQUEST_LINES = 1e3;
+var MetricsSourceError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+  }
+  status;
+};
+function httpSource({ url, token, timeoutMs = 3e3, fetch = globalThis.fetch }) {
+  const logsUrl = new URL("logs", url);
+  const requestsUrl = new URL("requests", url);
+  async function request(target) {
+    let res;
+    try {
+      res = await fetch(target, {
+        headers: token ? { Authorization: `Bearer ${token}` } : {},
+        signal: AbortSignal.timeout(timeoutMs)
+      });
+    } catch (err) {
+      throw new MetricsSourceError(`Can't reach ${url}: ${err.message}`, "unreachable");
+    }
+    if (res.status === 401)
+      throw new MetricsSourceError("Metrics token missing or wrong (use --token)", "unauthorized");
+    if (res.status === 403)
+      throw new MetricsSourceError("Server only allows metrics from localhost without a token (use --token)", "forbidden");
+    if (res.status === 404)
+      throw new MetricsSourceError("Metrics endpoint not found: it is disabled, or the server runs a @mavonengine/core release without it", "disabled");
+    if (!res.ok)
+      throw new MetricsSourceError(`Server responded ${res.status} ${res.statusText}`, "unreachable");
+    return res.json();
+  }
+  return {
+    label: url,
+    fetch: () => request(url),
+    fetchLogs: (afterId) => {
+      logsUrl.searchParams.set("after", String(afterId));
+      return request(logsUrl.toString());
+    },
+    fetchRequests: (afterId) => {
+      requestsUrl.searchParams.set("after", String(afterId));
+      return request(requestsUrl.toString());
+    }
+  };
+}
+var Feed = class {
+  constructor(fetchPage, normalize, max) {
+    this.fetchPage = fetchPage;
+    this.normalize = normalize;
+    this.max = max;
+    this.available = fetchPage ? null : false;
+  }
+  fetchPage;
+  normalize;
+  max;
+  entries = [];
+  /** false once the server turned out not to serve it, null until known */
+  available;
+  lastId = 0;
+  async poll() {
+    if (!this.fetchPage || this.available === false)
+      return;
+    try {
+      let { entries, latestId } = this.normalize(await this.fetchPage(this.lastId));
+      if (latestId < this.lastId) {
+        this.entries = [];
+        this.lastId = 0;
+        ({ entries, latestId } = this.normalize(await this.fetchPage(0)));
+      }
+      this.available = true;
+      this.entries.push(...entries.filter((entry) => entry.id > this.lastId));
+      this.lastId = Math.max(this.lastId, latestId);
+      if (this.entries.length > this.max)
+        this.entries.splice(0, this.entries.length - this.max);
+    } catch (err) {
+      if (err instanceof MetricsSourceError && err.status === "disabled")
+        this.available = false;
+    }
+  }
+};
+var MetricsClient = class {
+  constructor(source, { intervalMs = 1e3, maxBackoffMs = 1e4, startupIntervalMs } = {}) {
+    this.source = source;
+    this.intervalMs = intervalMs;
+    this.maxBackoffMs = maxBackoffMs;
+    this.startupIntervalMs = startupIntervalMs;
+    this.logs = new Feed(source.fetchLogs?.bind(source), normalizeLogs, MAX_LOG_LINES);
+    this.requests = new Feed(source.fetchRequests?.bind(source), normalizeRequests, MAX_REQUEST_LINES);
+    this.state = {
+      status: "connecting",
+      source: source.label,
+      snapshot: null,
+      lastUpdate: null,
+      error: null,
+      failures: 0,
+      logs: [],
+      logsAvailable: this.logs.available,
+      requests: [],
+      requestsAvailable: this.requests.available
+    };
+  }
+  source;
+  state;
+  intervalMs;
+  maxBackoffMs;
+  startupIntervalMs;
+  timer = null;
+  running = false;
+  listeners = /* @__PURE__ */ new Set();
+  logs;
+  requests;
+  onChange(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  start() {
+    if (this.running)
+      return;
+    this.running = true;
+    void this.loop();
+  }
+  stop() {
+    this.running = false;
+    if (this.timer)
+      clearTimeout(this.timer);
+    this.timer = null;
+  }
+  /**
+   * Poll once now, skipping the wait.
+   */
+  async refresh() {
+    if (this.timer)
+      clearTimeout(this.timer);
+    this.timer = null;
+    await this.loop();
+  }
+  /**
+   * Fetch one snapshot, then any new log lines and requests, and update the state.
+   */
+  async poll() {
+    try {
+      const raw = await this.source.fetch();
+      this.state.snapshot = normalizeSnapshot(raw);
+      this.state.status = "live";
+      this.state.lastUpdate = Date.now();
+      this.state.error = null;
+      this.state.failures = 0;
+      await Promise.all([this.logs.poll(), this.requests.poll()]);
+      this.state.logs = this.logs.entries;
+      this.state.logsAvailable = this.logs.available;
+      this.state.requests = this.requests.entries;
+      this.state.requestsAvailable = this.requests.available;
+    } catch (err) {
+      this.state.status = err instanceof MetricsSourceError ? err.status : "unreachable";
+      this.state.error = err.message;
+      this.state.failures++;
+    }
+    this.listeners.forEach((listener) => listener(this.state));
+  }
+  /**
+   * Delay before the next poll: the normal interval, doubling per failure up to maxBackoffMs.
+   * The startup interval until the server first answered, if one is set.
+   */
+  nextDelay() {
+    if (this.startupIntervalMs !== void 0 && !this.state.snapshot)
+      return this.startupIntervalMs;
+    if (this.state.failures === 0)
+      return this.intervalMs;
+    return Math.min(this.intervalMs * 2 ** this.state.failures, Math.max(this.maxBackoffMs, this.intervalMs));
+  }
+  async loop() {
+    await this.poll();
+    if (this.running && !this.timer) {
+      this.timer = setTimeout(() => {
+        this.timer = null;
+        void this.loop();
+      }, this.nextDelay());
+    }
+  }
+};
+
+// src/dashboard/simulator.ts
+var HISTORY_LENGTH = 60;
+function mulberry32(seed) {
+  return () => {
+    seed |= 0;
+    seed = seed + 1831565813 | 0;
+    let t = Math.imul(seed ^ seed >>> 15, 1 | seed);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function push(history, item) {
+  history.push(item);
+  if (history.length > HISTORY_LENGTH)
+    history.shift();
+}
+function simulatedSource(seed = 1, sampleIntervalMs = 1e3) {
+  const random = mulberry32(seed);
+  const tickRate = 30;
+  const budgetMs = Math.round(1e3 / tickRate * 100) / 100;
+  let step = 0;
+  let now = Date.UTC(2026, 0, 1);
+  let sequence = 0;
+  const cpuHistory = [];
+  const bandwidthHistory = [];
+  const tickHistory = [];
+  const logs = [];
+  let previousPlayers = 0;
+  const joinedAt = [];
+  const log = (level, message) => {
+    logs.push({ id: logs.length + 1, timestamp: now, level, message });
+  };
+  const requests = [];
+  const request = (method, path, status, bytes, address) => {
+    requests.push({ id: requests.length + 1, timestamp: now, method, path, status, durationMs: Math.round((1 + random() * 20) * 100) / 100, bytes, address });
+  };
+  log("info", "Starting @mavon/engine - Socket Server");
+  log("info", "Starting @mavon/engine - HTTP Server");
+  return {
+    label: "simulation",
+    async fetch() {
+      step++;
+      now += sampleIntervalMs;
+      sequence += tickRate;
+      const playerCount = Math.max(1, Math.round(6 + 5 * Math.sin(step / 20) + random() * 2));
+      for (let i = previousPlayers; i < playerCount; i++)
+        joinedAt[i] = now;
+      const players = Array.from({ length: playerCount }, (_, i) => ({
+        id: `sim-${(i + 1).toString().padStart(2, "0")}`,
+        displayName: `Player ${i + 1}`,
+        position: {
+          x: Math.round(Math.cos(step / 10 + i) * (10 + i * 3) * 100) / 100,
+          y: 0,
+          z: Math.round(Math.sin(step / 10 + i) * (10 + i * 3) * 100) / 100
+        },
+        lastProcessedSequenceId: sequence - Math.floor(random() * 3),
+        trackedEntities: playerCount + 20 + Math.floor(random() * 5),
+        connectedFor: Math.round((now - joinedAt[i]) / 1e3),
+        connection: {
+          address: `203.0.113.${10 + i}`,
+          rttMs: Math.round(20 + i * 8 + random() * 10),
+          bytesSent: Math.round((now - joinedAt[i]) * (25 + i)),
+          bytesReceived: Math.round((now - joinedAt[i]) * (4 + i / 2))
+        }
+      }));
+      for (let i = previousPlayers; i < playerCount; i++) {
+        const address = players[i].connection.address;
+        request("GET", "/", 200, 1240, address);
+        const cached = step % 3 === 0;
+        request("GET", "/assets/index-4f2a9c1e.js", cached ? 304 : 200, cached ? 210 : 412e3, address);
+        request("GET", "/favicon.ico", 404, 160, address);
+        request("POST", "/.wrtc/v2/connections", 200, 2900, address);
+        request("POST", `/.wrtc/v2/connections/${players[i].id}/additional-candidates`, 200, 600, address);
+        log("info", `Connected: ${players[i].id}`);
+        log("info", `${i + 1} total players connected`);
+      }
+      for (let i = previousPlayers - 1; i >= playerCount; i--) {
+        log("info", `Disconnected sim-${(i + 1).toString().padStart(2, "0")}`);
+        log("info", `${i} total players connected`);
+      }
+      previousPlayers = playerCount;
+      if (step % 10 === 0)
+        request("GET", "/api/game/health", 200, 180, "198.51.100.7");
+      if (step % 23 === 0)
+        request("GET", "/wp-login.php", 404, 160, "192.0.2.66");
+      if (step % 5 === 0)
+        log("debug", `Client - Sent: ${playerCount * 4200} B, Received: ${playerCount * 600} B`);
+      const cpu = Math.max(0, 12 + playerCount * 2.5 + Math.sin(step / 7) * 6 + random() * 4);
+      push(cpuHistory, { timestamp: now, cpuPercentage: Math.round(cpu * 100) / 100 });
+      const sent = Math.round(playerCount * (900 + random() * 300) * tickRate * sampleIntervalMs / 1e3);
+      const received = Math.round(playerCount * (120 + random() * 60) * tickRate * sampleIntervalMs / 1e3);
+      push(bandwidthHistory, { timestamp: now, sent, received });
+      const avgMs = 2 + playerCount * 0.6 + random() * 1.5;
+      const maxMs = avgMs + random() * 3 + (step % 17 === 0 ? 25 : 0);
+      if (maxMs > budgetMs)
+        log("warn", `Slow tick: ${maxMs.toFixed(1)} ms (budget ${budgetMs} ms)`);
+      const commandsPerSecond = playerCount * tickRate;
+      push(tickHistory, {
+        timestamp: now,
+        ticks: tickRate,
+        ticksPerSecond: tickRate - (maxMs > budgetMs ? 1 : 0),
+        avgMs: Math.round(avgMs * 100) / 100,
+        maxMs: Math.round(maxMs * 100) / 100,
+        commandsPerSecond,
+        maxCommandsPerTick: playerCount + Math.floor(random() * 3)
+      });
+      const average = (ms) => {
+        const recent = cpuHistory.slice(-Math.max(1, Math.round(ms / sampleIntervalMs)));
+        return Math.round(recent.reduce((acc, h) => acc + h.cpuPercentage, 0) / recent.length * 100) / 100;
+      };
+      const heapUsed = 6e7 + playerCount * 2e6 + step % 30 * 1e6;
+      const snapshot = {
+        schemaVersion: 1,
+        engineVersion: "simulated",
+        serverTime: new Date(now).toISOString(),
+        uptime: Math.round(step * sampleIntervalMs / 1e3),
+        sampleIntervalMs,
+        tickRate,
+        players,
+        world: { entities: playerCount + 140 },
+        physics: { bodies: playerCount + 120, colliders: playerCount + 180 },
+        cpu: {
+          current: cpuHistory.at(-1).cpuPercentage,
+          avg1s: average(1e3),
+          avg10s: average(1e4),
+          avg60s: average(6e4),
+          history: [...cpuHistory]
+        },
+        bandwidth: {
+          sentPerSecond: Math.round(sent * 1e3 / sampleIntervalMs),
+          receivedPerSecond: Math.round(received * 1e3 / sampleIntervalMs),
+          history: [...bandwidthHistory]
+        },
+        tick: {
+          budgetMs,
+          latest: tickHistory.at(-1),
+          history: [...tickHistory]
+        },
+        memory: {
+          rss: heapUsed + 8e7,
+          heapUsed,
+          heapTotal: heapUsed + 3e7,
+          external: 5e6
+        },
+        latencySimulation: null
+      };
+      return snapshot;
+    },
+    async fetchLogs(afterId) {
+      return { entries: logs.filter((entry) => entry.id > afterId), latestId: logs.length };
+    },
+    async fetchRequests(afterId) {
+      return { entries: requests.filter((entry) => entry.id > afterId), latestId: requests.length };
+    }
+  };
+}
+
+// src/dashboard/theme.ts
+import { contrast, defineTheme, mix, resolveTheme } from "@profullstack/hqtui";
+var MIN_MUTED_CONTRAST = 6;
+function readableTheme(name) {
+  const base = resolveTheme(name);
+  let muted = base.muted;
+  for (let t = 0.05; contrast(muted, base.background) < MIN_MUTED_CONTRAST && t <= 1; t += 0.05)
+    muted = mix(base.muted, base.foreground, t);
+  return defineTheme({ name: base.name, muted }, base);
+}
+
+// src/dashboard/view.ts
+import { stripVTControlCharacters } from "util";
+
+// ../core/dist/Utils/BootBanner.js
+function bootBanner({ version: version2, threeRevision, rapierVersion, mode }) {
+  const row = (label, value) => `\u2502  ${`${label}:`.padEnd(10)}${value.padEnd(28)} \u2502`;
+  return [
+    "\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510",
+    "\u2502                                         \u2502",
+    "\u2502              MavonEngine                \u2502",
+    "\u2502                                         \u2502",
+    row("Version", version2),
+    ...threeRevision ? [row("Three.js", `r${threeRevision}`)] : [],
+    ...rapierVersion ? [row("Rapier", rapierVersion)] : [],
+    row("Mode", mode),
+    "\u2502                                         \u2502",
+    "\u2502  https://github.com/MavonEngine/core    \u2502",
+    "\u2502  https://mavonengine.com                \u2502",
+    "\u2502                                         \u2502",
+    "\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518"
+  ];
+}
+
+// src/dashboard/view.ts
+import { DEFAULT_COLOR, hex } from "@profullstack/hqtui";
+
+// src/dashboard/format.ts
+var BYTE_UNITS = ["B", "KiB", "MiB", "GiB", "TiB"];
+function formatBytes(bytes, decimals = 1) {
+  if (!Number.isFinite(bytes) || bytes <= 0)
+    return "0 B";
+  const exponent = Math.min(Math.floor(Math.log(bytes) / Math.log(1024)), BYTE_UNITS.length - 1);
+  const value = bytes / 1024 ** exponent;
+  return `${exponent === 0 ? value : value.toFixed(decimals)} ${BYTE_UNITS[exponent]}`;
+}
+function formatRate(bytesPerSecond) {
+  return `${formatBytes(bytesPerSecond)}/s`;
+}
+function formatDuration(totalSeconds) {
+  const seconds = Math.max(0, Math.floor(totalSeconds));
+  const d = Math.floor(seconds / 86400);
+  const h = Math.floor(seconds % 86400 / 3600);
+  const m = Math.floor(seconds % 3600 / 60);
+  const s = seconds % 60;
+  if (d > 0)
+    return `${d}d ${h}h ${m}m`;
+  if (h > 0)
+    return `${h}h ${m}m ${s}s`;
+  if (m > 0)
+    return `${m}m ${s}s`;
+  return `${s}s`;
+}
+function formatMs(ms) {
+  return `${ms.toFixed(ms < 10 ? 2 : 1)} ms`;
+}
+function formatPercent(value) {
+  return `${value.toFixed(1)}%`;
+}
+
+// src/dashboard/logo.ts
+var LOGO_SIZES = [
+  [
+    "------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------",
+    "------------------------------------------------------------------------------------------------------------------174c6b1f627f216682194f6f------------------------------------------------------------------------------------------------------------------",
+    "------------------------------------------------------------------------------------------------------184a6c2164813d98a958cbd357cdd53e9cae236680194b69------------------------------------------------------------------------------------------------------",
+    "------------------------------------------------------------------------------------------------1b50723a8aa255b7c344a2b33a9dad399cae3f9caf51b3c13c92a51c5474------------------------------------------------------------------------------------------------",
+    "------------------------------------------------------------------------------------16436524648047a0b14da7b72e7590185a7a2c859d2e8ba1195d7b276c8848a0b34aa5b5296b851a4868------------------------------------------------------------------------------------",
+    "------------------------------------------------------------------------------1d56763a8ca250b1be3e8b9e194e6d174c6e29789444b6c646bbc92c7f991a5274194f713884984cacb83d93a5215e7b194668------------------------------------------------------------------------",
+    "------------------------------------------------------------------1c4f6f357f9655b2bf479eae245c77------205974358da53796ad389bb03a9bb03693a93692a823637f------20566f4090a353b1bf39879c1d5775174366------------------------------------------------------------",
+    "------------------------------------------------------------2a6a844da6b555acb82f6e87------------296c85358ba225667f14496726768e297b91154865215e7732879e28748b194965------2665804ca3b34eabba29728b------------------------------------------------------------",
+    "------------------------------------------------1d546d3e8fa152b1be378397194a67------245e7a398fa636879d------------1d54703395aa349aad1e5a73------------2e7e943690a8256782------174869307b904aabba3c93a51d546f------------------------------------------------",
+    "------------------------------------194b67347b9161c0cc53b0be1e5b78------1b4e6b2e7d94348ca2225c75------------2d76903492a926728c236c86348da32e7a94------------1f53703188a131859d1e5772------16577441a3b556c4ce3583951a4f6a------------------------------------",
+    "------------------------------25637d49a5b552b1bf3a8a9f4aa2b43d91a52d7d963490a7266a83------------1e516e338ba32e7c941c4b66------------------2a728c338da5215975------------23627d3491a82d839b368fa441a4b533889e4aa8b649abb8286b83------------------------------",
+    "------------------1e55723c93a54ab1c0307e97174b6c------1d506b3a889b56bfca3c90a4------1a4a672e7c963795ab1f526f------------------------------------1d4d693691a732839a1d516e------33829953bdc93d92a41f5571------17496b2a758f47adba4197a8215c76------------------",
+    "------------2b728b50bcc84dbbc92780991e64811f5c781d4f6c------------255d774499ab4db3c041a9b92d7e96------------------------------------------------------------2d799343aabb4fb3c148a1b226647c------------1b4c681f5e7b1e6782257d9545b2c155c3ce318198------------",
+    "------1e516d4dc6d463ecf54fc0cc3fa3b43b9caf3898aa3c9daf34869c1c4c69------------2c6c8348a5b23c91a11f526e------------------------------------------------1d4c6a3b8a9d4eaeb7327a8f------------------347f943c9cae3597a93a9caf3ea2b44bbac862e6f156d4df225d75------",
+    "------205a774abed14eb6d841a6bc3290a315516e------------307991419fb32c758d------------------3680964ca8b72d6b85------------------------------------29637c4ea9b53b8798------------------2a6c85439fb1368397------------164d6d318ba045aabb4bb1d44dc4da23657f------",
+    "------1f5b7a43abbe3e7fb4336097357d9c4dabbb358299154665------1e4e6a3385983992a6225c78------------1f53714197aa3d91a6225a771844651845662156743b8ba1449cad245a76------------1e526b388ea0398d9d1f5670------------2f7a914dafbb3b87a2305e913e7eb643aabf236881------",
+    "------2056753da3b52859874260a51c35681f50744292a84ba7b723607a------------225c763993a8388ca3205171------1b44672b6b892a6a881d53761d52772868882c708c1b4b6c------1948683483993d97a7256379------------1e58754aa6b64ba0b0255977------3f5ea12a59883d9eb023647d------",
+    "------1d54723b9faf1e4971384f8f364b88------------27627f45a1b237879d1d4e6e------------2e7591409db52f7996194067------19456a215b80225c801a456b------------2d718f419eb3337f97------------------337f9549a7b62e7089------------2f427b3d55941c436a3b9bad24637d------",
+    "------1c536c3b9eae1b476a2b40783d4d8f------------------1d456738839a4ea8ba397f9a1c476d------1e4e723385a0368ca7255c801f4e772d6d912d6e921f517923587e3989a43b8fa91f5576------16426530758e4da8b73c8ca01f496b------------------3848842e457d------3a9aaa216078------",
+    "------1d53703b9dad1b4668273b7437468b------2f6c8d396199------------27577b4597ae4ba5b92c6c8c1b40691b3d682c6f93358cad307ba04196b3429ab52e7aa0388eaf2f78991a3f67------28658449a2b34aa2b42a607f------------32558d327495------32407f2b4079------3a99a8206078------",
+    "------1d51713898ad1c4366263a7139438c------3b8ea95f9ae14e62b42d4380------------2b688843a1b64297b2295b8622457a27548b3376a650b7ce51bbd0347ca925568c20457724557f3e93ad48a8b931728e------------2c40784e61ac6394e24198b5------333f7f2b3f75------3895a7205f78------",
+    "------1c51703494ab------27397038478e------378fa7417db04b5eb03f54a33d51a2273873------204572367aa14da8c63c76ad335c9f3e83b658c6da59c8dc3e88b82f5e9d396fa649a8c43782a01f476d------23346a42549d4a5ca95164b54776b13e93ac------324281293f76------3693a71f5a78------",
+    "------1c4f6e3494ab------28397339498f------328ba1286788384f942a41802a3b794452a73d4c9a273a79243d7a3256974078b6448fc147a9cd4bc5d94bc7dc48a7cf4590c4427cb7305995223a7422346e35478e4455a3303e812d3c7e4256a02b5f873b91a9------324381293f77------3692a8215978------",
+    "------1c4e6e3593ad1d4166283a7437468f------2f879c21607c2541744073b224597e2132693e4f995160b74356a638549d448abf50c4df4ccde146c9dc44c8dc4ac9e054c5e14b91c536569d4154a4505fb53d4e991f2f651f47704077b12d4b86215577368da6------3242802b4078------3591a9205978------",
+    "------1d4d6e3691ad1d406627387334448b------2f859d205f7c243a6d456eb23a93b22a668e1e356a2f41874567b2468ec84a9dce4da6d451c7e245cbdd44cadc4ecae34eaad54b9bce488ec64968b53143861b2f6523527c3c8fae4677b329407a1e51713288a3------304080293e76------348ca91f5978------",
+    "------1d4a6f348dac1c3f65253670324388------2e839c205f7e2639703c509b265a843c9bb6327da01f3e702333732b3c853341964160b150a5d644b8d741b9d54badd74066b4314196293883222e711e366f2e70973f9eba2c60893a5196283c771d52713186a1------2f3c7e293a73------338aa51f5479------",
+    "------1b4a6e348bac------24366f32418a------2c819d1f5d7e24376e394a941b406a2d7c9b40aec6358bad2859892136742a387f3545963f6db73e8dc53c90c53d75b834469a29358220306e2551843586a943a9c2398fab204570384b92273d771e50732e82a1------2e3b7d293872------3189a51f5379------",
+    "------1c4a6e3287aa------243570313f8a------2a7e9c1f5b7d22346935458d------266d8d2a6d9022567f378bb13784ae26448027357e2e47933066a63169a72c499326337e243e7c3781aa3a90b3255a82245d812f76961d406735478d263a761d4e6f2d7e9f------2d3a7c283874------3085a81c5279------",
+    "------1c486e3284ab1c3d68263472303f89------287c991e597a213268324089------266d8d2a698d------1b376528638d3285ae2b5f952745832857902958922543832a58903586ad2c6e951c3b6a------24587c2e7595------3243892437711c4c6f2c7a9d------2c3a7e283875------2f82a71d507a------",
+    "------1b47703081ab1d3c6726347430408b------2777981d567920316731418a------266b8b286588------------------2148752d6f9c2b6093244c80244b7f2a5c912e729f244f7b------------------2256792d7395------3041872436711c486e28779b------2d3b80293879------2f7fa61b5077------",
+    "------1a446f2d7fac1e3d6e27367b303f8f------26749a1d547b21326a30408c------26658a275f82------------------------------------1d3c681e3d6b1c3465------------------------------2051732c6f92------2e3e862335721a466c257499------2d3d8329387b------2f7da81b4f78------",
+    "------1a436f2e7eae1f3e6f28377f2e3d8e183b652c86ae22678f1f336a2c3b87------246088275d82------------------------------------------------------------------------------------1f50712a6b8e------2b397f21346f1f5a832a87b01a3f662c39852838811d38692f7eaa1b4c77------",
+    "------1b426e2e7fae1f4171263c803161ab2c7fa92a779f2a74a02e62a02b3d8b------266088255c84------------------------------------273b72293e77------------------------------------1f4f762a6a90------28387d2d609d2876a027719b2d7fa83364ae2940871d3d722f7dae1b4a77------",
+    "------1a3f6a2e7daf22578b2f77b23a80c9285090------------2744842e4295------26618f275c85------------------------------------2736722a3878------------------------------------204f772b6b92------2b3b84284585------------274385417ecd337db9255990317cb21b4674------",
+    "------1b3c693690c6368bc22057881d37732d3b902c3a8f------1c2a662e398e------265d8b265780------------------------------------262f73293178------------------------------------1f4972296790------2c3684202a67------2c3587333d952438782251853487bb3d9ad21b4371------",
+    "------------2b659b3585c021568b------------202e72333d98313c972d378e------245784275483283072252e6f------------------------262d74292e79------------------------222c6729327521487a275f8b------2c3484333a9438409a28337a------------2152853583bc306fa4------------",
+    "------------------1d41722d71a73172ac1e4376------------2f368c2f3696------235486244f80------373c92353a90------------------272c7b292d7f------------------313788383e95222b681e4373275b8b------2c3586343893------------1a3c6f2d6ea73075ae214678------------------",
+    "------------------------------235087347bb52a699f------------2c378f1b346a285c95254f85------------24296937399729307b------272c7b292d7f------252b6f353891282d71------------1e42742b62991b376a2b36881e2c6a------265d96347bb6265a92------------------------------",
+    "------------------------------------------255a912e74ae2c589c3250a62c629d2f66a5283a87232770------------------33368e37379934349932329635359235358e------------------23286f2838842d64a22e66a13451a42b52992a6faa255c951a3667------------------------------------",
+    "------------------------------------------------1d3b6f2f69aa3475be27538c------------24277031318e252872------------------3834a03934a3222568------------22276a32338e282b76------------234c803672b6306cab1d3b6f------------------------------------------------",
+    "------------------------------------------------------------------------------------------------2e2d842a2b7b------------262673282877------------282972302f86------------------------------------------------------------------------------------------------",
+    "------------------------------------------------------------------------292d72413ea3323285------------------302f862b2b7d2d2b892e2b892a2a7a302f87262468------------2d2c7d3e3ca02b2f7b------------------------------------------------------------------------",
+    "------------------------------------------------------------------------------------34328a3b369b272770------------2d2a7e4037ac4136b0302c86------------2524673a3397363390------------------------------------------------------------------------------------",
+    "------------------------------------------------------------------------------------------2325653a3599353290------------2a26782c277c------------322e853e379d2a2870------------------------------------------------------------------------------------------",
+    "------------------------------------------------------------------------------------------------------332e883c35a02e2a812f2a84302a852c277939329634308a------------------------------------------------------------------------------------------------------",
+    "------------------------------------------------------------------------------------------------------------------362f914338b54438b7382f96262469------------------------------------------------------------------------------------------------------------",
+    "------------------------------------------------------------------------------------------------------------------------252369242369------------------------------------------------------------------------------------------------------------------------",
+    "------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------"
+  ],
+  [
+    "------------------------------------------------------------------------------------------------------------------------------------------------------------------------",
+    "------------------------------------------------------------------------215c79368ea13790a4225f7b------------------------------------------------------------------------",
+    "------------------------------------------------------------1a47652f728f439cae3fa0b03d9eb0409aac3077911c4967------------------------------------------------------------",
+    "------------------------------------------------------235e7c3d8fa23d8da1226582308ca4318fa52267843a899f3d90a326637f------------------------------------------------------",
+    "------------------------------------------2255713c889d4294a527627b1e536e2d7d963594aa3594a82e7f981e5772255e773e8ea13c8ba0225a77------------------------------------------",
+    "------------------------------------2b6d834294a63172881e526e2a6c862c738a1b4d6926738c26758d1a4d67276f87286f891d53712d6e873d93a52b6e85------------------------------------",
+    "------------------------2560794a9eaf53b1bf205d79205b772a738b215771------2a738d28728a276f8729728b------1f536f2a738d21627d1c5e7a44a9ba43a1b027657c------------------------",
+    "------------1c4b673282973b90a42864812d6e85439dad3689a0194a66225b772d78911d4a66------------------2d778f25617a1a486532839b409fb02b738a24617d388da13584971e4f6a------------",
+    "------225c764ebdca42aaba2779922668831c4b671f4f6b38849942a0b02e7c93------------------------------------30799144a4b33a8a9e1f526d------2467812779923da4b651c1cd286880------",
+    "------338aa056cee33ca1b326738a21607c328097296982------23597339869a30728a------------------------306e843b8899276076------28677f34829720627b2570883ca0b255cbe13a97ac------",
+    "------30819a3e83b131679539879e2d7089------25627b2f7a91225976------2b69843076901d51711d4f702f758e2f6e86------1e526c2f7a8c27667d------2c6e863c8c9f326a933d7fb0328ca1------",
+    "------2d7b912c6088344989------2e6c8738889d2156731a47672c728d317a96204f731c486c1f577b1f567b1d4a6e1e4d703078922e758e1849651d536d3a8a9e33748c------3247852a5c8530859a------",
+    "------2c798e24567a344483------------1d446639819a3a829c225175215477307b9828698c2d6c902d6c9129688c347e9c2258791d4e6f37809639839a1f4667------------3345812251732e8396------",
+    "------2c778f2353752f3e7e20436c498ebc3f549c213b6c2a5f7f3a89a3317394244f7d2d6a99449ebd449fbd2d6e9b214e792e728f3d8ca32c6483213d6a3c50954b8dbf1f4266313f7c214e6e2e8194------",
+    "------28738e225073304081214a723c8aad465da93648922d3e81234174336e994184b33a75ae4eb1cf4eb3d13976af3f81b032719620426c2b3d7a3c4a924d60af4289b022496e30417d204c6d2d7c94------",
+    "------28728e235075303f831f486d2b7c9327457a3159902e4383424f9f3a4f9c3c6dac4bb4d549c8dd47c6dd4db4d83e70ae394f993e4d9a2d3e7e30568c2f4b872f799520476b30417e204d6e2c7a95------",
+    "------2a6f8e234e752d3d7f1e456c2a7891233e703c74a82c6f9329437d39579f417ab74ca5d449c4dd47c7de4ca8d4407ab73b579f273f7b2a658b3c75a52740772b718d1d44682e3f7d1f496d2b7795------",
+    "------286b8e214d732b3b7c1c426b2877932338702d4e872f809d3388a927508427347c3a59a5408cc53f90c5385da825307a2649803380a43789a630518a253d75296e8e1c41682d3b7b1e466a297394------",
+    "------27698e214b752b3a7e1c406b26729221366928457a236283265f862c6b9530709e2947892d56982c5798284488306e9d2f709825567e2966872a477d243972276a8c1a3f682c3b7b1e466c286f96------",
+    "------27658e2149772b39801d3f6c246e8e20326726427a235f801e456c------1f47712a6091265287264f862a6091234b74------------27638328447b22356f2464891b3e692d3b7e204470266d94------",
+    "------24618e224a7c2c38851d416f2571981f3369253e7a21597c------------------------------1d3765------------------------245d7f25407821336e23688f1b416d2c3981214474256b95------",
+    "------24608e234c7f2d4e98276c9a28729a2a5692233c7522567c------------------------------------------------------------245a7f213b71295491256e97276a9830529b22487f266796------",
+    "------2461902d76ab2b66a52a4b93------213774243e7e23557f------------------------------222f66------------------------245a80253c78223874------2c438f3167a92f76ae28689b------",
+    "------214c7c317bb51c4375------2732812c358b253779214f7b243e71------------------1f2865212866------------------20386d22527e2437752f368a2c35821e2a651d4173327cb2255383------",
+    "------------1a3765285f96275d92------252c7524367d214d7e203a6c272c6e2c327e------20276a21276a------2b317a282f721c3365234f7f243779272f7a------25588e29629a1d3b69------------",
+    "------------------------1f44762860982a56982e579e295591212e70------------2e31823233933131912c2f7f------------212c6e2855902e579e2a5396265e9620477b------------------------",
+    "------------------------------------254b85264a83------------27287524286d------282878282979------222667272a75------------24467c244b83------------------------------------",
+    "------------------------------------------------272b6e323284------------2728722d2b842d2b83292873------------2e2f7f282d73------------------------------------------------",
+    "------------------------------------------------------------312e832b2a79------2f2a842f2b87------2a2873332f85232565------------------------------------------------------",
+    "------------------------------------------------------------------292872312d86302b87302a84302b802b2973------------------------------------------------------------------",
+    "------------------------------------------------------------------------------322b88332c8a------------------------------------------------------------------------------",
+    "------------------------------------------------------------------------------------------------------------------------------------------------------------------------"
+  ]
+];
+
+// src/dashboard/view.ts
+var DASHBOARD_TABS = ["Overview", "Players", "Logs", "HTTP"];
+var WIDE_LAYOUT = 100;
+var NEWLINE_RE = /\r?\n/;
+var STATUS_LABELS = {
+  connecting: "CONNECTING",
+  live: "LIVE",
+  unreachable: "UNREACHABLE",
+  unauthorized: "UNAUTHORIZED",
+  forbidden: "FORBIDDEN",
+  disabled: "METRICS DISABLED"
+};
+function tabForKey(key) {
+  const index = Number(key) - 1;
+  return Number.isInteger(index) && index >= 0 && index < DASHBOARD_TABS.length ? index : null;
+}
+function sortedPlayers(players) {
+  return [...players].sort((a, b) => a.id.localeCompare(b.id));
+}
+function handlePlayersKey(view, snapshot, key) {
+  if (DASHBOARD_TABS[view.tab] !== "Players" || !snapshot)
+    return false;
+  if (key === "escape") {
+    const had = view.selectedPlayerId !== null;
+    view.selectedPlayerId = null;
+    return had;
+  }
+  const delta = key === "down" || key === "j" ? 1 : key === "up" || key === "k" ? -1 : 0;
+  const rows = sortedPlayers(snapshot.players);
+  if (delta === 0 || rows.length === 0)
+    return false;
+  const current = rows.findIndex((p) => p.id === view.selectedPlayerId);
+  const next = current === -1 ? delta > 0 ? 0 : rows.length - 1 : Math.max(0, Math.min(rows.length - 1, current + delta));
+  view.selectedPlayerId = rows[next].id;
+  view.followSelectedPlayer = true;
+  return true;
+}
+function statusColor(status, theme) {
+  if (status === "live")
+    return theme.success;
+  if (status === "connecting")
+    return theme.warning;
+  return theme.danger;
+}
+function renderDashboard(ui, theme, state, view, { transparent = false, startup, openKey = false } = {}) {
+  const { snapshot } = state;
+  const starting = !snapshot && !!startup && (state.status === "connecting" || state.status === "unreachable");
+  ui.column({}, (root) => {
+    header(root, theme, state);
+    if (snapshot?.latencySimulation)
+      latencyBanner(root, theme, snapshot.latencySimulation);
+    if (state.error && snapshot)
+      root.text([{ text: ` ${state.error} \u2014 showing last known values`, fg: theme.danger }], { size: 1 });
+    if (starting) {
+      startupScreen(root, theme, startup);
+    } else if (!snapshot) {
+      waiting(root, theme, state);
+    } else {
+      root.tabs({
+        tabs: DASHBOARD_TABS.map((name, i) => `${i + 1} ${name}`),
+        active: view.tab,
+        size: 1,
+        onSelect: (index) => {
+          view.tab = index;
+          root.ctx.invalidate();
+        }
+      });
+      const tab = DASHBOARD_TABS[view.tab] ?? "Overview";
+      if (tab === "Players") {
+        playersTab(root, theme, snapshot, view, transparent);
+      } else if (tab === "Logs") {
+        logsPanel(root, theme, state, view);
+      } else if (tab === "HTTP") {
+        requestsPanel(root, theme, state, view, transparent);
+      } else {
+        root.responsive({
+          [WIDE_LAYOUT]: (c) => wideLayout(c, theme, state, snapshot, view, transparent),
+          0: (c) => narrowLayout(c, theme, state, snapshot, view, transparent)
+        });
+      }
+    }
+    root.statusBar({
+      size: 1,
+      background: transparent ? DEFAULT_COLOR : void 0,
+      items: [
+        { key: "q", label: "Quit" },
+        { key: "r", label: "Refresh" },
+        { key: `1-${DASHBOARD_TABS.length}`, label: "Tabs" },
+        ...openKey && snapshot ? [{ key: "o", label: "Open game" }] : [],
+        ...snapshot && DASHBOARD_TABS[view.tab] === "Players" ? [{ key: "\u2191\u2193", label: "Select player" }, ...view.selectedPlayerId ? [{ key: "esc", label: "Close" }] : []] : []
+      ],
+      right: [starting ? { label: "STARTING", color: statusColor("connecting", theme) } : { label: STATUS_LABELS[state.status], color: statusColor(state.status, theme), active: state.status === "live" }]
+    });
+  });
+}
+function header(ui, theme, state) {
+  const spans = [
+    { text: " MavonEngine ", fg: theme.primary, bold: true },
+    { text: state.source, fg: theme.muted }
+  ];
+  if (state.snapshot) {
+    spans.push(
+      { text: "  uptime ", fg: theme.muted },
+      { text: formatDuration(state.snapshot.uptime) },
+      { text: "  engine ", fg: theme.muted },
+      { text: state.snapshot.engineVersion }
+    );
+    if (state.snapshot.schemaVersion > SUPPORTED_SCHEMA_VERSION)
+      spans.push({ text: "  newer metrics schema, update @mavonengine/cli", fg: theme.warning });
+  }
+  ui.text(spans, { size: 1 });
+}
+function latencyBanner(ui, theme, latency) {
+  ui.text([{
+    text: ` LATENCY SIMULATION ON  ${latency.fixedLatency}ms \xB1 ${latency.jitter / 2}ms, ${formatPercent(latency.packetLoss * 100)} packet loss `,
+    fg: theme.background,
+    bg: theme.warning,
+    bold: true
+  }], { size: 1 });
+}
+var STARTUP_OUTPUT_LINES = 8;
+function logoLines(pixels) {
+  const pixel = (row, x) => {
+    const value = row?.slice(x * 6, x * 6 + 6);
+    return value && value !== "------" ? hex(Number.parseInt(value, 16)) : null;
+  };
+  const lines = [];
+  for (let y = 0; y < pixels.length; y += 2) {
+    const line = [];
+    for (let x = 0; x < pixels[y].length / 6; x++) {
+      const top = pixel(pixels[y], x);
+      const bottom = pixel(pixels[y + 1], x);
+      if (top !== null)
+        line.push({ text: "\u2580", fg: top, bg: bottom ?? void 0 });
+      else if (bottom !== null)
+        line.push({ text: "\u2584", fg: bottom });
+      else
+        line.push({ text: " " });
+    }
+    lines.push(line);
+  }
+  return lines;
+}
+var LOGOS = LOGO_SIZES.map(logoLines);
+function startupScreen(ui, theme, { engineVersion, output, label = "Starting the game server\u2026", outputTitle = "Dev script" }) {
+  const lines = stripVTControlCharacters(output).split(NEWLINE_RE).filter((line) => line.trim() !== "");
+  const banner = bootBanner({ version: engineVersion ?? "unknown", mode: "development" });
+  ui.column({ size: "1fr" }, (column) => {
+    const { unicode, colors } = column.ctx.capabilities;
+    const logo = unicode && (colors === "truecolor" || colors === "ansi256") ? LOGOS.find((l) => l.length + banner.length + 3 <= column.height && l[0].length <= column.width) : void 0;
+    column.spacer("1fr");
+    if (logo) {
+      for (const line of logo)
+        column.text(line, { align: "center", size: 1 });
+      column.spacer(1);
+    }
+    for (const line of banner)
+      column.text([{ text: line, fg: theme.primary }], { align: "center", size: 1 });
+    column.spacer(1);
+    column.row({ size: 1 }, (row) => {
+      row.spacer("1fr");
+      row.spinner({ label, size: label.length + 2 });
+      row.spacer("1fr");
+    });
+    column.spacer("1fr");
+  });
+  ui.panel({ title: outputTitle, size: STARTUP_OUTPUT_LINES + 2 }, (panel) => {
+    if (lines.length === 0) {
+      panel.label("No output yet");
+      return;
+    }
+    panel.log({ entries: lines.slice(-STARTUP_OUTPUT_LINES).map((message) => ({ message })), size: "1fr" });
+  });
+}
+function waiting(ui, theme, state) {
+  ui.panel({ title: "Game server", size: "1fr" }, (panel) => {
+    if (state.status === "connecting") {
+      panel.spinner({ label: `Connecting to ${state.source}` });
+      return;
+    }
+    panel.text([{ text: STATUS_LABELS[state.status], fg: statusColor(state.status, theme), bold: true }]);
+    panel.text(state.error ?? "", { wrap: true });
+    panel.label(`Retrying (attempt ${state.failures})\u2026`);
+  });
+}
+function wideLayout(ui, theme, state, snapshot, view, transparent) {
+  ui.grid({ columns: ["1fr", "1fr"], rows: [11, 11], size: 22 }, (grid) => {
+    grid.panel({ title: "CPU" }, (p) => cpuPanel(p, theme, snapshot));
+    grid.panel({ title: "Network" }, (p) => networkPanel(p, theme, snapshot));
+    grid.panel({ title: "Tick" }, (p) => tickPanel(p, theme, snapshot));
+    grid.panel({ title: "World" }, (p) => worldPanel(p, theme, snapshot));
+  });
+  ui.row({ size: "1fr" }, (row) => {
+    playersPanel(row, theme, snapshot, view, transparent);
+    logsPanel(row, theme, state, view);
+  });
+}
+function narrowLayout(ui, theme, state, snapshot, view, transparent) {
+  ui.panel({ title: "CPU", size: 9 }, (p) => cpuPanel(p, theme, snapshot));
+  ui.panel({ title: "Network", size: 9 }, (p) => networkPanel(p, theme, snapshot));
+  ui.panel({ title: "Tick", size: 9 }, (p) => tickPanel(p, theme, snapshot));
+  ui.panel({ title: "World", size: 11 }, (p) => worldPanel(p, theme, snapshot));
+  playersPanel(ui, theme, snapshot, view, transparent);
+  logsPanel(ui, theme, state, view);
+}
+function cpuPanel(ui, theme, { cpu }) {
+  const values = cpu.history.map((h) => h.cpuPercentage);
+  ui.graph({
+    values,
+    min: 0,
+    max: Math.max(100, ...values),
+    fill: true,
+    colors: theme.heat,
+    axis: true,
+    axisFormat: (v) => `${Math.round(v)}%`,
+    size: "1fr"
+  });
+  ui.meters([
+    { label: "1s", value: cpu.avg1s, max: 100, text: formatPercent(cpu.avg1s) },
+    { label: "10s", value: cpu.avg10s, max: 100, text: formatPercent(cpu.avg10s) },
+    { label: "1m", value: cpu.avg60s, max: 100, text: formatPercent(cpu.avg60s) }
+  ], { columns: 3 });
+}
+function networkPanel(ui, theme, { bandwidth, sampleIntervalMs }) {
+  const perSecond = 1e3 / sampleIntervalMs;
+  ui.multiGraph([
+    { label: "sent", values: bandwidth.history.map((b) => b.sent * perSecond), color: theme.graph[0] },
+    { label: "received", values: bandwidth.history.map((b) => b.received * perSecond), color: theme.graph[1] }
+  ], {
+    min: 0,
+    axis: true,
+    axisFormat: formatRate,
+    legend: true,
+    legendAlign: "right",
+    size: "1fr"
+  });
+  ui.keyValues([
+    { label: "Sent", value: formatRate(bandwidth.sentPerSecond), color: theme.graph[0] },
+    { label: "Received", value: formatRate(bandwidth.receivedPerSecond), color: theme.graph[1] }
+  ], { spread: true });
+}
+function tickPanel(ui, theme, { tick, tickRate }) {
+  const avg = tick.history.map((t) => t.avgMs);
+  const max = tick.history.map((t) => t.maxMs);
+  const latest = tick.latest;
+  ui.multiGraph([
+    { label: "avg", values: avg, color: theme.graph[0] },
+    { label: "max", values: max, color: theme.graph[2] ?? theme.warning }
+  ], {
+    min: 0,
+    max: Math.max(tick.budgetMs * 1.25, ...max, 1),
+    axis: true,
+    axisFormat: (v) => `${v.toFixed(0)}ms`,
+    legend: true,
+    legendAlign: "right",
+    size: "1fr"
+  });
+  ui.meter({
+    label: "Budget",
+    value: latest?.avgMs ?? 0,
+    max: tick.budgetMs || 1,
+    text: `${formatMs(latest?.avgMs ?? 0)} / ${formatMs(tick.budgetMs)}`
+  });
+  ui.keyValues([
+    { label: "Ticks/s", value: `${latest?.ticksPerSecond ?? 0} / ${tickRate}`, color: (latest?.ticksPerSecond ?? 0) < tickRate * 0.9 ? theme.danger : void 0 },
+    { label: "Commands/s", value: `${latest?.commandsPerSecond ?? 0} (max ${latest?.maxCommandsPerTick ?? 0}/tick)` }
+  ], { spread: true });
+}
+function worldPanel(ui, theme, { players, world, physics, memory }) {
+  ui.keyValues([
+    { label: "Players", value: String(players.length), color: theme.primary },
+    { label: "Entities", value: String(world.entities) },
+    { label: "Physics bodies", value: physics ? String(physics.bodies) : "\u2014" },
+    { label: "Colliders", value: physics ? String(physics.colliders) : "\u2014" },
+    { label: "RSS", value: formatBytes(memory.rss) },
+    { label: "External", value: formatBytes(memory.external) }
+  ], { spread: true });
+  ui.spacer("1fr");
+  ui.meter({
+    label: "Heap",
+    value: memory.heapUsed,
+    max: memory.heapTotal || 1,
+    text: `${formatBytes(memory.heapUsed)} / ${formatBytes(memory.heapTotal)}`
+  });
+}
+function playersTab(ui, theme, snapshot, view, transparent) {
+  const selected = snapshot.players.find((p) => p.id === view.selectedPlayerId);
+  if (!selected) {
+    view.selectedPlayerId = null;
+    playersPanel(ui, theme, snapshot, view, transparent, true);
+    return;
+  }
+  ui.responsive({
+    [WIDE_LAYOUT]: (c) => c.row({ size: "1fr" }, (row) => {
+      playersPanel(row, theme, snapshot, view, transparent, true);
+      playerDetails(row, theme, selected, 42);
+    }),
+    0: (c) => {
+      playersPanel(c, theme, snapshot, view, transparent, true);
+      playerDetails(c, theme, selected, 13);
+    }
+  });
+}
+function playerDetails(ui, theme, player, size) {
+  const { connection, position } = player;
+  ui.panel({ title: player.displayName, size }, (panel) => {
+    panel.keyValues([
+      { label: "ID", value: player.id },
+      { label: "Connected", value: formatDuration(player.connectedFor) },
+      { label: "IP", value: connection ? connection.address ?? "pending" : "\u2014", color: theme.primary },
+      { label: "RTT", value: connection?.rttMs != null ? formatMs(connection.rttMs) : "\u2014" },
+      { label: "Sent", value: connection ? formatBytes(connection.bytesSent) : "\u2014" },
+      { label: "Received", value: connection ? formatBytes(connection.bytesReceived) : "\u2014" },
+      { label: "Position", value: [position.x, position.y, position.z].map((n) => n.toFixed(2)).join(", ") },
+      { label: "Last seq", value: String(player.lastProcessedSequenceId) },
+      { label: "Tracked", value: String(player.trackedEntities) }
+    ], { spread: true });
+    if (!connection)
+      panel.label("No live connection (a bot, or an older server)");
+  });
+}
+function playersPanel(ui, theme, { players }, view, transparent, selectable = false) {
+  const rows = sortedPlayers(players);
+  const maxOffset = Math.max(0, rows.length - 1);
+  view.playerOffset = Math.min(view.playerOffset, maxOffset);
+  const showNames = rows.some((p) => p.displayName !== p.id);
+  ui.panel({ title: `Players (${rows.length})`, size: "1fr" }, (panel) => {
+    if (rows.length === 0) {
+      panel.label("No players connected");
+      return;
+    }
+    panel.table({
+      rows,
+      offset: view.playerOffset,
+      selected: selectable ? rows.findIndex((p) => p.id === view.selectedPlayerId) : -1,
+      followSelection: selectable && view.followSelectedPlayer,
+      // Following the selection can move the window, so keep our offset in step with what is drawn
+      onRow: (_row, index, y) => {
+        if (y === 1)
+          view.playerOffset = index;
+      },
+      onSelectRow: selectable ? (visibleRow) => {
+        const row = rows[view.playerOffset + visibleRow];
+        if (!row)
+          return;
+        view.selectedPlayerId = row.id === view.selectedPlayerId ? null : row.id;
+        ui.ctx.invalidate();
+      } : void 0,
+      scrollbar: true,
+      // Zebra stripes are solid fills, which would break transparency
+      zebra: !transparent,
+      size: "1fr",
+      onScroll: (delta) => {
+        view.playerOffset = Math.max(0, Math.min(maxOffset, view.playerOffset + delta));
+        view.followSelectedPlayer = false;
+        ui.ctx.invalidate();
+      },
+      columns: [
+        ...showNames ? [{ key: "displayName", title: "Name" }] : [],
+        { key: "id", title: "ID" },
+        { key: "x", title: "X", width: 9, align: "right", render: (p) => p.position.x.toFixed(2) },
+        { key: "y", title: "Y", width: 9, align: "right", render: (p) => p.position.y.toFixed(2) },
+        { key: "z", title: "Z", width: 9, align: "right", render: (p) => p.position.z.toFixed(2) },
+        { key: "lastProcessedSequenceId", title: "Seq", width: 10, align: "right" },
+        { key: "trackedEntities", title: "Tracked", width: 8, align: "right" }
+      ]
+    });
+  });
+}
+function formatTime(timestamp) {
+  const date = new Date(timestamp);
+  return [date.getHours(), date.getMinutes(), date.getSeconds()].map((n) => n.toString().padStart(2, "0")).join(":");
+}
+function toLogRows(lines) {
+  return lines.flatMap(({ timestamp, level, message }) => {
+    const parts = message.split(NEWLINE_RE);
+    while (parts.length > 1 && parts[0].trim() === "")
+      parts.shift();
+    while (parts.length > 1 && parts.at(-1).trim() === "")
+      parts.pop();
+    return parts.map((part, i) => i === 0 ? { time: formatTime(timestamp), level, message: part } : { message: `${" ".repeat(15)}${part}` });
+  });
+}
+function logsPanel(ui, theme, state, view) {
+  const rows = toLogRows(state.logs);
+  view.logFromEnd = Math.min(view.logFromEnd, Math.max(0, rows.length - 1));
+  const title = view.logFromEnd > 0 ? `Logs (scrolled back ${view.logFromEnd}, scroll down to follow)` : "Logs";
+  ui.panel({ title, size: "1fr" }, (panel) => {
+    if (state.logsAvailable === false) {
+      panel.label("Not available: the server runs a @mavonengine/core release without GET /api/game/logs, or has metrics.logBufferSize set to 0");
+      return;
+    }
+    if (rows.length === 0) {
+      panel.label("No log output yet");
+      return;
+    }
+    panel.log({
+      entries: rows,
+      fromEnd: view.logFromEnd,
+      scrollbar: true,
+      size: "1fr",
+      levelColors: {
+        VERBOSE: theme.muted,
+        SILLY: theme.muted,
+        HTTP: theme.info
+      },
+      onScroll: (delta) => {
+        view.logFromEnd = Math.max(0, Math.min(rows.length - 1, view.logFromEnd - delta * 3));
+        ui.ctx.invalidate();
+      }
+    });
+  });
+}
+function statusCodeColor(status, theme) {
+  if (status === null || status >= 500)
+    return theme.danger;
+  if (status >= 400)
+    return theme.warning;
+  if (status >= 300)
+    return theme.info;
+  return theme.success;
+}
+function requestsPanel(ui, theme, state, view, transparent) {
+  const rows = [...state.requests].reverse();
+  const anchor = view.requestTopId === null ? 0 : rows.findIndex((r) => r.id <= view.requestTopId);
+  const offset = Math.max(0, anchor);
+  const errors = rows.filter((r) => r.status === null || r.status >= 400).length;
+  const title = `HTTP requests (${rows.length}${errors ? `, ${errors} error${errors === 1 ? "" : "s"}` : ""})${offset > 0 ? ", scroll up to follow" : ""}`;
+  ui.panel({ title, size: "1fr" }, (panel) => {
+    if (state.requestsAvailable === false) {
+      panel.label("Not available: the server runs a @mavonengine/core release without GET /api/game/requests, or has metrics.requestLogSize set to 0");
+      return;
+    }
+    if (rows.length === 0) {
+      panel.label("No requests yet");
+      return;
+    }
+    panel.table({
+      rows,
+      offset,
+      scrollbar: true,
+      // Zebra stripes are solid fills, which would break transparency
+      zebra: !transparent,
+      size: "1fr",
+      // The table won't scroll past the last full page, so keep the anchor on the row it actually drew
+      onRow: (_row, index, y) => {
+        if (y === 1)
+          view.requestTopId = index === 0 ? null : rows[index].id;
+      },
+      onScroll: (delta) => {
+        const next = Math.max(0, Math.min(rows.length - 1, offset + delta));
+        view.requestTopId = next === 0 ? null : rows[next].id;
+        ui.ctx.invalidate();
+      },
+      columns: [
+        { key: "time", title: "Time", width: 8, color: theme.muted, render: (r) => formatTime(r.timestamp) },
+        { key: "method", title: "Method", width: 7, color: (r) => r.method === "WS" ? theme.primary : void 0 },
+        { key: "status", title: "Status", width: 6, align: "right", color: (r) => statusCodeColor(r.status, theme), render: (r) => r.status === null ? "\u2014" : String(r.status) },
+        { key: "durationMs", title: "Duration", width: 10, align: "right", render: (r) => formatMs(r.durationMs) },
+        { key: "bytes", title: "Size", width: 10, align: "right", render: (r) => formatBytes(r.bytes) },
+        { key: "address", title: "Client", width: 18, color: theme.muted, render: (r) => r.address ?? "\u2014" },
+        { key: "path", title: "Path" }
+      ]
+    });
+  });
+}
+
+// src/commands/dashboard.ts
+var DASHBOARD_HELP = `Usage: mavonengine dashboard [options]
+
+Live terminal dashboard for a running MavonEngine game server.
+
+Options:
+  --host <host>        Server host (default: localhost)
+  --port <port>        Server HTTP port (default: 8050)
+  --url <url>          Full metrics URL, overrides --host and --port
+  --token <token>      Metrics token (or set MAVONENGINE_METRICS_TOKEN)
+  --interval <ms>      Poll interval in ms (default: 1000)
+  --theme <name>       dark, dracula, nord, tokyoNight, gruvbox, matrix, light, \u2026
+  --transparent        Let a transparent terminal background show through
+                       (text can be hard to read over a light wallpaper)
+  --sim                Show simulated data instead of connecting to a server
+  -h, --help           Show this help
+`;
+var STARTUP_POLL_MS = 250;
+var UsageError = class extends Error {
+};
+function parseDashboardArgs(args, env = process2.env) {
+  const { values } = parseArgs({
+    args,
+    options: {
+      host: { type: "string", default: "localhost" },
+      port: { type: "string", default: "8050" },
+      url: { type: "string" },
+      token: { type: "string" },
+      interval: { type: "string", default: "1000" },
+      theme: { type: "string" },
+      transparent: { type: "boolean", default: false },
+      sim: { type: "boolean", default: false },
+      help: { type: "boolean", short: "h", default: false }
+    },
+    strict: true,
+    allowPositionals: false
+  });
+  if (values.help)
+    return "help";
+  const intervalMs = Number(values.interval);
+  if (!Number.isInteger(intervalMs) || intervalMs < 100)
+    throw new UsageError("--interval must be a whole number of ms, at least 100");
+  if (values.sim)
+    return { source: simulatedSource(), intervalMs, theme: values.theme, transparent: values.transparent };
+  let url = values.url;
+  if (!url) {
+    const port = Number(values.port);
+    if (!Number.isInteger(port) || port < 1 || port > 65535)
+      throw new UsageError("--port must be between 1 and 65535");
+    const host = values.host.includes(":") && !values.host.startsWith("[") ? `[${values.host}]` : values.host;
+    url = `http://${host}:${port}/api/game/metrics`;
+  }
+  try {
+    void new URL(url);
+  } catch {
+    throw new UsageError(`Invalid --url: ${url}`);
+  }
+  const token = values.token ?? env.MAVONENGINE_METRICS_TOKEN;
+  return { source: httpSource({ url, token }), clientUrl: new URL("/", url).href, intervalMs, theme: values.theme, transparent: values.transparent };
+}
+async function runDashboard(options, signal) {
+  const { createApp } = await import("@profullstack/hqtui");
+  const client = new MetricsClient(options.source, {
+    intervalMs: options.intervalMs,
+    startupIntervalMs: options.startup ? STARTUP_POLL_MS : void 0
+  });
+  const view = { tab: 0, playerOffset: 0, logFromEnd: 0, requestTopId: null, selectedPlayerId: null, followSelectedPlayer: true };
+  const app = await createApp({ fps: 15, theme: readableTheme(options.theme), paintBackground: !options.transparent });
+  app.render(({ ui, theme }) => renderDashboard(ui, theme, client.state, view, {
+    transparent: options.transparent,
+    startup: options.startup?.(),
+    openKey: !!options.clientUrl
+  }));
+  client.onChange(() => app.invalidate());
+  const { clientUrl } = options;
+  if (clientUrl && options.openBrowser) {
+    const off = client.onChange(async (state) => {
+      if (state.status !== "live")
+        return;
+      off();
+      if (await servesPage(clientUrl))
+        openBrowser(clientUrl);
+    });
+  }
+  app.on("key", (event) => {
+    if (event.key === "r")
+      void client.refresh();
+    if (event.key === "o" && options.clientUrl)
+      openBrowser(options.clientUrl);
+    const tab = tabForKey(event.key);
+    if (tab !== null) {
+      view.tab = tab;
+      app.invalidate();
+    }
+    if (handlePlayersKey(view, client.state.snapshot, event.key))
+      app.invalidate();
+  });
+  app.on("exit", () => client.stop());
+  const onAbort = () => app.stop();
+  signal?.addEventListener("abort", onAbort);
+  client.start();
+  if (!signal?.aborted)
+    await app.start();
+  signal?.removeEventListener("abort", onAbort);
+  client.stop();
+}
+
+// src/commands/dev.ts
+import { execFileSync, spawn as spawn2 } from "child_process";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { constants } from "os";
+import { dirname as dirname2, join as join2, resolve as resolve2 } from "path";
+import process3 from "process";
+import { setTimeout as delay } from "timers/promises";
+import { parseArgs as parseArgs2 } from "util";
+var DEV_HELP = `Usage: mavonengine dev [options]
+
+Run the dev servers of the MavonEngine project you are in (game server and client)
+and show the dashboard for it. Once the game server is up, the game opens in the
+browser. Quitting the dashboard stops the dev servers.
+
+Runs the project's 'dev:server' script, or its 'dev' script when there is none.
+So 'dev' can be 'mavonengine dev' itself, as in the multiplayer template.
+
+Options:
+  --cwd <dir>        Start looking for the project here (default: current directory)
+  --no-dashboard     Only run the dev script, with its output in the terminal
+  --port <port>      Game server HTTP port for the dashboard (default: 8050)
+  --theme <name>     Dashboard theme, see 'mavonengine dashboard --help'
+  --transparent      Let a transparent terminal background show through
+  --no-open          Don't open the game in the browser once the server is up
+  -h, --help         Show this help
+`;
+var MAX_CAPTURED_OUTPUT = 64 * 1024;
+var STOP_TIMEOUT_MS = 3e3;
+var KILL_TIMEOUT_MS = 2e3;
+var LOCKFILES = [
+  ["pnpm-lock.yaml", "pnpm"],
+  ["yarn.lock", "yarn"],
+  ["bun.lock", "bun"],
+  ["bun.lockb", "bun"],
+  ["package-lock.json", "npm"]
+];
+var WHITESPACE_RE = /\s+/;
+var RUNS_MAVONENGINE_DEV_RE = /\bmavonengine\s+dev\b/;
+var DEV_ENV_FLAG = "MAVONENGINE_DEV_SCRIPT";
+var DEV_SERVER_SCRIPT = "dev:server";
+var DEV_FLAGS = {
+  cwd: { type: "string" },
+  dashboard: { type: "boolean", default: true },
+  port: { type: "string" },
+  theme: { type: "string" },
+  transparent: { type: "boolean", default: false },
+  open: { type: "boolean", default: true },
+  help: { type: "boolean", short: "h", default: false }
+};
+function parseDevArgs(args, cwd = process3.cwd(), env = process3.env) {
+  const { values } = parseArgs2({
+    args,
+    options: DEV_FLAGS,
+    strict: true,
+    allowPositionals: false,
+    allowNegative: true
+  });
+  if (values.help)
+    return "help";
+  return toDevOptions(values, cwd, env);
+}
+function toDevOptions(values, cwd, env) {
+  let dashboard = false;
+  if (values.dashboard) {
+    const dashboardArgs = [
+      ...values.port ? ["--port", values.port] : [],
+      ...values.theme ? ["--theme", values.theme] : [],
+      ...values.transparent ? ["--transparent"] : []
+    ];
+    dashboard = parseDashboardArgs(dashboardArgs, env);
+    dashboard.openBrowser = values.open && canOpenBrowserHere(env);
+  }
+  return { cwd: resolve2(cwd, values.cwd ?? "."), dashboard };
+}
+function readPackageJson(dir) {
+  const path = join2(dir, "package.json");
+  if (!existsSync2(path))
+    return void 0;
+  try {
+    return JSON.parse(readFileSync2(path, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function devScriptOf(pkg) {
+  const scripts = pkg?.scripts ?? {};
+  if (typeof scripts[DEV_SERVER_SCRIPT] === "string")
+    return DEV_SERVER_SCRIPT;
+  return typeof scripts.dev === "string" ? "dev" : void 0;
+}
+function checkDevScript(root, env = process3.env) {
+  const pkg = readPackageJson(root);
+  const script = devScriptOf(pkg);
+  if (!script)
+    throw new UsageError(`${join2(root, "package.json")} has no '${DEV_SERVER_SCRIPT}' or 'dev' script`);
+  const command = String(pkg?.scripts?.[script] ?? "");
+  if (env[DEV_ENV_FLAG] || RUNS_MAVONENGINE_DEV_RE.test(command)) {
+    throw new UsageError(`the '${script}' script starts 'mavonengine dev' again. Put the command that starts the game server in a '${DEV_SERVER_SCRIPT}' script: 'mavonengine dev' runs that instead of 'dev'`);
+  }
+  return script;
+}
+function findProjectRoot(start) {
+  for (let dir = resolve2(start); ; dir = dirname2(dir)) {
+    const pkg = readPackageJson(dir);
+    const deps = { ...pkg?.dependencies, ...pkg?.devDependencies };
+    if ("@mavonengine/core" in deps && devScriptOf(pkg))
+      return dir;
+    if (dirname2(dir) === dir)
+      return void 0;
+  }
+}
+function installedEngineVersion(root) {
+  return readPackageJson(join2(root, "node_modules", "@mavonengine", "core"))?.version;
+}
+function detectPackageManager(root) {
+  return LOCKFILES.find(([file]) => existsSync2(join2(root, file)))?.[1] ?? "npm";
+}
+function descendants(root, psOutput) {
+  const children = /* @__PURE__ */ new Map();
+  for (const line of psOutput.trim().split("\n")) {
+    const [pid, ppid] = line.trim().split(WHITESPACE_RE).map(Number);
+    if (!children.has(ppid))
+      children.set(ppid, []);
+    children.get(ppid).push(pid);
+  }
+  const found = [];
+  const queue = [root];
+  while (queue.length) {
+    for (const child of children.get(queue.shift()) ?? []) {
+      found.push(child);
+      queue.push(child);
+    }
+  }
+  return found;
+}
+function processTree(pid) {
+  if (process3.platform === "win32")
+    return [];
+  try {
+    return [pid, ...descendants(pid, execFileSync("ps", ["-A", "-o", "pid=,ppid="], { encoding: "utf8" }))];
+  } catch {
+    return [pid];
+  }
+}
+function signalAll(pids, signal) {
+  for (const p of pids) {
+    try {
+      process3.kill(p, signal);
+    } catch {
+    }
+  }
+}
+function isAlive(pid) {
+  try {
+    process3.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function waitForExit(pids, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (pids.some(isAlive) && Date.now() < deadline)
+    await delay(50);
+}
+function killTree(pid, signal) {
+  if (process3.platform === "win32") {
+    try {
+      execFileSync("taskkill", ["/pid", String(pid), "/T", "/F"], { stdio: "ignore" });
+    } catch {
+    }
+    return;
+  }
+  signalAll(processTree(pid), signal);
+}
+function startDev(root, { capture = false } = {}) {
+  const pm = detectPackageManager(root);
+  const script = checkDevScript(root);
+  const child = spawn2(pm, ["run", script], {
+    cwd: root,
+    env: { ...process3.env, [DEV_ENV_FLAG]: "1" },
+    stdio: capture ? ["ignore", "pipe", "pipe"] : "inherit",
+    // npm, pnpm and yarn are .cmd shims on Windows
+    shell: process3.platform === "win32"
+  });
+  let output = "";
+  const keep = (chunk) => {
+    output = (output + chunk).slice(-MAX_CAPTURED_OUTPUT);
+  };
+  const announce = `mavonengine: running '${pm} run ${script}' in ${root}
+`;
+  if (capture)
+    keep(announce);
+  else
+    process3.stdout.write(announce);
+  child.stdout?.setEncoding("utf8").on("data", keep);
+  child.stderr?.setEncoding("utf8").on("data", keep);
+  let running = true;
+  const onInterrupt = () => {
+  };
+  const forward = (signal) => child.pid && killTree(child.pid, signal);
+  const onExit = () => running && child.pid && killTree(child.pid, "SIGTERM");
+  process3.on("SIGINT", onInterrupt);
+  process3.on("SIGTERM", forward);
+  process3.on("SIGHUP", forward);
+  process3.on("exit", onExit);
+  const exited = new Promise((resolvePromise, reject) => {
+    const cleanup = () => {
+      running = false;
+      process3.off("SIGINT", onInterrupt);
+      process3.off("SIGTERM", forward);
+      process3.off("SIGHUP", forward);
+      process3.off("exit", onExit);
+    };
+    child.on("error", (err) => {
+      cleanup();
+      reject(err.code === "ENOENT" ? new Error(`'${pm}' was not found on your PATH`) : err);
+    });
+    child.on("exit", (code, signal) => {
+      cleanup();
+      resolvePromise(code ?? 128 + (signal ? constants.signals[signal] : 0));
+    });
+  });
+  const stop = async () => {
+    if (running && child.pid) {
+      if (process3.platform === "win32") {
+        killTree(child.pid, "SIGTERM");
+      } else {
+        const tree = processTree(child.pid);
+        signalAll(tree, "SIGTERM");
+        await waitForExit(tree, STOP_TIMEOUT_MS);
+        signalAll(tree.filter(isAlive), "SIGKILL");
+        await waitForExit(tree, KILL_TIMEOUT_MS);
+      }
+    }
+    return exited;
+  };
+  return { exited, stop, output: () => output };
+}
+function runDev(root) {
+  return startDev(root).exited;
+}
+async function runDevWithDashboard(root, dashboard) {
+  const dev = startDev(root, { capture: true });
+  const engineVersion = installedEngineVersion(root);
+  const startup = () => ({ engineVersion, output: dev.output() });
+  const devExited = new AbortController();
+  dev.exited.then(() => devExited.abort(), () => devExited.abort());
+  let quit = false;
+  try {
+    await runDashboard({ ...dashboard, startup }, devExited.signal);
+  } finally {
+    quit = !devExited.signal.aborted;
+    if (quit)
+      await dev.stop().catch(() => {
+      });
+  }
+  if (quit)
+    return 0;
+  const exitCode = await dev.exited;
+  process3.stderr.write(`${dev.output()}
+mavonengine: the dev script exited with code ${exitCode}
+`);
+  return exitCode;
+}
+async function runDevCommand(options) {
+  const root = findProjectRoot(options.cwd);
+  if (!root)
+    throw new UsageError(`no MavonEngine project found in ${options.cwd} or its parents (looking for a package.json with @mavonengine/core and a dev script)`);
+  checkDevScript(root);
+  if (options.dashboard && process3.stdout.isTTY && process3.stdin.isTTY)
+    return runDevWithDashboard(root, options.dashboard);
+  return runDev(root);
+}
+
+// src/commands/build.ts
+var BUILD_HELP = `Usage: mavonengine build [options]
+
+Build the MavonEngine project you are in for release by running its build script.
+Plugin assets go into the client's output under plugins/<package>/: the shared
+ones, and those of the prefabs listed in ${CONFIG_FILE}. The others are left out.
+
+Options:
+  --cwd <dir>        Start looking for the project here (default: current directory)
+  -h, --help         Show this help
+`;
+function parseBuildArgs(args, cwd = process4.cwd()) {
+  const { values } = parseArgs3({
+    args,
+    options: {
+      cwd: { type: "string" },
+      help: { type: "boolean", short: "h", default: false }
+    },
+    strict: true,
+    allowPositionals: false
+  });
+  if (values.help)
+    return "help";
+  return { cwd: resolve3(cwd, values.cwd ?? ".") };
+}
+function summarizeReleaseAssets(root, assets, warnings) {
+  const plugins = readConfig(root).plugins;
+  const enabled = Object.entries(plugins).filter(([, entry]) => entry?.enabled !== false);
+  if (enabled.length === 0)
+    return "";
+  const lines = [`
+Plugins in ${CONFIG_FILE}:`];
+  for (const [pkg, entry] of enabled) {
+    const count = assets.filter((a) => a.package === pkg).length;
+    const prefabs = entry?.prefabs?.length ? `, prefabs: ${entry.prefabs.join(", ")}` : "";
+    lines.push(`  ${pkg}: ${count} asset${count === 1 ? "" : "s"}${prefabs}`);
+  }
+  for (const warning of warnings)
+    lines.push(`  warning: ${warning}`);
+  return `${lines.join("\n")}
+`;
+}
+function run(command, args, cwd) {
+  return new Promise((resolvePromise, reject) => {
+    const child = spawn3(command, args, { cwd, stdio: "inherit", shell: process4.platform === "win32" });
+    child.on("error", (err) => {
+      reject(err.code === "ENOENT" ? new Error(`'${command}' was not found on your PATH`) : err);
+    });
+    child.on("exit", (code) => resolvePromise(code ?? 1));
+  });
+}
+async function runBuildCommand(options) {
+  const root = findProjectRoot(options.cwd);
+  if (!root)
+    throw new UsageError(`no MavonEngine project found in ${options.cwd} or its parents (looking for a package.json with @mavonengine/core and a dev script)`);
+  const pkg = JSON.parse(readFileSync3(join3(root, "package.json"), "utf8"));
+  if (typeof pkg.scripts?.build !== "string")
+    throw new UsageError(`${join3(root, "package.json")} has no build script`);
+  const pm = detectPackageManager(root);
+  process4.stdout.write(`mavonengine: running '${pm} run build' in ${root}
+`);
+  const code = await run(pm, ["run", "build"], root);
+  if (code !== 0) {
+    process4.stderr.write(`mavonengine: the build script exited with code ${code}
+`);
+    return code;
+  }
+  if (existsSync3(join3(root, CONFIG_FILE))) {
+    const { assets, warnings } = releaseAssets(root);
+    process4.stdout.write(summarizeReleaseAssets(root, assets, warnings));
+  }
+  return 0;
+}
+
+// src/commands/create.ts
+import { existsSync as existsSync5 } from "fs";
+import process6 from "process";
+import { createInterface } from "readline/promises";
+import { parseArgs as parseArgs4 } from "util";
+
+// src/create/project.ts
+import { spawn as spawn4 } from "child_process";
+import { createWriteStream, existsSync as existsSync4, mkdirSync, readFileSync as readFileSync4, rmSync, writeFileSync as writeFileSync2 } from "fs";
+import { tmpdir } from "os";
+import { dirname as dirname3, isAbsolute as isAbsolute2, join as join4, relative as relative2, resolve as resolve4 } from "path";
+import process5 from "process";
+import { Readable, Transform } from "stream";
+import { pipeline } from "stream/promises";
+import AdmZip from "adm-zip";
+var TEMPLATE_URL = "https://github.com/MavonEngine/Core/archive/refs/tags/0.0.16-alpha.zip";
+var TEMPLATE_SUBPATH = "packages/multiplayer-template";
+var PROJECT_NAME_RE = /^[\w@./-][\w@./\- ]*$/;
+function projectDirFor(projectName, parentDir) {
+  return resolve4(parentDir, projectName);
+}
+async function downloadZip(url, { report, signal, fetch = globalThis.fetch }) {
+  const response = await fetch(url, { signal });
+  if (!response.ok || !response.body)
+    throw new Error(`Failed to download ${url}: ${response.status} ${response.statusText}`);
+  const total = Number(response.headers.get("content-length")) || 0;
+  let received = 0;
+  const progress = new Transform({
+    transform(chunk, _encoding, callback) {
+      received += chunk.length;
+      report.step(`Downloading the template\u2026 ${formatBytes(received)}${total ? ` of ${formatBytes(total)}` : ""}`);
+      callback(null, chunk);
+    }
+  });
+  const dest = join4(tmpdir(), `mavonengine-create-${process5.pid}-${Date.now()}.zip`);
+  try {
+    await pipeline(Readable.fromWeb(response.body), progress, createWriteStream(dest), { signal });
+  } catch (err) {
+    rmSync(dest, { force: true });
+    throw err;
+  }
+  return dest;
+}
+function extractTemplate(zipPath, templateSubpath, destDir) {
+  const entries = new AdmZip(zipPath).getEntries();
+  if (entries.length === 0)
+    throw new Error("Downloaded zip archive is empty");
+  const rootFolder = entries[0].entryName.split("/")[0];
+  const templatePrefix = `${rootFolder}/${templateSubpath}/`;
+  const templateEntries = entries.filter((e) => e.entryName.startsWith(templatePrefix));
+  if (templateEntries.length === 0)
+    throw new Error(`Template path "${templateSubpath}" not found in zip archive (root: ${rootFolder})`);
+  const root = resolve4(destDir);
+  let files = 0;
+  for (const entry of templateEntries) {
+    const relativePath = entry.entryName.slice(templatePrefix.length);
+    if (!relativePath)
+      continue;
+    const outputPath = resolve4(root, relativePath);
+    const inside = relative2(root, outputPath);
+    if (inside.startsWith("..") || isAbsolute2(inside))
+      throw new Error(`Refusing to extract ${entry.entryName} outside the project`);
+    if (entry.isDirectory) {
+      mkdirSync(outputPath, { recursive: true });
+    } else {
+      mkdirSync(dirname3(outputPath), { recursive: true });
+      writeFileSync2(outputPath, entry.getData());
+      files++;
+    }
+  }
+  return files;
+}
+function runCommand(command, args, cwd, { report, signal }) {
+  return new Promise((resolvePromise, reject) => {
+    const child = spawn4(command, args, {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      // npm is a .cmd shim on Windows
+      shell: process5.platform === "win32",
+      signal
+    });
+    child.stdout.setEncoding("utf8").on("data", report.output);
+    child.stderr.setEncoding("utf8").on("data", report.output);
+    child.on("error", (err) => {
+      reject(err.code === "ENOENT" ? new Error(`'${command}' was not found on your PATH`) : err);
+    });
+    child.on("exit", (code, exitSignal) => {
+      if (code === 0)
+        resolvePromise();
+      else
+        reject(new Error(`'${command} ${args.join(" ")}' ${code === null ? `was stopped by ${exitSignal}` : `exited with code ${code}`}`));
+    });
+  });
+}
+async function createProject({ projectName, parentDir, report, signal, templateUrl = TEMPLATE_URL, fetch, install = true }) {
+  const projectDir = projectDirFor(projectName, parentDir);
+  if (existsSync4(projectDir))
+    throw new Error(`Directory "${projectDir}" already exists`);
+  report.output(`Creating project "${projectName}" in ${projectDir}
+`);
+  mkdirSync(projectDir, { recursive: true });
+  report.step("Downloading the template\u2026");
+  report.output(`Downloading the template from ${templateUrl}
+`);
+  const zipPath = await downloadZip(templateUrl, { report, signal, fetch });
+  try {
+    report.step("Extracting the template\u2026");
+    const files = extractTemplate(zipPath, TEMPLATE_SUBPATH, projectDir);
+    report.output(`Extracted ${files} files
+`);
+  } finally {
+    rmSync(zipPath, { force: true });
+  }
+  const pkgJsonPath = join4(projectDir, "package.json");
+  if (existsSync4(pkgJsonPath)) {
+    const pkg = JSON.parse(readFileSync4(pkgJsonPath, "utf-8"));
+    pkg.name = projectName;
+    writeFileSync2(pkgJsonPath, `${JSON.stringify(pkg, null, 2)}
+`);
+  }
+  if (writeMcpConfig(projectDir))
+    report.output(`Wrote ${MCP_CONFIG_FILE} so AI assistants with MCP support can inspect the running game server
+`);
+  if (install) {
+    signal?.throwIfAborted();
+    report.step("Installing dependencies\u2026");
+    report.output("Running 'npm install'\n");
+    await runCommand("npm", ["install"], projectDir, { report, signal });
+  }
+  return projectDir;
+}
+
+// src/commands/create.ts
+var CREATE_HELP = `Usage: mavonengine create [name] [options]
+
+Create a MavonEngine project from the multiplayer template, install its
+dependencies and start it like 'mavonengine dev'. Asks for a name if none is given.
+
+Options:
+  --cwd <dir>        Create the project in here (default: current directory)
+  --no-dashboard     Print the progress and the dev script's output instead
+  --port <port>      Game server HTTP port for the dashboard (default: 8050)
+  --theme <name>     Dashboard theme, see 'mavonengine dashboard --help'
+  --transparent      Let a transparent terminal background show through
+  --no-open          Don't open the game in the browser once the server is up
+  -h, --help         Show this help
+`;
+var MAX_SETUP_OUTPUT = 64 * 1024;
+function parseCreateArgs(args, cwd = process6.cwd(), env = process6.env) {
+  const { values, positionals } = parseArgs4({
+    args,
+    options: DEV_FLAGS,
+    strict: true,
+    allowPositionals: true,
+    allowNegative: true
+  });
+  if (values.help)
+    return "help";
+  if (positionals.length > 1)
+    throw new UsageError(`expected one project name, got ${positionals.length}`);
+  const projectName = positionals[0]?.trim() || void 0;
+  if (projectName)
+    checkProjectName(projectName);
+  return { ...toDevOptions(values, cwd, env), projectName };
+}
+function checkProjectName(name) {
+  if (!PROJECT_NAME_RE.test(name))
+    throw new UsageError(`invalid project name '${name}'`);
+}
+async function promptProjectName() {
+  const rl = createInterface({ input: process6.stdin, output: process6.stdout });
+  try {
+    return (await rl.question("Project name: ")).trim();
+  } finally {
+    rl.close();
+  }
+}
+function gatedSource(source, ready) {
+  return {
+    ...source,
+    fetch: () => ready() ? source.fetch() : Promise.reject(new MetricsSourceError("Creating the project", "connecting"))
+  };
+}
+async function runCreateWithDashboard(projectName, parentDir, dashboard) {
+  let label = "Creating the project\u2026";
+  let output = "";
+  let engineVersion;
+  let dev;
+  const report = {
+    step: (text) => {
+      label = text;
+    },
+    output: (chunk) => {
+      output = (output + chunk).slice(-MAX_SETUP_OUTPUT);
+    }
+  };
+  const setup = new AbortController();
+  const done = new AbortController();
+  const work = (async () => {
+    const dir = await createProject({ projectName, parentDir, report, signal: setup.signal });
+    setup.signal.throwIfAborted();
+    engineVersion = installedEngineVersion(dir);
+    label = "Starting the game server\u2026";
+    dev = startDev(dir, { capture: true });
+    return dev.exited;
+  })();
+  work.then(() => done.abort(), () => done.abort());
+  const startup = () => dev ? { engineVersion, output: dev.output() } : { engineVersion, label, output, outputTitle: "Setup" };
+  let quit = false;
+  try {
+    await runDashboard({ ...dashboard, source: gatedSource(dashboard.source, () => dev !== void 0), startup }, done.signal);
+  } finally {
+    quit = !done.signal.aborted;
+    if (quit) {
+      setup.abort();
+      await dev?.stop().catch(() => {
+      });
+    }
+  }
+  if (quit) {
+    if (dev)
+      return 0;
+    await work.catch(() => {
+    });
+    process6.stderr.write(`mavonengine: stopped creating the project, what was set up so far is in ${projectDirFor(projectName, parentDir)}
+`);
+    return 130;
+  }
+  try {
+    const exitCode = await work;
+    process6.stderr.write(`${dev.output()}
+mavonengine: the dev script exited with code ${exitCode}
+`);
+    return exitCode;
+  } catch (err) {
+    process6.stderr.write(output);
+    throw err;
+  }
+}
+async function runCreatePlain(projectName, parentDir) {
+  const report = {
+    step: () => {
+    },
+    output: (chunk) => process6.stdout.write(chunk)
+  };
+  const dir = await createProject({ projectName, parentDir, report });
+  process6.stdout.write(`
+mavonengine: your project is ready at ${dir}
+`);
+  return runDev(dir);
+}
+async function runCreateCommand(options) {
+  const interactive = !!process6.stdout.isTTY && !!process6.stdin.isTTY;
+  let projectName = options.projectName;
+  if (!projectName) {
+    if (!interactive)
+      throw new UsageError("a project name is required, e.g. mavonengine create my-game");
+    projectName = await promptProjectName();
+    if (!projectName)
+      throw new UsageError("a project name is required");
+    checkProjectName(projectName);
+  }
+  const dir = projectDirFor(projectName, options.cwd);
+  if (existsSync5(dir))
+    throw new UsageError(`${dir} already exists`);
+  if (options.dashboard && interactive)
+    return runCreateWithDashboard(projectName, options.cwd, options.dashboard);
+  return runCreatePlain(projectName, options.cwd);
+}
+
+// src/commands/install.ts
+import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
+import { join as join5, resolve as resolve5 } from "path";
+import process7 from "process";
+import { createInterface as createInterface2 } from "readline/promises";
+import { parseArgs as parseArgs5 } from "util";
+var INSTALL_HELP = `Usage: mavonengine install <package...> [options]
+
+Install packages into the MavonEngine project you are in. For each one that is a
+MavonEngine plugin, asks whether to add it to the plugins in ${CONFIG_FILE}, so it
+loads on the client and/or the game server and is built into the release.
+
+Takes anything your package manager does: names, name@version, file: paths, git URLs.
+
+Options:
+  --cwd <dir>        Start looking for the project here (default: current directory)
+  -y, --yes          Add plugins to ${CONFIG_FILE} without asking
+  --no-register      Only install, leave ${CONFIG_FILE} alone
+  -h, --help         Show this help
+`;
+var PACKAGE_SPEC_RE = /^((?:@[\w.-]+\/)?[\w.-]+)(?:@.*)?$/;
+var LOCAL_PATH_RE = /^(?:\.{1,2}(?:[/\\]|$)|[/~]|[a-z]:[/\\])/i;
+var TARGET_LABELS = {
+  client: "client only",
+  server: "server only",
+  both: "client + server"
+};
+function parseInstallArgs(args, cwd = process7.cwd()) {
+  const { values, positionals } = parseArgs5({
+    args,
+    options: {
+      cwd: { type: "string" },
+      yes: { type: "boolean", short: "y", default: false },
+      register: { type: "boolean", default: true },
+      help: { type: "boolean", short: "h", default: false }
+    },
+    strict: true,
+    allowPositionals: true,
+    allowNegative: true
+  });
+  if (values.help)
+    return "help";
+  if (positionals.length === 0)
+    throw new UsageError(`which package? e.g. mavonengine install my-plugin
+
+${INSTALL_HELP}`);
+  return { cwd: resolve5(cwd, values.cwd ?? "."), packages: positionals, yes: values.yes, register: values.register };
+}
+function packageNameFromSpec(spec, root) {
+  const localPath = spec.startsWith("file:") ? spec.slice("file:".length) : LOCAL_PATH_RE.test(spec) ? spec : void 0;
+  if (localPath !== void 0) {
+    const packageJson = join5(resolve5(root, localPath), "package.json");
+    try {
+      return existsSync6(packageJson) ? JSON.parse(readFileSync5(packageJson, "utf8")).name : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  if (spec.includes(":") || spec.endsWith(".tgz"))
+    return void 0;
+  return PACKAGE_SPEC_RE.exec(spec)?.[1];
+}
+function installArgs(pm, packages) {
+  return [pm === "npm" ? "install" : "add", ...packages];
+}
+function dependencyNames(root) {
+  const path = join5(root, "package.json");
+  if (!existsSync6(path))
+    return /* @__PURE__ */ new Map();
+  const pkg = JSON.parse(readFileSync5(path, "utf8"));
+  return new Map(Object.entries({ ...pkg.devDependencies, ...pkg.dependencies }));
+}
+function installedNames(specs, root, before, after) {
+  const names = specs.map((spec) => packageNameFromSpec(spec, root)).filter((name) => !!name);
+  for (const [name, version2] of after) {
+    if (before.get(name) !== version2)
+      names.push(name);
+  }
+  return [...new Set(names)];
+}
+function describePlugin(plugin, engineVersion) {
+  const { manifest } = plugin;
+  const lines = [`${plugin.package}${plugin.version ? `@${plugin.version}` : ""} is a MavonEngine plugin (${TARGET_LABELS[manifest.target]})`];
+  const prefabs = Object.keys(manifest.assets?.prefabs ?? {});
+  if (prefabs.length)
+    lines.push(`  Prefabs: ${prefabs.join(", ")}. Their assets ship in the release once you place them in the editor`);
+  if (manifest.engine)
+    lines.push(`  Made for @mavonengine/core ${manifest.engine}${engineVersion ? `, you have ${engineVersion}` : ""}`);
+  return `${lines.join("\n")}
+`;
+}
+function confirmOnTerminal(question) {
+  const rl = createInterface2({ input: process7.stdin, output: process7.stdout });
+  return rl.question(question).then((answer) => ["", "y", "yes"].includes(answer.trim().toLowerCase())).finally(() => rl.close());
+}
+var terminalIO = {
+  run: (command, args, cwd) => runCommand(command, args, cwd, {
+    report: { step: () => {
+    }, output: (chunk) => process7.stdout.write(chunk) }
+  }),
+  confirm: confirmOnTerminal,
+  get interactive() {
+    return !!process7.stdin.isTTY && !!process7.stdout.isTTY;
+  },
+  write: (text) => process7.stdout.write(text)
+};
+async function runInstallCommand(options, io = terminalIO) {
+  const root = findProjectRoot(options.cwd);
+  if (!root)
+    throw new UsageError(`no MavonEngine project found in ${options.cwd} or its parents (looking for a package.json with @mavonengine/core and a dev script)`);
+  const config = readConfig(root);
+  const pm = detectPackageManager(root);
+  const args = installArgs(pm, options.packages);
+  const before = dependencyNames(root);
+  io.write(`mavonengine: running '${pm} ${args.join(" ")}' in ${root}
+`);
+  await io.run(pm, args, root);
+  const engineVersion = installedEngineVersion(root);
+  let failed = false;
+  const names = installedNames(options.packages, root, before, dependencyNames(root));
+  if (names.length === 0)
+    io.write(`
+mavonengine: couldn't tell which packages were installed. If one is a plugin, run 'mavonengine install <its name>' to register it
+`);
+  for (const name of names) {
+    let plugin;
+    try {
+      plugin = readPluginManifest(root, name);
+    } catch (err) {
+      io.write(`
+mavonengine: ${err.message}
+`);
+      failed = true;
+      continue;
+    }
+    if (!plugin) {
+      io.write(`
+${name} is installed. It is not a MavonEngine plugin (no "mavonengine" field in its package.json), so ${CONFIG_FILE} is left alone
+`);
+      continue;
+    }
+    io.write(`
+${describePlugin(plugin, engineVersion)}`);
+    const entry = config.plugins[name];
+    if (entry && entry.enabled !== false) {
+      io.write(`  Already in ${CONFIG_FILE}
+`);
+      continue;
+    }
+    if (!options.register)
+      continue;
+    if (!options.yes && !io.interactive) {
+      io.write(`  Not added to ${CONFIG_FILE}: run with --yes, or add "${name}": { "enabled": true } to its "plugins"
+`);
+      continue;
+    }
+    if (!options.yes && !await io.confirm(`Add ${name} to the plugins in ${CONFIG_FILE}? (Y/n) `)) {
+      io.write(`  Not added. Add "${name}": { "enabled": true } to "plugins" in ${CONFIG_FILE} to use it later
+`);
+      continue;
+    }
+    addPluginToConfig(root, name);
+    io.write(`  Added to ${join5(root, CONFIG_FILE)}
+`);
+    if (plugin.manifest.target !== "client")
+      io.write(`  Restart the game server ('mavonengine dev') to load it there
+`);
+  }
+  return failed ? 1 : 0;
+}
+
+// src/commands/mcp.ts
+import process8 from "process";
+import { parseArgs as parseArgs6 } from "util";
+
+// src/mcp/GameServerClient.ts
+var GameServerError = class extends Error {
+};
+var DEV_UNAVAILABLE = "The dev endpoints are not available: the game server runs with NODE_ENV=production (they are never served there), or it uses a @mavonengine/core release without them";
+var GameServerClient = class {
+  url;
+  clientUrl;
+  base;
+  clientBase;
+  token;
+  timeoutMs;
+  fetchImpl;
+  constructor({ url, clientUrl, token, timeoutMs = 3e3, fetch = globalThis.fetch }) {
+    this.base = new URL(url.endsWith("/") ? url : `${url}/`);
+    this.url = this.base.href;
+    this.clientBase = clientUrl ? new URL(clientUrl.endsWith("/") ? clientUrl : `${clientUrl}/`) : this.base;
+    this.clientUrl = this.clientBase.href;
+    this.token = token;
+    this.timeoutMs = timeoutMs;
+    this.fetchImpl = fetch;
+  }
+  health() {
+    return this.get("api/game/health");
+  }
+  metrics() {
+    return this.get("api/game/metrics");
+  }
+  logs(afterId = 0) {
+    return this.get("api/game/logs", { after: String(afterId) }, "The server does not keep logs (metrics.logBufferSize is 0)");
+  }
+  requests(afterId = 0) {
+    return this.get("api/game/requests", { after: String(afterId) }, "The server does not record requests (metrics.requestLogSize is 0)");
+  }
+  scene() {
+    return this.get("api/game/dev/scene", {}, DEV_UNAVAILABLE);
+  }
+  entities(query = {}) {
+    const params = {};
+    if (query.type)
+      params.type = query.type;
+    if (query.near)
+      params.near = `${query.near.x},${query.near.y},${query.near.z}`;
+    for (const key of ["radius", "limit", "offset"]) {
+      if (query[key] !== void 0)
+        params[key] = String(query[key]);
+    }
+    return this.get("api/game/dev/entities", params, DEV_UNAVAILABLE);
+  }
+  entity(id) {
+    return this.get(`api/game/dev/entities/${encodeURIComponent(id)}`, {}, DEV_UNAVAILABLE);
+  }
+  /** The game tabs open in a browser, through the dev bridge */
+  clients() {
+    return this.bridge("__mavonengine/clients", {});
+  }
+  /**
+   * Ask one tab. `clientId` defaults to the only open tab (or the only one not running the editor)
+   */
+  client(query, params = {}, clientId = "auto") {
+    const defined = Object.fromEntries(Object.entries(params).filter(([, v]) => v !== void 0).map(([k, v]) => [k, String(v)]));
+    const timeoutMs = query === "trace" ? Number(params.durationMs ?? 3e3) + 15e3 : query === "screenshot" ? 15e3 : query === "status" ? 1e4 : 8e3;
+    return this.bridge(`__mavonengine/clients/${encodeURIComponent(clientId)}/${query}`, defined, timeoutMs);
+  }
+  async bridge(path, params, timeoutMs = 5e3) {
+    const target = new URL(path, this.clientBase);
+    for (const [key, value] of Object.entries(params))
+      target.searchParams.set(key, value);
+    let res;
+    try {
+      res = await this.fetchImpl(target, {
+        headers: this.token ? { Authorization: `Bearer ${this.token}` } : {},
+        signal: AbortSignal.timeout(timeoutMs)
+      });
+    } catch (err) {
+      throw new GameServerError(`Can't reach the client dev server at ${this.clientUrl}: ${err.message}. Is it running?`);
+    }
+    const isJson = res.headers.get("content-type")?.includes("application/json");
+    const body = isJson ? await res.json().catch(() => null) : null;
+    if (!isJson || res.status === 404 && !body?.error) {
+      throw new GameServerError(`No dev bridge at ${this.clientUrl}. The game client must be served by Vite in dev with the mavonengine Vite plugin (@mavonengine/core/vite.config). If Vite runs on its own port, pass --client-url, e.g. http://localhost:5173`);
+    }
+    if (res.status === 401 || res.status === 403)
+      throw new GameServerError(`${body?.error ?? "Not allowed"}: pass --token or set MAVONENGINE_METRICS_TOKEN for both the CLI and the dev server`);
+    if (!res.ok)
+      throw new GameServerError(body?.error ?? `Client dev server responded ${res.status} ${res.statusText}`);
+    return body;
+  }
+  async get(path, params = {}, notFound) {
+    const target = new URL(path, this.base);
+    for (const [key, value] of Object.entries(params))
+      target.searchParams.set(key, value);
+    let res;
+    try {
+      res = await this.fetchImpl(target, {
+        headers: this.token ? { Authorization: `Bearer ${this.token}` } : {},
+        signal: AbortSignal.timeout(this.timeoutMs)
+      });
+    } catch (err) {
+      throw new GameServerError(`Can't reach the game server at ${this.url}: ${err.message}. Is it running?`);
+    }
+    if (res.status === 401)
+      throw new GameServerError("Metrics token missing or wrong: pass --token or set MAVONENGINE_METRICS_TOKEN");
+    if (res.status === 403)
+      throw new GameServerError("The game server only answers localhost without a token: pass --token or set MAVONENGINE_METRICS_TOKEN");
+    if (res.status === 404)
+      throw new GameServerError(notFound ?? "Metrics endpoints not found: they are turned off in the server options, or it runs in production without a metrics token");
+    if (res.status === 400)
+      throw new GameServerError(`Bad request: ${(await res.json().catch(() => null))?.error ?? res.statusText}`);
+    if (!res.ok)
+      throw new GameServerError(`Game server responded ${res.status} ${res.statusText}`);
+    return res.json();
+  }
+};
+
+// src/commands/mcp.ts
+var MCP_HELP = `Usage: mavonengine mcp [options]
+
+Model Context Protocol (MCP) server over stdio, for any MCP client and model
+(Claude Code, Cursor, VS Code, Codex, Gemini CLI, Zed, local models, \u2026).
+It lets the assistant read a running game: the game server (status, metrics,
+players, scene, entities, logs, HTTP requests) and the game tabs open in a
+browser (renderer stats, entities, network, console, screenshots), and compare
+an entity on both sides. Every tool is read-only. Server scene and entity tools
+need the game server in development (NODE_ENV is not "production"); client
+tools need the client served by Vite in dev.
+
+Register it in your client as a stdio server with this command:
+  npx -y @mavonengine/cli mcp [options]
+
+Most clients take JSON like this (projects from 'mavonengine create' get it in .mcp.json):
+  { "mcpServers": { "mavonengine": { "command": "npx", "args": ["-y", "@mavonengine/cli", "mcp"] } } }
+
+Options:
+  --host <host>        Server host (default: localhost)
+  --port <port>        Server HTTP port (default: 8050)
+  --url <url>          Server base URL, e.g. http://localhost:8050, overrides --host and --port
+  --client-url <url>   Where Vite serves the client in dev (default: the server URL,
+                       which serves it in the template), e.g. http://localhost:5173
+  --token <token>      Metrics token (or set MAVONENGINE_METRICS_TOKEN)
+  --docs-url <url>     MCP server of the documentation for the docs_* tools
+                       (default: https://mavonengine.com/mcp)
+  --no-docs            Leave out the docs_* tools, e.g. offline
+  -h, --help           Show this help
+`;
+function parseMcpArgs(args, env = process8.env) {
+  const { values } = parseArgs6({
+    args,
+    options: {
+      "host": { type: "string", default: "localhost" },
+      "port": { type: "string", default: "8050" },
+      "url": { type: "string" },
+      "client-url": { type: "string" },
+      "token": { type: "string" },
+      "docs-url": { type: "string" },
+      "docs": { type: "boolean", default: true },
+      "help": { type: "boolean", short: "h", default: false }
+    },
+    strict: true,
+    allowPositionals: false,
+    allowNegative: true
+  });
+  if (values.help)
+    return "help";
+  let url = values.url;
+  if (!url) {
+    const port = Number(values.port);
+    if (!Number.isInteger(port) || port < 1 || port > 65535)
+      throw new UsageError("--port must be between 1 and 65535");
+    const host = values.host.includes(":") && !values.host.startsWith("[") ? `[${values.host}]` : values.host;
+    url = `http://${host}:${port}`;
+  }
+  for (const [flag, value] of [["--url", url], ["--client-url", values["client-url"]], ["--docs-url", values["docs-url"]]]) {
+    try {
+      if (value !== void 0)
+        void new URL(value);
+    } catch {
+      throw new UsageError(`Invalid ${flag}: ${value}`);
+    }
+  }
+  return {
+    client: new GameServerClient({ url, clientUrl: values["client-url"], token: values.token ?? env.MAVONENGINE_METRICS_TOKEN }),
+    docsUrl: values.docs ? values["docs-url"] ?? DEFAULT_DOCS_URL : false
+  };
+}
+async function runMcpCommand({ client, docsUrl }) {
+  const [{ StdioServerTransport }, { createMcpServer }, { DocsClient }] = await Promise.all([
+    import("@modelcontextprotocol/sdk/server/stdio.js"),
+    import("./server-35RY6IGC.js"),
+    import("./docs-4C7X6FUQ.js")
+  ]);
+  const docs = docsUrl ? new DocsClient(docsUrl) : void 0;
+  const server = createMcpServer(client, docs);
+  const transport = new StdioServerTransport();
+  const closed = new Promise((resolve6) => {
+    transport.onclose = resolve6;
+    process8.stdin.on("end", resolve6);
+  });
+  await server.connect(transport);
+  process8.stderr.write(`mavonengine mcp: reading the game server at ${client.url}
+`);
+  await closed;
+  await server.close().catch(() => {
+  });
+  await docs?.close();
+  return 0;
+}
+
+// src/index.ts
+var HELP = `Usage: mavonengine <command> [options]
+
+Commands:
+  create       Create a project from the multiplayer template and start it
+  dashboard    Live terminal dashboard for a running game server
+  dev          Run the project's dev servers (game server and client)
+  install      Install packages and register engine plugins in mavonengine.json
+  build        Build the project for release, with the plugin assets it uses
+  mcp          MCP server so AI assistants (any MCP client) can inspect a running game server
+
+Options:
+  -h, --help       Show help
+  -v, --version    Show version
+
+Run 'mavonengine <command> --help' for command options.
+`;
+async function main(argv) {
+  const [command, ...args] = argv;
+  if (!command || command === "-h" || command === "--help" || command === "help") {
+    process9.stdout.write(HELP);
+    return 0;
+  }
+  if (command === "-v" || command === "--version") {
+    process9.stdout.write(`${version}
+`);
+    return 0;
+  }
+  if (command === "create") {
+    const options = parseCreateArgs(args);
+    if (options === "help") {
+      process9.stdout.write(CREATE_HELP);
+      return 0;
+    }
+    return runCreateCommand(options);
+  }
+  if (command === "dashboard") {
+    const options = parseDashboardArgs(args);
+    if (options === "help") {
+      process9.stdout.write(DASHBOARD_HELP);
+      return 0;
+    }
+    if (!process9.stdout.isTTY || !process9.stdin.isTTY) {
+      process9.stderr.write("mavonengine dashboard needs an interactive terminal\n");
+      return 1;
+    }
+    await runDashboard(options);
+    return 0;
+  }
+  if (command === "dev") {
+    const options = parseDevArgs(args);
+    if (options === "help") {
+      process9.stdout.write(DEV_HELP);
+      return 0;
+    }
+    return runDevCommand(options);
+  }
+  if (command === "install" || command === "i" || command === "add") {
+    const options = parseInstallArgs(args);
+    if (options === "help") {
+      process9.stdout.write(INSTALL_HELP);
+      return 0;
+    }
+    return runInstallCommand(options);
+  }
+  if (command === "mcp") {
+    const options = parseMcpArgs(args);
+    if (options === "help") {
+      process9.stdout.write(MCP_HELP);
+      return 0;
+    }
+    return runMcpCommand(options);
+  }
+  if (command === "build") {
+    const options = parseBuildArgs(args);
+    if (options === "help") {
+      process9.stdout.write(BUILD_HELP);
+      return 0;
+    }
+    return runBuildCommand(options);
+  }
+  throw new UsageError(`Unknown command '${command}'
+
+${HELP}`);
+}
+main(process9.argv.slice(2)).then((code) => process9.exit(code)).catch((err) => {
+  const isUsage = err instanceof UsageError || err.code?.startsWith("ERR_PARSE_ARGS");
+  process9.stderr.write(`mavonengine: ${err.message}
+`);
+  process9.exit(isUsage ? 2 : 1);
+});