@genex-ai/cli-demo 1.36.10-dev.965 → 1.36.11-dev.967

package/dist/index.js

@@ -219,8 +219,8 @@ var pending = /* @__PURE__ */ new Set();
 function setSentryTag(key, value) {
   tags[key] = value;
 }
-function setSentryContext(name, context3) {
-  contexts[name] = context3;
+function setSentryContext(name, context4) {
+  contexts[name] = context4;
 }
 function beforeSend(event, hint) {
   const e = event;
@@ -1924,8 +1924,8 @@ async function ensureLocalCli(log, cwd = process.cwd(), opts = {}) {
   const spec = `${CLI_PACKAGE}@${CLI_CHANNEL}`;
   const { command, args } = installArgs(pm, spec);
   log.step(`Adding ${c.cyan(CLI_PACKAGE)} as a devDependency (${pm}) so npx genex resolves here\u2026`);
-  const run4 = opts.runner ?? spawnInstall;
-  const result = await run4(command, args, cwd);
+  const run5 = opts.runner ?? spawnInstall;
+  const result = await run5(command, args, cwd);
   if (result.ok) {
     log.success(`${c.cyan("npx genex")} now resolves in this folder.`);
   } else {
@@ -2255,13 +2255,13 @@ async function countFailed(kind, cwd = process.cwd()) {
 }
 async function trailingFailures(kind, cwd = process.cwd()) {
   const rows = (await readLedger(cwd)).filter((e) => e.kind === kind);
-  let run4 = 0;
+  let run5 = 0;
   for (let i = rows.length - 1; i >= 0; i -= 1) {
     const status2 = rows[i].status;
     if (status2 === "completed") break;
-    if (status2 === "failed") run4 += 1;
+    if (status2 === "failed") run5 += 1;
   }
-  return run4;
+  return run5;
 }
 async function countOutcomes(kind, cwd = process.cwd()) {
   const rows = (await readLedger(cwd)).filter((e) => e.kind === kind);
@@ -3076,15 +3076,15 @@ async function detectSurfaceScan(cwd = process.cwd()) {
         detail: `repeat.set(${m[1]}, ${m[2]})`
       });
     }
-    for (const call of ctorArgs(content, "PointsMaterial")) {
-      if (/\b(map|alphaMap)\s*:/.test(call.text)) continue;
+    for (const call2 of ctorArgs(content, "PointsMaterial")) {
+      if (/\b(map|alphaMap)\s*:/.test(call2.text)) continue;
       found.squarePoints.push({
-        where: `${rel}:${lineOf(content, call.index)}`,
+        where: `${rel}:${lineOf(content, call2.index)}`,
         detail: "PointsMaterial with no map/alphaMap"
       });
     }
-    for (const call of ctorArgs(content, "PerspectiveCamera")) {
-      const args = splitArgs(call.text);
+    for (const call2 of ctorArgs(content, "PerspectiveCamera")) {
+      const args = splitArgs(call2.text);
       if (args.length < 4) continue;
       const near = Number(args[2]);
       const far = Number(args[3]);
@@ -3092,7 +3092,7 @@ async function detectSurfaceScan(cwd = process.cwd()) {
       const ratio = far / near;
       if (ratio <= DEPTH_RATIO_LIMIT) continue;
       found.depthRange.push({
-        where: `${rel}:${lineOf(content, call.index)}`,
+        where: `${rel}:${lineOf(content, call2.index)}`,
         detail: `near ${near} / far ${far}`,
         ratio
       });
@@ -3387,7 +3387,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 call of dialogCalls(content)) add(found.dialogs, call.index, `${call.name}()`);
+    for (const call2 of dialogCalls(content)) add(found.dialogs, call2.index, `${call2.name}()`);
     for (const m of content.matchAll(SERVICE_WORKER)) {
       add(found.serviceWorker, m.index, "serviceWorker.register");
     }
@@ -4235,32 +4235,32 @@ async function uiExtract(opts, log) {
   if (dilatePx > 0) {
     const tmp = new Uint8Array(W * H);
     for (let y = 0; y < H; y++) {
-      let run4 = 0;
+      let run5 = 0;
       for (let x = 0; x < W; x++) {
-        if (subject[y * W + x]) run4 = dilatePx;
-        else if (run4 > 0) run4--;
-        tmp[y * W + x] = run4 > 0 || subject[y * W + x] ? 1 : 0;
+        if (subject[y * W + x]) run5 = dilatePx;
+        else if (run5 > 0) run5--;
+        tmp[y * W + x] = run5 > 0 || subject[y * W + x] ? 1 : 0;
       }
-      run4 = 0;
+      run5 = 0;
       for (let x = W - 1; x >= 0; x--) {
-        if (subject[y * W + x]) run4 = dilatePx;
-        else if (run4 > 0) run4--;
-        if (run4 > 0) tmp[y * W + x] = 1;
+        if (subject[y * W + x]) run5 = dilatePx;
+        else if (run5 > 0) run5--;
+        if (run5 > 0) tmp[y * W + x] = 1;
       }
     }
     const tmp2 = new Uint8Array(W * H);
     for (let x = 0; x < W; x++) {
-      let run4 = 0;
+      let run5 = 0;
       for (let y = 0; y < H; y++) {
-        if (tmp[y * W + x]) run4 = dilatePx;
-        else if (run4 > 0) run4--;
-        tmp2[y * W + x] = run4 > 0 || tmp[y * W + x] ? 1 : 0;
+        if (tmp[y * W + x]) run5 = dilatePx;
+        else if (run5 > 0) run5--;
+        tmp2[y * W + x] = run5 > 0 || tmp[y * W + x] ? 1 : 0;
       }
-      run4 = 0;
+      run5 = 0;
       for (let y = H - 1; y >= 0; y--) {
-        if (tmp[y * W + x]) run4 = dilatePx;
-        else if (run4 > 0) run4--;
-        if (run4 > 0) tmp2[y * W + x] = 1;
+        if (tmp[y * W + x]) run5 = dilatePx;
+        else if (run5 > 0) run5--;
+        if (run5 > 0) tmp2[y * W + x] = 1;
       }
     }
     connect = tmp2;
@@ -8358,14 +8358,14 @@ async function runDomain(opts) {
   }
   const base = `${apiUrl}/api/projects/${encodeURIComponent(meta.id)}/domains`;
   const auth = { Authorization: `Bearer ${token}` };
-  const call = (url, init) => apiFetch(url, { ...init, headers: { ...auth, "Content-Type": "application/json", ...init?.headers ?? {} } });
+  const call2 = (url, init) => apiFetch(url, { ...init, headers: { ...auth, "Content-Type": "application/json", ...init?.headers ?? {} } });
   let res;
   try {
-    if (sub === "list") res = await call(base);
-    else if (sub === "add") res = await call(base, { method: "POST", body: JSON.stringify({ hostname }) });
+    if (sub === "list") res = await call2(base);
+    else if (sub === "add") res = await call2(base, { method: "POST", body: JSON.stringify({ hostname }) });
     else if (sub === "verify")
-      res = await call(`${base}/${encodeURIComponent(hostname)}/verify`, { method: "POST" });
-    else res = await call(`${base}/${encodeURIComponent(hostname)}`, { method: "DELETE" });
+      res = await call2(`${base}/${encodeURIComponent(hostname)}/verify`, { method: "POST" });
+    else res = await call2(`${base}/${encodeURIComponent(hostname)}`, { method: "DELETE" });
   } catch (err) {
     log.error(`Couldn't reach the API at ${apiUrl}.`);
     log.dim(`  ${String(err)}`);
@@ -8506,7 +8506,7 @@ async function runShop(opts) {
     await writeUserToken(token, opts.envPath, apiUrl);
   }
   const auth = { Authorization: `Bearer ${token}`, "Content-Type": "application/json" };
-  const call = (url, init) => apiFetch(url, { ...init, headers: { ...auth, ...init?.headers ?? {} } });
+  const call2 = (url, init) => apiFetch(url, { ...init, headers: { ...auth, ...init?.headers ?? {} } });
   const projectSkus = `${apiUrl}/api/coin/projects/${encodeURIComponent(meta.id)}/skus`;
   async function fail5(res2, what) {
     if (printedStructuredError(res2)) {
@@ -8528,7 +8528,7 @@ async function runShop(opts) {
     }
   }
   if (sub === "list") {
-    const res2 = await call(projectSkus);
+    const res2 = await call2(projectSkus);
     if (!res2.ok) return fail5(res2, "read your shop");
     const body = await res2.json();
     if (opts.json) {
@@ -8564,7 +8564,7 @@ async function runShop(opts) {
       process.exitCode = 1;
       return;
     }
-    const res2 = await call(projectSkus, {
+    const res2 = await call2(projectSkus, {
       method: "POST",
       body: JSON.stringify({
         name,
@@ -8594,7 +8594,7 @@ async function runShop(opts) {
   }
   const skuUrl = `${apiUrl}/api/coin/skus/${encodeURIComponent(skuId)}`;
   if (sub === "test") {
-    const res2 = await call(`${skuUrl}/test-grant`, { method: "POST" });
+    const res2 = await call2(`${skuUrl}/test-grant`, { method: "POST" });
     if (!res2.ok) return fail5(res2, "grant yourself a test copy");
     const got = await res2.json();
     log.success(`You now own ${c.cyan(got.name)} in this game.`);
@@ -8617,14 +8617,14 @@ async function runShop(opts) {
       process.exitCode = 1;
       return;
     }
-    const res2 = await call(skuUrl, { method: "PATCH", body: JSON.stringify(patch) });
+    const res2 = await call2(skuUrl, { method: "PATCH", body: JSON.stringify(patch) });
     if (!res2.ok) return fail5(res2, "update that item");
     const sku = await res2.json();
     log.success(`Updated ${c.cyan(sku.name)} \u2014 ${sku.priceCoins} coin.`);
     if (opts.resellable === false) log.dim("  Listings already on the market stay up.");
     return;
   }
-  const res = await call(skuUrl, { method: "DELETE" });
+  const res = await call2(skuUrl, { method: "DELETE" });
   if (!res.ok) return fail5(res, "remove that item");
   log.success("Removed from the shop.");
   log.dim("  Players who already bought it keep it.");
@@ -10599,10 +10599,10 @@ function reportLocalFiles(result, log, json) {
   }
 }
 function laneFailureAdvice(kind, outcomes) {
-  const run4 = outcomes.trailingFailed ?? (outcomes.completed > 0 ? 0 : outcomes.failed);
-  if (run4 < 2) return null;
+  const run5 = outcomes.trailingFailed ?? (outcomes.completed > 0 ? 0 : outcomes.failed);
+  if (run5 < 2) return null;
   const everSucceeded = outcomes.completed > 0;
-  const opening = everSucceeded ? `\u270B the last ${run4} ${kind} generations in this project all failed.` : `\u270B ${run4} ${kind} generations attempted in this project, ${run4} failed, none succeeded.`;
+  const opening = everSucceeded ? `\u270B the last ${run5} ${kind} generations in this project all failed.` : `\u270B ${run5} ${kind} generations attempted in this project, ${run5} failed, none succeeded.`;
   return `  ${c.bold(opening)} That pattern is the LANE, not your prompt \u2014 a fourth attempt bills the same and returns the same. Build this one in code, use a different lane, or tell the user in one plain line what is unavailable and carry on with the rest of the game.`;
 }
 function videoFailureAdvice(failures) {
@@ -21453,7 +21453,7 @@ async function runWorkflow(args) {
     created.id,
     args.kind,
     args.opts.json ? () => {
-    } : (progress) => log.dim(`  ${progress}%`)
+    } : (progress2) => log.dim(`  ${progress2}%`)
   );
   if (!view) {
     fail3(args.opts, "Timed out waiting for the character workflow.", args.kind);
@@ -21849,22 +21849,22 @@ async function context2(opts) {
   if (!token) return null;
   return { token, apiUrl };
 }
-async function readVideo(path46, log) {
+async function readVideo(path47, log) {
   let bytes;
   try {
-    bytes = await readFile(path46);
+    bytes = await readFile(path47);
   } catch {
-    log.error(`Can't read ${path46}.`);
+    log.error(`Can't read ${path47}.`);
     return null;
   }
   if (bytes.byteLength > MAX_VIDEO_BYTES) {
-    log.error(`${basename(path46)} is ${(bytes.byteLength / 1e6).toFixed(0)} MB \u2014 the limit is ${MAX_VIDEO_BYTES / 1e6} MB.`);
+    log.error(`${basename(path47)} 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, path46, bytes, log) {
-  const contentType = /\.mov$/i.test(path46) ? "video/quicktime" : "video/mp4";
+async function uploadVideo(apiUrl, token, characterId, path47, bytes, log) {
+  const contentType = /\.mov$/i.test(path47) ? "video/quicktime" : "video/mp4";
   const minted = await apiFetch(
     `${apiUrl}/api/characters/${encodeURIComponent(characterId)}/motions/video-url`,
     {
@@ -21879,7 +21879,7 @@ async function uploadVideo(apiUrl, token, characterId, path46, bytes, log) {
     return null;
   }
   const { uploadUrl, videoUrl } = await minted.json();
-  log.dim(`  uploading ${basename(path46)} (${(bytes.byteLength / 1e6).toFixed(1)} MB)\u2026`);
+  log.dim(`  uploading ${basename(path47)} (${(bytes.byteLength / 1e6).toFixed(1)} MB)\u2026`);
   const put = await fetch(uploadUrl, {
     method: "PUT",
     headers: { "Content-Type": contentType, "Content-Length": String(bytes.byteLength) },
@@ -22879,11 +22879,11 @@ function mAimhold(C, w) {
   const r = yawMed * Math.PI / 180;
   const axis = [Math.sin(r), 0, Math.cos(r)];
   const fwdF = fwdSrc.map(({ v, L }) => (v[0] * axis[0] + v[1] * axis[1] + v[2] * axis[2]) / (L + 1e-9));
-  let run4 = 0, best = 0;
+  let run5 = 0, best = 0;
   for (let i = 0; i < fwdF.length; i++) {
     const ok = dev[i] < 15 && dyF[i] < -0.22 && gapF[i] > 0.18 && gapF[i] < 0.46 && fwdF[i] > 0.75 && hunchF[i] < 16;
-    run4 = ok ? run4 + 1 : 0;
-    best = Math.max(best, run4);
+    run5 = ok ? run5 + 1 : 0;
+    best = Math.max(best, run5);
   }
   let holdBest = 0, holdBestScore = -Infinity;
   for (let i = 0; i < fwdF.length; i++) {
@@ -23237,15 +23237,15 @@ function cutOneshot(t, cfg) {
   const cc = folded(t);
   const air = cc.map((c2) => c2[0] === 0 && c2[1] === 0);
   let best = null;
-  let run4 = null;
+  let run5 = null;
   for (let f = 0; f < air.length; f++) {
-    if (air[f]) run4 = run4 ? [run4[0], f] : [f, f];
+    if (air[f]) run5 = run5 ? [run5[0], f] : [f, f];
     else {
-      if (run4 && (!best || run4[1] - run4[0] > best[1] - best[0])) best = run4;
-      run4 = null;
+      if (run5 && (!best || run5[1] - run5[0] > best[1] - best[0])) best = run5;
+      run5 = null;
     }
   }
-  if (run4 && (!best || run4[1] - run4[0] > best[1] - best[0])) best = run4;
+  if (run5 && (!best || run5[1] - run5[0] > best[1] - best[0])) best = run5;
   let s, e;
   if (best) {
     s = best[0];
@@ -24809,7 +24809,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 call = (url, init) => apiFetch(url, { ...init, headers: { ...auth, ...init?.headers ?? {} } });
+  const call2 = (url, init) => apiFetch(url, { ...init, headers: { ...auth, ...init?.headers ?? {} } });
   let schema;
   if (opts.schemaPath) {
     try {
@@ -24888,7 +24888,7 @@ async function runBench(args) {
     if (!opts.json) log.warn("Stopping \u2014 cancelling the attempt in flight.");
     void (async () => {
       if (target) {
-        await call(`${base}/${encodeURIComponent(target)}/cancel`, { method: "POST" }).catch(() => {
+        await call2(`${base}/${encodeURIComponent(target)}/cancel`, { method: "POST" }).catch(() => {
         });
       }
       process.exit(130);
@@ -24897,7 +24897,7 @@ async function runBench(args) {
   process.once("SIGINT", onSigint);
   try {
     for (let i = 0; i < samples; i++) {
-      const res = await call(base, {
+      const res = await call2(base, {
         method: "POST",
         body: JSON.stringify({
           maxCredits,
@@ -24911,7 +24911,7 @@ async function runBench(args) {
         })
       });
       if (!res.ok) {
-        const verdict = await explainBenchRefusal(res, call, base, log, opts, i, results.length);
+        const verdict = await explainBenchRefusal(res, call2, base, log, opts, i, results.length);
         if (verdict.refusal) refusal2 = verdict.refusal;
         if (verdict.stop) break;
         continue;
@@ -24922,7 +24922,7 @@ async function runBench(args) {
         continue;
       }
       inflight = started.id;
-      const settled = await pollSettled(call, `${base}/${encodeURIComponent(started.id)}`, opts.timeoutSec ?? DEFAULT_SAMPLE_TIMEOUT_SEC);
+      const settled = await pollSettled(call2, `${base}/${encodeURIComponent(started.id)}`, opts.timeoutSec ?? DEFAULT_SAMPLE_TIMEOUT_SEC);
       inflight = null;
       const row = sampleFrom(started.id, settled);
       results.push(row);
@@ -25125,7 +25125,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, call, base, log, opts, index, settledSoFar) {
+async function explainBenchRefusal(res, call2, 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 } };
@@ -25133,7 +25133,7 @@ async function explainBenchRefusal(res, call, base, log, opts, index, settledSoF
   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(call, base);
+    const counts = serverSlotCounts(body) ?? await readSlotCounts(call2, base);
     refusal2.slotsHeld = counts?.held ?? null;
     refusal2.slotLimit = counts?.limit ?? null;
     if (!opts.json) log.error(`  Sample ${index + 1} ${benchSlotsHeldSentence(counts)}`);
@@ -25174,17 +25174,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(call, base) {
-  const res = await call(`${base}?scope=open`).catch(() => null);
+async function readSlotCounts(call2, base) {
+  const res = await call2(`${base}?scope=open`).catch(() => null);
   if (!res?.ok) return null;
   const body = await res.json().catch(() => null);
   return serverSlotCounts(body);
 }
-async function pollSettled(call, url, timeoutSec) {
+async function pollSettled(call2, url, timeoutSec) {
   const deadline = Date.now() + timeoutSec * 1e3;
   let last = null;
   while (Date.now() < deadline) {
-    const res = await call(url).catch(() => null);
+    const res = await call2(url).catch(() => null);
     if (res?.ok) {
       last = await res.json().catch(() => null);
       if (last?.billingStatus === "final") return last;
@@ -25247,9 +25247,9 @@ function emptyBenchJson(apiUrl, projectId, prompt, outputFormat, samples, maxCre
 }
 async function reportStatus(args) {
   const { apiUrl, token, projectId, opts, log } = args;
-  const call = (url, init) => apiFetch(url, { ...init, headers: { Authorization: `Bearer ${token}`, ...init?.headers ?? {} } });
+  const call2 = (url, init) => apiFetch(url, { ...init, headers: { Authorization: `Bearer ${token}`, ...init?.headers ?? {} } });
   const base = `${apiUrl}/api/runtime/development/projects/${encodeURIComponent(projectId)}/generations`;
-  const res = await call(`${base}?scope=open`).catch(() => null);
+  const res = await call2(`${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));
@@ -25340,14 +25340,14 @@ function statusJson(apiUrl, projectId, status2, error, rows, slotsHeld, slotLimi
 }
 async function cancelCall(args) {
   const { apiUrl, token, projectId, id, opts, log } = args;
-  const call = (url, init) => apiFetch(url, { ...init, headers: { Authorization: `Bearer ${token}`, ...init?.headers ?? {} } });
+  const call2 = (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 call(rowUrl).catch(() => null);
+  const read = await call2(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(() => ({})) : {};
@@ -25386,7 +25386,7 @@ async function cancelCall(args) {
     }
     return done("ok", null, state === "awaiting bill" ? "awaiting_bill" : "already_final", row);
   }
-  const res = await call(`${rowUrl}/cancel`, { method: "POST" }).catch(() => null);
+  const res = await call2(`${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(() => ({})) : {};
@@ -26342,14 +26342,14 @@ var PlayerClient = class {
     this.version = options.version ?? getCliVersion();
     this.timeoutMs = options.timeoutMs ?? 3e4;
   }
-  async call(path46, init = {}, provider) {
+  async call(path47, 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}${path46}`, {
+    const res = await apiFetch(`${this.apiUrl}${path47}`, {
       ...init,
       headers,
       signal: AbortSignal.timeout(this.timeoutMs)
@@ -27673,6 +27673,727 @@ function writeJsonLine2(value) {
 `);
 }
 
+// src/lib/native-build.ts
+import { createHash as createHash3 } from "crypto";
+import { createReadStream } from "fs";
+import fs43 from "fs/promises";
+import os13 from "os";
+import path46 from "path";
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+
+// src/lib/native-zip.ts
+import fs42 from "fs/promises";
+import zlib2 from "zlib";
+var EOCD_SIGNATURE = 101010256;
+var EOCD64_LOCATOR_SIGNATURE = 117853008;
+var EOCD64_SIGNATURE = 101075792;
+var CENTRAL_SIGNATURE = 33639248;
+var LOCAL_SIGNATURE = 67324752;
+var EOCD_MIN = 22;
+var COMMENT_MAX = 65535;
+var ZIP64_EXTRA = 1;
+var U32_MAX = 4294967295;
+var U16_MAX = 65535;
+var DIRECTORY_MAX_BYTES = 256 * 1024 * 1024;
+var UNIX_HOST = 3;
+var INPUT_MIN = 64 * 1024;
+var INPUT_MAX = 1024 * 1024;
+var S_IFMT = 61440;
+var S_IFLNK = 40960;
+var isDirectory = (entry) => entry.name.endsWith("/");
+var isSymlink = (entry) => entry.mode !== null && (entry.mode & S_IFMT) === S_IFLNK;
+async function readAt2(file, position, length) {
+  const buffer = Buffer.alloc(length);
+  const { bytesRead } = await file.read(buffer, 0, length, position);
+  return buffer.subarray(0, bytesRead);
+}
+async function findDirectory(file, size) {
+  const tailLength = Math.min(size, EOCD_MIN + COMMENT_MAX);
+  const tail = await readAt2(file, size - tailLength, tailLength);
+  let at = -1;
+  for (let i = tail.length - EOCD_MIN; i >= 0; i--) {
+    if (tail.readUInt32LE(i) === EOCD_SIGNATURE) {
+      at = i;
+      break;
+    }
+  }
+  if (at < 0) throw new Error("not a zip archive (no end-of-directory record)");
+  let count = tail.readUInt16LE(at + 10);
+  let bytes = tail.readUInt32LE(at + 12);
+  let offset = tail.readUInt32LE(at + 16);
+  const zip64 = count === U16_MAX || bytes === U32_MAX || offset === U32_MAX;
+  const locatorAt = at - 20;
+  if (zip64 && locatorAt >= 0 && tail.readUInt32LE(locatorAt) === EOCD64_LOCATOR_SIGNATURE) {
+    const recordOffset = Number(tail.readBigUInt64LE(locatorAt + 8));
+    const record = await readAt2(file, recordOffset, 56);
+    if (record.length < 56 || record.readUInt32LE(0) !== EOCD64_SIGNATURE) throw new Error("broken zip64 directory record");
+    count = Number(record.readBigUInt64LE(32));
+    bytes = Number(record.readBigUInt64LE(40));
+    offset = Number(record.readBigUInt64LE(48));
+  }
+  if (bytes > DIRECTORY_MAX_BYTES || offset + bytes > size) throw new Error("zip directory is out of bounds");
+  return { offset, bytes, count };
+}
+function applyZip64(extra, entry, overflowed) {
+  for (let at = 0; at + 4 <= extra.length; ) {
+    const id = extra.readUInt16LE(at);
+    const length = extra.readUInt16LE(at + 2);
+    if (id === ZIP64_EXTRA) {
+      let field = at + 4;
+      const next = () => {
+        const value = Number(extra.readBigUInt64LE(field));
+        field += 8;
+        return value;
+      };
+      if (overflowed.uncompressed) entry.uncompressedSize = next();
+      if (overflowed.compressed) entry.compressedSize = next();
+      if (overflowed.offset) entry.localOffset = next();
+      return;
+    }
+    at += 4 + length;
+  }
+}
+async function readZipEntries(filePath) {
+  const file = await fs42.open(filePath, "r");
+  try {
+    const { size } = await file.stat();
+    const directory = await findDirectory(file, size);
+    const data = await readAt2(file, directory.offset, directory.bytes);
+    const entries = [];
+    let at = 0;
+    while (entries.length < directory.count && at + 46 <= data.length) {
+      if (data.readUInt32LE(at) !== CENTRAL_SIGNATURE) throw new Error("broken zip directory entry");
+      const madeBy = data.readUInt16LE(at + 4);
+      const nameLength = data.readUInt16LE(at + 28);
+      const extraLength = data.readUInt16LE(at + 30);
+      const commentLength = data.readUInt16LE(at + 32);
+      const external = data.readUInt32LE(at + 38);
+      const entry = {
+        name: data.toString("utf8", at + 46, at + 46 + nameLength),
+        method: data.readUInt16LE(at + 10),
+        compressedSize: data.readUInt32LE(at + 20),
+        uncompressedSize: data.readUInt32LE(at + 24),
+        localOffset: data.readUInt32LE(at + 42),
+        mode: madeBy >> 8 === UNIX_HOST ? external >>> 16 : null
+      };
+      applyZip64(data.subarray(at + 46 + nameLength, at + 46 + nameLength + extraLength), entry, {
+        uncompressed: entry.uncompressedSize === U32_MAX,
+        compressed: entry.compressedSize === U32_MAX,
+        offset: entry.localOffset === U32_MAX
+      });
+      entries.push(entry);
+      at += 46 + nameLength + extraLength + commentLength;
+    }
+    if (entries.length !== directory.count) throw new Error("zip directory ends early");
+    return entries;
+  } finally {
+    await file.close();
+  }
+}
+async function readZipEntryHead(filePath, entry, maxBytes) {
+  const file = await fs42.open(filePath, "r");
+  try {
+    const local = await readAt2(file, entry.localOffset, 30);
+    if (local.length < 30 || local.readUInt32LE(0) !== LOCAL_SIGNATURE) throw new Error(`broken zip entry ${entry.name}`);
+    const start = entry.localOffset + 30 + local.readUInt16LE(26) + local.readUInt16LE(28);
+    if (entry.method === 0) return await readAt2(file, start, Math.min(maxBytes, entry.uncompressedSize));
+    if (entry.method !== 8) throw new Error(`${entry.name} uses a compression this command cannot read`);
+    const input = await readAt2(file, start, Math.min(entry.compressedSize, INPUT_MAX, Math.max(maxBytes, INPUT_MIN)));
+    return await inflateHead(input, maxBytes);
+  } finally {
+    await file.close();
+  }
+}
+function inflateHead(input, maxBytes) {
+  return new Promise((resolve) => {
+    const inflater = zlib2.createInflateRaw();
+    const chunks = [];
+    let total = 0;
+    const finish2 = () => resolve(Buffer.concat(chunks).subarray(0, maxBytes));
+    inflater.on("data", (chunk) => {
+      chunks.push(chunk);
+      total += chunk.length;
+      if (total >= maxBytes) inflater.destroy();
+    });
+    inflater.on("error", finish2);
+    inflater.on("close", finish2);
+    inflater.end(input);
+  });
+}
+
+// src/lib/native-build.ts
+var run4 = promisify2(execFile2);
+var NATIVE_PLATFORMS = ["mac", "windows", "linux"];
+var NATIVE_ARCHES = ["arm64", "x64", "universal"];
+var VERSION = /^[A-Za-z0-9][A-Za-z0-9._+-]*$/;
+var VERSION_MAX = 64;
+var OS_VERSION = /^\d{1,4}(\.\d{1,6}){0,3}$/;
+var ENGINE = /^[a-z][a-z0-9-]{1,39}$/;
+var HEADER_BYTES = 4096;
+var PLIST_BYTES = 1024 * 1024;
+var VERSION_SHA_CHARS = 12;
+var ENTRY_DEPTH_MAX = 4;
+var MACHO_64_LE = 4277009103;
+var FAT_MAGIC = 3405691582;
+var FAT_MAGIC_64 = 3405691583;
+var CPU_X86_64 = 16777223;
+var CPU_ARM64 = 16777228;
+var PE_X64 = 34404;
+var PE_ARM64 = 43620;
+var ELF_X64 = 62;
+var ELF_ARM64 = 183;
+var HELPER_EXE = /crash|prereq|redist|setup|unins/i;
+var NativeBuildError = class extends Error {
+};
+var isPlatform = (value) => NATIVE_PLATFORMS.includes(value);
+var isArch = (value) => NATIVE_ARCHES.includes(value);
+function rootNames(entries) {
+  return new Set(entries.map((e) => e.name.split("/")[0]).filter(Boolean));
+}
+function rootApps(entries) {
+  return [...rootNames(entries)].filter((name) => name.toLowerCase().endsWith(".app") && entries.some((e) => e.name.startsWith(`${name}/`)));
+}
+function launchableExes(entries) {
+  const exes = entries.filter((e) => !isDirectory(e) && e.name.toLowerCase().endsWith(".exe"));
+  const games = exes.filter((e) => e.name.split("/").length <= ENTRY_DEPTH_MAX && !HELPER_EXE.test(path46.posix.basename(e.name)));
+  const depth = (name) => name.split("/").length;
+  return games.map((e) => e.name).sort((a, b) => depth(a) - depth(b) || a.localeCompare(b));
+}
+function platformOf(entries, asked) {
+  if (asked !== void 0) {
+    if (!isPlatform(asked)) throw new NativeBuildError(`--platform must be one of ${NATIVE_PLATFORMS.join(", ")}.`);
+    return asked;
+  }
+  if (rootApps(entries).length > 0) return "mac";
+  if (launchableExes(entries).length > 0) return "windows";
+  const nested = entries.find((e) => /^[^/]+\/[^/]+\.app\/$/i.test(e.name));
+  if (nested) {
+    throw new NativeBuildError(
+      `The Mac app sits inside a folder (${nested.name.slice(0, -1)}). Pass the .app itself, or zip it so it is at the archive's root.`
+    );
+  }
+  throw new NativeBuildError("Couldn't tell which system this build is for. Pass --platform mac|windows|linux.");
+}
+function entryOf(entries, platform, asked) {
+  const files = new Set(entries.map((e) => isDirectory(e) ? e.name.slice(0, -1) : e.name));
+  if (asked !== void 0) {
+    const entry = asked.replace(/\/+$/, "");
+    if (!files.has(entry)) throw new NativeBuildError(`--entry ${asked} is not in the archive.`);
+    return entry;
+  }
+  if (platform === "mac") {
+    const apps = rootApps(entries);
+    if (apps.length === 1) return apps[0];
+    throw new NativeBuildError(
+      apps.length === 0 ? "No .app at the archive's root. Pass the Mac app itself, or zip it so it is at the root." : `More than one app at the archive's root (${apps.join(", ")}). Pass --entry "<name>.app".`
+    );
+  }
+  if (platform === "windows") {
+    const exes = launchableExes(entries);
+    const shallowest = exes.filter((name) => name.split("/").length === exes[0]?.split("/").length);
+    if (shallowest.length === 1) return shallowest[0];
+    throw new NativeBuildError(
+      exes.length === 0 ? "No .exe in the archive. Pass --entry with the program to run." : `More than one program could be the game (${shallowest.join(", ")}). Pass --entry "<path>.exe".`
+    );
+  }
+  throw new NativeBuildError("A Linux build needs --entry: the path of the program to run, from the archive's root.");
+}
+function plistString(plist, key) {
+  const match = new RegExp(`<key>${key}</key>\\s*<string>([^<]*)</string>`).exec(plist);
+  return match?.[1]?.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&amp;/g, "&").trim();
+}
+function machOArches(head) {
+  const found = /* @__PURE__ */ new Set();
+  const add = (cpu) => {
+    if (cpu === CPU_ARM64) found.add("arm64");
+    if (cpu === CPU_X86_64) found.add("x64");
+  };
+  if (head.length < 8) return found;
+  const magic = head.readUInt32BE(0);
+  if (magic === FAT_MAGIC || magic === FAT_MAGIC_64) {
+    const stride = magic === FAT_MAGIC ? 20 : 32;
+    const count = head.readUInt32BE(4);
+    for (let i = 0; i < count && 8 + i * stride + 4 <= head.length; i++) add(head.readUInt32BE(8 + i * stride));
+    return found;
+  }
+  if (head.readUInt32LE(0) === MACHO_64_LE) add(head.readUInt32LE(4));
+  return found;
+}
+function exeArch(head) {
+  if (head.length >= 64 && head.toString("latin1", 0, 2) === "MZ") {
+    const pe = head.readUInt32LE(60);
+    if (pe + 6 > head.length || head.toString("latin1", pe, pe + 4) !== "PE\0\0") return null;
+    const machine = head.readUInt16LE(pe + 4);
+    if (machine === PE_X64) return "x64";
+    if (machine === PE_ARM64) return "arm64";
+    return machine === 332 ? "x86" : null;
+  }
+  if (head.length >= 20 && head.readUInt32BE(0) === 2135247942) {
+    const machine = head.readUInt16LE(18);
+    if (machine === ELF_X64) return "x64";
+    if (machine === ELF_ARM64) return "arm64";
+  }
+  return null;
+}
+function engineOf(entries) {
+  const names2 = entries.map((e) => e.name.toLowerCase());
+  const base = (name) => path46.posix.basename(name.replace(/\/$/, ""));
+  if (names2.some((n) => /^unityplayer\.(dll|dylib|so)$/.test(base(n)) || base(n) === "globalgamemanagers")) return "unity";
+  if (names2.some((n) => n.startsWith("engine/binaries/") || /\.app\/contents\/ue[45]?\//.test(n) || n.includes("/engine/binaries/")))
+    return "unreal";
+  if (names2.some((n) => n.endsWith(".pck"))) return "godot";
+  return void 0;
+}
+async function describeMacApp(zipPath, entries, app) {
+  const plistEntry = entries.find((e) => e.name === `${app}/Contents/Info.plist`);
+  if (!plistEntry) throw new NativeBuildError(`${app} has no Contents/Info.plist \u2014 is it a complete app?`);
+  const plist = (await readZipEntryHead(zipPath, plistEntry, PLIST_BYTES)).toString("utf8");
+  const readable = plist.includes("<plist");
+  const executable = readable ? plistString(plist, "CFBundleExecutable") : void 0;
+  const binary = executable ? entries.find((e) => e.name === `${app}/Contents/MacOS/${executable}`) : void 0;
+  const arches = binary && !isSymlink(binary) ? machOArches(await readZipEntryHead(zipPath, binary, HEADER_BYTES)) : /* @__PURE__ */ new Set();
+  const arch = arches.size === 2 ? "universal" : [...arches][0];
+  return {
+    arch,
+    minOs: readable ? plistString(plist, "LSMinimumSystemVersion") : void 0,
+    appVersion: readable ? plistString(plist, "CFBundleShortVersionString") : void 0
+  };
+}
+async function describeProgram(zipPath, entries, entry) {
+  const file = entries.find((e) => e.name === entry);
+  if (!file || isSymlink(file)) return void 0;
+  const arch = exeArch(await readZipEntryHead(zipPath, file, HEADER_BYTES));
+  if (arch === "x86") throw new NativeBuildError(`${entry} is a 32-bit program. Genex installs 64-bit builds only (x64 or arm64).`);
+  return arch ?? void 0;
+}
+function settleArch(read, asked, platform) {
+  if (asked !== void 0 && !isArch(asked)) throw new NativeBuildError(`--arch must be one of ${NATIVE_ARCHES.join(", ")}.`);
+  const arch = asked ?? read;
+  if (!arch) throw new NativeBuildError("Couldn't read which processor this build is for. Pass --arch arm64|x64|universal.");
+  if (arch === "universal" && platform !== "mac") throw new NativeBuildError("Only a Mac app can be universal.");
+  if (read && asked && read !== asked) {
+    throw new NativeBuildError(`--arch ${asked} does not match the build, which is ${read}.`);
+  }
+  return arch;
+}
+async function describeNativeArchive(zipPath, asked = {}) {
+  let entries;
+  try {
+    entries = await readZipEntries(zipPath);
+  } catch (err) {
+    throw new NativeBuildError(`Couldn't read ${path46.basename(zipPath)} as a zip: ${err.message}`);
+  }
+  if (entries.length === 0) throw new NativeBuildError("The archive is empty.");
+  const platform = platformOf(entries, asked.platform);
+  const entry = entryOf(entries, platform, asked.entry);
+  const mac = platform === "mac" ? await describeMacApp(zipPath, entries, entry) : void 0;
+  const arch = settleArch(mac ? mac.arch : await describeProgram(zipPath, entries, entry), asked.arch, platform);
+  const minOs = asked.minOs ?? mac?.minOs;
+  if (minOs !== void 0 && !OS_VERSION.test(minOs)) throw new NativeBuildError(`Minimum system "${minOs}" is not a dotted version such as 13.0.`);
+  const engine = (asked.engine ?? engineOf(entries))?.toLowerCase();
+  if (engine !== void 0 && !ENGINE.test(engine)) throw new NativeBuildError(`--engine ${engine} is not an engine id such as unity, godot or unreal.`);
+  const installedBytes = entries.reduce((sum, e) => isDirectory(e) ? sum : sum + e.uncompressedSize, 0);
+  return {
+    platform,
+    arch,
+    entry,
+    installedBytes: Math.max(1, installedBytes),
+    ...minOs ? { minOs } : {},
+    ...engine ? { engine } : {},
+    ...mac?.appVersion ? { appVersion: mac.appVersion } : {}
+  };
+}
+function buildVersion(asked, appVersion, sha2562) {
+  if (asked !== void 0) {
+    if (asked.length > VERSION_MAX || !VERSION.test(asked)) {
+      throw new NativeBuildError(`--build-version "${asked}" may hold only letters, digits and . _ + - (at most ${VERSION_MAX}).`);
+    }
+    return asked;
+  }
+  const hash = sha2562.slice(0, VERSION_SHA_CHARS);
+  const app = (appVersion ?? "").replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^[^A-Za-z0-9]+/, "").slice(0, VERSION_MAX - hash.length - 1);
+  return app ? `${app}+${hash}` : hash;
+}
+async function hashFile(filePath, onProgress) {
+  const hash = createHash3("sha256");
+  let sizeBytes = 0;
+  for await (const chunk of createReadStream(filePath)) {
+    hash.update(chunk);
+    sizeBytes += chunk.length;
+    onProgress?.(sizeBytes);
+  }
+  return { sha256: hash.digest("hex"), sizeBytes };
+}
+async function packTarget(dir) {
+  if (dir.toLowerCase().endsWith(".app")) return { target: dir, keepParent: true };
+  const children = await fs43.readdir(dir, { withFileTypes: true });
+  const apps = children.filter((d) => d.isDirectory() && d.name.toLowerCase().endsWith(".app"));
+  if (apps.length === 1) return { target: path46.join(dir, apps[0].name), keepParent: true };
+  return { target: dir, keepParent: false };
+}
+async function packNativeBuild(input) {
+  const stat = await fs43.stat(input).catch(() => null);
+  if (!stat) throw new NativeBuildError(`${input} does not exist.`);
+  if (stat.isFile()) {
+    if (!input.toLowerCase().endsWith(".zip")) throw new NativeBuildError("Pass a .zip, a .app, or the build's folder.");
+    return { zipPath: input, cleanup: async () => {
+    } };
+  }
+  const { target, keepParent } = await packTarget(input);
+  const dir = await fs43.mkdtemp(path46.join(os13.tmpdir(), "genex-native-"));
+  const zipPath = path46.join(dir, `${path46.basename(target).replace(/[^A-Za-z0-9._-]+/g, "-") || "build"}.zip`);
+  const cleanup = () => fs43.rm(dir, { recursive: true, force: true });
+  try {
+    if (process.platform === "darwin") {
+      await run4("ditto", ["-c", "-k", "--sequesterRsrc", ...keepParent ? ["--keepParent"] : [], target, zipPath]);
+    } else if (keepParent) {
+      await run4("zip", ["-q", "-r", "-y", zipPath, path46.basename(target)], { cwd: path46.dirname(target) });
+    } else {
+      await run4("zip", ["-q", "-r", "-y", zipPath, "."], { cwd: target });
+    }
+  } catch (err) {
+    await cleanup();
+    const missing = err.code === "ENOENT";
+    throw new NativeBuildError(
+      missing ? "Couldn't zip the build: no `zip` on this machine. Zip it yourself (keeping links) and pass the .zip." : `Couldn't zip the build: ${err.message}`
+    );
+  }
+  return { zipPath, cleanup };
+}
+
+// src/lib/native-upload.ts
+import fs44 from "fs/promises";
+var PART_CONCURRENCY = 2;
+async function call(ctx, route, init, what, log) {
+  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 null;
+  }
+  if (res.ok) return res;
+  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.");
+    return null;
+  }
+  if (res.status === 404 && route.startsWith("/native-upload-token")) {
+    log.error("This account doesn't own this game (HTTP 404), or the API predates native builds.");
+    return null;
+  }
+  if (res.status === 429) {
+    log.error(`Rate limited ${what} (HTTP 429).${retryAfterHint(res)}`);
+    return null;
+  }
+  const reason = await serverReason(res);
+  log.error(`Couldn't ${what} (HTTP ${res.status}).`);
+  if (reason) log.dim(`  ${reason}`);
+  return null;
+}
+async function requestNativeUpload(ctx, body, log) {
+  const res = await call(ctx, "/native-upload-token", { method: "POST", body: JSON.stringify(body) }, "get an upload token", log);
+  return res ? await res.json() : null;
+}
+async function readPart(file, position, length) {
+  const buffer = Buffer.alloc(length);
+  const { bytesRead } = await file.read(buffer, 0, length, position);
+  if (bytesRead !== length) throw new Error("the archive changed while it was being uploaded");
+  return buffer;
+}
+async function uploadNativeArchive(grant, zipPath, sizeBytes, log, onProgress) {
+  const base = grant.uploadUrl.replace(/\/+$/, "");
+  const encoded = grant.uploadPath.split("/").map(encodeURIComponent).join("/");
+  const auth = { Authorization: `Bearer ${grant.token}` };
+  const file = await fs44.open(zipPath, "r");
+  try {
+    if (sizeBytes <= grant.limits.singlePutMaxBytes) {
+      const body = await readPart(file, 0, sizeBytes);
+      const res = await fetch(`${base}/${encoded}`, { method: "PUT", headers: auth, body }).catch(() => null);
+      if (!res?.ok) {
+        log.error(`Upload failed${res ? ` (HTTP ${res.status})` : " (network error)"}.`);
+        return false;
+      }
+      onProgress?.(sizeBytes);
+      return true;
+    }
+    return await uploadParts(base, encoded, auth, file, sizeBytes, grant.limits.partSizeBytes, log, onProgress);
+  } finally {
+    await file.close();
+  }
+}
+async function uploadParts(base, encoded, auth, file, sizeBytes, partSize, log, onProgress) {
+  const created = await fetch(`${base}/${encoded}?action=mpu-create`, { method: "POST", headers: auth }).catch(() => null);
+  if (!created?.ok) {
+    log.error(`Upload failed${created ? ` (HTTP ${created.status} starting multipart)` : " (network error starting multipart)"}.`);
+    return false;
+  }
+  const { uploadId } = await created.json();
+  const totalParts = Math.ceil(sizeBytes / partSize);
+  const parts = [];
+  let sent = 0;
+  let next = 0;
+  let failed = false;
+  const worker = async () => {
+    while (!failed) {
+      const index = next++;
+      if (index >= totalParts) return;
+      const start = index * partSize;
+      const length = Math.min(partSize, sizeBytes - start);
+      const bytes = await readPart(file, start, length);
+      const part = await uploadPartWithRetry(base, encoded, auth, uploadId, index + 1, bytes);
+      if (!part) {
+        failed = true;
+        log.error(`Upload failed (part ${index + 1}/${totalParts}).`);
+        return;
+      }
+      parts.push(part);
+      sent += length;
+      onProgress?.(sent);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(PART_CONCURRENCY, totalParts) }, () => worker()));
+  const query = `uploadId=${encodeURIComponent(uploadId)}`;
+  if (!failed) {
+    parts.sort((a, b) => a.partNumber - b.partNumber);
+    const done = await fetch(`${base}/${encoded}?action=mpu-complete&${query}`, {
+      method: "POST",
+      headers: { ...auth, "Content-Type": "application/json" },
+      body: JSON.stringify({ parts })
+    }).catch(() => null);
+    if (done?.ok) return true;
+    log.error(`Upload failed${done ? ` (HTTP ${done.status} completing multipart)` : " (network error completing multipart)"}.`);
+  }
+  await fetch(`${base}/${encoded}?action=mpu-abort&${query}`, { method: "DELETE", headers: auth }).catch(() => null);
+  return false;
+}
+async function publishNativeBuild(ctx, body, log) {
+  const res = await call(ctx, "/native-builds", { method: "POST", body: JSON.stringify(body) }, "publish the build", log);
+  if (!res) return null;
+  return (await res.json()).build;
+}
+async function listNativeBuilds(ctx, log) {
+  const res = await call(ctx, "/native-builds", { method: "GET" }, "list the builds", log);
+  if (!res) return null;
+  return (await res.json()).builds;
+}
+async function removeNativeBuild(ctx, platform, arch, log) {
+  const route = `/native-builds/${encodeURIComponent(platform)}/${encodeURIComponent(arch)}`;
+  return await call(ctx, route, { method: "DELETE" }, `remove the ${platform} ${arch} build`, log) !== null;
+}
+async function listInGallery(ctx, body, log) {
+  let res;
+  try {
+    res = await apiFetch(`${ctx.apiUrl}/api/projects/${ctx.projectId}/publish`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${ctx.token}` },
+      body: JSON.stringify(body)
+    });
+  } catch (err) {
+    log.error(`Couldn't reach the API at ${ctx.apiUrl}: ${String(err)}`);
+    return null;
+  }
+  const json = await res.json().catch(() => null);
+  if (res.status === 202) {
+    return { state: "held", category: json?.moderation?.category ?? null, detail: json?.moderation?.detail ?? null };
+  }
+  if (res.status === 403 && json?.error === "moderation_refused") {
+    return { state: "refused", category: json.category ?? null, detail: json.detail ?? null };
+  }
+  if (res.ok) return { state: "published", slug: json?.project?.slug ?? null };
+  log.error(`Couldn't list the game in the gallery (HTTP ${res.status}).`);
+  if (json?.error) log.dim(`  ${json.error}`);
+  return null;
+}
+
+// src/commands/native.ts
+var PROGRESS_STEPS = 10;
+var MB2 = 1024 * 1024;
+function loggerFor2(opts) {
+  if (!opts.json) return createLogger({ quiet: opts.quiet });
+  const err = (s) => {
+    if (!opts.quiet) writeSafely(process.stderr, `${s}
+`);
+  };
+  return {
+    info: (m) => err(`i ${m}`),
+    success: (m) => err(`\u2713 ${m}`),
+    warn: (m) => err(`! ${m}`),
+    error: (m) => writeSafely(process.stderr, `\u2717 ${m}
+`),
+    step: (m) => err(`\u203A ${m}`),
+    dim: err,
+    plain: err
+  };
+}
+function progress(log, label, total) {
+  let shown = 0;
+  return (done) => {
+    const step = Math.floor(done / Math.max(total, 1) * PROGRESS_STEPS);
+    if (step <= shown) return;
+    shown = step;
+    log.dim(`  ${label} ${step * PROGRESS_STEPS}%`);
+  };
+}
+async function context3(opts, log) {
+  const meta = await readProject();
+  if (!meta) {
+    log.error("No genex project here. Run `genex init` or `genex link <game>` in this directory first.");
+    return null;
+  }
+  const apiUrl = opts.apiUrl ?? getApiUrl(meta.apiUrl);
+  const token = opts.token ?? await readUserToken(opts.envPath, apiUrl);
+  if (!token) {
+    log.error("Not authorized. Run `genex link <your-game>` to sign in.");
+    return null;
+  }
+  return { apiUrl, projectId: meta.id, token };
+}
+function refusedInHostedSession(log) {
+  if (!inHostedSession()) return false;
+  log.error("Native builds are published from the creator's own computer, not from a hosted session.");
+  return true;
+}
+function sizeLine(bytes) {
+  return `${(bytes / MB2).toFixed(1)} MB`;
+}
+function describeLine(d) {
+  const parts = [`${d.platform} ${d.arch}`, d.entry, `${sizeLine(d.installedBytes)} unpacked`];
+  if (d.minOs) parts.push(`${d.platform === "mac" ? "macOS" : "system"} ${d.minOs}+`);
+  if (d.engine) parts.push(d.engine);
+  return parts.join(" \xB7 ");
+}
+async function runPublish2(opts, log) {
+  if (refusedInHostedSession(log)) return false;
+  if (!opts.nativePath) {
+    log.error("Which build? `genex native publish <path>` \u2014 a .zip, a .app, or the build's folder.");
+    return false;
+  }
+  const ctx = await context3(opts, log);
+  if (!ctx) return false;
+  let packed;
+  try {
+    if (!opts.nativePath.toLowerCase().endsWith(".zip")) log.step(`Zipping ${opts.nativePath}\u2026`);
+    packed = await packNativeBuild(opts.nativePath);
+  } catch (err) {
+    if (!(err instanceof NativeBuildError)) throw err;
+    log.error(err.message);
+    return false;
+  }
+  try {
+    const description = await describeNativeArchive(packed.zipPath, opts);
+    log.step(describeLine(description));
+    log.step("Hashing the archive\u2026");
+    const { sha256: sha2562, sizeBytes } = await hashFile(packed.zipPath);
+    const version = buildVersion(opts.buildVersion, description.appVersion, sha2562);
+    const { platform, arch, entry, installedBytes, minOs, engine } = description;
+    const grant = await requestNativeUpload(ctx, { platform, arch, sha256: sha2562, sizeBytes }, log);
+    if (!grant) return false;
+    if (grant.uploaded) {
+      log.step(`Already uploaded (${sizeLine(sizeBytes)}).`);
+    } else {
+      log.step(`Uploading ${sizeLine(sizeBytes)}\u2026`);
+      const sent = await uploadNativeArchive(grant, packed.zipPath, sizeBytes, log, progress(log, "uploaded", sizeBytes));
+      if (!sent) return false;
+    }
+    const build = await publishNativeBuild(
+      ctx,
+      { platform, arch, sha256: sha2562, sizeBytes, installedBytes, version, entry, ...minOs ? { minOs } : {}, ...engine ? { engine } : {} },
+      log
+    );
+    if (!build) return false;
+    log.success(`Live \u2014 Genex desktop players on ${platform} ${arch} now get version ${build.version}.`);
+    log.dim(`  ${build.url}`);
+    const listing = opts.gallery ? await listGame(ctx, opts, log) : void 0;
+    if (opts.json) {
+      console.log(JSON.stringify({ build, engine: engine ?? null, ...listing === void 0 ? {} : { listing } }));
+    }
+    return listing === void 0 || listing?.state === "published" || listing?.state === "held";
+  } catch (err) {
+    if (!(err instanceof NativeBuildError)) throw err;
+    log.error(err.message);
+    return false;
+  } finally {
+    await packed.cleanup();
+  }
+}
+async function listGame(ctx, opts, log) {
+  log.step("Listing it in the gallery\u2026");
+  const listing = await listInGallery(
+    ctx,
+    {
+      ...opts.title ? { title: opts.title } : {},
+      ...opts.description ? { description: opts.description } : {},
+      ...opts.categories?.length ? { categories: opts.categories } : {}
+    },
+    log
+  );
+  if (!listing) return null;
+  if (listing.state === "published") {
+    log.success("Listed in the gallery.");
+    return listing;
+  }
+  const why = listing.detail ? `: ${listing.detail}` : ".";
+  if (listing.state === "held") log.warn(`Held for review before it is listed${why}`);
+  else log.error(`The listing was refused${why}`);
+  return listing;
+}
+function buildLine(b) {
+  return `${c.bold(`${b.platform} ${b.arch}`)}  ${b.version}  ${b.entry}  ${sizeLine(b.sizeBytes)}  ${b.publishedAt}`;
+}
+async function runList2(opts, log) {
+  const ctx = await context3(opts, log);
+  if (!ctx) return false;
+  const builds = await listNativeBuilds(ctx, log);
+  if (!builds) return false;
+  if (opts.json) {
+    console.log(JSON.stringify({ builds }));
+    return true;
+  }
+  if (builds.length === 0) {
+    log.plain("No native builds. Publish one with `genex native publish <path>`.");
+    return true;
+  }
+  for (const b of builds) log.plain(buildLine(b));
+  return true;
+}
+async function runRemove(opts, log) {
+  if (refusedInHostedSession(log)) return false;
+  if (!opts.platform || !opts.arch) {
+    log.error("Which build? `genex native remove --platform <mac|windows|linux> --arch <arm64|x64|universal> --yes`.");
+    return false;
+  }
+  if (!opts.yes) {
+    log.error(`This stops offering the ${opts.platform} ${opts.arch} build to players. Re-run with --yes to remove it.`);
+    return false;
+  }
+  const ctx = await context3(opts, log);
+  if (!ctx) return false;
+  if (!await removeNativeBuild(ctx, opts.platform, opts.arch, log)) return false;
+  if (opts.json) console.log(JSON.stringify({ removed: { platform: opts.platform, arch: opts.arch } }));
+  log.success(`Removed the ${opts.platform} ${opts.arch} build. Copies already installed keep working.`);
+  return true;
+}
+var SUBCOMMANDS2 = {
+  publish: runPublish2,
+  list: runList2,
+  remove: runRemove
+};
+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`.");
+    process.exitCode = 1;
+    return;
+  }
+  if (!await run5(opts, log)) process.exitCode = 1;
+}
+
 // src/lib/costs.ts
 var TYPICAL_CREDITS = {
   model: 35,
@@ -27792,6 +28513,11 @@ ${c.bold("Usage")}
   genex rollback [--yes]             Put players back on the previous version. One
                                      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.
+                                     "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.
   genex cover [<file>]               Show this game's cover and where it came from, or
                                      make <file> (PNG/JPEG/WebP, \u22648 MB) the cover: one
                                      real frame of the game \u2014 its signature moment,
@@ -28594,6 +29320,39 @@ ${c.bold("Content filter")}
   a body) as body horror \u2014 describe the object or machine instead: "a
   statue-like figure threaded into the wall" passes where "cables entering her
   spine" fails. Rejections are never retryable; reword and re-run.
+`,
+  native: `${c.bold("genex native")} \u2014 a Unity, Godot or Unreal build players install from the Genex desktop app.
+
+${c.bold("Usage")}
+  genex native publish <path>        Make this build what desktop players on its platform
+                                     and processor install. <path> is a .zip, a .app, or
+                                     the build's folder (zipped for you, links and
+                                     permissions kept). Live as soon as it returns; the
+                                     build it replaces stays downloadable one more version.
+  genex native list                  This game's builds: platform, processor, version.
+  genex native remove --platform <p> --arch <a> --yes
+                                     Stop offering one build. Installed copies keep working.
+
+${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.
+  --entry <path>                     What runs: the root .app, or the game's .exe.
+  --build-version <id>               Default: the app's own version + the archive's hash,
+                                     so every rebuild is an update.
+  --min-os <version>                 Default: a Mac app's LSMinimumSystemVersion.
+  --engine unity|godot|unreal        From the files the engine ships.
+  --json                             One JSON object on stdout ({"build": \u2026}).
+
+${c.bold("List it in the gallery")}
+  --gallery                          After the build is live, list the game in the public
+                                     gallery, the same moderated listing \`genex publish\`
+                                     does, without building or deploying a web bundle.
+  --title <t>  --description <d>     The listing's words (kept as they are when omitted).
+  --categories <list>                1-3, comma-separated, e.g. games.
+
+${c.bold("Notes")}
+  An archive is at most 4 GB. A Mac app must be signed, at least ad hoc (Unity, Godot
+  and Unreal do this when they build) \u2014 the desktop app refuses an unsigned one.
 `,
   wait: `${c.bold("genex wait")} \u2014 attach to a generation already running, or just ask how it is doing.
 
@@ -28749,7 +29508,15 @@ function parseArgs(argv) {
     "--tags",
     // `genex cover --clip <file> --commit <sha>`: the clip and the build it shows.
     "--clip",
-    "--commit"
+    "--commit",
+    // `genex native publish|remove` value flags. `--build-version`, never
+    // `--version`, which prints the CLI's own.
+    "--platform",
+    "--arch",
+    "--entry",
+    "--build-version",
+    "--min-os",
+    "--engine"
   ]);
   let i = 0;
   while (i < argv.length) {
@@ -28899,6 +29666,9 @@ function parseArgs(argv) {
       case "--yes":
         parsed.options.yes = true;
         break;
+      case "--gallery":
+        parsed.options.gallery = true;
+        break;
       // A pair rather than one flag taking a value: `--resellable false` reads
       // as a filename to every shell user who has ever mistyped it, and the two
       // states have to be distinguishable from ABSENT so `shop set` can leave
@@ -29023,6 +29793,13 @@ function parseArgs(argv) {
             parsed.error = `Unexpected argument: ${arg}`;
             return parsed;
           }
+        } else if (parsed.command === "native") {
+          if (parsed.options.name === "publish" && parsed.options.nativePath === void 0) {
+            parsed.options.nativePath = arg;
+          } else {
+            parsed.error = `Unexpected argument: ${arg}`;
+            return parsed;
+          }
         } else if (parsed.command === "blender") {
           if (parsed.options.name === "import" && parsed.options.importUrl === void 0) {
             parsed.options.importUrl = arg;
@@ -29070,6 +29847,24 @@ function applyValueFlag(options, flag, value) {
     case "--dir":
       options.dir = value;
       break;
+    case "--platform":
+      options.platform = value.toLowerCase();
+      break;
+    case "--arch":
+      options.arch = value.toLowerCase();
+      break;
+    case "--entry":
+      options.entry = value;
+      break;
+    case "--build-version":
+      options.buildVersion = value;
+      break;
+    case "--min-os":
+      options.minOs = value;
+      break;
+    case "--engine":
+      options.engine = value.toLowerCase();
+      break;
     case "--env":
       options.envPath = value;
       break;
@@ -29661,6 +30456,9 @@ async function main() {
       case "rollback":
         await runRollback(parsed.options);
         break;
+      case "native":
+        await runNative(parsed.options);
+        break;
       case "cover":
         await runCover({ ...parsed.options, imagePath: parsed.options.name });
         break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@genex-ai/cli-demo",
-  "version": "1.36.10-dev.965",
+  "version": "1.36.11-dev.967",
   "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": {