lecodes-cli 0.20.2 → 2.0.0

package/src/dev/webRunner.ts

@@ -1,22 +1,90 @@
-import { existsSync } from "node:fs"
+import { spawnSync } from "node:child_process"
+import { existsSync, readdirSync, statSync } from "node:fs"
 import { createRequire } from "node:module"
 import { dirname, join } from "node:path"
-import { distRoot } from "../distRoot"
+import { distRoot } from "../hosts/distRoot"
 
 /**
- * Where the browser runner for `lecodes dev --web` lives: viewer-lite's built `dist-embed`
- * (embed.html + embed.js + assets/ — the Web Lite host as a static folder). Two shapes:
- *   - vendored next to the CLI as runtime/web (scripts/vendor-runtime.ts — the npm package and
- *     the standalone binary),
- *   - the lecodes-viewer-lite package's own dist-embed (monorepo dev after `bun run build:embed`).
- * `null` = no runner available (the dev server then serves everything but /web/).
+ * What `lecodes dev --web` serves to a browser, two built folders:
+ *   player   the web player (lecodes-web-player's dist: index.html + player.js + assets/ — the
+ *            runtime module, the archives, the plugins' web halves): the app, filling its window
+ *   page     the page around it (lecodes-web-frame's dist-page: the app in a device, the buttons,
+ *            the console), which holds the player in an <iframe>; absent = the player alone
+ *
+ * Each comes in one of two shapes:
+ *   - its package's own build, in a CHECKOUT of the core (the package has its sources beside it):
+ *     built here when it is older than what it is built from — a stale build is yesterday's host
+ *     under today's SDK, and it fails in ways that name nothing;
+ *   - vendored next to the CLI as runtime/web and runtime/web-page (scripts/vendor-runtime.ts —
+ *     the npm package and the standalone binary).
+ * `null` = no player available (the dev server then serves everything but /web/).
  */
-export const resolveWebRunnerDir = (): string | null => {
-  const candidates = [join(distRoot, "runtime", "web")]
+export type WebRunner = { player: string, page: string | null }
+
+type Built = {
+  /** The package, as npm names it. */
+  pkg: string
+  /** Its build, a folder of the package. */
+  dist: string
+  /** The file a build has. */
+  entry: string
+  /** The folder it is vendored as, beside the CLI. */
+  vendored: string
+  /** What it is built from, relative to the repo. */
+  sources: string[]
+  /** The arguments of the `vite build` that makes it. */
+  build: string[]
+}
+
+const PLAYER: Built = {
+  pkg: "lecodes-web-player", dist: "dist", entry: "player.js", vendored: "web", build: [],
+  sources: ["hosts/web-player/src", "hosts/web-player/build", "hosts/web-player/index.html", "hosts/web-host/src", "renderers/web-canvas/src", "renderers/web-shared/src", "runtime/web/src", "runtime/web/native/dist", "hosts/plugins/plugins"],
+}
+const PAGE: Built = {
+  // (the package's own build is the element, a library; the page is another)
+  pkg: "lecodes-web-frame", dist: "dist-page", entry: "page.js", vendored: "web-page", build: ["-c", "vite.page.config.ts"],
+  sources: ["hosts/web-frame/src", "hosts/web-frame/page", "hosts/web-player/src/protocol.ts"],
+}
+
+export const resolveWebRunner = (log: (message: string) => void = () => {}): WebRunner | null => {
+  const player = resolve(PLAYER, log)
+  return player ? { player, page: resolve(PAGE, log) } : null
+}
+
+const resolve = (built: Built, log: (message: string) => void): string | null => {
+  const has = (dir: string) => existsSync(join(dir, "index.html")) && existsSync(join(dir, built.entry))
+  const checkout = checkoutOf(built.pkg)
+  if (checkout) {
+    const dist = join(checkout, built.dist)
+    const repo = join(checkout, "..", "..")
+    if (!has(dist) || newest(built.sources.map((s) => join(repo, s))) > statSync(join(dist, built.entry)).mtimeMs) {
+      log(`Building ${built.pkg} (its sources are newer than its build)…`)
+      const done = spawnSync("bunx", ["vite", "build", ...built.build], { cwd: checkout, stdio: "pipe", encoding: "utf8", shell: process.platform === "win32" })
+      if (done.status !== 0) log(`${built.pkg} did not build — the browser gets the build that is there:\n${done.stderr || done.stdout}`)
+    }
+    if (has(dist)) return dist
+  }
+  const vendored = join(distRoot, "runtime", built.vendored)
+  return has(vendored) ? vendored : null
+}
+
+/** A package when it is a checkout (its sources are there), else null. */
+const checkoutOf = (pkg: string): string | null => {
   try {
-    const pkg = createRequire(import.meta.url).resolve("lecodes-viewer-lite/package.json")
-    candidates.push(join(dirname(pkg), "dist-embed"))
-  } catch { /* no package: standalone */ }
-  for (const dir of candidates) if (existsSync(join(dir, "embed.html")) && existsSync(join(dir, "embed.js"))) return dir
-  return null
+    const dir = dirname(createRequire(import.meta.url).resolve(`${pkg}/package.json`))
+    return existsSync(join(dir, "vite.config.ts")) && existsSync(join(dir, "src")) ? dir : null
+  } catch { return null }
+}
+
+/** The latest modification under the paths (0 when none exists). */
+const newest = (paths: string[]): number => {
+  let latest = 0
+  const walk = (path: string) => {
+    let stat
+    try { stat = statSync(path) } catch { return }
+    if (!stat.isDirectory()) { latest = Math.max(latest, stat.mtimeMs); return }
+    for (const name of readdirSync(path)) if (name !== "node_modules" && name !== "ios" && name !== "android") walk(join(path, name))
+  }
+  for (const path of paths) walk(path)
+  return latest
 }

package/src/{cmgenTool.ts → hosts/cmgenTool.ts}

@@ -2,7 +2,7 @@ import { existsSync, readdirSync } from "node:fs"
 import { homedir } from "node:os"
 import { join, resolve } from "node:path"
 import { downloadReleaseArchive, fetchReleaseProduct, newestForPlatform, semverNewer, type ManifestFile, type ManifestVersion } from "./releases"
-import { CliError, note } from "./util"
+import { CliError, note } from "../cli"
 
 /*
  * Filament's cmgen (environment tool) — the tool behind `lecodes assets sky`, which turns an
@@ -14,7 +14,7 @@ import { CliError, note } from "./util"
  * releases/versions.json — published by scripts/release/release-windows.ps1 from the desktop
  * build's in-tree filament host tools, so the KTX it writes always matches the engine the hosts
  * ship). Cache: ~/.lecodes/cmgen/cmgen-<version>/. LECODES_CMGEN overrides resolution entirely
- * (local dev: packages/desktop/build/creator-gl/filament/tools/cmgen/cmgen.exe).
+ * (local dev: hosts/desktop/build/creator-gl/filament/tools/cmgen/cmgen.exe).
  *
  * The CLI resolves it and hands the path to lecodes-assets through LECODES_CMGEN, so that package
  * stays network-free and still works standalone against a local build.

package/src/{desktopRenderer.ts → hosts/desktopRenderer.ts}

@@ -1,10 +1,10 @@
 import { execFileSync, spawn, spawnSync } from "node:child_process"
-import { copyFileSync, existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs"
+import { copyFileSync, existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync, linkSync } from "node:fs"
 import { homedir, tmpdir } from "node:os"
 import { delimiter, join, resolve } from "node:path"
 import { cachedArtifactSha, downloadReleaseArchive, fetchReleaseProduct, semverNewer, type ManifestVersion } from "./releases"
-import { CliError, note, warnErr } from "./util"
-import { makeStackDemangler } from "./compile/nativeStack"
+import { CliError, note, warnErr } from "../cli"
+import { makeStackDemangler } from "../compile/nativeStack"
 
 /*
  * The NATIVE renderer behind `lecodes render --desktop`: the LeCodes Desktop host (tgfx UI + Filament
@@ -15,7 +15,7 @@ import { makeStackDemangler } from "./compile/nativeStack"
  * natively). It downloads on first use from the same S3 release bucket the desktop distribution
  * publishes to (scripts/release/* → releases/versions.json), sha256-verified, into
  * ~/.lecodes/renderer/desktop-<version>/. LECODES_DESKTOP_EXE overrides resolution entirely
- * (local dev: point it at packages/desktop/build/lecodes-desktop.exe).
+ * (local dev: point it at hosts/desktop/build/lecodes-desktop.exe).
  *
  * Platforms: windows-x64 + linux (the ubuntu build) + macos-arm64. The macOS host is built and
  * published separately (the Apple repo's LeCodes Desktop.app, via scripts/release/release-macos.sh)
@@ -38,9 +38,10 @@ export const DESKTOP_RENDERER_VERSION = "1.1.0"
 export { semverNewer }
 
 /** Which desktop host to run. "gl" is the default everywhere; "vulkan" is a separate Windows binary
- *  (Filament + tgfx on one VkDevice), NOT a runtime switch — it has its own artifact, its own
- *  shaders, and a smaller feature set (no 2D engine, no native-view plugins). Chosen per project via
- *  app.json `desktop.renderer`, or per run via `--renderer` / LECODES_DESKTOP_RENDERER. */
+ *  (Filament + tgfx + creator-2d on one VkDevice), NOT a runtime switch — it has its own artifact, its
+ *  own shaders, and a smaller feature set (no native-view plugins; the 2D engine joined it 2026-09-08,
+ *  i.e. desktop releases after 1.4.1). Chosen per project via app.json `desktop.renderer`, or per run via `--renderer` /
+ *  LECODES_DESKTOP_RENDERER. */
 export type DesktopRenderer = "gl" | "vulkan"
 
 export const DESKTOP_RENDERER_MIN_VERSION: Record<DesktopRenderer, string> = { gl: "0.0.0", vulkan: "1.4.0" }
@@ -57,8 +58,9 @@ const platformKey = (renderer: DesktopRenderer = "gl"): string => {
 
 const isMac = () => process.platform === "darwin"
 
-/** The host binary's file name. macOS: the executable inside LeCodes Desktop.app. */
-const exeName = () => (process.platform === "win32" ? "lecodes-desktop.exe" : isMac() ? "lecodes-app" : "lecodes-desktop")
+/** The host binary's file name — the same on every OS; on macOS it sits inside LeCodes Desktop.app
+ *  (Contents/MacOS/lecodes-desktop, hosts/desktop/package-macos.sh). */
+const exeName = () => (process.platform === "win32" ? "lecodes-desktop.exe" : "lecodes-desktop")
 
 /** Recursively locate the host binary inside an extracted archive (the zip nests a
  *  `lecodes-desktop/` top-level folder; the tarballs may differ — search, don't assume). */
@@ -166,7 +168,7 @@ export const findMacHostExe = (): string | null => {
   const candidates = [
     ...["/Applications", join(homedir(), "Applications")]
       .flatMap((root) => ["LeCodes Desktop.app", "LeCodes.app"].map((app) => join(root, app))),
-  ].map((app) => join(app, "Contents", "MacOS", "lecodes-app"))
+  ].map((app) => join(app, "Contents", "MacOS", "lecodes-desktop"))
   return candidates.find((exe) => existsSync(exe)) ?? null
 }
 
@@ -204,7 +206,7 @@ const resolveMacExe = async (selected: string): Promise<string> => {
     throw new CliError(
       `${e instanceof Error ? e.message : String(e)}\n` +
       "  No LeCodes Desktop.app is installed either — retry online (`lecodes desktop update`), install the DMG into\n" +
-      "  /Applications, or point LECODES_DESKTOP_EXE at a build (…/LeCodes Desktop.app/Contents/MacOS/lecodes-app).",
+      "  /Applications, or point LECODES_DESKTOP_EXE at a build (hosts/desktop/build-macos/lecodes-desktop, or an .app's Contents/MacOS/lecodes-desktop).",
     )
   }
 }
@@ -234,6 +236,38 @@ export const resolveDesktopExe = async (renderer: DesktopRenderer = "gl"): Promi
   return exe
 }
 
+/** Which native host runs a bundle: the desktop (a window, a GPU, pixels) or the windowless server
+ *  (hosts/desktop lecodes-server: the same engine on Filament's NOOP backend — the dedicated
+ *  multiplayer server, a headless client, an offline simulation run; no UI hit-test, no pixels). */
+export type HostKind = "desktop" | "server"
+
+const serverExeName = () => (process.platform === "win32" ? "lecodes-server.exe" : "lecodes-server")
+
+/** The windowless host: LECODES_SERVER_EXE override → the binary beside the resolved desktop host
+ *  (one product, two executables — a release archive and a repo build both keep them side by side,
+ *  sharing runtime/). A host older than the server's introduction has none beside it. */
+export const resolveServerExe = async (renderer: DesktopRenderer = "gl"): Promise<string> => {
+  const override = process.env.LECODES_SERVER_EXE
+  if (override) {
+    if (!existsSync(override)) throw new CliError(`LECODES_SERVER_EXE points at "${override}" which doesn't exist.`)
+    return resolve(override)
+  }
+  // macOS: the server ships inside the .app beside the window host (Contents/MacOS/) since the
+  // in-repo Metal host (hosts/desktop/build-macos.sh); the "beside the desktop exe" rule holds.
+  const desktopExe = await resolveDesktopExe(renderer)
+  const exe = join(desktopExe, "..", serverExeName())
+  if (!existsSync(exe)) {
+    throw new CliError(
+      `No ${serverExeName()} beside ${desktopExe} — this desktop host predates the windowless server. ` +
+      "Update it (lecodes desktop update), or point LECODES_SERVER_EXE at a build (hosts/desktop/build[-linux|-macos]/lecodes-server).",
+    )
+  }
+  return exe
+}
+
+const resolveHostExe = (host: HostKind | undefined, renderer: DesktopRenderer | undefined): Promise<string> =>
+  host === "server" ? resolveServerExe(renderer) : resolveDesktopExe(renderer)
+
 /** `lecodes desktop update`: move the render host to the newest published release (never below the
  *  CLI's pin — a manifest that somehow regressed under it is an error, not a downgrade). Saves the
  *  selection so later `render --desktop` runs use it; the download is skipped when already cached. */
@@ -278,6 +312,8 @@ export type DesktopWindowOpts = {
   /** Which host binary to run (see DesktopRenderer). Must match the renderer the bundle's shaders
    *  were staged for — resolve it once per command and pass the same value to both. */
   renderer?: DesktopRenderer
+  /** The desktop window (default) or the windowless server host (see HostKind). */
+  host?: HostKind
   width?: number
   height?: number
   minWidth?: number
@@ -304,8 +340,16 @@ export type DesktopWindowOpts = {
    *  the block, forwarded verbatim as CREATOR_VIRTUAL_KEYBOARD JSON. A set env wins, like the mouse knob. */
   virtualKeyboard?: boolean | object
   /** Draw the host's frame counter in the corner (host ≥1.5.0; older hosts ignore the env). Costs
-   *  nothing to leave off and next to nothing on — the digits are rectangles, no UI behind them. */
+   *  nothing to leave off and next to nothing on — the digits are rectangles, no UI behind them.
+   *  On macOS too (host 2026-09-09; the CLI sets the same env there). */
   fps?: boolean
+  /** The host's profiler (CREATOR_PERF=1, host 2026-09-26): a `[perf]` line a second — GPU frame time from
+   *  Filament's timer query, the CPU split, visible / total renderables, the view's switches — and the
+   *  fps overlay's second row. docs/profiling.md in the core repo. */
+  perf?: boolean
+  /** app.json desktop.frameRate — a CAP on the host's render loop, "display" or a number; forwarded
+   *  verbatim as CREATOR_FRAME_RATE (a set env wins). macOS host 2026-09-09; Windows ignores it. */
+  frameRate?: number | "display"
   /** Multiplayer launch facts for the host (`--server --port N --max-clients N` / `--connect ip:port`);
    *  the SDK reads them through `Net.launch` and decides (docs/multiplayer-plan.md). */
   net?: { role: "server" | "client"; address?: string; port?: number; maxClients?: number }
@@ -339,6 +383,10 @@ const windowEnv = (opts: DesktopWindowOpts): Record<string, string> => {
     env.CREATOR_RENDER_MAX = `${Math.round(opts.maxRenderSize[0])}x${Math.round(opts.maxRenderSize[1])}`
   }
   if (opts.fps) env.CREATOR_FPS = "1"
+  if (opts.perf) env.CREATOR_PERF = "1"
+  if (opts.frameRate !== undefined && process.env.CREATOR_FRAME_RATE === undefined) {
+    env.CREATOR_FRAME_RATE = String(opts.frameRate)
+  }
   if (opts.mouseEmulateTouch !== undefined && process.env.CREATOR_MOUSE_TOUCH === undefined) {
     env.CREATOR_MOUSE_TOUCH = opts.mouseEmulateTouch ? "1" : "0"
   }
@@ -366,6 +414,9 @@ export type DesktopRenderOptions = {
   /** Which host binary to run (see DesktopRenderer). Must match the renderer the bundle's shaders
    *  were staged for — resolve it once per command and pass the same value to both. */
   renderer?: DesktopRenderer
+  /** The hidden desktop host (default: pixels, a PNG) or the windowless server host (no pixels — the
+   *  run is judged by its output alone; `outPng` is ignored). */
+  host?: HostKind
   width: number
   height: number
   /** Frames to run before the dump — headroom for async loads (GLB, images, fonts). */
@@ -375,7 +426,7 @@ export type DesktopRenderOptions = {
   /** Forward the host's stdout/stderr (app console.log included) to stderr. */
   logs: boolean
   timeoutMs: number
-  /** CREATOR_SCRIPT contents (the line format in packages/desktop/src/main.cpp `scriptStep`): the
+  /** CREATOR_SCRIPT contents (the line format in hosts/desktop/src/main.cpp `scriptStep`): the
    *  host drives these commands and self-terminates when done; `frames` is then only a safety cap. */
   script?: string
   /** CREATOR_FIXED_DT: virtual app clock, ms per frame (0/undefined = wall clock). */
@@ -395,13 +446,29 @@ export type DesktopRenderOutcome = {
 
 /** Stage a compiled bundle for the host: app.js + the local-asset resources copied next to it
  *  (the host's fetchLocal resolves them by basename relative to its cwd). Caller removes the dir. */
+/** The staging dir the host runs from: app.js + every resource the bundle names, next to it (fetchLocal's
+ *  fallback). A resource is HARD-LINKED when the temp dir shares the project's volume (the usual case:
+ *  both on C:) and copied otherwise — a yard-sized project names hundreds of MB of models and textures,
+ *  and copying them was seconds of "the window has not opened yet" on every run. The host only reads
+ *  them, and the dir is removed after the run, so a link is as safe as a copy. */
 const stageBundle = (js: string, resources: { name: string, absPath?: string }[]): string => {
+  const t0 = performance.now()
   const runDir = mkdtempSync(join(tmpdir(), "lecodes-render-"))
   writeFileSync(join(runDir, "app.js"), js)
+  let files = 0, bytes = 0, copied = 0
   for (const r of resources) {
-    if (r.absPath && existsSync(r.absPath) && statSync(r.absPath).isFile()) {
-      copyFileSync(r.absPath, join(runDir, r.name))
-    }
+    if (!r.absPath || !existsSync(r.absPath)) continue
+    const st = statSync(r.absPath)
+    if (!st.isFile()) continue
+    const dst = join(runDir, r.name)
+    try { linkSync(r.absPath, dst) }
+    catch { copyFileSync(r.absPath, dst); copied++ }
+    files++
+    bytes += st.size
+  }
+  const ms = performance.now() - t0
+  if (files > 0 && (ms > 250 || copied > 0)) {
+    note(`Staged ${files} resources (${(bytes / 1048576).toFixed(0)} MB${copied > 0 ? `, ${copied} copied` : ", linked"}) in ${(ms / 1000).toFixed(1)} s`)
   }
   return runDir
 }
@@ -428,7 +495,8 @@ export const runDesktopApp = async (
   resources: { name: string, absPath?: string }[],
   opts: DesktopWindowOpts = {},
 ): Promise<void> => {
-  const exe = await resolveDesktopExe(opts.renderer)
+  const exe = await resolveHostExe(opts.host, opts.renderer)
+  const what = opts.host === "server" ? "server" : "desktop"
   const runDir = stageBundle(js, resources)
   try {
     const env = { ...process.env, ...windowEnv(opts) }
@@ -444,10 +512,15 @@ export const runDesktopApp = async (
         pipeThroughDemangler(child.stdout!, process.stdout, demangle)
         pipeThroughDemangler(child.stderr!, process.stderr, demangle)
       }
-      child.on("error", (e) => fail(new CliError(`Can't run the desktop host: ${e.message}`)))
+      // Ctrl+C in the terminal: the child gets it too on a console (Windows) or via SIGINT (POSIX),
+      // and the server host tears its endpoint down on it; make sure a detached one is not left behind.
+      const onSigint = () => { child.kill("SIGINT") }
+      process.once("SIGINT", onSigint)
+      child.on("error", (e) => { process.off("SIGINT", onSigint); fail(new CliError(`Can't run the ${what} host: ${e.message}`)) })
       child.on("exit", (code) => {
+        process.off("SIGINT", onSigint)
         if (code === 0 || code === null) done()   // null: killed (e.g. Ctrl+C reached the child)
-        else fail(new CliError(`The desktop host exited with code ${code}.`))
+        else fail(new CliError(`The ${what} host exited with code ${code}.`))
       })
     })
   } finally {
@@ -479,30 +552,29 @@ export const runDesktopDev = async (url: string, opts: DesktopWindowOpts = {}):
   })
 }
 
-/** Run a compiled bundle in the hidden desktop host and dump the final frame as a PNG. */
+/** Run a compiled bundle in the hidden desktop host and dump the final frame as a PNG — or, with
+ *  `host: "server"`, in the windowless host, which paints nothing: the outcome is its output. */
 export const runDesktopRender = async (
   js: string,
   resources: { name: string, absPath?: string }[],
   opts: DesktopRenderOptions,
 ): Promise<DesktopRenderOutcome> => {
-  if (isMac()) {
-    throw new CliError(
-      "`lecodes render --desktop` isn't available on macOS yet — the macOS host has no headless mode " +
-      "(CREATOR_HIDDEN / CREATOR_DUMP_PNG). `lecodes desktop run` and `lecodes desktop build` do work there.",
-    )
-  }
-  const exe = await resolveDesktopExe(opts.renderer)
+  const server = opts.host === "server"
+  // macOS: the in-repo Metal host (hosts/desktop, phase 11) carries the headless render contract like
+  // the other two platforms (CREATOR_HIDDEN / CREATOR_DUMP_PNG / CREATOR_SCRIPT); the old Swift shell
+  // did not — a cached one is refused by its missing lecodes-server, not here.
+  const exe = await resolveHostExe(opts.host, opts.renderer)
   const runDir = stageBundle(js, resources)
   try {
     const appJs = join(runDir, "app.js")
     const outAbs = resolve(opts.outPng)
     const env: Record<string, string | undefined> = {
       ...process.env,
-      CREATOR_DUMP_PNG: outAbs,
       CREATOR_MAX_FRAMES: String(opts.frames),
       CREATOR_WINDOW_SIZE: `${opts.width}x${opts.height}`,
-      CREATOR_HIDDEN: "1",
+      CREATOR_HIDDEN: "1",   // a clean storage every run (and, on the desktop host, no window)
     }
+    if (!server) env.CREATOR_DUMP_PNG = outAbs
     if (opts.script !== undefined) {
       const scriptPath = join(runDir, "script.txt")
       writeFileSync(scriptPath, opts.script)
@@ -534,17 +606,17 @@ export const runDesktopRender = async (
         child.kill()
         fail(new CliError(`The native render timed out after ${opts.timeoutMs}ms (raise --timeout, or lower --frames).`))
       }, opts.timeoutMs)
-      child.on("error", (e) => { clearTimeout(killer); fail(new CliError(`Can't run the desktop renderer: ${e.message}`)) })
+      child.on("error", (e) => { clearTimeout(killer); fail(new CliError(`Can't run the ${server ? "server" : "desktop"} host: ${e.message}`)) })
       child.on("exit", (code) => {
         clearTimeout(killer)
         const output = demangle(chunks.join(""))
         if (stopped) return done({ output, exitCode: 0 })
-        if (code === 0 && existsSync(outAbs)) return done({ output, exitCode: code })
+        if (code === 0 && (server || existsSync(outAbs))) return done({ output, exitCode: code })
         const tail = demangle(chunks.slice(-80).join("")).trimEnd()
         const detail = tail.length > 0 ? `\n${tail}` : ""
         fail(new CliError(code === 0
           ? `The renderer exited cleanly but produced no PNG — did the app open a screen?${detail}`
-          : `The renderer exited with code ${code}.${detail}`))
+          : `The ${server ? "server host" : "renderer"} exited with code ${code}.${detail}`))
       })
     })
   } finally {