@genex-ai/cli-demo 1.10.4-dev.536 → 1.11.0-dev.538

package/dist/index.js

@@ -1,103 +1,32 @@
 #!/usr/bin/env node
+import {
+  BLENDER_SETUP_HINT,
+  CLI_CHANNEL,
+  DEFAULT_API_URL,
+  DEFAULT_AUTH_URL,
+  ENV_FILE_ENV,
+  ENV_TOKEN_KEY,
+  RENDER_MODES,
+  STANDS,
+  blenderCall,
+  blenderEndpoint,
+  getAnimsBase,
+  getAnimsCacheDir,
+  getApiUrl,
+  getAuthUrl,
+  getCliVersion,
+  getGenexDir,
+  getGenexEnvPath,
+  getTemplatesDir,
+  isRenderMode,
+  resolveAgentTargets
+} from "./chunk-ZHIP7LCA.js";
 
 // src/instrument.ts
 import * as Sentry from "@sentry/node";
 
-// src/config.ts
-import fs from "fs";
-import os from "os";
-import path from "path";
-import { fileURLToPath } from "url";
-var RAW_CHANNEL = "dev";
-var CLI_CHANNEL = RAW_CHANNEL === "dev" ? "dev" : "latest";
-var STANDS = {
-  prod: { api: "https://api.genex.games", dashboard: "https://genex.games" },
-  dev: { api: "https://api-dev.genex.games", dashboard: "https://dev.genex.games" }
-};
-var DEFAULT_AUTH_URL = CLI_CHANNEL === "dev" ? STANDS.dev.dashboard : STANDS.prod.dashboard;
-var DEFAULT_API_URL = CLI_CHANNEL === "dev" ? STANDS.dev.api : STANDS.prod.api;
-var DEFAULT_ANIMS_BASE = "https://cdn.genex.technology/anims/ual1/v1/";
-var ANIMS_BASE_ENV = "GENEX_ANIMS_BASE";
-function getAnimsBase(override) {
-  const raw = override || process.env[ANIMS_BASE_ENV] || DEFAULT_ANIMS_BASE;
-  return raw.replace(/\/+$/, "") + "/";
-}
-function getAnimsCacheDir() {
-  return path.join(getGenexDir(), "cache", "anims");
-}
-var ENV_TOKEN_KEY = "GENEX_TOKEN";
-var AUTH_URL_ENV = "GENEX_AUTH_URL";
-var API_URL_ENV = "GENEX_API_URL";
-var ENV_FILE_ENV = "GENEX_ENV_FILE";
-function getAuthUrl(override) {
-  const raw = override || process.env[AUTH_URL_ENV] || DEFAULT_AUTH_URL;
-  return raw.replace(/\/+$/, "");
-}
-function getApiUrl(override) {
-  const raw = override || process.env[API_URL_ENV] || DEFAULT_API_URL;
-  return raw.replace(/\/+$/, "");
-}
-function getGenexDir() {
-  return path.join(os.homedir(), ".genex");
-}
-function getGenexEnvPath(override) {
-  if (override) return path.resolve(override);
-  const fromEnv = process.env[ENV_FILE_ENV];
-  if (fromEnv) return path.resolve(fromEnv);
-  return path.join(getGenexDir(), "env");
-}
-function getTemplatesDir() {
-  const here = path.dirname(fileURLToPath(import.meta.url));
-  return path.resolve(here, "..", "templates");
-}
-function getCliVersion() {
-  try {
-    const here = path.dirname(fileURLToPath(import.meta.url));
-    const pkg = JSON.parse(
-      fs.readFileSync(path.resolve(here, "..", "package.json"), "utf8")
-    );
-    return pkg.version ?? "0.0.0";
-  } catch {
-    return "0.0.0";
-  }
-}
-var KNOWN_AGENTS = {
-  claude: { label: "Claude Code", dirName: ".claude", full: true },
-  codex: { label: "Codex", dirName: ".codex", full: false },
-  cursor: { label: "Cursor", dirName: ".cursor", full: false }
-};
-var KNOWN_AGENT_IDS = Object.keys(KNOWN_AGENTS);
-function resolveAgentTargets(opts = {}) {
-  if (opts.dir) {
-    return [{ id: "custom", label: "workspace", baseDir: path.resolve(opts.dir), full: true }];
-  }
-  const home = os.homedir();
-  const projectRoot = process.cwd();
-  let ids;
-  if (opts.agents && opts.agents.length > 0) {
-    ids = opts.agents.filter((id) => KNOWN_AGENTS[id]);
-  } else {
-    ids = KNOWN_AGENT_IDS.filter((id) => {
-      const dirName = KNOWN_AGENTS[id].dirName;
-      return isDir(path.join(home, dirName)) || isDir(path.join(projectRoot, dirName));
-    });
-    if (ids.length === 0) ids = ["claude"];
-  }
-  return ids.map((id) => {
-    const def = KNOWN_AGENTS[id];
-    return { id, label: def.label, baseDir: path.join(projectRoot, def.dirName), full: def.full };
-  });
-}
-function isDir(p) {
-  try {
-    return fs.statSync(p).isDirectory();
-  } catch {
-    return false;
-  }
-}
-
 // src/lib/sentry-scrub.ts
-import os2 from "os";
+import os from "os";
 var BEARER = /\bBearer\s+[A-Za-z0-9._~+/-]+=*/gi;
 var URL_CRED = /(https?:\/\/)[^/@\s:]+(?::[^/@\s]*)?@/gi;
 var TOKENISH_KV = /((?:token|secret|password|api[_-]?key|authorization)=)[^&#\s"']+/gi;
@@ -105,7 +34,7 @@ var SENSITIVE_KEY = /token|secret|password|api[_-]?key|authorization|bearer/i;
 function scrubString(s) {
   return s.replace(URL_CRED, "$1[redacted]@").replace(BEARER, "Bearer [redacted]").replace(TOKENISH_KV, "$1[redacted]");
 }
-function redactHome(s, home = os2.homedir()) {
+function redactHome(s, home = os.homedir()) {
   if (!home) return s;
   return s.split(home).join("~");
 }
@@ -197,7 +126,7 @@ import * as Sentry2 from "@sentry/node";
 // src/lib/auth.ts
 import http from "http";
 import crypto from "crypto";
-import os3 from "os";
+import os2 from "os";
 import readline from "readline";
 import { spawn as spawn2 } from "child_process";
 import { URL as URL2 } from "url";
@@ -322,18 +251,18 @@ async function fetchSignedInEmail(apiUrl, token) {
 }
 
 // src/lib/pending-auth.ts
-import fs3 from "fs/promises";
-import path3 from "path";
-
-// src/lib/env.ts
 import fs2 from "fs/promises";
 import path2 from "path";
+
+// src/lib/env.ts
+import fs from "fs/promises";
+import path from "path";
 import { spawn } from "child_process";
 async function writeEnvVar(envPath, key, value) {
   let content = "";
   let existed = false;
   try {
-    content = await fs2.readFile(envPath, "utf8");
+    content = await fs.readFile(envPath, "utf8");
     existed = true;
   } catch {
   }
@@ -353,14 +282,14 @@ async function writeEnvVar(envPath, key, value) {
     next = prefix + assignment + "\n";
     mode = existed ? "appended" : "created";
   }
-  await fs2.mkdir(path2.dirname(envPath), { recursive: true });
-  await fs2.writeFile(envPath, next, { mode: 384 });
+  await fs.mkdir(path.dirname(envPath), { recursive: true });
+  await fs.writeFile(envPath, next, { mode: 384 });
   await restrictFilePermissions(envPath);
   return { mode, path: envPath };
 }
 async function restrictFilePermissions(filePath) {
   if (process.platform !== "win32") {
-    await fs2.chmod(filePath, 384).catch(() => {
+    await fs.chmod(filePath, 384).catch(() => {
     });
     return;
   }
@@ -392,11 +321,11 @@ function escapeRegExp(s) {
 
 // src/lib/pending-auth.ts
 function pendingAuthPath() {
-  return path3.join(getGenexDir(), "pending-auth.json");
+  return path2.join(getGenexDir(), "pending-auth.json");
 }
 async function readPendingAuth(apiUrl) {
   try {
-    const raw = JSON.parse(await fs3.readFile(pendingAuthPath(), "utf8"));
+    const raw = JSON.parse(await fs2.readFile(pendingAuthPath(), "utf8"));
     if (!raw?.deviceCode || !raw.userCode || raw.apiUrl !== apiUrl) return null;
     if (Date.now() >= raw.expiresAt) return null;
     return raw;
@@ -406,12 +335,12 @@ async function readPendingAuth(apiUrl) {
 }
 async function writePendingAuth(pending) {
   const file = pendingAuthPath();
-  await fs3.mkdir(path3.dirname(file), { recursive: true });
-  await fs3.writeFile(file, JSON.stringify(pending, null, 2), { mode: 384 });
+  await fs2.mkdir(path2.dirname(file), { recursive: true });
+  await fs2.writeFile(file, JSON.stringify(pending, null, 2), { mode: 384 });
   await restrictFilePermissions(file);
 }
 async function clearPendingAuth() {
-  await fs3.rm(pendingAuthPath(), { force: true }).catch(() => {
+  await fs2.rm(pendingAuthPath(), { force: true }).catch(() => {
   });
 }
 
@@ -495,7 +424,7 @@ async function startDeviceAuth(apiBaseUrl, label) {
 }
 function defaultLabel() {
   try {
-    return os3.hostname();
+    return os2.hostname();
   } catch {
     return "";
   }
@@ -819,17 +748,17 @@ function tokenizeCommand(input) {
 }
 
 // src/lib/store.ts
-import fs4 from "fs/promises";
-import path4 from "path";
+import fs3 from "fs/promises";
+import path3 from "path";
 function getProjectMetadataPath(cwd = process.cwd()) {
-  return path4.join(cwd, ".genex", "project.json");
+  return path3.join(cwd, ".genex", "project.json");
 }
 function getWorkspacePath(cwd = process.cwd()) {
-  return path4.join(cwd, ".genex", "workspace.json");
+  return path3.join(cwd, ".genex", "workspace.json");
 }
 async function readWorkspace(cwd = process.cwd()) {
   try {
-    const raw = await fs4.readFile(getWorkspacePath(cwd), "utf8");
+    const raw = await fs3.readFile(getWorkspacePath(cwd), "utf8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -837,9 +766,9 @@ async function readWorkspace(cwd = process.cwd()) {
 }
 async function writeWorkspace(meta, cwd = process.cwd()) {
   const file = getWorkspacePath(cwd);
-  await fs4.mkdir(path4.dirname(file), { recursive: true });
-  await fs4.writeFile(file, JSON.stringify(meta, null, 2) + "\n", { mode: 384 });
-  await fs4.chmod(file, 384).catch(() => {
+  await fs3.mkdir(path3.dirname(file), { recursive: true });
+  await fs3.writeFile(file, JSON.stringify(meta, null, 2) + "\n", { mode: 384 });
+  await fs3.chmod(file, 384).catch(() => {
   });
   return { path: file };
 }
@@ -852,7 +781,7 @@ async function rotateRejectedEnv(envPath) {
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   const aside = `${file}.rejected-${stamp}`;
   try {
-    await fs4.rename(file, aside);
+    await fs3.rename(file, aside);
     return aside;
   } catch {
     return null;
@@ -862,14 +791,14 @@ async function readUserToken(envPath) {
   const fromGenex = await readTokenFromFile(getGenexEnvPath(envPath));
   if (fromGenex) return fromGenex;
   if (!envPath && !process.env[ENV_FILE_ENV]) {
-    return readTokenFromFile(path4.join(process.cwd(), ".env"));
+    return readTokenFromFile(path3.join(process.cwd(), ".env"));
   }
   return null;
 }
 async function readTokenFromFile(file) {
   let content;
   try {
-    content = await fs4.readFile(file, "utf8");
+    content = await fs3.readFile(file, "utf8");
   } catch {
     return null;
   }
@@ -885,7 +814,7 @@ function stripQuotes(v) {
 }
 async function readProject(cwd = process.cwd()) {
   try {
-    const raw = await fs4.readFile(getProjectMetadataPath(cwd), "utf8");
+    const raw = await fs3.readFile(getProjectMetadataPath(cwd), "utf8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -893,9 +822,9 @@ async function readProject(cwd = process.cwd()) {
 }
 async function writeProject(meta, cwd = process.cwd()) {
   const file = getProjectMetadataPath(cwd);
-  await fs4.mkdir(path4.dirname(file), { recursive: true });
-  await fs4.writeFile(file, JSON.stringify(meta, null, 2) + "\n", { mode: 384 });
-  await fs4.chmod(file, 384).catch(() => {
+  await fs3.mkdir(path3.dirname(file), { recursive: true });
+  await fs3.writeFile(file, JSON.stringify(meta, null, 2) + "\n", { mode: 384 });
+  await fs3.chmod(file, 384).catch(() => {
   });
   return { path: file };
 }
@@ -960,14 +889,14 @@ async function runAuth(opts) {
 }
 
 // src/commands/init.ts
-import fs10 from "fs/promises";
-import path10 from "path";
+import fs9 from "fs/promises";
+import path9 from "path";
 
 // src/lib/copy-templates.ts
-import fs5 from "fs/promises";
-import path5 from "path";
+import fs4 from "fs/promises";
+import path4 from "path";
 function isGenexManaged(rel) {
-  return rel.split(path5.sep).some((seg) => seg.startsWith("genex"));
+  return rel.split(path4.sep).some((seg) => seg.startsWith("genex"));
 }
 async function copyTemplates(srcDir, destDir, opts = {}) {
   const result = { copied: [], updated: [], skipped: [] };
@@ -975,15 +904,15 @@ async function copyTemplates(srcDir, destDir, opts = {}) {
   return result;
 }
 async function walk(rootSrc, src, dest, opts, result) {
-  const entries = await fs5.readdir(src, { withFileTypes: true });
+  const entries = await fs4.readdir(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path5.join(src, entry.name);
-    const destPath = path5.join(dest, entry.name);
-    const rel = path5.relative(rootSrc, srcPath);
+    const srcPath = path4.join(src, entry.name);
+    const destPath = path4.join(dest, entry.name);
+    const rel = path4.relative(rootSrc, srcPath);
     if (opts.exclude?.includes(rel)) continue;
     if (opts.filter && !opts.filter(rel)) continue;
     if (entry.isDirectory()) {
-      await fs5.mkdir(destPath, { recursive: true });
+      await fs4.mkdir(destPath, { recursive: true });
       await walk(rootSrc, srcPath, destPath, opts, result);
       continue;
     }
@@ -996,15 +925,15 @@ async function walk(rootSrc, src, dest, opts, result) {
       result.skipped.push(rel);
       continue;
     }
-    await fs5.mkdir(path5.dirname(destPath), { recursive: true });
-    await fs5.copyFile(srcPath, destPath);
+    await fs4.mkdir(path4.dirname(destPath), { recursive: true });
+    await fs4.copyFile(srcPath, destPath);
     result.copied.push(rel);
     if (present) result.updated.push(rel);
   }
 }
 async function exists(p) {
   try {
-    await fs5.access(p);
+    await fs4.access(p);
     return true;
   } catch {
     return false;
@@ -1012,9 +941,9 @@ async function exists(p) {
 }
 
 // src/lib/agents-contract.ts
-import fs6 from "fs/promises";
-import os4 from "os";
-import path6 from "path";
+import fs5 from "fs/promises";
+import os3 from "os";
+import path5 from "path";
 var CONTRACT_BEGIN = "<!-- genex:contract:begin (managed by genex \u2014 edits inside this block are overwritten on sync) -->";
 var CONTRACT_END = "<!-- genex:contract:end -->";
 var GENEX_CONTRACT_BLOCK = `${CONTRACT_BEGIN}
@@ -1078,32 +1007,32 @@ ${block}
 async function writeAgentsContract(projectDir, contractBlock = GENEX_CONTRACT_BLOCK) {
   let changed = false;
   try {
-    const agentsPath = path6.join(projectDir, "AGENTS.md");
+    const agentsPath = path5.join(projectDir, "AGENTS.md");
     let existing = null;
     try {
-      existing = await fs6.readFile(agentsPath, "utf8");
+      existing = await fs5.readFile(agentsPath, "utf8");
     } catch {
       existing = null;
     }
     const next = mergeContractBlock(existing, contractBlock);
     if (next !== existing) {
-      await fs6.writeFile(agentsPath, next, "utf8");
+      await fs5.writeFile(agentsPath, next, "utf8");
       changed = true;
     }
-    const claudePath = path6.join(projectDir, "CLAUDE.md");
+    const claudePath = path5.join(projectDir, "CLAUDE.md");
     let claude = null;
     try {
-      claude = await fs6.readFile(claudePath, "utf8");
+      claude = await fs5.readFile(claudePath, "utf8");
     } catch {
       claude = null;
     }
     if (claude === null) {
-      await fs6.writeFile(claudePath, `${CLAUDE_IMPORT_LINE}
+      await fs5.writeFile(claudePath, `${CLAUDE_IMPORT_LINE}
 `, "utf8");
       changed = true;
     } else if (!claude.split("\n").some((line) => line.trim() === CLAUDE_IMPORT_LINE)) {
       const sep = claude.endsWith("\n") ? "" : "\n";
-      await fs6.writeFile(claudePath, `${claude}${sep}
+      await fs5.writeFile(claudePath, `${claude}${sep}
 ${CLAUDE_IMPORT_LINE}
 `, "utf8");
       changed = true;
@@ -1115,26 +1044,26 @@ ${CLAUDE_IMPORT_LINE}
 async function writeToolsContract(projectDir) {
   return writeAgentsContract(projectDir, GENEX_TOOLS_CONTRACT_BLOCK);
 }
-async function healAncestorContracts(projectDir, stopDir = os4.homedir()) {
+async function healAncestorContracts(projectDir, stopDir = os3.homedir()) {
   const findings = [];
-  const stop = path6.resolve(stopDir);
-  let dir = path6.dirname(path6.resolve(projectDir));
+  const stop = path5.resolve(stopDir);
+  let dir = path5.dirname(path5.resolve(projectDir));
   for (let depth = 0; depth < 20; depth++) {
     try {
       let isWorkspace = false;
       for (const marker of ["project.json", "workspace.json"]) {
         try {
-          await fs6.access(path6.join(dir, ".genex", marker));
+          await fs5.access(path5.join(dir, ".genex", marker));
           isWorkspace = true;
           break;
         } catch {
         }
       }
       if (!isWorkspace) {
-        const agentsPath = path6.join(dir, "AGENTS.md");
+        const agentsPath = path5.join(dir, "AGENTS.md");
         let content = null;
         try {
-          content = await fs6.readFile(agentsPath, "utf8");
+          content = await fs5.readFile(agentsPath, "utf8");
         } catch {
         }
         if (content !== null && CONTRACT_REGION.test(content)) {
@@ -1143,11 +1072,11 @@ async function healAncestorContracts(projectDir, stopDir = os4.homedir()) {
             remainder = remainder.replace(CONTRACT_REGION, "");
           }
           if (remainder.trim() === "") {
-            await fs6.unlink(agentsPath);
+            await fs5.unlink(agentsPath);
             try {
-              const claudePath = path6.join(dir, "CLAUDE.md");
-              if ((await fs6.readFile(claudePath, "utf8")).trim() === CLAUDE_IMPORT_LINE) {
-                await fs6.unlink(claudePath);
+              const claudePath = path5.join(dir, "CLAUDE.md");
+              if ((await fs5.readFile(claudePath, "utf8")).trim() === CLAUDE_IMPORT_LINE) {
+                await fs5.unlink(claudePath);
               }
             } catch {
             }
@@ -1160,7 +1089,7 @@ async function healAncestorContracts(projectDir, stopDir = os4.homedir()) {
     } catch {
     }
     if (dir === stop) break;
-    const parent = path6.dirname(dir);
+    const parent = path5.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -1169,7 +1098,7 @@ async function healAncestorContracts(projectDir, stopDir = os4.homedir()) {
 async function healAncestorContractsAndReport(log, projectDir) {
   try {
     for (const f of await healAncestorContracts(projectDir)) {
-      const file = path6.join(f.dir, "AGENTS.md");
+      const file = path5.join(f.dir, "AGENTS.md");
       if (f.removed) {
         log.plain(
           `\u{1F9F9} Removed a stray genex build contract from ${file} \u2014 it belongs in each game's folder, and a stale copy above the project misleads agents.`
@@ -1185,9 +1114,9 @@ async function healAncestorContractsAndReport(log, projectDir) {
 }
 
 // src/lib/updates.ts
-import fs7 from "fs/promises";
-import os5 from "os";
-import path7 from "path";
+import fs6 from "fs/promises";
+import os4 from "os";
+import path6 from "path";
 
 // src/lib/workspace.ts
 async function workspaceMode(cwd = process.cwd()) {
@@ -1245,7 +1174,7 @@ function isNewerVersion(a, b) {
 var SKILLS_VERSION_MARKER = "genex-skills-version.json";
 async function readSkillsMarker(skillsDir) {
   try {
-    const raw = await fs7.readFile(path7.join(skillsDir, SKILLS_VERSION_MARKER), "utf8");
+    const raw = await fs6.readFile(path6.join(skillsDir, SKILLS_VERSION_MARKER), "utf8");
     const parsed = JSON.parse(raw);
     return typeof parsed.version === "string" ? parsed.version : null;
   } catch {
@@ -1253,15 +1182,15 @@ async function readSkillsMarker(skillsDir) {
   }
 }
 async function writeSkillsMarker(skillsDir, version = getCliVersion()) {
-  await fs7.mkdir(skillsDir, { recursive: true });
-  await fs7.writeFile(
-    path7.join(skillsDir, SKILLS_VERSION_MARKER),
+  await fs6.mkdir(skillsDir, { recursive: true });
+  await fs6.writeFile(
+    path6.join(skillsDir, SKILLS_VERSION_MARKER),
     JSON.stringify({ version, syncedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2) + "\n"
   );
 }
 async function hasGenexSkills(skillsDir) {
   try {
-    const entries = await fs7.readdir(skillsDir);
+    const entries = await fs6.readdir(skillsDir);
     return entries.some((name) => name.startsWith("genex-"));
   } catch {
     return false;
@@ -1324,14 +1253,14 @@ var REMOVED_SKILLS = [
 async function pruneRemovedSkills(skillsDir, log) {
   const removed = [];
   for (const name of REMOVED_SKILLS) {
-    const target = path7.join(skillsDir, name);
+    const target = path6.join(skillsDir, name);
     try {
-      await fs7.access(target);
+      await fs6.access(target);
     } catch {
       continue;
     }
     try {
-      await fs7.rm(target, { recursive: true });
+      await fs6.rm(target, { recursive: true });
       removed.push(name);
     } catch {
     }
@@ -1346,16 +1275,16 @@ async function pruneRemovedSkills(skillsDir, log) {
 async function pruneToolCards(log, overrides) {
   let removedAny = false;
   for (const target of resolveAgentTargets(overrides ?? {})) {
-    const skillsDir = path7.join(target.baseDir, "skills");
+    const skillsDir = path6.join(target.baseDir, "skills");
     for (const name of TOOL_SKILLS) {
-      const dir = path7.join(skillsDir, name);
+      const dir = path6.join(skillsDir, name);
       try {
-        await fs7.access(dir);
+        await fs6.access(dir);
       } catch {
         continue;
       }
       try {
-        await fs7.rm(dir, { recursive: true });
+        await fs6.rm(dir, { recursive: true });
         removedAny = true;
       } catch {
       }
@@ -1369,10 +1298,10 @@ async function pruneToolCards(log, overrides) {
   return removedAny;
 }
 async function syncSkillsForTarget(target, templatesDir = getTemplatesDir(), version = getCliVersion(), log, family = "game") {
-  const skillsDir = path7.join(target.baseDir, "skills");
+  const skillsDir = path6.join(target.baseDir, "skills");
   if (!await hasGenexSkills(skillsDir)) return false;
   if (await readSkillsMarker(skillsDir) === version) return false;
-  const src = target.full ? templatesDir : path7.join(templatesDir, "skills");
+  const src = target.full ? templatesDir : path6.join(templatesDir, "skills");
   const dest = target.full ? target.baseDir : skillsDir;
   const familyFilter = skillFamilyFilter(family);
   const filter = target.full ? familyFilter : (rel) => familyFilter(`skills/${rel}`);
@@ -1386,36 +1315,36 @@ async function syncSkillsForTarget(target, templatesDir = getTemplatesDir(), ver
 }
 async function cleanupLegacyGlobalSkills(log) {
   try {
-    const home = os5.homedir();
+    const home = os4.homedir();
     const [realCwd, realHome] = await Promise.all([
-      fs7.realpath(process.cwd()).catch(() => path7.resolve(process.cwd())),
-      fs7.realpath(home).catch(() => path7.resolve(home))
+      fs6.realpath(process.cwd()).catch(() => path6.resolve(process.cwd())),
+      fs6.realpath(home).catch(() => path6.resolve(home))
     ]);
     if (realCwd === realHome) return false;
     let removed = false;
     for (const dirName of [".claude", ".codex", ".cursor"]) {
-      const skillsDir = path7.join(home, dirName, "skills");
+      const skillsDir = path6.join(home, dirName, "skills");
       let entries = [];
       try {
-        entries = await fs7.readdir(skillsDir);
+        entries = await fs6.readdir(skillsDir);
       } catch {
         continue;
       }
       for (const name of entries) {
         if (!name.startsWith("genex-")) continue;
         try {
-          await fs7.rm(path7.join(skillsDir, name), { recursive: true });
+          await fs6.rm(path6.join(skillsDir, name), { recursive: true });
           removed = true;
         } catch {
         }
       }
     }
     for (const rel of [
-      path7.join("agents", "genex-helper.md"),
-      path7.join("commands", "genex-status.md")
+      path6.join("agents", "genex-helper.md"),
+      path6.join("commands", "genex-status.md")
     ]) {
       try {
-        await fs7.rm(path7.join(home, ".claude", rel));
+        await fs6.rm(path6.join(home, ".claude", rel));
         removed = true;
       } catch {
       }
@@ -1473,7 +1402,7 @@ var PUBLISHED_PACKAGES = [
 var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 var REGISTRY_TIMEOUT_MS = 1500;
 function getUpdateCachePath() {
-  return path7.join(getGenexDir(), "update-check.json");
+  return path6.join(getGenexDir(), "update-check.json");
 }
 function isCacheFresh(cache, nowMs) {
   const at = Date.parse(cache.checkedAt);
@@ -1486,7 +1415,7 @@ function wasRecentlyNotified(cache, name, latest, nowMs) {
 }
 async function readUpdateCache() {
   try {
-    const raw = await fs7.readFile(getUpdateCachePath(), "utf8");
+    const raw = await fs6.readFile(getUpdateCachePath(), "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.checkedAt !== "string" || typeof parsed.latest !== "object") return null;
     return parsed;
@@ -1525,8 +1454,8 @@ function startUpdateCheck() {
         ...cached?.notified ? { notified: cached.notified } : {},
         ...cached?.notifiedAt ? { notifiedAt: cached.notifiedAt } : {}
       };
-      await fs7.mkdir(getGenexDir(), { recursive: true });
-      await fs7.writeFile(getUpdateCachePath(), JSON.stringify(next, null, 2) + "\n");
+      await fs6.mkdir(getGenexDir(), { recursive: true });
+      await fs6.writeFile(getUpdateCachePath(), JSON.stringify(next, null, 2) + "\n");
       return next;
     } catch {
       return null;
@@ -1535,7 +1464,7 @@ function startUpdateCheck() {
 }
 async function installedPackageVersion(cwd, name) {
   try {
-    const raw = await fs7.readFile(path7.join(cwd, "node_modules", name, "package.json"), "utf8");
+    const raw = await fs6.readFile(path6.join(cwd, "node_modules", name, "package.json"), "utf8");
     const pkg = JSON.parse(raw);
     return typeof pkg.version === "string" ? pkg.version : null;
   } catch {
@@ -1582,8 +1511,8 @@ async function recordNotified(cache, announced, cachePath) {
       notified: { ...cache.notified ?? {}, ...announced },
       notifiedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    await fs7.mkdir(path7.dirname(cachePath), { recursive: true });
-    await fs7.writeFile(cachePath, JSON.stringify(next, null, 2) + "\n");
+    await fs6.mkdir(path6.dirname(cachePath), { recursive: true });
+    await fs6.writeFile(cachePath, JSON.stringify(next, null, 2) + "\n");
   } catch {
   }
 }
@@ -1682,13 +1611,13 @@ async function fetchProjectStatus(apiUrl, token, slug) {
 }
 
 // src/lib/ssh.ts
-import fs8 from "fs/promises";
-import path8 from "path";
+import fs7 from "fs/promises";
+import path7 from "path";
 async function writeGitignore(dir, log) {
-  const file = path8.join(dir, ".gitignore");
+  const file = path7.join(dir, ".gitignore");
   let content = "";
   try {
-    content = await fs8.readFile(file, "utf8");
+    content = await fs7.readFile(file, "utf8");
   } catch {
   }
   const present = new Set(content.split("\n").map((l) => l.trim()));
@@ -1698,7 +1627,7 @@ async function writeGitignore(dir, log) {
   if (next.length > 0 && !next.endsWith("\n")) next += "\n";
   if (!content.trim()) next += "# genex local metadata + secrets \u2014 never publish\n";
   next += toAdd.join("\n") + "\n";
-  await fs8.writeFile(file, next);
+  await fs7.writeFile(file, next);
   log.dim(`Updated .gitignore (${toAdd.join(", ")}).`);
 }
 var LFS_PATTERNS = [
@@ -1728,10 +1657,10 @@ var LFS_PATTERNS = [
   "*.webm"
 ];
 async function writeGitattributes(dir, log) {
-  const file = path8.join(dir, ".gitattributes");
+  const file = path7.join(dir, ".gitattributes");
   let content = "";
   try {
-    content = await fs8.readFile(file, "utf8");
+    content = await fs7.readFile(file, "utf8");
   } catch {
   }
   const present = new Set(content.split("\n").map((l) => l.trim().split(/\s+/)[0]));
@@ -1741,13 +1670,13 @@ async function writeGitattributes(dir, log) {
   if (next.length > 0 && !next.endsWith("\n")) next += "\n";
   if (!content.trim()) next += "# Binary game assets go to Git LFS (R2) \u2014 keeps the source push small\n";
   next += toAdd.map((p) => `${p} filter=lfs diff=lfs merge=lfs -text`).join("\n") + "\n";
-  await fs8.writeFile(file, next);
+  await fs7.writeFile(file, next);
   log.dim(`Updated .gitattributes (${toAdd.length} binary globs \u2192 Git LFS).`);
 }
 
 // src/lib/game-config.ts
-import fs9 from "fs/promises";
-import path9 from "path";
+import fs8 from "fs/promises";
+import path8 from "path";
 var DEFAULT_DASHBOARD_ORIGIN = new URL(DEFAULT_AUTH_URL).origin;
 function renderGenexConfig(slug) {
   return `// src/genex.config.ts \u2014 written by \`genex init\`. DO NOT hardcode URLs here.
@@ -1804,7 +1733,7 @@ ${overrides.join("\n")}
 }
 async function writeIfAbsent(file, content, log) {
   try {
-    await fs9.writeFile(file, content, { flag: "wx" });
+    await fs8.writeFile(file, content, { flag: "wx" });
     log.dim(`  wrote ${c.cyan(file)}`);
     return true;
   } catch (err) {
@@ -1818,7 +1747,7 @@ async function writeIfAbsent(file, content, log) {
 async function ensureEnvVar(file, key, value, log) {
   let existing = null;
   try {
-    existing = await fs9.readFile(file, "utf8");
+    existing = await fs8.readFile(file, "utf8");
   } catch {
     existing = null;
   }
@@ -1829,23 +1758,23 @@ async function ensureEnvVar(file, key, value, log) {
       return false;
     }
     const sep = existing.endsWith("\n") || existing === "" ? "" : "\n";
-    await fs9.writeFile(file, `${existing}${sep}${key}=${value}
+    await fs8.writeFile(file, `${existing}${sep}${key}=${value}
 `, "utf8");
     log.dim(`  appended ${c.cyan(`${key}=${value}`)} to ${c.cyan(file)}`);
     return true;
   }
-  await fs9.writeFile(file, `${key}=${value}
+  await fs8.writeFile(file, `${key}=${value}
 `, "utf8");
   log.dim(`  wrote ${c.cyan(file)} (${key})`);
   return true;
 }
 async function writeGameConfigFiles(meta, log, cwd = process.cwd()) {
-  await fs9.mkdir(path9.join(cwd, "src"), { recursive: true });
-  await writeIfAbsent(path9.join(cwd, "src", "genex.config.ts"), renderGenexConfig(meta.slug), log);
-  await writeIfAbsent(path9.join(cwd, ".env"), renderSlugEnv(meta.slug), log);
+  await fs8.mkdir(path8.join(cwd, "src"), { recursive: true });
+  await writeIfAbsent(path8.join(cwd, "src", "genex.config.ts"), renderGenexConfig(meta.slug), log);
+  await writeIfAbsent(path8.join(cwd, ".env"), renderSlugEnv(meta.slug), log);
   const overrides = renderDevOverrides(meta);
   if (overrides) {
-    await writeIfAbsent(path9.join(cwd, ".env.development.local"), overrides, log);
+    await writeIfAbsent(path8.join(cwd, ".env.development.local"), overrides, log);
   }
 }
 
@@ -1878,7 +1807,7 @@ var TOOLING_ENTRIES = /* @__PURE__ */ new Set([
 ]);
 async function listPreexistingEntries(dir) {
   try {
-    return (await fs10.readdir(dir)).filter((name) => !TOOLING_ENTRIES.has(name)).sort();
+    return (await fs9.readdir(dir)).filter((name) => !TOOLING_ENTRIES.has(name)).sort();
   } catch {
     return [];
   }
@@ -1930,15 +1859,15 @@ async function runInit(opts) {
   let totalNew = 0;
   let totalUpdated = 0;
   for (const t of targets) {
-    const src = t.full ? templatesDir : path10.join(templatesDir, "skills");
-    const dest = t.full ? t.baseDir : path10.join(t.baseDir, "skills");
+    const src = t.full ? templatesDir : path9.join(templatesDir, "skills");
+    const dest = t.full ? t.baseDir : path9.join(t.baseDir, "skills");
     const { copied, updated } = await copyTemplates(src, dest, {
       force: opts.force,
       exclude: ["controllers", "motion", "asset-viewer"],
       filter: t.full ? skillFamilyFilter("game") : (rel) => skillFamilyFilter("game")(`skills/${rel}`)
     });
-    await pruneRemovedSkills(path10.join(t.baseDir, "skills"), log);
-    await writeSkillsMarker(path10.join(t.baseDir, "skills"));
+    await pruneRemovedSkills(path9.join(t.baseDir, "skills"), log);
+    await writeSkillsMarker(path9.join(t.baseDir, "skills"));
     const added = copied.length - updated.length;
     totalNew += added;
     totalUpdated += updated.length;
@@ -1989,7 +1918,7 @@ async function runInit(opts) {
     if (email) log.plain(`  signed in as ${c.cyan(email)}`);
   };
   await echoIdentity();
-  const projectName = opts.name?.trim() || path10.basename(process.cwd());
+  const projectName = opts.name?.trim() || path9.basename(process.cwd());
   const create = (bearer) => createDraftProject({
     apiUrl,
     token: bearer,
@@ -2037,10 +1966,10 @@ async function runInit(opts) {
   log.dim(`  saved ${c.cyan(metaPath)}`);
   await writeGameConfigFiles(meta, log);
   if (converting) {
-    await fs10.rm(getWorkspacePath(process.cwd()), { force: true }).catch(() => {
+    await fs9.rm(getWorkspacePath(process.cwd()), { force: true }).catch(() => {
     });
     await pruneToolCards(log, { dir: opts.dir, agents: opts.agents });
-    await ensureEnvVar(path10.join(process.cwd(), ".env"), "VITE_GENEX_SLUG", meta.slug, log);
+    await ensureEnvVar(path9.join(process.cwd(), ".env"), "VITE_GENEX_SLUG", meta.slug, log);
     await reportCliEvent(apiUrl, token, "tools_converted");
   }
   warnPreexisting(log, preexisting);
@@ -2065,14 +1994,14 @@ async function runInit(opts) {
 }
 
 // src/commands/link.ts
-import fs12 from "fs/promises";
-import os7 from "os";
-import path12 from "path";
-
-// src/lib/source-sync.ts
 import fs11 from "fs/promises";
-import path11 from "path";
 import os6 from "os";
+import path11 from "path";
+
+// src/lib/source-sync.ts
+import fs10 from "fs/promises";
+import path10 from "path";
+import os5 from "os";
 
 // src/utils/run.ts
 import { spawn as spawn3 } from "child_process";
@@ -2144,12 +2073,12 @@ function reportStale(log, slug, local, remote) {
   log.dim(`  ${c.cyan("npx genex preview --force")} \u2014 keep yours and replace theirs`);
 }
 async function sourceTreeHash(cwd) {
-  const gitDir = await fs11.mkdtemp(path11.join(os6.tmpdir(), "genex-tree-"));
+  const gitDir = await fs10.mkdtemp(path10.join(os5.tmpdir(), "genex-tree-"));
   const base = { GIT_DIR: gitDir };
   try {
     if ((await run("git", ["init", "-q"], base)).code !== 0) return null;
-    await fs11.writeFile(
-      path11.join(gitDir, "info", "exclude"),
+    await fs10.writeFile(
+      path10.join(gitDir, "info", "exclude"),
       ["node_modules/", "dist/", ".git/", ".genex/", ".env", ".env.*", "!.env.example", ""].join("\n")
     );
     if ((await run("git", ["lfs", "version"], base)).code === 0) {
@@ -2161,14 +2090,14 @@ async function sourceTreeHash(cwd) {
       ];
       for (const [key, value] of filters) await run("git", ["config", key, value], base);
     }
-    const env = { ...base, GIT_WORK_TREE: cwd, GIT_INDEX_FILE: path11.join(gitDir, "index-tree") };
+    const env = { ...base, GIT_WORK_TREE: cwd, GIT_INDEX_FILE: path10.join(gitDir, "index-tree") };
     if ((await run("git", ["add", "-A"], env)).code !== 0) return null;
     const tree = (await run("git", ["write-tree"], env)).out.trim();
     return /^[0-9a-f]{40}$/.test(tree) ? tree : null;
   } catch {
     return null;
   } finally {
-    await fs11.rm(gitDir, { recursive: true, force: true }).catch(() => {
+    await fs10.rm(gitDir, { recursive: true, force: true }).catch(() => {
     });
   }
 }
@@ -2219,7 +2148,7 @@ async function cloneSource(grant, dest, log) {
     log.dim(`  git clone exited ${cloned.code}`);
     return false;
   }
-  const repo = { ...env, GIT_DIR: path11.join(dest, ".git"), GIT_WORK_TREE: dest };
+  const repo = { ...env, GIT_DIR: path10.join(dest, ".git"), GIT_WORK_TREE: dest };
   const filters = [
     ["filter.lfs.clean", "git-lfs clean -- %f"],
     ["filter.lfs.smudge", "git-lfs smudge -- %f"],
@@ -2315,7 +2244,7 @@ async function runLink(opts) {
 }
 async function isEmptyDir(cwd) {
   try {
-    const entries = await fs12.readdir(cwd);
+    const entries = await fs11.readdir(cwd);
     return entries.every((e) => e === ".git" || e === ".genex" || e === ".DS_Store");
   } catch {
     return false;
@@ -2329,13 +2258,13 @@ async function downloadSource(apiUrl, token, project, log) {
     return false;
   }
   log.step(`Downloading the ${grant.sourceRef === "preview" ? "draft" : "published"} source\u2026`);
-  const staging = await fs12.mkdtemp(path12.join(os7.tmpdir(), "genex-link-"));
-  const fresh = path12.join(staging, "source");
+  const staging = await fs11.mkdtemp(path11.join(os6.tmpdir(), "genex-link-"));
+  const fresh = path11.join(staging, "source");
   try {
     if (!await cloneSource(grant, fresh, log)) return false;
-    await fs12.rm(path12.join(fresh, ".git"), { recursive: true, force: true });
-    for (const entry of await fs12.readdir(fresh)) {
-      await fs12.cp(path12.join(fresh, entry), path12.join(process.cwd(), entry), {
+    await fs11.rm(path11.join(fresh, ".git"), { recursive: true, force: true });
+    for (const entry of await fs11.readdir(fresh)) {
+      await fs11.cp(path11.join(fresh, entry), path11.join(process.cwd(), entry), {
         recursive: true,
         force: true
       });
@@ -2343,28 +2272,28 @@ async function downloadSource(apiUrl, token, project, log) {
     log.success("Downloaded.");
     return true;
   } finally {
-    await fs12.rm(staging, { recursive: true, force: true }).catch(() => {
+    await fs11.rm(staging, { recursive: true, force: true }).catch(() => {
     });
   }
 }
 async function ensureSlugEnv(slug, log, cwd = process.cwd()) {
-  const file = path12.join(cwd, ".env");
+  const file = path11.join(cwd, ".env");
   let content;
   try {
-    content = await fs12.readFile(file, "utf8");
+    content = await fs11.readFile(file, "utf8");
   } catch {
     return;
   }
   const re = /^(\s*VITE_GENEX_SLUG=)(.*)$/m;
   const m = content.match(re);
   if (!m) {
-    await fs12.appendFile(file, `${content.endsWith("\n") ? "" : "\n"}VITE_GENEX_SLUG=${slug}
+    await fs11.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 fs12.writeFile(file, content.replace(re, `$1${slug}`));
+  await fs11.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) {
@@ -2418,9 +2347,9 @@ async function listOwnSlugs(apiUrl, token, log) {
 }
 
 // src/commands/pull.ts
-import fs13 from "fs/promises";
-import path13 from "path";
-import os8 from "os";
+import fs12 from "fs/promises";
+import path12 from "path";
+import os7 from "os";
 function isMachineLocal(entry) {
   if (entry === ".genex" || entry === "node_modules" || entry === ".git") return true;
   if (entry === ".env.example") return false;
@@ -2479,23 +2408,23 @@ async function runPull(opts) {
     process.exitCode = 1;
     return;
   }
-  const staging = await fs13.mkdtemp(path13.join(os8.tmpdir(), "genex-pull-"));
-  const fresh = path13.join(staging, "source");
+  const staging = await fs12.mkdtemp(path12.join(os7.tmpdir(), "genex-pull-"));
+  const fresh = path12.join(staging, "source");
   try {
     if (!await cloneSource(grant, fresh, log)) {
       process.exitCode = 1;
       return;
     }
-    await fs13.rm(path13.join(fresh, ".git"), { recursive: true, force: true });
+    await fs12.rm(path12.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(path13.relative(cwd, kept) || kept)}`);
+      log.info(`What was here is kept at ${c.cyan(path12.relative(cwd, kept) || kept)}`);
       log.dim("  Nothing was thrown away \u2014 re-apply from there, or delete it when you are done.");
     }
   } finally {
-    await fs13.rm(staging, { recursive: true, force: true }).catch(() => {
+    await fs12.rm(staging, { recursive: true, force: true }).catch(() => {
     });
   }
   const remote = await readRemoteSource(apiUrl, token, meta.id);
@@ -2514,13 +2443,13 @@ async function runPull(opts) {
 }
 async function keepReplaced(cwd, log) {
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const dest = path13.join(cwd, ".genex", `replaced-${stamp}`);
+  const dest = path12.join(cwd, ".genex", `replaced-${stamp}`);
   try {
-    const entries = (await fs13.readdir(cwd)).filter((e) => !isMachineLocal(e));
+    const entries = (await fs12.readdir(cwd)).filter((e) => !isMachineLocal(e));
     if (entries.length === 0) return null;
-    await fs13.mkdir(dest, { recursive: true });
+    await fs12.mkdir(dest, { recursive: true });
     for (const entry of entries) {
-      await fs13.cp(path13.join(cwd, entry), path13.join(dest, entry), { recursive: true });
+      await fs12.cp(path12.join(cwd, entry), path12.join(dest, entry), { recursive: true });
     }
     return dest;
   } catch (err) {
@@ -2530,19 +2459,19 @@ async function keepReplaced(cwd, log) {
   }
 }
 async function replaceTree(dest, src) {
-  for (const entry of await fs13.readdir(dest)) {
+  for (const entry of await fs12.readdir(dest)) {
     if (isMachineLocal(entry)) continue;
-    await fs13.rm(path13.join(dest, entry), { recursive: true, force: true });
+    await fs12.rm(path12.join(dest, entry), { recursive: true, force: true });
   }
-  for (const entry of await fs13.readdir(src)) {
+  for (const entry of await fs12.readdir(src)) {
     if (isMachineLocal(entry)) continue;
-    await fs13.cp(path13.join(src, entry), path13.join(dest, entry), { recursive: true });
+    await fs12.cp(path12.join(src, entry), path12.join(dest, entry), { recursive: true });
   }
 }
 
 // src/commands/rename.ts
-import fs14 from "fs/promises";
-import path14 from "path";
+import fs13 from "fs/promises";
+import path13 from "path";
 async function runRename(opts) {
   const log = createLogger({ quiet: opts.quiet });
   log.plain(c.bold("genex rename"));
@@ -2630,23 +2559,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 = path14.join(cwd, ".env");
+  const file = path13.join(cwd, ".env");
   let content;
   try {
-    content = await fs14.readFile(file, "utf8");
+    content = await fs13.readFile(file, "utf8");
   } catch {
     return;
   }
   const re = /^(\s*VITE_GENEX_SLUG=)(.*)$/m;
   if (!re.test(content)) return;
-  await fs14.writeFile(file, content.replace(re, `$1${to}`));
+  await fs13.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 = path14.join(cwd, "src", "genex.config.ts");
+  const file = path13.join(cwd, "src", "genex.config.ts");
   let content;
   try {
-    content = await fs14.readFile(file, "utf8");
+    content = await fs13.readFile(file, "utf8");
   } catch {
     return;
   }
@@ -2656,7 +2585,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 fs14.writeFile(file, content.replace(quoted, `"${to}"`));
+  await fs13.writeFile(file, content.replace(quoted, `"${to}"`));
   log.dim(`  src/genex.config.ts: baked slug -> ${to}`);
 }
 
@@ -2786,9 +2715,9 @@ function relTime(iso) {
 // src/lib/deploy.ts
 import "child_process";
 import crypto3 from "crypto";
-import fs17 from "fs/promises";
-import os9 from "os";
-import path16 from "path";
+import fs16 from "fs/promises";
+import os8 from "os";
+import path15 from "path";
 
 // ../../packages/mobile-scan/src/image-dims.ts
 function u32be(b, o) {
@@ -3052,12 +2981,12 @@ function tierFor(estVramMb) {
 }
 
 // src/commands/ui.ts
-import fs16 from "fs/promises";
-import path15 from "path";
+import fs15 from "fs/promises";
+import path14 from "path";
 import { PNG as PNG2 } from "pngjs";
 
 // src/lib/png-tools.ts
-import fs15 from "fs/promises";
+import fs14 from "fs/promises";
 import { PNG } from "pngjs";
 var ALPHA_TRANSPARENT_MAX = 16;
 var isHttpUrl = (s) => /^https?:\/\//i.test(s);
@@ -3068,12 +2997,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 fs14.readFile(input);
   }
   return PNG.sync.read(buf);
 }
 async function writePng(file, png) {
-  await fs15.writeFile(file, PNG.sync.write(png));
+  await fs14.writeFile(file, PNG.sync.write(png));
 }
 function cropPng(image, box) {
   const out = new PNG({ width: box.w, height: box.h });
@@ -3373,7 +3302,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 fs15.mkdir(outDir, { recursive: true });
   log.plain(c.bold("genex ui extract"));
   log.dim(`  ${input} (${W}x${H}) \u2192 ${outDir}, ${names.length} names`);
   let hasTransparency = false;
@@ -3602,7 +3531,7 @@ async function uiExtract(opts, log) {
         rimPixels: speckle.sampled
       });
     }
-    const outPath = path15.join(outDir, `${name}.png`);
+    const outPath = path14.join(outDir, `${name}.png`);
     await writePng(outPath, out);
     const sidecar = {
       name,
@@ -3621,7 +3550,7 @@ async function uiExtract(opts, log) {
       defringed
     };
     const { name: _n, out: _o, ...sidecarBody } = sidecar;
-    await fs16.writeFile(
+    await fs15.writeFile(
       outPath.replace(/\.png$/i, "") + ".bbox.json",
       JSON.stringify(sidecarBody, null, 2)
     );
@@ -3630,8 +3559,8 @@ async function uiExtract(opts, log) {
       `${name}.png  ${cropW}x${cropH} (ar ${sidecar.aspectRatio}) at sheet ${padX0},${padY0}`
     );
   }
-  const debugPath = path15.join(outDir, "extract-debug.json");
-  await fs16.writeFile(
+  const debugPath = path14.join(outDir, "extract-debug.json");
+  await fs15.writeFile(
     debugPath,
     JSON.stringify(
       {
@@ -4093,7 +4022,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 fs15.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);
@@ -4146,11 +4075,11 @@ async function uiMasks(opts, log) {
       });
     }
     const overlay = makeOverlay(clean2, converted.png);
-    const framePath = path15.join(outDir, `${pair.name}-frame.png`);
-    const maskPath = path15.join(outDir, `${pair.name}-mask.png`);
-    const annotatedPath = path15.join(outDir, `${pair.name}-annotated-source.png`);
-    const overlayPath = path15.join(outDir, `${pair.name}-overlay.png`);
-    const metaPath = path15.join(outDir, `${pair.name}.annotated-progress.json`);
+    const framePath = path14.join(outDir, `${pair.name}-frame.png`);
+    const maskPath = path14.join(outDir, `${pair.name}-mask.png`);
+    const annotatedPath = path14.join(outDir, `${pair.name}-annotated-source.png`);
+    const overlayPath = path14.join(outDir, `${pair.name}-overlay.png`);
+    const metaPath = path14.join(outDir, `${pair.name}.annotated-progress.json`);
     await writePng(framePath, clean2);
     await writePng(maskPath, converted.png);
     await writePng(annotatedPath, annotated);
@@ -4197,7 +4126,7 @@ async function uiMasks(opts, log) {
       },
       overlay: overlayPath
     };
-    await fs16.writeFile(metaPath, `${JSON.stringify(meta, null, 2)}
+    await fs15.writeFile(metaPath, `${JSON.stringify(meta, null, 2)}
 `);
     results.push(meta);
     const fb = converted.bbox;
@@ -4213,8 +4142,8 @@ async function uiMasks(opts, log) {
       );
     }
   }
-  const indexPath = path15.join(outDir, "annotated-progress.json");
-  await fs16.writeFile(indexPath, `${JSON.stringify({ input, loosened, pairs: results }, null, 2)}
+  const indexPath = path14.join(outDir, "annotated-progress.json");
+  await fs15.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}).`);
@@ -4340,7 +4269,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 fs15.writeFile(opts.out, `${JSON.stringify(result, null, 2)}
 `);
   if (opts.cropPath) log.dim(`  crop \u2192 ${opts.cropPath}`);
 }
@@ -4372,7 +4301,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 fs15.writeFile(
     sidecarPath,
     JSON.stringify(speckleAllowed ? { ...sidecar, speckleAllowed: true } : sidecar, null, 2)
   );
@@ -4479,7 +4408,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 = path15.basename(outPath);
+  const name = path14.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):");
@@ -4644,13 +4573,13 @@ async function walkFiles(dir) {
   const out = [];
   let entries;
   try {
-    entries = await fs16.readdir(dir, { withFileTypes: true });
+    entries = await fs15.readdir(dir, { withFileTypes: true });
   } catch {
     return out;
   }
   for (const entry of entries) {
     if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
-    const p = path15.join(dir, entry.name);
+    const p = path14.join(dir, entry.name);
     if (entry.isDirectory()) out.push(...await walkFiles(p));
     else out.push(p);
   }
@@ -4659,7 +4588,7 @@ async function walkFiles(dir) {
 async function collectUiAuditFindings(assetDir, srcDir, cwd = process.cwd()) {
   const viewportFindings = [];
   try {
-    const indexHtml = await fs16.readFile(path15.join(cwd, "index.html"), "utf8");
+    const indexHtml = await fs15.readFile(path14.join(cwd, "index.html"), "utf8");
     if (!/<meta[^>]+name=["']viewport["']/i.test(indexHtml)) {
       viewportFindings.push({
         kind: "viewport-meta",
@@ -4673,28 +4602,28 @@ async function collectUiAuditFindings(assetDir, srcDir, cwd = process.cwd()) {
     }
   } catch {
   }
-  const absAssets = path15.resolve(cwd, assetDir);
+  const absAssets = path14.resolve(cwd, assetDir);
   try {
-    if (!(await fs16.stat(absAssets)).isDirectory()) {
+    if (!(await fs15.stat(absAssets)).isDirectory()) {
       return viewportFindings.length > 0 ? viewportFindings : null;
     }
   } catch {
     return viewportFindings.length > 0 ? viewportFindings : null;
   }
-  const srcFiles = (await walkFiles(path15.resolve(cwd, srcDir))).filter(
-    (p) => AUDIT_SRC_EXTS.has(path15.extname(p).toLowerCase())
+  const srcFiles = (await walkFiles(path14.resolve(cwd, srcDir))).filter(
+    (p) => AUDIT_SRC_EXTS.has(path14.extname(p).toLowerCase())
   );
   try {
-    for (const name of await fs16.readdir(cwd)) {
-      const ext = path15.extname(name).toLowerCase();
-      if (ext === ".html" || ext === ".css") srcFiles.push(path15.join(cwd, name));
+    for (const name of await fs15.readdir(cwd)) {
+      const ext = path14.extname(name).toLowerCase();
+      if (ext === ".html" || ext === ".css") srcFiles.push(path14.join(cwd, name));
     }
   } catch {
   }
   const sources = [];
   for (const p of srcFiles) {
     try {
-      sources.push({ rel: path15.relative(cwd, p), text: await fs16.readFile(p, "utf8") });
+      sources.push({ rel: path14.relative(cwd, p), text: await fs15.readFile(p, "utf8") });
     } catch {
     }
   }
@@ -4704,11 +4633,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 = path15.basename(p);
+    const base = path14.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 fs15.readFile(p, "utf8"));
         metaByName.set(metaMatch[1], {
           cleanCrop: meta.clean?.crop ?? null,
           loosened: meta.loosened === true
@@ -4719,7 +4648,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 fs15.readFile(p, "utf8"));
         if (sidecar.sheetBBox) bboxByPng.set(base.replace(/\.bbox\.json$/, ".png"), sidecar.sheetBBox);
       } catch {
       }
@@ -4728,7 +4657,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 = path15.basename(p);
+      const base = path14.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;
@@ -4752,7 +4681,7 @@ async function collectUiAuditFindings(assetDir, srcDir, cwd = process.cwd()) {
   }
   const pngByBase = /* @__PURE__ */ new Map();
   for (const p of assetFiles) {
-    const base = path15.basename(p);
+    const base = path14.basename(p);
     if (base.toLowerCase().endsWith(".png")) pngByBase.set(base, p);
   }
   for (const [maskBase, maskPath] of pngByBase) {
@@ -4765,8 +4694,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 fs15.readFile(framePath));
+        mask = PNG2.sync.read(await fs15.readFile(maskPath));
       } catch {
         continue;
       }
@@ -4785,7 +4714,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 fs15.readFile(p));
     } catch {
       continue;
     }
@@ -4805,7 +4734,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(path15.basename(p));
+    const m = /^(.+)\.annotated-progress\.json$/.exec(path14.basename(p));
     if (!m) continue;
     const maskBase = `${m[1]}-mask.png`;
     if (!referenced(maskBase)) {
@@ -4817,14 +4746,14 @@ async function collectUiAuditFindings(assetDir, srcDir, cwd = process.cwd()) {
     }
   }
   for (const p of assetFiles) {
-    const base = path15.basename(p);
+    const base = path14.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: `${path15.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: `${path14.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.)`
       });
     }
   }
@@ -5011,7 +4940,7 @@ async function printUiAuditPreflight(log) {
 }
 async function printPipelineStatePreflight(log, cwd = process.cwd()) {
   try {
-    const design = await fs17.readFile(path16.join(cwd, "DESIGN.md"), "utf8").catch(() => "");
+    const design = await fs16.readFile(path15.join(cwd, "DESIGN.md"), "utf8").catch(() => "");
     const warnings = [];
     if (design.length > 0 && !/##\s*build plan & status/i.test(design)) {
       warnings.push(
@@ -5019,7 +4948,7 @@ async function printPipelineStatePreflight(log, cwd = process.cwd()) {
       );
     }
     if (!/player character:/i.test(design)) {
-      const hasCharacter = await fs17.access(path16.join(cwd, "public", "assets", "meshy-character.json")).then(() => true, () => false);
+      const hasCharacter = await fs16.access(path15.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).`
@@ -5033,12 +4962,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(path16.join(cwd, "src"), { recursive: true });
+    const entries = await fs16.readdir(path15.join(cwd, "src"), { recursive: true });
     for (const rel of entries) {
       if (rel.includes("node_modules")) continue;
-      if (rel.split(path16.sep)[0] === "controllers" || rel.startsWith("controllers/")) continue;
+      if (rel.split(path15.sep)[0] === "controllers" || rel.startsWith("controllers/")) continue;
       if (!/\.(ts|tsx|js|jsx)$/.test(rel)) continue;
-      const text = await fs17.readFile(path16.join(cwd, "src", rel), "utf8").catch(() => "");
+      const text = await fs16.readFile(path15.join(cwd, "src", rel), "utf8").catch(() => "");
       if (BODY_LOADERS.test(text)) return true;
     }
   } catch {
@@ -5075,9 +5004,9 @@ async function deployGame(ctx, opts, log) {
     }
     log.success("Built.");
   }
-  const distDir = path16.join(cwd, "dist");
-  const siteDir = await isDir2(distDir) ? distDir : cwd;
-  const rel = path16.relative(cwd, siteDir) || ".";
+  const distDir = path15.join(cwd, "dist");
+  const siteDir = await isDir(distDir) ? distDir : cwd;
+  const rel = path15.relative(cwd, siteDir) || ".";
   if (siteDir === cwd) await writeGitignore(cwd, log);
   const files = await collectFiles(siteDir);
   if (files.length === 0) {
@@ -5166,7 +5095,7 @@ async function deployGame(ctx, opts, log) {
 }
 async function hasBuildScript(cwd) {
   try {
-    const pkg = JSON.parse(await fs17.readFile(path16.join(cwd, "package.json"), "utf8"));
+    const pkg = JSON.parse(await fs16.readFile(path15.join(cwd, "package.json"), "utf8"));
     return Boolean(pkg.scripts?.build);
   } catch {
     return false;
@@ -5175,12 +5104,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 fs16.readdir(dir, { withFileTypes: true })) {
       const relPath = prefix ? `${prefix}/${e.name}` : e.name;
       if (e.isDirectory()) {
-        if (!EXCLUDE_DIRS.has(e.name)) await walk2(path16.join(dir, e.name), relPath);
+        if (!EXCLUDE_DIRS.has(e.name)) await walk2(path15.join(dir, e.name), relPath);
       } else if (e.isFile() && !isSecretEnvFile(e.name)) {
-        out.push({ relPath, bytes: await fs17.readFile(path16.join(dir, e.name)) });
+        out.push({ relPath, bytes: await fs16.readFile(path15.join(dir, e.name)) });
       }
     }
   };
@@ -5422,7 +5351,7 @@ async function pushWorktree(cwd, pushUrl, managed, log, branch = "main", onCommi
     log.error("Couldn't save your game's source \u2014 please try again.");
     return false;
   };
-  const gitDir = await fs17.mkdtemp(path16.join(os9.tmpdir(), "genex-source-"));
+  const gitDir = await fs16.mkdtemp(path15.join(os8.tmpdir(), "genex-source-"));
   const base = { GIT_DIR: gitDir };
   if (urlHasEmbeddedCredentials(pushUrl)) {
     base.GIT_CONFIG_COUNT = "1";
@@ -5437,12 +5366,12 @@ async function pushWorktree(cwd, pushUrl, managed, log, branch = "main", onCommi
   };
   try {
     if ((await run("git", ["init", "-q"], base)).code !== 0) return failed();
-    await fs17.writeFile(
-      path16.join(gitDir, "info", "exclude"),
+    await fs16.writeFile(
+      path15.join(gitDir, "info", "exclude"),
       // .env* are secrets — never publish them; `!` keeps the non-secret template.
       ["node_modules/", "dist/", ".git/", ".genex/", ".env", ".env.*", "!.env.example", ""].join("\n")
     );
-    const env = { ...base, GIT_WORK_TREE: cwd, GIT_INDEX_FILE: path16.join(gitDir, "index-source") };
+    const env = { ...base, GIT_WORK_TREE: cwd, GIT_INDEX_FILE: path15.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");
@@ -5494,7 +5423,7 @@ async function pushWorktree(cwd, pushUrl, managed, log, branch = "main", onCommi
   } catch {
     return failed();
   } finally {
-    await fs17.rm(gitDir, { recursive: true, force: true }).catch(() => {
+    await fs16.rm(gitDir, { recursive: true, force: true }).catch(() => {
     });
   }
 }
@@ -5544,9 +5473,9 @@ async function fetchPushUrl(ctx, log, expectStagingCommit) {
   }
   return { pushUrl: data.pushUrl, managed: data.managed !== false, sourceRef: data.sourceRef ?? null };
 }
-async function isDir2(p) {
+async function isDir(p) {
   try {
-    return (await fs17.stat(p)).isDirectory();
+    return (await fs16.stat(p)).isDirectory();
   } catch {
     return false;
   }
@@ -6028,17 +5957,17 @@ async function promoteBuild(apiUrl, projectId, token, log) {
 }
 
 // src/lib/detect-features.ts
-import fs19 from "fs/promises";
-import path18 from "path";
-
-// src/lib/generation-ledger.ts
 import fs18 from "fs/promises";
 import path17 from "path";
-var ledgerPath = (cwd) => path17.join(cwd, ".genex", "generations.ndjson");
+
+// src/lib/generation-ledger.ts
+import fs17 from "fs/promises";
+import path16 from "path";
+var ledgerPath = (cwd) => path16.join(cwd, ".genex", "generations.ndjson");
 async function append(cwd, event) {
   try {
-    await fs18.access(path17.join(cwd, ".genex"));
-    await fs18.appendFile(ledgerPath(cwd), `${JSON.stringify(event)}
+    await fs17.access(path16.join(cwd, ".genex"));
+    await fs17.appendFile(ledgerPath(cwd), `${JSON.stringify(event)}
 `, "utf8");
   } catch {
   }
@@ -6046,7 +5975,7 @@ async function append(cwd, event) {
 async function readLedger(cwd = process.cwd()) {
   let raw;
   try {
-    raw = await fs18.readFile(ledgerPath(cwd), "utf8");
+    raw = await fs17.readFile(ledgerPath(cwd), "utf8");
   } catch {
     return [];
   }
@@ -6107,7 +6036,7 @@ async function countOutcomes(kind, cwd = process.cwd()) {
 // src/lib/detect-features.ts
 async function detectEmbedSdkVersion(cwd = process.cwd()) {
   try {
-    const raw = await fs19.readFile(path18.join(cwd, "package.json"), "utf8");
+    const raw = await fs18.readFile(path17.join(cwd, "package.json"), "utf8");
     const pkg = JSON.parse(raw);
     const version = pkg.dependencies?.["@genex-ai/embed-sdk"] ?? pkg.devDependencies?.["@genex-ai/embed-sdk"];
     return typeof version === "string" && version ? version : null;
@@ -6117,7 +6046,7 @@ async function detectEmbedSdkVersion(cwd = process.cwd()) {
 }
 async function detectMultiplayer(cwd = process.cwd()) {
   try {
-    const raw = await fs19.readFile(path18.join(cwd, "package.json"), "utf8");
+    const raw = await fs18.readFile(path17.join(cwd, "package.json"), "utf8");
     const pkg = JSON.parse(raw);
     return Boolean(
       pkg.dependencies?.["@genex-ai/multiplayer"] ?? pkg.devDependencies?.["@genex-ai/multiplayer"]
@@ -6129,7 +6058,7 @@ async function detectMultiplayer(cwd = process.cwd()) {
 async function detectMatchmaking(log, cwd = process.cwd()) {
   let pkg;
   try {
-    pkg = JSON.parse(await fs19.readFile(path18.join(cwd, "package.json"), "utf8"));
+    pkg = JSON.parse(await fs18.readFile(path17.join(cwd, "package.json"), "utf8"));
   } catch (err) {
     log.dim(`  (skipping matchmaking \u2014 couldn't read package.json: ${String(err)})`);
     return null;
@@ -6147,15 +6076,15 @@ async function detectMatchmaking(log, cwd = process.cwd()) {
 var TOUCH_KIT_MARKERS = /controllers\/touch\/|controllers\/character\/touch-joystick|TouchJoystick|VirtualButton|DragZone|RotateOverlay/;
 async function detectMobileControls(cwd = process.cwd()) {
   try {
-    const raw = await fs19.readFile(path18.join(cwd, "package.json"), "utf8");
+    const raw = await fs18.readFile(path17.join(cwd, "package.json"), "utf8");
     const pkg = JSON.parse(raw);
     if (pkg.genex?.mobileControls === true) return true;
   } catch {
   }
-  const srcDir = path18.join(cwd, "src");
+  const srcDir = path17.join(cwd, "src");
   let entries;
   try {
-    entries = await fs19.readdir(srcDir, { recursive: true });
+    entries = await fs18.readdir(srcDir, { recursive: true });
   } catch {
     return false;
   }
@@ -6163,7 +6092,7 @@ async function detectMobileControls(cwd = process.cwd()) {
     if (rel.includes("node_modules")) continue;
     if (!/\.(ts|js|mts|mjs|tsx|jsx)$/.test(rel)) continue;
     try {
-      const content = await fs19.readFile(path18.join(srcDir, rel), "utf8");
+      const content = await fs18.readFile(path17.join(srcDir, rel), "utf8");
       if (TOUCH_KIT_MARKERS.test(content)) return true;
     } catch {
     }
@@ -6172,10 +6101,10 @@ async function detectMobileControls(cwd = process.cwd()) {
 }
 var GAME_STATE_CALLS = /savePlayerState|saveWorldState|submitScore/;
 async function detectGameStateUsage(cwd = process.cwd()) {
-  const srcDir = path18.join(cwd, "src");
+  const srcDir = path17.join(cwd, "src");
   let entries;
   try {
-    entries = await fs19.readdir(srcDir, { recursive: true });
+    entries = await fs18.readdir(srcDir, { recursive: true });
   } catch {
     return false;
   }
@@ -6183,7 +6112,7 @@ async function detectGameStateUsage(cwd = process.cwd()) {
     if (rel.includes("node_modules")) continue;
     if (!/\.(ts|js|mts|mjs|tsx|jsx)$/.test(rel)) continue;
     try {
-      const content = await fs19.readFile(path18.join(srcDir, rel), "utf8");
+      const content = await fs18.readFile(path17.join(srcDir, rel), "utf8");
       if (GAME_STATE_CALLS.test(content)) return true;
     } catch {
     }
@@ -6233,19 +6162,19 @@ async function detectSurfaceScan(cwd = process.cwd()) {
     mediaElementAudio: [],
     deferredAudioContext: []
   };
-  const srcDir = path18.join(cwd, "src");
+  const srcDir = path17.join(cwd, "src");
   let entries;
   try {
-    entries = await fs19.readdir(srcDir, { recursive: true });
+    entries = await fs18.readdir(srcDir, { recursive: true });
   } catch {
     return found;
   }
   for (const nativeRel of entries) {
     if (nativeRel.includes("node_modules")) continue;
     if (!/\.(ts|js|mts|mjs|tsx|jsx)$/.test(nativeRel)) continue;
-    const raw = await fs19.readFile(path18.join(srcDir, nativeRel), "utf8").catch(() => "");
+    const raw = await fs18.readFile(path17.join(srcDir, nativeRel), "utf8").catch(() => "");
     if (!raw) continue;
-    const rel = nativeRel.split(path18.sep).join("/");
+    const rel = nativeRel.split(path17.sep).join("/");
     const content = raw.replace(/\/\*[\s\S]*?\*\//g, (m2) => m2.replace(/[^\n]/g, " ")).replace(/(^|[^:])\/\/[^\n]*/gm, (m2, p1) => p1 + " ".repeat(m2.length - p1.length));
     const repeatRe = /\.repeat\.set\(\s*(-?\d+(?:\.\d+)?)\s*,\s*(-?\d+(?:\.\d+)?)\s*\)/g;
     let m;
@@ -6325,25 +6254,25 @@ async function detectGenerationAudit(cwd = process.cwd()) {
   let haystack = "";
   const read = async (file) => {
     try {
-      haystack += await fs19.readFile(file, "utf8");
+      haystack += await fs18.readFile(file, "utf8");
     } catch {
     }
   };
   try {
-    for (const entry of await fs19.readdir(cwd, { withFileTypes: true })) {
+    for (const entry of await fs18.readdir(cwd, { withFileTypes: true })) {
       if (entry.isFile() && /\.(ts|tsx|js|jsx|css|html|json)$/.test(entry.name)) {
-        await read(path18.join(cwd, entry.name));
+        await read(path17.join(cwd, entry.name));
       }
     }
   } catch {
   }
   for (const sub of ["src", "public"]) {
     try {
-      const entries = await fs19.readdir(path18.join(cwd, sub), { recursive: true });
+      const entries = await fs18.readdir(path17.join(cwd, sub), { recursive: true });
       for (const rel of entries) {
         if (rel.includes("node_modules")) continue;
         if (!/\.(ts|tsx|js|jsx|css|html|json|txt)$/.test(rel)) continue;
-        await read(path18.join(cwd, sub, rel));
+        await read(path17.join(cwd, sub, rel));
       }
     } catch {
     }
@@ -6489,7 +6418,7 @@ async function borrowEvidence(meta, cwd) {
   } catch {
     return true;
   }
-  const gitConfig = await fs19.readFile(path18.join(cwd, ".git", "config"), "utf8").catch(() => "");
+  const gitConfig = await fs18.readFile(path17.join(cwd, ".git", "config"), "utf8").catch(() => "");
   for (const m of gitConfig.matchAll(/url\s*=\s*(\S+)/g)) {
     try {
       const u = new URL(m[1]);
@@ -6497,7 +6426,7 @@ async function borrowEvidence(meta, cwd) {
     } catch {
     }
   }
-  const readme = await fs19.readFile(path18.join(cwd, "README.md"), "utf8").catch(() => "");
+  const readme = await fs18.readFile(path17.join(cwd, "README.md"), "utf8").catch(() => "");
   return readme.includes(host) || /\b(upstream|originally by|ported from|borrowed from)\b/i.test(readme);
 }
 
@@ -6977,8 +6906,8 @@ async function runRollback(opts) {
 }
 
 // src/commands/generate.ts
-import fs21 from "fs/promises";
-import path20 from "path";
+import fs20 from "fs/promises";
+import path19 from "path";
 import { PNG as PNG4 } from "pngjs";
 
 // src/lib/glass.ts
@@ -7059,8 +6988,8 @@ function solveMagentaGlass(source) {
 }
 
 // src/lib/download-assets.ts
-import fs20 from "fs/promises";
-import path19 from "path";
+import fs19 from "fs/promises";
+import path18 from "path";
 var RUNG_ROLE = /@\d+$/;
 function isPrimaryRole(role) {
   return !RUNG_ROLE.test(role);
@@ -7080,7 +7009,7 @@ async function downloadAssets(files, opts) {
   const result = { saved: [], failures: [] };
   if (wanted.length === 0) return result;
   try {
-    await fs20.mkdir(opts.outDir, { recursive: true });
+    await fs19.mkdir(opts.outDir, { recursive: true });
   } catch (err) {
     result.failures.push(
       `couldn't create ${opts.outDir} (${err instanceof Error ? err.message : String(err)})`
@@ -7089,12 +7018,12 @@ async function downloadAssets(files, opts) {
   }
   const multi = wanted.length > 1;
   for (const file of wanted) {
-    const dest = path19.join(opts.outDir, localAssetName(opts.kind, opts.prompt, opts.id, file, multi));
+    const dest = path18.join(opts.outDir, localAssetName(opts.kind, opts.prompt, opts.id, file, multi));
     try {
       const res = await fetch(file.url);
       if (!res.ok) throw new Error(`HTTP ${res.status}`);
       const buf = Buffer.from(await res.arrayBuffer());
-      await fs20.writeFile(dest, buf);
+      await fs19.writeFile(dest, buf);
       result.saved.push({ role: file.role, path: dest, url: file.url, bytes: buf.byteLength });
     } catch (err) {
       result.failures.push(
@@ -7238,7 +7167,7 @@ var isRemoteRef = (value) => /^(https?:\/\/|data:)/i.test(value);
 async function inlineLocalImage(filePath, flag) {
   let bytes;
   try {
-    bytes = await fs21.readFile(filePath);
+    bytes = await fs20.readFile(filePath);
   } catch {
     return { ok: false, error: `Couldn't read the ${flag} file at ${filePath}.` };
   }
@@ -7248,7 +7177,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[path20.extname(filePath).toLowerCase()] ?? "image/png";
+  const mime = IMAGE_MIME_BY_EXT[path19.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.";
@@ -7406,7 +7335,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: ${path20.basename(ref).slice(0, 120)}`;
+    typedPrompt = `from image: ${path19.basename(ref).slice(0, 120)}`;
   }
   if (!typedPrompt) {
     log.error(`Missing prompt. Usage: ${c.cyan(`genex ${kind} "<prompt>"`)}`);
@@ -7450,7 +7379,7 @@ async function runGenerate(kind, opts) {
       return;
     }
     try {
-      const bytes = await fs21.readFile(opts.inpaintUrl);
+      const bytes = await fs20.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}.`);
@@ -7621,7 +7550,7 @@ async function reportGlassTerminal(view, outDir, log, json) {
     return;
   }
   await recordTerminal(view.id, "completed", files.map((f) => f.url));
-  await fs21.mkdir(outDir, { recursive: true });
+  await fs20.mkdir(outDir, { recursive: true });
   const solved = [];
   for (let i = 0; i < files.length; i++) {
     const f = files[i];
@@ -7653,8 +7582,8 @@ async function reportGlassTerminal(view, outDir, log, json) {
       });
       continue;
     }
-    const outPath = path20.join(outDir, `glass-${i + 1}.png`);
-    await fs21.writeFile(outPath, PNG4.sync.write(r.png));
+    const outPath = path19.join(outDir, `glass-${i + 1}.png`);
+    await fs20.writeFile(outPath, PNG4.sync.write(r.png));
     solved.push({
       path: outPath,
       url: f.url,
@@ -8420,8 +8349,8 @@ async function toRow(e, v, cwd) {
 }
 
 // src/commands/controller.ts
-import fs23 from "fs/promises";
-import path22 from "path";
+import fs22 from "fs/promises";
+import path21 from "path";
 
 // ../../packages/meshy-animation-catalog/src/index.ts
 import { createHash } from "crypto";
@@ -17551,9 +17480,9 @@ function searchMeshyAnimations(query, options = {}) {
 }
 
 // src/lib/anims.ts
-import fs22 from "fs/promises";
-import path21 from "path";
-var ANIMS_DEST = path21.join("public", "assets", "anims");
+import fs21 from "fs/promises";
+import path20 from "path";
+var ANIMS_DEST = path20.join("public", "assets", "anims");
 var HIDDEN_TAG = "reference";
 async function runAnims(opts) {
   const log = createLogger({ quiet: opts.quiet });
@@ -17569,7 +17498,7 @@ async function runAnims(opts) {
     printCatalog(log, manifest, selectors);
     return;
   }
-  const controllerMarker = path21.join(root, "src", "controllers", "character");
+  const controllerMarker = path20.join(root, "src", "controllers", "character");
   if (!await exists2(controllerMarker)) {
     log.error(
       `No character controller in this game (missing ${c.cyan("src/controllers/character/")}).`
@@ -17578,11 +17507,11 @@ async function runAnims(opts) {
     process.exitCode = 1;
     return;
   }
-  const destDir = path21.join(root, ANIMS_DEST);
-  const gameManifestPath = path21.join(destDir, "manifest.json");
+  const destDir = path20.join(root, ANIMS_DEST);
+  const gameManifestPath = path20.join(destDir, "manifest.json");
   if (opts.reset) {
-    await fs22.rm(destDir, { recursive: true, force: true });
-    log.step(`Cleared ${c.cyan(ANIMS_DEST + path21.sep)} (--reset)`);
+    await fs21.rm(destDir, { recursive: true, force: true });
+    log.step(`Cleared ${c.cyan(ANIMS_DEST + path20.sep)} (--reset)`);
   }
   if (selectors.length === 0) {
     const installed = await readGameManifest(gameManifestPath);
@@ -17620,35 +17549,35 @@ async function runAnims(opts) {
     }
   }
   const wanted = [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
-  const cacheDir = path21.join(
+  const cacheDir = path20.join(
     opts.cacheDir ?? getAnimsCacheDir(),
     `${manifest.library}-v${manifest.version}`
   );
-  await fs22.mkdir(cacheDir, { recursive: true });
-  await fs22.mkdir(destDir, { recursive: true });
+  await fs21.mkdir(cacheDir, { recursive: true });
+  await fs21.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 = path21.join(destDir, entry.file);
+    const dest = path20.join(destDir, entry.file);
     if (await hasSize(dest, entry.bytes)) {
       presentCount++;
       continue;
     }
     try {
-      const cached = path21.join(cacheDir, entry.file);
+      const cached = path20.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 fs22.writeFile(cached, buf);
+        await fs21.writeFile(cached, buf);
       }
-      await fs22.copyFile(cached, dest);
+      await fs21.copyFile(cached, dest);
       installedCount++;
       addedBytes += entry.bytes;
-      log.dim(`  ${path21.join(ANIMS_DEST, entry.file)} (${formatMb(entry.bytes)})`);
+      log.dim(`  ${path20.join(ANIMS_DEST, entry.file)} (${formatMb(entry.bytes)})`);
     } catch (err) {
       failures.push(`${entry.name} (${err instanceof Error ? err.message : String(err)})`);
     }
@@ -17664,13 +17593,13 @@ async function runAnims(opts) {
     version: manifest.version,
     clips: [...union].sort((a, b) => a.localeCompare(b))
   };
-  await fs22.writeFile(gameManifestPath, JSON.stringify(gameManifest, null, 2) + "\n");
+  await fs21.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 + path21.sep)}${addedBytes > 0 ? ` (+${formatMb(addedBytes)})` : ""}`
+    `${parts.join(", ")} \u2192 ${c.cyan(ANIMS_DEST + path20.sep)}${addedBytes > 0 ? ` (+${formatMb(addedBytes)})` : ""}`
   );
   for (const [selector, entries] of resolved) {
     const names = entries.filter((e) => !coreNames.has(e.name)).map((e) => e.name);
@@ -17702,8 +17631,8 @@ async function loadManifest(baseOverride) {
     }
   } catch {
   }
-  const snapshotPath = path21.join(getTemplatesDir(), "controllers", "assets", "anims-manifest.json");
-  const manifest = JSON.parse(await fs22.readFile(snapshotPath, "utf8"));
+  const snapshotPath = path20.join(getTemplatesDir(), "controllers", "assets", "anims-manifest.json");
+  const manifest = JSON.parse(await fs21.readFile(snapshotPath, "utf8"));
   return { manifest, source: "snapshot" };
 }
 function resolveSelectors(manifest, selectors) {
@@ -17821,21 +17750,21 @@ function printCatalog(log, manifest, selectors) {
 }
 async function readGameManifest(file) {
   try {
-    return JSON.parse(await fs22.readFile(file, "utf8"));
+    return JSON.parse(await fs21.readFile(file, "utf8"));
   } catch {
     return null;
   }
 }
 async function hasSize(file, bytes) {
   try {
-    return (await fs22.stat(file)).size === bytes;
+    return (await fs21.stat(file)).size === bytes;
   } catch {
     return false;
   }
 }
 async function exists2(p) {
   try {
-    await fs22.access(p);
+    await fs21.access(p);
     return true;
   } catch {
     return false;
@@ -18029,8 +17958,8 @@ var CONTROLLER_FILE_SETS = {
     ]
   }
 };
-var CODE_DEST = path22.join("src", "controllers");
-var ASSETS_DEST = path22.join("public", "assets");
+var CODE_DEST = path21.join("src", "controllers");
+var ASSETS_DEST = path21.join("public", "assets");
 async function runController(opts) {
   const log = createLogger({ quiet: opts.quiet });
   if (opts.kind?.trim() === "anims") {
@@ -18047,31 +17976,31 @@ async function runController(opts) {
     process.exitCode = 1;
     return;
   }
-  const srcDir = path22.join(getTemplatesDir(), "controllers");
+  const srcDir = path21.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 + path22.sep)}`);
+  log.step(`Installing the ${kind} controller into ${c.cyan(CODE_DEST + path21.sep)}`);
   const plan = [
-    ...set.code.map((rel) => ({ from: rel, rel: path22.join(CODE_DEST, rel) })),
+    ...set.code.map((rel) => ({ from: rel, rel: path21.join(CODE_DEST, rel) })),
     ...set.assets.map((rel) => ({
       from: rel,
-      rel: path22.join(ASSETS_DEST, path22.basename(rel))
+      rel: path21.join(ASSETS_DEST, path21.basename(rel))
     }))
   ];
   let copied = 0;
   let skipped = 0;
   try {
     for (const file of plan) {
-      const dest = path22.join(root, file.rel);
+      const dest = path21.join(root, file.rel);
       if (!opts.force && await exists3(dest)) {
         skipped++;
         log.dim(`  skipped ${file.rel} (exists \u2014 use --force to overwrite)`);
         continue;
       }
-      await fs23.mkdir(path22.dirname(dest), { recursive: true });
-      await fs23.copyFile(path22.join(srcDir, file.from), dest);
+      await fs22.mkdir(path21.dirname(dest), { recursive: true });
+      await fs22.copyFile(path21.join(srcDir, file.from), dest);
       copied++;
       log.dim(`  ${file.rel}`);
     }
@@ -18124,7 +18053,7 @@ async function runController(opts) {
   for (const line of set.sketch) {
     log.dim(`       ${line}`);
   }
-  if (kind === "character" && !await exists3(path22.join(root, ASSETS_DEST, "meshy-character.json"))) {
+  if (kind === "character" && !await exists3(path21.join(root, ASSETS_DEST, "meshy-character.json"))) {
     log.plain("");
     log.plain(
       `  ${stepOffset + 3}. This game has no generated character yet \u2014 ${c.cyan(
@@ -18156,9 +18085,9 @@ async function installMeshyCharacterManifest(args) {
     throw new Error("The API returned an invalid Meshy character manifest.");
   }
   assertCompleteMeshyControllerPack(manifest);
-  const destination = path22.join(args.root, ASSETS_DEST, "meshy-character.json");
-  await fs23.mkdir(path22.dirname(destination), { recursive: true });
-  await fs23.writeFile(
+  const destination = path21.join(args.root, ASSETS_DEST, "meshy-character.json");
+  await fs22.mkdir(path21.dirname(destination), { recursive: true });
+  await fs22.writeFile(
     destination,
     `${JSON.stringify(manifest, null, 2)}
 `
@@ -18296,14 +18225,14 @@ function assertCompleteMeshyControllerPack(manifest) {
 }
 async function installFallbackAvatar(args) {
   const { root, srcDir, log } = args;
-  const dest = path22.join(root, ASSETS_DEST, "avatar.vrm");
-  await fs23.mkdir(path22.dirname(dest), { recursive: true });
-  await fs23.copyFile(path22.join(srcDir, "assets", "default-avatar.vrm"), dest);
+  const dest = path21.join(root, ASSETS_DEST, "avatar.vrm");
+  await fs22.mkdir(path21.dirname(dest), { recursive: true });
+  await fs22.copyFile(path21.join(srcDir, "assets", "default-avatar.vrm"), dest);
   log.dim("  public/assets/avatar.vrm (fallback avatar \u2014 bundled CC0 default)");
 }
 async function exists3(p) {
   try {
-    await fs23.access(p);
+    await fs22.access(p);
     return true;
   } catch {
     return false;
@@ -18311,8 +18240,8 @@ async function exists3(p) {
 }
 
 // src/commands/character.ts
-import fs24 from "fs/promises";
-import path23 from "path";
+import fs23 from "fs/promises";
+import path22 from "path";
 function exactAnimation(selector) {
   const trimmed = selector.trim();
   if (/^-?\d+$/.test(trimmed)) return animationById(Number(trimmed));
@@ -18392,7 +18321,7 @@ function showAmbiguity(selector, candidates, log, json = false) {
   }
   process.exitCode = 1;
 }
-var INSTALLED_MANIFEST = path23.join("public", "assets", "meshy-character.json");
+var INSTALLED_MANIFEST = path22.join("public", "assets", "meshy-character.json");
 async function resolveAdoptTarget(selector) {
   const trimmed = selector?.trim();
   if (trimmed && !trimmed.endsWith(".json")) {
@@ -18401,7 +18330,7 @@ async function resolveAdoptTarget(selector) {
   const file = trimmed ?? INSTALLED_MANIFEST;
   let raw;
   try {
-    raw = await fs24.readFile(file, "utf8");
+    raw = await fs23.readFile(file, "utf8");
   } catch {
     return {
       ok: false,
@@ -19230,8 +19159,8 @@ function rank(items, query) {
 }
 
 // src/commands/motion.ts
-import fs25 from "fs/promises";
-import path24 from "path";
+import fs24 from "fs/promises";
+import path23 from "path";
 
 // src/lib/motion/npz.ts
 import zlib from "zlib";
@@ -20482,7 +20411,7 @@ async function motionGen(opts, log) {
   }
   if (opts.constraintsPath !== void 0) {
     try {
-      const raw = await fs25.readFile(opts.constraintsPath, "utf8");
+      const raw = await fs24.readFile(opts.constraintsPath, "utf8");
       generationOptions.constraints = JSON.parse(raw);
     } catch {
       log.error(`Couldn't read the --constraints JSON at ${opts.constraintsPath}.`);
@@ -20506,10 +20435,10 @@ async function motionGen(opts, log) {
 async function expandTakes(selectors) {
   const out = [];
   for (const sel of selectors) {
-    const st = await fs25.stat(sel).catch(() => null);
+    const st = await fs24.stat(sel).catch(() => null);
     if (st?.isDirectory()) {
-      const names = await fs25.readdir(sel);
-      for (const n of names.sort()) if (n.endsWith(".npz")) out.push(path24.join(sel, n));
+      const names = await fs24.readdir(sel);
+      for (const n of names.sort()) if (n.endsWith(".npz")) out.push(path23.join(sel, n));
     } else if (st?.isFile()) {
       out.push(sel);
     } else {
@@ -20544,7 +20473,7 @@ async function motionVerify(opts, log) {
   let gates = DEFAULT_GATES;
   if (opts.gatesPath) {
     try {
-      gates = mergeGates(DEFAULT_GATES, JSON.parse(await fs25.readFile(opts.gatesPath, "utf8")));
+      gates = mergeGates(DEFAULT_GATES, JSON.parse(await fs24.readFile(opts.gatesPath, "utf8")));
     } catch {
       log.error(`Couldn't read the --gates JSON at ${opts.gatesPath}.`);
       process.exitCode = 1;
@@ -20566,9 +20495,9 @@ async function motionVerify(opts, log) {
   }
   const reports = [];
   for (const file of files) {
-    const stem = path24.basename(file).replace(/\.npz$/, "");
+    const stem = path23.basename(file).replace(/\.npz$/, "");
     try {
-      reports.push(analyzeTake(stem, await fs25.readFile(file), gates));
+      reports.push(analyzeTake(stem, await fs24.readFile(file), gates));
     } catch (err) {
       reports.push({
         take: stem,
@@ -20606,7 +20535,7 @@ async function motionCompile(opts, log) {
   let cfg = DEFAULT_MOTION_CONFIG;
   if (opts.configPath) {
     try {
-      const patch = JSON.parse(await fs25.readFile(opts.configPath, "utf8"));
+      const patch = JSON.parse(await fs24.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}.`);
@@ -20624,16 +20553,16 @@ async function motionCompile(opts, log) {
   }
   const inputs = [];
   for (const file of files) {
-    const stem = path24.basename(file).replace(/\.npz$/, "");
+    const stem = path23.basename(file).replace(/\.npz$/, "");
     try {
-      inputs.push({ stem, take: loadTake(await fs25.readFile(file)) });
+      inputs.push({ stem, take: loadTake(await fs24.readFile(file)) });
     } catch (err) {
       log.error(`${stem}: ${err instanceof Error ? err.message : String(err)}`);
       process.exitCode = 1;
       return;
     }
   }
-  const setName = opts.set ?? path24.basename(opts.out).replace(/\.json$/, "");
+  const setName = opts.set ?? path23.basename(opts.out).replace(/\.json$/, "");
   let result;
   try {
     result = compileSet(inputs, setName, cfg);
@@ -20648,9 +20577,9 @@ async function motionCompile(opts, log) {
     process.exitCode = 1;
     return;
   }
-  await fs25.mkdir(path24.dirname(path24.resolve(opts.out)), { recursive: true });
+  await fs24.mkdir(path23.dirname(path23.resolve(opts.out)), { recursive: true });
   const json = JSON.stringify(result.data);
-  await fs25.writeFile(opts.out, json);
+  await fs24.writeFile(opts.out, json);
   if (opts.json) {
     writeJson({ out: opts.out, set: setName, tracks: Object.keys(result.data.gaits), bytes: json.length });
     return;
@@ -20668,9 +20597,9 @@ var MOTION_RUNTIME_FILES = [
 var MOTION_PRESETS = {
   rifle: ["sets/rifle.json", "sets/jumps.json"]
 };
-var MOTION_DEST = path24.join("src", "motion");
+var MOTION_DEST = path23.join("src", "motion");
 async function motionInstall(opts, log) {
-  const srcDir = path24.join(getTemplatesDir(), "motion");
+  const srcDir = path23.join(getTemplatesDir(), "motion");
   const root = opts.cwd ?? process.cwd();
   const preset = opts.set;
   if (preset !== void 0 && !MOTION_PRESETS[preset]) {
@@ -20681,21 +20610,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 + path24.sep)}`);
+  log.step(`Vendoring the motion runtime into ${c.cyan(MOTION_DEST + path23.sep)}`);
   let copied = 0, skipped = 0;
   try {
     for (const rel of files) {
-      const dest = path24.join(root, MOTION_DEST, rel);
-      const exists5 = await fs25.access(dest).then(() => true, () => false);
+      const dest = path23.join(root, MOTION_DEST, rel);
+      const exists5 = await fs24.access(dest).then(() => true, () => false);
       if (!opts.force && exists5) {
         skipped++;
-        log.dim(`  skipped ${path24.join(MOTION_DEST, rel)} (exists \u2014 use --force to overwrite)`);
+        log.dim(`  skipped ${path23.join(MOTION_DEST, rel)} (exists \u2014 use --force to overwrite)`);
         continue;
       }
-      await fs25.mkdir(path24.dirname(dest), { recursive: true });
-      await fs25.copyFile(path24.join(srcDir, rel), dest);
+      await fs24.mkdir(path23.dirname(dest), { recursive: true });
+      await fs24.copyFile(path23.join(srcDir, rel), dest);
       copied++;
-      log.dim(`  ${path24.join(MOTION_DEST, rel)}`);
+      log.dim(`  ${path23.join(MOTION_DEST, rel)}`);
     }
   } catch (err) {
     log.error(`Copy failed: ${String(err)}`);
@@ -20736,7 +20665,7 @@ async function motionConstraints(opts, log) {
   }
   const doc = directionConstraint(dir, speed, duration);
   const out = opts.out ?? "constraints.json";
-  await fs25.writeFile(out, JSON.stringify(doc));
+  await fs24.writeFile(out, JSON.stringify(doc));
   if (opts.json) {
     writeJson({ out, dir: dirName, speed, duration, waypoints: doc[0].frame_indices.length });
     return;
@@ -20772,6 +20701,214 @@ async function runMotion(opts) {
   }
 }
 
+// src/commands/blender.ts
+import fs25 from "fs/promises";
+import path24 from "path";
+var SUBS2 = ["demo", "exec", "snap", "scene", "export", "reset", "mcp"];
+var DEFAULT_OUT_DIR = "assets/blender";
+async function writeB64(dir, name, b64) {
+  await fs25.mkdir(dir, { recursive: true });
+  const p = path24.join(dir, name);
+  await fs25.writeFile(p, Buffer.from(b64, "base64"));
+  return p;
+}
+function reportScene(log, s) {
+  if (!s) return;
+  log.plain(
+    `  ${c.dim("objects")} ${s.objectCount}  ${c.dim("meshes")} ${s.meshCount}  ${c.dim("tris")} ${s.totalTris}  ${c.dim("materials")} ${s.materialCount}  ${c.dim("radius")} ${s.bounds.radius}`
+  );
+}
+async function runBlender(opts) {
+  const log = createLogger();
+  const sub = opts.sub;
+  if (!sub || !SUBS2.includes(sub)) {
+    log.error(`Usage: genex blender <${SUBS2.join("|")}>`);
+    return 1;
+  }
+  if (sub === "mcp") {
+    const { runBlenderMcp } = await import("./blender-mcp-OXFN3RVI.js");
+    return runBlenderMcp();
+  }
+  const base = blenderEndpoint();
+  if (!base) {
+    const [first, ...rest] = BLENDER_SETUP_HINT.split("\n");
+    log.error(first ?? "GENEX_BLENDER_URL is not set");
+    log.plain(rest.join("\n"));
+    return 1;
+  }
+  const outDir = path24.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(", ")}.`);
+    return 1;
+  }
+  try {
+    const health = await blenderCall(base, "/health");
+    log.dim(`  blender ${String(health.blender ?? "?")} at ${base}`);
+  } catch (err) {
+    log.error(`Cannot reach the Blender service at ${base}`);
+    log.plain(`  ${err instanceof Error ? err.message : String(err)}`);
+    return 1;
+  }
+  switch (sub) {
+    case "reset": {
+      const r = await blenderCall(base, "/reset", {});
+      log.success("Scene reset.");
+      reportScene(log, r.scene);
+      return 0;
+    }
+    case "scene": {
+      const r = await blenderCall(base, "/scene");
+      log.plain(JSON.stringify(r, null, 2));
+      return 0;
+    }
+    case "snap": {
+      const r = await blenderCall(base, "/render", mode ? { mode } : {});
+      const used = String(r.mode ?? mode ?? "default");
+      const p = await writeB64(outDir, `snap-${used}.png`, r.contactSheetPng ?? "");
+      log.success(`${used} sheet in ${r.ms ?? "?"}ms`);
+      log.plain(`  ${c.cyan(p)}`);
+      return 0;
+    }
+    case "export": {
+      const target = opts.out ?? path24.join(outDir, "scene.glb");
+      const r = await blenderCall(base, "/export", { path: "/tmp/genex-export.glb" });
+      await fs25.mkdir(path24.dirname(target), { recursive: true });
+      await fs25.writeFile(target, Buffer.from(r.glbBase64 ?? "", "base64"));
+      log.success(`Exported ${r.bytes ?? 0} bytes`);
+      log.plain(`  ${c.cyan(target)}`);
+      return 0;
+    }
+    case "exec":
+    case "demo": {
+      let script;
+      let label;
+      if (sub === "demo") {
+        script = DEMO_SCRIPT;
+        label = "demo";
+      } else {
+        if (!opts.input) {
+          log.error("genex blender exec needs a script: --in <file.py>");
+          return 1;
+        }
+        try {
+          script = await fs25.readFile(opts.input, "utf8");
+        } catch {
+          log.error(`Can't read ${opts.input}`);
+          return 1;
+        }
+        label = path24.basename(opts.input);
+      }
+      const r = await blenderCall(base, "/exec", mode ? { script, mode } : { script });
+      if (r.stdout?.trim()) log.plain(r.stdout.trimEnd());
+      if (r.stderr?.trim()) log.dim(r.stderr.trimEnd());
+      if (r.error) {
+        log.error(`${label} raised:`);
+        log.plain(r.error.trimEnd());
+        if (r.contactSheetPng) {
+          const p = await writeB64(outDir, "contact-sheet.png", r.contactSheetPng);
+          log.plain(`  ${c.dim("scene at failure:")} ${c.cyan(p)}`);
+        }
+        return 1;
+      }
+      log.success(`${label} ran in ${r.ms ?? "?"}ms`);
+      if (r.sceneRestored?.restored) {
+        log.warn(
+          `The service restarted (${r.sceneRestored.reason ?? "unknown"}) and the scene was restored from a checkpoint \u2014 your last step may be missing.`
+        );
+      }
+      reportScene(log, r.scene);
+      const written = [];
+      if (r.contactSheetPng) {
+        written.push(await writeB64(outDir, "contact-sheet.png", r.contactSheetPng));
+      }
+      if (sub === "demo") {
+        const glb = await blenderCall(base, "/export", { path: "/tmp/genex-export.glb" });
+        written.push(await writeB64(outDir, "castle.glb", glb.glbBase64 ?? ""));
+      }
+      for (const p of written) log.plain(`  ${c.cyan(p)}`);
+      if (sub === "demo") {
+        log.plain(`
+  ${c.dim("Open the sheet. If it shows a castle room, the loop works.")}`);
+      }
+      return 0;
+    }
+  }
+  return 1;
+}
+var DEMO_SCRIPT = `
+import bpy
+
+ROOM, WALL_H, WALL_T = 12.0, 5.0, 0.6
+bpy.ops.wm.read_factory_settings(use_empty=True)
+
+def mat(name, rgb, rough=0.85):
+    m = bpy.data.materials.new(name)
+    m.use_nodes = True
+    b = m.node_tree.nodes["Principled BSDF"]
+    b.inputs["Base Color"].default_value = (*rgb, 1.0)
+    b.inputs["Roughness"].default_value = rough
+    # BOTH, and the second is the trap: Workbench's MATERIAL mode -- what every
+    # contact sheet renders -- reads diffuse_color, NOT the Principled BSDF.
+    # Setting only the BSDF gives a scene that exports with correct colours,
+    # reports materialCount>0, and renders ENTIRELY GREY.
+    m.diffuse_color = (*rgb, 1.0)
+    return m
+
+def cube(name, loc, scale, m):
+    bpy.ops.mesh.primitive_cube_add(size=2.0, location=loc)
+    o = bpy.context.active_object
+    o.name, o.scale = name, scale
+    o.data.materials.append(m)
+    return o
+
+stone, dark = mat("Stone", (0.46, 0.44, 0.41)), mat("StoneDark", (0.26, 0.25, 0.24))
+wood, roofm = mat("Wood", (0.24, 0.14, 0.07)), mat("Roof", (0.35, 0.12, 0.12), 0.6)
+fire = mat("Fire", (1.0, 0.45, 0.1), 0.4)
+half = ROOM / 2
+
+cube("Floor", (0, 0, -0.25), (half, half, 0.25), dark)
+cube("Wall_N", (0, half, WALL_H / 2), (half, WALL_T / 2, WALL_H / 2), stone)
+cube("Wall_E", (half, 0, WALL_H / 2), (WALL_T / 2, half, WALL_H / 2), stone)
+cube("Wall_W", (-half, 0, WALL_H / 2), (WALL_T / 2, half, WALL_H / 2), stone)
+door = 2.2
+side = (ROOM - door) / 4
+for sgn in (-1, 1):
+    cube(f"Wall_S{sgn}", (sgn * (door / 2 + side), -half, WALL_H / 2),
+         (side, WALL_T / 2, WALL_H / 2), stone)
+cube("Lintel", (0, -half, WALL_H - 0.5), (door / 2, WALL_T / 2, 0.5), stone)
+
+for i in range(9):
+    x = -half + 0.6 + i * (ROOM - 1.2) / 8
+    for y in (half, -half):
+        cube(f"Cren_{i}_{y:.0f}", (x, y, WALL_H + 0.35), (0.35, WALL_T / 2, 0.35), stone)
+
+for i, (sx, sy) in enumerate(((1, 1), (1, -1), (-1, 1), (-1, -1))):
+    cx, cy = sx * half, sy * half
+    bpy.ops.mesh.primitive_cylinder_add(radius=1.5, depth=WALL_H + 2.0, vertices=16,
+                                        location=(cx, cy, (WALL_H + 2.0) / 2))
+    t = bpy.context.active_object; t.name = f"Tower_{i}"; t.data.materials.append(stone)
+    bpy.ops.mesh.primitive_cone_add(radius1=2.0, depth=2.4, vertices=16,
+                                    location=(cx, cy, WALL_H + 3.2))
+    r = bpy.context.active_object; r.name = f"Roof_{i}"; r.data.materials.append(roofm)
+
+cube("TableTop", (0, 1.0, 1.1), (2.2, 0.9, 0.12), wood)
+for dx in (-1.9, 1.9):
+    for dy in (-0.65, 0.65):
+        cube(f"Leg{dx}{dy}", (dx, 1.0 + dy, 0.55), (0.12, 0.12, 0.55), wood)
+
+for i, (tx, ty) in enumerate(((-half + 0.6, 2.5), (-half + 0.6, -2.5),
+                              (half - 0.6, 2.5), (half - 0.6, -2.5))):
+    cube(f"Sconce_{i}", (tx, ty, 3.0), (0.15, 0.15, 0.4), wood)
+    bpy.ops.mesh.primitive_uv_sphere_add(radius=0.32, segments=12, ring_count=8,
+                                         location=(tx, ty, 3.5))
+    f = bpy.context.active_object; f.name = f"Flame_{i}"; f.data.materials.append(fire)
+
+bpy.ops.object.select_all(action="DESELECT")
+n = len(bpy.context.scene.objects)
+print(f"castle: {n} objects")
+`;
+
 // src/commands/asset-new.ts
 import fs26 from "fs";
 import fsp from "fs/promises";
@@ -22054,6 +22191,8 @@ function parseArgs(argv) {
     "--image",
     "--granularity",
     "--preset",
+    // `genex blender` (M1 spike): which shading the contact sheet uses.
+    "--mode",
     // `genex ui` string flags (the numeric ones come from UI_NUMBER_FLAGS).
     "--in",
     "--out-dir",
@@ -22583,6 +22722,9 @@ function applyValueFlag(options, flag, value) {
     case "--last-frame":
       options.lastFrameUrl = value;
       break;
+    case "--mode":
+      options.mode = value;
+      break;
     case "--in":
       options.input = value;
       break;
@@ -22638,7 +22780,8 @@ async function main() {
     log.plain(mode === "tools" ? HELP_TOOLS : HELP);
     return;
   }
-  const quietUpdates = Boolean(parsed.options.quiet || parsed.options.json);
+  const isBlenderMcp = parsed.command === "blender" && parsed.options.name === "mcp";
+  const quietUpdates = Boolean(parsed.options.quiet || parsed.options.json || isBlenderMcp);
   const updateLog = createLogger({ quiet: quietUpdates });
   if (parsed.command !== "init" && parsed.command !== "tools") {
     await syncSkills(updateLog, mode);
@@ -22809,6 +22952,12 @@ async function main() {
       case "ui":
         await runUi({ ...parsed.options, sub: parsed.options.name });
         break;
+      // HIDDEN from --help: the M1 test surface for the Blender service spike
+      // (apps/blender-service). Gated on GENEX_BLENDER_URL, which no hosted
+      // stand sets, so this is a local-only verb until that service is real.
+      case "blender":
+        process.exitCode = await runBlender({ ...parsed.options, sub: parsed.options.name });
+        break;
       // PARKED (AG-824 D12) — still dispatches, deliberately unlisted in --help
       // and gone from the skills, the same way `genex explore` is parked.
       //