@genex-ai/cli-demo 1.38.0-dev.1096 → 1.38.1-dev.1097

package/dist/index.js

@@ -810,9 +810,9 @@ async function runAuth(opts) {
 }
 
 // src/commands/remix.ts
-import fs19 from "fs/promises";
-import path19 from "path";
-import crypto5 from "crypto";
+import fs20 from "fs/promises";
+import path20 from "path";
+import crypto6 from "crypto";
 import { spawn as spawn4 } from "child_process";
 
 // src/lib/game-config.ts
@@ -2852,6 +2852,98 @@ async function detectMatchmaking(log, cwd = process.cwd()) {
   }
   return null;
 }
+var AUTHORITY_TICK_RATES = [20, 30, 60, 120];
+var AUTHORITY_PHYSICS_ONLY_TICK_HZ = 120;
+var authorityTickHzOf = (value) => AUTHORITY_TICK_RATES.find((hz) => hz === value);
+var AUTHORITY_TICK_RATES_TEXT = `${AUTHORITY_TICK_RATES.slice(0, -1).join(", ")} or ${AUTHORITY_TICK_RATES.at(-1)}`;
+var AUTHORITY_MAX_PLAYERS = 64;
+var MAX_AUTHORITY_MANIFEST_CHARS = 1024;
+var AUTHORITY_SERVER_DIR = "server";
+var ROOM_MODULE_FILE = /\.(js|ts)$/;
+var PRESET_NAME = /^[a-z][a-z0-9-]{0,31}$/;
+var TEMPLATE_GENEX_SETTINGS = "genex.json";
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function modulePathProblem(module) {
+  if (typeof module !== "string" || module === "") return `needs "module", the room module's path (e.g. "server/room.ts")`;
+  if (!ROOM_MODULE_FILE.test(module)) return `module "${module.slice(0, 80)}" is not a .js or .ts file`;
+  const unsafe = module.includes("\\") || /[\u0000-\u001f]/.test(module) || module.startsWith("/") || /^[A-Za-z]:/.test(module);
+  const segments = module.split("/");
+  if (unsafe || segments.some((s) => s === "" || s === "." || s === "..")) {
+    return `module "${module.slice(0, 80)}" must be a plain path inside the game folder, like "server/room.ts"`;
+  }
+  if (segments[0] !== AUTHORITY_SERVER_DIR || segments.length < 2) {
+    return `module "${module.slice(0, 80)}" must be in the game's ${AUTHORITY_SERVER_DIR}/ folder, like "server/room.ts"`;
+  }
+  return null;
+}
+function knobProblem(block) {
+  const { tickHz, maxPlayers, preset } = block;
+  if (tickHz !== void 0 && authorityTickHzOf(tickHz) === void 0) {
+    return `tickHz must be ${AUTHORITY_TICK_RATES_TEXT}`;
+  }
+  const players = typeof maxPlayers === "number" && Number.isSafeInteger(maxPlayers) && maxPlayers >= 1 && maxPlayers <= AUTHORITY_MAX_PLAYERS;
+  if (maxPlayers !== void 0 && !players) return `maxPlayers must be a whole number from 1 to ${AUTHORITY_MAX_PLAYERS}`;
+  if (preset !== void 0 && !(typeof preset === "string" && PRESET_NAME.test(preset))) {
+    return 'preset must be a preset name, like "topdown"';
+  }
+  return null;
+}
+function parseAuthorityManifest(value) {
+  if (!isRecord(value)) return { problem: 'must be an object like { "module": "server/room.ts" }' };
+  if (JSON.stringify(value).length > MAX_AUTHORITY_MANIFEST_CHARS) {
+    return { problem: `is over ${MAX_AUTHORITY_MANIFEST_CHARS} characters` };
+  }
+  const problem = modulePathProblem(value.module) ?? knobProblem(value);
+  if (problem) return { problem };
+  const manifest = { module: value.module };
+  const tickHz = authorityTickHzOf(value.tickHz);
+  if (tickHz !== void 0) manifest.tickHz = tickHz;
+  if (value.maxPlayers !== void 0) manifest.maxPlayers = value.maxPlayers;
+  if (value.preset !== void 0) manifest.preset = value.preset;
+  return { manifest };
+}
+function within(child, parent) {
+  const rel = path14.relative(parent, child);
+  return rel === "" || !rel.startsWith("..") && !path14.isAbsolute(rel);
+}
+async function moduleFileProblem(cwd, module) {
+  try {
+    const root = await fs13.realpath(cwd);
+    const real = await fs13.realpath(path14.join(root, module));
+    if (!within(real, root)) return `module "${module}" leads outside the game folder`;
+    if (!(await fs13.stat(real)).isFile()) return `module "${module}" is not a file`;
+    return null;
+  } catch {
+    return `module "${module}" does not exist`;
+  }
+}
+async function readJsonFile(cwd, rel) {
+  try {
+    return JSON.parse(await fs13.readFile(path14.join(cwd, rel), "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+async function detectAuthority(cwd = process.cwd()) {
+  const pkg = await readJsonFile(cwd, "package.json");
+  const fromPkg = isRecord(pkg) && isRecord(pkg.genex) && Object.hasOwn(pkg.genex, "authority");
+  let block;
+  let source;
+  if (fromPkg) {
+    block = pkg.genex.authority;
+    source = "package.json";
+  } else {
+    const settings = await readJsonFile(cwd, TEMPLATE_GENEX_SETTINGS);
+    if (!isRecord(settings) || !Object.hasOwn(settings, "authority")) return { state: "none" };
+    block = settings.authority;
+    source = "genex.json";
+  }
+  const parsed = parseAuthorityManifest(block);
+  if ("problem" in parsed) return { state: "invalid", source, problem: parsed.problem };
+  const onDisk = await moduleFileProblem(cwd, parsed.manifest.module);
+  if (onDisk) return { state: "invalid", source, problem: onDisk };
+  return { state: "declared", source, manifest: parsed.manifest };
+}
 var TOUCH_KIT_MARKERS = /controllers\/touch\/|controllers\/character\/touch-joystick|TouchJoystick|VirtualButton|DragZone|RotateOverlay/;
 async function detectMobileControls(cwd = process.cwd()) {
   try {
@@ -3459,7 +3551,8 @@ async function detectFeatures(log, cwd = process.cwd()) {
     generations: await detectGenerationAudit(cwd),
     embedBoot: await detectEmbedBoot(cwd),
     capabilities: await detectCapabilities(cwd),
-    shellApis: await detectShellApis(cwd)
+    shellApis: await detectShellApis(cwd),
+    authority: await detectAuthority(cwd)
   };
 }
 function advisoryNudges(log, d) {
@@ -3478,6 +3571,16 @@ function advisoryNudges(log, d) {
       "package.json declares genex.matchmaking but @genex-ai/multiplayer is not installed \u2014 matchmaking cannot work. Install the SDK and use matchmake() (see genex-threejs-multiplayer)."
     );
   }
+  if (d.authority.state === "invalid") {
+    log.warn(
+      `${d.authority.source} declares genex.authority but ${d.authority.problem} \u2014 the deploy will refuse it until the room module is named correctly (see genex-authoritative-multiplayer).`
+    );
+  }
+  if (d.authority.state === "declared" && !d.multiplayer) {
+    log.warn(
+      "genex.authority names a room module but @genex-ai/multiplayer is not installed \u2014 the game cannot join its server. Install the SDK and connect with connectAuthority (see genex-authoritative-multiplayer)."
+    );
+  }
   embedBootNudges(log, d);
   shellNudges(log, d);
   surfaceNudges(log, d.surfaces);
@@ -3685,6 +3788,223 @@ async function borrowEvidence(meta, cwd) {
   return readme.includes(host) || /\b(upstream|originally by|ported from|borrowed from)\b/i.test(readme);
 }
 
+// src/lib/authority-publish.ts
+import crypto2 from "crypto";
+import fs14 from "fs/promises";
+import { createRequire } from "module";
+import path15 from "path";
+import { pathToFileURL } from "url";
+var AUTHORITY_DEV_PACKAGE = "@genex-ai/authority-dev";
+var MODULE_CONTRACT = 1;
+var MODULE_MAX_BYTES = 1048576;
+var REPORT_MAX_BYTES = 64 * 1024;
+var REPORT_COPY = path15.join(".genex", "authority", "report.json");
+var MAX_FAILURES_SHOWN = 6;
+var AuthorityStop = {
+  /** The manifest's `genex.authority` is unusable (detect-features said why). */
+  ManifestInvalid: "manifest_invalid",
+  /** The game has no @genex-ai/authority-dev to bundle and validate with. */
+  ToolchainMissing: "toolchain_missing",
+  /** It has one, but it does not export the library calls this CLI uses. */
+  ToolchainUnusable: "toolchain_unusable",
+  /** The module did not bundle (the bundler's reason is printed beside it). */
+  BundleFailed: "bundle_failed",
+  /** The module failed validation (each typed reason is printed). */
+  ValidateFailed: "validate_failed",
+  /** The report passed a different module than the one bundled for upload. */
+  ShaDisagrees: "sha_disagrees",
+  /** The module or its report is larger than the API stores. */
+  TooLarge: "too_large",
+  /** The resolved tick rate, player count or preset is one the API refuses. */
+  ConfigOutOfRange: "config_out_of_range",
+  /** The owner is not on a plan with Genex servers (403 authority_requires_pro). */
+  RequiresPro: "requires_pro",
+  /** The presign or a PUT failed. */
+  UploadFailed: "upload_failed"
+};
+var sha256 = (bytes) => crypto2.createHash("sha256").update(bytes).digest("hex");
+var localTestCommand = (module) => `npx genex-authority-dev start --module ${module} --bots 3`;
+async function loadAuthorityToolchain(gameDir) {
+  let manifestPath;
+  try {
+    manifestPath = createRequire(path15.join(gameDir, "package.json")).resolve(`${AUTHORITY_DEV_PACKAGE}/package.json`);
+  } catch {
+    return { ok: false, stop: AuthorityStop.ToolchainMissing };
+  }
+  try {
+    const pkg = JSON.parse(await fs14.readFile(manifestPath, "utf8"));
+    const root = pkg.exports?.["."];
+    const entry = typeof root === "string" ? root : root?.import;
+    if (typeof entry !== "string") return { ok: false, stop: AuthorityStop.ToolchainUnusable };
+    const lib = await import(pathToFileURL(path15.resolve(path15.dirname(manifestPath), entry)).href);
+    if (typeof lib.bundleModule !== "function" || typeof lib.validateModule !== "function") {
+      return { ok: false, stop: AuthorityStop.ToolchainUnusable };
+    }
+    return { ok: true, toolchain: lib, version: typeof pkg.version === "string" ? pkg.version : "unknown" };
+  } catch {
+    return { ok: false, stop: AuthorityStop.ToolchainUnusable };
+  }
+}
+function stopped(log, stop2, sentence, ...details) {
+  log.error(`Room module refused (${stop2}): ${sentence} Nothing was deployed.`);
+  for (const line of details) log.dim(`  ${line}`);
+  return null;
+}
+var failureLine = (f) => `${f.code ? `${f.reason}:${f.code}` : f.reason} \u2014 ${f.detail}${f.tick === void 0 ? "" : ` (tick ${f.tick})`}`;
+async function keepReport(gameDir, bytes) {
+  const file = path15.join(gameDir, REPORT_COPY);
+  await fs14.mkdir(path15.dirname(file), { recursive: true }).catch(() => {
+  });
+  await fs14.writeFile(file, bytes).catch(() => {
+  });
+  return REPORT_COPY.split(path15.sep).join("/");
+}
+function goLiveBlock(manifest, report, code, reportBytes) {
+  const preset = manifest.preset ?? report.config?.preset?.name;
+  return {
+    contract: MODULE_CONTRACT,
+    moduleSha256: sha256(code),
+    bytes: code.length,
+    tickHz: manifest.tickHz ?? report.config?.tickHz ?? 0,
+    maxPlayers: manifest.maxPlayers ?? report.config?.maxPlayers ?? 0,
+    ...preset ? { preset } : {},
+    reportSha256: sha256(reportBytes)
+  };
+}
+var asksPhysics = (report) => typeof report.config?.physics === "object" && report.config.physics !== null;
+function blockProblem(block, report) {
+  if (authorityTickHzOf(block.tickHz) === void 0) return `tick rate ${block.tickHz} is not ${AUTHORITY_TICK_RATES_TEXT}`;
+  if (block.tickHz === AUTHORITY_PHYSICS_ONLY_TICK_HZ && !asksPhysics(report)) {
+    return `tick rate ${block.tickHz} is only for a module that asks for physics`;
+  }
+  if (!Number.isSafeInteger(block.maxPlayers) || block.maxPlayers < 1 || block.maxPlayers > AUTHORITY_MAX_PLAYERS) {
+    return `${block.maxPlayers} players is outside 1\u2013${AUTHORITY_MAX_PLAYERS}`;
+  }
+  return null;
+}
+async function prepareAuthorityModule(gameDir, detection, log, injected) {
+  if (detection === void 0 || detection.state === "none") return null;
+  if (detection.state === "invalid") {
+    stopped(log, AuthorityStop.ManifestInvalid, `${detection.source} genex.authority ${detection.problem}.`);
+    return false;
+  }
+  const { manifest } = detection;
+  let toolchain = injected;
+  if (!toolchain) {
+    const loaded = await loadAuthorityToolchain(gameDir);
+    if (!loaded.ok) {
+      const verb = loaded.stop === AuthorityStop.ToolchainMissing ? "is not installed in this game" : "in this game is too old";
+      stopped(log, loaded.stop, `${AUTHORITY_DEV_PACKAGE} ${verb}; it bundles and checks the room module.`, `Run \`npm i -D ${AUTHORITY_DEV_PACKAGE}@latest\`, then deploy again.`);
+      return false;
+    }
+    toolchain = loaded.toolchain;
+  }
+  const entry = path15.join(gameDir, manifest.module);
+  log.step(`Checking the room module (${manifest.module})\u2026`);
+  const bundled = await toolchain.bundleModule(entry, gameDir);
+  if (!bundled.ok) {
+    stopped(log, AuthorityStop.BundleFailed, `${manifest.module} does not bundle.`, failureLine(bundled.failure));
+    return false;
+  }
+  const report = await toolchain.validateModule({ module: entry, root: gameDir });
+  const reportBytes = Buffer.from(`${JSON.stringify(report, null, 2)}
+`, "utf8");
+  const kept = await keepReport(gameDir, reportBytes);
+  if (!report.passed) {
+    const shown = report.failures.slice(0, MAX_FAILURES_SHOWN).map(failureLine);
+    const more = report.failures.length > MAX_FAILURES_SHOWN ? [`\u2026and ${report.failures.length - MAX_FAILURES_SHOWN} more`] : [];
+    stopped(log, AuthorityStop.ValidateFailed, `${manifest.module} did not pass validation.`, ...shown, ...more, `Full report: ${kept}`, `Reproduce: npx genex-authority-dev validate --module ${manifest.module}`);
+    return false;
+  }
+  const code = Buffer.from(bundled.value.code, "utf8");
+  if (report.moduleSha256 !== sha256(code) || bundled.value.sha256 !== sha256(code)) {
+    stopped(log, AuthorityStop.ShaDisagrees, "the report passed a different bundle than the one about to be uploaded.", `Update ${AUTHORITY_DEV_PACKAGE} and deploy again.`);
+    return false;
+  }
+  if (code.length > MODULE_MAX_BYTES || reportBytes.length > REPORT_MAX_BYTES) {
+    stopped(log, AuthorityStop.TooLarge, `the module (${code.length} bytes) or its report (${reportBytes.length} bytes) is over what Genex stores.`);
+    return false;
+  }
+  const goLive = goLiveBlock(manifest, report, code, reportBytes);
+  const problem = blockProblem(goLive, report);
+  if (problem) {
+    stopped(log, AuthorityStop.ConfigOutOfRange, `${problem}.`, "Set genex.authority's tickHz / maxPlayers, or the module's config, to a value Genex runs.");
+    return false;
+  }
+  log.success(`Room module passed (${goLive.moduleSha256.slice(0, 12)}, ${code.length} bytes).`);
+  return { manifest, code, report: reportBytes, goLive };
+}
+function isServerFile(relPath) {
+  const [top, ...rest] = relPath.split("/");
+  return rest.length > 0 && top?.toLowerCase() === AUTHORITY_SERVER_DIR;
+}
+var isPresigned = (value) => {
+  const v = value;
+  return typeof v?.url === "string" && typeof v.headers === "object" && v.headers !== null;
+};
+async function putSigned(target, body, what, log) {
+  if (target.headers["Content-Length"] !== String(body.length)) {
+    log.error(`The server signed the ${what} for ${target.headers["Content-Length"]} bytes, not ${body.length}. Nothing was deployed.`);
+    return false;
+  }
+  try {
+    const res = await fetch(target.url, { method: "PUT", headers: target.headers, body });
+    if (res.ok) return true;
+    log.error(`Couldn't upload the ${what} (HTTP ${res.status}). Nothing was deployed.`);
+  } catch (err) {
+    log.error(`Couldn't upload the ${what}: ${String(err)}. Nothing was deployed.`);
+  }
+  return false;
+}
+async function reportPresignRefusal(res, module, log) {
+  const body = await res.clone().json().catch(() => null);
+  if (res.status === 403 && body?.error === "authority_requires_pro") {
+    log.error(`Room module refused (${AuthorityStop.RequiresPro}): server-authoritative multiplayer on Genex servers needs Genex Pro. Nothing was deployed.`);
+    log.dim(`  Test it on this machine without an account: ${localTestCommand(module)}`);
+    return;
+  }
+  if (res.status === 401) {
+    log.error("Not authorized (HTTP 401) \u2014 your sign-in expired or was revoked. Run `genex link <your-game>` and sign in again.");
+    return;
+  }
+  if (res.status === 404) {
+    log.error("This account doesn't own this game (HTTP 404). Run `genex link <your-game>` as the owner.");
+    return;
+  }
+  const said = typeof body?.message === "string" ? body.message : typeof body?.error === "string" ? body.error : "";
+  log.error(`Couldn't store the room module (HTTP ${res.status})${said ? `: ${said}` : ""}. Nothing was deployed.`);
+}
+async function uploadAuthorityModule(api, prepared, log) {
+  log.step("Uploading the room module\u2026");
+  let res;
+  try {
+    res = await apiFetch(`${api.apiUrl}/api/games/${api.projectId}/authority-module`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${api.token}` },
+      body: JSON.stringify({
+        sha256: prepared.goLive.moduleSha256,
+        bytes: prepared.code.length,
+        reportSha256: prepared.goLive.reportSha256,
+        reportBytes: prepared.report.length
+      })
+    });
+  } catch (err) {
+    log.error(`Couldn't reach the API at ${api.apiUrl}: ${String(err)}`);
+    return false;
+  }
+  if (!res.ok) {
+    await reportPresignRefusal(res, prepared.manifest.module, log);
+    return false;
+  }
+  const grant = await res.json().catch(() => null);
+  if (!isPresigned(grant?.module) || !isPresigned(grant?.report)) {
+    log.error("The API answered the room module upload without upload addresses. Nothing was deployed.");
+    return false;
+  }
+  if (!await putSigned(grant.module, prepared.code, "room module", log)) return false;
+  return putSigned(grant.report, prepared.report, "validation report", log);
+}
+
 // src/lib/generation-plan.ts
 var LANE_OF_KIND = {
   image: "image",
@@ -3863,14 +4183,14 @@ function auditGenerationPlan(input) {
 }
 
 // src/lib/deploy.ts
-import crypto2 from "crypto";
-import fs17 from "fs/promises";
+import crypto3 from "crypto";
+import fs18 from "fs/promises";
 import os5 from "os";
-import path17 from "path";
+import path18 from "path";
 
 // src/lib/source-size.ts
-import fs14 from "fs/promises";
-import path15 from "path";
+import fs15 from "fs/promises";
+import path16 from "path";
 var FALLBACK_SOURCE_LIMITS = {
   maxTotalBytes: 5 * 1024 * 1024 * 1024,
   maxFiles: 5e3
@@ -3912,7 +4232,7 @@ async function measurePayload(cwd, staged) {
   for (const file of staged) {
     let size = 0;
     try {
-      size = (await fs14.stat(path15.join(cwd, file))).size;
+      size = (await fs15.stat(path16.join(cwd, file))).size;
     } catch {
       size = 0;
     }
@@ -3923,12 +4243,12 @@ async function measurePayload(cwd, staged) {
 }
 
 // src/commands/ui.ts
-import fs16 from "fs/promises";
-import path16 from "path";
+import fs17 from "fs/promises";
+import path17 from "path";
 import { PNG as PNG2 } from "pngjs";
 
 // src/lib/png-tools.ts
-import fs15 from "fs/promises";
+import fs16 from "fs/promises";
 import { PNG } from "pngjs";
 var ALPHA_TRANSPARENT_MAX = 16;
 var isHttpUrl = (s) => /^https?:\/\//i.test(s);
@@ -3939,12 +4259,12 @@ async function loadPng(input) {
     if (!res.ok) throw new Error(`Couldn't fetch ${input} (HTTP ${res.status}).`);
     buf = Buffer.from(await res.arrayBuffer());
   } else {
-    buf = await fs15.readFile(input);
+    buf = await fs16.readFile(input);
   }
   return PNG.sync.read(buf);
 }
 async function writePng(file, png) {
-  await fs15.writeFile(file, PNG.sync.write(png));
+  await fs16.writeFile(file, PNG.sync.write(png));
 }
 function cropPng(image, box) {
   const out = new PNG({ width: box.w, height: box.h });
@@ -4244,7 +4564,7 @@ async function uiExtract(opts, log) {
   const dilatePx = opts.dilate ?? 0;
   const sheet = await loadPng(input);
   const { width: W, height: H, data } = sheet;
-  await fs16.mkdir(outDir, { recursive: true });
+  await fs17.mkdir(outDir, { recursive: true });
   log.plain(c.bold("genex ui extract"));
   log.dim(`  ${input} (${W}x${H}) \u2192 ${outDir}, ${names2.length} names`);
   let hasTransparency = false;
@@ -4473,7 +4793,7 @@ async function uiExtract(opts, log) {
         rimPixels: speckle.sampled
       });
     }
-    const outPath = path16.join(outDir, `${name}.png`);
+    const outPath = path17.join(outDir, `${name}.png`);
     await writePng(outPath, out);
     const sidecar = {
       name,
@@ -4492,7 +4812,7 @@ async function uiExtract(opts, log) {
       defringed
     };
     const { name: _n, out: _o, ...sidecarBody } = sidecar;
-    await fs16.writeFile(
+    await fs17.writeFile(
       outPath.replace(/\.png$/i, "") + ".bbox.json",
       JSON.stringify(sidecarBody, null, 2)
     );
@@ -4501,8 +4821,8 @@ async function uiExtract(opts, log) {
       `${name}.png  ${cropW}x${cropH} (ar ${sidecar.aspectRatio}) at sheet ${padX0},${padY0}`
     );
   }
-  const debugPath = path16.join(outDir, "extract-debug.json");
-  await fs16.writeFile(
+  const debugPath = path17.join(outDir, "extract-debug.json");
+  await fs17.writeFile(
     debugPath,
     JSON.stringify(
       {
@@ -4964,7 +5284,7 @@ async function uiMasks(opts, log) {
   const registrationTolerance = opts.registrationTolerance ?? 0.04;
   const edgeFlushMax = opts.edgeFlushMax ?? 0.04;
   const loosened = registrationTolerance > 0.04 || edgeFlushMax > 0.04 || minCoverage < 0.01 || maxCoverage > 0.85;
-  await fs16.mkdir(outDir, { recursive: true });
+  await fs17.mkdir(outDir, { recursive: true });
   log.plain(c.bold("genex ui masks"));
   log.dim(`  ${input} (${image.width}x${image.height}), ${pairs.length} pair(s) \u2192 ${outDir}`);
   const sheetComponents = detectSheetComponents(image, opts.minPixels ?? 2e3);
@@ -5017,11 +5337,11 @@ async function uiMasks(opts, log) {
       });
     }
     const overlay = makeOverlay(clean2, converted.png);
-    const framePath = path16.join(outDir, `${pair.name}-frame.png`);
-    const maskPath = path16.join(outDir, `${pair.name}-mask.png`);
-    const annotatedPath = path16.join(outDir, `${pair.name}-annotated-source.png`);
-    const overlayPath = path16.join(outDir, `${pair.name}-overlay.png`);
-    const metaPath = path16.join(outDir, `${pair.name}.annotated-progress.json`);
+    const framePath = path17.join(outDir, `${pair.name}-frame.png`);
+    const maskPath = path17.join(outDir, `${pair.name}-mask.png`);
+    const annotatedPath = path17.join(outDir, `${pair.name}-annotated-source.png`);
+    const overlayPath = path17.join(outDir, `${pair.name}-overlay.png`);
+    const metaPath = path17.join(outDir, `${pair.name}.annotated-progress.json`);
     await writePng(framePath, clean2);
     await writePng(maskPath, converted.png);
     await writePng(annotatedPath, annotated);
@@ -5068,7 +5388,7 @@ async function uiMasks(opts, log) {
       },
       overlay: overlayPath
     };
-    await fs16.writeFile(metaPath, `${JSON.stringify(meta, null, 2)}
+    await fs17.writeFile(metaPath, `${JSON.stringify(meta, null, 2)}
 `);
     results.push(meta);
     const fb = converted.bbox;
@@ -5084,8 +5404,8 @@ async function uiMasks(opts, log) {
       );
     }
   }
-  const indexPath = path16.join(outDir, "annotated-progress.json");
-  await fs16.writeFile(indexPath, `${JSON.stringify({ input, loosened, pairs: results }, null, 2)}
+  const indexPath = path17.join(outDir, "annotated-progress.json");
+  await fs17.writeFile(indexPath, `${JSON.stringify({ input, loosened, pairs: results }, null, 2)}
 `);
   log.plain("");
   log.success(`Wrote ${pairs.length} frame+mask pair(s) \u2192 ${outDir} (index: ${indexPath}).`);
@@ -5211,7 +5531,7 @@ async function uiTextColor(opts, log) {
   };
   process.stdout.write(`${JSON.stringify(result, null, 2)}
 `);
-  if (opts.out) await fs16.writeFile(opts.out, `${JSON.stringify(result, null, 2)}
+  if (opts.out) await fs17.writeFile(opts.out, `${JSON.stringify(result, null, 2)}
 `);
   if (opts.cropPath) log.dim(`  crop \u2192 ${opts.cropPath}`);
 }
@@ -5243,7 +5563,7 @@ async function uiTrim(opts, log) {
   const sidecar = computeBBoxes(trimmed);
   const speckleAllowed = !!(speckle && speckle.ratio > SPECKLE_MAX_RATIO);
   const sidecarPath = outPath.replace(/\.png$/i, "") + ".bbox.json";
-  await fs16.writeFile(
+  await fs17.writeFile(
     sidecarPath,
     JSON.stringify(speckleAllowed ? { ...sidecar, speckleAllowed: true } : sidecar, null, 2)
   );
@@ -5350,7 +5670,7 @@ async function uiPlate(opts, log) {
     fail("No interior found \u2014 the image is fully transparent (or erode ate everything). Check --in / lower --erode.");
   }
   await writePng(outPath, out);
-  const name = path16.basename(outPath);
+  const name = path17.basename(outPath);
   log.plain(c.bold("genex ui plate"));
   log.success(`${outPath}  ${W}x${H}, interior ${(count / (W * H) * 100).toFixed(1)}% (erode ${erode}px)`);
   log.dim("  Wire it as the plate's silhouette (same box as the frame <img>, plate UNDER the art):");
@@ -5515,13 +5835,13 @@ async function walkFiles(dir) {
   const out = [];
   let entries;
   try {
-    entries = await fs16.readdir(dir, { withFileTypes: true });
+    entries = await fs17.readdir(dir, { withFileTypes: true });
   } catch {
     return out;
   }
   for (const entry of entries) {
     if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
-    const p = path16.join(dir, entry.name);
+    const p = path17.join(dir, entry.name);
     if (entry.isDirectory()) out.push(...await walkFiles(p));
     else out.push(p);
   }
@@ -5530,7 +5850,7 @@ async function walkFiles(dir) {
 async function collectUiAuditFindings(assetDir, srcDir, cwd = process.cwd()) {
   const viewportFindings = [];
   try {
-    const indexHtml = await fs16.readFile(path16.join(cwd, "index.html"), "utf8");
+    const indexHtml = await fs17.readFile(path17.join(cwd, "index.html"), "utf8");
     if (!/<meta[^>]+name=["']viewport["']/i.test(indexHtml)) {
       viewportFindings.push({
         kind: "viewport-meta",
@@ -5544,28 +5864,28 @@ async function collectUiAuditFindings(assetDir, srcDir, cwd = process.cwd()) {
     }
   } catch {
   }
-  const absAssets = path16.resolve(cwd, assetDir);
+  const absAssets = path17.resolve(cwd, assetDir);
   try {
-    if (!(await fs16.stat(absAssets)).isDirectory()) {
+    if (!(await fs17.stat(absAssets)).isDirectory()) {
       return viewportFindings.length > 0 ? viewportFindings : null;
     }
   } catch {
     return viewportFindings.length > 0 ? viewportFindings : null;
   }
-  const srcFiles = (await walkFiles(path16.resolve(cwd, srcDir))).filter(
-    (p) => AUDIT_SRC_EXTS.has(path16.extname(p).toLowerCase())
+  const srcFiles = (await walkFiles(path17.resolve(cwd, srcDir))).filter(
+    (p) => AUDIT_SRC_EXTS.has(path17.extname(p).toLowerCase())
   );
   try {
-    for (const name of await fs16.readdir(cwd)) {
-      const ext = path16.extname(name).toLowerCase();
-      if (ext === ".html" || ext === ".css") srcFiles.push(path16.join(cwd, name));
+    for (const name of await fs17.readdir(cwd)) {
+      const ext = path17.extname(name).toLowerCase();
+      if (ext === ".html" || ext === ".css") srcFiles.push(path17.join(cwd, name));
     }
   } catch {
   }
   const sources = [];
   for (const p of srcFiles) {
     try {
-      sources.push({ rel: path16.relative(cwd, p), text: await fs16.readFile(p, "utf8") });
+      sources.push({ rel: path17.relative(cwd, p), text: await fs17.readFile(p, "utf8") });
     } catch {
     }
   }
@@ -5575,11 +5895,11 @@ async function collectUiAuditFindings(assetDir, srcDir, cwd = process.cwd()) {
   const metaByName = /* @__PURE__ */ new Map();
   const bboxByPng = /* @__PURE__ */ new Map();
   for (const p of assetFiles) {
-    const base = path16.basename(p);
+    const base = path17.basename(p);
     const metaMatch = /^(.+)\.annotated-progress\.json$/.exec(base);
     if (metaMatch) {
       try {
-        const meta = JSON.parse(await fs16.readFile(p, "utf8"));
+        const meta = JSON.parse(await fs17.readFile(p, "utf8"));
         metaByName.set(metaMatch[1], {
           cleanCrop: meta.clean?.crop ?? null,
           loosened: meta.loosened === true
@@ -5590,7 +5910,7 @@ async function collectUiAuditFindings(assetDir, srcDir, cwd = process.cwd()) {
     }
     if (base.endsWith(".bbox.json")) {
       try {
-        const sidecar = JSON.parse(await fs16.readFile(p, "utf8"));
+        const sidecar = JSON.parse(await fs17.readFile(p, "utf8"));
         if (sidecar.sheetBBox) bboxByPng.set(base.replace(/\.bbox\.json$/, ".png"), sidecar.sheetBBox);
       } catch {
       }
@@ -5599,7 +5919,7 @@ async function collectUiAuditFindings(assetDir, srcDir, cwd = process.cwd()) {
   for (const [name, meta] of metaByName) {
     if (!meta.cleanCrop || !referenced(`${name}-mask.png`)) continue;
     for (const p of assetFiles) {
-      const base = path16.basename(p);
+      const base = path17.basename(p);
       if (!base.toLowerCase().endsWith(".png")) continue;
       if (base !== `${name}.png` && !base.startsWith(`${name}-`)) continue;
       if (/-mask\.png$|-frame\.png$|-overlay\.png$|-annotated-source\.png$/.test(base)) continue;
@@ -5623,7 +5943,7 @@ async function collectUiAuditFindings(assetDir, srcDir, cwd = process.cwd()) {
   }
   const pngByBase = /* @__PURE__ */ new Map();
   for (const p of assetFiles) {
-    const base = path16.basename(p);
+    const base = path17.basename(p);
     if (base.toLowerCase().endsWith(".png")) pngByBase.set(base, p);
   }
   for (const [maskBase, maskPath] of pngByBase) {
@@ -5636,8 +5956,8 @@ async function collectUiAuditFindings(assetDir, srcDir, cwd = process.cwd()) {
       let frame;
       let mask;
       try {
-        frame = PNG2.sync.read(await fs16.readFile(framePath));
-        mask = PNG2.sync.read(await fs16.readFile(maskPath));
+        frame = PNG2.sync.read(await fs17.readFile(framePath));
+        mask = PNG2.sync.read(await fs17.readFile(maskPath));
       } catch {
         continue;
       }
@@ -5656,7 +5976,7 @@ async function collectUiAuditFindings(assetDir, srcDir, cwd = process.cwd()) {
     if (!referenced(base)) continue;
     let png;
     try {
-      png = PNG2.sync.read(await fs16.readFile(p));
+      png = PNG2.sync.read(await fs17.readFile(p));
     } catch {
       continue;
     }
@@ -5676,7 +5996,7 @@ async function collectUiAuditFindings(assetDir, srcDir, cwd = process.cwd()) {
   }
   const maskReported = /* @__PURE__ */ new Set();
   for (const p of assetFiles) {
-    const m = /^(.+)\.annotated-progress\.json$/.exec(path16.basename(p));
+    const m = /^(.+)\.annotated-progress\.json$/.exec(path17.basename(p));
     if (!m) continue;
     const maskBase = `${m[1]}-mask.png`;
     if (!referenced(maskBase)) {
@@ -5688,14 +6008,14 @@ async function collectUiAuditFindings(assetDir, srcDir, cwd = process.cwd()) {
     }
   }
   for (const p of assetFiles) {
-    const base = path16.basename(p);
+    const base = path17.basename(p);
     if (!base.toLowerCase().endsWith(".png")) continue;
     if (/-annotated-source\.png$|-overlay\.png$/.test(base)) continue;
     if (maskReported.has(base)) continue;
     if (!referenced(base)) {
       findings.push({
         kind: "unwired-sprite",
-        message: `${path16.relative(cwd, p)} is on disk but never referenced in ${srcDir}/index.html/CSS \u2014 wire it, or record the one-line reason it was cut. (Computed-string references are invisible here \u2014 check.)`
+        message: `${path17.relative(cwd, p)} is on disk but never referenced in ${srcDir}/index.html/CSS \u2014 wire it, or record the one-line reason it was cut. (Computed-string references are invisible here \u2014 check.)`
       });
     }
   }
@@ -5827,7 +6147,7 @@ async function printUiAuditPreflight(log) {
 }
 async function printPipelineStatePreflight(log, cwd = process.cwd()) {
   try {
-    const design = await fs17.readFile(path17.join(cwd, "DESIGN.md"), "utf8").catch(() => "");
+    const design = await fs18.readFile(path18.join(cwd, "DESIGN.md"), "utf8").catch(() => "");
     const warnings = [];
     if (design.length > 0 && !/##\s*build plan & status/i.test(design)) {
       warnings.push(
@@ -5835,7 +6155,7 @@ async function printPipelineStatePreflight(log, cwd = process.cwd()) {
       );
     }
     if (!/player character:/i.test(design)) {
-      const hasCharacter = await fs17.access(path17.join(cwd, "public", "assets", "meshy-character.json")).then(() => true, () => false);
+      const hasCharacter = await fs18.access(path18.join(cwd, "public", "assets", "meshy-character.json")).then(() => true, () => false);
       if (!hasCharacter && await loadsPlayerBody(cwd)) {
         warnings.push(
           `Player character is the stock avatar \u2014 no generated character is wired. The game's own generated character is the player's body wherever a human body appears on screen, first-person included (genex-ai-character). Generate it, or record "Player character: VRM \u2014 <reason>" in DESIGN.md (no human body in this game / out of credits / player declined).`
@@ -5852,12 +6172,12 @@ async function printPipelineStatePreflight(log, cwd = process.cwd()) {
 async function loadsPlayerBody(cwd) {
   const BODY_LOADERS = /\bloadPlayerCharacter\s*\(|\bloadVrm(?:Clone)?\s*\(/;
   try {
-    const entries = await fs17.readdir(path17.join(cwd, "src"), { recursive: true });
+    const entries = await fs18.readdir(path18.join(cwd, "src"), { recursive: true });
     for (const rel of entries) {
       if (rel.includes("node_modules")) continue;
-      if (rel.split(path17.sep)[0] === "controllers" || rel.startsWith("controllers/")) continue;
+      if (rel.split(path18.sep)[0] === "controllers" || rel.startsWith("controllers/")) continue;
       if (!/\.(ts|tsx|js|jsx)$/.test(rel)) continue;
-      const text = await fs17.readFile(path17.join(cwd, "src", rel), "utf8").catch(() => "");
+      const text = await fs18.readFile(path18.join(cwd, "src", rel), "utf8").catch(() => "");
       if (BODY_LOADERS.test(text)) return true;
     }
   } catch {
@@ -5900,6 +6220,8 @@ async function deployGame(ctx, opts, log) {
     );
     return false;
   }
+  const authority = await prepareAuthorityModule(cwd, opts.authority, log, opts.authorityToolchain);
+  if (authority === false) return false;
   if (!opts.noBuild && await hasBuildScript(cwd)) {
     log.step("Building the production bundle\u2026");
     const built = await run("npm", ["run", "build"]);
@@ -5911,11 +6233,15 @@ async function deployGame(ctx, opts, log) {
     }
     log.success("Built.");
   }
-  const distDir = path17.join(cwd, "dist");
+  const distDir = path18.join(cwd, "dist");
   const siteDir = await isDir(distDir) ? distDir : cwd;
-  const rel = path17.relative(cwd, siteDir) || ".";
+  const rel = path18.relative(cwd, siteDir) || ".";
   if (siteDir === cwd) await writeGitignore(cwd, log);
-  const files = await collectFiles(siteDir);
+  const collected = await collectFiles(siteDir);
+  const files = authority ? collected.filter((f) => !isServerFile(f.relPath)) : collected;
+  if (authority && files.length < collected.length) {
+    log.dim(`  Kept ${collected.length - files.length} server file(s) out of the game's public build.`);
+  }
   if (files.length === 0) {
     log.warn("Nothing to deploy \u2014 the build produced no files.");
     return false;
@@ -5966,6 +6292,7 @@ async function deployGame(ctx, opts, log) {
     log.error(`Build is ${mb2(totalBytes)} MB \u2014 over the ${mb2(grant.limits.maxTotalBytes)} MB limit.`);
     return false;
   }
+  if (authority && !await uploadAuthorityModule(ctx, authority, log)) return false;
   log.step(`Uploading ${files.length} files\u2026`);
   if (!await uploadAll(grant, files, log)) {
     log.error("Couldn't upload your game \u2014 please try again.");
@@ -5985,7 +6312,7 @@ async function deployGame(ctx, opts, log) {
   );
   if (pushed !== true) return false;
   log.step("Publishing\u2026");
-  const published = await callPublish(ctx, commit, opts, log, sourceCommitSha, capabilities);
+  const published = await callPublish(ctx, commit, opts, log, sourceCommitSha, capabilities, authority?.goLive);
   if (!published) return false;
   if (opts.channel === "staging") {
     const pushedHere = opts.sourceDir === void 0;
@@ -6010,7 +6337,7 @@ async function deployGame(ctx, opts, log) {
 }
 async function hasBuildScript(cwd) {
   try {
-    const pkg = JSON.parse(await fs17.readFile(path17.join(cwd, "package.json"), "utf8"));
+    const pkg = JSON.parse(await fs18.readFile(path18.join(cwd, "package.json"), "utf8"));
     return Boolean(pkg.scripts?.build);
   } catch {
     return false;
@@ -6019,12 +6346,12 @@ async function hasBuildScript(cwd) {
 async function collectFiles(root) {
   const out = [];
   const walk2 = async (dir, prefix) => {
-    for (const e of await fs17.readdir(dir, { withFileTypes: true })) {
+    for (const e of await fs18.readdir(dir, { withFileTypes: true })) {
       const relPath = prefix ? `${prefix}/${e.name}` : e.name;
       if (e.isDirectory()) {
-        if (!EXCLUDE_DIRS.has(e.name)) await walk2(path17.join(dir, e.name), relPath);
+        if (!EXCLUDE_DIRS.has(e.name)) await walk2(path18.join(dir, e.name), relPath);
       } else if (e.isFile() && !isSecretEnvFile(e.name)) {
-        out.push({ relPath, bytes: await fs17.readFile(path17.join(dir, e.name)) });
+        out.push({ relPath, bytes: await fs18.readFile(path18.join(dir, e.name)) });
       }
     }
   };
@@ -6032,7 +6359,7 @@ async function collectFiles(root) {
   return out;
 }
 function contentCommit(files) {
-  const h = crypto2.createHash("sha1");
+  const h = crypto3.createHash("sha1");
   for (const f of [...files].sort((a, b) => a.relPath < b.relPath ? -1 : a.relPath > b.relPath ? 1 : 0)) {
     h.update(f.relPath, "utf8");
     h.update("\0");
@@ -6210,7 +6537,7 @@ async function uploadPartWithRetry(base, encoded, auth, uploadId, partNumber, by
     await new Promise((resolve) => setTimeout(resolve, attempt === 0 ? 500 : 2e3));
   }
 }
-async function callPublish(ctx, commit, opts, log, sourceCommitSha, capabilities) {
+async function callPublish(ctx, commit, opts, log, sourceCommitSha, capabilities, authority) {
   let res;
   try {
     res = await apiFetch(`${ctx.apiUrl}/api/games/${ctx.projectId}/publish`, {
@@ -6234,7 +6561,10 @@ async function callPublish(ctx, commit, opts, log, sourceCommitSha, capabilities
         // Recorded into the release history and acted on by nothing. Absent when
         // the source push produced no commit (a user's own repo, or a failure
         // that already stopped the deploy), which the server accepts as null.
-        ...sourceCommitSha ? { sourceCommitSha } : {}
+        ...sourceCommitSha ? { sourceCommitSha } : {},
+        // Last, and only when there is one: a game without a room module sends the body it always
+        // sent, so the channel keeps whatever module it had (absent = keep, on the API).
+        ...authority ? { authority } : {}
       })
     });
   } catch (err) {
@@ -6259,6 +6589,16 @@ async function callPublish(ctx, commit, opts, log, sourceCommitSha, capabilities
     log.dim("  Re-run once the API finishes deploying; the build you meant to keep is still in R2.");
     return null;
   }
+  if (authority && body?.authority?.moduleSha256 !== authority.moduleSha256) {
+    log.error("The server did not record this build's room module, so its multiplayer rooms would not start.");
+    log.dim(`  Your ${asked} build may already be serving${body?.url ? ` at ${body.url}` : ""}. Deploy again once the API is updated.`);
+    return null;
+  }
+  const kept = authority ? void 0 : body?.authority?.moduleSha256;
+  if (typeof kept === "string") {
+    log.warn(`This ${asked} channel still runs the room module from an earlier build (${kept.slice(0, 12)}); this build declares none.`);
+    log.dim("  Its rooms keep that module until a build declares another in genex.authority.");
+  }
   return { url: body?.url ?? "" };
 }
 async function pushSource(sourceDir, ctx, log, branch = "main", expectStagingCommit, onCommit) {
@@ -6296,17 +6636,17 @@ async function pushSource(sourceDir, ctx, log, branch = "main", expectStagingCom
   ) === true;
 }
 async function resolveSourceDir(dir, cwd = process.cwd()) {
-  const abs = path17.resolve(cwd, dir);
-  const stat = await fs17.lstat(abs).catch(() => null);
+  const abs = path18.resolve(cwd, dir);
+  const stat = await fs18.lstat(abs).catch(() => null);
   if (!stat) return { refused: `--source ${abs} does not exist.` };
   if (stat.isSymbolicLink()) {
     return { refused: `--source ${abs} is a symbolic link. Pass the folder itself.` };
   }
   if (!stat.isDirectory()) return { refused: `--source ${abs} is not a folder.` };
-  const real = await fs17.realpath(abs);
-  const project = await fs17.realpath(cwd).catch(() => path17.resolve(cwd));
-  const genex = path17.join(project, ".genex");
-  const genexTarget = await fs17.realpath(genex).catch(() => genex);
+  const real = await fs18.realpath(abs);
+  const project = await fs18.realpath(cwd).catch(() => path18.resolve(cwd));
+  const genex = path18.join(project, ".genex");
+  const genexTarget = await fs18.realpath(genex).catch(() => genex);
   for (const meta of /* @__PURE__ */ new Set([genex, genexTarget])) {
     if (real === meta) {
       return { refused: `--source ${abs} is this project's .genex folder, not the game's source.` };
@@ -6320,8 +6660,8 @@ async function resolveSourceDir(dir, cwd = process.cwd()) {
   return { dir: real };
 }
 function isInside(child, parent) {
-  const rel = path17.relative(parent, child);
-  return rel !== "" && rel !== ".." && !rel.startsWith(`..${path17.sep}`) && !path17.isAbsolute(rel);
+  const rel = path18.relative(parent, child);
+  return rel !== "" && rel !== ".." && !rel.startsWith(`..${path18.sep}`) && !path18.isAbsolute(rel);
 }
 var WORKSPACE_SOURCE_REF = "workspace";
 function gitLfsInstallCommand(platform) {
@@ -6340,7 +6680,7 @@ async function pushWorktree(workTree, pushUrl, managed, log, branch = "main", on
     log.error("Couldn't save your game's source \u2014 please try again.");
     return "failed";
   };
-  const gitDir = await fs17.mkdtemp(path17.join(os5.tmpdir(), "genex-source-"));
+  const gitDir = await fs18.mkdtemp(path18.join(os5.tmpdir(), "genex-source-"));
   const base = { GIT_DIR: gitDir };
   if (urlHasEmbeddedCredentials(pushUrl)) {
     base.GIT_CONFIG_COUNT = "1";
@@ -6355,8 +6695,8 @@ async function pushWorktree(workTree, pushUrl, managed, log, branch = "main", on
   };
   try {
     if ((await run("git", ["init", "-q"], base)).code !== 0) return failed();
-    await fs17.writeFile(path17.join(gitDir, "info", "exclude"), excludeFile());
-    const env = { ...base, GIT_WORK_TREE: workTree, GIT_INDEX_FILE: path17.join(gitDir, "index-source") };
+    await fs18.writeFile(path18.join(gitDir, "info", "exclude"), excludeFile());
+    const env = { ...base, GIT_WORK_TREE: workTree, GIT_INDEX_FILE: path18.join(gitDir, "index-source") };
     let lfs = (await run("git", ["lfs", "version"], base)).code !== 0 ? false : true;
     if (!lfs) {
       log.step("Installing git-lfs (keeps large binary assets out of the source push)\u2026");
@@ -6422,7 +6762,7 @@ async function pushWorktree(workTree, pushUrl, managed, log, branch = "main", on
   } catch {
     return failed();
   } finally {
-    await fs17.rm(gitDir, { recursive: true, force: true }).catch(() => {
+    await fs18.rm(gitDir, { recursive: true, force: true }).catch(() => {
     });
   }
 }
@@ -6483,7 +6823,7 @@ async function fetchPushUrl(ctx, log, expectStagingCommit) {
 }
 async function isDir(p) {
   try {
-    return (await fs17.stat(p)).isDirectory();
+    return (await fs18.stat(p)).isDirectory();
   } catch {
     return false;
   }
@@ -6516,7 +6856,7 @@ async function waitUntilLive(playUrl, fingerprint, timeoutMs, log) {
 }
 
 // src/lib/project.ts
-import crypto3 from "crypto";
+import crypto4 from "crypto";
 async function createDraftProject(opts) {
   const { apiUrl, token, dashboardUrl, log } = opts;
   log.step("Creating your project\u2026");
@@ -6582,7 +6922,7 @@ async function createDraftProject(opts) {
   return { meta: null };
 }
 function randomSuffix() {
-  return crypto3.randomBytes(3).toString("hex");
+  return crypto4.randomBytes(3).toString("hex");
 }
 async function fetchOwnerProject(apiUrl, token, slug) {
   try {
@@ -6606,9 +6946,9 @@ async function fetchOwnerProject(apiUrl, token, slug) {
 }
 
 // src/lib/cover.ts
-import crypto4 from "crypto";
-import fs18 from "fs/promises";
-import path18 from "path";
+import crypto5 from "crypto";
+import fs19 from "fs/promises";
+import path19 from "path";
 var COVER_MAX_BYTES = 8 * 1024 * 1024;
 var COVER_MIN_WIDTH = 320;
 var COVER_MIN_HEIGHT = 180;
@@ -6936,12 +7276,12 @@ function reportCoverOutcome(log, outcome2, opts) {
       return;
   }
 }
-function sha256(bytes) {
-  return crypto4.createHash("sha256").update(bytes).digest("hex");
+function sha2562(bytes) {
+  return crypto5.createHash("sha256").update(bytes).digest("hex");
 }
 async function readCoverMemo(cwd = process.cwd()) {
   try {
-    const memo = JSON.parse(await fs18.readFile(path18.join(cwd, COVER_MEMO), "utf8"));
+    const memo = JSON.parse(await fs19.readFile(path19.join(cwd, COVER_MEMO), "utf8"));
     return typeof memo.sha256 === "string" ? memo : null;
   } catch {
     return null;
@@ -6949,10 +7289,10 @@ async function readCoverMemo(cwd = process.cwd()) {
 }
 async function rememberCoverUpload(bytes, file, outcome2, cwd = process.cwd()) {
   if (!isFinalAnswer(outcome2)) return;
-  const memo = { sha256: sha256(bytes), file, outcome: outcome2.kind, at: (/* @__PURE__ */ new Date()).toISOString() };
+  const memo = { sha256: sha2562(bytes), file, outcome: outcome2.kind, at: (/* @__PURE__ */ new Date()).toISOString() };
   try {
-    await fs18.mkdir(path18.join(cwd, ".genex"), { recursive: true });
-    await fs18.writeFile(path18.join(cwd, COVER_MEMO), JSON.stringify(memo, null, 2) + "\n");
+    await fs19.mkdir(path19.join(cwd, ".genex"), { recursive: true });
+    await fs19.writeFile(path19.join(cwd, COVER_MEMO), JSON.stringify(memo, null, 2) + "\n");
   } catch {
   }
 }
@@ -6961,7 +7301,7 @@ async function findScratchCover(cwd = process.cwd()) {
   for (const name of SCRATCH_COVER_NAMES) {
     const rel = `${SCRATCH_DIR}/${name}`;
     try {
-      const stat = await fs18.stat(path18.join(cwd, rel));
+      const stat = await fs19.stat(path19.join(cwd, rel));
       if (stat.isFile() && (!best || stat.mtimeMs > best.mtime)) best = { rel, mtime: stat.mtimeMs };
     } catch {
     }
@@ -6973,9 +7313,9 @@ async function pickUpScratchCover(args) {
   try {
     const rel = await findScratchCover(cwd);
     if (!rel) return null;
-    const bytes = await fs18.readFile(path18.join(cwd, rel));
+    const bytes = await fs19.readFile(path19.join(cwd, rel));
     const memo = await readCoverMemo(cwd);
-    if (memo?.sha256 === sha256(bytes)) return null;
+    if (memo?.sha256 === sha2562(bytes)) return null;
     const outcome2 = await uploadCover({ apiUrl: args.apiUrl, token: args.token, projectId: args.projectId, bytes, label: rel });
     reportCoverOutcome(args.log, outcome2, {
       label: rel,
@@ -7036,7 +7376,10 @@ async function runPreview(opts) {
       embedSdkVersion: detections.embedSdkVersion,
       multiplayer: detections.multiplayer,
       mobileControls: detections.mobileControls,
-      capabilities: detections.capabilities
+      capabilities: detections.capabilities,
+      // The room module, when the game declares one: bundled, validated and uploaded with this
+      // staging build (promote carries it to production with the build).
+      authority: detections.authority
     },
     log
   );
@@ -7109,28 +7452,28 @@ function loggerFor(opts) {
 }
 async function readState(directory) {
   try {
-    const marker = path19.join(directory, ".genex", "remix-operation.json");
-    if ((await fs19.lstat(marker)).isSymbolicLink()) return null;
-    const value = JSON.parse(await fs19.readFile(marker, "utf8"));
+    const marker = path20.join(directory, ".genex", "remix-operation.json");
+    if ((await fs20.lstat(marker)).isSymbolicLink()) return null;
+    const value = JSON.parse(await fs20.readFile(marker, "utf8"));
     return value.schema === 1 && value.directory === directory && typeof value.operationId === "string" && /^[a-zA-Z0-9_-]{8,128}$/.test(value.operationId) && value.source && /^[a-f0-9]{40}$/.test(value.source.sourceCommitSha) ? value : null;
   } catch {
     return null;
   }
 }
 async function saveState(state) {
-  const dir = path19.join(state.directory, ".genex");
-  await fs19.mkdir(dir, { recursive: true, mode: 448 });
-  const temp = path19.join(dir, "remix-operation.next.json");
-  await fs19.writeFile(temp, JSON.stringify(state, null, 2) + "\n", { mode: 384 });
-  await fs19.rename(temp, path19.join(dir, "remix-operation.json"));
+  const dir = path20.join(state.directory, ".genex");
+  await fs20.mkdir(dir, { recursive: true, mode: 448 });
+  const temp = path20.join(dir, "remix-operation.next.json");
+  await fs20.writeFile(temp, JSON.stringify(state, null, 2) + "\n", { mode: 384 });
+  await fs20.rename(temp, path20.join(dir, "remix-operation.json"));
 }
 async function checkDestination(directory) {
   try {
-    const stat = await fs19.lstat(directory);
+    const stat = await fs20.lstat(directory);
     if (!stat.isDirectory() || stat.isSymbolicLink()) throw new RemixError("destination_occupied", "The destination is not a fresh directory. Choose a new folder.");
-    const entries = await fs19.readdir(directory);
+    const entries = await fs20.readdir(directory);
     if (!entries.length) return null;
-    const genex = await fs19.lstat(path19.join(directory, ".genex")).catch(() => null);
+    const genex = await fs20.lstat(path20.join(directory, ".genex")).catch(() => null);
     const state = genex?.isDirectory() && !genex.isSymbolicLink() ? await readState(directory) : null;
     if (state) return state;
     throw new RemixError("destination_occupied", "The destination already contains files. Choose a fresh folder; remix never clears an existing project.");
@@ -7141,7 +7484,7 @@ async function checkDestination(directory) {
 }
 async function assertReferenceParents(cwd) {
   for (const rel of [".genex", ".genex/refs"]) {
-    const stat = await fs19.lstat(path19.join(cwd, rel)).catch((err) => {
+    const stat = await fs20.lstat(path20.join(cwd, rel)).catch((err) => {
       if (err.code === "ENOENT") return null;
       throw err;
     });
@@ -7149,41 +7492,41 @@ async function assertReferenceParents(cwd) {
   }
 }
 async function archiveSourceInstructions(directory) {
-  const archive = path19.join(directory, ".genex", "source-instructions");
+  const archive = path20.join(directory, ".genex", "source-instructions");
   const rootArtifacts = /* @__PURE__ */ new Set([".claude", ".codex", ".cursor", ".agents", ".mcp.json", ".cursorrules", "DESIGN.md"]);
   const instructionNames = /* @__PURE__ */ new Set(["AGENTS.md", "CLAUDE.md", "GEMINI.md"]);
   const visit = async (dir) => {
-    for (const entry of await fs19.readdir(dir, { withFileTypes: true })) {
+    for (const entry of await fs20.readdir(dir, { withFileTypes: true })) {
       if (entry.name === ".genex" || entry.name === ".git" || entry.name === "node_modules") continue;
-      const from = path19.join(dir, entry.name), rel = path19.relative(directory, from);
+      const from = path20.join(dir, entry.name), rel = path20.relative(directory, from);
       if (instructionNames.has(entry.name) || dir === directory && rootArtifacts.has(entry.name)) {
-        const to = path19.join(archive, rel);
-        await fs19.mkdir(path19.dirname(to), { recursive: true });
-        if (await fs19.lstat(to).catch(() => null)) throw new RemixError("destination_changed", `Source instructions at ${rel} changed during preparation; both copies were retained.`);
-        await fs19.rename(from, to);
+        const to = path20.join(archive, rel);
+        await fs20.mkdir(path20.dirname(to), { recursive: true });
+        if (await fs20.lstat(to).catch(() => null)) throw new RemixError("destination_changed", `Source instructions at ${rel} changed during preparation; both copies were retained.`);
+        await fs20.rename(from, to);
       } else if (entry.isDirectory()) await visit(from);
     }
   };
   await visit(directory);
 }
 async function acquireLock(directory) {
-  const lock = path19.join(directory, ".genex", "remix.lock");
+  const lock = path20.join(directory, ".genex", "remix.lock");
   for (let attempt = 0; attempt < 2; attempt++) {
     try {
-      const handle = await fs19.open(lock, "wx", 384);
+      const handle = await fs20.open(lock, "wx", 384);
       await handle.writeFile(String(process.pid));
       await handle.close();
-      return () => fs19.unlink(lock).catch(() => {
+      return () => fs20.unlink(lock).catch(() => {
       });
     } catch (err) {
       if (err.code !== "EEXIST") throw err;
-      const pid = Number(await fs19.readFile(lock, "utf8").catch(() => ""));
+      const pid = Number(await fs20.readFile(lock, "utf8").catch(() => ""));
       if (!Number.isInteger(pid) || pid <= 0) throw new RemixError("remix_in_progress", "Another remix owns this destination. Retry after it finishes.");
       try {
         process.kill(pid, 0);
       } catch (probe) {
         if (probe.code === "ESRCH") {
-          await fs19.unlink(lock);
+          await fs20.unlink(lock);
           continue;
         }
       }
@@ -7269,13 +7612,13 @@ function pinRemixDependencies(pkg, version) {
   return warnings;
 }
 async function installRemixDependencies(cwd, pm, version, log, runner = childRun) {
-  const pkgPath = path19.join(cwd, "package.json");
-  const pkg = JSON.parse(await fs19.readFile(pkgPath, "utf8"));
+  const pkgPath = path20.join(cwd, "package.json");
+  const pkg = JSON.parse(await fs20.readFile(pkgPath, "utf8"));
   const warnings = pinRemixDependencies(pkg, version);
-  await fs19.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+  await fs20.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
   log.step(`Restoring dependencies with ${pm}; pinning ${CLI_PACKAGE}@${version} (${CLI_CHANNEL}).`);
   const args = pm === "npm" ? ["install", "--workspaces=false", "--no-audit", "--no-fund"] : pm === "pnpm" ? ["install", "--ignore-workspace", "--no-frozen-lockfile"] : ["install"];
-  if (pm === "yarn") await fs19.writeFile(path19.join(cwd, "yarn.lock"), "", { flag: "wx" }).catch((err) => {
+  if (pm === "yarn") await fs20.writeFile(path20.join(cwd, "yarn.lock"), "", { flag: "wx" }).catch((err) => {
     if (err.code !== "EEXIST") throw err;
   });
   await runner(cwd, pm, args);
@@ -7309,27 +7652,27 @@ function rebindRemixConfig(content, slug) {
 async function configureIdentity(state, log) {
   const cwd = state.directory, meta = state.project;
   await writeProject(meta, cwd);
-  const configFile = path19.join(cwd, "src", "genex.config.ts");
-  const config = await fs19.readFile(configFile, "utf8").catch((err) => {
+  const configFile = path20.join(cwd, "src", "genex.config.ts");
+  const config = await fs20.readFile(configFile, "utf8").catch((err) => {
     if (err.code === "ENOENT") return null;
     throw err;
   });
-  if (config !== null) await fs19.writeFile(configFile, rebindRemixConfig(config, meta.slug));
+  if (config !== null) await fs20.writeFile(configFile, rebindRemixConfig(config, meta.slug));
   await writeGameConfigFiles(meta, log, cwd);
   await writeGitignore(cwd, log);
   await installRemixProfile(cwd, state.apiUrl, log);
-  const manifestFile = path19.join(cwd, "package.json");
-  const manifest = JSON.parse(await fs19.readFile(manifestFile, "utf8"));
+  const manifestFile = path20.join(cwd, "package.json");
+  const manifest = JSON.parse(await fs20.readFile(manifestFile, "utf8"));
   manifest.genex.remixSource = { projectId: state.source.projectId, slug: state.source.slug, sourceCommitSha: state.source.sourceCommitSha, version: state.source.version, versionCertainty: state.source.versionCertainty };
-  await fs19.writeFile(manifestFile, JSON.stringify(manifest, null, 2) + "\n");
+  await fs20.writeFile(manifestFile, JSON.stringify(manifest, null, 2) + "\n");
   const possible = [];
   const quoted = new RegExp(`(["'\`])(?:${state.source.slug.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}|${state.source.projectId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")})\\1`);
   const scan = async (dir) => {
-    for (const entry of await fs19.readdir(dir, { withFileTypes: true })) {
+    for (const entry of await fs20.readdir(dir, { withFileTypes: true })) {
       if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-      const file = path19.join(dir, entry.name);
+      const file = path20.join(dir, entry.name);
       if (entry.isDirectory()) await scan(file);
-      else if (entry.isFile() && /\.(?:[cm]?[jt]sx?|html)$/.test(entry.name) && (await fs19.stat(file)).size < 1024 * 1024 && quoted.test(await fs19.readFile(file, "utf8"))) possible.push(path19.relative(cwd, file));
+      else if (entry.isFile() && /\.(?:[cm]?[jt]sx?|html)$/.test(entry.name) && (await fs20.stat(file)).size < 1024 * 1024 && quoted.test(await fs20.readFile(file, "utf8"))) possible.push(path20.relative(cwd, file));
     }
   };
   await scan(cwd);
@@ -7354,7 +7697,7 @@ async function runRemix(opts, deps = {}) {
     const apiUrl = getApiUrl(opts.apiUrl), dashboardUrl = new URL(getAuthUrl(opts.authUrl)).origin;
     if (opts.sourceOnly && !opts.destination) await assertReferenceParents(originalCwd);
     const selected = parseRemixSource(opts.remixSource, apiUrl, dashboardUrl);
-    let directory = opts.destination ? path19.resolve(originalCwd, opts.destination) : !opts.sourceOnly ? path19.resolve(originalCwd, `${selected.slug}-remix`) : void 0;
+    let directory = opts.destination ? path20.resolve(originalCwd, opts.destination) : !opts.sourceOnly ? path20.resolve(originalCwd, `${selected.slug}-remix`) : void 0;
     if (directory) state = await checkDestination(directory);
     resumed = state !== null;
     if (state && (state.apiUrl !== apiUrl || state.sourceOnly !== Boolean(opts.sourceOnly) || ![state.requestedSlug, state.source.slug].includes(selected.slug) || opts.operationId && state.operationId !== opts.operationId || opts.name && state.name !== opts.name || selected.version && selected.version !== state.source.version)) throw new RemixError("operation_mismatch", "This folder belongs to a different remix operation. Resume with its original source/options or choose a fresh folder.");
@@ -7372,29 +7715,29 @@ async function runRemix(opts, deps = {}) {
       log.step(`Resolving source for ${selected.slug}\u2026`);
       const body = await responseJson(await request(`${apiUrl}/api/projects/${encodeURIComponent(selected.slug)}/source?${query}`, { headers, redirect: "error" }));
       validateSource(body, Boolean(opts.sourceOnly));
-      directory ??= path19.resolve(originalCwd, ".genex", "refs", `${body.source.slug}-${body.source.sourceCommitSha.slice(0, 12)}`);
+      directory ??= path20.resolve(originalCwd, ".genex", "refs", `${body.source.slug}-${body.source.sourceCommitSha.slice(0, 12)}`);
       const existing = await checkDestination(directory);
       if (existing) {
         if (!existing.sourceOnly || !opts.sourceOnly || existing.apiUrl !== apiUrl || existing.source.sourceCommitSha !== body.source.sourceCommitSha || existing.source.projectId !== body.source.projectId) throw new RemixError("destination_occupied", "This reference destination already belongs to another operation. Choose a fresh folder.");
         state = existing;
         resumed = true;
       } else {
-        state = { schema: 1, operationId: opts.operationId ?? crypto5.randomUUID(), directory, apiUrl, dashboardUrl, requestedSlug: selected.slug, source: body.source, sourceToken: body.sourceToken, sourceOnly: Boolean(opts.sourceOnly), cliVersion: getCliVersion(), name: opts.name?.trim() || `${body.source.title.slice(0, 74)} remix`, stage: "download", warnings: [...body.source.warnings] };
-        await fs19.mkdir(directory, { recursive: true });
-        if ((await fs19.readdir(directory)).length) throw new RemixError("destination_occupied", "The destination changed during setup. Choose a fresh folder.");
-        await fs19.mkdir(path19.join(directory, ".genex"), { mode: 448 });
+        state = { schema: 1, operationId: opts.operationId ?? crypto6.randomUUID(), directory, apiUrl, dashboardUrl, requestedSlug: selected.slug, source: body.source, sourceToken: body.sourceToken, sourceOnly: Boolean(opts.sourceOnly), cliVersion: getCliVersion(), name: opts.name?.trim() || `${body.source.title.slice(0, 74)} remix`, stage: "download", warnings: [...body.source.warnings] };
+        await fs20.mkdir(directory, { recursive: true });
+        if ((await fs20.readdir(directory)).length) throw new RemixError("destination_occupied", "The destination changed during setup. Choose a fresh folder.");
+        await fs20.mkdir(path20.join(directory, ".genex"), { mode: 448 });
         await saveState(state);
       }
     }
     unlock = await acquireLock(state.directory);
     state = await readState(state.directory) ?? state;
     if (resumed && state.stage === "download") await renewSource(state, request, headers);
-    const staging = path19.join(state.directory, ".genex", "remix-stage");
+    const staging = path20.join(state.directory, ".genex", "remix-stage");
     if (state.stage === "download") {
-      await fs19.rm(staging, { recursive: true, force: true });
-      await fs19.mkdir(staging, { recursive: true });
-      const archive = path19.join(staging, "source.zip"), sourceDir = path19.join(staging, "source");
-      await fs19.mkdir(sourceDir);
+      await fs20.rm(staging, { recursive: true, force: true });
+      await fs20.mkdir(staging, { recursive: true });
+      const archive = path20.join(staging, "source.zip"), sourceDir = path20.join(staging, "source");
+      await fs20.mkdir(sourceDir);
       const archiveUrl = new URL(state.source.archiveUrl, state.apiUrl);
       if (archiveUrl.origin !== new URL(state.apiUrl).origin || !archiveUrl.pathname.startsWith("/api/projects/")) throw new RemixError("invalid_source_response", "Source archive must be served by the selected Genex API.");
       log.step(`Downloading ${state.source.slug} at ${state.source.sourceCommitSha.slice(0, 12)}\u2026`);
@@ -7409,26 +7752,26 @@ async function runRemix(opts, deps = {}) {
       if (!state.sourceOnly) {
         let pkg;
         try {
-          pkg = JSON.parse(await fs19.readFile(path19.join(sourceDir, "package.json"), "utf8"));
+          pkg = JSON.parse(await fs20.readFile(path20.join(sourceDir, "package.json"), "utf8"));
         } catch (error) {
-          const staticEntry = await fs19.stat(path19.join(sourceDir, "index.html")).catch(() => null);
+          const staticEntry = await fs20.stat(path20.join(sourceDir, "index.html")).catch(() => null);
           if (error.code !== "ENOENT" || !staticEntry?.isFile()) throw new RemixError("source_unavailable", "Source has neither a readable package.json nor a static index.html. Use --source-only to inspect it.");
           pkg = { name: manifestName(state.directory), private: true };
-          await fs19.writeFile(path19.join(sourceDir, "package.json"), JSON.stringify(pkg, null, 2) + "\n");
+          await fs20.writeFile(path20.join(sourceDir, "package.json"), JSON.stringify(pkg, null, 2) + "\n");
           state.warnings.push("This static game had no package.json; added a minimal private manifest for the local CLI. Its source and index.html remain unchanged.");
         }
         if (!pkg || typeof pkg !== "object" || Array.isArray(pkg)) throw new RemixError("source_unavailable", "Source package.json is not a project manifest.");
       }
-      state.transferEntries = await fs19.readdir(sourceDir);
+      state.transferEntries = await fs20.readdir(sourceDir);
       state.stage = "transfer";
       await saveState(state);
     }
     if (state.stage === "transfer") {
       for (const entry of state.transferEntries ?? []) {
-        const from = path19.join(staging, "source", entry), to = path19.join(state.directory, entry);
-        if (await fs19.lstat(from).catch(() => null)) {
-          if (await fs19.lstat(to).catch(() => null)) throw new RemixError("destination_changed", `A file appeared at ${entry} during source preparation. It was left untouched.`);
-          await fs19.rename(from, to);
+        const from = path20.join(staging, "source", entry), to = path20.join(state.directory, entry);
+        if (await fs20.lstat(from).catch(() => null)) {
+          if (await fs20.lstat(to).catch(() => null)) throw new RemixError("destination_changed", `A file appeared at ${entry} during source preparation. It was left untouched.`);
+          await fs20.rename(from, to);
         }
       }
       if (!state.sourceOnly) {
@@ -7437,7 +7780,7 @@ async function runRemix(opts, deps = {}) {
       }
       state.stage = state.sourceOnly ? "prepared" : "configure";
       await saveState(state);
-      await fs19.rm(staging, { recursive: true, force: true });
+      await fs20.rm(staging, { recursive: true, force: true });
     }
     process.chdir(state.directory);
     if (state.stage === "configure") {
@@ -7508,18 +7851,18 @@ async function runRemix(opts, deps = {}) {
 }
 
 // src/commands/init.ts
-import fs23 from "fs/promises";
-import path22 from "path";
+import fs24 from "fs/promises";
+import path23 from "path";
 
 // src/lib/item-drafts.ts
 import { createHash as createHash2, randomBytes } from "crypto";
 import { constants as fsConstants2 } from "fs";
-import fs22 from "fs/promises";
+import fs23 from "fs/promises";
 import os6 from "os";
-import path21 from "path";
+import path22 from "path";
 
 // src/lib/item-media.ts
-import fs20 from "fs/promises";
+import fs21 from "fs/promises";
 var MIB = 1024 * 1024;
 var MediaKind = { Picture: "picture", Model: "model" };
 var MediaContentType = {
@@ -7553,7 +7896,7 @@ async function readItemMedia(kind, file) {
   }
   let size;
   try {
-    const stat = await fs20.stat(file);
+    const stat = await fs21.stat(file);
     if (!stat.isFile()) throw new Error("not a file");
     size = stat.size;
   } catch {
@@ -7563,7 +7906,7 @@ async function readItemMedia(kind, file) {
   if (size > max) {
     throw new ItemMediaError(`${file} is ${Math.ceil(size / MIB * 10) / 10} MB; ${kind === MediaKind.Picture ? "a picture" : "a model"} may be at most ${max / MIB} MB.`);
   }
-  const bytes = await fs20.readFile(file);
+  const bytes = await fs21.readFile(file);
   const contentType = mediaContentType(kind, bytes);
   if (!contentType) {
     throw new ItemMediaError(
@@ -7576,8 +7919,8 @@ async function readItemMedia(kind, file) {
 // src/lib/item-package.ts
 import { createHash } from "crypto";
 import { constants as fsConstants } from "fs";
-import fs21 from "fs/promises";
-import path20 from "path";
+import fs22 from "fs/promises";
+import path21 from "path";
 import zlib from "zlib";
 var MIB2 = 1024 * 1024;
 var ITEM_PACKAGE_BYTES_MAX = 50 * MIB2;
@@ -7656,16 +7999,16 @@ async function packItemDirectory(dir) {
 }
 async function realDirectory(dir) {
   try {
-    const root = await fs21.realpath(dir);
-    if ((await fs21.stat(root)).isDirectory()) return root;
+    const root = await fs22.realpath(dir);
+    if ((await fs22.stat(root)).isDirectory()) return root;
   } catch {
   }
   throw new ItemPackageError(PackageErrorCode.DirMissing, `${dir} is not a folder.`);
 }
 async function insideRoot(root, candidate) {
   try {
-    const real = await fs21.realpath(candidate);
-    return real === root || real.startsWith(root + path20.sep);
+    const real = await fs22.realpath(candidate);
+    return real === root || real.startsWith(root + path21.sep);
   } catch {
     return false;
   }
@@ -7681,10 +8024,10 @@ function portableName(relPath) {
 }
 var byName = (a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0;
 async function collect(root, abs, rel, out) {
-  const entries = (await fs21.readdir(abs, { withFileTypes: true })).sort(byName);
+  const entries = (await fs22.readdir(abs, { withFileTypes: true })).sort(byName);
   for (const entry of entries) {
     const relPath = rel ? `${rel}/${entry.name}` : entry.name;
-    const full = path20.join(abs, entry.name);
+    const full = path21.join(abs, entry.name);
     const excluded = packExclusion(relPath, entry.name);
     if (excluded) {
       out.skipped.push({ path: relPath, reason: excluded });
@@ -7722,10 +8065,10 @@ async function collect(root, abs, rel, out) {
   }
 }
 async function readRegularFile(root, full) {
-  if (!await insideRoot(root, path20.dirname(full))) return PackSkip.Symlink;
+  if (!await insideRoot(root, path21.dirname(full))) return PackSkip.Symlink;
   let handle;
   try {
-    handle = await fs21.open(full, fsConstants.O_RDONLY | (fsConstants.O_NOFOLLOW ?? 0));
+    handle = await fs22.open(full, fsConstants.O_RDONLY | (fsConstants.O_NOFOLLOW ?? 0));
   } catch {
     return PackSkip.Symlink;
   }
@@ -7933,14 +8276,14 @@ function entryBytes(zip, entry) {
   if (sourceCrc32(data) !== entry.crc) invalid(`${entry.path} fails its checksum.`, entry.path);
   return data;
 }
-var sha2562 = (data) => createHash("sha256").update(data).digest("hex");
+var sha2563 = (data) => createHash("sha256").update(data).digest("hex");
 function checkAgainstManifest(zip, files, manifest) {
   const expected = new Map(manifest.files.map((f) => [f.path, f]));
   if (expected.size !== manifest.files.length) throw new ItemPackageError(PackageErrorCode.Mismatch, "The package's manifest lists a file twice.");
   for (const file of files) {
     const want = expected.get(file.path);
     if (!want) throw new ItemPackageError(PackageErrorCode.Mismatch, `${file.path} is in the package but not in its manifest.`, file.path);
-    if (want.bytes !== file.size || want.sha256.toLowerCase() !== sha2562(entryBytes(zip, file))) {
+    if (want.bytes !== file.size || want.sha256.toLowerCase() !== sha2563(entryBytes(zip, file))) {
       throw new ItemPackageError(PackageErrorCode.Mismatch, `${file.path} is not the file the manifest recorded.`, file.path);
     }
     expected.delete(file.path);
@@ -7959,7 +8302,7 @@ async function extractItemPackage(zip, dest, manifest) {
   for (const file of files) entryBytes(zip, file);
   if (manifest) checkAgainstManifest(zip, files, manifest);
   try {
-    await fs21.mkdir(dest);
+    await fs22.mkdir(dest);
   } catch (err) {
     if (err.code === "EEXIST") {
       throw new ItemPackageError(PackageErrorCode.DestinationExists, `${dest} already exists.`);
@@ -7967,13 +8310,13 @@ async function extractItemPackage(zip, dest, manifest) {
     throw err;
   }
   for (const entry of entries) {
-    const target = path20.join(dest, ...entry.path.split("/"));
+    const target = path21.join(dest, ...entry.path.split("/"));
     if (entry.dir) {
-      await fs21.mkdir(target, { recursive: true });
+      await fs22.mkdir(target, { recursive: true });
       continue;
     }
-    await fs21.mkdir(path20.dirname(target), { recursive: true });
-    await fs21.writeFile(target, entryBytes(zip, entry), { flag: "wx", mode: FILE_MODE });
+    await fs22.mkdir(path21.dirname(target), { recursive: true });
+    await fs22.writeFile(target, entryBytes(zip, entry), { flag: "wx", mode: FILE_MODE });
   }
   return files.map((f) => f.path);
 }
@@ -8200,7 +8543,7 @@ function isLocalId(value) {
 function newLocalId() {
   return `${LOCAL_ID_PREFIX}${randomBytes(6).toString("hex")}`;
 }
-var sha2563 = (bytes) => createHash2("sha256").update(bytes).digest("hex");
+var sha2564 = (bytes) => createHash2("sha256").update(bytes).digest("hex");
 function contentHash(fields, files) {
   const canonical = JSON.stringify({
     description: fields.description ?? null,
@@ -8213,9 +8556,9 @@ function contentHash(fields, files) {
   const parts = [canonical];
   for (const kind of FILE_ORDER) {
     const bytes = files[kind];
-    if (bytes) parts.push(`${kind}:${sha2563(bytes)}`);
+    if (bytes) parts.push(`${kind}:${sha2564(bytes)}`);
   }
-  return sha2563(parts.join("\n"));
+  return sha2564(parts.join("\n"));
 }
 function draftLine(draft) {
   const { record } = draft;
@@ -8245,13 +8588,13 @@ var machineFolder = () => new LocalDraftError(
   "This is the home folder: its .genex is this machine's Genex folder (sign-in and caches), not a game's. Run it in the game's folder; nothing was read or written."
 );
 async function isHomeFolder(cwd) {
-  const [here, home] = await Promise.all([fs22.realpath(cwd), fs22.realpath(os6.homedir()).catch(() => path21.resolve(os6.homedir()))]);
+  const [here, home] = await Promise.all([fs23.realpath(cwd), fs23.realpath(os6.homedir()).catch(() => path22.resolve(os6.homedir()))]);
   return here === home;
 }
-var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 async function lstatOrNull(full) {
   try {
-    return await fs22.lstat(full);
+    return await fs23.lstat(full);
   } catch (err) {
     if (err.code === "ENOENT") return null;
     throw err;
@@ -8259,8 +8602,8 @@ async function lstatOrNull(full) {
 }
 var isRealFolder = (stat) => stat !== null && stat.isDirectory() && !stat.isSymbolicLink();
 async function itemsFolder(cwd, create) {
-  const genex = path21.join(cwd, ".genex");
-  const items = path21.join(genex, "items");
+  const genex = path22.join(cwd, ".genex");
+  const items = path22.join(genex, "items");
   if (await isHomeFolder(cwd)) {
     if (!create && !await lstatOrNull(items)) return null;
     throw machineFolder();
@@ -8269,22 +8612,22 @@ async function itemsFolder(cwd, create) {
     let stat = await lstatOrNull(dir);
     if (!stat && !create) return null;
     if (!stat) {
-      await fs22.mkdir(dir).catch((err) => {
+      await fs23.mkdir(dir).catch((err) => {
         if (err.code !== "EEXIST") throw err;
       });
       stat = await lstatOrNull(dir);
     }
     if (!isRealFolder(stat)) throw folderRefused(rel);
   }
-  const [root, real] = await Promise.all([fs22.realpath(cwd), fs22.realpath(items)]);
-  if (real !== path21.join(root, ".genex", "items")) throw folderRefused(LOCAL_ITEMS_DIR);
+  const [root, real] = await Promise.all([fs23.realpath(cwd), fs23.realpath(items)]);
+  if (real !== path22.join(root, ".genex", "items")) throw folderRefused(LOCAL_ITEMS_DIR);
   return items;
 }
 async function draftFolder(items, localId, create) {
-  const dir = path21.join(items, localId);
+  const dir = path22.join(items, localId);
   let stat = await lstatOrNull(dir);
   if (!stat && create) {
-    await fs22.mkdir(dir).catch((err) => {
+    await fs23.mkdir(dir).catch((err) => {
       if (err.code !== "EEXIST") throw err;
     });
     stat = await lstatOrNull(dir);
@@ -8307,7 +8650,7 @@ async function readStored(full, max) {
   if (stat.isSymbolicLink()) throw new StoredFileError(ReadRefusal.Link);
   let handle;
   try {
-    handle = await fs22.open(full, fsConstants2.O_RDONLY | (fsConstants2.O_NOFOLLOW ?? 0));
+    handle = await fs23.open(full, fsConstants2.O_RDONLY | (fsConstants2.O_NOFOLLOW ?? 0));
   } catch (err) {
     if (err.code === "ENOENT") throw new StoredFileError(ReadRefusal.Missing);
     throw new StoredFileError(ReadRefusal.Link);
@@ -8362,7 +8705,7 @@ function checkFields(raw, label) {
 }
 var RECORD_KEYS = /* @__PURE__ */ new Set(["localId", "name", "description", "priceCoins", "type", "tags", "shareable", "files", "createdAt", "updatedAt"]);
 function checkFileNames(files, label) {
-  if (!isRecord(files)) throw invalid2(`${label} is not a draft this CLI wrote: its files are not a list of names.`);
+  if (!isRecord2(files)) throw invalid2(`${label} is not a draft this CLI wrote: its files are not a list of names.`);
   const out = {};
   for (const [kind, name] of Object.entries(files)) {
     if (!FILE_ORDER.includes(kind)) throw invalid2(`${label} names a file kind no draft has (${JSON.stringify(kind.slice(0, 40))}).`);
@@ -8376,7 +8719,7 @@ function checkFileNames(files, label) {
 }
 function parseDraftRecord(raw, fileId) {
   const label = `${LOCAL_ITEMS_DIR}/${fileId}.json`;
-  if (!isRecord(raw)) throw invalid2(`${label} is not a draft this CLI wrote: it is not an object.`);
+  if (!isRecord2(raw)) throw invalid2(`${label} is not a draft this CLI wrote: it is not an object.`);
   const extra = Object.keys(raw).find((key) => !RECORD_KEYS.has(key));
   if (extra !== void 0) throw invalid2(`${label} is not a draft this CLI wrote: it has a field no draft has (${JSON.stringify(extra.slice(0, 40))}).`);
   if (raw.localId !== fileId) throw invalid2(`${label} is not a draft this CLI wrote: its localId is not its file name.`);
@@ -8409,7 +8752,7 @@ async function readRecord2(items, localId) {
   const rel = `${LOCAL_ITEMS_DIR}/${localId}.json`;
   let text;
   try {
-    text = await readStored(path21.join(items, `${localId}.json`), DRAFT_FILE_BYTES_MAX);
+    text = await readStored(path22.join(items, `${localId}.json`), DRAFT_FILE_BYTES_MAX);
   } catch (err) {
     if (!(err instanceof StoredFileError)) throw err;
     if (err.reason === ReadRefusal.Missing) throw notFound(localId);
@@ -8434,7 +8777,7 @@ async function readDraft(items, localId) {
       const rel = `${LOCAL_ITEMS_DIR}/${localId}/${name}`;
       let bytes;
       try {
-        bytes = await readStored(path21.join(dir, name), FILE_BYTES_MAX[kind]);
+        bytes = await readStored(path22.join(dir, name), FILE_BYTES_MAX[kind]);
       } catch (err) {
         if (err instanceof StoredFileError) throw unreadable(rel, err.reason, FILE_BYTES_MAX[kind]);
         throw err;
@@ -8453,7 +8796,7 @@ async function loadLocalDraft(cwd, localId) {
 }
 var isDraftFileName = (name) => name.endsWith(".json") && name !== LAST_SYNC_FILE;
 async function draftFileNames(items) {
-  return (await fs22.readdir(items)).filter(isDraftFileName).sort();
+  return (await fs23.readdir(items)).filter(isDraftFileName).sort();
 }
 async function holdsDraftFiles(items) {
   return (await draftFileNames(items)).length > 0;
@@ -8489,12 +8832,12 @@ async function listLocalDrafts(cwd) {
   return { drafts, refused };
 }
 async function writeReplacing(target, bytes) {
-  const temporary = path21.join(path21.dirname(target), `.${path21.basename(target)}.${randomBytes(4).toString("hex")}.tmp`);
-  await fs22.writeFile(temporary, bytes, { flag: "wx", mode: 420 });
+  const temporary = path22.join(path22.dirname(target), `.${path22.basename(target)}.${randomBytes(4).toString("hex")}.tmp`);
+  await fs23.writeFile(temporary, bytes, { flag: "wx", mode: 420 });
   try {
-    await fs22.rename(temporary, target);
+    await fs23.rename(temporary, target);
   } catch (err) {
-    await fs22.rm(temporary, { force: true });
+    await fs23.rm(temporary, { force: true });
     throw err;
   }
 }
@@ -8507,13 +8850,13 @@ async function storeDraft(items, record, newFiles) {
   if (newFiles.package) incoming.push([DraftFileKind.Package, STORED_NAMES.package[0] ?? "", newFiles.package]);
   for (const [kind, name, bytes] of incoming) {
     if (!STORED_NAMES[kind].includes(name)) throw invalid2(`A ${kind} of that type cannot be stored with a draft.`);
-    await writeReplacing(path21.join(dir, name), bytes);
+    await writeReplacing(path22.join(dir, name), bytes);
     const previous = files[kind];
-    if (previous && previous !== name) await fs22.rm(path21.join(dir, previous), { force: true });
+    if (previous && previous !== name) await fs23.rm(path22.join(dir, previous), { force: true });
     files[kind] = name;
   }
   const stored = { ...record, files };
-  await writeReplacing(path21.join(items, `${record.localId}.json`), `${JSON.stringify(orderedRecord(stored), null, 2)}
+  await writeReplacing(path22.join(items, `${record.localId}.json`), `${JSON.stringify(orderedRecord(stored), null, 2)}
 `);
   return readDraft(items, record.localId);
 }
@@ -8536,7 +8879,7 @@ async function createLocalDraft(cwd, fields, files, now = /* @__PURE__ */ new Da
   if (!items) throw folderRefused(LOCAL_ITEMS_DIR);
   for (let attempt = 0; attempt < NEW_ID_ATTEMPTS; attempt++) {
     const localId = newLocalId();
-    const taken = await lstatOrNull(path21.join(items, `${localId}.json`)) ?? await lstatOrNull(path21.join(items, localId));
+    const taken = await lstatOrNull(path22.join(items, `${localId}.json`)) ?? await lstatOrNull(path22.join(items, localId));
     if (taken) continue;
     const stamp = now.toISOString();
     return storeDraft(items, { localId, ...fields, files: {}, createdAt: stamp, updatedAt: stamp }, files);
@@ -8558,26 +8901,26 @@ async function removeLocalDraft(cwd, localId) {
 }
 async function removeFrom(items, localId) {
   const record = await readRecord2(items, localId);
-  const dir = path21.join(items, localId);
+  const dir = path22.join(items, localId);
   const stat = await lstatOrNull(dir);
   if (stat && !isRealFolder(stat)) throw folderRefused(`${LOCAL_ITEMS_DIR}/${localId}`);
-  await fs22.rm(path21.join(items, `${localId}.json`), { force: true });
-  if (stat) await fs22.rm(dir, { recursive: true, force: true });
+  await fs23.rm(path22.join(items, `${localId}.json`), { force: true });
+  if (stat) await fs23.rm(dir, { recursive: true, force: true });
   return record;
 }
 async function removeSyncedDraft(items, localId) {
   await removeFrom(items, localId);
 }
 async function writeLastSync(items, document) {
-  await writeReplacing(path21.join(items, LAST_SYNC_FILE), `${JSON.stringify(document)}
+  await writeReplacing(path22.join(items, LAST_SYNC_FILE), `${JSON.stringify(document)}
 `);
 }
 async function takeSyncLock(items, now = Date.now()) {
-  const lock = path21.join(items, SYNC_LOCK_FILE);
+  const lock = path22.join(items, SYNC_LOCK_FILE);
   const body = JSON.stringify({ pid: process.pid, at: new Date(now).toISOString() });
   const create = async () => {
     try {
-      await fs22.writeFile(lock, body, { flag: "wx", mode: 420 });
+      await fs23.writeFile(lock, body, { flag: "wx", mode: 420 });
       return true;
     } catch (err) {
       if (err.code === "EEXIST") return false;
@@ -8588,11 +8931,11 @@ async function takeSyncLock(items, now = Date.now()) {
     const held = await lstatOrNull(lock);
     const fresh = held !== null && held.isFile() && !held.isSymbolicLink() && now - held.mtimeMs < SYNC_LOCK_STALE_MS;
     if (fresh) return null;
-    await fs22.rm(lock, { force: true });
+    await fs23.rm(lock, { force: true });
     if (!await create()) return null;
   }
   return async () => {
-    await fs22.rm(lock, { force: true });
+    await fs23.rm(lock, { force: true });
   };
 }
 
@@ -8611,7 +8954,7 @@ function isTransferUrl(url) {
   if (parsed.protocol === "https:") return true;
   return parsed.protocol === "http:" && LOOPBACK_HOSTS.has(parsed.hostname);
 }
-async function putSigned(uploadUrl, bytes, contentType) {
+async function putSigned2(uploadUrl, bytes, contentType) {
   if (!isTransferUrl(uploadUrl)) throw new Error("The upload link Genex returned isn't an https URL.");
   const res = await fetch(uploadUrl, {
     method: "PUT",
@@ -8666,7 +9009,7 @@ async function uploadItemPart(call3, skuUrl2, part) {
   if (!urlRes.ok) return { ok: false, refused: urlRes, what: `upload the ${part.kind}` };
   const { uploadUrl, key } = await urlRes.json();
   try {
-    await putSigned(uploadUrl, part.bytes, part.contentType);
+    await putSigned2(uploadUrl, part.bytes, part.contentType);
   } catch (err) {
     return { ok: false, putFailed: err instanceof Error ? err.message : String(err) };
   }
@@ -8970,7 +9313,7 @@ var TOOLING_ENTRIES = /* @__PURE__ */ new Set([
 ]);
 async function listPreexistingEntries(dir) {
   try {
-    return (await fs23.readdir(dir)).filter((name) => !TOOLING_ENTRIES.has(name)).sort();
+    return (await fs24.readdir(dir)).filter((name) => !TOOLING_ENTRIES.has(name)).sort();
   } catch {
     return [];
   }
@@ -9038,8 +9381,8 @@ async function runInit(opts) {
   let totalUpdated = 0;
   const refused = [];
   for (const t of targets) {
-    const src = t.full ? templatesDir : path22.join(templatesDir, "skills");
-    const dest = t.full ? t.baseDir : path22.join(t.baseDir, "skills");
+    const src = t.full ? templatesDir : path23.join(templatesDir, "skills");
+    const dest = t.full ? t.baseDir : path23.join(t.baseDir, "skills");
     const family = remixing ? skillFamilyFilter("remix") : converting ? skillFamilyFilter("tools", { hosted: true }) : skillFamilyFilter("game");
     let copied;
     let updated;
@@ -9050,8 +9393,8 @@ async function runInit(opts) {
         exclude: ["controllers", "motion", "asset-viewer", "blender-service"],
         filter: t.full ? family : (rel) => family(`skills/${rel}`)
       }));
-      await pruneRemovedSkills(path22.join(t.baseDir, "skills"), log);
-      await writeSkillsMarker(path22.join(t.baseDir, "skills"));
+      await pruneRemovedSkills(path23.join(t.baseDir, "skills"), log);
+      await writeSkillsMarker(path23.join(t.baseDir, "skills"));
     } catch (err) {
       const refusal2 = explainFsPermission(err, dest);
       if (!refusal2) throw err;
@@ -9121,7 +9464,7 @@ async function runInit(opts) {
     if (email) log.plain(`  signed in as ${c.cyan(email)}`);
   };
   await echoIdentity();
-  const projectName = opts.name?.trim() || path22.basename(process.cwd());
+  const projectName = opts.name?.trim() || path23.basename(process.cwd());
   const create = (bearer) => createDraftProject({
     apiUrl,
     token: bearer,
@@ -9173,7 +9516,7 @@ async function runInit(opts) {
     if (await writeToolsContract(process.cwd(), { hosted: true })) {
       log.dim("  wrote the Genex Tools publishing rules into AGENTS.md (managed block)");
     }
-    await ensureEnvVar(path22.join(process.cwd(), ".env"), "VITE_GENEX_SLUG", meta.slug, log);
+    await ensureEnvVar(path23.join(process.cwd(), ".env"), "VITE_GENEX_SLUG", meta.slug, log);
     await reportCliEvent(apiUrl, token, "tools_converted");
   }
   if (!remixing) warnPreexisting(log, preexisting);
@@ -9201,9 +9544,9 @@ async function runInit(opts) {
 }
 
 // src/commands/link.ts
-import fs24 from "fs/promises";
+import fs25 from "fs/promises";
 import os7 from "os";
-import path23 from "path";
+import path24 from "path";
 async function runLink(opts) {
   const log = createLogger({ quiet: opts.quiet });
   log.plain(c.bold("genex link"));
@@ -9286,7 +9629,7 @@ async function runLink(opts) {
 }
 async function isEmptyDir(cwd) {
   try {
-    const entries = await fs24.readdir(cwd);
+    const entries = await fs25.readdir(cwd);
     return entries.every((e) => e === ".git" || e === ".genex" || e === ".DS_Store");
   } catch {
     return false;
@@ -9300,13 +9643,13 @@ async function downloadSource(apiUrl, token, project, log) {
     return false;
   }
   log.step(`Downloading the ${grant.sourceRef === "preview" ? "draft" : "published"} source\u2026`);
-  const staging = await fs24.mkdtemp(path23.join(os7.tmpdir(), "genex-link-"));
-  const fresh = path23.join(staging, "source");
+  const staging = await fs25.mkdtemp(path24.join(os7.tmpdir(), "genex-link-"));
+  const fresh = path24.join(staging, "source");
   try {
     if (!await cloneSource(grant, fresh, log)) return false;
-    await fs24.rm(path23.join(fresh, ".git"), { recursive: true, force: true });
-    for (const entry of await fs24.readdir(fresh)) {
-      await fs24.cp(path23.join(fresh, entry), path23.join(process.cwd(), entry), {
+    await fs25.rm(path24.join(fresh, ".git"), { recursive: true, force: true });
+    for (const entry of await fs25.readdir(fresh)) {
+      await fs25.cp(path24.join(fresh, entry), path24.join(process.cwd(), entry), {
         recursive: true,
         force: true
       });
@@ -9314,28 +9657,28 @@ async function downloadSource(apiUrl, token, project, log) {
     log.success("Downloaded.");
     return true;
   } finally {
-    await fs24.rm(staging, { recursive: true, force: true }).catch(() => {
+    await fs25.rm(staging, { recursive: true, force: true }).catch(() => {
     });
   }
 }
 async function ensureSlugEnv(slug, log, cwd = process.cwd()) {
-  const file = path23.join(cwd, ".env");
+  const file = path24.join(cwd, ".env");
   let content;
   try {
-    content = await fs24.readFile(file, "utf8");
+    content = await fs25.readFile(file, "utf8");
   } catch {
     return;
   }
   const re = /^(\s*VITE_GENEX_SLUG=)(.*)$/m;
   const m = content.match(re);
   if (!m) {
-    await fs24.appendFile(file, `${content.endsWith("\n") ? "" : "\n"}VITE_GENEX_SLUG=${slug}
+    await fs25.appendFile(file, `${content.endsWith("\n") ? "" : "\n"}VITE_GENEX_SLUG=${slug}
 `);
     log.dim(`  added VITE_GENEX_SLUG=${slug} to .env`);
     return;
   }
   if (m[2].trim() === slug) return;
-  await fs24.writeFile(file, content.replace(re, `$1${slug}`));
+  await fs25.writeFile(file, content.replace(re, `$1${slug}`));
   log.dim(`  updated .env: VITE_GENEX_SLUG=${slug} (was ${m[2].trim()})`);
 }
 async function fetchOwnProject(apiUrl, token, slug, log) {
@@ -9389,8 +9732,8 @@ async function listOwnSlugs(apiUrl, token, log) {
 }
 
 // src/commands/pull.ts
-import fs25 from "fs/promises";
-import path24 from "path";
+import fs26 from "fs/promises";
+import path25 from "path";
 import os8 from "os";
 function isMachineLocal(entry) {
   if (entry === ".genex" || entry === "node_modules" || entry === ".git") return true;
@@ -9450,23 +9793,23 @@ async function runPull(opts) {
     process.exitCode = 1;
     return;
   }
-  const staging = await fs25.mkdtemp(path24.join(os8.tmpdir(), "genex-pull-"));
-  const fresh = path24.join(staging, "source");
+  const staging = await fs26.mkdtemp(path25.join(os8.tmpdir(), "genex-pull-"));
+  const fresh = path25.join(staging, "source");
   try {
     if (!await cloneSource(grant, fresh, log)) {
       process.exitCode = 1;
       return;
     }
-    await fs25.rm(path24.join(fresh, ".git"), { recursive: true, force: true });
+    await fs26.rm(path25.join(fresh, ".git"), { recursive: true, force: true });
     const kept = await keepReplaced(cwd, log);
     await replaceTree(cwd, fresh);
     if (kept) {
       log.plain("");
-      log.info(`What was here is kept at ${c.cyan(path24.relative(cwd, kept) || kept)}`);
+      log.info(`What was here is kept at ${c.cyan(path25.relative(cwd, kept) || kept)}`);
       log.dim("  Nothing was thrown away \u2014 re-apply from there, or delete it when you are done.");
     }
   } finally {
-    await fs25.rm(staging, { recursive: true, force: true }).catch(() => {
+    await fs26.rm(staging, { recursive: true, force: true }).catch(() => {
     });
   }
   if (await hasRemixProfile(cwd)) await installRemixProfile(cwd, apiUrl, log);
@@ -9486,13 +9829,13 @@ async function runPull(opts) {
 }
 async function keepReplaced(cwd, log) {
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const dest = path24.join(cwd, ".genex", `replaced-${stamp}`);
+  const dest = path25.join(cwd, ".genex", `replaced-${stamp}`);
   try {
-    const entries = (await fs25.readdir(cwd)).filter((e) => !isMachineLocal(e));
+    const entries = (await fs26.readdir(cwd)).filter((e) => !isMachineLocal(e));
     if (entries.length === 0) return null;
-    await fs25.mkdir(dest, { recursive: true });
+    await fs26.mkdir(dest, { recursive: true });
     for (const entry of entries) {
-      await fs25.cp(path24.join(cwd, entry), path24.join(dest, entry), { recursive: true });
+      await fs26.cp(path25.join(cwd, entry), path25.join(dest, entry), { recursive: true });
     }
     return dest;
   } catch (err) {
@@ -9502,19 +9845,19 @@ async function keepReplaced(cwd, log) {
   }
 }
 async function replaceTree(dest, src) {
-  for (const entry of await fs25.readdir(dest)) {
+  for (const entry of await fs26.readdir(dest)) {
     if (isMachineLocal(entry)) continue;
-    await fs25.rm(path24.join(dest, entry), { recursive: true, force: true });
+    await fs26.rm(path25.join(dest, entry), { recursive: true, force: true });
   }
-  for (const entry of await fs25.readdir(src)) {
+  for (const entry of await fs26.readdir(src)) {
     if (isMachineLocal(entry)) continue;
-    await fs25.cp(path24.join(src, entry), path24.join(dest, entry), { recursive: true });
+    await fs26.cp(path25.join(src, entry), path25.join(dest, entry), { recursive: true });
   }
 }
 
 // src/commands/rename.ts
-import fs26 from "fs/promises";
-import path25 from "path";
+import fs27 from "fs/promises";
+import path26 from "path";
 async function runRename(opts) {
   const log = createLogger({ quiet: opts.quiet });
   log.plain(c.bold("genex rename"));
@@ -9602,23 +9945,23 @@ async function runRename(opts) {
   log.info("Run `genex preview` (or `publish`) to rebuild \u2014 the new slug is baked into the bundle.");
 }
 async function rewriteSlugEnv(from, to, log, cwd = process.cwd()) {
-  const file = path25.join(cwd, ".env");
+  const file = path26.join(cwd, ".env");
   let content;
   try {
-    content = await fs26.readFile(file, "utf8");
+    content = await fs27.readFile(file, "utf8");
   } catch {
     return;
   }
   const re = /^(\s*VITE_GENEX_SLUG=)(.*)$/m;
   if (!re.test(content)) return;
-  await fs26.writeFile(file, content.replace(re, `$1${to}`));
+  await fs27.writeFile(file, content.replace(re, `$1${to}`));
   log.dim(`  .env: VITE_GENEX_SLUG=${to} (was ${from})`);
 }
 async function rewriteBakedSlug(from, to, log, cwd = process.cwd()) {
-  const file = path25.join(cwd, "src", "genex.config.ts");
+  const file = path26.join(cwd, "src", "genex.config.ts");
   let content;
   try {
-    content = await fs26.readFile(file, "utf8");
+    content = await fs27.readFile(file, "utf8");
   } catch {
     return;
   }
@@ -9628,7 +9971,7 @@ async function rewriteBakedSlug(from, to, log, cwd = process.cwd()) {
     log.warn(`  src/genex.config.ts has no "${from}" literal \u2014 check its slug by hand.`);
     return;
   }
-  await fs26.writeFile(file, content.replace(quoted, `"${to}"`));
+  await fs27.writeFile(file, content.replace(quoted, `"${to}"`));
   log.dim(`  src/genex.config.ts: baked slug -> ${to}`);
 }
 
@@ -10558,9 +10901,9 @@ var ShopSession = class {
 };
 
 // src/commands/items.ts
-import crypto6 from "crypto";
-import fs27 from "fs/promises";
-import path26 from "path";
+import crypto7 from "crypto";
+import fs28 from "fs/promises";
+import path27 from "path";
 var SUBS2 = ["search", "add", "remove", "list"];
 var ITEMS_DIR = SHARED_ITEMS_DIR;
 var REPLACED_DIR = ".genex/replaced-items";
@@ -10756,26 +11099,26 @@ var ItemsSession = class _ItemsSession {
    */
   async writeItemFolder(skuId, itemFile, pkg) {
     const root = process.cwd();
-    const itemsDir = path26.join(root, ITEMS_DIR);
+    const itemsDir = path27.join(root, ITEMS_DIR);
     await ensureRealDir(itemsDir, ITEMS_DIR);
-    const final = path26.join(itemsDir, skuId);
+    const final = path27.join(itemsDir, skuId);
     const existing = await lstatOrNull2(final);
     if (existing && !existing.isDirectory()) {
       throw new FolderRefused(`${ITEMS_DIR}/${skuId} is a link or a file, not a folder. Move it aside first; nothing was written through it.`);
     }
     const keep = existing ? await replacedItemsDir(root) : null;
     const zip = pkg ? await downloadItemPackage(pkg.url) : null;
-    const staging = path26.join(itemsDir, `.${skuId}.incoming-${crypto6.randomBytes(4).toString("hex")}`);
+    const staging = path27.join(itemsDir, `.${skuId}.incoming-${crypto7.randomBytes(4).toString("hex")}`);
     try {
       const files = zip && pkg ? await extractItemPackage(zip, staging, pkg.manifest) : [];
-      if (!zip) await fs27.mkdir(staging);
-      await fs27.writeFile(path26.join(staging, ITEM_FILE), `${JSON.stringify(itemFile, null, 2)}
+      if (!zip) await fs28.mkdir(staging);
+      await fs28.writeFile(path27.join(staging, ITEM_FILE), `${JSON.stringify(itemFile, null, 2)}
 `, { flag: "wx" });
-      if (keep) await fs27.rename(final, path26.join(keep, `${skuId}-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`));
-      await fs27.rename(staging, final);
+      if (keep) await fs28.rename(final, path27.join(keep, `${skuId}-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`));
+      await fs28.rename(staging, final);
       return files;
     } finally {
-      await fs27.rm(staging, { recursive: true, force: true });
+      await fs28.rm(staging, { recursive: true, force: true });
     }
   }
   async remove(skuId) {
@@ -10830,22 +11173,22 @@ function folderRefusal(skuId, name, err) {
 }
 async function lstatOrNull2(p) {
   try {
-    return await fs27.lstat(p);
+    return await fs28.lstat(p);
   } catch (err) {
     if (err.code === "ENOENT") return null;
     throw err;
   }
 }
 async function replacedItemsDir(root) {
-  await fs27.mkdir(path26.join(root, ".genex"), { recursive: true });
-  const keep = path26.join(root, ...REPLACED_DIR.split("/"));
+  await fs28.mkdir(path27.join(root, ".genex"), { recursive: true });
+  const keep = path27.join(root, ...REPLACED_DIR.split("/"));
   await ensureRealDir(keep, REPLACED_DIR);
   return keep;
 }
 async function ensureRealDir(dir, label) {
   const stat = await lstatOrNull2(dir);
   if (!stat) {
-    await fs27.mkdir(dir);
+    await fs28.mkdir(dir);
     return;
   }
   if (!stat.isDirectory()) {
@@ -11059,7 +11402,10 @@ async function runPublish(opts) {
         mobileControls: detections.mobileControls,
         // Declared on the staging go-live; the promotion below copies that
         // build's own list to production with it.
-        capabilities: detections.capabilities
+        capabilities: detections.capabilities,
+        // The room module, when the game declares one: bundled, validated and uploaded with this
+        // staging build (the promotion below carries it to production).
+        authority: detections.authority
       },
       log
     );
@@ -11295,23 +11641,36 @@ async function readPreviousVersion(apiUrl, projectId, token, log) {
     log.dim("  Nothing was changed. Try again shortly, or update the server.");
     return null;
   }
-  if (!body.available || !body.commit || !body.currentCommit) {
+  const available = typeof body.releaseAvailable === "boolean" ? body.releaseAvailable : body.available;
+  if (!available || !body.commit || !body.currentCommit) {
     log.error("This game has no previous version to go back to.");
     log.dim("  Only versions published from this account since the feature shipped are recorded.");
     return null;
   }
+  const release = typeof body.release === "string" ? body.release : null;
+  const currentRelease = typeof body.currentRelease === "string" ? body.currentRelease : null;
   return {
     commit: body.commit,
     deployedAt: body.deployedAt ?? null,
-    currentCommit: body.currentCommit
+    currentCommit: body.currentCommit,
+    release,
+    currentRelease,
+    expectLive: currentRelease ?? body.currentCommit
   };
 }
-async function restorePreviousVersion(apiUrl, projectId, token, expectLiveCommit, log) {
+function releaseModule(tag) {
+  if (tag === null) return void 0;
+  const at = tag.indexOf("@");
+  if (at < 0) return void 0;
+  const module = tag.slice(at + 1);
+  return module === "none" ? null : module;
+}
+async function restorePreviousVersion(apiUrl, projectId, token, expectLive, log) {
   let res;
   try {
     res = await apiFetch(`${apiUrl}/api/games/${projectId}/rollback`, {
       method: "POST",
-      headers: { Authorization: `Bearer ${token}`, "If-Match": expectLiveCommit }
+      headers: { Authorization: `Bearer ${token}`, "If-Match": expectLive }
     });
   } catch (err) {
     log.error(`Couldn't reach the API at ${apiUrl}: ${String(err)}`);
@@ -11335,6 +11694,12 @@ async function restorePreviousVersion(apiUrl, projectId, token, expectLiveCommit
     return null;
   }
   if (res.status === 428) {
+    const body2 = await res.json().catch(() => null);
+    if (body2?.error === "release_match_required") {
+      log.error("The previous version differs from the live one only in its room module, and the server needs that named exactly \u2014 nothing was changed.");
+      log.dim("  Run the command again; if it repeats, update the CLI.");
+      return null;
+    }
     log.error("This CLI is out of date for this command \u2014 upgrade and try again.");
     return null;
   }
@@ -11368,6 +11733,26 @@ function when(iso) {
   if (hours < 48) return `${hours} hour${hours === 1 ? "" : "s"} ago`;
   return `${Math.round(hours / 24)} days ago`;
 }
+var moduleLabel = (module) => module === null ? "no room module" : `room module ${module.slice(0, 7)}`;
+function restoreLines(previous) {
+  const now = releaseModule(previous.currentRelease);
+  const back = releaseModule(previous.release);
+  const hasModule = now !== void 0 && now !== null || back !== void 0 && back !== null;
+  if (!hasModule || now === void 0 || back === void 0) {
+    return [`live now:  ${previous.currentCommit.slice(0, 7)}`, `goes back to: ${previous.commit.slice(0, 7)}`];
+  }
+  if (previous.commit === previous.currentCommit) {
+    return [
+      `same game build: ${previous.commit.slice(0, 7)}`,
+      `live now:  ${moduleLabel(now)}`,
+      `goes back to: ${moduleLabel(back)}`
+    ];
+  }
+  return [
+    `live now:  ${previous.currentCommit.slice(0, 7)} with ${moduleLabel(now)}`,
+    `goes back to: ${previous.commit.slice(0, 7)} with ${moduleLabel(back)}`
+  ];
+}
 async function runRollback(opts) {
   const log = createLogger({ quiet: opts.quiet });
   log.plain(c.bold("genex rollback"));
@@ -11401,15 +11786,14 @@ async function runRollback(opts) {
   }
   if (!opts.yes) {
     log.warn(`This puts players back on the version from ${when(previous.deployedAt)}.`);
-    log.dim(`  live now:  ${previous.currentCommit.slice(0, 7)}`);
-    log.dim(`  goes back to: ${previous.commit.slice(0, 7)}`);
+    for (const line of restoreLines(previous)) log.dim(`  ${line}`);
     log.dim("  Your code is NOT changed \u2014 this folder, and what a Remix copies, stay as they are.");
     log.dim("  Re-run with --yes to do it.");
     process.exitCode = 1;
     return;
   }
   log.step("Putting the previous version back\u2026");
-  const result = await restorePreviousVersion(apiUrl, meta.id, token, previous.currentCommit, log);
+  const result = await restorePreviousVersion(apiUrl, meta.id, token, previous.expectLive, log);
   if (!result) {
     process.exitCode = 1;
     return;
@@ -11423,8 +11807,8 @@ async function runRollback(opts) {
 }
 
 // src/commands/cover.ts
-import fs28 from "fs/promises";
-import path27 from "path";
+import fs29 from "fs/promises";
+import path28 from "path";
 var WHAT_A_COVER_IS = "one real frame of the game: its signature moment, real gameplay, well lit, no menus, popups or busy HUD, landscape 16:9, no text";
 async function runCover(opts) {
   const log = createLogger({ quiet: opts.quiet || opts.json });
@@ -11449,7 +11833,7 @@ async function runCover(opts) {
   }
   let bytes;
   try {
-    const stat = await fs28.stat(file);
+    const stat = await fs29.stat(file);
     if (!stat.isFile()) throw new Error("not a file");
     if (stat.size > COVER_MAX_BYTES) {
       return finish(
@@ -11459,23 +11843,23 @@ async function runCover(opts) {
         log
       );
     }
-    bytes = await fs28.readFile(file);
+    bytes = await fs29.readFile(file);
   } catch {
     return finish({ kind: "invalid", message: `Can't read ${file} \u2014 pass the path of a PNG, JPEG or WebP image.` }, file, opts, log);
   }
-  log.step(`Uploading ${path27.basename(file)} as the cover\u2026`);
+  log.step(`Uploading ${path28.basename(file)} as the cover\u2026`);
   const outcome2 = await uploadCover({ apiUrl, token, projectId: meta.id, bytes, label: file });
   await rememberNomination(bytes, file, outcome2);
   finish(outcome2, file, opts, log);
 }
 async function rememberNomination(bytes, file, outcome2) {
   const scratch = await findScratchCover();
-  if (!scratch || path27.resolve(scratch) === path27.resolve(file)) {
+  if (!scratch || path28.resolve(scratch) === path28.resolve(file)) {
     await rememberCoverUpload(bytes, file, outcome2);
     return;
   }
   if (outcome2.kind !== "applied" && outcome2.kind !== "outranked") return;
-  const stale = await fs28.readFile(scratch).catch(() => null);
+  const stale = await fs29.readFile(scratch).catch(() => null);
   if (stale) await rememberCoverUpload(stale, scratch, outcome2);
 }
 async function sendClip(apiUrl, token, projectId, clip, opts, log) {
@@ -11486,16 +11870,16 @@ async function sendClip(apiUrl, token, projectId, clip, opts, log) {
   if (!opts.commit?.trim()) return invalid3("--clip needs --commit <sha>: the git commit of the build the recording shows.");
   let bytes;
   try {
-    const stat = await fs28.stat(clip);
+    const stat = await fs29.stat(clip);
     if (!stat.isFile()) throw new Error("not a file");
     if (stat.size > CLIP_MAX_BYTES) {
       return invalid3(`${clip} is ${(stat.size / 1024 / 1024).toFixed(1)} MB; a cover clip recording can be at most ${CLIP_MAX_BYTES / 1024 / 1024} MB.`);
     }
-    bytes = await fs28.readFile(clip);
+    bytes = await fs29.readFile(clip);
   } catch {
     return invalid3(`Can't read ${clip} \u2014 pass the path of an MP4 or WebM recording.`);
   }
-  log.step(`Uploading ${path27.basename(clip)} as the cover clip\u2026`);
+  log.step(`Uploading ${path28.basename(clip)} as the cover clip\u2026`);
   const outcome2 = await uploadClip({ apiUrl, token, projectId, bytes, label: clip, buildCommit: opts.commit });
   finishClip(outcome2, clip, opts, log);
 }
@@ -11553,8 +11937,8 @@ async function showCover(apiUrl, token, slug, opts, log) {
 }
 
 // src/commands/generate.ts
-import fs31 from "fs/promises";
-import path30 from "path";
+import fs32 from "fs/promises";
+import path31 from "path";
 import { PNG as PNG4 } from "pngjs";
 
 // src/lib/glass.ts
@@ -11742,13 +12126,13 @@ function ceilingVerdict(input) {
 }
 
 // src/lib/generation-admission.ts
-import fs30 from "fs/promises";
-import path29 from "path";
+import fs31 from "fs/promises";
+import path30 from "path";
 import { createHash as createHash3, randomUUID } from "crypto";
 
 // src/lib/asset-budget.ts
-import fs29 from "fs/promises";
-import path28 from "path";
+import fs30 from "fs/promises";
+import path29 from "path";
 var DEFAULT_ASSET_BUDGET_SHARE = 0.5;
 var DEFAULT_ASSET_BUDGET_CAP = 500;
 function envShare(raw, fallback) {
@@ -11775,10 +12159,10 @@ function allowanceFor(input) {
   if (!Number.isFinite(spendable) || spendable <= 0) return 0;
   return Math.max(0, Math.min(Math.floor(spendable * config.share), config.cap));
 }
-var storePath = (cwd) => path28.join(cwd, ".genex", "asset-budget.json");
+var storePath = (cwd) => path29.join(cwd, ".genex", "asset-budget.json");
 async function readBudgetStore(cwd = process.cwd()) {
   try {
-    const raw = await fs29.readFile(storePath(cwd), "utf8");
+    const raw = await fs30.readFile(storePath(cwd), "utf8");
     const parsed = JSON.parse(raw);
     if (!parsed || parsed.v !== 1 || typeof parsed.allowanceCredits !== "number" || !Number.isFinite(parsed.allowanceCredits) || parsed.setBy !== "default" && parsed.setBy !== "user") {
       return null;
@@ -11797,8 +12181,8 @@ async function readBudgetStore(cwd = process.cwd()) {
 }
 async function writeBudgetStore(cwd, store) {
   try {
-    await fs29.access(path28.join(cwd, ".genex"));
-    await fs29.writeFile(storePath(cwd), `${JSON.stringify(store, null, 2)}
+    await fs30.access(path29.join(cwd, ".genex"));
+    await fs30.writeFile(storePath(cwd), `${JSON.stringify(store, null, 2)}
 `, "utf8");
     return true;
   } catch {
@@ -11809,7 +12193,7 @@ async function ensureBudgetStore(cwd, input) {
   const existing = await readBudgetStore(cwd);
   if (existing) return existing;
   try {
-    await fs29.stat(storePath(cwd));
+    await fs30.stat(storePath(cwd));
     throw new Error("Stored asset allowance is unreadable or invalid; reconcile it before paid generation.");
   } catch (error) {
     if (error.code !== "ENOENT") throw error;
@@ -11913,13 +12297,13 @@ async function assetBudgetGate(input) {
 
 // src/lib/generation-admission.ts
 async function withAdmissionLock(cwd, work, waitMs = 3e4) {
-  const lock = path29.join(cwd, ".genex", "generation-admission.lock");
-  await fs30.mkdir(path29.dirname(lock), { recursive: true });
+  const lock = path30.join(cwd, ".genex", "generation-admission.lock");
+  await fs31.mkdir(path30.dirname(lock), { recursive: true });
   const deadline = Date.now() + waitMs;
   let file;
   while (!file) {
     try {
-      file = await fs30.open(lock, "wx");
+      file = await fs31.open(lock, "wx");
     } catch (error) {
       if (error.code !== "EEXIST") throw error;
       if (Date.now() >= deadline) throw new Error("Another generation admission holds .genex/generation-admission.lock. If its process died, reconcile pending reservations before removing that lock.");
@@ -11931,7 +12315,7 @@ async function withAdmissionLock(cwd, work, waitMs = 3e4) {
     return await work();
   } finally {
     await file.close();
-    await fs30.unlink(lock);
+    await fs31.unlink(lock);
   }
 }
 async function enqueueWithAllowance(input) {
@@ -12180,7 +12564,7 @@ var isRemoteRef = (value) => /^(https?:\/\/|data:)/i.test(value);
 async function inlineLocalImage(filePath, flag) {
   let bytes;
   try {
-    bytes = await fs31.readFile(filePath);
+    bytes = await fs32.readFile(filePath);
   } catch {
     return { ok: false, error: `Couldn't read the ${flag} file at ${filePath}.` };
   }
@@ -12190,7 +12574,7 @@ async function inlineLocalImage(filePath, flag) {
       error: `${flag} file is ${(bytes.length / 1048576).toFixed(1)} MB \u2014 over the ~4 MB inline limit. Downscale/compress it first, or pass an asset URL instead.`
     };
   }
-  const mime = IMAGE_MIME_BY_EXT[path30.extname(filePath).toLowerCase()] ?? "image/png";
+  const mime = IMAGE_MIME_BY_EXT[path31.extname(filePath).toLowerCase()] ?? "image/png";
   return { ok: true, dataUri: `data:${mime};base64,${bytes.toString("base64")}` };
 }
 var SKYBOX_ENVIRONMENT_SUFFIX = ". The image contains ONLY sky: cloud, atmosphere, light, weather and distant haze at the horizon. Every structure, object, plant and ground surface is outside the frame.";
@@ -12385,7 +12769,7 @@ async function runGenerate(kind, opts) {
   let typedPrompt = opts.prompt?.trim();
   if (!typedPrompt && kind === "model" && opts.imageUrl) {
     const ref = opts.imageUrl.startsWith("data:") ? "local image" : opts.imageUrl;
-    typedPrompt = `from image: ${path30.basename(ref).slice(0, 120)}`;
+    typedPrompt = `from image: ${path31.basename(ref).slice(0, 120)}`;
   }
   if (kind === "model" && opts.texture !== void 0 && !MODEL_TEXTURE_TIERS.includes(opts.texture)) {
     log.error(`--texture ${opts.texture} is a character texture size. \`genex model\` takes a texture TIER: ${MODEL_TEXTURE_TIERS.join("|")} (default detailed).`);
@@ -12434,7 +12818,7 @@ async function runGenerate(kind, opts) {
       return;
     }
     try {
-      const bytes = await fs31.readFile(opts.inpaintUrl);
+      const bytes = await fs32.readFile(opts.inpaintUrl);
       opts = { ...opts, inpaintUrl: `data:image/png;base64,${bytes.toString("base64")}` };
     } catch {
       log.error(`Couldn't read the --inpaint mask at ${opts.inpaintUrl}.`);
@@ -12603,7 +12987,7 @@ async function reportGlassTerminal(view, outDir, log, json) {
     return;
   }
   await recordTerminal(view.id, "completed", files.map((f) => f.url));
-  await fs31.mkdir(outDir, { recursive: true });
+  await fs32.mkdir(outDir, { recursive: true });
   const solved = [];
   for (let i = 0; i < files.length; i++) {
     const f = files[i];
@@ -12635,8 +13019,8 @@ async function reportGlassTerminal(view, outDir, log, json) {
       });
       continue;
     }
-    const outPath = path30.join(outDir, `glass-${i + 1}.png`);
-    await fs31.writeFile(outPath, PNG4.sync.write(r.png));
+    const outPath = path31.join(outDir, `glass-${i + 1}.png`);
+    await fs32.writeFile(outPath, PNG4.sync.write(r.png));
     solved.push({
       path: outPath,
       url: f.url,
@@ -13266,8 +13650,8 @@ function writeJson(value) {
 }
 
 // src/commands/model-sub.ts
-import fs32 from "fs/promises";
-import path31 from "path";
+import fs33 from "fs/promises";
+import path32 from "path";
 var MODEL_SUBCOMMANDS = ["segment", "rig", "animate", "import"];
 function apiErrorMessage(data, fallback) {
   if (typeof data !== "object" || data === null) return fallback;
@@ -13282,29 +13666,29 @@ async function importModelFile(args) {
   const { log } = args;
   const filePath = args.filePath.trim();
   if (!/\.glb$/i.test(filePath)) {
-    log.error(`\`import\` takes a .glb file (binary glTF 2.0). Export ${path31.basename(filePath) || "the model"} as GLB first \u2014 Blender: File \u2192 Export \u2192 glTF 2.0, format "glTF Binary".`);
+    log.error(`\`import\` takes a .glb file (binary glTF 2.0). Export ${path32.basename(filePath) || "the model"} as GLB first \u2014 Blender: File \u2192 Export \u2192 glTF 2.0, format "glTF Binary".`);
     return null;
   }
   let bytes;
   try {
-    bytes = await fs32.readFile(filePath);
+    bytes = await fs33.readFile(filePath);
   } catch {
     log.error(`Couldn't read ${filePath}.`);
     return null;
   }
   if (bytes.byteLength > MODEL_IMPORT_MAX_BYTES) {
-    log.error(`${path31.basename(filePath)} is ${(bytes.byteLength / 1e6).toFixed(1)} MB; imports are capped at ${MODEL_IMPORT_MAX_BYTES / 1024 / 1024} MB. Shrink its textures (they are usually the bulk) and try again.`);
+    log.error(`${path32.basename(filePath)} is ${(bytes.byteLength / 1e6).toFixed(1)} MB; imports are capped at ${MODEL_IMPORT_MAX_BYTES / 1024 / 1024} MB. Shrink its textures (they are usually the bulk) and try again.`);
     return null;
   }
   if (bytes.byteLength < 12 || bytes.readUInt32LE(0) !== GLB_MAGIC) {
-    log.error(`${path31.basename(filePath)} is not a GLB (no glTF magic). A .gltf + .bin pair must be exported as one binary .glb.`);
+    log.error(`${path32.basename(filePath)} is not a GLB (no glTF magic). A .gltf + .bin pair must be exported as one binary .glb.`);
     return null;
   }
   const headers = { "Content-Type": "application/json", Authorization: `Bearer ${args.token}` };
   const minted = await apiFetch(`${args.apiUrl}/api/generations/import`, {
     method: "POST",
     headers,
-    body: JSON.stringify({ filename: path31.basename(filePath), bytes: bytes.byteLength, contentType: "model/gltf-binary" })
+    body: JSON.stringify({ filename: path32.basename(filePath), bytes: bytes.byteLength, contentType: "model/gltf-binary" })
   });
   if (printedStructuredError(minted)) return null;
   if (!minted.ok) {
@@ -13313,7 +13697,7 @@ async function importModelFile(args) {
     return null;
   }
   const { id, uploadUrl, url } = await minted.json();
-  log.dim(`  uploading ${path31.basename(filePath)} (${(bytes.byteLength / 1e6).toFixed(1)} MB)\u2026`);
+  log.dim(`  uploading ${path32.basename(filePath)} (${(bytes.byteLength / 1e6).toFixed(1)} MB)\u2026`);
   const put = await fetch(uploadUrl, {
     method: "PUT",
     headers: { "Content-Type": "model/gltf-binary", "Content-Length": String(bytes.byteLength) },
@@ -13461,7 +13845,7 @@ async function runModelAnimate(opts) {
 }
 
 // src/commands/wait.ts
-import path32 from "path";
+import path33 from "path";
 var MAX_TIMEOUT_SEC = 2e6;
 var STILL_RUNNING_EXIT = 2;
 var TERMINAL2 = /* @__PURE__ */ new Set(["completed", "failed"]);
@@ -13668,7 +14052,7 @@ async function runWaitAll(opts) {
       if (v?.status !== "completed" || !v.files?.length) continue;
       const local = localDeliveryFor("tools", { ...opts, outDir: opts.outDir ?? e.outDir }, e.prompt || e.kind);
       if (!local) continue;
-      const outDir = path32.join(path32.relative(process.cwd(), cwd) || ".", local.outDir);
+      const outDir = path33.join(path33.relative(process.cwd(), cwd) || ".", local.outDir);
       const target = { kind: e.kind, prompt: local.prompt, id: e.id, outDir };
       const missing = await undeliveredFiles(v.files, target);
       if (missing.length === 0) continue;
@@ -13780,8 +14164,8 @@ async function toRow(e, v, cwd) {
 }
 
 // src/commands/controller.ts
-import fs34 from "fs/promises";
-import path34 from "path";
+import fs35 from "fs/promises";
+import path35 from "path";
 
 // ../../packages/meshy-animation-catalog/src/index.ts
 import { createHash as createHash4 } from "crypto";
@@ -22625,9 +23009,9 @@ function searchMeshyAnimations(query, options = {}) {
 }
 
 // src/lib/anims.ts
-import fs33 from "fs/promises";
-import path33 from "path";
-var ANIMS_DEST = path33.join("public", "assets", "anims");
+import fs34 from "fs/promises";
+import path34 from "path";
+var ANIMS_DEST = path34.join("public", "assets", "anims");
 var HIDDEN_TAG = "reference";
 async function runAnims(opts) {
   const log = createLogger({ quiet: opts.quiet });
@@ -22643,7 +23027,7 @@ async function runAnims(opts) {
     printCatalog(log, manifest, selectors);
     return;
   }
-  const controllerMarker = path33.join(root, "src", "controllers", "character");
+  const controllerMarker = path34.join(root, "src", "controllers", "character");
   if (!await exists3(controllerMarker)) {
     log.error(
       `No character controller in this game (missing ${c.cyan("src/controllers/character/")}).`
@@ -22652,11 +23036,11 @@ async function runAnims(opts) {
     process.exitCode = 1;
     return;
   }
-  const destDir = path33.join(root, ANIMS_DEST);
-  const gameManifestPath = path33.join(destDir, "manifest.json");
+  const destDir = path34.join(root, ANIMS_DEST);
+  const gameManifestPath = path34.join(destDir, "manifest.json");
   if (opts.reset) {
-    await fs33.rm(destDir, { recursive: true, force: true });
-    log.step(`Cleared ${c.cyan(ANIMS_DEST + path33.sep)} (--reset)`);
+    await fs34.rm(destDir, { recursive: true, force: true });
+    log.step(`Cleared ${c.cyan(ANIMS_DEST + path34.sep)} (--reset)`);
   }
   if (selectors.length === 0) {
     const installed = await readGameManifest(gameManifestPath);
@@ -22694,35 +23078,35 @@ async function runAnims(opts) {
     }
   }
   const wanted = [...byName2.values()].sort((a, b) => a.name.localeCompare(b.name));
-  const cacheDir = path33.join(
+  const cacheDir = path34.join(
     opts.cacheDir ?? getAnimsCacheDir(),
     `${manifest.library}-v${manifest.version}`
   );
-  await fs33.mkdir(cacheDir, { recursive: true });
-  await fs33.mkdir(destDir, { recursive: true });
+  await fs34.mkdir(cacheDir, { recursive: true });
+  await fs34.mkdir(destDir, { recursive: true });
   const base = getAnimsBase(opts.animsBase);
   let installedCount = 0;
   let presentCount = 0;
   let addedBytes = 0;
   const failures = [];
   for (const entry of wanted) {
-    const dest = path33.join(destDir, entry.file);
+    const dest = path34.join(destDir, entry.file);
     if (await hasSize(dest, entry.bytes)) {
       presentCount++;
       continue;
     }
     try {
-      const cached = path33.join(cacheDir, entry.file);
+      const cached = path34.join(cacheDir, entry.file);
       if (!await hasSize(cached, entry.bytes)) {
         const res = await fetch(base + entry.file);
         if (!res.ok) throw new Error(`HTTP ${res.status}`);
         const buf = Buffer.from(await res.arrayBuffer());
-        await fs33.writeFile(cached, buf);
+        await fs34.writeFile(cached, buf);
       }
-      await fs33.copyFile(cached, dest);
+      await fs34.copyFile(cached, dest);
       installedCount++;
       addedBytes += entry.bytes;
-      log.dim(`  ${path33.join(ANIMS_DEST, entry.file)} (${formatMb(entry.bytes)})`);
+      log.dim(`  ${path34.join(ANIMS_DEST, entry.file)} (${formatMb(entry.bytes)})`);
     } catch (err) {
       failures.push(`${entry.name} (${err instanceof Error ? err.message : String(err)})`);
     }
@@ -22738,13 +23122,13 @@ async function runAnims(opts) {
     version: manifest.version,
     clips: [...union].sort((a, b) => a.localeCompare(b))
   };
-  await fs33.writeFile(gameManifestPath, JSON.stringify(gameManifest, null, 2) + "\n");
+  await fs34.writeFile(gameManifestPath, JSON.stringify(gameManifest, null, 2) + "\n");
   log.plain("");
   const parts = [`${installedCount} clip${installedCount === 1 ? "" : "s"} installed`];
   if (presentCount > 0) parts.push(`${presentCount} already present`);
   if (bundledSkips > 0) parts.push(`${bundledSkips} already bundled in animation-library.glb`);
   log.success(
-    `${parts.join(", ")} \u2192 ${c.cyan(ANIMS_DEST + path33.sep)}${addedBytes > 0 ? ` (+${formatMb(addedBytes)})` : ""}`
+    `${parts.join(", ")} \u2192 ${c.cyan(ANIMS_DEST + path34.sep)}${addedBytes > 0 ? ` (+${formatMb(addedBytes)})` : ""}`
   );
   for (const [selector, entries] of resolved) {
     const names2 = entries.filter((e) => !coreNames.has(e.name)).map((e) => e.name);
@@ -22776,8 +23160,8 @@ async function loadManifest(baseOverride) {
     }
   } catch {
   }
-  const snapshotPath = path33.join(getTemplatesDir(), "controllers", "assets", "anims-manifest.json");
-  const manifest = JSON.parse(await fs33.readFile(snapshotPath, "utf8"));
+  const snapshotPath = path34.join(getTemplatesDir(), "controllers", "assets", "anims-manifest.json");
+  const manifest = JSON.parse(await fs34.readFile(snapshotPath, "utf8"));
   return { manifest, source: "snapshot" };
 }
 function resolveSelectors(manifest, selectors) {
@@ -22895,21 +23279,21 @@ function printCatalog(log, manifest, selectors) {
 }
 async function readGameManifest(file) {
   try {
-    return JSON.parse(await fs33.readFile(file, "utf8"));
+    return JSON.parse(await fs34.readFile(file, "utf8"));
   } catch {
     return null;
   }
 }
 async function hasSize(file, bytes) {
   try {
-    return (await fs33.stat(file)).size === bytes;
+    return (await fs34.stat(file)).size === bytes;
   } catch {
     return false;
   }
 }
 async function exists3(p) {
   try {
-    await fs33.access(p);
+    await fs34.access(p);
     return true;
   } catch {
     return false;
@@ -23110,8 +23494,8 @@ var CONTROLLER_FILE_SETS = {
     ]
   }
 };
-var CODE_DEST = path34.join("src", "controllers");
-var ASSETS_DEST = path34.join("public", "assets");
+var CODE_DEST = path35.join("src", "controllers");
+var ASSETS_DEST = path35.join("public", "assets");
 async function runController(opts) {
   const log = createLogger({ quiet: opts.quiet });
   if (opts.kind?.trim() === "anims") {
@@ -23128,31 +23512,31 @@ async function runController(opts) {
     process.exitCode = 1;
     return;
   }
-  const srcDir = path34.join(getTemplatesDir(), "controllers");
+  const srcDir = path35.join(getTemplatesDir(), "controllers");
   const root = opts.cwd ?? process.cwd();
   const set = CONTROLLER_FILE_SETS[kind];
   log.plain(c.bold(`genex controller ${kind}`));
   log.plain("");
-  log.step(`Installing the ${kind} controller into ${c.cyan(CODE_DEST + path34.sep)}`);
+  log.step(`Installing the ${kind} controller into ${c.cyan(CODE_DEST + path35.sep)}`);
   const plan2 = [
-    ...set.code.map((rel) => ({ from: rel, rel: path34.join(CODE_DEST, rel) })),
+    ...set.code.map((rel) => ({ from: rel, rel: path35.join(CODE_DEST, rel) })),
     ...set.assets.map((rel) => ({
       from: rel,
-      rel: path34.join(ASSETS_DEST, path34.basename(rel))
+      rel: path35.join(ASSETS_DEST, path35.basename(rel))
     }))
   ];
   let copied = 0;
   let skipped = 0;
   try {
     for (const file of plan2) {
-      const dest = path34.join(root, file.rel);
+      const dest = path35.join(root, file.rel);
       if (!opts.force && await exists4(dest)) {
         skipped++;
         log.dim(`  skipped ${file.rel} (exists \u2014 use --force to overwrite)`);
         continue;
       }
-      await fs34.mkdir(path34.dirname(dest), { recursive: true });
-      await fs34.copyFile(path34.join(srcDir, file.from), dest);
+      await fs35.mkdir(path35.dirname(dest), { recursive: true });
+      await fs35.copyFile(path35.join(srcDir, file.from), dest);
       copied++;
       log.dim(`  ${file.rel}`);
     }
@@ -23205,7 +23589,7 @@ async function runController(opts) {
   for (const line of set.sketch) {
     log.dim(`       ${line}`);
   }
-  if (kind === "character" && !await exists4(path34.join(root, ASSETS_DEST, "meshy-character.json"))) {
+  if (kind === "character" && !await exists4(path35.join(root, ASSETS_DEST, "meshy-character.json"))) {
     log.plain("");
     log.plain(
       `  ${stepOffset + 3}. This game has no generated character yet \u2014 ${c.cyan(
@@ -23237,9 +23621,9 @@ async function installMeshyCharacterManifest(args) {
     throw new Error("The API returned an invalid Meshy character manifest.");
   }
   assertCompleteMeshyControllerPack(manifest);
-  const destination = path34.join(args.root, ASSETS_DEST, "meshy-character.json");
-  await fs34.mkdir(path34.dirname(destination), { recursive: true });
-  await fs34.writeFile(
+  const destination = path35.join(args.root, ASSETS_DEST, "meshy-character.json");
+  await fs35.mkdir(path35.dirname(destination), { recursive: true });
+  await fs35.writeFile(
     destination,
     `${JSON.stringify(manifest, null, 2)}
 `
@@ -23384,14 +23768,14 @@ function assertCompleteMeshyControllerPack(manifest) {
 }
 async function installFallbackAvatar(args) {
   const { root, srcDir, log } = args;
-  const dest = path34.join(root, ASSETS_DEST, "avatar.vrm");
-  await fs34.mkdir(path34.dirname(dest), { recursive: true });
-  await fs34.copyFile(path34.join(srcDir, "assets", "default-avatar.vrm"), dest);
+  const dest = path35.join(root, ASSETS_DEST, "avatar.vrm");
+  await fs35.mkdir(path35.dirname(dest), { recursive: true });
+  await fs35.copyFile(path35.join(srcDir, "assets", "default-avatar.vrm"), dest);
   log.dim("  public/assets/avatar.vrm (fallback avatar \u2014 bundled CC0 default)");
 }
 async function exists4(p) {
   try {
-    await fs34.access(p);
+    await fs35.access(p);
     return true;
   } catch {
     return false;
@@ -23399,8 +23783,8 @@ async function exists4(p) {
 }
 
 // src/commands/character.ts
-import fs35 from "fs/promises";
-import path35 from "path";
+import fs36 from "fs/promises";
+import path36 from "path";
 function exactAnimation(selector) {
   const trimmed = selector.trim();
   if (/^-?\d+$/.test(trimmed)) return animationById(Number(trimmed));
@@ -23485,7 +23869,7 @@ function showAmbiguity(selector, candidates, log, json = false) {
   }
   process.exitCode = 1;
 }
-var INSTALLED_MANIFEST = path35.join("public", "assets", "meshy-character.json");
+var INSTALLED_MANIFEST = path36.join("public", "assets", "meshy-character.json");
 async function resolveAdoptTarget(selector) {
   const trimmed = selector?.trim();
   if (trimmed && !trimmed.endsWith(".json")) {
@@ -23494,7 +23878,7 @@ async function resolveAdoptTarget(selector) {
   const file = trimmed ?? INSTALLED_MANIFEST;
   let raw;
   try {
-    raw = await fs35.readFile(file, "utf8");
+    raw = await fs36.readFile(file, "utf8");
   } catch {
     return {
       ok: false,
@@ -23619,7 +24003,7 @@ async function runCharacterImport(opts) {
     opts,
     ctx,
     kind: "character",
-    prompt: `Import ${path35.basename(filePath)} as a rigged character`,
+    prompt: `Import ${path36.basename(filePath)} as a rigged character`,
     createPath: "/api/characters/import",
     body,
     quote: price,
@@ -24164,22 +24548,22 @@ async function context2(opts) {
   if (!token) return null;
   return { token, apiUrl };
 }
-async function readVideo(path52, log) {
+async function readVideo(path53, log) {
   let bytes;
   try {
-    bytes = await readFile(path52);
+    bytes = await readFile(path53);
   } catch {
-    log.error(`Can't read ${path52}.`);
+    log.error(`Can't read ${path53}.`);
     return null;
   }
   if (bytes.byteLength > MAX_VIDEO_BYTES) {
-    log.error(`${basename(path52)} is ${(bytes.byteLength / 1e6).toFixed(0)} MB \u2014 the limit is ${MAX_VIDEO_BYTES / 1e6} MB.`);
+    log.error(`${basename(path53)} is ${(bytes.byteLength / 1e6).toFixed(0)} MB \u2014 the limit is ${MAX_VIDEO_BYTES / 1e6} MB.`);
     return null;
   }
   return bytes;
 }
-async function uploadVideo(apiUrl, token, characterId, path52, bytes, log) {
-  const contentType = /\.mov$/i.test(path52) ? "video/quicktime" : "video/mp4";
+async function uploadVideo(apiUrl, token, characterId, path53, bytes, log) {
+  const contentType = /\.mov$/i.test(path53) ? "video/quicktime" : "video/mp4";
   const minted = await apiFetch(
     `${apiUrl}/api/characters/${encodeURIComponent(characterId)}/motions/video-url`,
     {
@@ -24194,7 +24578,7 @@ async function uploadVideo(apiUrl, token, characterId, path52, bytes, log) {
     return null;
   }
   const { uploadUrl, videoUrl } = await minted.json();
-  log.dim(`  uploading ${basename(path52)} (${(bytes.byteLength / 1e6).toFixed(1)} MB)\u2026`);
+  log.dim(`  uploading ${basename(path53)} (${(bytes.byteLength / 1e6).toFixed(1)} MB)\u2026`);
   const put = await fetch(uploadUrl, {
     method: "PUT",
     headers: { "Content-Type": contentType, "Content-Length": String(bytes.byteLength) },
@@ -24526,8 +24910,8 @@ function rank(items, query) {
 }
 
 // src/commands/motion.ts
-import fs36 from "fs/promises";
-import path36 from "path";
+import fs37 from "fs/promises";
+import path37 from "path";
 
 // src/lib/motion/npz.ts
 import zlib2 from "zlib";
@@ -25778,7 +26162,7 @@ async function motionGen(opts, log) {
   }
   if (opts.constraintsPath !== void 0) {
     try {
-      const raw = await fs36.readFile(opts.constraintsPath, "utf8");
+      const raw = await fs37.readFile(opts.constraintsPath, "utf8");
       generationOptions.constraints = JSON.parse(raw);
     } catch {
       log.error(`Couldn't read the --constraints JSON at ${opts.constraintsPath}.`);
@@ -25802,10 +26186,10 @@ async function motionGen(opts, log) {
 async function expandTakes(selectors) {
   const out = [];
   for (const sel of selectors) {
-    const st = await fs36.stat(sel).catch(() => null);
+    const st = await fs37.stat(sel).catch(() => null);
     if (st?.isDirectory()) {
-      const names2 = await fs36.readdir(sel);
-      for (const n of names2.sort()) if (n.endsWith(".npz")) out.push(path36.join(sel, n));
+      const names2 = await fs37.readdir(sel);
+      for (const n of names2.sort()) if (n.endsWith(".npz")) out.push(path37.join(sel, n));
     } else if (st?.isFile()) {
       out.push(sel);
     } else {
@@ -25840,7 +26224,7 @@ async function motionVerify(opts, log) {
   let gates = DEFAULT_GATES;
   if (opts.gatesPath) {
     try {
-      gates = mergeGates(DEFAULT_GATES, JSON.parse(await fs36.readFile(opts.gatesPath, "utf8")));
+      gates = mergeGates(DEFAULT_GATES, JSON.parse(await fs37.readFile(opts.gatesPath, "utf8")));
     } catch {
       log.error(`Couldn't read the --gates JSON at ${opts.gatesPath}.`);
       process.exitCode = 1;
@@ -25862,9 +26246,9 @@ async function motionVerify(opts, log) {
   }
   const reports = [];
   for (const file of files) {
-    const stem = path36.basename(file).replace(/\.npz$/, "");
+    const stem = path37.basename(file).replace(/\.npz$/, "");
     try {
-      reports.push(analyzeTake(stem, await fs36.readFile(file), gates));
+      reports.push(analyzeTake(stem, await fs37.readFile(file), gates));
     } catch (err) {
       reports.push({
         take: stem,
@@ -25902,7 +26286,7 @@ async function motionCompile(opts, log) {
   let cfg = DEFAULT_MOTION_CONFIG;
   if (opts.configPath) {
     try {
-      const patch = JSON.parse(await fs36.readFile(opts.configPath, "utf8"));
+      const patch = JSON.parse(await fs37.readFile(opts.configPath, "utf8"));
       cfg = { ...DEFAULT_MOTION_CONFIG, ...patch, idleLoop: { ...DEFAULT_MOTION_CONFIG.idleLoop, ...patch.idleLoop } };
     } catch {
       log.error(`Couldn't read the --config JSON at ${opts.configPath}.`);
@@ -25920,16 +26304,16 @@ async function motionCompile(opts, log) {
   }
   const inputs = [];
   for (const file of files) {
-    const stem = path36.basename(file).replace(/\.npz$/, "");
+    const stem = path37.basename(file).replace(/\.npz$/, "");
     try {
-      inputs.push({ stem, take: loadTake(await fs36.readFile(file)) });
+      inputs.push({ stem, take: loadTake(await fs37.readFile(file)) });
     } catch (err) {
       log.error(`${stem}: ${err instanceof Error ? err.message : String(err)}`);
       process.exitCode = 1;
       return;
     }
   }
-  const setName = opts.set ?? path36.basename(opts.out).replace(/\.json$/, "");
+  const setName = opts.set ?? path37.basename(opts.out).replace(/\.json$/, "");
   let result;
   try {
     result = compileSet(inputs, setName, cfg);
@@ -25944,9 +26328,9 @@ async function motionCompile(opts, log) {
     process.exitCode = 1;
     return;
   }
-  await fs36.mkdir(path36.dirname(path36.resolve(opts.out)), { recursive: true });
+  await fs37.mkdir(path37.dirname(path37.resolve(opts.out)), { recursive: true });
   const json = JSON.stringify(result.data);
-  await fs36.writeFile(opts.out, json);
+  await fs37.writeFile(opts.out, json);
   if (opts.json) {
     writeJson({ out: opts.out, set: setName, tracks: Object.keys(result.data.gaits), bytes: json.length });
     return;
@@ -25964,9 +26348,9 @@ var MOTION_RUNTIME_FILES = [
 var MOTION_PRESETS = {
   rifle: ["sets/rifle.json", "sets/jumps.json"]
 };
-var MOTION_DEST = path36.join("src", "motion");
+var MOTION_DEST = path37.join("src", "motion");
 async function motionInstall(opts, log) {
-  const srcDir = path36.join(getTemplatesDir(), "motion");
+  const srcDir = path37.join(getTemplatesDir(), "motion");
   const root = opts.cwd ?? process.cwd();
   const preset = opts.set;
   if (preset !== void 0 && !MOTION_PRESETS[preset]) {
@@ -25977,21 +26361,21 @@ async function motionInstall(opts, log) {
   const files = [...MOTION_RUNTIME_FILES, ...preset ? MOTION_PRESETS[preset] : []];
   log.plain(c.bold(`genex motion install${preset ? ` --set ${preset}` : ""}`));
   log.plain("");
-  log.step(`Vendoring the motion runtime into ${c.cyan(MOTION_DEST + path36.sep)}`);
+  log.step(`Vendoring the motion runtime into ${c.cyan(MOTION_DEST + path37.sep)}`);
   let copied = 0, skipped = 0;
   try {
     for (const rel of files) {
-      const dest = path36.join(root, MOTION_DEST, rel);
-      const exists5 = await fs36.access(dest).then(() => true, () => false);
+      const dest = path37.join(root, MOTION_DEST, rel);
+      const exists5 = await fs37.access(dest).then(() => true, () => false);
       if (!opts.force && exists5) {
         skipped++;
-        log.dim(`  skipped ${path36.join(MOTION_DEST, rel)} (exists \u2014 use --force to overwrite)`);
+        log.dim(`  skipped ${path37.join(MOTION_DEST, rel)} (exists \u2014 use --force to overwrite)`);
         continue;
       }
-      await fs36.mkdir(path36.dirname(dest), { recursive: true });
-      await fs36.copyFile(path36.join(srcDir, rel), dest);
+      await fs37.mkdir(path37.dirname(dest), { recursive: true });
+      await fs37.copyFile(path37.join(srcDir, rel), dest);
       copied++;
-      log.dim(`  ${path36.join(MOTION_DEST, rel)}`);
+      log.dim(`  ${path37.join(MOTION_DEST, rel)}`);
     }
   } catch (err) {
     log.error(`Copy failed: ${String(err)}`);
@@ -26032,7 +26416,7 @@ async function motionConstraints(opts, log) {
   }
   const doc = directionConstraint(dir, speed, duration);
   const out = opts.out ?? "constraints.json";
-  await fs36.writeFile(out, JSON.stringify(doc));
+  await fs37.writeFile(out, JSON.stringify(doc));
   if (opts.json) {
     writeJson({ out, dir: dirName, speed, duration, waypoints: doc[0].frame_indices.length });
     return;
@@ -26069,14 +26453,14 @@ async function runMotion(opts) {
 }
 
 // src/commands/blender.ts
-import fs37 from "fs/promises";
-import path37 from "path";
+import fs38 from "fs/promises";
+import path38 from "path";
 var SUBS3 = ["demo", "exec", "snap", "scene", "import", "export", "reset", "mcp", "serve", "seat", "release"];
 var DEFAULT_OUT_DIR = "assets/blender";
 async function writeB64(dir, name, b64) {
-  await fs37.mkdir(dir, { recursive: true });
-  const p = path37.join(dir, name);
-  await fs37.writeFile(p, Buffer.from(b64, "base64"));
+  await fs38.mkdir(dir, { recursive: true });
+  const p = path38.join(dir, name);
+  await fs38.writeFile(p, Buffer.from(b64, "base64"));
   return p;
 }
 function reportScene(log, s) {
@@ -26160,7 +26544,7 @@ async function runBlender(opts) {
     log.plain(rest.join("\n"));
     return 1;
   }
-  const outDir = path37.resolve(opts.outDir ?? DEFAULT_OUT_DIR);
+  const outDir = path38.resolve(opts.outDir ?? DEFAULT_OUT_DIR);
   const mode = opts.mode;
   if (mode !== void 0 && !isRenderMode(mode)) {
     log.error(`Unknown --mode ${mode}. Use one of: ${RENDER_MODES.join(", ")}.`);
@@ -26200,14 +26584,14 @@ async function runBlender(opts) {
       return 0;
     }
     case "export": {
-      const target = opts.out ?? path37.join(outDir, "scene.glb");
+      const target = opts.out ?? path38.join(outDir, "scene.glb");
       const r = await blenderCall(base, "/export", { path: "/tmp/genex-export.glb" });
       if (!r.glbBase64) {
         log.error(`/export answered with no GLB bytes${r.uploaded ? " (it was uploaded, not inlined)" : ""}`);
         return 1;
       }
-      await fs37.mkdir(path37.dirname(target), { recursive: true });
-      await fs37.writeFile(target, Buffer.from(r.glbBase64, "base64"));
+      await fs38.mkdir(path38.dirname(target), { recursive: true });
+      await fs38.writeFile(target, Buffer.from(r.glbBase64, "base64"));
       log.success(`Exported ${r.bytes ?? 0} bytes`);
       log.plain(`  ${c.cyan(target)}`);
       return 0;
@@ -26240,12 +26624,12 @@ async function runBlender(opts) {
           return 1;
         }
         try {
-          script = await fs37.readFile(opts.input, "utf8");
+          script = await fs38.readFile(opts.input, "utf8");
         } catch {
           log.error(`Can't read ${opts.input}`);
           return 1;
         }
-        label = path37.basename(opts.input);
+        label = path38.basename(opts.input);
       }
       const r = await blenderCall(base, "/exec", { script, ...mode ? { mode } : {}, sheet: { formats: SHEET_FORMATS } });
       if (r.stdout?.trim()) log.plain(r.stdout.trimEnd());
@@ -26364,10 +26748,10 @@ print(f"castle: {n} objects")
 `;
 
 // src/commands/asset-new.ts
-import fs38 from "fs";
+import fs39 from "fs";
 import fsp from "fs/promises";
-import path38 from "path";
-import { pathToFileURL } from "url";
+import path39 from "path";
+import { pathToFileURL as pathToFileURL2 } from "url";
 var EXTRA_FILES = [
   "genex-asset.example.json",
   "public/fonts/ZalandoSansSemiExpanded-variable.woff2",
@@ -26460,7 +26844,7 @@ Every milestone ends with \`npm run verify\`, then \`npx genex preview --no-buil
 }
 async function runAssetNew(options) {
   const log = createLogger();
-  const cwd = options.dir ? path38.resolve(options.dir) : process.cwd();
+  const cwd = options.dir ? path39.resolve(options.dir) : process.cwd();
   const slug = options.assetSlug;
   if (!slug) {
     log.error('Usage: genex asset new <slug> [--title "<Name>"] [--dims WxDxH] [--tri-band LOW-HIGH] [--holder "<your name>"] [--out <dir>]');
@@ -26470,14 +26854,14 @@ async function runAssetNew(options) {
     log.error(`The slug must be kebab-case (letters, digits, dashes), got: ${slug}`);
     return 1;
   }
-  const templateDir = path38.join(getTemplatesDir(), "asset-viewer");
-  if (!fs38.existsSync(templateDir)) {
+  const templateDir = path39.join(getTemplatesDir(), "asset-viewer");
+  if (!fs39.existsSync(templateDir)) {
     log.error(`Vendored asset-viewer template not found at ${templateDir} \u2014 reinstall the CLI.`);
     return 1;
   }
-  const manifestTools = await import(pathToFileURL(path38.join(templateDir, "tools", "emit-manifest.mjs")).href);
+  const manifestTools = await import(pathToFileURL2(path39.join(templateDir, "tools", "emit-manifest.mjs")).href);
   const { SHARED_FILES, PARITY_FILENAME, hashSharedFiles, pascalCase } = manifestTools;
-  const lockPath = path38.join(templateDir, "shared-files.sha256.json");
+  const lockPath = path39.join(templateDir, "shared-files.sha256.json");
   const lock = JSON.parse(await fsp.readFile(lockPath, "utf8"));
   const actual = hashSharedFiles(templateDir);
   const drifted = SHARED_FILES.filter((rel) => lock.files[rel] !== actual[rel]);
@@ -26490,8 +26874,8 @@ async function runAssetNew(options) {
   const triBand = parseBand(options.triBand ?? "500-8000");
   const holder = options.holder?.trim() || HOLDER_PLACEHOLDER;
   const year = (/* @__PURE__ */ new Date()).getUTCFullYear();
-  const outDir = path38.resolve(cwd, options.out ?? slug);
-  if (fs38.existsSync(outDir) && fs38.readdirSync(outDir).length > 0 && !options.force) {
+  const outDir = path39.resolve(cwd, options.out ?? slug);
+  if (fs39.existsSync(outDir) && fs39.readdirSync(outDir).length > 0 && !options.force) {
     log.error(`${outDir} already holds files. Nothing was touched \u2014 pass --force to write into it anyway.`);
     return 1;
   }
@@ -26519,24 +26903,24 @@ async function runAssetNew(options) {
   };
   await fsp.mkdir(outDir, { recursive: true });
   for (const rel of [...SHARED_FILES, ...EXTRA_FILES]) {
-    const to = path38.join(outDir, rel);
-    await fsp.mkdir(path38.dirname(to), { recursive: true });
-    await fsp.copyFile(path38.join(templateDir, rel), to);
+    const to = path39.join(outDir, rel);
+    await fsp.mkdir(path39.dirname(to), { recursive: true });
+    await fsp.copyFile(path39.join(templateDir, rel), to);
   }
-  const pkg = fillTemplate(await fsp.readFile(path38.join(templateDir, "package.json"), "utf8"), {
+  const pkg = fillTemplate(await fsp.readFile(path39.join(templateDir, "package.json"), "utf8"), {
     slug,
     name,
     version
   });
-  await fsp.writeFile(path38.join(outDir, "package.json"), pkg, "utf8");
-  await fsp.writeFile(path38.join(outDir, "asset.config.json"), JSON.stringify(config, null, 2) + "\n", "utf8");
-  await fsp.writeFile(path38.join(outDir, ".gitignore"), GITIGNORE, "utf8");
+  await fsp.writeFile(path39.join(outDir, "package.json"), pkg, "utf8");
+  await fsp.writeFile(path39.join(outDir, "asset.config.json"), JSON.stringify(config, null, 2) + "\n", "utf8");
+  await fsp.writeFile(path39.join(outDir, ".gitignore"), GITIGNORE, "utf8");
   await fsp.writeFile(
-    path38.join(outDir, "DESIGN.md"),
+    path39.join(outDir, "DESIGN.md"),
     designDoc({ name, slug, sizeMeters, triBand, holder }),
     "utf8"
   );
-  const placeholder = await fsp.readFile(path38.join(templateDir, "src", "asset", "PLACEHOLDER.ts"), "utf8");
+  const placeholder = await fsp.readFile(path39.join(templateDir, "src", "asset", "PLACEHOLDER.ts"), "utf8");
   const seeded = seedAssetSource(placeholder, {
     slug,
     name,
@@ -26547,8 +26931,8 @@ async function runAssetNew(options) {
     pascalCase
   });
   const assetFilename = `${slug.replace(/-([a-z0-9])/g, (_, ch) => ch.toUpperCase())}.ts`;
-  await fsp.mkdir(path38.join(outDir, "src", "asset"), { recursive: true });
-  await fsp.writeFile(path38.join(outDir, "src", "asset", assetFilename), seeded, "utf8");
+  await fsp.mkdir(path39.join(outDir, "src", "asset"), { recursive: true });
+  await fsp.writeFile(path39.join(outDir, "src", "asset", assetFilename), seeded, "utf8");
   const copied = hashSharedFiles(outDir);
   const mismatched = SHARED_FILES.filter((rel) => copied[rel] !== lock.files[rel]);
   if (mismatched.length) {
@@ -26556,7 +26940,7 @@ async function runAssetNew(options) {
     return 1;
   }
   await fsp.writeFile(
-    path38.join(outDir, PARITY_FILENAME),
+    path39.join(outDir, PARITY_FILENAME),
     JSON.stringify(
       {
         note: "Recorded by `genex asset new`. Gate G13 recomputes these; do not hand-edit the viewer.",
@@ -26600,14 +26984,14 @@ async function runAssetNew(options) {
 }
 
 // src/commands/tools.ts
-import path41 from "path";
+import path42 from "path";
 
 // src/commands/doctor.ts
-import path40 from "path";
+import path41 from "path";
 
 // src/commands/llm.ts
-import fs39 from "fs/promises";
-import path39 from "path";
+import fs40 from "fs/promises";
+import path40 from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 var SUBS4 = ["models", "bench", "price", "status", "cancel"];
 var LLM_BENCH_APPROVAL_REQUIRED = "STOP: `genex llm bench` runs the real model and spends YOUR OWN credits \u2014 your balance, not a player's, and a spend this build's asset allowance does not count. Re-run with --max-credits <n> --user-approved only after the person at the keyboard agreed to the number.";
@@ -27129,7 +27513,7 @@ async function runBench(args) {
   let schema;
   if (opts.schemaPath) {
     try {
-      schema = JSON.parse(await fs39.readFile(path39.resolve(cwd, opts.schemaPath), "utf8"));
+      schema = JSON.parse(await fs40.readFile(path40.resolve(cwd, opts.schemaPath), "utf8"));
     } catch (err) {
       benchFailed(opts, log, `Couldn't read --schema ${opts.schemaPath}: ${err instanceof Error ? err.message : String(err)}`);
       return;
@@ -27511,9 +27895,9 @@ async function pollSettled(call3, url, timeoutSec) {
 }
 async function saveBench(cwd, record) {
   try {
-    const file = path39.join(cwd, LLM_BENCH_FILE);
-    await fs39.mkdir(path39.dirname(file), { recursive: true });
-    await fs39.writeFile(file, JSON.stringify(record, null, 2) + "\n");
+    const file = path40.join(cwd, LLM_BENCH_FILE);
+    await fs40.mkdir(path40.dirname(file), { recursive: true });
+    await fs40.writeFile(file, JSON.stringify(record, null, 2) + "\n");
     return LLM_BENCH_FILE;
   } catch {
     return null;
@@ -27726,7 +28110,7 @@ async function cancelCall(args) {
 async function readSavedBench(cwd) {
   let parsed;
   try {
-    parsed = JSON.parse(await fs39.readFile(path39.join(cwd, LLM_BENCH_FILE), "utf8"));
+    parsed = JSON.parse(await fs40.readFile(path40.join(cwd, LLM_BENCH_FILE), "utf8"));
   } catch {
     return null;
   }
@@ -28158,7 +28542,7 @@ async function fetchLegalStatus(apiUrl, token) {
 }
 async function firstSkillsMarker() {
   for (const target of resolveAgentTargets()) {
-    const marker = await readSkillsMarker(path40.join(target.baseDir, "skills"));
+    const marker = await readSkillsMarker(path41.join(target.baseDir, "skills"));
     if (marker) return marker;
   }
   return null;
@@ -28210,11 +28594,11 @@ async function runTools(opts) {
   let totalUpdated = 0;
   const refused = [];
   for (const t of targets) {
-    const dest = path41.join(t.baseDir, "skills");
+    const dest = path42.join(t.baseDir, "skills");
     let copied;
     let updated;
     try {
-      ({ copied, updated } = await copyTemplates(path41.join(templatesDir, "skills"), dest, {
+      ({ copied, updated } = await copyTemplates(path42.join(templatesDir, "skills"), dest, {
         filter: (rel) => skillFamilyFilter("tools")(`skills/${rel}`)
       }));
       await pruneRemovedSkills(dest, log);
@@ -28286,8 +28670,8 @@ async function runTools(opts) {
 }
 
 // src/commands/budget.ts
-import fs40 from "fs/promises";
-import path42 from "path";
+import fs41 from "fs/promises";
+import path43 from "path";
 var BUDGET_SOURCE_LINE = "Live from your account; prices can change without a deploy.";
 var BUDGET_APPROVAL_REQUIRED = "STOP: raising the asset allowance requires the player's explicit approval. Re-run with --user-approved only after they agreed to the number.";
 function internalKind(kind) {
@@ -28295,7 +28679,7 @@ function internalKind(kind) {
 }
 async function isGenexProject(cwd) {
   try {
-    await fs40.access(path42.join(cwd, ".genex"));
+    await fs41.access(path43.join(cwd, ".genex"));
     return true;
   } catch {
     return false;
@@ -28444,39 +28828,39 @@ async function runBudget(opts = {}) {
 }
 
 // src/commands/player.ts
-import fs45 from "fs";
+import fs46 from "fs";
 import fsp2 from "fs/promises";
 import os13 from "os";
-import path48 from "path";
+import path49 from "path";
 import { spawn as spawn8 } from "child_process";
 
 // src/lib/player/paths.ts
 import os9 from "os";
-import path43 from "path";
+import path44 from "path";
 var PLAYER_DRY_RUN_ENV = "GENEX_PLAYER_DRY_RUN";
 function playerDryRun() {
   const raw = process.env[PLAYER_DRY_RUN_ENV];
   return raw === "1" || raw === "true";
 }
 function playerPaths(home = os9.homedir()) {
-  const dir = home === os9.homedir() ? getGenexDir() : path43.join(home, ".genex");
-  const logDir = path43.join(dir, "logs");
+  const dir = home === os9.homedir() ? getGenexDir() : path44.join(home, ".genex");
+  const logDir = path44.join(dir, "logs");
   return {
-    credential: path43.join(dir, "player.json"),
-    state: path43.join(dir, "player-state.json"),
-    relaunch: path43.join(dir, "player-relaunch.json"),
+    credential: path44.join(dir, "player.json"),
+    state: path44.join(dir, "player-state.json"),
+    relaunch: path44.join(dir, "player-relaunch.json"),
     logDir,
-    log: path43.join(logDir, "player.log"),
-    errorLog: path43.join(logDir, "player.error.log")
+    log: path44.join(logDir, "player.log"),
+    errorLog: path44.join(logDir, "player.error.log")
   };
 }
 
 // src/lib/player/store.ts
-import fs41 from "fs/promises";
-import path44 from "path";
+import fs42 from "fs/promises";
+import path45 from "path";
 async function readPlayerInstall(home) {
   try {
-    const raw = await fs41.readFile(playerPaths(home).credential, "utf8");
+    const raw = await fs42.readFile(playerPaths(home).credential, "utf8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed.token !== "string" || typeof parsed.apiUrl !== "string") return null;
     return parsed;
@@ -28506,7 +28890,7 @@ function describeInstall(install2) {
 }
 async function readPlayerState(home) {
   try {
-    return JSON.parse(await fs41.readFile(playerPaths(home).state, "utf8"));
+    return JSON.parse(await fs42.readFile(playerPaths(home).state, "utf8"));
   } catch {
     return null;
   }
@@ -28514,8 +28898,8 @@ async function readPlayerState(home) {
 async function writePlayerState(state, home) {
   const file = playerPaths(home).state;
   try {
-    await fs41.mkdir(path44.dirname(file), { recursive: true, mode: 448 });
-    await fs41.writeFile(file, JSON.stringify(state, null, 2) + "\n", { mode: 384 });
+    await fs42.mkdir(path45.dirname(file), { recursive: true, mode: 448 });
+    await fs42.writeFile(file, JSON.stringify(state, null, 2) + "\n", { mode: 384 });
   } catch {
   }
 }
@@ -28523,8 +28907,8 @@ async function removePlayerFiles(home) {
   const paths = playerPaths(home);
   const removed = [];
   for (const file of [paths.credential, paths.state, paths.relaunch]) {
-    const existed = await fs41.stat(file).then(() => true, () => false);
-    await fs41.rm(file, { force: true }).catch(() => {
+    const existed = await fs42.stat(file).then(() => true, () => false);
+    await fs42.rm(file, { force: true }).catch(() => {
     });
     if (existed) removed.push(file);
   }
@@ -28658,14 +29042,14 @@ var PlayerClient = class {
     this.version = options.version ?? getCliVersion();
     this.timeoutMs = options.timeoutMs ?? 3e4;
   }
-  async call(path52, init = {}, provider) {
+  async call(path53, init = {}, provider) {
     const headers = {
       Authorization: `Bearer ${this.token}`,
       [PLAYER_VERSION_HEADER]: this.version,
       ...provider ? { [EXTERNAL_PROVIDER_HEADER]: provider } : {},
       ...init.body === void 0 ? {} : { "Content-Type": "application/json" }
     };
-    const res = await apiFetch(`${this.apiUrl}${path52}`, {
+    const res = await apiFetch(`${this.apiUrl}${path53}`, {
       ...init,
       headers,
       signal: AbortSignal.timeout(this.timeoutMs)
@@ -28734,10 +29118,10 @@ var PlayerClient = class {
 
 // src/lib/player/runners.ts
 import { spawn as spawn6, spawnSync } from "child_process";
-import fs42 from "fs/promises";
+import fs43 from "fs/promises";
 import fsSync from "fs";
 import os10 from "os";
-import path45 from "path";
+import path46 from "path";
 import { randomUUID as randomUUID3 } from "crypto";
 var WATCHER_RUNNERS = ["claude", "codex"];
 var RUNNER_FOR_FAMILY = { claude: "claude", chatgpt: "codex" };
@@ -28795,7 +29179,7 @@ function resolveOnPath(name, env = process.env, platform = process.platform) {
   const candidates = win ? [`${name}.cmd`, `${name}.exe`, `${name}.bat`, name] : [name];
   for (const dir of dirs) {
     for (const candidate of candidates) {
-      const file = path45.join(dir, candidate);
+      const file = path46.join(dir, candidate);
       try {
         const stat = fsSync.statSync(file);
         if (!stat.isFile()) continue;
@@ -28959,17 +29343,17 @@ async function runJob(job, options = {}) {
   if (!resolved) {
     return { ok: false, release: "runner_unavailable", detail: `missing:${runner}`, durationMs: Date.now() - started };
   }
-  const cwd = path45.join(os10.tmpdir(), `genex-player-${randomUUID3()}`);
-  await fs42.mkdir(cwd, { recursive: true, mode: 448 });
-  const outFile = path45.join(cwd, "result.out");
+  const cwd = path46.join(os10.tmpdir(), `genex-player-${randomUUID3()}`);
+  await fs43.mkdir(cwd, { recursive: true, mode: 448 });
+  const outFile = path46.join(cwd, "result.out");
   let argv;
   if (runner === "claude") {
     argv = claudeArgv(job, policy.claude ?? FALLBACK_POLICY.claude ?? {});
   } else {
     let schemaFile;
     if (job.outputFormat === "json" && job.schema !== void 0) {
-      schemaFile = path45.join(cwd, "schema.json");
-      await fs42.writeFile(schemaFile, JSON.stringify(job.schema), { mode: 384 });
+      schemaFile = path46.join(cwd, "schema.json");
+      await fs43.writeFile(schemaFile, JSON.stringify(job.schema), { mode: 384 });
     }
     argv = codexArgv(job, policy.codex ?? FALLBACK_POLICY.codex ?? {}, { cwd, outFile, ...schemaFile ? { schemaFile } : {} });
   }
@@ -29033,7 +29417,7 @@ async function runJob(job, options = {}) {
       if (!read2.ok) return { ok: false, release: "failed", detail: read2.detail, exitCode: code, durationMs };
       return { ok: true, output: read2.output, exitCode: code, durationMs };
     }
-    const text = await fs42.readFile(outFile, "utf8").catch(() => "");
+    const text = await fs43.readFile(outFile, "utf8").catch(() => "");
     if (code !== 0 && !text.trim()) {
       const classified = classifyFailure(`${stderrText} exit ${code}`);
       return { ok: false, ...classified, detail: `exit_${code}`, exitCode: code, durationMs };
@@ -29042,15 +29426,15 @@ async function runJob(job, options = {}) {
     if (!read.ok) return { ok: false, release: "failed", detail: read.detail, exitCode: code, durationMs };
     return { ok: true, output: read.output, exitCode: code, durationMs };
   } finally {
-    await fs42.rm(cwd, { recursive: true, force: true }).catch(() => {
+    await fs43.rm(cwd, { recursive: true, force: true }).catch(() => {
     });
   }
 }
 
 // src/lib/player/service.ts
-import fs43 from "fs/promises";
+import fs44 from "fs/promises";
 import os11 from "os";
-import path46 from "path";
+import path47 from "path";
 import { execFile } from "child_process";
 import { promisify } from "util";
 var run2 = promisify(execFile);
@@ -29067,9 +29451,9 @@ function servicePlatform(platform = process.platform) {
 }
 function servicePaths(platform, home = os11.homedir()) {
   const { log, errorLog } = playerPaths(home);
-  if (platform === "darwin") return { log, errorLog, unit: path46.join(home, "Library", "LaunchAgents", `${SERVICE_LABEL}.plist`) };
-  if (platform === "linux") return { log, errorLog, unit: path46.join(home, ".config", "systemd", "user", SYSTEMD_UNIT) };
-  return { log, errorLog, unit: path46.join(home, "AppData", "Roaming", "Microsoft", "Windows", "Start Menu", "Programs", "Startup", "genex-player.cmd") };
+  if (platform === "darwin") return { log, errorLog, unit: path47.join(home, "Library", "LaunchAgents", `${SERVICE_LABEL}.plist`) };
+  if (platform === "linux") return { log, errorLog, unit: path47.join(home, ".config", "systemd", "user", SYSTEMD_UNIT) };
+  return { log, errorLog, unit: path47.join(home, "AppData", "Roaming", "Microsoft", "Windows", "Start Menu", "Programs", "Startup", "genex-player.cmd") };
 }
 function xmlEscape(value) {
   return value.replace(/[<>&'"]/g, (ch) => ({ "<": "&lt;", ">": "&gt;", "&": "&amp;", "'": "&apos;", '"': "&quot;" })[ch]);
@@ -29148,9 +29532,9 @@ function autostartCommand(opts) {
 }
 async function installService(input, platform = servicePlatform()) {
   const paths = servicePaths(platform, input.home);
-  await fs43.mkdir(path46.dirname(paths.unit), { recursive: true });
-  await fs43.mkdir(path46.dirname(paths.log), { recursive: true, mode: 448 });
-  await fs43.writeFile(paths.unit, unitFile(platform, input, paths), { mode: platform === "win32" ? 420 : 384 });
+  await fs44.mkdir(path47.dirname(paths.unit), { recursive: true });
+  await fs44.mkdir(path47.dirname(paths.log), { recursive: true, mode: 448 });
+  await fs44.writeFile(paths.unit, unitFile(platform, input, paths), { mode: platform === "win32" ? 420 : 384 });
   if (playerDryRun()) return { unit: paths.unit, loaded: false, detail: "dry run \u2014 the unit was written, the system was not asked" };
   if (platform === "darwin") {
     const domain = `gui/${process.getuid?.() ?? 501}`;
@@ -29179,7 +29563,7 @@ async function installService(input, platform = servicePlatform()) {
 }
 async function serviceInstalled(home = os11.homedir(), platform = servicePlatform()) {
   const paths = servicePaths(platform, home);
-  return await fs43.stat(paths.unit).then(() => paths.unit, () => null);
+  return await fs44.stat(paths.unit).then(() => paths.unit, () => null);
 }
 async function stopService(home = os11.homedir(), platform = servicePlatform()) {
   const paths = servicePaths(platform, home);
@@ -29209,15 +29593,15 @@ async function uninstallService(home = os11.homedir(), platform = servicePlatfor
       });
     }
   }
-  await fs43.rm(paths.unit, { force: true }).catch(() => {
+  await fs44.rm(paths.unit, { force: true }).catch(() => {
   });
   return { unit: paths.unit, loaded: false, detail: present ? "removed" : "nothing installed" };
 }
 
 // src/lib/player/relaunch.ts
-import fs44 from "fs/promises";
+import fs45 from "fs/promises";
 import fsSync2 from "fs";
-import path47 from "path";
+import path48 from "path";
 import { spawn as spawn7 } from "child_process";
 var RELAUNCH_COOLDOWN_MS = 10 * 60 * 1e3;
 function relaunchPlan(input) {
@@ -29245,7 +29629,7 @@ function relaunchPossible() {
 }
 async function relaunchOnCooldown(home, now = Date.now()) {
   try {
-    const raw = await fs44.readFile(playerPaths(home).relaunch, "utf8");
+    const raw = await fs45.readFile(playerPaths(home).relaunch, "utf8");
     const at = Date.parse(JSON.parse(raw).at ?? "");
     return Number.isFinite(at) && now - at < RELAUNCH_COOLDOWN_MS;
   } catch {
@@ -29255,8 +29639,8 @@ async function relaunchOnCooldown(home, now = Date.now()) {
 async function markRelaunch(version, home) {
   const file = playerPaths(home).relaunch;
   try {
-    await fs44.mkdir(path47.dirname(file), { recursive: true, mode: 448 });
-    await fs44.writeFile(file, JSON.stringify({ at: (/* @__PURE__ */ new Date()).toISOString(), version }) + "\n", { mode: 384 });
+    await fs45.mkdir(path48.dirname(file), { recursive: true, mode: 448 });
+    await fs45.writeFile(file, JSON.stringify({ at: (/* @__PURE__ */ new Date()).toISOString(), version }) + "\n", { mode: 384 });
   } catch {
   }
 }
@@ -29280,7 +29664,7 @@ async function relaunchWatcher(input) {
   let err;
   const paths = playerPaths(input.home);
   try {
-    await fs44.mkdir(paths.logDir, { recursive: true, mode: 448 });
+    await fs45.mkdir(paths.logDir, { recursive: true, mode: 448 });
     out = fsSync2.openSync(paths.log, "a", 384);
     err = fsSync2.openSync(paths.errorLog, "a", 384);
   } catch {
@@ -29761,8 +30145,8 @@ async function spawnDetachedRun(apiUrl, opts) {
   try {
     const paths = playerPaths();
     await fsp2.mkdir(paths.logDir, { recursive: true, mode: 448 });
-    out = fs45.openSync(paths.log, "a", 384);
-    err = fs45.openSync(paths.errorLog, "a", 384);
+    out = fs46.openSync(paths.log, "a", 384);
+    err = fs46.openSync(paths.errorLog, "a", 384);
     const args = [process.argv[1] ?? "", "player", "run", ...opts.apiUrl ? ["--api-url", apiUrl] : []];
     const child = spawn8(process.execPath, args, { detached: true, stdio: ["ignore", out, err] });
     child.on("error", () => {
@@ -29773,7 +30157,7 @@ async function spawnDetachedRun(apiUrl, opts) {
     return false;
   } finally {
     for (const fd of [out, err]) if (fd !== void 0) try {
-      fs45.closeSync(fd);
+      fs46.closeSync(fd);
     } catch {
     }
   }
@@ -29972,7 +30356,7 @@ async function uninstall(opts, log) {
     writeJsonLine2({ command: "player uninstall", status: "ok", error: null, unit: service.unit, detail: service.detail, removed });
     return;
   }
-  log.success(`Removed: ${service.detail} (${path48.basename(service.unit)})`);
+  log.success(`Removed: ${service.detail} (${path49.basename(service.unit)})`);
   for (const file of removed) log.dim(`  deleted ${file}`);
   if (removed.length === 0) log.dim("  no credential was stored here");
   log.plain("");
@@ -29990,21 +30374,21 @@ function writeJsonLine2(value) {
 }
 
 // src/commands/native.ts
-import fs51 from "fs/promises";
+import fs52 from "fs/promises";
 import os15 from "os";
-import path51 from "path";
+import path52 from "path";
 
 // src/lib/native-build.ts
 import { createHash as createHash5 } from "crypto";
 import { createReadStream } from "fs";
-import fs47 from "fs/promises";
+import fs48 from "fs/promises";
 import os14 from "os";
-import path49 from "path";
+import path50 from "path";
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
 
 // src/lib/native-zip.ts
-import fs46 from "fs/promises";
+import fs47 from "fs/promises";
 import zlib3 from "zlib";
 var EOCD_SIGNATURE2 = 101010256;
 var EOCD64_LOCATOR_SIGNATURE = 117853008;
@@ -30106,7 +30490,7 @@ function entryAt(data, at) {
   return { entry, madeBy, external, next: at + 46 + nameLength + extraLength + commentLength };
 }
 async function readZipEntries(filePath) {
-  const file = await fs46.open(filePath, "r");
+  const file = await fs47.open(filePath, "r");
   try {
     const { size } = await file.stat();
     const directory = await findDirectory2(file, size);
@@ -30125,7 +30509,7 @@ async function readZipEntries(filePath) {
   }
 }
 async function readZipEntryHead(filePath, entry, maxBytes) {
-  const file = await fs46.open(filePath, "r");
+  const file = await fs47.open(filePath, "r");
   try {
     return await entryHead(file, entry, maxBytes);
   } finally {
@@ -30154,7 +30538,7 @@ function wantedMode(mode, directory, program) {
   return (mode | S_IFREG2 | EXECUTE_BITS) >>> 0;
 }
 async function markPrograms(filePath) {
-  const file = await fs46.open(filePath, "r+");
+  const file = await fs47.open(filePath, "r+");
   try {
     const { size } = await file.stat();
     const directory = await findDirectory2(file, size);
@@ -30234,7 +30618,7 @@ function rootApps(entries) {
 }
 function launchableExes(entries) {
   const exes = entries.filter((e) => !isDirectory(e) && e.name.toLowerCase().endsWith(".exe"));
-  const games = exes.filter((e) => e.name.split("/").length <= ENTRY_DEPTH_MAX && !HELPER_EXE.test(path49.posix.basename(e.name)));
+  const games = exes.filter((e) => e.name.split("/").length <= ENTRY_DEPTH_MAX && !HELPER_EXE.test(path50.posix.basename(e.name)));
   const depth = (name) => name.split("/").length;
   return games.map((e) => e.name).sort((a, b) => depth(a) - depth(b) || a.localeCompare(b));
 }
@@ -30316,7 +30700,7 @@ function exeArch(head) {
 }
 function engineOf(entries) {
   const names2 = entries.map((e) => e.name.toLowerCase());
-  const base = (name) => path49.posix.basename(name.replace(/\/$/, ""));
+  const base = (name) => path50.posix.basename(name.replace(/\/$/, ""));
   if (names2.some((n) => /^unityplayer\.(dll|dylib|so)$/.test(base(n)) || base(n) === "globalgamemanagers")) return "unity";
   if (names2.some((n) => n.startsWith("engine/binaries/") || /\.app\/contents\/ue[45]?\//.test(n) || n.includes("/engine/binaries/")))
     return "unreal";
@@ -30360,7 +30744,7 @@ async function describeNativeArchive(zipPath, asked = {}) {
   try {
     entries = await readZipEntries(zipPath);
   } catch (err) {
-    throw new NativeBuildError(`Couldn't read ${path49.basename(zipPath)} as a zip: ${err.message}`);
+    throw new NativeBuildError(`Couldn't read ${path50.basename(zipPath)} as a zip: ${err.message}`);
   }
   if (entries.length === 0) throw new NativeBuildError("The archive is empty.");
   const platform = platformOf(entries, asked.platform);
@@ -30382,14 +30766,14 @@ async function describeNativeArchive(zipPath, asked = {}) {
     ...mac?.appVersion ? { appVersion: mac.appVersion } : {}
   };
 }
-function buildVersion(asked, appVersion, sha2564) {
+function buildVersion(asked, appVersion, sha2565) {
   if (asked !== void 0) {
     if (asked.length > VERSION_MAX || !VERSION2.test(asked)) {
       throw new NativeBuildError(`--build-version "${asked}" may hold only letters, digits and . _ + - (at most ${VERSION_MAX}).`);
     }
     return asked;
   }
-  const hash = sha2564.slice(0, VERSION_SHA_CHARS);
+  const hash = sha2565.slice(0, VERSION_SHA_CHARS);
   const app = (appVersion ?? "").replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^[^A-Za-z0-9]+/, "").slice(0, VERSION_MAX - hash.length - 1);
   return app ? `${app}+${hash}` : hash;
 }
@@ -30405,28 +30789,28 @@ async function hashFile(filePath, onProgress) {
 }
 async function packTarget(dir) {
   if (dir.toLowerCase().endsWith(".app")) return { target: dir, keepParent: true };
-  const children = await fs47.readdir(dir, { withFileTypes: true });
+  const children = await fs48.readdir(dir, { withFileTypes: true });
   const apps = children.filter((d) => d.isDirectory() && d.name.toLowerCase().endsWith(".app"));
-  if (apps.length === 1) return { target: path49.join(dir, apps[0].name), keepParent: true };
+  if (apps.length === 1) return { target: path50.join(dir, apps[0].name), keepParent: true };
   return { target: dir, keepParent: false };
 }
-var windowsTar = () => path49.join(process.env.SystemRoot ?? "C:\\Windows", "System32", "tar.exe");
+var windowsTar = () => path50.join(process.env.SystemRoot ?? "C:\\Windows", "System32", "tar.exe");
 async function zipFolder(target, keepParent, zipPath, opts) {
   const platform = opts.platform ?? process.platform;
   if (platform === "darwin") {
     await run4("ditto", ["-c", "-k", "--sequesterRsrc", ...keepParent ? ["--keepParent"] : [], target, zipPath]);
     return;
   }
-  const cwd = keepParent ? path49.dirname(target) : target;
+  const cwd = keepParent ? path50.dirname(target) : target;
   if (platform === "win32") {
-    const names2 = keepParent ? [path49.basename(target)] : await fs47.readdir(target);
+    const names2 = keepParent ? [path50.basename(target)] : await fs48.readdir(target);
     await run4(opts.tar ?? windowsTar(), ["-a", "-c", "-f", zipPath, ...names2], { cwd });
     return;
   }
-  await run4("zip", ["-q", "-r", "-y", zipPath, keepParent ? path49.basename(target) : "."], { cwd });
+  await run4("zip", ["-q", "-r", "-y", zipPath, keepParent ? path50.basename(target) : "."], { cwd });
 }
 async function packNativeBuild(input, opts = {}) {
-  const stat = await fs47.stat(input).catch(() => null);
+  const stat = await fs48.stat(input).catch(() => null);
   if (!stat) throw new NativeBuildError(`${input} does not exist.`);
   if (stat.isFile()) {
     if (!input.toLowerCase().endsWith(".zip")) throw new NativeBuildError("Pass a .zip, a .app, or the build's folder.");
@@ -30434,9 +30818,9 @@ async function packNativeBuild(input, opts = {}) {
     } };
   }
   const { target, keepParent } = await packTarget(input);
-  const dir = await fs47.mkdtemp(path49.join(os14.tmpdir(), "genex-native-"));
-  const zipPath = path49.join(dir, `${path49.basename(target).replace(/[^A-Za-z0-9._-]+/g, "-") || "build"}.zip`);
-  const cleanup = () => fs47.rm(dir, { recursive: true, force: true });
+  const dir = await fs48.mkdtemp(path50.join(os14.tmpdir(), "genex-native-"));
+  const zipPath = path50.join(dir, `${path50.basename(target).replace(/[^A-Za-z0-9._-]+/g, "-") || "build"}.zip`);
+  const cleanup = () => fs48.rm(dir, { recursive: true, force: true });
   try {
     await zipFolder(target, keepParent, zipPath, opts);
     await markPrograms(zipPath);
@@ -30452,7 +30836,7 @@ async function packNativeBuild(input, opts = {}) {
 }
 
 // src/lib/native-upload.ts
-import fs48 from "fs/promises";
+import fs49 from "fs/promises";
 var PART_CONCURRENCY = 2;
 async function call(ctx, route, init, what, log) {
   let res;
@@ -30498,7 +30882,7 @@ async function uploadNativeArchive(grant, zipPath, sizeBytes, log, onProgress) {
   const base = grant.uploadUrl.replace(/\/+$/, "");
   const encoded = grant.uploadPath.split("/").map(encodeURIComponent).join("/");
   const auth = { Authorization: `Bearer ${grant.token}` };
-  const file = await fs48.open(zipPath, "r");
+  const file = await fs49.open(zipPath, "r");
   try {
     if (sizeBytes <= grant.limits.singlePutMaxBytes) {
       const body = await readPart(file, 0, sizeBytes);
@@ -30601,7 +30985,7 @@ async function listInGallery(ctx, body, log) {
 }
 
 // src/lib/cloud-build.ts
-import fs49 from "fs/promises";
+import fs50 from "fs/promises";
 var CLOUD_BUILD_PLATFORMS = ["windows", "linux", "mac"];
 var isCloudBuildPlatform = (value) => CLOUD_BUILD_PLATFORMS.includes(value);
 var CLOUD_BUILD_JOB_ID = /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/;
@@ -30718,7 +31102,7 @@ async function uploadCloudBuildSource(upload, zipPath, sizeBytes, log, onProgres
     log.error(`The API sent ${parts.length} upload URLs for a ${expected}-part project. Run this again.`);
     return null;
   }
-  const file = await fs49.open(zipPath, "r");
+  const file = await fs50.open(zipPath, "r");
   const done = [];
   let sent = 0;
   let next = 0;
@@ -30752,8 +31136,8 @@ async function uploadCloudBuildSource(upload, zipPath, sizeBytes, log, onProgres
 }
 
 // src/lib/source-zip.ts
-import fs50 from "fs/promises";
-import path50 from "path";
+import fs51 from "fs/promises";
+import path51 from "path";
 import zlib4 from "zlib";
 var SOURCE_ZIP_ROOT_EXCLUDES = [".genex", "Intermediate", "Saved", "DerivedDataCache", "Binaries"];
 var SOURCE_ZIP_EXCLUDES_ANYWHERE = [".git", ".DS_Store", ".env"];
@@ -30771,23 +31155,23 @@ var U32_MAX2 = 4294967295;
 var CHUNK = 1024 * 1024;
 var isExcludedAnywhere = (name) => SOURCE_ZIP_EXCLUDES_ANYWHERE.includes(name) || ENV_VARIANT.test(name) && name !== ENV_TEMPLATE;
 function inside(root, target) {
-  const rel = path50.relative(root, target);
-  return rel === "" || rel !== ".." && !rel.startsWith(`..${path50.sep}`) && !path50.isAbsolute(rel);
+  const rel = path51.relative(root, target);
+  return rel === "" || rel !== ".." && !rel.startsWith(`..${path51.sep}`) && !path51.isAbsolute(rel);
 }
 async function plan(root) {
   const entries = [];
   const skippedLinks = [];
   const walk2 = async (dir, rel) => {
-    const children = await fs50.readdir(dir, { withFileTypes: true });
+    const children = await fs51.readdir(dir, { withFileTypes: true });
     let kept = 0;
     for (const child of children) {
       const name = child.name;
       const childRel = rel ? `${rel}/${name}` : name;
-      const abs = path50.join(dir, name);
+      const abs = path51.join(dir, name);
       if (isExcludedAnywhere(name)) continue;
       if (!rel && SOURCE_ZIP_ROOT_EXCLUDES.includes(name)) continue;
       if (child.isSymbolicLink()) {
-        const target = await fs50.realpath(abs).catch(() => null);
+        const target = await fs51.realpath(abs).catch(() => null);
         if (target !== null && !inside(root, target)) {
           throw new SourceZipError(
             `${childRel} is a link to ${target}, outside the folder being built. Copy what it points to into the project, or remove the link.`
@@ -30801,7 +31185,7 @@ async function plan(root) {
         await walk2(abs, childRel);
       } else if (child.isFile()) {
         kept++;
-        const { size } = await fs50.stat(abs);
+        const { size } = await fs51.stat(abs);
         entries.push({ name: childRel, abs, size });
       }
     }
@@ -30847,8 +31231,8 @@ var Out = class {
   }
 };
 async function writeSourceZip(root, zipPath, opts = {}) {
-  const { entries, skippedLinks } = await plan(await fs50.realpath(root));
-  const file = await fs50.open(zipPath, "w");
+  const { entries, skippedLinks } = await plan(await fs51.realpath(root));
+  const file = await fs51.open(zipPath, "w");
   const out = new Out(file);
   const central = [];
   let contentBytes = 0;
@@ -30875,7 +31259,7 @@ async function writeSourceZip(root, zipPath, opts = {}) {
       await out.write(Buffer.concat([local, name, localExtra]));
       let crc = 0;
       if (entry.abs) {
-        const source = await fs50.open(entry.abs, "r");
+        const source = await fs51.open(entry.abs, "r");
         try {
           let read = 0;
           for (; ; ) {
@@ -30966,12 +31350,12 @@ function zip64Extra(values) {
   return extra;
 }
 async function resolveZipSource(dir, cwd = process.cwd()) {
-  const abs = path50.resolve(cwd, dir);
-  const stat = await fs50.lstat(abs).catch(() => null);
+  const abs = path51.resolve(cwd, dir);
+  const stat = await fs51.lstat(abs).catch(() => null);
   if (!stat) return { refused: `--source ${abs} does not exist.` };
   if (stat.isSymbolicLink()) return { refused: `--source ${abs} is a symbolic link. Pass the folder itself.` };
   if (!stat.isDirectory()) return { refused: `--source ${abs} is not a folder.` };
-  return { dir: await fs50.realpath(abs) };
+  return { dir: await fs51.realpath(abs) };
 }
 
 // src/commands/native.ts
@@ -31063,10 +31447,10 @@ async function runPublish2(opts, log) {
     const description = await describeNativeArchive(packed.zipPath, opts);
     log.step(describeLine(description));
     log.step("Hashing the archive\u2026");
-    const { sha256: sha2564, sizeBytes } = await hashFile(packed.zipPath);
-    const version = buildVersion(opts.buildVersion, description.appVersion, sha2564);
+    const { sha256: sha2565, sizeBytes } = await hashFile(packed.zipPath);
+    const version = buildVersion(opts.buildVersion, description.appVersion, sha2565);
     const { platform, arch, entry, installedBytes, minOs, engine } = description;
-    const grant = await requestNativeUpload(ctx, { platform, arch, sha256: sha2564, sizeBytes }, log);
+    const grant = await requestNativeUpload(ctx, { platform, arch, sha256: sha2565, sizeBytes }, log);
     if (!grant) return false;
     if (grant.uploaded) {
       log.step(`Already uploaded (${sizeLine(sizeBytes)}).`);
@@ -31077,7 +31461,7 @@ async function runPublish2(opts, log) {
     }
     const build = await publishNativeBuild(
       ctx,
-      { platform, arch, sha256: sha2564, sizeBytes, installedBytes, version, entry, ...minOs ? { minOs } : {}, ...engine ? { engine } : {} },
+      { platform, arch, sha256: sha2565, sizeBytes, installedBytes, version, entry, ...minOs ? { minOs } : {}, ...engine ? { engine } : {} },
       log
     );
     if (!build) return false;
@@ -31224,8 +31608,8 @@ async function runBuild(opts, log) {
   }
   const ctx = await context3(opts, log);
   if (!ctx) return false;
-  const tmp = await fs51.mkdtemp(path51.join(os15.tmpdir(), "genex-cloud-build-"));
-  const zipPath = path51.join(tmp, "source.zip");
+  const tmp = await fs52.mkdtemp(path52.join(os15.tmpdir(), "genex-cloud-build-"));
+  const zipPath = path52.join(tmp, "source.zip");
   try {
     log.step(`Zipping ${source.dir}\u2026`);
     let zipped;
@@ -31245,11 +31629,11 @@ async function runBuild(opts, log) {
       const more = zipped.skippedLinks.length > 5 ? ` and ${zipped.skippedLinks.length - 5} more` : "";
       log.warn(`Left out ${zipped.skippedLinks.length} link(s) inside the folder: ${shown}${more}.`);
     }
-    const { sha256: sha2564, sizeBytes } = await hashFile(zipPath);
+    const { sha256: sha2565, sizeBytes } = await hashFile(zipPath);
     log.step(`${zipped.entries} files, ${sizeLine(sizeBytes)} zipped.`);
     const body = {
       platform: opts.platform,
-      sourceSha256: sha2564,
+      sourceSha256: sha2565,
       sourceBytes: sizeBytes,
       ...opts.buildVersion !== void 0 ? { version: opts.buildVersion } : {}
     };
@@ -31294,7 +31678,7 @@ async function runBuild(opts, log) {
     if (opts.json) console.log(JSON.stringify({ build }));
     return true;
   } finally {
-    await fs51.rm(tmp, { recursive: true, force: true });
+    await fs52.rm(tmp, { recursive: true, force: true });
   }
 }
 async function runBuildStatus(opts, log) {