@genex-ai/cli-demo 1.6.4-dev.433 → 1.6.6-dev.435

package/dist/index.js

@@ -1829,8 +1829,159 @@ 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";
+
+// src/utils/run.ts
+import { spawn as spawn3 } from "child_process";
+var WIN_SHELL_COMMANDS = /* @__PURE__ */ new Set(["npm", "npx"]);
+function run(cmd, args, env) {
+  const shell = process.platform === "win32" && WIN_SHELL_COMMANDS.has(cmd);
+  return new Promise((resolve) => {
+    let child;
+    try {
+      child = spawn3(cmd, args, { env: env ? { ...process.env, ...env } : process.env, shell });
+    } catch {
+      resolve({ code: -1, out: "", err: `${cmd} not found` });
+      return;
+    }
+    let out = "";
+    let err = "";
+    child.stdout?.on("data", (d) => out += String(d));
+    child.stderr?.on("data", (d) => err += String(d));
+    child.on("error", () => resolve({ code: -1, out, err: `${cmd} not found` }));
+    child.on("close", (code2) => resolve({ code: code2 ?? -1, out, err }));
+  });
+}
+
+// src/lib/source-sync.ts
+async function readRemoteSource(apiUrl, token, projectId) {
+  try {
+    const res = await apiFetch(`${apiUrl}/api/projects/${projectId}`, {
+      headers: { Authorization: `Bearer ${token}` }
+    });
+    if (!res.ok) return null;
+    const data = await res.json().catch(() => null);
+    if (!data?.project) return null;
+    return {
+      stagingCommit: data.project.stagingCommitSha ?? null,
+      commit: data.project.commitSha ?? null
+    };
+  } catch {
+    return null;
+  }
+}
+function isStale(local, remote) {
+  if (!local || !remote) return false;
+  return local !== remote;
+}
+function reportStale(log, slug, local, remote) {
+  log.error(`${c.cyan(slug)} was updated from another device \u2014 nothing was deployed.`);
+  if (remote && local) {
+    log.dim(`  the draft is on ${remote.slice(0, 7)}, this folder last shipped ${local.slice(0, 7)}`);
+  }
+  log.dim(`  ${c.cyan("npx genex pull")} \u2014 take the other device's work (refuses if you have unshipped changes)`);
+  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 base = { GIT_DIR: gitDir };
+  try {
+    if ((await run("git", ["init", "-q"], base)).code !== 0) return null;
+    await fs11.writeFile(
+      path11.join(gitDir, "info", "exclude"),
+      ["node_modules/", "dist/", ".git/", ".genex/", ".env", ".env.*", "!.env.example", ""].join("\n")
+    );
+    if ((await run("git", ["lfs", "version"], base)).code === 0) {
+      const filters = [
+        ["filter.lfs.clean", "git-lfs clean -- %f"],
+        ["filter.lfs.smudge", "git-lfs smudge -- %f"],
+        ["filter.lfs.process", "git-lfs filter-process"],
+        ["filter.lfs.required", "true"]
+      ];
+      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") };
+    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(() => {
+    });
+  }
+}
+function urlHasEmbeddedCredentials(url) {
+  return /^[a-z][a-z0-9+.-]*:\/\/[^/@]+@/i.test(url);
+}
+function credentialHelperOff(url) {
+  if (!urlHasEmbeddedCredentials(url)) return {};
+  return { GIT_CONFIG_COUNT: "1", GIT_CONFIG_KEY_0: "credential.helper", GIT_CONFIG_VALUE_0: "" };
+}
+async function fetchCloneGrant(apiUrl, token, projectId, log) {
+  let res;
+  try {
+    res = await apiFetch(`${apiUrl}/api/projects/${projectId}/push-token`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${token}` }
+    });
+  } catch (err) {
+    log.error(`Couldn't reach the API to authorize the source read: ${String(err)}`);
+    return null;
+  }
+  if (res.status === 401) {
+    log.error("Not authorized \u2014 your token may have expired. Re-run `genex auth`.");
+    return null;
+  }
+  if (!res.ok) {
+    log.error(`Couldn't authorize the source read (HTTP ${res.status}).`);
+    return null;
+  }
+  const data = await res.json().catch(() => null);
+  const url = data?.pushUrl ?? data?.cloneUrl;
+  if (!url) {
+    log.error("The API didn't return a source URL.");
+    return null;
+  }
+  return { cloneUrl: url, sourceRef: data?.sourceRef ?? null };
+}
+async function cloneSource(grant, dest, log) {
+  const args = grant.sourceRef ? ["clone", "--branch", grant.sourceRef, grant.cloneUrl, dest] : ["clone", grant.cloneUrl, dest];
+  const env = {
+    GIT_LFS_SKIP_SMUDGE: "1",
+    GIT_TERMINAL_PROMPT: "0",
+    ...credentialHelperOff(grant.cloneUrl)
+  };
+  const cloned = await run("git", args, env);
+  if (cloned.code !== 0) {
+    log.error("Couldn't download the game's source.");
+    log.dim(`  git clone exited ${cloned.code}`);
+    return false;
+  }
+  const repo = { ...env, GIT_DIR: path11.join(dest, ".git"), GIT_WORK_TREE: dest };
+  const filters = [
+    ["filter.lfs.clean", "git-lfs clean -- %f"],
+    ["filter.lfs.smudge", "git-lfs smudge -- %f"],
+    ["filter.lfs.process", "git-lfs filter-process"],
+    ["filter.lfs.required", "true"]
+  ];
+  for (const [key, value] of filters) await run("git", ["config", key, value], repo);
+  const pulled = await run("git", ["lfs", "pull"], repo);
+  if (pulled.code !== 0) {
+    log.warn("Binary assets (models, textures, audio) are still pointer files \u2014 `git lfs pull` failed.");
+    log.dim("  The source is there; run `git lfs pull` in this folder once git-lfs works.");
+  }
+  return true;
+}
+
+// src/commands/link.ts
 async function runLink(opts) {
   const log = createLogger({ quiet: opts.quiet });
   log.plain(c.bold("genex link"));
@@ -1878,7 +2029,9 @@ async function runLink(opts) {
     process.exitCode = 1;
     return;
   }
+  const wasEmpty = await isEmptyDir(process.cwd());
   await writeGitignore(process.cwd(), log);
+  const cloned = wasEmpty ? await downloadSource(apiUrl, token, project, log) : false;
   const meta = {
     id: project.id,
     slug: project.slug,
@@ -1892,30 +2045,72 @@ async function runLink(opts) {
   log.dim(`  saved ${c.cyan(metaPath)}`);
   await writeGameConfigFiles(meta, log);
   await ensureSlugEnv(project.slug, log);
+  if (cloned) {
+    const remote = await readRemoteSource(apiUrl, token, project.id);
+    const tree = await sourceTreeHash(process.cwd());
+    if (remote?.stagingCommit) meta.stagingCommit = remote.stagingCommit;
+    if (tree) meta.sourceTree = tree;
+    await writeProject(meta);
+  }
   log.plain("");
   log.success(
     `Linked. This folder now updates ${c.cyan(project.slug)} \u2014 \`npx genex preview\` / \`publish\` ship to the same live game.`
   );
+  if (cloned) log.dim(`  Run ${c.cyan("npm install")}, then keep building.`);
   if (project.playUrl) log.dim(`  play URL: ${project.playUrl}`);
 }
+async function isEmptyDir(cwd) {
+  try {
+    const entries = await fs12.readdir(cwd);
+    return entries.every((e) => e === ".git" || e === ".genex" || e === ".DS_Store");
+  } catch {
+    return false;
+  }
+}
+async function downloadSource(apiUrl, token, project, log) {
+  const grant = await fetchCloneGrant(apiUrl, token, project.id, log);
+  if (!grant) return false;
+  if (!grant.sourceRef) {
+    log.dim("  (no source saved for this game yet \u2014 nothing to download)");
+    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");
+  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), {
+        recursive: true,
+        force: true
+      });
+    }
+    log.success("Downloaded.");
+    return true;
+  } finally {
+    await fs12.rm(staging, { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
 async function ensureSlugEnv(slug, log, cwd = process.cwd()) {
-  const file = path11.join(cwd, ".env");
+  const file = path12.join(cwd, ".env");
   let content;
   try {
-    content = await fs11.readFile(file, "utf8");
+    content = await fs12.readFile(file, "utf8");
   } catch {
     return;
   }
   const re = /^(\s*VITE_GENEX_SLUG=)(.*)$/m;
   const m = content.match(re);
   if (!m) {
-    await fs11.appendFile(file, `${content.endsWith("\n") ? "" : "\n"}VITE_GENEX_SLUG=${slug}
+    await fs12.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 fs11.writeFile(file, content.replace(re, `$1${slug}`));
+  await fs12.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) {
@@ -1968,9 +2163,109 @@ async function listOwnSlugs(apiUrl, token, log) {
   }
 }
 
+// src/commands/pull.ts
+import fs13 from "fs/promises";
+import path13 from "path";
+import os8 from "os";
+function isMachineLocal(entry) {
+  if (entry === ".genex" || entry === "node_modules" || entry === ".git") return true;
+  if (entry === ".env.example") return false;
+  return entry === ".env" || entry.startsWith(".env.");
+}
+async function runPull(opts) {
+  const log = createLogger({ quiet: opts.quiet });
+  const cwd = process.cwd();
+  log.plain(c.bold("genex pull"));
+  log.plain("");
+  const meta = await readProject(cwd);
+  if (!meta) {
+    log.error("This folder isn't linked to a game.");
+    log.dim(`  Run ${c.cyan("npx genex link <slug>")} here, or in an empty folder to download it.`);
+    process.exitCode = 1;
+    return;
+  }
+  const token = await readUserToken(opts.envPath);
+  if (!token) {
+    log.error(`Not signed in. Run ${c.cyan("npx genex auth")} first.`);
+    process.exitCode = 1;
+    return;
+  }
+  const apiUrl = getApiUrl(opts.apiUrl ?? meta.apiUrl);
+  if (!opts.force) {
+    const tree2 = await sourceTreeHash(cwd);
+    if (!meta.sourceTree) {
+      log.error("This folder has never deployed, so there's no way to tell what's unsaved here.");
+      log.dim(`  ${c.cyan("npx genex preview")} first to save it, or ${c.cyan("npx genex pull --force")} to discard it.`);
+      process.exitCode = 1;
+      return;
+    }
+    if (tree2 === null) {
+      log.error("Couldn't check this folder for unsaved changes (git is unavailable).");
+      log.dim(`  ${c.cyan("npx genex pull --force")} replaces it anyway.`);
+      process.exitCode = 1;
+      return;
+    }
+    if (tree2 !== meta.sourceTree) {
+      log.error("This folder has changes that were never deployed.");
+      log.dim(`  ${c.cyan("npx genex preview")} ships them first (add ${c.cyan("--force")} if it says another device updated this)`);
+      log.dim(`  ${c.cyan("npx genex pull --force")} throws them away and takes the draft`);
+      process.exitCode = 1;
+      return;
+    }
+  }
+  log.step(`Fetching ${c.cyan(meta.slug)}\u2026`);
+  const grant = await fetchCloneGrant(apiUrl, token, meta.id, log);
+  if (!grant) {
+    process.exitCode = 1;
+    return;
+  }
+  if (!grant.sourceRef) {
+    log.error(`${c.cyan(meta.slug)} has no source saved yet \u2014 nothing to pull.`);
+    log.dim(`  Run ${c.cyan("npx genex preview")} on the machine that has the game.`);
+    process.exitCode = 1;
+    return;
+  }
+  const staging = await fs13.mkdtemp(path13.join(os8.tmpdir(), "genex-pull-"));
+  const fresh = path13.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 replaceTree(cwd, fresh);
+  } finally {
+    await fs13.rm(staging, { recursive: true, force: true }).catch(() => {
+    });
+  }
+  const remote = await readRemoteSource(apiUrl, token, meta.id);
+  const tree = await sourceTreeHash(cwd);
+  await writeProject(
+    {
+      ...meta,
+      ...remote?.stagingCommit ? { stagingCommit: remote.stagingCommit } : {},
+      ...tree ? { sourceTree: tree } : {}
+    },
+    cwd
+  );
+  log.plain("");
+  log.success(`Pulled ${c.cyan(meta.slug)}${grant.sourceRef === "preview" ? " (draft)" : ""}.`);
+  log.dim(`  Run ${c.cyan("npm install")} if dependencies changed, then keep building.`);
+}
+async function replaceTree(dest, src) {
+  for (const entry of await fs13.readdir(dest)) {
+    if (isMachineLocal(entry)) continue;
+    await fs13.rm(path13.join(dest, entry), { recursive: true, force: true });
+  }
+  for (const entry of await fs13.readdir(src)) {
+    if (isMachineLocal(entry)) continue;
+    await fs13.cp(path13.join(src, entry), path13.join(dest, entry), { recursive: true });
+  }
+}
+
 // src/commands/rename.ts
-import fs12 from "fs/promises";
-import path12 from "path";
+import fs14 from "fs/promises";
+import path14 from "path";
 async function runRename(opts) {
   const log = createLogger({ quiet: opts.quiet });
   log.plain(c.bold("genex rename"));
@@ -2058,23 +2353,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 = path12.join(cwd, ".env");
+  const file = path14.join(cwd, ".env");
   let content;
   try {
-    content = await fs12.readFile(file, "utf8");
+    content = await fs14.readFile(file, "utf8");
   } catch {
     return;
   }
   const re = /^(\s*VITE_GENEX_SLUG=)(.*)$/m;
   if (!re.test(content)) return;
-  await fs12.writeFile(file, content.replace(re, `$1${to}`));
+  await fs14.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 = path12.join(cwd, "src", "genex.config.ts");
+  const file = path14.join(cwd, "src", "genex.config.ts");
   let content;
   try {
-    content = await fs12.readFile(file, "utf8");
+    content = await fs14.readFile(file, "utf8");
   } catch {
     return;
   }
@@ -2084,7 +2379,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 fs12.writeFile(file, content.replace(quoted, `"${to}"`));
+  await fs14.writeFile(file, content.replace(quoted, `"${to}"`));
   log.dim(`  src/genex.config.ts: baked slug -> ${to}`);
 }
 
@@ -2212,11 +2507,11 @@ function relTime(iso) {
 }
 
 // src/lib/deploy.ts
-import { spawn as spawn3 } from "child_process";
+import "child_process";
 import crypto3 from "crypto";
-import fs15 from "fs/promises";
-import os6 from "os";
-import path14 from "path";
+import fs17 from "fs/promises";
+import os9 from "os";
+import path16 from "path";
 
 // ../../packages/mobile-scan/src/image-dims.ts
 function u32be(b, o) {
@@ -2480,12 +2775,12 @@ function tierFor(estVramMb) {
 }
 
 // src/commands/ui.ts
-import fs14 from "fs/promises";
-import path13 from "path";
+import fs16 from "fs/promises";
+import path15 from "path";
 import { PNG as PNG2 } from "pngjs";
 
 // src/lib/png-tools.ts
-import fs13 from "fs/promises";
+import fs15 from "fs/promises";
 import { PNG } from "pngjs";
 var ALPHA_TRANSPARENT_MAX = 16;
 var isHttpUrl = (s) => /^https?:\/\//i.test(s);
@@ -2496,12 +2791,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 fs13.readFile(input);
+    buf = await fs15.readFile(input);
   }
   return PNG.sync.read(buf);
 }
 async function writePng(file, png) {
-  await fs13.writeFile(file, PNG.sync.write(png));
+  await fs15.writeFile(file, PNG.sync.write(png));
 }
 function cropPng(image, box) {
   const out = new PNG({ width: box.w, height: box.h });
@@ -2801,7 +3096,7 @@ async function uiExtract(opts, log) {
   const dilatePx = opts.dilate ?? 0;
   const sheet = await loadPng(input);
   const { width: W, height: H, data } = sheet;
-  await fs14.mkdir(outDir, { recursive: true });
+  await fs16.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;
@@ -3030,7 +3325,7 @@ async function uiExtract(opts, log) {
         rimPixels: speckle.sampled
       });
     }
-    const outPath = path13.join(outDir, `${name}.png`);
+    const outPath = path15.join(outDir, `${name}.png`);
     await writePng(outPath, out);
     const sidecar = {
       name,
@@ -3049,7 +3344,7 @@ async function uiExtract(opts, log) {
       defringed
     };
     const { name: _n, out: _o, ...sidecarBody } = sidecar;
-    await fs14.writeFile(
+    await fs16.writeFile(
       outPath.replace(/\.png$/i, "") + ".bbox.json",
       JSON.stringify(sidecarBody, null, 2)
     );
@@ -3058,8 +3353,8 @@ async function uiExtract(opts, log) {
       `${name}.png  ${cropW}x${cropH} (ar ${sidecar.aspectRatio}) at sheet ${padX0},${padY0}`
     );
   }
-  const debugPath = path13.join(outDir, "extract-debug.json");
-  await fs14.writeFile(
+  const debugPath = path15.join(outDir, "extract-debug.json");
+  await fs16.writeFile(
     debugPath,
     JSON.stringify(
       {
@@ -3521,7 +3816,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 fs14.mkdir(outDir, { recursive: true });
+  await fs16.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);
@@ -3574,11 +3869,11 @@ async function uiMasks(opts, log) {
       });
     }
     const overlay = makeOverlay(clean2, converted.png);
-    const framePath = path13.join(outDir, `${pair.name}-frame.png`);
-    const maskPath = path13.join(outDir, `${pair.name}-mask.png`);
-    const annotatedPath = path13.join(outDir, `${pair.name}-annotated-source.png`);
-    const overlayPath = path13.join(outDir, `${pair.name}-overlay.png`);
-    const metaPath = path13.join(outDir, `${pair.name}.annotated-progress.json`);
+    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`);
     await writePng(framePath, clean2);
     await writePng(maskPath, converted.png);
     await writePng(annotatedPath, annotated);
@@ -3625,7 +3920,7 @@ async function uiMasks(opts, log) {
       },
       overlay: overlayPath
     };
-    await fs14.writeFile(metaPath, `${JSON.stringify(meta, null, 2)}
+    await fs16.writeFile(metaPath, `${JSON.stringify(meta, null, 2)}
 `);
     results.push(meta);
     const fb = converted.bbox;
@@ -3641,8 +3936,8 @@ async function uiMasks(opts, log) {
       );
     }
   }
-  const indexPath = path13.join(outDir, "annotated-progress.json");
-  await fs14.writeFile(indexPath, `${JSON.stringify({ input, loosened, pairs: results }, null, 2)}
+  const indexPath = path15.join(outDir, "annotated-progress.json");
+  await fs16.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}).`);
@@ -3768,7 +4063,7 @@ async function uiTextColor(opts, log) {
   };
   process.stdout.write(`${JSON.stringify(result, null, 2)}
 `);
-  if (opts.out) await fs14.writeFile(opts.out, `${JSON.stringify(result, null, 2)}
+  if (opts.out) await fs16.writeFile(opts.out, `${JSON.stringify(result, null, 2)}
 `);
   if (opts.cropPath) log.dim(`  crop \u2192 ${opts.cropPath}`);
 }
@@ -3800,7 +4095,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 fs14.writeFile(
+  await fs16.writeFile(
     sidecarPath,
     JSON.stringify(speckleAllowed ? { ...sidecar, speckleAllowed: true } : sidecar, null, 2)
   );
@@ -3907,7 +4202,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 = path13.basename(outPath);
+  const name = path15.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):");
@@ -4072,13 +4367,13 @@ async function walkFiles(dir) {
   const out = [];
   let entries;
   try {
-    entries = await fs14.readdir(dir, { withFileTypes: true });
+    entries = await fs16.readdir(dir, { withFileTypes: true });
   } catch {
     return out;
   }
   for (const entry of entries) {
     if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
-    const p = path13.join(dir, entry.name);
+    const p = path15.join(dir, entry.name);
     if (entry.isDirectory()) out.push(...await walkFiles(p));
     else out.push(p);
   }
@@ -4087,7 +4382,7 @@ async function walkFiles(dir) {
 async function collectUiAuditFindings(assetDir, srcDir, cwd = process.cwd()) {
   const viewportFindings = [];
   try {
-    const indexHtml = await fs14.readFile(path13.join(cwd, "index.html"), "utf8");
+    const indexHtml = await fs16.readFile(path15.join(cwd, "index.html"), "utf8");
     if (!/<meta[^>]+name=["']viewport["']/i.test(indexHtml)) {
       viewportFindings.push({
         kind: "viewport-meta",
@@ -4101,28 +4396,28 @@ async function collectUiAuditFindings(assetDir, srcDir, cwd = process.cwd()) {
     }
   } catch {
   }
-  const absAssets = path13.resolve(cwd, assetDir);
+  const absAssets = path15.resolve(cwd, assetDir);
   try {
-    if (!(await fs14.stat(absAssets)).isDirectory()) {
+    if (!(await fs16.stat(absAssets)).isDirectory()) {
       return viewportFindings.length > 0 ? viewportFindings : null;
     }
   } catch {
     return viewportFindings.length > 0 ? viewportFindings : null;
   }
-  const srcFiles = (await walkFiles(path13.resolve(cwd, srcDir))).filter(
-    (p) => AUDIT_SRC_EXTS.has(path13.extname(p).toLowerCase())
+  const srcFiles = (await walkFiles(path15.resolve(cwd, srcDir))).filter(
+    (p) => AUDIT_SRC_EXTS.has(path15.extname(p).toLowerCase())
   );
   try {
-    for (const name of await fs14.readdir(cwd)) {
-      const ext = path13.extname(name).toLowerCase();
-      if (ext === ".html" || ext === ".css") srcFiles.push(path13.join(cwd, name));
+    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));
     }
   } catch {
   }
   const sources = [];
   for (const p of srcFiles) {
     try {
-      sources.push({ rel: path13.relative(cwd, p), text: await fs14.readFile(p, "utf8") });
+      sources.push({ rel: path15.relative(cwd, p), text: await fs16.readFile(p, "utf8") });
     } catch {
     }
   }
@@ -4132,11 +4427,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 = path13.basename(p);
+    const base = path15.basename(p);
     const metaMatch = /^(.+)\.annotated-progress\.json$/.exec(base);
     if (metaMatch) {
       try {
-        const meta = JSON.parse(await fs14.readFile(p, "utf8"));
+        const meta = JSON.parse(await fs16.readFile(p, "utf8"));
         metaByName.set(metaMatch[1], {
           cleanCrop: meta.clean?.crop ?? null,
           loosened: meta.loosened === true
@@ -4147,7 +4442,7 @@ async function collectUiAuditFindings(assetDir, srcDir, cwd = process.cwd()) {
     }
     if (base.endsWith(".bbox.json")) {
       try {
-        const sidecar = JSON.parse(await fs14.readFile(p, "utf8"));
+        const sidecar = JSON.parse(await fs16.readFile(p, "utf8"));
         if (sidecar.sheetBBox) bboxByPng.set(base.replace(/\.bbox\.json$/, ".png"), sidecar.sheetBBox);
       } catch {
       }
@@ -4156,7 +4451,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 = path13.basename(p);
+      const base = path15.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;
@@ -4180,7 +4475,7 @@ async function collectUiAuditFindings(assetDir, srcDir, cwd = process.cwd()) {
   }
   const pngByBase = /* @__PURE__ */ new Map();
   for (const p of assetFiles) {
-    const base = path13.basename(p);
+    const base = path15.basename(p);
     if (base.toLowerCase().endsWith(".png")) pngByBase.set(base, p);
   }
   for (const [maskBase, maskPath] of pngByBase) {
@@ -4193,8 +4488,8 @@ async function collectUiAuditFindings(assetDir, srcDir, cwd = process.cwd()) {
       let frame;
       let mask;
       try {
-        frame = PNG2.sync.read(await fs14.readFile(framePath));
-        mask = PNG2.sync.read(await fs14.readFile(maskPath));
+        frame = PNG2.sync.read(await fs16.readFile(framePath));
+        mask = PNG2.sync.read(await fs16.readFile(maskPath));
       } catch {
         continue;
       }
@@ -4213,7 +4508,7 @@ async function collectUiAuditFindings(assetDir, srcDir, cwd = process.cwd()) {
     if (!referenced(base)) continue;
     let png;
     try {
-      png = PNG2.sync.read(await fs14.readFile(p));
+      png = PNG2.sync.read(await fs16.readFile(p));
     } catch {
       continue;
     }
@@ -4233,7 +4528,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(path13.basename(p));
+    const m = /^(.+)\.annotated-progress\.json$/.exec(path15.basename(p));
     if (!m) continue;
     const maskBase = `${m[1]}-mask.png`;
     if (!referenced(maskBase)) {
@@ -4245,14 +4540,14 @@ async function collectUiAuditFindings(assetDir, srcDir, cwd = process.cwd()) {
     }
   }
   for (const p of assetFiles) {
-    const base = path13.basename(p);
+    const base = path15.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: `${path13.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: `${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.)`
       });
     }
   }
@@ -4305,25 +4600,6 @@ async function uiAudit(opts, log) {
 }
 
 // src/lib/deploy.ts
-var WIN_SHELL_COMMANDS = /* @__PURE__ */ new Set(["npm", "npx"]);
-function run(cmd, args, env) {
-  const shell = process.platform === "win32" && WIN_SHELL_COMMANDS.has(cmd);
-  return new Promise((resolve) => {
-    let child;
-    try {
-      child = spawn3(cmd, args, { env: env ? { ...process.env, ...env } : process.env, shell });
-    } catch {
-      resolve({ code: -1, out: "", err: `${cmd} not found` });
-      return;
-    }
-    let out = "";
-    let err = "";
-    child.stdout?.on("data", (d) => out += String(d));
-    child.stderr?.on("data", (d) => err += String(d));
-    child.on("error", () => resolve({ code: -1, out, err: `${cmd} not found` }));
-    child.on("close", (code2) => resolve({ code: code2 ?? -1, out, err }));
-  });
-}
 function printMobilePreflight(files, log) {
   try {
     const scan = scanBundle(files.map((f) => ({ relPath: f.relPath, bytes: f.bytes })));
@@ -4386,7 +4662,7 @@ async function printUiAuditPreflight(log) {
 }
 async function printPipelineStatePreflight(log, cwd = process.cwd()) {
   try {
-    const design = await fs15.readFile(path14.join(cwd, "DESIGN.md"), "utf8").catch(() => "");
+    const design = await fs17.readFile(path16.join(cwd, "DESIGN.md"), "utf8").catch(() => "");
     const warnings = [];
     if (design.length > 0 && !/##\s*build plan & status/i.test(design)) {
       warnings.push(
@@ -4394,7 +4670,7 @@ async function printPipelineStatePreflight(log, cwd = process.cwd()) {
       );
     }
     if (!/player character:/i.test(design)) {
-      const hasCharacter = await fs15.access(path14.join(cwd, "public", "assets", "meshy-character.json")).then(() => true, () => false);
+      const hasCharacter = await fs17.access(path16.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).`
@@ -4408,12 +4684,12 @@ async function printPipelineStatePreflight(log, cwd = process.cwd()) {
 async function loadsPlayerBody(cwd) {
   const BODY_LOADERS = /\bloadPlayerCharacter\s*\(|\bloadVrm(?:Clone)?\s*\(/;
   try {
-    const entries = await fs15.readdir(path14.join(cwd, "src"), { recursive: true });
+    const entries = await fs17.readdir(path16.join(cwd, "src"), { recursive: true });
     for (const rel of entries) {
       if (rel.includes("node_modules")) continue;
-      if (rel.split(path14.sep)[0] === "controllers" || rel.startsWith("controllers/")) continue;
+      if (rel.split(path16.sep)[0] === "controllers" || rel.startsWith("controllers/")) continue;
       if (!/\.(ts|tsx|js|jsx)$/.test(rel)) continue;
-      const text = await fs15.readFile(path14.join(cwd, "src", rel), "utf8").catch(() => "");
+      const text = await fs17.readFile(path16.join(cwd, "src", rel), "utf8").catch(() => "");
       if (BODY_LOADERS.test(text)) return true;
     }
   } catch {
@@ -4426,6 +4702,15 @@ function isSecretEnvFile(name) {
 }
 async function deployGame(ctx, opts, log) {
   const cwd = process.cwd();
+  const meta = await readProject(cwd);
+  const expectStagingCommit = opts.force ? void 0 : meta?.stagingCommit;
+  if (expectStagingCommit) {
+    const remote = await readRemoteSource(ctx.apiUrl, ctx.token, ctx.projectId);
+    if (remote && isStale(expectStagingCommit, remote.stagingCommit)) {
+      reportStale(log, ctx.slug ?? meta?.slug ?? "this game", expectStagingCommit, remote.stagingCommit);
+      return false;
+    }
+  }
   if (!opts.noBuild && await hasBuildScript(cwd)) {
     log.step("Building the production bundle\u2026");
     const built = await run("npm", ["run", "build"]);
@@ -4437,9 +4722,9 @@ async function deployGame(ctx, opts, log) {
     }
     log.success("Built.");
   }
-  const distDir = path14.join(cwd, "dist");
+  const distDir = path16.join(cwd, "dist");
   const siteDir = await isDir2(distDir) ? distDir : cwd;
-  const rel = path14.relative(cwd, siteDir) || ".";
+  const rel = path16.relative(cwd, siteDir) || ".";
   if (siteDir === cwd) await writeGitignore(cwd, log);
   const files = await collectFiles(siteDir);
   if (files.length === 0) {
@@ -4495,10 +4780,28 @@ async function deployGame(ctx, opts, log) {
     log.error("Couldn't upload your game \u2014 please try again.");
     return false;
   }
-  if (!await pushSource(cwd, ctx, log, opts.channel === "staging" ? "preview" : "main")) return false;
+  const pushed = await pushSource(
+    cwd,
+    ctx,
+    log,
+    opts.channel === "staging" ? "preview" : "main",
+    expectStagingCommit
+  );
+  if (pushed !== true) return false;
   log.step("Publishing\u2026");
   const published = await callPublish(ctx, commit, opts, log);
   if (!published) return false;
+  if (opts.channel === "staging") {
+    const tree = await sourceTreeHash(cwd);
+    const current = await readProject(cwd);
+    if (current) {
+      await writeProject(
+        { ...current, stagingCommit: commit, ...tree ? { sourceTree: tree } : {} },
+        cwd
+      ).catch(() => {
+      });
+    }
+  }
   const index = files.find((f) => f.relPath === "index.html");
   const liveUrl = published.url || grant.playUrl;
   await waitUntilLive(liveUrl, fingerprintOf(index.bytes.toString("utf8")), opts.liveTimeoutMs ?? 2e4, log);
@@ -4506,7 +4809,7 @@ async function deployGame(ctx, opts, log) {
 }
 async function hasBuildScript(cwd) {
   try {
-    const pkg = JSON.parse(await fs15.readFile(path14.join(cwd, "package.json"), "utf8"));
+    const pkg = JSON.parse(await fs17.readFile(path16.join(cwd, "package.json"), "utf8"));
     return Boolean(pkg.scripts?.build);
   } catch {
     return false;
@@ -4515,12 +4818,12 @@ async function hasBuildScript(cwd) {
 async function collectFiles(root) {
   const out = [];
   const walk2 = async (dir, prefix) => {
-    for (const e of await fs15.readdir(dir, { withFileTypes: true })) {
+    for (const e of await fs17.readdir(dir, { withFileTypes: true })) {
       const relPath = prefix ? `${prefix}/${e.name}` : e.name;
       if (e.isDirectory()) {
-        if (!EXCLUDE_DIRS.has(e.name)) await walk2(path14.join(dir, e.name), relPath);
+        if (!EXCLUDE_DIRS.has(e.name)) await walk2(path16.join(dir, e.name), relPath);
       } else if (e.isFile() && !isSecretEnvFile(e.name)) {
-        out.push({ relPath, bytes: await fs15.readFile(path14.join(dir, e.name)) });
+        out.push({ relPath, bytes: await fs17.readFile(path16.join(dir, e.name)) });
       }
     }
   };
@@ -4737,28 +5040,27 @@ async function callPublish(ctx, commit, opts, log) {
   }
   return { url: body?.url ?? "" };
 }
-async function pushSource(cwd, ctx, log, branch = "main") {
-  const target = await fetchPushUrl(ctx, log);
+async function pushSource(cwd, ctx, log, branch = "main", expectStagingCommit) {
+  const target = await fetchPushUrl(ctx, log, expectStagingCommit);
+  if (target === "stale") return "stale";
   if (!target) return false;
   const ref = target.managed ? branch : "main";
   if (await pushWorktree(cwd, target.pushUrl, target.managed, log, ref)) return true;
   if (!target.managed) return false;
   log.info("Retrying the source push\u2026");
   await new Promise((r) => setTimeout(r, 2e3));
-  const fresh = await fetchPushUrl(ctx, log);
+  const fresh = await fetchPushUrl(ctx, log, expectStagingCommit);
+  if (fresh === "stale") return "stale";
   if (!fresh) return false;
   return pushWorktree(cwd, fresh.pushUrl, fresh.managed, log, ref);
 }
-function urlHasEmbeddedCredentials(pushUrl) {
-  return /^[a-z][a-z0-9+.-]*:\/\/[^/@]+@/i.test(pushUrl);
-}
 async function pushWorktree(cwd, pushUrl, managed, log, branch = "main") {
   const EMPTY_TREE = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
   const failed = () => {
     log.error("Couldn't save your game's source \u2014 please try again.");
     return false;
   };
-  const gitDir = await fs15.mkdtemp(path14.join(os6.tmpdir(), "genex-source-"));
+  const gitDir = await fs17.mkdtemp(path16.join(os9.tmpdir(), "genex-source-"));
   const base = { GIT_DIR: gitDir };
   if (urlHasEmbeddedCredentials(pushUrl)) {
     base.GIT_CONFIG_COUNT = "1";
@@ -4773,12 +5075,12 @@ async function pushWorktree(cwd, pushUrl, managed, log, branch = "main") {
   };
   try {
     if ((await run("git", ["init", "-q"], base)).code !== 0) return failed();
-    await fs15.writeFile(
-      path14.join(gitDir, "info", "exclude"),
+    await fs17.writeFile(
+      path16.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: path14.join(gitDir, "index-source") };
+    const env = { ...base, GIT_WORK_TREE: cwd, GIT_INDEX_FILE: path16.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");
@@ -4829,16 +5131,19 @@ async function pushWorktree(cwd, pushUrl, managed, log, branch = "main") {
   } catch {
     return failed();
   } finally {
-    await fs15.rm(gitDir, { recursive: true, force: true }).catch(() => {
+    await fs17.rm(gitDir, { recursive: true, force: true }).catch(() => {
     });
   }
 }
-async function fetchPushUrl(ctx, log) {
+async function fetchPushUrl(ctx, log, expectStagingCommit) {
   let res;
   try {
     res = await apiFetch(`${ctx.apiUrl}/api/projects/${ctx.projectId}/push-token`, {
       method: "POST",
-      headers: { Authorization: `Bearer ${ctx.token}` }
+      headers: {
+        Authorization: `Bearer ${ctx.token}`,
+        ...expectStagingCommit ? { "If-Match": expectStagingCommit } : {}
+      }
     });
   } catch (err) {
     log.error(`Couldn't reach the API to authorize the source push: ${String(err)}`);
@@ -4848,6 +5153,11 @@ async function fetchPushUrl(ctx, log) {
     log.error("Not authorized \u2014 your token may have expired. Re-run `genex init`.");
     return null;
   }
+  if (res.status === 409) {
+    const body = await res.json().catch(() => null);
+    reportStale(log, ctx.slug ?? "this game", expectStagingCommit, body?.stagingCommit ?? null);
+    return "stale";
+  }
   if (res.status === 429) {
     log.error(`Rate limited authorizing the source push (HTTP 429).${retryAfterHint(res)}`);
     return null;
@@ -4861,11 +5171,11 @@ async function fetchPushUrl(ctx, log) {
     log.error("The API didn't return a push URL.");
     return null;
   }
-  return { pushUrl: data.pushUrl, managed: data.managed !== false };
+  return { pushUrl: data.pushUrl, managed: data.managed !== false, sourceRef: data.sourceRef ?? null };
 }
 async function isDir2(p) {
   try {
-    return (await fs15.stat(p)).isDirectory();
+    return (await fs17.stat(p)).isDirectory();
   } catch {
     return false;
   }
@@ -5312,17 +5622,17 @@ async function promoteBuild(apiUrl, projectId, token, log) {
 }
 
 // src/lib/detect-features.ts
-import fs17 from "fs/promises";
-import path16 from "path";
+import fs19 from "fs/promises";
+import path18 from "path";
 
 // src/lib/generation-ledger.ts
-import fs16 from "fs/promises";
-import path15 from "path";
-var ledgerPath = (cwd) => path15.join(cwd, ".genex", "generations.ndjson");
+import fs18 from "fs/promises";
+import path17 from "path";
+var ledgerPath = (cwd) => path17.join(cwd, ".genex", "generations.ndjson");
 async function append(cwd, event) {
   try {
-    await fs16.access(path15.join(cwd, ".genex"));
-    await fs16.appendFile(ledgerPath(cwd), `${JSON.stringify(event)}
+    await fs18.access(path17.join(cwd, ".genex"));
+    await fs18.appendFile(ledgerPath(cwd), `${JSON.stringify(event)}
 `, "utf8");
   } catch {
   }
@@ -5330,7 +5640,7 @@ async function append(cwd, event) {
 async function readLedger(cwd = process.cwd()) {
   let raw;
   try {
-    raw = await fs16.readFile(ledgerPath(cwd), "utf8");
+    raw = await fs18.readFile(ledgerPath(cwd), "utf8");
   } catch {
     return [];
   }
@@ -5384,7 +5694,7 @@ async function countFailed(kind, cwd = process.cwd()) {
 // src/lib/detect-features.ts
 async function detectEmbedSdkVersion(cwd = process.cwd()) {
   try {
-    const raw = await fs17.readFile(path16.join(cwd, "package.json"), "utf8");
+    const raw = await fs19.readFile(path18.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;
@@ -5394,7 +5704,7 @@ async function detectEmbedSdkVersion(cwd = process.cwd()) {
 }
 async function detectMultiplayer(cwd = process.cwd()) {
   try {
-    const raw = await fs17.readFile(path16.join(cwd, "package.json"), "utf8");
+    const raw = await fs19.readFile(path18.join(cwd, "package.json"), "utf8");
     const pkg = JSON.parse(raw);
     return Boolean(
       pkg.dependencies?.["@genex-ai/multiplayer"] ?? pkg.devDependencies?.["@genex-ai/multiplayer"]
@@ -5406,7 +5716,7 @@ async function detectMultiplayer(cwd = process.cwd()) {
 async function detectMatchmaking(log, cwd = process.cwd()) {
   let pkg;
   try {
-    pkg = JSON.parse(await fs17.readFile(path16.join(cwd, "package.json"), "utf8"));
+    pkg = JSON.parse(await fs19.readFile(path18.join(cwd, "package.json"), "utf8"));
   } catch (err) {
     log.dim(`  (skipping matchmaking \u2014 couldn't read package.json: ${String(err)})`);
     return null;
@@ -5424,15 +5734,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 fs17.readFile(path16.join(cwd, "package.json"), "utf8");
+    const raw = await fs19.readFile(path18.join(cwd, "package.json"), "utf8");
     const pkg = JSON.parse(raw);
     if (pkg.genex?.mobileControls === true) return true;
   } catch {
   }
-  const srcDir = path16.join(cwd, "src");
+  const srcDir = path18.join(cwd, "src");
   let entries;
   try {
-    entries = await fs17.readdir(srcDir, { recursive: true });
+    entries = await fs19.readdir(srcDir, { recursive: true });
   } catch {
     return false;
   }
@@ -5440,7 +5750,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 fs17.readFile(path16.join(srcDir, rel), "utf8");
+      const content = await fs19.readFile(path18.join(srcDir, rel), "utf8");
       if (TOUCH_KIT_MARKERS.test(content)) return true;
     } catch {
     }
@@ -5449,10 +5759,10 @@ async function detectMobileControls(cwd = process.cwd()) {
 }
 var GAME_STATE_CALLS = /savePlayerState|saveWorldState|submitScore/;
 async function detectGameStateUsage(cwd = process.cwd()) {
-  const srcDir = path16.join(cwd, "src");
+  const srcDir = path18.join(cwd, "src");
   let entries;
   try {
-    entries = await fs17.readdir(srcDir, { recursive: true });
+    entries = await fs19.readdir(srcDir, { recursive: true });
   } catch {
     return false;
   }
@@ -5460,7 +5770,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 fs17.readFile(path16.join(srcDir, rel), "utf8");
+      const content = await fs19.readFile(path18.join(srcDir, rel), "utf8");
       if (GAME_STATE_CALLS.test(content)) return true;
     } catch {
     }
@@ -5509,19 +5819,19 @@ async function detectSurfaceScan(cwd = process.cwd()) {
     depthRange: [],
     mediaElementAudio: []
   };
-  const srcDir = path16.join(cwd, "src");
+  const srcDir = path18.join(cwd, "src");
   let entries;
   try {
-    entries = await fs17.readdir(srcDir, { recursive: true });
+    entries = await fs19.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 fs17.readFile(path16.join(srcDir, nativeRel), "utf8").catch(() => "");
+    const raw = await fs19.readFile(path18.join(srcDir, nativeRel), "utf8").catch(() => "");
     if (!raw) continue;
-    const rel = nativeRel.split(path16.sep).join("/");
+    const rel = nativeRel.split(path18.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;
@@ -5579,25 +5889,25 @@ async function detectGenerationAudit(cwd = process.cwd()) {
   let haystack = "";
   const read = async (file) => {
     try {
-      haystack += await fs17.readFile(file, "utf8");
+      haystack += await fs19.readFile(file, "utf8");
     } catch {
     }
   };
   try {
-    for (const entry of await fs17.readdir(cwd, { withFileTypes: true })) {
+    for (const entry of await fs19.readdir(cwd, { withFileTypes: true })) {
       if (entry.isFile() && /\.(ts|tsx|js|jsx|css|html|json)$/.test(entry.name)) {
-        await read(path16.join(cwd, entry.name));
+        await read(path18.join(cwd, entry.name));
       }
     }
   } catch {
   }
   for (const sub of ["src", "public"]) {
     try {
-      const entries = await fs17.readdir(path16.join(cwd, sub), { recursive: true });
+      const entries = await fs19.readdir(path18.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(path16.join(cwd, sub, rel));
+        await read(path18.join(cwd, sub, rel));
       }
     } catch {
     }
@@ -5729,7 +6039,7 @@ async function borrowEvidence(meta, cwd) {
   } catch {
     return true;
   }
-  const gitConfig = await fs17.readFile(path16.join(cwd, ".git", "config"), "utf8").catch(() => "");
+  const gitConfig = await fs19.readFile(path18.join(cwd, ".git", "config"), "utf8").catch(() => "");
   for (const m of gitConfig.matchAll(/url\s*=\s*(\S+)/g)) {
     try {
       const u = new URL(m[1]);
@@ -5737,7 +6047,7 @@ async function borrowEvidence(meta, cwd) {
     } catch {
     }
   }
-  const readme = await fs17.readFile(path16.join(cwd, "README.md"), "utf8").catch(() => "");
+  const readme = await fs19.readFile(path18.join(cwd, "README.md"), "utf8").catch(() => "");
   return readme.includes(host) || /\b(upstream|originally by|ported from|borrowed from)\b/i.test(readme);
 }
 
@@ -5803,7 +6113,7 @@ async function runPublish(opts) {
   advisoryNudges(log, detections);
   if (!opts.noPush) {
     const ok = await deployGame(
-      { projectId: meta.id, apiUrl, token },
+      { projectId: meta.id, apiUrl, token, slug: meta.slug },
       {
         // Publish deploys to staging and then promotes, so both channels end up
         // naming the same build. Deploying straight to production instead would
@@ -5811,6 +6121,7 @@ async function runPublish(opts) {
         // staging — the owner would publish and then see a stale game.
         channel: "staging",
         noBuild: opts.noBuild,
+        force: opts.force,
         matchmaking: detections.matchmaking,
         embedSdkVersion: detections.embedSdkVersion,
         multiplayer: detections.multiplayer,
@@ -5904,7 +6215,7 @@ async function runPreview(opts) {
   await exploreReuseNudge(log, meta);
   const apiUrl = getApiUrl(meta.apiUrl);
   const ok = await deployGame(
-    { projectId: meta.id, apiUrl, token },
+    { projectId: meta.id, apiUrl, token, slug: meta.slug },
     // Detections reach the server on every preview too: matchmaking so a draft's
     // declared preset doesn't silently run the default (null clears a removed
     // config), embedSdkVersion/multiplayer so the dashboard's Publish button can
@@ -5915,6 +6226,7 @@ async function runPreview(opts) {
       // was inside, and the only protection was a warning line below.
       channel: "staging",
       noBuild: opts.noBuild,
+      force: opts.force,
       matchmaking: detections.matchmaking,
       embedSdkVersion: detections.embedSdkVersion,
       multiplayer: detections.multiplayer,
@@ -5987,8 +6299,8 @@ async function runPromote(opts) {
 }
 
 // src/commands/generate.ts
-import fs18 from "fs/promises";
-import path17 from "path";
+import fs20 from "fs/promises";
+import path19 from "path";
 import { PNG as PNG4 } from "pngjs";
 
 // src/lib/glass.ts
@@ -6069,7 +6381,7 @@ function solveMagentaGlass(source) {
 }
 
 // src/lib/open.ts
-import { spawn as spawn4 } from "child_process";
+import { spawn as spawn5 } from "child_process";
 function tokenize(cmd) {
   return cmd.trim().split(/\s+/).filter(Boolean);
 }
@@ -6098,7 +6410,7 @@ function openUrl(url) {
     }
   }
   try {
-    const child = spawn4(command, args, { stdio: "ignore", detached: true });
+    const child = spawn5(command, args, { stdio: "ignore", detached: true });
     child.on("error", () => {
     });
     child.unref();
@@ -6158,7 +6470,7 @@ var isRemoteRef = (value) => /^(https?:\/\/|data:)/i.test(value);
 async function inlineLocalImage(filePath, flag) {
   let bytes;
   try {
-    bytes = await fs18.readFile(filePath);
+    bytes = await fs20.readFile(filePath);
   } catch {
     return { ok: false, error: `Couldn't read the ${flag} file at ${filePath}.` };
   }
@@ -6168,7 +6480,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[path17.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.";
@@ -6364,7 +6676,7 @@ async function runGenerate(kind, opts) {
       return;
     }
     try {
-      const bytes = await fs18.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}.`);
@@ -6488,7 +6800,7 @@ async function reportGlassTerminal(view, outDir, log, json) {
     return;
   }
   await recordTerminal(view.id, "completed", files.map((f) => f.url));
-  await fs18.mkdir(outDir, { recursive: true });
+  await fs20.mkdir(outDir, { recursive: true });
   const solved = [];
   for (let i = 0; i < files.length; i++) {
     const f = files[i];
@@ -6520,8 +6832,8 @@ async function reportGlassTerminal(view, outDir, log, json) {
       });
       continue;
     }
-    const outPath = path17.join(outDir, `glass-${i + 1}.png`);
-    await fs18.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,
@@ -7118,8 +7430,8 @@ async function toRow(e, v, cwd) {
 }
 
 // src/commands/controller.ts
-import fs20 from "fs/promises";
-import path19 from "path";
+import fs22 from "fs/promises";
+import path21 from "path";
 
 // ../../packages/meshy-animation-catalog/src/index.ts
 import { createHash } from "crypto";
@@ -16249,9 +16561,9 @@ function searchMeshyAnimations(query, options = {}) {
 }
 
 // src/lib/anims.ts
-import fs19 from "fs/promises";
-import path18 from "path";
-var ANIMS_DEST = path18.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 });
@@ -16267,7 +16579,7 @@ async function runAnims(opts) {
     printCatalog(log, manifest, selectors);
     return;
   }
-  const controllerMarker = path18.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/")}).`
@@ -16276,11 +16588,11 @@ async function runAnims(opts) {
     process.exitCode = 1;
     return;
   }
-  const destDir = path18.join(root, ANIMS_DEST);
-  const gameManifestPath = path18.join(destDir, "manifest.json");
+  const destDir = path20.join(root, ANIMS_DEST);
+  const gameManifestPath = path20.join(destDir, "manifest.json");
   if (opts.reset) {
-    await fs19.rm(destDir, { recursive: true, force: true });
-    log.step(`Cleared ${c.cyan(ANIMS_DEST + path18.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);
@@ -16318,35 +16630,35 @@ async function runAnims(opts) {
     }
   }
   const wanted = [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
-  const cacheDir = path18.join(
+  const cacheDir = path20.join(
     opts.cacheDir ?? getAnimsCacheDir(),
     `${manifest.library}-v${manifest.version}`
   );
-  await fs19.mkdir(cacheDir, { recursive: true });
-  await fs19.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 = path18.join(destDir, entry.file);
+    const dest = path20.join(destDir, entry.file);
     if (await hasSize(dest, entry.bytes)) {
       presentCount++;
       continue;
     }
     try {
-      const cached = path18.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 fs19.writeFile(cached, buf);
+        await fs21.writeFile(cached, buf);
       }
-      await fs19.copyFile(cached, dest);
+      await fs21.copyFile(cached, dest);
       installedCount++;
       addedBytes += entry.bytes;
-      log.dim(`  ${path18.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)})`);
     }
@@ -16362,13 +16674,13 @@ async function runAnims(opts) {
     version: manifest.version,
     clips: [...union].sort((a, b) => a.localeCompare(b))
   };
-  await fs19.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 + path18.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);
@@ -16400,8 +16712,8 @@ async function loadManifest(baseOverride) {
     }
   } catch {
   }
-  const snapshotPath = path18.join(getTemplatesDir(), "controllers", "assets", "anims-manifest.json");
-  const manifest = JSON.parse(await fs19.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) {
@@ -16519,21 +16831,21 @@ function printCatalog(log, manifest, selectors) {
 }
 async function readGameManifest(file) {
   try {
-    return JSON.parse(await fs19.readFile(file, "utf8"));
+    return JSON.parse(await fs21.readFile(file, "utf8"));
   } catch {
     return null;
   }
 }
 async function hasSize(file, bytes) {
   try {
-    return (await fs19.stat(file)).size === bytes;
+    return (await fs21.stat(file)).size === bytes;
   } catch {
     return false;
   }
 }
 async function exists2(p) {
   try {
-    await fs19.access(p);
+    await fs21.access(p);
     return true;
   } catch {
     return false;
@@ -16727,8 +17039,8 @@ var CONTROLLER_FILE_SETS = {
     ]
   }
 };
-var CODE_DEST = path19.join("src", "controllers");
-var ASSETS_DEST = path19.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") {
@@ -16745,31 +17057,31 @@ async function runController(opts) {
     process.exitCode = 1;
     return;
   }
-  const srcDir = path19.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 + path19.sep)}`);
+  log.step(`Installing the ${kind} controller into ${c.cyan(CODE_DEST + path21.sep)}`);
   const plan = [
-    ...set.code.map((rel) => ({ from: rel, rel: path19.join(CODE_DEST, rel) })),
+    ...set.code.map((rel) => ({ from: rel, rel: path21.join(CODE_DEST, rel) })),
     ...set.assets.map((rel) => ({
       from: rel,
-      rel: path19.join(ASSETS_DEST, path19.basename(rel))
+      rel: path21.join(ASSETS_DEST, path21.basename(rel))
     }))
   ];
   let copied = 0;
   let skipped = 0;
   try {
     for (const file of plan) {
-      const dest = path19.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 fs20.mkdir(path19.dirname(dest), { recursive: true });
-      await fs20.copyFile(path19.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}`);
     }
@@ -16822,7 +17134,7 @@ async function runController(opts) {
   for (const line of set.sketch) {
     log.dim(`       ${line}`);
   }
-  if (kind === "character" && !await exists3(path19.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(
@@ -16854,9 +17166,9 @@ async function installMeshyCharacterManifest(args) {
     throw new Error("The API returned an invalid Meshy character manifest.");
   }
   assertCompleteMeshyControllerPack(manifest);
-  const destination = path19.join(args.root, ASSETS_DEST, "meshy-character.json");
-  await fs20.mkdir(path19.dirname(destination), { recursive: true });
-  await fs20.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)}
 `
@@ -16994,14 +17306,14 @@ function assertCompleteMeshyControllerPack(manifest) {
 }
 async function installFallbackAvatar(args) {
   const { root, srcDir, log } = args;
-  const dest = path19.join(root, ASSETS_DEST, "avatar.vrm");
-  await fs20.mkdir(path19.dirname(dest), { recursive: true });
-  await fs20.copyFile(path19.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 fs20.access(p);
+    await fs22.access(p);
     return true;
   } catch {
     return false;
@@ -17009,8 +17321,8 @@ async function exists3(p) {
 }
 
 // src/commands/character.ts
-import fs21 from "fs/promises";
-import path20 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));
@@ -17090,7 +17402,7 @@ function showAmbiguity(selector, candidates, log, json = false) {
   }
   process.exitCode = 1;
 }
-var INSTALLED_MANIFEST = path20.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")) {
@@ -17099,7 +17411,7 @@ async function resolveAdoptTarget(selector) {
   const file = trimmed ?? INSTALLED_MANIFEST;
   let raw;
   try {
-    raw = await fs21.readFile(file, "utf8");
+    raw = await fs23.readFile(file, "utf8");
   } catch {
     return {
       ok: false,
@@ -17577,22 +17889,22 @@ async function context2(opts) {
   const project = await readProject();
   return { token, apiUrl: getApiUrl(opts.apiUrl ?? project?.apiUrl) };
 }
-async function readVideo(path23, log) {
+async function readVideo(path25, log) {
   let bytes;
   try {
-    bytes = await readFile(path23);
+    bytes = await readFile(path25);
   } catch {
-    log.error(`Can't read ${path23}.`);
+    log.error(`Can't read ${path25}.`);
     return null;
   }
   if (bytes.byteLength > MAX_VIDEO_BYTES) {
-    log.error(`${basename(path23)} is ${(bytes.byteLength / 1e6).toFixed(0)} MB \u2014 the limit is ${MAX_VIDEO_BYTES / 1e6} MB.`);
+    log.error(`${basename(path25)} is ${(bytes.byteLength / 1e6).toFixed(0)} MB \u2014 the limit is ${MAX_VIDEO_BYTES / 1e6} MB.`);
     return null;
   }
   return bytes;
 }
-async function uploadVideo(apiUrl, token, characterId, path23, bytes, log) {
-  const contentType = /\.mov$/i.test(path23) ? "video/quicktime" : "video/mp4";
+async function uploadVideo(apiUrl, token, characterId, path25, bytes, log) {
+  const contentType = /\.mov$/i.test(path25) ? "video/quicktime" : "video/mp4";
   const minted = await apiFetch(
     `${apiUrl}/api/characters/${encodeURIComponent(characterId)}/motions/video-url`,
     {
@@ -17607,7 +17919,7 @@ async function uploadVideo(apiUrl, token, characterId, path23, bytes, log) {
     return null;
   }
   const { uploadUrl, videoUrl } = await minted.json();
-  log.dim(`  uploading ${basename(path23)} (${(bytes.byteLength / 1e6).toFixed(1)} MB)\u2026`);
+  log.dim(`  uploading ${basename(path25)} (${(bytes.byteLength / 1e6).toFixed(1)} MB)\u2026`);
   const put = await fetch(uploadUrl, {
     method: "PUT",
     headers: { "Content-Type": contentType, "Content-Length": String(bytes.byteLength) },
@@ -17923,8 +18235,8 @@ function rank(items, query) {
 }
 
 // src/commands/motion.ts
-import fs22 from "fs/promises";
-import path21 from "path";
+import fs24 from "fs/promises";
+import path23 from "path";
 
 // src/lib/motion/npz.ts
 import zlib from "zlib";
@@ -19175,7 +19487,7 @@ async function motionGen(opts, log) {
   }
   if (opts.constraintsPath !== void 0) {
     try {
-      const raw = await fs22.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}.`);
@@ -19199,10 +19511,10 @@ async function motionGen(opts, log) {
 async function expandTakes(selectors) {
   const out = [];
   for (const sel of selectors) {
-    const st = await fs22.stat(sel).catch(() => null);
+    const st = await fs24.stat(sel).catch(() => null);
     if (st?.isDirectory()) {
-      const names = await fs22.readdir(sel);
-      for (const n of names.sort()) if (n.endsWith(".npz")) out.push(path21.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 {
@@ -19237,7 +19549,7 @@ async function motionVerify(opts, log) {
   let gates = DEFAULT_GATES;
   if (opts.gatesPath) {
     try {
-      gates = mergeGates(DEFAULT_GATES, JSON.parse(await fs22.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;
@@ -19259,9 +19571,9 @@ async function motionVerify(opts, log) {
   }
   const reports = [];
   for (const file of files) {
-    const stem = path21.basename(file).replace(/\.npz$/, "");
+    const stem = path23.basename(file).replace(/\.npz$/, "");
     try {
-      reports.push(analyzeTake(stem, await fs22.readFile(file), gates));
+      reports.push(analyzeTake(stem, await fs24.readFile(file), gates));
     } catch (err) {
       reports.push({
         take: stem,
@@ -19299,7 +19611,7 @@ async function motionCompile(opts, log) {
   let cfg = DEFAULT_MOTION_CONFIG;
   if (opts.configPath) {
     try {
-      const patch = JSON.parse(await fs22.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}.`);
@@ -19317,16 +19629,16 @@ async function motionCompile(opts, log) {
   }
   const inputs = [];
   for (const file of files) {
-    const stem = path21.basename(file).replace(/\.npz$/, "");
+    const stem = path23.basename(file).replace(/\.npz$/, "");
     try {
-      inputs.push({ stem, take: loadTake(await fs22.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 ?? path21.basename(opts.out).replace(/\.json$/, "");
+  const setName = opts.set ?? path23.basename(opts.out).replace(/\.json$/, "");
   let result;
   try {
     result = compileSet(inputs, setName, cfg);
@@ -19341,9 +19653,9 @@ async function motionCompile(opts, log) {
     process.exitCode = 1;
     return;
   }
-  await fs22.mkdir(path21.dirname(path21.resolve(opts.out)), { recursive: true });
+  await fs24.mkdir(path23.dirname(path23.resolve(opts.out)), { recursive: true });
   const json = JSON.stringify(result.data);
-  await fs22.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;
@@ -19361,9 +19673,9 @@ var MOTION_RUNTIME_FILES = [
 var MOTION_PRESETS = {
   rifle: ["sets/rifle.json", "sets/jumps.json"]
 };
-var MOTION_DEST = path21.join("src", "motion");
+var MOTION_DEST = path23.join("src", "motion");
 async function motionInstall(opts, log) {
-  const srcDir = path21.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]) {
@@ -19374,21 +19686,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 + path21.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 = path21.join(root, MOTION_DEST, rel);
-      const exists4 = await fs22.access(dest).then(() => true, () => false);
+      const dest = path23.join(root, MOTION_DEST, rel);
+      const exists4 = await fs24.access(dest).then(() => true, () => false);
       if (!opts.force && exists4) {
         skipped++;
-        log.dim(`  skipped ${path21.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 fs22.mkdir(path21.dirname(dest), { recursive: true });
-      await fs22.copyFile(path21.join(srcDir, rel), dest);
+      await fs24.mkdir(path23.dirname(dest), { recursive: true });
+      await fs24.copyFile(path23.join(srcDir, rel), dest);
       copied++;
-      log.dim(`  ${path21.join(MOTION_DEST, rel)}`);
+      log.dim(`  ${path23.join(MOTION_DEST, rel)}`);
     }
   } catch (err) {
     log.error(`Copy failed: ${String(err)}`);
@@ -19429,7 +19741,7 @@ async function motionConstraints(opts, log) {
   }
   const doc = directionConstraint(dir, speed, duration);
   const out = opts.out ?? "constraints.json";
-  await fs22.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;
@@ -19466,9 +19778,9 @@ async function runMotion(opts) {
 }
 
 // src/commands/asset-new.ts
-import fs23 from "fs";
+import fs25 from "fs";
 import fsp from "fs/promises";
-import path22 from "path";
+import path24 from "path";
 import { pathToFileURL } from "url";
 var EXTRA_FILES = [
   "genex-asset.example.json",
@@ -19561,7 +19873,7 @@ Every milestone ends with \`npm run verify\`, then \`npx genex preview --no-buil
 }
 async function runAssetNew(options) {
   const log = createLogger();
-  const cwd = options.dir ? path22.resolve(options.dir) : process.cwd();
+  const cwd = options.dir ? path24.resolve(options.dir) : process.cwd();
   const slug = options.assetSlug;
   if (!slug) {
     log.error('Usage: genex asset new <slug> [--title "<Name>"] [--dims WxDxH] [--tri-band LOW-HIGH] [--holder "<your name>"] [--out <dir>]');
@@ -19571,14 +19883,14 @@ async function runAssetNew(options) {
     log.error(`The slug must be kebab-case (letters, digits, dashes), got: ${slug}`);
     return 1;
   }
-  const templateDir = path22.join(getTemplatesDir(), "asset-viewer");
-  if (!fs23.existsSync(templateDir)) {
+  const templateDir = path24.join(getTemplatesDir(), "asset-viewer");
+  if (!fs25.existsSync(templateDir)) {
     log.error(`Vendored asset-viewer template not found at ${templateDir} \u2014 reinstall the CLI.`);
     return 1;
   }
-  const manifestTools = await import(pathToFileURL(path22.join(templateDir, "tools", "emit-manifest.mjs")).href);
+  const manifestTools = await import(pathToFileURL(path24.join(templateDir, "tools", "emit-manifest.mjs")).href);
   const { SHARED_FILES, PARITY_FILENAME, hashSharedFiles, pascalCase } = manifestTools;
-  const lockPath = path22.join(templateDir, "shared-files.sha256.json");
+  const lockPath = path24.join(templateDir, "shared-files.sha256.json");
   const lock = JSON.parse(await fsp.readFile(lockPath, "utf8"));
   const actual = hashSharedFiles(templateDir);
   const drifted = SHARED_FILES.filter((rel) => lock.files[rel] !== actual[rel]);
@@ -19591,8 +19903,8 @@ async function runAssetNew(options) {
   const triBand = parseBand(options.triBand ?? "500-8000");
   const holder = options.holder?.trim() || HOLDER_PLACEHOLDER;
   const year = (/* @__PURE__ */ new Date()).getUTCFullYear();
-  const outDir = path22.resolve(cwd, options.out ?? slug);
-  if (fs23.existsSync(outDir) && fs23.readdirSync(outDir).length > 0 && !options.force) {
+  const outDir = path24.resolve(cwd, options.out ?? slug);
+  if (fs25.existsSync(outDir) && fs25.readdirSync(outDir).length > 0 && !options.force) {
     log.error(`${outDir} already holds files. Nothing was touched \u2014 pass --force to write into it anyway.`);
     return 1;
   }
@@ -19620,24 +19932,24 @@ async function runAssetNew(options) {
   };
   await fsp.mkdir(outDir, { recursive: true });
   for (const rel of [...SHARED_FILES, ...EXTRA_FILES]) {
-    const to = path22.join(outDir, rel);
-    await fsp.mkdir(path22.dirname(to), { recursive: true });
-    await fsp.copyFile(path22.join(templateDir, rel), to);
+    const to = path24.join(outDir, rel);
+    await fsp.mkdir(path24.dirname(to), { recursive: true });
+    await fsp.copyFile(path24.join(templateDir, rel), to);
   }
-  const pkg = fillTemplate(await fsp.readFile(path22.join(templateDir, "package.json"), "utf8"), {
+  const pkg = fillTemplate(await fsp.readFile(path24.join(templateDir, "package.json"), "utf8"), {
     slug,
     name,
     version
   });
-  await fsp.writeFile(path22.join(outDir, "package.json"), pkg, "utf8");
-  await fsp.writeFile(path22.join(outDir, "asset.config.json"), JSON.stringify(config, null, 2) + "\n", "utf8");
-  await fsp.writeFile(path22.join(outDir, ".gitignore"), GITIGNORE, "utf8");
+  await fsp.writeFile(path24.join(outDir, "package.json"), pkg, "utf8");
+  await fsp.writeFile(path24.join(outDir, "asset.config.json"), JSON.stringify(config, null, 2) + "\n", "utf8");
+  await fsp.writeFile(path24.join(outDir, ".gitignore"), GITIGNORE, "utf8");
   await fsp.writeFile(
-    path22.join(outDir, "DESIGN.md"),
+    path24.join(outDir, "DESIGN.md"),
     designDoc({ name, slug, sizeMeters, triBand, holder }),
     "utf8"
   );
-  const placeholder = await fsp.readFile(path22.join(templateDir, "src", "asset", "PLACEHOLDER.ts"), "utf8");
+  const placeholder = await fsp.readFile(path24.join(templateDir, "src", "asset", "PLACEHOLDER.ts"), "utf8");
   const seeded = seedAssetSource(placeholder, {
     slug,
     name,
@@ -19648,8 +19960,8 @@ async function runAssetNew(options) {
     pascalCase
   });
   const assetFilename = `${slug.replace(/-([a-z0-9])/g, (_, ch) => ch.toUpperCase())}.ts`;
-  await fsp.mkdir(path22.join(outDir, "src", "asset"), { recursive: true });
-  await fsp.writeFile(path22.join(outDir, "src", "asset", assetFilename), seeded, "utf8");
+  await fsp.mkdir(path24.join(outDir, "src", "asset"), { recursive: true });
+  await fsp.writeFile(path24.join(outDir, "src", "asset", assetFilename), seeded, "utf8");
   const copied = hashSharedFiles(outDir);
   const mismatched = SHARED_FILES.filter((rel) => copied[rel] !== lock.files[rel]);
   if (mismatched.length) {
@@ -19657,7 +19969,7 @@ async function runAssetNew(options) {
     return 1;
   }
   await fsp.writeFile(
-    path22.join(outDir, PARITY_FILENAME),
+    path24.join(outDir, PARITY_FILENAME),
     JSON.stringify(
       {
         note: "Recorded by `genex asset new`. Gate G13 recomputes these; do not hand-edit the viewer.",
@@ -19711,9 +20023,15 @@ ${c.bold("Usage")}
                                      resumes the same code, so an interrupted
                                      'genex init' costs nothing. --force switches
                                      accounts.
-  genex link <slug> [options]        Re-link THIS folder to an existing game of yours
-                                     (lost folder / new machine); preview/publish then
-                                     update the same live game. Never creates a project.
+  genex link <slug> [options]        Point THIS folder at an existing game of yours;
+                                     preview/publish then update the same live game.
+                                     In an EMPTY folder it downloads the game too \u2014
+                                     that's how you pick a game up on a new machine.
+                                     Never creates a project.
+  genex pull [options]               Update THIS folder with the game's latest draft,
+                                     for when it was built from somewhere else. Refuses
+                                     if this folder has changes you never deployed;
+                                     --force replaces them.
   genex rename <name> [options]      Rename THIS game \u2014 its play address, its source repo,
                                      and its gallery name. Keeps the game (plays, likes,
                                      comments); the OLD address stops working, so a
@@ -20660,6 +20978,9 @@ async function main() {
       case "link":
         await runLink(parsed.options);
         break;
+      case "pull":
+        await runPull(parsed.options);
+        break;
       case "rename":
         await runRename(parsed.options);
         break;