@genex-ai/cli-demo 1.36.20-dev.1078 → 1.38.0-dev.1079

package/dist/index.js

@@ -3123,15 +3123,15 @@ async function detectSurfaceScan(cwd = process.cwd()) {
         detail: `repeat.set(${m[1]}, ${m[2]})`
       });
     }
-    for (const call2 of ctorArgs(content, "PointsMaterial")) {
-      if (/\b(map|alphaMap)\s*:/.test(call2.text)) continue;
+    for (const call3 of ctorArgs(content, "PointsMaterial")) {
+      if (/\b(map|alphaMap)\s*:/.test(call3.text)) continue;
       found.squarePoints.push({
-        where: `${rel}:${lineOf(content, call2.index)}`,
+        where: `${rel}:${lineOf(content, call3.index)}`,
         detail: "PointsMaterial with no map/alphaMap"
       });
     }
-    for (const call2 of ctorArgs(content, "PerspectiveCamera")) {
-      const args = splitArgs(call2.text);
+    for (const call3 of ctorArgs(content, "PerspectiveCamera")) {
+      const args = splitArgs(call3.text);
       if (args.length < 4) continue;
       const near = Number(args[2]);
       const far = Number(args[3]);
@@ -3139,7 +3139,7 @@ async function detectSurfaceScan(cwd = process.cwd()) {
       const ratio = far / near;
       if (ratio <= DEPTH_RATIO_LIMIT) continue;
       found.depthRange.push({
-        where: `${rel}:${lineOf(content, call2.index)}`,
+        where: `${rel}:${lineOf(content, call3.index)}`,
         detail: `near ${near} / far ${far}`,
         ratio
       });
@@ -3434,7 +3434,7 @@ async function detectShellApis(cwd = process.cwd()) {
       for (const m of content.matchAll(DOWNLOAD_ASSIGN)) add(found.download, m.index, "a.download");
     }
     for (const m of content.matchAll(DOWNLOAD_ATTR)) add(found.download, m.index, "a download link");
-    for (const call2 of dialogCalls(content)) add(found.dialogs, call2.index, `${call2.name}()`);
+    for (const call3 of dialogCalls(content)) add(found.dialogs, call3.index, `${call3.name}()`);
     for (const m of content.matchAll(SERVICE_WORKER)) {
       add(found.serviceWorker, m.index, "serviceWorker.register");
     }
@@ -8658,10 +8658,10 @@ var PACKAGE_PART = "package";
 function packagePart(zip) {
   return { kind: PACKAGE_PART, bytes: zip, contentType: MediaContentType.Zip };
 }
-async function uploadItemPart(call2, skuUrl2, part) {
+async function uploadItemPart(call3, skuUrl2, part) {
   const isPackage = part.kind === PACKAGE_PART;
   const base = isPackage ? `${skuUrl2}/package` : `${skuUrl2}/media`;
-  const post = (url, body) => call2(url, { method: "POST", body: JSON.stringify(body) });
+  const post = (url, body) => call3(url, { method: "POST", body: JSON.stringify(body) });
   const urlRes = await post(`${base}/upload-url`, isPackage ? { bytes: part.bytes.length } : { kind: part.kind, bytes: part.bytes.length, contentType: part.contentType });
   if (!urlRes.ok) return { ok: false, refused: urlRes, what: `upload the ${part.kind}` };
   const { uploadUrl, key } = await urlRes.json();
@@ -8680,19 +8680,19 @@ function bearerCaller(token) {
   const auth = { Authorization: `Bearer ${token}`, "Content-Type": "application/json" };
   return (url, init) => apiFetch(url, { ...init, headers: { ...auth, ...init?.headers ?? {} } });
 }
-async function readPriceGrid(call2, apiUrl, projectId) {
-  const res = await call2(`${apiUrl}/api/coin/projects/${encodeURIComponent(projectId)}/skus`).catch(() => null);
+async function readPriceGrid(call3, apiUrl, projectId) {
+  const res = await call3(`${apiUrl}/api/coin/projects/${encodeURIComponent(projectId)}/skus`).catch(() => null);
   if (!res?.ok) return null;
   const body = await res.json().catch(() => null);
   const grid = body?.priceGrid;
   return Array.isArray(grid) && grid.every((n) => typeof n === "number") ? grid : null;
 }
-async function storeTakesFree(call2, apiUrl) {
-  const res = await call2(`${apiUrl}/api/store/catalog?limit=1`).catch(() => null);
+async function storeTakesFree(call3, apiUrl) {
+  const res = await call3(`${apiUrl}/api/store/catalog?limit=1`).catch(() => null);
   return res?.ok === true;
 }
-async function priceGridHint(call2, apiUrl, projectId) {
-  const [grid, free] = await Promise.all([readPriceGrid(call2, apiUrl, projectId), storeTakesFree(call2, apiUrl)]);
+async function priceGridHint(call3, apiUrl, projectId) {
+  const [grid, free] = await Promise.all([readPriceGrid(call3, apiUrl, projectId), storeTakesFree(call3, apiUrl)]);
   return grid ? priceGridLine(grid, free) : null;
 }
 async function openLinkedGame(opts, log, rerun) {
@@ -9892,14 +9892,14 @@ async function runDomain(opts) {
   }
   const base = `${apiUrl}/api/projects/${encodeURIComponent(meta.id)}/domains`;
   const auth = { Authorization: `Bearer ${token}` };
-  const call2 = (url, init) => apiFetch(url, { ...init, headers: { ...auth, "Content-Type": "application/json", ...init?.headers ?? {} } });
+  const call3 = (url, init) => apiFetch(url, { ...init, headers: { ...auth, "Content-Type": "application/json", ...init?.headers ?? {} } });
   let res;
   try {
-    if (sub === "list") res = await call2(base);
-    else if (sub === "add") res = await call2(base, { method: "POST", body: JSON.stringify({ hostname }) });
+    if (sub === "list") res = await call3(base);
+    else if (sub === "add") res = await call3(base, { method: "POST", body: JSON.stringify({ hostname }) });
     else if (sub === "verify")
-      res = await call2(`${base}/${encodeURIComponent(hostname)}/verify`, { method: "POST" });
-    else res = await call2(`${base}/${encodeURIComponent(hostname)}`, { method: "DELETE" });
+      res = await call3(`${base}/${encodeURIComponent(hostname)}/verify`, { method: "POST" });
+    else res = await call3(`${base}/${encodeURIComponent(hostname)}`, { method: "DELETE" });
   } catch (err) {
     log.error(`Couldn't reach the API at ${apiUrl}.`);
     log.dim(`  ${String(err)}`);
@@ -23134,7 +23134,7 @@ async function runController(opts) {
   log.plain(c.bold(`genex controller ${kind}`));
   log.plain("");
   log.step(`Installing the ${kind} controller into ${c.cyan(CODE_DEST + path34.sep)}`);
-  const plan = [
+  const plan2 = [
     ...set.code.map((rel) => ({ from: rel, rel: path34.join(CODE_DEST, rel) })),
     ...set.assets.map((rel) => ({
       from: rel,
@@ -23144,7 +23144,7 @@ async function runController(opts) {
   let copied = 0;
   let skipped = 0;
   try {
-    for (const file of plan) {
+    for (const file of plan2) {
       const dest = path34.join(root, file.rel);
       if (!opts.force && await exists4(dest)) {
         skipped++;
@@ -24164,22 +24164,22 @@ async function context2(opts) {
   if (!token) return null;
   return { token, apiUrl };
 }
-async function readVideo(path50, log) {
+async function readVideo(path52, log) {
   let bytes;
   try {
-    bytes = await readFile(path50);
+    bytes = await readFile(path52);
   } catch {
-    log.error(`Can't read ${path50}.`);
+    log.error(`Can't read ${path52}.`);
     return null;
   }
   if (bytes.byteLength > MAX_VIDEO_BYTES) {
-    log.error(`${basename(path50)} is ${(bytes.byteLength / 1e6).toFixed(0)} MB \u2014 the limit is ${MAX_VIDEO_BYTES / 1e6} MB.`);
+    log.error(`${basename(path52)} 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, path50, bytes, log) {
-  const contentType = /\.mov$/i.test(path50) ? "video/quicktime" : "video/mp4";
+async function uploadVideo(apiUrl, token, characterId, path52, bytes, log) {
+  const contentType = /\.mov$/i.test(path52) ? "video/quicktime" : "video/mp4";
   const minted = await apiFetch(
     `${apiUrl}/api/characters/${encodeURIComponent(characterId)}/motions/video-url`,
     {
@@ -24194,7 +24194,7 @@ async function uploadVideo(apiUrl, token, characterId, path50, bytes, log) {
     return null;
   }
   const { uploadUrl, videoUrl } = await minted.json();
-  log.dim(`  uploading ${basename(path50)} (${(bytes.byteLength / 1e6).toFixed(1)} MB)\u2026`);
+  log.dim(`  uploading ${basename(path52)} (${(bytes.byteLength / 1e6).toFixed(1)} MB)\u2026`);
   const put = await fetch(uploadUrl, {
     method: "PUT",
     headers: { "Content-Type": contentType, "Content-Length": String(bytes.byteLength) },
@@ -24206,9 +24206,9 @@ async function uploadVideo(apiUrl, token, characterId, path50, bytes, log) {
   }
   return videoUrl;
 }
-function printPlan(plan, log, creature) {
+function printPlan(plan2, log, creature) {
   log.plain(c.bold(creature ? "Creature animation plan" : "Animation plan"));
-  for (const item of plan.items) {
+  for (const item of plan2.items) {
     const count = item.clips > 1 ? ` (${item.clips} clips)` : "";
     log.plain(`  \xB7 ${c.bold(item.request)}${count} \u2014 ${item.explanation}`);
     if (item.supersededSlots.length > 0) {
@@ -24217,14 +24217,14 @@ function printPlan(plan, log, creature) {
       );
     }
   }
-  if (plan.secondsApplied === false) {
+  if (plan2.secondsApplied === false) {
     log.plain(
       `  ${c.dim("--duration sets the reference-video length; none of these verbs took the video route, so it did nothing.")}`
     );
   }
   log.plain("");
-  if (plan.credits > 0) log.dim(`  ${plan.totalClips} clips \xB7 ${plan.credits} credits`);
-  else log.dim(`  ${plan.totalClips} clips`);
+  if (plan2.credits > 0) log.dim(`  ${plan2.totalClips} clips \xB7 ${plan2.credits} credits`);
+  else log.dim(`  ${plan2.totalClips} clips`);
   log.plain("");
 }
 async function runCharacterAnimateMotion(opts) {
@@ -26959,10 +26959,10 @@ async function reportModels(apiUrl, token, opts, log, toolsOnly = false) {
     shown === lane.models ? `  ${lane.models.length} model${lane.models.length === 1 ? "" : "s"} live:` : `  ${shown.length} featured model${shown.length === 1 ? "" : "s"} of ${lane.models.length} live:`
   );
   for (const m of shown) {
-    const plan = m.personalPlan ? `  \xB7  personal plan: ${m.personalPlan}` : "";
+    const plan2 = m.personalPlan ? `  \xB7  personal plan: ${m.personalPlan}` : "";
     const kind = m.kind === "typesafe" ? "  \xB7  judge (classifier): judge() under a budget, not generate() or bench" : "";
     log.plain(
-      `    ${c.cyan(m.id)}  ${m.label} \u2014 ${usdPerMillion(m.inputUsdPerMillion)} in / ${usdPerMillion(m.outputUsdPerMillion)} out per million tokens${plan}${kind}`
+      `    ${c.cyan(m.id)}  ${m.label} \u2014 ${usdPerMillion(m.inputUsdPerMillion)} in / ${usdPerMillion(m.outputUsdPerMillion)} out per million tokens${plan2}${kind}`
     );
   }
   if (hiddenCount > 0) {
@@ -27125,7 +27125,7 @@ async function runBench(args) {
   const samples = opts.samples ?? DEFAULT_BENCH_SAMPLES;
   const prompt = opts.benchPrompt.trim();
   const auth = { Authorization: `Bearer ${token}`, "Content-Type": "application/json" };
-  const call2 = (url, init) => apiFetch(url, { ...init, headers: { ...auth, ...init?.headers ?? {} } });
+  const call3 = (url, init) => apiFetch(url, { ...init, headers: { ...auth, ...init?.headers ?? {} } });
   let schema;
   if (opts.schemaPath) {
     try {
@@ -27204,7 +27204,7 @@ async function runBench(args) {
     if (!opts.json) log.warn("Stopping \u2014 cancelling the attempt in flight.");
     void (async () => {
       if (target) {
-        await call2(`${base}/${encodeURIComponent(target)}/cancel`, { method: "POST" }).catch(() => {
+        await call3(`${base}/${encodeURIComponent(target)}/cancel`, { method: "POST" }).catch(() => {
         });
       }
       process.exit(130);
@@ -27213,7 +27213,7 @@ async function runBench(args) {
   process.once("SIGINT", onSigint);
   try {
     for (let i = 0; i < samples; i++) {
-      const res = await call2(base, {
+      const res = await call3(base, {
         method: "POST",
         body: JSON.stringify({
           maxCredits,
@@ -27227,7 +27227,7 @@ async function runBench(args) {
         })
       });
       if (!res.ok) {
-        const verdict = await explainBenchRefusal(res, call2, base, log, opts, i, results.length);
+        const verdict = await explainBenchRefusal(res, call3, base, log, opts, i, results.length);
         if (verdict.refusal) refusal2 = verdict.refusal;
         if (verdict.stop) break;
         continue;
@@ -27238,7 +27238,7 @@ async function runBench(args) {
         continue;
       }
       inflight = started.id;
-      const settled = await pollSettled(call2, `${base}/${encodeURIComponent(started.id)}`, opts.timeoutSec ?? DEFAULT_SAMPLE_TIMEOUT_SEC);
+      const settled = await pollSettled(call3, `${base}/${encodeURIComponent(started.id)}`, opts.timeoutSec ?? DEFAULT_SAMPLE_TIMEOUT_SEC);
       inflight = null;
       const row = sampleFrom(started.id, settled);
       results.push(row);
@@ -27441,7 +27441,7 @@ function printAverage(log, record, attempts) {
     log.dim(`  = that average rounded up to a whole credit. disclosure.estimatedCreditsPerPeriod = your calls per period \xD7 ${formatCredits(record.averageCreditsPerCall)}, rounded up.`);
   }
 }
-async function explainBenchRefusal(res, call2, base, log, opts, index, settledSoFar) {
+async function explainBenchRefusal(res, call3, base, log, opts, index, settledSoFar) {
   if (printedStructuredError(res)) {
     const printed = await res.json().catch(() => ({}));
     return { stop: true, refusal: { status: res.status, error: typeof printed.error === "string" ? printed.error : null, slotsHeld: null, slotLimit: null } };
@@ -27449,7 +27449,7 @@ async function explainBenchRefusal(res, call2, base, log, opts, index, settledSo
   const body = await res.json().catch(() => ({}));
   const refusal2 = { status: res.status, error: body.error ?? null, slotsHeld: null, slotLimit: null };
   if (res.status === 429 && body.error === "generation_limit") {
-    const counts = serverSlotCounts(body) ?? await readSlotCounts(call2, base);
+    const counts = serverSlotCounts(body) ?? await readSlotCounts(call3, base);
     refusal2.slotsHeld = counts?.held ?? null;
     refusal2.slotLimit = counts?.limit ?? null;
     if (!opts.json) log.error(`  Sample ${index + 1} ${benchSlotsHeldSentence(counts)}`);
@@ -27490,17 +27490,17 @@ function printProviderRefusal(log, status2, message, awaitingBill = false) {
     log.dim(`      A ${status2} here is this stand's provider configuration refusing the model \u2014 a message for the operator, not something to fix in the game.`);
   }
 }
-async function readSlotCounts(call2, base) {
-  const res = await call2(`${base}?scope=open`).catch(() => null);
+async function readSlotCounts(call3, base) {
+  const res = await call3(`${base}?scope=open`).catch(() => null);
   if (!res?.ok) return null;
   const body = await res.json().catch(() => null);
   return serverSlotCounts(body);
 }
-async function pollSettled(call2, url, timeoutSec) {
+async function pollSettled(call3, url, timeoutSec) {
   const deadline = Date.now() + timeoutSec * 1e3;
   let last = null;
   while (Date.now() < deadline) {
-    const res = await call2(url).catch(() => null);
+    const res = await call3(url).catch(() => null);
     if (res?.ok) {
       last = await res.json().catch(() => null);
       if (last?.billingStatus === "final") return last;
@@ -27563,9 +27563,9 @@ function emptyBenchJson(apiUrl, projectId, prompt, outputFormat, samples, maxCre
 }
 async function reportStatus(args) {
   const { apiUrl, token, projectId, opts, log } = args;
-  const call2 = (url, init) => apiFetch(url, { ...init, headers: { Authorization: `Bearer ${token}`, ...init?.headers ?? {} } });
+  const call3 = (url, init) => apiFetch(url, { ...init, headers: { Authorization: `Bearer ${token}`, ...init?.headers ?? {} } });
   const base = `${apiUrl}/api/runtime/development/projects/${encodeURIComponent(projectId)}/generations`;
-  const res = await call2(`${base}?scope=open`).catch(() => null);
+  const res = await call3(`${base}?scope=open`).catch(() => null);
   if (!res || !res.ok) {
     if (res && printedStructuredError(res)) {
       if (opts.json) writeJsonLine(statusJson(apiUrl, projectId, "failed", `http_${res.status}`, [], null, null));
@@ -27656,14 +27656,14 @@ function statusJson(apiUrl, projectId, status2, error, rows, slotsHeld, slotLimi
 }
 async function cancelCall(args) {
   const { apiUrl, token, projectId, id, opts, log } = args;
-  const call2 = (url, init) => apiFetch(url, { ...init, headers: { Authorization: `Bearer ${token}`, ...init?.headers ?? {} } });
+  const call3 = (url, init) => apiFetch(url, { ...init, headers: { Authorization: `Bearer ${token}`, ...init?.headers ?? {} } });
   const base = `${apiUrl}/api/runtime/development/projects/${encodeURIComponent(projectId)}/generations`;
   const rowUrl = `${base}/${encodeURIComponent(id)}`;
   const done = (status2, error, reason, row2) => {
     if (opts.json) writeJsonLine({ command: "llm cancel", status: status2, error, id, cancelled: reason === "cancelled", reason, generation: row2 });
     if (status2 === "failed") process.exitCode = 1;
   };
-  const read = await call2(rowUrl).catch(() => null);
+  const read = await call3(rowUrl).catch(() => null);
   if (!read || !read.ok) {
     if (read && printedStructuredError(read)) return done("failed", `http_${read.status}`, null, null);
     const body = read ? await read.json().catch(() => ({})) : {};
@@ -27702,7 +27702,7 @@ async function cancelCall(args) {
     }
     return done("ok", null, state === "awaiting bill" ? "awaiting_bill" : "already_final", row);
   }
-  const res = await call2(`${rowUrl}/cancel`, { method: "POST" }).catch(() => null);
+  const res = await call3(`${rowUrl}/cancel`, { method: "POST" }).catch(() => null);
   if (!res || !res.ok) {
     if (res && printedStructuredError(res)) return done("failed", `http_${res.status}`, null, row);
     const body = res ? await res.json().catch(() => ({})) : {};
@@ -28658,14 +28658,14 @@ var PlayerClient = class {
     this.version = options.version ?? getCliVersion();
     this.timeoutMs = options.timeoutMs ?? 3e4;
   }
-  async call(path50, init = {}, provider) {
+  async call(path52, init = {}, provider) {
     const headers = {
       Authorization: `Bearer ${this.token}`,
       [PLAYER_VERSION_HEADER]: this.version,
       ...provider ? { [EXTERNAL_PROVIDER_HEADER]: provider } : {},
       ...init.body === void 0 ? {} : { "Content-Type": "application/json" }
     };
-    const res = await apiFetch(`${this.apiUrl}${path50}`, {
+    const res = await apiFetch(`${this.apiUrl}${path52}`, {
       ...init,
       headers,
       signal: AbortSignal.timeout(this.timeoutMs)
@@ -29261,20 +29261,20 @@ async function markRelaunch(version, home) {
   }
 }
 async function relaunchWatcher(input) {
-  const plan = relaunchPlan(input);
+  const plan2 = relaunchPlan(input);
   const log = input.log ?? (() => {
   });
-  if (input.relaunched) return { launched: false, plan, reason: "relaunched_child" };
-  if (!relaunchPossible()) return { launched: false, plan, reason: "no_npx" };
-  if (await relaunchOnCooldown(input.home)) return { launched: false, plan, reason: "cooldown" };
+  if (input.relaunched) return { launched: false, plan: plan2, reason: "relaunched_child" };
+  if (!relaunchPossible()) return { launched: false, plan: plan2, reason: "no_npx" };
+  if (await relaunchOnCooldown(input.home)) return { launched: false, plan: plan2, reason: "cooldown" };
   await markRelaunch(input.version, input.home);
   if (supervisedWatcher()) {
     log(`player: stopping so the login item restarts as ${input.version} (it resolves ${PLAYER_AUTOSTART_SPEC} each start)`);
-    return { launched: false, plan, reason: "supervisor_restarts" };
+    return { launched: false, plan: plan2, reason: "supervisor_restarts" };
   }
   if (playerDryRun()) {
-    log(`player: would relaunch: ${JSON.stringify([plan.launcher, ...plan.args])}`);
-    return { launched: true, plan, reason: "dry_run" };
+    log(`player: would relaunch: ${JSON.stringify([plan2.launcher, ...plan2.args])}`);
+    return { launched: true, plan: plan2, reason: "dry_run" };
   }
   let out;
   let err;
@@ -29286,7 +29286,7 @@ async function relaunchWatcher(input) {
   } catch {
   }
   try {
-    const child = spawn7(plan.launcher, plan.args, {
+    const child = spawn7(plan2.launcher, plan2.args, {
       detached: true,
       stdio: ["ignore", out ?? "ignore", err ?? "ignore"]
     });
@@ -29299,7 +29299,7 @@ async function relaunchWatcher(input) {
     }
   }
   log(`player: relaunching as ${input.version}`);
-  return { launched: true, plan };
+  return { launched: true, plan: plan2 };
 }
 
 // src/lib/player/loop.ts
@@ -29989,6 +29989,11 @@ function writeJsonLine2(value) {
 `);
 }
 
+// src/commands/native.ts
+import fs51 from "fs/promises";
+import os15 from "os";
+import path51 from "path";
+
 // src/lib/native-build.ts
 import { createHash as createHash5 } from "crypto";
 import { createReadStream } from "fs";
@@ -30595,6 +30600,380 @@ async function listInGallery(ctx, body, log) {
   return null;
 }
 
+// src/lib/cloud-build.ts
+import fs49 from "fs/promises";
+var CLOUD_BUILD_PLATFORMS = ["windows", "linux", "mac"];
+var isCloudBuildPlatform = (value) => CLOUD_BUILD_PLATFORMS.includes(value);
+var CLOUD_BUILD_JOB_ID = /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/;
+var UPLOAD_INCOMPLETE = "cloud_build_upload_incomplete";
+var PART_ATTEMPTS = 3;
+var PART_BACKOFF_MS = [500, 2e3];
+var PART_CONCURRENCY2 = 2;
+async function call2(ctx, route, init, log, silent) {
+  let res;
+  try {
+    res = await apiFetch(`${ctx.apiUrl}/api/games/${ctx.projectId}${route}`, {
+      ...init,
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${ctx.token}`, ...init.headers ?? {} }
+    });
+  } catch (err) {
+    log.error(`Couldn't reach the API at ${ctx.apiUrl}: ${String(err)}`);
+    return { ok: false, refusal: { status: 0, body: null } };
+  }
+  const body = await res.clone().json().catch(() => null);
+  if (res.ok && body) return { ok: true, value: body, status: res.status };
+  const error = typeof body?.error === "string" ? body.error : void 0;
+  const refusal2 = { status: res.status, body: body && typeof body === "object" ? body : null, ...error ? { error } : {} };
+  if (res.ok) {
+    log.error(`The API answered HTTP ${res.status} with no build.`);
+    return { ok: false, refusal: refusal2 };
+  }
+  if (silent !== void 0 && error === silent) return { ok: false, refusal: refusal2 };
+  if (res.status === 401) {
+    log.error("Not authorized (HTTP 401) \u2014 your sign-in expired or was revoked.");
+    log.plain("  Fix: run `genex link <your-game>` and sign in as the game's owner, then re-run this command.");
+  } else if (res.status === 404) {
+    log.error(
+      route.includes("/cloud-builds/") ? "No such build for this game (HTTP 404)." : "This account doesn't own this game, or Build on Genex is not on for this stand (HTTP 404)."
+    );
+  } else if (res.status === 429 && error === "rate_limited") {
+    log.error(`Rate limited starting a build (HTTP 429).${retryAfterHint(res)}`);
+  } else if (error === "cloud_build_unavailable") {
+    log.error("Build on Genex isn't available on this stand right now (HTTP 503). Try again later.");
+  } else {
+    const reason = await serverReason(res);
+    log.error(reason ?? `The API refused the build (HTTP ${res.status}).`);
+  }
+  return { ok: false, refusal: refusal2 };
+}
+async function startCloudBuild(ctx, body, log) {
+  const answer = await call2(ctx, "/cloud-builds", { method: "POST", body: JSON.stringify(body) }, log);
+  if (!answer.ok) return answer;
+  const v = answer.value;
+  if (!v.build) {
+    log.error(`The API answered HTTP ${answer.status} with no build.`);
+    return { ok: false, refusal: { status: answer.status, body: answer.value } };
+  }
+  return {
+    ok: true,
+    status: answer.status,
+    value: {
+      status: answer.status,
+      build: v.build,
+      ...v.upload ? { upload: v.upload } : {},
+      ...v.deduplicated ? { deduplicated: true } : {}
+    }
+  };
+}
+async function completeCloudBuildSource(ctx, jobId, parts, log) {
+  const route = `/cloud-builds/${encodeURIComponent(jobId)}/source`;
+  const answer = await call2(ctx, route, { method: "POST", body: JSON.stringify({ parts }) }, log, UPLOAD_INCOMPLETE);
+  if (!answer.ok) return answer;
+  const build = answer.value.build;
+  if (!build) {
+    log.error(`The API answered HTTP ${answer.status} with no build.`);
+    return { ok: false, refusal: { status: answer.status, body: answer.value } };
+  }
+  return { ok: true, status: answer.status, value: build };
+}
+async function readCloudBuild(ctx, jobId, log) {
+  const answer = await call2(ctx, `/cloud-builds/${encodeURIComponent(jobId)}`, { method: "GET" }, log);
+  if (!answer.ok) return answer;
+  const build = answer.value.build;
+  if (!build) {
+    log.error(`The API answered HTTP ${answer.status} with no build.`);
+    return { ok: false, refusal: { status: answer.status, body: answer.value } };
+  }
+  return { ok: true, status: answer.status, value: build };
+}
+async function readPart2(file, position, length) {
+  const buffer = Buffer.alloc(length);
+  const { bytesRead } = await file.read(buffer, 0, length, position);
+  if (bytesRead !== length) throw new Error("the project zip changed while it was being uploaded");
+  return buffer;
+}
+async function putPart(url, bytes, sleep7) {
+  for (let attempt = 0; attempt < PART_ATTEMPTS; attempt++) {
+    let res = null;
+    try {
+      res = await fetch(url, { method: "PUT", body: bytes });
+    } catch {
+      res = null;
+    }
+    if (res?.ok) {
+      const etag = res.headers.get("etag");
+      await res.arrayBuffer().catch(() => void 0);
+      if (etag) return etag;
+    } else if (res && res.status < 500 && res.status !== 408 && res.status !== 429) {
+      return null;
+    }
+    if (attempt < PART_ATTEMPTS - 1) await sleep7(PART_BACKOFF_MS[attempt] ?? 2e3);
+  }
+  return null;
+}
+async function uploadCloudBuildSource(upload, zipPath, sizeBytes, log, onProgress, sleep7 = (ms) => new Promise((resolve) => setTimeout(resolve, ms))) {
+  const parts = [...upload.parts].sort((a, b) => a.partNumber - b.partNumber);
+  const expected = Math.ceil(sizeBytes / upload.partBytes);
+  if (parts.length !== expected || parts.some((p, i) => p.partNumber !== i + 1)) {
+    log.error(`The API sent ${parts.length} upload URLs for a ${expected}-part project. Run this again.`);
+    return null;
+  }
+  const file = await fs49.open(zipPath, "r");
+  const done = [];
+  let sent = 0;
+  let next = 0;
+  let failed = false;
+  try {
+    const worker = async () => {
+      while (!failed) {
+        const index = next++;
+        const part = parts[index];
+        if (!part) return;
+        const start = index * upload.partBytes;
+        const length = Math.min(upload.partBytes, sizeBytes - start);
+        const bytes = await readPart2(file, start, length);
+        const etag = await putPart(part.url, bytes, sleep7);
+        if (!etag) {
+          failed = true;
+          log.error(`Upload failed (part ${part.partNumber}/${parts.length}).`);
+          return;
+        }
+        done.push({ partNumber: part.partNumber, etag });
+        sent += length;
+        onProgress?.(sent);
+      }
+    };
+    await Promise.all(Array.from({ length: Math.min(PART_CONCURRENCY2, parts.length) }, () => worker()));
+  } finally {
+    await file.close();
+  }
+  if (failed) return null;
+  return done.sort((a, b) => a.partNumber - b.partNumber);
+}
+
+// src/lib/source-zip.ts
+import fs50 from "fs/promises";
+import path50 from "path";
+import zlib4 from "zlib";
+var SOURCE_ZIP_ROOT_EXCLUDES = [".genex", "Intermediate", "Saved", "DerivedDataCache", "Binaries"];
+var SOURCE_ZIP_EXCLUDES_ANYWHERE = [".git", ".DS_Store", ".env"];
+var ENV_VARIANT = /^\.env\./;
+var ENV_TEMPLATE = ".env.example";
+var SourceZipError = class extends Error {
+};
+var DOS_TIME = 0;
+var DOS_DATE2 = 0 << 9 | 1 << 5 | 1;
+var UTF8_FLAG = 2048;
+var VERSION_STORED = 20;
+var VERSION_ZIP64 = 45;
+var U16_MAX2 = 65535;
+var U32_MAX2 = 4294967295;
+var CHUNK = 1024 * 1024;
+var isExcludedAnywhere = (name) => SOURCE_ZIP_EXCLUDES_ANYWHERE.includes(name) || ENV_VARIANT.test(name) && name !== ENV_TEMPLATE;
+function inside(root, target) {
+  const rel = path50.relative(root, target);
+  return rel === "" || rel !== ".." && !rel.startsWith(`..${path50.sep}`) && !path50.isAbsolute(rel);
+}
+async function plan(root) {
+  const entries = [];
+  const skippedLinks = [];
+  const walk2 = async (dir, rel) => {
+    const children = await fs50.readdir(dir, { withFileTypes: true });
+    let kept = 0;
+    for (const child of children) {
+      const name = child.name;
+      const childRel = rel ? `${rel}/${name}` : name;
+      const abs = path50.join(dir, name);
+      if (isExcludedAnywhere(name)) continue;
+      if (!rel && SOURCE_ZIP_ROOT_EXCLUDES.includes(name)) continue;
+      if (child.isSymbolicLink()) {
+        const target = await fs50.realpath(abs).catch(() => null);
+        if (target !== null && !inside(root, target)) {
+          throw new SourceZipError(
+            `${childRel} is a link to ${target}, outside the folder being built. Copy what it points to into the project, or remove the link.`
+          );
+        }
+        skippedLinks.push(childRel);
+        continue;
+      }
+      if (child.isDirectory()) {
+        kept++;
+        await walk2(abs, childRel);
+      } else if (child.isFile()) {
+        kept++;
+        const { size } = await fs50.stat(abs);
+        entries.push({ name: childRel, abs, size });
+      }
+    }
+    if (rel && kept === 0) entries.push({ name: `${rel}/`, size: 0 });
+  };
+  await walk2(root, "");
+  entries.sort((a, b) => Buffer.compare(Buffer.from(a.name, "utf8"), Buffer.from(b.name, "utf8")));
+  skippedLinks.sort();
+  return { entries, skippedLinks };
+}
+var crcTable = (() => {
+  const table = new Uint32Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c2 = n;
+    for (let k = 0; k < 8; k++) c2 = c2 & 1 ? 3988292384 ^ c2 >>> 1 : c2 >>> 1;
+    table[n] = c2 >>> 0;
+  }
+  return table;
+})();
+var zlibCrc = zlib4.crc32;
+function crc32(data, value) {
+  if (zlibCrc) return zlibCrc(data, value);
+  let c2 = (value ^ U32_MAX2) >>> 0;
+  for (let i = 0; i < data.length; i++) c2 = crcTable[(c2 ^ data[i]) & 255] ^ c2 >>> 8;
+  return (c2 ^ U32_MAX2) >>> 0;
+}
+var Out = class {
+  position = 0;
+  file;
+  constructor(file) {
+    this.file = file;
+  }
+  async write(buffer) {
+    let done = 0;
+    while (done < buffer.length) {
+      const { bytesWritten } = await this.file.write(buffer, done, buffer.length - done, this.position + done);
+      done += bytesWritten;
+    }
+    this.position += buffer.length;
+  }
+  async patch(at, buffer) {
+    await this.file.write(buffer, 0, buffer.length, at);
+  }
+};
+async function writeSourceZip(root, zipPath, opts = {}) {
+  const { entries, skippedLinks } = await plan(await fs50.realpath(root));
+  const file = await fs50.open(zipPath, "w");
+  const out = new Out(file);
+  const central = [];
+  let contentBytes = 0;
+  const chunk = Buffer.alloc(CHUNK);
+  try {
+    for (const entry of entries) {
+      const name = Buffer.from(entry.name, "utf8");
+      const offset = out.position;
+      const bigSize = opts.forceZip64 || entry.size >= U32_MAX2;
+      const bigOffset = opts.forceZip64 || offset >= U32_MAX2;
+      const localExtra = bigSize ? zip64Extra([entry.size, entry.size]) : Buffer.alloc(0);
+      const local = Buffer.alloc(30);
+      local.writeUInt32LE(67324752, 0);
+      local.writeUInt16LE(bigSize ? VERSION_ZIP64 : VERSION_STORED, 4);
+      local.writeUInt16LE(UTF8_FLAG, 6);
+      local.writeUInt16LE(0, 8);
+      local.writeUInt16LE(DOS_TIME, 10);
+      local.writeUInt16LE(DOS_DATE2, 12);
+      local.writeUInt32LE(0, 14);
+      local.writeUInt32LE(bigSize ? U32_MAX2 : entry.size, 18);
+      local.writeUInt32LE(bigSize ? U32_MAX2 : entry.size, 22);
+      local.writeUInt16LE(name.length, 26);
+      local.writeUInt16LE(localExtra.length, 28);
+      await out.write(Buffer.concat([local, name, localExtra]));
+      let crc = 0;
+      if (entry.abs) {
+        const source = await fs50.open(entry.abs, "r");
+        try {
+          let read = 0;
+          for (; ; ) {
+            const { bytesRead } = await source.read(chunk, 0, CHUNK, read);
+            if (bytesRead === 0) break;
+            read += bytesRead;
+            if (read > entry.size) break;
+            const piece = chunk.subarray(0, bytesRead);
+            crc = crc32(piece, crc);
+            await out.write(piece);
+          }
+          if (read !== entry.size) throw new SourceZipError(`${entry.name} changed while it was being zipped. Close the editor and run this again.`);
+        } finally {
+          await source.close();
+        }
+        contentBytes += entry.size;
+        const crcBytes = Buffer.alloc(4);
+        crcBytes.writeUInt32LE(crc >>> 0, 0);
+        await out.patch(offset + 14, crcBytes);
+      }
+      const centralFields = [];
+      if (bigSize) centralFields.push(entry.size, entry.size);
+      if (bigOffset) centralFields.push(offset);
+      const centralExtra = centralFields.length ? zip64Extra(centralFields) : Buffer.alloc(0);
+      const needs64 = bigSize || bigOffset;
+      const head = Buffer.alloc(46);
+      head.writeUInt32LE(33639248, 0);
+      head.writeUInt16LE(needs64 ? VERSION_ZIP64 : VERSION_STORED, 4);
+      head.writeUInt16LE(needs64 ? VERSION_ZIP64 : VERSION_STORED, 6);
+      head.writeUInt16LE(UTF8_FLAG, 8);
+      head.writeUInt16LE(0, 10);
+      head.writeUInt16LE(DOS_TIME, 12);
+      head.writeUInt16LE(DOS_DATE2, 14);
+      head.writeUInt32LE(crc >>> 0, 16);
+      head.writeUInt32LE(bigSize ? U32_MAX2 : entry.size, 20);
+      head.writeUInt32LE(bigSize ? U32_MAX2 : entry.size, 24);
+      head.writeUInt16LE(name.length, 28);
+      head.writeUInt16LE(centralExtra.length, 30);
+      head.writeUInt16LE(0, 32);
+      head.writeUInt16LE(0, 34);
+      head.writeUInt16LE(0, 36);
+      head.writeUInt32LE(entry.abs ? 0 : 16, 38);
+      head.writeUInt32LE(bigOffset ? U32_MAX2 : offset, 42);
+      central.push(head, name, centralExtra);
+    }
+    const directoryOffset = out.position;
+    const directory = Buffer.concat(central);
+    await out.write(directory);
+    const count = entries.length;
+    const end64 = opts.forceZip64 || count >= U16_MAX2 || directory.length >= U32_MAX2 || directoryOffset >= U32_MAX2;
+    if (end64) {
+      const recordOffset = out.position;
+      const record = Buffer.alloc(56);
+      record.writeUInt32LE(101075792, 0);
+      record.writeBigUInt64LE(44n, 4);
+      record.writeUInt16LE(VERSION_ZIP64, 12);
+      record.writeUInt16LE(VERSION_ZIP64, 14);
+      record.writeUInt32LE(0, 16);
+      record.writeUInt32LE(0, 20);
+      record.writeBigUInt64LE(BigInt(count), 24);
+      record.writeBigUInt64LE(BigInt(count), 32);
+      record.writeBigUInt64LE(BigInt(directory.length), 40);
+      record.writeBigUInt64LE(BigInt(directoryOffset), 48);
+      const locator = Buffer.alloc(20);
+      locator.writeUInt32LE(117853008, 0);
+      locator.writeUInt32LE(0, 4);
+      locator.writeBigUInt64LE(BigInt(recordOffset), 8);
+      locator.writeUInt32LE(1, 16);
+      await out.write(Buffer.concat([record, locator]));
+    }
+    const end = Buffer.alloc(22);
+    end.writeUInt32LE(101010256, 0);
+    end.writeUInt16LE(end64 ? U16_MAX2 : count, 8);
+    end.writeUInt16LE(end64 ? U16_MAX2 : count, 10);
+    end.writeUInt32LE(end64 ? U32_MAX2 : directory.length, 12);
+    end.writeUInt32LE(end64 ? U32_MAX2 : directoryOffset, 16);
+    await out.write(end);
+  } finally {
+    await file.close();
+  }
+  return { entries: entries.length, contentBytes, skippedLinks };
+}
+function zip64Extra(values) {
+  const extra = Buffer.alloc(4 + values.length * 8);
+  extra.writeUInt16LE(1, 0);
+  extra.writeUInt16LE(values.length * 8, 2);
+  values.forEach((v, i) => extra.writeBigUInt64LE(BigInt(v), 4 + i * 8));
+  return extra;
+}
+async function resolveZipSource(dir, cwd = process.cwd()) {
+  const abs = path50.resolve(cwd, dir);
+  const stat = await fs50.lstat(abs).catch(() => null);
+  if (!stat) return { refused: `--source ${abs} does not exist.` };
+  if (stat.isSymbolicLink()) return { refused: `--source ${abs} is a symbolic link. Pass the folder itself.` };
+  if (!stat.isDirectory()) return { refused: `--source ${abs} is not a folder.` };
+  return { dir: await fs50.realpath(abs) };
+}
+
 // src/commands/native.ts
 var PROGRESS_STEPS = 10;
 var MB2 = 1024 * 1024;
@@ -30638,9 +31017,9 @@ async function context3(opts, log) {
   }
   return { apiUrl, projectId: meta.id, token };
 }
-function refusedInHostedSession(log) {
+function refusedInHostedSession(log, line = "Native builds are published from the creator's own computer, not from a hosted session.") {
   if (!inHostedSession()) return false;
-  log.error("Native builds are published from the creator's own computer, not from a hosted session.");
+  log.error(line);
   return true;
 }
 function sizeLine(bytes) {
@@ -30779,16 +31158,184 @@ async function runRemove(opts, log) {
   log.success(`Removed the ${opts.platform} ${opts.arch} build. Copies already installed keep working.`);
   return true;
 }
+var CLOUD_HOSTED_REFUSAL = "Build on Genex is started from the creator's own computer, not from a hosted session.";
+var FAILURE_WORDS = {
+  "engine-unsupported": "the project's Unreal version isn't one the build machine has",
+  compile: "the game's code didn't compile",
+  cook: "cooking the game's content failed",
+  timeout: "the build ran past its time limit",
+  quota: "this account has used its builds for the month",
+  "source-too-big": "the project is over the size limit",
+  "not-on-genex": "the game has no page on Genex yet",
+  failed: "the build machine stopped or its result failed the checks"
+};
+var STATE_WORDS = {
+  queued: "Queued",
+  building: "Building",
+  publishing: "Publishing",
+  done: "Built",
+  failed: "Failed"
+};
+function printRefusal(opts, refusal2) {
+  if (opts.json && refusal2.body) console.log(JSON.stringify(refusal2.body));
+}
+function stateLine(build) {
+  const state = STATE_WORDS[build.state] ?? build.state;
+  if (build.state !== "failed") return `${state} \u2014 ${build.platform} build ${build.jobId}`;
+  const why = build.failure ? `: ${FAILURE_WORDS[build.failure] ?? build.failure} (${build.failure})` : "";
+  return `${state}${why} \u2014 ${build.platform} build ${build.jobId}`;
+}
+function reportCloudBuild(build, how, log) {
+  if (how === "deduplicated") {
+    log.success(`Already built (no change since): ${stateLine(build)}`);
+    return;
+  }
+  const line = how === "running" ? `Already building: ${stateLine(build)}` : stateLine(build);
+  if (build.state === "failed") log.warn(line);
+  else log.success(line);
+  if (build.state !== "done" && build.state !== "failed") {
+    log.dim(`  Follow it: genex native build-status ${build.jobId}`);
+    log.dim("  When it is done the build is attached to the game's page (held for review unless you are a Genex admin).");
+  }
+}
+async function runBuild(opts, log) {
+  if (refusedInHostedSession(log, CLOUD_HOSTED_REFUSAL)) return false;
+  if (!opts.platform || !isCloudBuildPlatform(opts.platform)) {
+    log.error("Which platform? `genex native build --platform windows --source <folder>` (windows, linux or mac).");
+    return false;
+  }
+  if (!opts.sourceDir) {
+    log.error("Which project? `genex native build --platform windows --source <folder>` \u2014 the folder holding the .uproject.");
+    return false;
+  }
+  if (opts.buildVersion !== void 0) {
+    try {
+      buildVersion(opts.buildVersion, void 0, "");
+    } catch (err) {
+      if (!(err instanceof NativeBuildError)) throw err;
+      log.error(err.message);
+      return false;
+    }
+  }
+  const source = await resolveZipSource(opts.sourceDir);
+  if ("refused" in source) {
+    log.error(source.refused);
+    return false;
+  }
+  const ctx = await context3(opts, log);
+  if (!ctx) return false;
+  const tmp = await fs51.mkdtemp(path51.join(os15.tmpdir(), "genex-cloud-build-"));
+  const zipPath = path51.join(tmp, "source.zip");
+  try {
+    log.step(`Zipping ${source.dir}\u2026`);
+    let zipped;
+    try {
+      zipped = await writeSourceZip(source.dir, zipPath);
+    } catch (err) {
+      if (!(err instanceof SourceZipError)) throw err;
+      log.error(err.message);
+      return false;
+    }
+    if (zipped.entries === 0) {
+      log.error(`${source.dir} has nothing to build in it.`);
+      return false;
+    }
+    if (zipped.skippedLinks.length > 0) {
+      const shown = zipped.skippedLinks.slice(0, 5).join(", ");
+      const more = zipped.skippedLinks.length > 5 ? ` and ${zipped.skippedLinks.length - 5} more` : "";
+      log.warn(`Left out ${zipped.skippedLinks.length} link(s) inside the folder: ${shown}${more}.`);
+    }
+    const { sha256: sha2564, sizeBytes } = await hashFile(zipPath);
+    log.step(`${zipped.entries} files, ${sizeLine(sizeBytes)} zipped.`);
+    const body = {
+      platform: opts.platform,
+      sourceSha256: sha2564,
+      sourceBytes: sizeBytes,
+      ...opts.buildVersion !== void 0 ? { version: opts.buildVersion } : {}
+    };
+    const started = await startCloudBuild(ctx, body, log);
+    if (!started.ok) {
+      printRefusal(opts, started.refusal);
+      return false;
+    }
+    let build = started.value.build;
+    let upload = started.value.upload;
+    const how = started.value.deduplicated ? "deduplicated" : started.value.status === 201 ? "new" : "running";
+    let uploaded = false;
+    for (let round2 = 0; upload; round2++) {
+      log.step(`Uploading ${sizeLine(sizeBytes)}\u2026`);
+      const parts = await uploadCloudBuildSource(upload, zipPath, sizeBytes, log, progress(log, "uploaded", sizeBytes));
+      if (!parts) return false;
+      const done = await completeCloudBuildSource(ctx, build.jobId, parts, log);
+      if (done.ok) {
+        build = done.value;
+        uploaded = true;
+        break;
+      }
+      if (done.refusal.error !== UPLOAD_INCOMPLETE) {
+        printRefusal(opts, done.refusal);
+        return false;
+      }
+      if (round2 > 0) {
+        log.error("The upload still isn't complete after sending it twice. Run this again.");
+        printRefusal(opts, done.refusal);
+        return false;
+      }
+      log.warn("Some parts did not arrive. Sending the project again\u2026");
+      const again = await startCloudBuild(ctx, body, log);
+      if (!again.ok) {
+        printRefusal(opts, again.refusal);
+        return false;
+      }
+      build = again.value.build;
+      upload = again.value.upload;
+    }
+    reportCloudBuild(build, how === "running" && uploaded ? "new" : how, log);
+    if (opts.json) console.log(JSON.stringify({ build }));
+    return true;
+  } finally {
+    await fs51.rm(tmp, { recursive: true, force: true });
+  }
+}
+async function runBuildStatus(opts, log) {
+  if (refusedInHostedSession(log, CLOUD_HOSTED_REFUSAL)) return false;
+  if (!opts.jobId || !CLOUD_BUILD_JOB_ID.test(opts.jobId)) {
+    log.error(
+      opts.jobId ? `"${opts.jobId}" is not a build id. \`genex native build\` prints one (cb-\u2026).` : "Which build? `genex native build-status <jobId>` \u2014 the id `genex native build` printed."
+    );
+    return false;
+  }
+  const ctx = await context3(opts, log);
+  if (!ctx) return false;
+  const read = await readCloudBuild(ctx, opts.jobId, log);
+  if (!read.ok) {
+    printRefusal(opts, read.refusal);
+    return false;
+  }
+  const build = read.value;
+  if (opts.json) {
+    console.log(JSON.stringify({ build }));
+    return true;
+  }
+  if (build.state === "failed") log.warn(stateLine(build));
+  else log.success(stateLine(build));
+  log.dim(`  Started ${build.startedAt}${build.finishedAt ? `, finished ${build.finishedAt}` : ""}.`);
+  return true;
+}
 var SUBCOMMANDS2 = {
   publish: runPublish2,
   list: runList2,
-  remove: runRemove
+  remove: runRemove,
+  build: runBuild,
+  "build-status": runBuildStatus
 };
 async function runNative(opts) {
   const log = loggerFor2(opts);
   const run5 = opts.name ? SUBCOMMANDS2[opts.name] : void 0;
   if (!run5) {
-    log.error("Unknown native command. Use `genex native publish <path>`, `genex native list` or `genex native remove`.");
+    log.error(
+      "Unknown native command. Use `genex native publish <path>`, `genex native list`, `genex native remove`, `genex native build` or `genex native build-status <jobId>`."
+    );
     process.exitCode = 1;
     return;
   }
@@ -30987,10 +31534,13 @@ ${c.bold("Usage")}
                                      version back, instantly \u2014 your code is not
                                      changed, only what the play URL serves.
   genex native <sub> [options]       This game's Mac/Windows/Linux builds for the Genex
-                                     desktop app: publish <path> | list | remove.
+                                     desktop app: publish <path> | list | remove |
+                                     build | build-status <jobId>.
                                      "publish" takes a .zip, a .app or the build's
                                      folder and makes it what desktop players install
                                      for its platform and processor, live at once.
+                                     "build --platform windows --source <folder>" has
+                                     Genex build the Windows app of an Unreal project.
   genex web remove [--yes] [--json]  Remove this game's web version and keep its
                                      Mac/Windows/Linux apps: the page shows the apps
                                      again. Refused for a game with no app.
@@ -31866,6 +32416,21 @@ ${c.bold("Usage")}
   genex native remove --platform <p> --arch <a> --yes
                                      Stop offering one build. Installed copies keep working.
 
+${c.bold("Build on Genex")} (an Unreal project, built for a system this computer can't build for)
+  genex native build --platform windows --source <folder> [--build-version <v>]
+                                     Zip the project folder (the same files always give
+                                     the same zip, so an unchanged project is not built
+                                     twice), upload it privately, and build it on a Genex
+                                     machine. The result is attached to the game's page
+                                     like a published build. Left out: .git, .genex,
+                                     .DS_Store, .env files, and the top-level Intermediate,
+                                     Saved, DerivedDataCache and Binaries folders. A link
+                                     out of the folder is refused; one inside it is skipped.
+  genex native build-status <jobId>  Where that build stands: queued, building,
+                                     publishing, done or failed (with why).
+  --json                             One JSON object on stdout ({"build": \u2026}); a refusal
+                                     prints the server's error body and exits 1.
+
 ${c.bold("Read from the build, or set")}
   --platform mac|windows|linux       A .app at the archive's root is mac, an .exe windows.
   --arch arm64|x64|universal         From the app's executable header.
@@ -32357,6 +32922,8 @@ function parseArgs(argv) {
         } else if (parsed.command === "native") {
           if (parsed.options.name === "publish" && parsed.options.nativePath === void 0) {
             parsed.options.nativePath = arg;
+          } else if (parsed.options.name === "build-status" && parsed.options.jobId === void 0) {
+            parsed.options.jobId = arg;
           } else {
             parsed.error = `Unexpected argument: ${arg}`;
             return parsed;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@genex-ai/cli-demo",
-  "version": "1.36.20-dev.1078",
+  "version": "1.38.0-dev.1079",
   "description": "Set up your project's agent workspace (.claude/.codex/.cursor in the game folder), authorize, create a game project, generate AI assets, and publish (genex CLI).",
   "type": "module",
   "bin": {