@volter/play 0.5.211 → 0.5.212

package/dist-node/serving.mjs

@@ -0,0 +1,664 @@
+// serving/std-dev.ts
+import { spawn } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { open, readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { StringDecoder } from "node:string_decoder";
+import { pathToFileURL } from "node:url";
+import { stripVTControlCharacters } from "node:util";
+
+// ../sdk/src/npm-process.ts
+import { accessSync, constants, statSync } from "node:fs";
+import { delimiter, dirname, resolve } from "node:path";
+function resolveNpmProcess(cwd, path) {
+  if (process.platform !== "win32") {
+    for (const dir of path.split(delimiter)) {
+      const program = resolve(cwd, dir, "npm");
+      try {
+        accessSync(program, constants.X_OK);
+        if (statSync(program).isFile()) return { program, args: [] };
+      } catch {
+      }
+    }
+    return void 0;
+  }
+  const dirs = [dirname(process.execPath), ...path.split(delimiter).filter((dir) => {
+    try {
+      return statSync(resolve(cwd, dir, "npm.cmd")).isFile();
+    } catch {
+      return false;
+    }
+  })];
+  for (const dir of dirs) {
+    const cli = resolve(cwd, dir, "node_modules", "npm", "bin", "npm-cli.js");
+    try {
+      if (statSync(cli).isFile()) return { program: process.execPath, args: [cli] };
+    } catch {
+    }
+  }
+  return void 0;
+}
+function npmProcess(args, cwd) {
+  const npm = resolveNpmProcess(cwd, process.env["PATH"] ?? "");
+  if (!npm) throw new Error("npm is unavailable: install Node.js with npm, then retry.");
+  return { program: npm.program, args: [...npm.args, ...args] };
+}
+
+// ../sdk/src/process-tree.ts
+import { execFileSync } from "node:child_process";
+function signalProcessTree(pid, signal) {
+  if (process.platform === "win32") {
+    try {
+      execFileSync("taskkill", ["/PID", String(pid), "/T", "/F"], { windowsHide: true, stdio: "ignore" });
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        try {
+          process.kill(pid, signal);
+        } catch {
+        }
+      }
+    }
+    return;
+  }
+  try {
+    process.kill(-pid, signal);
+  } catch {
+    try {
+      process.kill(pid, signal);
+    } catch {
+    }
+  }
+}
+
+// serving/std-dev.ts
+var STD_ROUTE = "/__editor/play/std";
+var START_MS = 12e4;
+var LOOK_MS = 250;
+var TRACE_READ_BYTES = 256 * 1024;
+var TRACE_HEAD_BYTES = 4096;
+var PAGE_ID = /^[0-9a-f]{32}(-rerun)?$/;
+var CAPTURE_FILE = /^[0-9a-f]{32}(-rerun)?-capture-\d+\.png$/;
+var stdDev = (root) => join(root, "node_modules", "@volter-ai", "std-dev");
+var blenderHalfOf = (root) => join(stdDev(root), "blender", "blend-to-scene.py");
+var isLevelGlb = (path) => (/^levels\/.+\.glb$/.test(path) || /^prefabs\/([^/]+)\/\1\.glb$/.test(path)) && !path.includes("\\") && path.split("/").every((part) => part !== "" && part !== "." && part !== "..");
+function runStdLevel(root, glb) {
+  return new Promise((resolve2) => {
+    const run = spawn(process.execPath, [join(stdDev(root), "bin", "std.js"), "level", glb, "--description", glb.replace(/\.glb$/, ".level.json")], { cwd: root, windowsHide: true });
+    let output = "";
+    run.stdout.on("data", (chunk) => {
+      output += chunk.toString();
+    });
+    run.stderr.on("data", (chunk) => {
+      output += chunk.toString();
+    });
+    run.on("error", (error) => resolve2({ code: null, output: `${output}${error.message}` }));
+    run.on("close", (code) => resolve2({ code, output }));
+  });
+}
+var GOALS_MS = 1e4;
+var BOT_ENTRIES = ["index.ts", "index.js", "index.mjs"];
+var READ_GOALS = [
+  "const program = (await import(process.argv[1])).program;",
+  "if (typeof program?.goals !== 'object' || program.goals === null) throw new Error('autopilot/index exports no program with goals (autopilot({ goals }))');",
+  "console.log(JSON.stringify(Object.keys(program.goals)));"
+].join("\n");
+function botGoals(root) {
+  const entry = BOT_ENTRIES.map((name) => join(root, "autopilot", name)).find((file) => existsSync(file));
+  if (entry === void 0) return Promise.resolve({ status: 200, body: { goals: [] } });
+  return new Promise((resolve2) => {
+    const read = spawn(
+      process.execPath,
+      ["--input-type=module", "--eval", READ_GOALS, pathToFileURL(entry).href],
+      { cwd: root, windowsHide: true, timeout: GOALS_MS }
+    );
+    let output = "";
+    let said = "";
+    read.stdout.on("data", (chunk) => {
+      output += chunk.toString();
+    });
+    read.stderr.on("data", (chunk) => {
+      said += chunk.toString();
+    });
+    read.on("error", (error) => resolve2({ status: 500, body: { error: `The game's goals could not be read: ${error.message}` } }));
+    read.on("close", (code) => {
+      let goals = null;
+      try {
+        if (code === 0) goals = JSON.parse(output.trim().split("\n").at(-1) ?? "[]");
+      } catch {
+      }
+      resolve2(Array.isArray(goals) && goals.every((goal) => typeof goal === "string") ? { status: 200, body: { goals } } : { status: 500, body: { error: `The game's goals could not be read from ${entry} (exit ${String(code)}): ${said.trim() || output.trim()}` } });
+    });
+  });
+}
+async function levelAnswer(root, method, body) {
+  if (!stdGame(root).game || !existsSync(blenderHalfOf(root)))
+    return { status: 404, body: { error: "The project is not a std game with @volter-ai/std-dev installed: no std.json, or no blender/blend-to-scene.py in its std-dev." } };
+  if (method === "GET") return { status: 200, body: { blenderHalf: await readFile(blenderHalfOf(root), "utf8") } };
+  const glb = body?.glb;
+  if (typeof glb !== "string" || !isLevelGlb(glb))
+    return { status: 400, body: { error: `A level's glb is a path under levels/ ending .glb, a prefab's prefabs/<name>/<name>.glb; it was given ${JSON.stringify(glb)}.` } };
+  return { status: 200, body: await runStdLevel(root, glb) };
+}
+var ENGINE_PACKAGES = { roblox: "@volter-ai/std-roblox", unreal: "@volter-ai/std-unreal" };
+var ENGINE_LABELS = { roblox: "Roblox", unreal: "Unreal" };
+var isEngine = (value) => typeof value === "string" && Object.hasOwn(ENGINE_PACKAGES, value);
+function stdGame(root) {
+  if (!existsSync(join(root, "std.json"))) return { game: false, goal: null, targets: [] };
+  const manifest = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+  const named = (name) => manifest.dependencies?.[name] !== void 0 || manifest.devDependencies?.[name] !== void 0;
+  const targets = Object.keys(ENGINE_PACKAGES).filter((engine) => named(ENGINE_PACKAGES[engine]));
+  return { game: named("@volter-ai/std-dev"), goal: /--goal[ =](\S+)/.exec(manifest.scripts?.play ?? "")?.[1] ?? null, targets };
+}
+var EXPORT_MS = 30 * 6e4;
+var EXPORTED = { web: "dist", roblox: "build/roblox", unreal: "build/unreal/StdGame" };
+var EXPORT_LINE_MOST = 2e3;
+var exporting = /* @__PURE__ */ new Map();
+function endExports() {
+  for (const ended of exporting.values()) ended.abort();
+  exporting.clear();
+}
+function runStd(root, args, line, ended) {
+  return new Promise((resolve2) => {
+    const run = spawn(
+      process.execPath,
+      [join(stdDev(root), "bin", "std.js"), ...args],
+      { cwd: root, windowsHide: true, detached: process.platform !== "win32" }
+    );
+    const lines = () => {
+      const decoder = new StringDecoder("utf8");
+      let held = "";
+      return (chunk) => {
+        held += chunk === null ? decoder.end() : decoder.write(chunk);
+        const parts = held.split(/\r\n|\r|\n/);
+        held = chunk === null ? "" : parts.pop() ?? "";
+        if (held.length > EXPORT_LINE_MOST) {
+          parts.push(held);
+          held = "";
+        }
+        for (const part of parts) if (part.trim() !== "") line(stripVTControlCharacters(part).slice(0, EXPORT_LINE_MOST));
+      };
+    };
+    const out = lines();
+    const err = lines();
+    run.stdout.on("data", out);
+    run.stdout.on("end", () => out(null));
+    run.stderr.on("data", err);
+    run.stderr.on("end", () => err(null));
+    const end = () => {
+      if (run.pid !== void 0 && run.exitCode === null) signalProcessTree(run.pid, "SIGTERM");
+    };
+    ended.addEventListener("abort", end, { once: true });
+    run.on("error", (error) => {
+      line(error.message);
+      resolve2(null);
+    });
+    run.on("close", (code) => {
+      ended.removeEventListener("abort", end);
+      resolve2(code);
+    });
+  });
+}
+async function exportGame(root, body, response) {
+  const asked = body;
+  const target = asked?.target;
+  if (target !== "web" && !isEngine(target) || asked?.add !== void 0 && typeof asked.add !== "boolean")
+    return answer(response, 400, { error: `An export is { target, add? }: web, roblox or unreal, and whether to add an engine as the game's target; it was given ${JSON.stringify(body)}.` });
+  const game = stdGame(root);
+  if (!game.game) return answer(response, 404, { error: "The project is not a std game: no std.json, or no @volter-ai/std-dev among its packages." });
+  const added = target !== "web" && !game.targets.includes(target);
+  if (added && asked?.add !== true)
+    return answer(response, 409, { error: `${ENGINE_LABELS[target]} isn't a target of this game: Export's "Add ${ENGINE_LABELS[target]} and export" adds it (std target add ${target}).` });
+  if (exporting.has(root)) return answer(response, 409, { error: "An export of this game is running: wait for it to end." });
+  const ended = new AbortController();
+  exporting.set(root, ended);
+  response.statusCode = 200;
+  response.setHeader("content-type", "application/x-ndjson");
+  const said = (message) => {
+    if (!response.writableEnded && !response.destroyed) response.write(`${JSON.stringify(message)}
+`);
+  };
+  response.on("close", () => ended.abort());
+  const limit = setTimeout(() => {
+    said({ line: `Play ended the export: it ran ${EXPORT_MS / 6e4} minutes.` });
+    ended.abort();
+  }, EXPORT_MS);
+  const steps = target === "web" ? [["build"]] : [["target", "add", target], ["export", "--target", target]];
+  let ok = true;
+  try {
+    for (const step of steps) {
+      if (ended.signal.aborted) {
+        ok = false;
+        break;
+      }
+      said({ line: `std ${step.join(" ")}` });
+      if (await runStd(root, step, (line) => said({ line }), ended.signal) !== 0) {
+        ok = false;
+        break;
+      }
+    }
+  } finally {
+    clearTimeout(limit);
+    if (exporting.get(root) === ended) exporting.delete(root);
+  }
+  said({ end: { ok, added: added && stdGame(root).targets.includes(target), out: EXPORTED[target] } });
+  response.end();
+}
+var alive = (pid) => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+};
+async function runningServer(root) {
+  const text = await readFile(join(root, "node_modules", ".vite", "std-dev.json"), "utf8").catch(() => null);
+  if (text === null) return null;
+  const record = JSON.parse(text);
+  return alive(record.pid) ? record : null;
+}
+var ERRORS_KEPT = 500;
+var LINE_MOST = 4e3;
+var owned = /* @__PURE__ */ new Map();
+function heardError(server, chunk) {
+  const text = chunk === null ? server.decoder.end() : server.decoder.write(chunk);
+  const lines = stripVTControlCharacters(server.partial + text).split(/\r?\n/);
+  server.partial = chunk === null ? "" : (lines.pop() ?? "").slice(-LINE_MOST);
+  server.errors.push(...lines.filter((line, at) => chunk !== null || at < lines.length - 1 || line !== ""));
+  const over = server.errors.length - ERRORS_KEPT;
+  if (over > 0) {
+    server.errors.splice(0, over);
+    server.dropped += over;
+  }
+}
+function errorsFrom(root, server, from) {
+  const mine = owned.get(root);
+  const pid = mine?.child.pid ?? null;
+  if (!mine || pid === null) return { lines: [], next: 0, server: null };
+  const next = mine.dropped + mine.errors.length;
+  if (from === null) return { lines: [], next, server: pid };
+  const start = server === pid ? from : 0;
+  return { lines: mine.errors.slice(Math.max(0, start - mine.dropped)), next, server: pid };
+}
+function endOwned() {
+  for (const { child } of owned.values()) if (child.pid !== void 0 && child.exitCode === null) signalProcessTree(child.pid, "SIGTERM");
+  owned.clear();
+}
+async function startedServer(root) {
+  const running = await runningServer(root);
+  if (running) return running;
+  let mine = owned.get(root);
+  if (!mine || mine.child.exitCode !== null || mine.failed !== null) {
+    const npm = npmProcess(["run", "dev", "--", "--no-open"], root);
+    const child = spawn(npm.program, npm.args, { cwd: root, detached: process.platform !== "win32", windowsHide: true, stdio: ["ignore", "pipe", "pipe"] });
+    mine = { child, said: "", failed: null, errors: [], dropped: 0, partial: "", decoder: new StringDecoder("utf8") };
+    const kept = mine;
+    const hear = (chunk) => {
+      kept.said = (kept.said + chunk.toString("utf8")).slice(-4e3);
+    };
+    child.stdout?.on("data", hear);
+    child.stderr?.on("data", hear);
+    child.stderr?.on("data", (chunk) => heardError(kept, chunk));
+    child.stderr?.on("end", () => heardError(kept, null));
+    child.on("error", (error) => {
+      kept.failed = error.message;
+    });
+    owned.set(root, mine);
+  }
+  const bound = Date.now() + START_MS;
+  for (; ; ) {
+    const record = await runningServer(root);
+    if (record) return record;
+    if (mine.failed !== null) throw new Error(`The game's dev server (npm run dev) could not be started: ${mine.failed}`);
+    if (mine.child.exitCode !== null) throw new Error(`The game's dev server (npm run dev) ended with code ${mine.child.exitCode}:
+${mine.said.trim()}`);
+    if (Date.now() > bound) throw new Error(`The game's dev server (npm run dev) wrote no record in ${START_MS / 1e3} s:
+${mine.said.trim()}`);
+    await new Promise((done) => setTimeout(done, LOOK_MS));
+  }
+}
+async function newestRun(root) {
+  const runs = join(root, "build", "runs");
+  const newest = (await readdir(runs).catch(() => [])).sort().at(-1);
+  return newest === void 0 ? null : join(runs, newest);
+}
+async function pageSlots(root) {
+  const run = await newestRun(root);
+  if (run === null) return {};
+  const slots = {};
+  for (const name of await readdir(run)) {
+    const page = name.replace(/\.jsonl$/, "");
+    if (page === name || !PAGE_ID.test(page)) continue;
+    const handle = await open(join(run, name), "r");
+    try {
+      const buffer = Buffer.alloc(TRACE_HEAD_BYTES);
+      const { bytesRead } = await handle.read(buffer, 0, TRACE_HEAD_BYTES, 0);
+      const first = buffer.subarray(0, bytesRead).toString("utf8").split("\n")[0] ?? "";
+      if (!first.endsWith("}")) continue;
+      const head = JSON.parse(first);
+      if (head.k === "trace" && typeof head.slot === "string") slots[page] = head.slot;
+    } finally {
+      await handle.close();
+    }
+  }
+  return slots;
+}
+async function traceFrom(root, page, from) {
+  const run = await newestRun(root);
+  if (run === null || !existsSync(join(run, `${page}.jsonl`))) return { lines: [], next: from };
+  const handle = await open(join(run, `${page}.jsonl`), "r");
+  try {
+    const buffer = Buffer.alloc(TRACE_READ_BYTES);
+    const { bytesRead } = await handle.read(buffer, 0, TRACE_READ_BYTES, from);
+    const text = buffer.subarray(0, bytesRead).toString("utf8");
+    const end = text.lastIndexOf("\n") + 1;
+    return { lines: text.slice(0, end).split("\n").filter(Boolean), next: from + Buffer.byteLength(text.slice(0, end)) };
+  } finally {
+    await handle.close();
+  }
+}
+var PLAY_MS = 15 * 6e4;
+async function playGoal(root, body, response) {
+  const asked = body;
+  if (typeof asked?.goal !== "string" || asked.goal === "" || asked.bots !== void 0 && !(Number.isInteger(asked.bots) && Number(asked.bots) >= 1))
+    return answer(response, 400, { error: `A play is { goal, bots? }: a goal of the game's bot, and a whole number of bots; it was given ${JSON.stringify(body)}.` });
+  const running = await runningServer(root);
+  if (!running) return answer(response, 409, { error: "The game's dev server is not running: press Play." });
+  response.statusCode = 200;
+  response.setHeader("content-type", "application/x-ndjson");
+  const said = (message) => {
+    response.write(`${JSON.stringify(message)}
+`);
+  };
+  const socket = new WebSocket(`${running.url.replace(/^http/, "ws").replace(/\/$/, "")}/__std/play?token=${running.token}`);
+  let ended = false;
+  const end = (ok, why) => {
+    if (ended) return;
+    ended = true;
+    clearTimeout(limit);
+    if (why !== void 0) said({ line: why });
+    said({ end: { ok } });
+    response.end();
+    if (socket.readyState === WebSocket.OPEN || socket.readyState === WebSocket.CONNECTING) socket.close();
+  };
+  const limit = setTimeout(() => end(false, `Play ended std's play of ${asked.goal}: it ran ${PLAY_MS / 6e4} minutes.`), PLAY_MS);
+  socket.addEventListener("open", () => socket.send(JSON.stringify({ goal: asked.goal, bots: asked.bots ?? 1, device: "headless" })));
+  socket.addEventListener("message", (event) => {
+    const message = JSON.parse(String(event.data));
+    if (message.end !== void 0) end(message.end.ok === true);
+    else said(message);
+  });
+  socket.addEventListener("error", () => end(false, "std's play could not be reached on the game's dev server."));
+  socket.addEventListener("close", () => end(false, "std's play closed before it said how it ended."));
+  response.on("close", () => {
+    if (!ended) {
+      ended = true;
+      clearTimeout(limit);
+      socket.close();
+    }
+  });
+}
+var bodyOf = (request) => request.body;
+function answer(response, status, value) {
+  response.statusCode = status;
+  response.setHeader("content-type", "application/json");
+  response.end(JSON.stringify(value));
+}
+async function askStd(root, path, init) {
+  const running = await runningServer(root);
+  if (!running) return { status: 409, body: { error: "The game's dev server is not running: press Play." } };
+  const response = await fetch(`${running.url}${path}?token=${running.token}`, init);
+  return { status: response.status, body: await response.json() };
+}
+function stdDevPlugin(services) {
+  return {
+    name: "volter-play-std-dev",
+    configureServer(server) {
+      server.httpServer?.once("close", endOwned);
+      process.once("exit", endOwned);
+      server.httpServer?.once("close", endExports);
+      process.once("exit", endExports);
+      server.middlewares.use(STD_ROUTE, (request, response, next) => {
+        const root = services.currentProjectRoot();
+        if (!root) return next();
+        if (!services.requireLocalOwner(request, response)) return;
+        const url = new URL(request.url ?? "/", "http://session");
+        const captured = url.pathname === "/capture" && request.method === "GET" ? url.searchParams.get("file") ?? "" : null;
+        if (captured !== null) {
+          void newestRun(root).then(async (run) => {
+            if (run === null || !CAPTURE_FILE.test(captured) || !existsSync(join(run, captured)))
+              return answer(response, 404, { error: `No captured frame ${JSON.stringify(captured)} in the dev server's newest run.` });
+            response.statusCode = 200;
+            response.setHeader("content-type", "image/png");
+            response.end(await readFile(join(run, captured)));
+          }).catch((error) => answer(response, 500, { error: error instanceof Error ? error.message : String(error) }));
+          return;
+        }
+        if (url.pathname === "/export" && request.method === "POST") {
+          void exportGame(root, bodyOf(request), response).catch((error) => {
+            if (!response.headersSent) answer(response, 500, { error: error instanceof Error ? error.message : String(error) });
+            else response.end();
+          });
+          return;
+        }
+        if (url.pathname === "/play" && request.method === "POST") {
+          void playGoal(root, bodyOf(request), response).catch((error) => {
+            if (!response.headersSent) answer(response, 500, { error: error instanceof Error ? error.message : String(error) });
+            else response.end();
+          });
+          return;
+        }
+        const control = /^\/devices\/([^/]+)\/control$/.exec(url.pathname)?.[1];
+        const asked = url.pathname === "/" && request.method === "GET" ? Promise.resolve({ status: 200, body: stdGame(root) }) : url.pathname === "/start" && request.method === "POST" ? startedServer(root).then(({ url: at }) => ({ status: 200, body: { url: at } })) : url.pathname === "/devices" && request.method === "GET" ? askStd(root, "/__std/devices") : control !== void 0 && request.method === "POST" ? askStd(
+          root,
+          `/__std/devices/${encodeURIComponent(decodeURIComponent(control))}/control`,
+          { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(bodyOf(request)) }
+        ) : url.pathname === "/level" && (request.method === "GET" || request.method === "POST") ? levelAnswer(root, request.method, bodyOf(request)) : url.pathname === "/goals" && request.method === "GET" ? botGoals(root) : url.pathname === "/pages" && request.method === "GET" ? pageSlots(root).then((body) => ({ status: 200, body })) : url.pathname === "/trace" && request.method === "GET" && PAGE_ID.test(url.searchParams.get("page") ?? "") ? traceFrom(root, url.searchParams.get("page"), Number(url.searchParams.get("from") ?? 0)).then((body) => ({ status: 200, body })) : url.pathname === "/errors" && request.method === "GET" ? Promise.resolve({ status: 200, body: errorsFrom(
+          root,
+          url.searchParams.has("server") ? Number(url.searchParams.get("server")) : null,
+          url.searchParams.has("from") ? Number(url.searchParams.get("from")) || 0 : null
+        ) }) : Promise.resolve({ status: 404, body: { error: `${STD_ROUTE}${url.pathname} is not a route of Play's` } });
+        asked.then(
+          ({ status, body }) => answer(response, status, body),
+          (error) => answer(response, 500, { error: error instanceof Error ? error.message : String(error) })
+        );
+      });
+    }
+  };
+}
+
+// serving/std-scene.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "node:fs";
+import { dirname as dirname3, join as join3, relative, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// ../live/dist/chunk-7WKVJGHZ.js
+import { existsSync as existsSync2, realpathSync } from "node:fs";
+import { dirname as dirname2, join as join2 } from "node:path";
+function installedPackageDir(fromDir, name) {
+  for (let dir = fromDir; ; dir = dirname2(dir)) {
+    const candidate = join2(dir, "node_modules", ...name.split("/"));
+    if (existsSync2(join2(candidate, "package.json"))) return realpathSync(candidate);
+    if (dirname2(dir) === dir) return null;
+  }
+}
+
+// ../sdk/src/project-module-url.ts
+function fsFileUrl(file) {
+  const path = file.replaceAll("\\", "/");
+  return path.startsWith("/") ? `/@fs${path}` : `/@fs/${path}`;
+}
+var liveModuleRevision = Date.now();
+
+// serving/std-scene.ts
+import { normalizePath } from "vite";
+
+// src/std-level-files.ts
+var pascal = (name) => name.replace(/(^|[^A-Za-z0-9]+)([A-Za-z0-9])/g, (_m, _s, c) => c.toUpperCase()).replace(/^[0-9]/, (d) => `L${d}`);
+var camel = (name) => {
+  const p = pascal(name);
+  return p.charAt(0).toLowerCase() + p.slice(1);
+};
+function levelFiles(blend) {
+  const dir = blend.slice(0, blend.lastIndexOf("/"));
+  const base = blend.slice(dir.length + 1).replace(/\.blend$/, "");
+  return {
+    base,
+    dir,
+    component: `${dir}/${pascal(base)}Level.tsx`,
+    environment: `${dir}/${pascal(base)}Environment.tsx`,
+    canvas: `${dir}/${base}.canvas.ts`,
+    grading: `${dir}/${base}.grading.tsx`
+  };
+}
+
+// serving/std-scene.ts
+var PREFIX = "/@volter-std-scene/";
+var VIRTUAL = "\0volter-std-scene:";
+var RUNTIME = "volter-std-scene-runtime";
+var RUNTIME_ID = "\0volter-std-scene-runtime";
+var RUNTIME_FILE = join3(dirname3(fileURLToPath(import.meta.url)), "..", "serving", "std-scene-runtime.js");
+var LEVEL = /^levels\/.+\.blend$/;
+var MARK = "volter-std-scene";
+var RUNTIME_PACKAGES = ["@react-three/fiber", "@react-three/rapier"];
+var THROUGH = /* @__PURE__ */ new Map([["postprocessing", "@volter-ai/std/level/client"]]);
+var installedFolder = (root, name) => installedPackageDir(root, name.split("/").slice(0, name.startsWith("@") ? 2 : 1).join("/"));
+var fileUrl = (file, version) => `${fsFileUrl(file)}?${MARK}=${version}`;
+function sceneModule(root, blend, read, version) {
+  const files = levelFiles(blend);
+  const { base, dir } = files;
+  const level = `${pascal(base)}Level`, environment = `${pascal(base)}Environment`, canvas = `${camel(base)}Canvas`;
+  const exists = (at) => {
+    read.add(normalizePath(join3(root, at)));
+    return existsSync3(join3(root, at));
+  };
+  if (!exists(files.component) || !exists(files.canvas)) {
+    throw new Error(`${blend} has no exported level beside it (${files.component} and ${files.canvas}): save it, and std's level export writes them.`);
+  }
+  const hasEnvironment = exists(files.environment);
+  const source = exists(files.grading) ? readFileSync2(join3(root, files.grading), "utf8") : null;
+  const shaper = source === null ? null : /<ViewShaper min=\{(-?[\d.]+)\} max=\{(-?[\d.]+)\}(?: exposure=\{(-?[\d.]+)\})? \/>/.exec(source);
+  const lut = source === null ? null : /import viewLut from '\.\/(.+?)\?url';/.exec(source);
+  const grading = shaper !== null && lut !== null ? { lut: join3(root, dir, lut[1]), min: Number(shaper[1]), max: Number(shaper[2]), exposure: Number(shaper[3] ?? 0) } : null;
+  if (grading !== null) read.add(normalizePath(grading.lut));
+  const gradingExtra = source !== null && [...source.matchAll(/^\s+<([A-Z]\w*)\b/gm)].some((found) => found[1] !== "EffectComposer" && found[1] !== "ViewShaper" && found[1] !== "LUT");
+  return [
+    `import { mountScene as mountLevel, viewTransform as levelTransform } from ${JSON.stringify(RUNTIME)};`,
+    `import { ${level} } from ${JSON.stringify(`/${files.component}`)};`,
+    ...hasEnvironment ? [`import { ${environment} } from ${JSON.stringify(`/${files.environment}`)};`] : [],
+    `import { ${canvas} } from ${JSON.stringify(`/${files.canvas}`)};`,
+    // (the LUT's address, which its loader fetches as it is: an import of a `.cube` is no asset to Vite, whose import of it
+    // is its text as a module)
+    ...grading === null ? [] : [`const viewLut = ${JSON.stringify(fileUrl(grading.lut, version))};`],
+    `export const component = ${JSON.stringify(files.component)};`,
+    `export const canvas = ${canvas};`,
+    `export const gradingExtra = ${String(gradingExtra)};`,
+    `const level = { Level: ${level}, Environment: ${hasEnvironment ? environment : "null"}, canvas: ${canvas} };`,
+    "export const mountScene = (stage) => mountLevel(level, stage);",
+    grading === null ? "export const viewTransform = async () => null;" : `export const viewTransform = () => levelTransform({ lut: viewLut, min: ${grading.min}, max: ${grading.max}, exposure: ${grading.exposure} });`,
+    ""
+  ].join("\n");
+}
+function gameFile(root, file) {
+  if (file === null) return false;
+  const at = relative(root, file);
+  return !at.startsWith("..") && !at.split(sep).includes("node_modules");
+}
+function importClosure(graph, root, id) {
+  const found = /* @__PURE__ */ new Set();
+  const visit = (node) => {
+    for (const next of node.importedModules) {
+      if (found.has(next) || !gameFile(root, next.file)) continue;
+      found.add(next);
+      visit(next);
+    }
+  };
+  const start = graph.getModuleById(id);
+  if (start) visit(start);
+  return found;
+}
+function stdScenePlugin(services) {
+  const stdGame2 = () => {
+    const root = services.currentProjectRoot();
+    return root && existsSync3(join3(root, "std.json")) ? root : null;
+  };
+  const scenes = /* @__PURE__ */ new Map();
+  let version = Date.now();
+  return {
+    name: "volter-play-std-scene",
+    enforce: "pre",
+    // (a std game's Scene view and its levels' modules prebundled as the session starts: found on the view's first open,
+    // Vite would optimize them again then, and the editor's page, which does not reload for it, would hold two copies of
+    // React. The levels' files are crawled, and the runtime's own packages are included where the game has them)
+    config() {
+      const root = stdGame2();
+      if (root === null) return void 0;
+      const include = RUNTIME_PACKAGES.filter((name) => installedFolder(root, name) !== null);
+      return { optimizeDeps: { entries: ["levels/**/*.{ts,tsx}"], include } };
+    },
+    async resolveId(source, importer) {
+      const ours = importer?.startsWith(VIRTUAL) === true || importer === RUNTIME_ID;
+      if (source === RUNTIME && ours) return RUNTIME_ID;
+      const through = THROUGH.get(source);
+      if (through !== void 0 && ours) {
+        const root = stdGame2();
+        const owner = root === null ? null : installedFolder(root, through);
+        if (!owner) throw new Error(`${through} is not installed for the game's folder, so its ${source} is not at hand.`);
+        return this.resolve(source, join3(owner, "package.json"), { skipSelf: true });
+      }
+      if (!source.startsWith(PREFIX)) return null;
+      const [path = "", query = ""] = source.slice(PREFIX.length).split("?");
+      const blend = decodeURIComponent(path);
+      if (!LEVEL.test(blend)) throw new Error(`${blend} is not a std level's Blender file (levels/<name>.blend).`);
+      return `${VIRTUAL}${blend}?${query}`;
+    },
+    load(id) {
+      if (id === RUNTIME_ID) return readFileSync2(RUNTIME_FILE, "utf8");
+      if (id.startsWith(VIRTUAL)) {
+        const root2 = stdGame2();
+        if (!root2) throw new Error("The open project is not a std game (no std.json), so it has no level to draw.");
+        const blend = id.slice(VIRTUAL.length).replace(/\?.*$/, "");
+        const read = /* @__PURE__ */ new Set();
+        scenes.set(blend, { id, read });
+        return sceneModule(root2, blend, read, version);
+      }
+      const [file = id, query] = id.split("?");
+      const root = query === "url" ? stdGame2() : null;
+      if (!root || !gameFile(root, file)) return null;
+      return `export default ${JSON.stringify(fileUrl(file, version))};`;
+    },
+    // (a Scene view depends on its module's whole import closure among the game's files, the modules whose import failed
+    // to resolve within it and the files its source was written from. Any file of those written, made or removed bumps
+    // the content version, invalidates the closure, so each of its modules and URLs is served anew, and is announced on
+    // the session's change channel naming the levels it reached)
+    hotUpdate({ file, type, modules, server, timestamp }) {
+      if (this.environment.name !== "client") return;
+      const root = stdGame2();
+      if (!root) return;
+      const graph = this.environment.moduleGraph;
+      const failed = new Set(type === "create" ? modules : []);
+      const reached = [...scenes].map(([blend, scene]) => ({ blend, scene, closure: importClosure(graph, root, scene.id) })).filter(({ scene, closure }) => {
+        const start = graph.getModuleById(scene.id);
+        return scene.read.has(file) || start !== void 0 && failed.has(start) || [...closure].some((node) => node.file === file || failed.has(node));
+      });
+      if (reached.length === 0) return;
+      version += 1;
+      const seen = /* @__PURE__ */ new Set();
+      for (const { closure } of reached) for (const node of closure) graph.invalidateModule(node, seen, timestamp, true);
+      server.ws.send({
+        type: "custom",
+        event: "volter:restart-required",
+        data: { file, path: relative(root, file).replaceAll("\\", "/"), type, affected: reached.map(({ blend }) => blend) }
+      });
+    }
+  };
+}
+
+// serving/index.ts
+var servingPlugins = (services) => [
+  stdDevPlugin(services),
+  stdScenePlugin(services)
+];
+export {
+  servingPlugins
+};