evolutionary-arcade 0.3.0 → 0.4.0

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 0.4.0
+
+- Games ship media for phones. arcade.json has `orientation` (`"landscape"`, `"portrait"`, or `"both"`; leaving it out means landscape) and `media_vertical`, a 9:16 set with the same fields as the landscape one (`thumbnail`, `screenshots`, `demo_video`, `preview_video`, `preview_gif`). The top-level media fields are the landscape set.
+- A portrait or both game with touch must ship its own vertical media from real upright play: a thumbnail, at least one screenshot, and a vertical demo when it has a landscape demo.
+- New `arcade media vertical`. For a landscape game it centers the landscape thumbnail, screenshots, and demo at full width over a blurred, darkened copy of themselves at 1080x1920, cuts a 480x854 hover preview and a 360x640 GIF, writes them to `media/vertical/`, and sets `media_vertical`. For a portrait or both game it cuts the vertical preview and GIF from the vertical demo. `arcade publish` makes a landscape game's set when it's missing, the way it makes the GIF.
+- The dry run warns when game code calls `requestFullscreen` (or the webkit, moz, and ms versions): "the arcade's player owns fullscreen; remove your fullscreen button". It also flags a missing vertical thumbnail and a vertical set older than the landscape media.
+- `arcade fork`, `blend`, `pull`, and `regen` carry `orientation` and `media_vertical` over.
+- Skills: `arcade-publishing` covers deciding a game's orientation and capturing both sets in one pass (1280x720, plus 390x844 with touch emulation). `arcade-building-games` says "Don't build fullscreen. The platform owns it." `arcade-onboarding` and `arcade-fork` include the vertical set in their capture steps and time estimates.
+
 ## 0.3.0
 
 - Every publish ends with a **Share it** block: the game's link, a video-description line, an X post draft under 280 characters, an X intent link, and the GIF to attach. A fork or blend's draft credits each parent's creator, by X handle when their profile links one. The agent drafts; the creator posts. The CLI never posts anywhere.

package/README.md

@@ -56,6 +56,7 @@ Everything you publish is public, including the source, and every game is open s
 | `arcade publish [dir] [--dry-run] [--yes]` | Check everything, list every file that goes public, and publish. |
 | `arcade share <slug> [--profile] [--badge] [--json]` | Reprint the Share block publish ends with: the link, a video-description line, an X post draft, and the GIF to attach. `--profile` shares your whole library; `--badge` prints the "Play on Evolutionary Arcade" badge as Markdown and HTML. You post them; the arcade never posts for you. |
 | `arcade media preview [dir]` | Make the 12-second hover preview from your demo (needs ffmpeg). |
+| `arcade media vertical [dir]` | Make the phone (9:16) media set: landscape games over a blurred fill, portrait games from their vertical demo (needs ffmpeg). |
 | `arcade main <slug> <generation>` | (Owner) Pick the main generation for a version. |
 | `arcade unpublish <slug>` / `arcade republish <slug>` | (Owner) Take your game down, or bring it back. |
 | `arcade profile show` / `set` / `avatar` / `banner` | See and edit your public profile. |

package/dist/cli.js

@@ -13,7 +13,7 @@ import { dirname, isAbsolute, join } from "path";
 // package.json
 var package_default = {
   name: "evolutionary-arcade",
-  version: "0.3.0",
+  version: "0.4.0",
   description: "The arcade CLI for Evolutionary Arcade. Publish, update, regen, fork, and blend AI-made browser games with your own coding agent.",
   type: "module",
   license: "MIT",
@@ -20592,6 +20592,14 @@ var videoPath = relPath.refine(
   (p) => ["mp4", "webm"].includes(ext(p)),
   "Use an .mp4 or .webm video."
 );
+var ORIENTATIONS = ["landscape", "portrait", "both"];
+var verticalMediaSchema = external_exports.object({
+  thumbnail: imagePath.optional(),
+  screenshots: external_exports.array(imagePath).max(12).default([]),
+  demo_video: videoPath.optional(),
+  preview_video: videoPath.optional(),
+  preview_gif: gifPath.optional()
+});
 var sourceSchema = external_exports.object({
   repo: external_exports.string().regex(
     /^https:\/\/github\.com\/[A-Za-z0-9](?:[A-Za-z0-9-]{0,38})\/[A-Za-z0-9._-]{1,100}$/,
@@ -20638,6 +20646,8 @@ var arcadeSchema = external_exports.object({
   // play: "someone remixed your game" emails and link previews. The CLI requires it whenever
   // there's a demo.
   preview_gif: gifPath.optional(),
+  orientation: external_exports.enum(ORIENTATIONS).default("landscape"),
+  media_vertical: verticalMediaSchema.optional(),
   lineage: lineageSchema.default({ kind: "original", parents: [] }),
   provenance: provenanceSchema.default({ subagent_models: [] }),
   source: sourceSchema.optional()
@@ -20649,6 +20659,20 @@ var arcadeSchema = external_exports.object({
       message: "A game can't be its own parent."
     });
   }
+  if (a.orientation !== "landscape" && a.input.touch) {
+    const v = a.media_vertical;
+    const missing = [
+      !v?.thumbnail && "a thumbnail",
+      !v?.screenshots.length && "at least one screenshot",
+      a.demo_video && !v?.demo_video && "a demo"
+    ].filter((x) => typeof x === "string");
+    if (missing.length)
+      ctx.addIssue({
+        code: "custom",
+        path: ["media_vertical"],
+        message: `A ${a.orientation === "both" ? "game that also plays upright" : "portrait game"} needs vertical media from real play at 390x844: ${missing.join(", ")}.`
+      });
+  }
   const ids = a.leaderboards.map((b) => b.id);
   ids.forEach((id, i) => {
     if (ids.indexOf(id) !== i)
@@ -20695,6 +20719,11 @@ var friendlyIssue = (iss) => {
       if (limit) return `Use up to ${limit} screenshots.`;
       if (missing) return "Add at least one screenshot.";
       break;
+    case "orientation":
+      return 'Use "landscape", "portrait", or "both": the way the game plays on a phone.';
+    case "media_vertical.screenshots":
+      if (limit) return `Use up to ${limit} vertical screenshots.`;
+      break;
     case "lineage.kind":
       return "lineage.kind was changed; re-run the arcade command that made this folder.";
     case "lineage.parents":
@@ -21198,7 +21227,9 @@ function derived2(src, overrides) {
     "screenshots",
     "demo_video",
     "preview_video",
-    "preview_gif"
+    "preview_gif",
+    "orientation",
+    "media_vertical"
   ];
   const out2 = { schema: "arcade/v0" };
   for (const k of keep) if (a[k] !== void 0) out2[k] = a[k];
@@ -21500,8 +21531,8 @@ function dev(dirArg, opts) {
 
 // src/commands/publish.ts
 import { execFileSync } from "child_process";
-import { existsSync as existsSync6, readFileSync as readFileSync8, statSync as statSync5, writeFileSync as writeFileSync3 } from "fs";
-import { isAbsolute as isAbsolute2, join as join6, relative as relative2, resolve as resolve4, sep as sep4 } from "path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync8, statSync as statSync5, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname3, isAbsolute as isAbsolute2, join as join6, relative as relative2, resolve as resolve4, sep as sep4 } from "path";
 
 // src/files.ts
 import { createHash as createHash2 } from "crypto";
@@ -21585,6 +21616,7 @@ function walkGame(root) {
 
 // src/fixes.ts
 var CAPTURE_GUIDE = 'arcade guide publishing, "Capturing media"';
+var VERTICAL = "media/vertical";
 var thumbnailFix = (path) => `Run the game (arcade dev), capture a 1280x720 frame of real play, mid-action with no title screen or added text, and save it as ${path}.`;
 var screenshotFix = (path) => `Capture a different moment of real play at 1280x720 and save it as ${path}. Aim for 2 to 4 screenshots in all.`;
 var demoFix = (path) => `Record 15 to 30 s of real play at 1280x720 as H.264 and save it as ${path}, with the action starting in the first second (${CAPTURE_GUIDE}).`;
@@ -21614,6 +21646,10 @@ function fixFor(issue2, raw) {
     return `${screenshotFix("media/shot-1.png")} List the paths in "screenshots".`;
   if (path === "demo_video") return `${demoFix("media/demo.mp4")} Then set "demo_video".`;
   if (path === "preview_video" || path === "preview_gif") return fromDemoFix;
+  if (path === "orientation")
+    return 'Play the game on a phone (390x844 with touch): "landscape" if it needs the phone sideways, "portrait" if it plays upright, "both" if it works either way.';
+  if (path === "media_vertical" || path.startsWith("media_vertical."))
+    return `Run the game at 390x844 with touch emulation and capture upright play into ${VERTICAL}/ (thumbnail.png, shot-1.png, and demo.mp4 if the game has a landscape demo), list them under "media_vertical", then run \`arcade media vertical\` for the preview and GIF (${CAPTURE_GUIDE}). If the game really only plays sideways, set "orientation": "landscape" instead.`;
   if (path === "title") return `Set "title" to the game's name as players should see it.`;
   if (path === "description")
     return 'Set "description" to one or two sentences: the fantasy and the goal.';
@@ -21629,6 +21665,10 @@ function missingMediaLine(path, raw) {
   if (raw.demo_video === path) return `${path} (demo): ${demoFix(path)}`;
   if (raw.preview_video === path) return `${path} (hover preview): ${fromDemoFix}`;
   if (raw.preview_gif === path) return `${path} (GIF): ${fromDemoFix}`;
+  const v = raw.media_vertical ?? {};
+  const vertical = [v.thumbnail, v.demo_video, v.preview_video, v.preview_gif].includes(path) || Array.isArray(v.screenshots) && v.screenshots.includes(path);
+  if (vertical)
+    return `${path} (vertical): ${raw.orientation === "portrait" || raw.orientation === "both" ? `capture it from real play at 390x844 with touch; previews and GIFs come from \`arcade media vertical\`.` : "run `arcade media vertical` to make the vertical set from the landscape media."}`;
   return path;
 }
 
@@ -22020,8 +22060,9 @@ function runFfmpeg(args, what) {
     throw new ExitError(`ffmpeg couldn't make the ${what}${last ? `: ${last}` : "."}`);
   }
 }
-function makePreview(dir, demo, target = "media/preview.mp4") {
+function makePreview(dir, demo, target = "media/preview.mp4", scale = "scale=854:-2") {
   if (!hasFfmpeg()) return null;
+  mkdirSync3(dirname3(join6(dir, target)), { recursive: true });
   runFfmpeg(
     [
       "-i",
@@ -22030,7 +22071,7 @@ function makePreview(dir, demo, target = "media/preview.mp4") {
       "12",
       "-an",
       "-vf",
-      "scale=854:-2,fps=30",
+      `${scale},fps=30`,
       "-c:v",
       "libx264",
       "-preset",
@@ -22048,9 +22089,13 @@ function makePreview(dir, demo, target = "media/preview.mp4") {
   return target;
 }
 var MAX_GIF_BYTES = 5 * 1024 * 1024;
-function makeGif(dir, demo, target = "media/preview.gif") {
+function makeGif(dir, demo, target = "media/preview.gif", vertical = false) {
   if (!hasFfmpeg()) return null;
-  const tries = [
+  mkdirSync3(dirname3(join6(dir, target)), { recursive: true });
+  const tries = vertical ? [
+    { width: 360, fps: 12, seconds: 6 },
+    { width: 270, fps: 10, seconds: 5 }
+  ] : [
     { width: 480, fps: 12, seconds: 6 },
     { width: 360, fps: 10, seconds: 5 }
   ];
@@ -22076,6 +22121,155 @@ function makeGif(dir, demo, target = "media/preview.gif") {
     `The GIF came out over ${MAX_GIF_BYTES / 1024 / 1024} MB, even small. Re-cut the demo so its first 5 seconds are less busy (a later -ss), then run \`arcade media preview\` again.`
   );
 }
+var VERTICAL_W = 1080;
+var VERTICAL_H = 1920;
+var BLURRED_FILL = [
+  "split=2[bg][fg]",
+  `[bg]scale=${VERTICAL_W}:${VERTICAL_H}:force_original_aspect_ratio=increase,crop=${VERTICAL_W}:${VERTICAL_H},scale=270:480,gblur=sigma=10,scale=${VERTICAL_W}:${VERTICAL_H},eq=brightness=-0.22:saturation=1.1[b]`,
+  `[fg]scale=${VERTICAL_W}:-2[f]`,
+  "[b][f]overlay=(W-w)/2:(H-h)/2"
+].join(";");
+var MAX_VIDEO_BYTES = 25 * 1024 * 1024;
+var VERTICAL_DIR = "media/vertical";
+function fillImage(dir, src, target) {
+  if (!hasFfmpeg()) return null;
+  mkdirSync3(dirname3(join6(dir, target)), { recursive: true });
+  runFfmpeg(
+    [
+      "-i",
+      join6(dir, src),
+      "-filter_complex",
+      BLURRED_FILL,
+      "-frames:v",
+      "1",
+      "-q:v",
+      "3",
+      join6(dir, target)
+    ],
+    `vertical version of ${src}`
+  );
+  return target;
+}
+function fillDemo(dir, demo, target = `${VERTICAL_DIR}/demo.mp4`) {
+  if (!hasFfmpeg()) return null;
+  mkdirSync3(dirname3(join6(dir, target)), { recursive: true });
+  for (const crf of ["28", "34"]) {
+    runFfmpeg(
+      [
+        "-i",
+        join6(dir, demo),
+        "-t",
+        "30",
+        "-an",
+        "-filter_complex",
+        `${BLURRED_FILL},fps=30,format=yuv420p`,
+        "-c:v",
+        "libx264",
+        "-preset",
+        "veryfast",
+        "-crf",
+        crf,
+        "-movflags",
+        "+faststart",
+        join6(dir, target)
+      ],
+      "vertical demo"
+    );
+    if (statSync5(join6(dir, target)).size <= MAX_VIDEO_BYTES) return target;
+  }
+  throw new ExitError(
+    `The vertical demo came out over ${MAX_VIDEO_BYTES / 1024 / 1024} MB. Record a shorter demo (15 to 20 s), then run \`arcade media vertical\` again.`
+  );
+}
+var orientationOf = (raw) => raw.orientation === "portrait" || raw.orientation === "both" ? raw.orientation : "landscape";
+var verticalOf = (raw) => raw.media_vertical && typeof raw.media_vertical === "object" ? { ...raw.media_vertical } : {};
+var exists = (dir, p) => typeof p === "string" && existsSync6(join6(dir, p));
+function fillVerticalSet(dir, raw) {
+  const v = verticalOf(raw);
+  const made = [];
+  const skipped = [];
+  const image = (src, target) => {
+    try {
+      made.push(fillImage(dir, src, target));
+      return target;
+    } catch (e) {
+      if (!(e instanceof ExitError)) throw e;
+      skipped.push(e.message);
+      return null;
+    }
+  };
+  if (exists(dir, raw.thumbnail)) {
+    const t = image(raw.thumbnail, `${VERTICAL_DIR}/thumbnail.jpg`);
+    if (t) v.thumbnail = t;
+  }
+  if (Array.isArray(raw.screenshots)) {
+    v.screenshots = raw.screenshots.filter((p) => exists(dir, p)).map((p, i) => image(p, `${VERTICAL_DIR}/shot-${i + 1}.jpg`)).filter((p) => p !== null);
+  }
+  if (exists(dir, raw.demo_video)) {
+    v.demo_video = fillDemo(dir, raw.demo_video);
+    v.preview_video = makePreview(
+      dir,
+      v.demo_video,
+      `${VERTICAL_DIR}/preview.mp4`,
+      "scale=-2:854"
+    );
+    v.preview_gif = makeGif(dir, v.demo_video, `${VERTICAL_DIR}/preview.gif`, true);
+    made.push(v.demo_video, v.preview_video, v.preview_gif);
+  }
+  if (made.length) raw.media_vertical = v;
+  return { made, skipped };
+}
+function ensureVertical(dir, raw) {
+  const v = verticalOf(raw);
+  const save = () => writeFileSync3(join6(dir, "arcade.json"), `${JSON.stringify(raw, null, 2)}
+`);
+  if (orientationOf(raw) === "landscape") {
+    const needDemo = exists(dir, raw.demo_video) && !v.demo_video;
+    const needThumb = exists(dir, raw.thumbnail) && !v.thumbnail;
+    if (!needDemo && !needThumb) return;
+    if (!hasFfmpeg()) {
+      if (needDemo)
+        throw new ExitError(
+          "This game has a demo, so phones need a vertical cut of it (over a blurred fill), and that takes ffmpeg.",
+          2,
+          [NO_FFMPEG],
+          "Then run `arcade media vertical` (or publish again, which makes it for you)."
+        );
+      out(
+        dim("No vertical thumbnail: ffmpeg isn't installed. Phones will show the landscape one.")
+      );
+      return;
+    }
+    const { made, skipped } = fillVerticalSet(dir, raw);
+    if (made.length) save();
+    if (made.length)
+      out(
+        dim(
+          `Made the vertical set for phones, over a blurred fill (${plural(made.length, "file")} in ${VERTICAL_DIR}/).`
+        )
+      );
+    for (const m of skipped)
+      out(yellow(`No vertical copy: ${m} Phones will show the landscape one.`));
+    return;
+  }
+  if (exists(dir, v.demo_video) && !v.preview_gif) {
+    if (!hasFfmpeg())
+      throw new ExitError("The vertical demo needs a GIF made from it, and that takes ffmpeg.", 2, [
+        NO_FFMPEG
+      ]);
+    const made = cutVerticalPreviews(dir, raw);
+    save();
+    out(dim(`Made a vertical preview and GIF from the vertical demo (${made.join(", ")}).`));
+  }
+}
+function cutVerticalPreviews(dir, raw) {
+  const v = verticalOf(raw);
+  if (!exists(dir, v.demo_video)) return [];
+  v.preview_video = makePreview(dir, v.demo_video, `${VERTICAL_DIR}/preview.mp4`, "scale=-2:854");
+  v.preview_gif = makeGif(dir, v.demo_video, `${VERTICAL_DIR}/preview.gif`, true);
+  raw.media_vertical = v;
+  return [v.preview_video, v.preview_gif];
+}
 var NO_FFMPEG = "ffmpeg isn't installed. Install it (macOS: `brew install ffmpeg`, Ubuntu: `sudo apt install ffmpeg`, Windows: `winget install ffmpeg`) and try again.";
 function demoFor(dir, raw, what) {
   if (typeof raw.demo_video !== "string")
@@ -22116,6 +22310,36 @@ async function mediaGif(dirArg) {
 `);
   out(`Made ${gif} (${mb(statSync5(join6(dir, gif)).size)}) and added it to arcade.json.`);
 }
+async function mediaVertical(dirArg) {
+  const dir = resolve4(dirArg ?? ".");
+  const raw = readArcadeRaw(dir);
+  if (!hasFfmpeg()) throw new ExitError(NO_FFMPEG);
+  const orientation = orientationOf(raw);
+  let made;
+  if (orientation === "landscape") {
+    if (!exists(dir, raw.thumbnail))
+      throw new ExitError(
+        `The vertical set is made from the landscape media, and ${typeof raw.thumbnail === "string" ? `${raw.thumbnail} isn't in the folder yet` : "arcade.json has no thumbnail"}. Capture the landscape media first (${CAPTURE_GUIDE}).`,
+        2
+      );
+    const r = fillVerticalSet(dir, raw);
+    made = r.made;
+    for (const m of r.skipped) out(yellow(`Skipped: ${m}`));
+  } else {
+    made = cutVerticalPreviews(dir, raw);
+    if (!made.length)
+      throw new ExitError(
+        `This game plays ${orientation === "portrait" ? "upright" : "both ways"}, so its vertical media comes from real upright play, not a blurred fill. Record 15 to 30 s at 390x844 with touch into ${VERTICAL_DIR}/demo.mp4, set "media_vertical.demo_video", then run this again (${CAPTURE_GUIDE}).`,
+        2
+      );
+  }
+  writeFileSync3(join6(dir, "arcade.json"), `${JSON.stringify(raw, null, 2)}
+`);
+  out(
+    `Made ${plural(made.length, "vertical file")} (${orientation === "landscape" ? "landscape media over a blurred fill, 1080x1920" : "cut from your vertical demo"}) and set media_vertical:`
+  );
+  for (const m of made) out(`  ${m} ${dim(mb(statSync5(join6(dir, m)).size))}`);
+}
 function describeAction(p, parentNames) {
   switch (p.action) {
     case "original":
@@ -22175,6 +22399,19 @@ function listWords(words) {
   if (words.length <= 1) return words.join("");
   return `${words.slice(0, -1).join(", ")}${words.length > 2 ? "," : ""} and ${words.at(-1)}`;
 }
+var FULLSCREEN_CALL = /\b(?:request|webkitRequest|mozRequest|msRequest)Full[sS]creen\b/;
+var CODE_FILE = /\.(?:html?|m?js|jsx|tsx?)$/i;
+function fullscreenCalls(files) {
+  const hits = [];
+  for (const f of files) {
+    if (!CODE_FILE.test(f.path) || f.path.startsWith("parents/") || f.size > 2 * 1024 * 1024)
+      continue;
+    const lines = readFileSync8(f.abs, "utf8").split("\n");
+    const i = lines.findIndex((l) => FULLSCREEN_CALL.test(l));
+    if (i >= 0) hits.push(`${f.path}:${i + 1}`);
+  }
+  return hits;
+}
 var HOME_PATH = /(?:\/Users\/|\/home\/|[A-Za-z]:\\Users\\)[^\s/\\"'`]+/;
 function headsUp(arcade, files, alreadyOnArcade, secretWarnings, dir) {
   const notes = [];
@@ -22261,6 +22498,26 @@ function headsUp(arcade, files, alreadyOnArcade, secretWarnings, dir) {
     notes.push(
       `The ${stale.map(([w]) => w).join(" and ")} ${stale.length > 1 ? "are" : "is"} older than the demo. Run \`arcade media preview\` to remake ${stale.length > 1 ? "them" : "it"}.`
     );
+  const v = arcade.media_vertical;
+  if (arcade.orientation === "landscape") {
+    if (!v?.thumbnail)
+      notes.push(
+        "There's no vertical thumbnail, so phones show the landscape one. Run `arcade media vertical` (it needs ffmpeg)."
+      );
+    const vStale = [
+      ["vertical thumbnail", age(v?.thumbnail), age(arcade.thumbnail)],
+      ["vertical demo", age(v?.demo_video), demoAt]
+    ].filter(([, t, src]) => t !== null && src !== null && t < src);
+    if (vStale.length)
+      notes.push(
+        `The ${vStale.map(([w]) => w).join(" and ")} ${vStale.length > 1 ? "are" : "is"} older than the landscape media. Run \`arcade media vertical\` to remake the vertical set.`
+      );
+  }
+  const fullscreen = fullscreenCalls(files);
+  if (fullscreen.length)
+    notes.push(
+      `${listWords(fullscreen.slice(0, 3))}${fullscreen.length > 3 ? ` and ${fullscreen.length - 3} more` : ""} ${fullscreen.length > 1 ? "call" : "calls"} requestFullscreen: the arcade's player owns fullscreen; remove your fullscreen button.`
+    );
   const thumb = files.find((f) => f.path === arcade.thumbnail);
   if (thumb && thumb.size > 500 * 1024) {
     const webp = arcade.thumbnail.replace(/\.[^.]+$/, ".webp");
@@ -22344,6 +22601,7 @@ async function publish(dirArg, opts) {
 `);
     out(dim(`Made a GIF from the demo (${made}, ${mb(statSync5(join6(dir, made)).size)}).`));
   }
+  ensureVertical(dir, raw);
   const prov = raw.provenance ?? {};
   const orch = prov.orchestrator ?? null;
   const named = opts.session ?? [];
@@ -22396,6 +22654,14 @@ async function publish(dirArg, opts) {
     throw new ExitError("A game with a demo needs a GIF made from it (preview_gif).", 2, [
       `${arcade.demo_video} (demo): record it first, then run \`arcade media preview\`.`
     ]);
+  if (arcade.media_vertical?.demo_video && !arcade.media_vertical.preview_gif)
+    throw new ExitError(
+      "The vertical demo needs a GIF made from it (media_vertical.preview_gif).",
+      2,
+      [
+        `${arcade.media_vertical.demo_video} (vertical demo): record it first, then run \`arcade media vertical\`.`
+      ]
+    );
   await fillLicenseHolder(dir);
   const { files, skipped, skippedLinks } = walkGame(dir);
   const bad = files.filter((f) => !f.type);
@@ -22413,7 +22679,12 @@ async function publish(dirArg, opts) {
     ...arcade.screenshots,
     arcade.demo_video,
     arcade.preview_video,
-    arcade.preview_gif
+    arcade.preview_gif,
+    arcade.media_vertical?.thumbnail,
+    ...arcade.media_vertical?.screenshots ?? [],
+    arcade.media_vertical?.demo_video,
+    arcade.media_vertical?.preview_video,
+    arcade.media_vertical?.preview_gif
   ];
   const missingMedia = media.filter((m) => !!m && !files.some((f) => f.path === m));
   if (missingMedia.length) {
@@ -22705,12 +22976,12 @@ async function setPublished(slug, published) {
 }
 
 // src/commands/skills.ts
-import { cpSync, existsSync as existsSync7, mkdirSync as mkdirSync3, readdirSync as readdirSync4, readFileSync as readFileSync9 } from "fs";
+import { cpSync, existsSync as existsSync7, mkdirSync as mkdirSync4, readdirSync as readdirSync4, readFileSync as readFileSync9 } from "fs";
 import { homedir as homedir4 } from "os";
-import { dirname as dirname3, join as join7, resolve as resolve5 } from "path";
+import { dirname as dirname4, join as join7, resolve as resolve5 } from "path";
 import { fileURLToPath } from "url";
 function skillsDir() {
-  const here = dirname3(fileURLToPath(import.meta.url));
+  const here = dirname4(fileURLToPath(import.meta.url));
   for (const candidate2 of [join7(here, "..", "skills"), join7(here, "..", "..", "skills")]) {
     if (existsSync7(join7(candidate2, "arcade-getting-started", "SKILL.md"))) return candidate2;
   }
@@ -22763,7 +23034,7 @@ function installSkills(opts) {
     return f();
   });
   for (const target of targets) {
-    mkdirSync3(target, { recursive: true });
+    mkdirSync4(target, { recursive: true });
     for (const name of names)
       cpSync(join7(src, name), join7(target, name), { recursive: true, force: true });
     out(`Installed ${names.length} skills into ${target}`);
@@ -22868,6 +23139,9 @@ function buildProgram() {
     "remake media/preview.mp4 (12 s) and media/preview.gif (6 s) from your demo, after every new demo"
   ).action(mediaPreview);
   media.command("gif [dir]").description("remake only media/preview.gif from your demo").action(mediaGif);
+  media.command("vertical [dir]").description(
+    "make the phone (9:16) set in media/vertical/: landscape games get their media over a blurred fill at 1080x1920; portrait and both games get a preview and GIF from their vertical demo"
+  ).action(mediaVertical);
   program.command("main <slug> <generation>").description("(owner) pick which generation is main for its version").action(setMain);
   program.command("unpublish <slug>").description("(owner) take your game down").action((slug) => setPublished(slug, false));
   program.command("republish <slug>").description("(owner) bring your game back").action((slug) => setPublished(slug, true));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "evolutionary-arcade",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "The arcade CLI for Evolutionary Arcade. Publish, update, regen, fork, and blend AI-made browser games with your own coding agent.",
   "type": "module",
   "license": "MIT",

package/skills/arcade-building-games/SKILL.md

@@ -59,7 +59,7 @@ someone else's game, see `arcade-remix-and-blend`.
    files by relative URL is fine. `arcade dev` lets `ws:` through but the arcade doesn't, so don't
    trust dev for sockets. Don't add tracking code; the arcade measures play from outside the frame.
 4. **Start on a click or keypress.** Show a title screen with "Click to play". Create or resume the
-   `AudioContext` inside that handler. Request pointer lock and fullscreen only from a gesture. Esc
+   `AudioContext` inside that handler. Request pointer lock only from a gesture. Esc
    and gamepad buttons don't count as gestures, so a controller-only player can't turn on sound.
    Show "click or press any key once."
 5. **Pointer lock comes from the sandbox token.** The arcade grants `allow-pointer-lock`, and Chrome
@@ -97,7 +97,15 @@ someone else's game, see `arcade-remix-and-blend`.
    like every game here. Anything you do bundle from others, like a vendored Three.js, keeps its
    own license: ship its LICENSE beside it (`vendor/three/LICENSE`), and only bundle what's yours
    to share.
-10. **Storage is optional, and shared.** `localStorage` works (a saved high score is nice), but wrap
+10. **Don't build fullscreen. The platform owns it.** The arcade's player has the fullscreen
+    button, and on phones the game page's Play button opens the game straight into it. It uses
+    the Fullscreen API where there is one, covers the whole page on iPhone (which has none for
+    games), and locks the orientation on Android. So no
+    fullscreen button, no `requestFullscreen()` or `webkitRequestFullscreen()`, and no
+    `screen.orientation.lock()` of your own. Size the game to its frame (`resize` events) and it
+    works full-size. `arcade publish` warns when your code calls requestFullscreen: "the arcade's
+    player owns fullscreen; remove your fullscreen button".
+11. **Storage is optional, and shared.** `localStorage` works (a saved high score is nice), but wrap
     every access in try/catch. Every version and generation of a game shares one origin, including
     other people's regens. Prefix keys with your slug, version your save format, and handle old or
     malformed data. To keep progress across devices, use profile saves (below).
@@ -259,7 +267,7 @@ a game's history is a record of what each model could build.
 - **Touch:** without `input.touch: true`, phones get your demo video instead of the game. Set it
   only if the game has real touch controls, like an on-screen stick and buttons with large targets
   (48 px or more). Use pointer events, put `touch-action: none` on the canvas, and don't rely on
-  hover. Test at phone width, where the 16:9 frame is tiny until the player goes fullscreen. To
+  hover. Test at phone width (390x844 with touch), where the player opens fullscreen. To
   try it on a real phone, run `arcade dev --host` and open the network address it prints on a
   phone on the same Wi-Fi.
 - **Tilt:** see Phone tilt, next.
@@ -282,21 +290,18 @@ that have touch on, and every tilt game needs touch controls anyway.
   little. Put "Recenter" in the pause menu.
 - **Turn the axes with the screen.** `gamma` is left-right only in portrait. In landscape it's
   `beta`, and the sign flips with the side the phone is turned to (`screen.orientation.angle`).
-- **Landscape lock only works in fullscreen on Android.** The arcade's Fullscreen button already
-  locks landscape there. A game that goes fullscreen from its own tap can lock too (a portrait
-  game can lock `"portrait"`). iPhones never lock and have no fullscreen for games, so show
-  "Turn your phone sideways" while a landscape game is held upright.
+- **Orientation is the platform's job.** Set `orientation` in arcade.json (`"landscape"`,
+  `"portrait"`, or `"both"`) and don't lock it yourself; the arcade's fullscreen player locks
+  the screen on Android. iPhones never lock, so a landscape game shows "Turn your phone sideways"
+  while it's held upright.
 
 ```js
-const LANDSCAPE = true;                                // a landscape-first game
 let tiltOk = false, zero = null, tilt = 0;             // tilt: -1..1; steer by touch until tiltOk
 async function onStartTap() {                          // the "Tap to play" handler
   const DOE = globalThis.DeviceOrientationEvent;
   const asking = typeof DOE?.requestPermission === "function"
     ? DOE.requestPermission().catch(() => "denied")    // iPhone: asks, so call it before any await
     : Promise.resolve(DOE ? "granted" : "denied");
-  if (LANDSCAPE) document.documentElement.requestFullscreen?.()
-    .then(() => screen.orientation.lock("landscape")).catch(() => {}); // Android only
   tiltOk = (await asking) === "granted";
   zero = null;                                         // "Recenter" does this too
   startOrResume();

package/skills/arcade-fork/SKILL.md

@@ -55,7 +55,7 @@ Play-test the idea before you touch code. Ask these together, in one message, an
 > 2. What should stay? The thing you liked most about the original. (default: its core feel)
 > 3. A name for your game? It becomes its address, evolutionaryarcade.com/g/<name>, and can't change later. (default: I'll suggest one from your idea)
 > 4. Phones: want touch controls so people watching on their phones can play it? (default: yes, if the original doesn't have them)
-> 5. Want me to record a short demo so your game page has a video and a GIF to share? (default: yes)"
+> 5. Want me to record a short demo so your game page has a video and a GIF to share? It comes in two shapes, wide for computers and tall for phones. (default: yes)"
 
 **For a blend**, replace question 1 and 2 with: "Which game's loop is the spine? I'll assume <spine>, with <donor> giving one thing: its movement, its look, an enemy, a mechanic. Which thing do you want from <donor>?" and say in one sentence what the blend would be ("Fly a starfighter to defend a deep-space relay from drone waves"). If they can't say it without "and also", it's two games; help them pick one.
 
@@ -105,9 +105,11 @@ Play it after every meaningful change, with real inputs through Playwright again
 
 ## Step 6. Media, demo, and GIF
 
-Capture new media from **their** build: a fork arrives with the parent's files, and a card showing the parent's footage misrepresents the game. A 1280x720 thumbnail mid-action and 2-4 screenshots from real play (`arcade guide publishing`, "Capturing media").
+Estimate (say it's an estimate): about 5 minutes for a landscape game's media and demo, the vertical set included, since `arcade media vertical` makes it; about 10 for a portrait or both game, which records upright play too.
 
-If they said yes to a demo (the default): record 15-30 s of real play at 1280x720 with the action in the first second, save it as `media/demo.mp4`, set `"demo_video"`, and run `arcade media preview`. That makes the hover preview and `media/preview.gif`. Look at the GIF before moving on. Keep raw recordings outside the game folder; everything in it is uploaded.
+Capture new media from **their** build: a fork arrives with the parent's files, and a card showing the parent's footage misrepresents the game. A 1280x720 thumbnail mid-action and 2-4 screenshots from real play, plus the vertical (phone) set in the same pass: check `orientation` still fits their version (play it at 390x844 with touch), then capture upright play into `media/vertical/` for a portrait or both game, or run `arcade media vertical` for a landscape one, which puts the landscape media over a blurred fill (`arcade guide publishing`, "Capturing media" and "Orientation and the vertical set"). The parent's vertical files are the parent's footage too, so remake them. If the game has its own fullscreen button, remove it: the arcade's player owns fullscreen.
+
+If they said yes to a demo (the default): record 15-30 s of real play at 1280x720 with the action in the first second, save it as `media/demo.mp4`, set `"demo_video"`, and run `arcade media preview`. That makes the hover preview and `media/preview.gif`. For a portrait or both game, also record upright play at 390x844 into `media/vertical/demo.mp4`; then run `arcade media vertical` either way. Look at both GIFs before moving on. Keep raw recordings outside the game folder; everything in it is uploaded.
 
 ## Step 7. One dry run, one go, publish
 

package/skills/arcade-onboarding/SKILL.md

@@ -97,7 +97,7 @@ For each candidate, decide from facts, then build one numbered table. It goes in
 
 Verdicts: **ready** (publishes as-is once it has metadata and media), **small fixes** (absolute paths, a CDN import to vendor, a build step, a stray big file), **not a fit** (needs a server, no web build, mostly someone else's work). Give the reason in a few words.
 
-**Time estimates are yours.** Look at the code before you estimate, and say they're estimates. As a starting point: as-is with metadata and media takes you a few minutes per game; touch controls 10-20 min; gamepad 5-10; saves or a leaderboard 5-10 each; a demo 3-5. Adjust for what you see.
+**Time estimates are yours.** Look at the code before you estimate, and say they're estimates. As a starting point: as-is with metadata and media takes you a few minutes per game, including the vertical (phone) set: about 1 more minute for a landscape game (`arcade media vertical` makes it), 3-5 for a portrait or both game (an upright capture at 390x844); touch controls 10-20 min; gamepad 5-10; saves or a leaderboard 5-10 each; a demo 3-5 (twice that for a portrait or both game, which records a vertical demo too); removing a game's own fullscreen button 2-5. Adjust for what you see.
 
 ```
 #  Game          Where                       Fit          What it needs               As-is / optimized
@@ -117,7 +117,9 @@ Follow their step-1 answer for the whole batch.
 - write `arcade.json` (`arcade guide publishing` has a full example): a slug you pick with them (permanent, it's the game's address), the title, a one-or-two-sentence description, exact `controls`, and honest `input` flags;
 - write `LICENSE` (MIT, "Copyright (c) <year> @<handle>") unless they already have an MIT one;
 - run it with `arcade dev`, fix anything that breaks under the arcade's CSP (outside requests, absolute paths);
-- capture a 1280x720 thumbnail mid-action and 2-4 screenshots from real play (`arcade guide publishing`, "Capturing media");
+- decide its `orientation` by playing it at 390x844 with touch: `"landscape"` if it needs the phone sideways (fine), `"portrait"` if it plays upright, `"both"` if either works;
+- capture a 1280x720 thumbnail mid-action and 2-4 screenshots from real play, and in the same pass the vertical set: for portrait or both, an upright thumbnail and 2-4 screenshots at 390x844 with touch emulation into `media/vertical/`; for landscape, run `arcade media vertical`, which puts the landscape media over a blurred fill (`arcade guide publishing`, "Capturing media" and "Orientation and the vertical set");
+- remove any fullscreen button of the game's own and its `requestFullscreen` calls: the arcade's player owns fullscreen (the dry run warns about them);
 - fill the Model card with what they tell you (the model and harness they used); leave out anything unknown. Never invent numbers.
 
 **Optimize** adds, per game, only what makes sense for it, using the arcade's format (`arcade guide building-games` has each one):
@@ -131,7 +133,7 @@ Play every game after you change it. Set an input flag only when that path works
 
 ## Step 6. Demos
 
-If they said yes in step 1 (the default), then for each game: play it with Playwright at 1280x720 against `arcade dev` (drive real inputs, or the game's autopilot if it has one), cut 15-30 s with the action in the first second, save it as `media/demo.mp4`, set `"demo_video"`, and run `arcade media preview`. That makes `media/preview.mp4` (the hover preview) and `media/preview.gif`, and sets both fields. **A game with a demo must have its GIF**; `arcade publish` makes it when it's missing and refuses without ffmpeg. Watch the clips and look at the GIF before moving on. Bot-driven footage is fine; say so in `provenance.notes`. Keep recordings outside the game folder, since everything in it is uploaded. Recording needs Playwright and ffmpeg; if they're missing, ask before installing.
+If they said yes in step 1 (the default), then for each game: play it with Playwright at 1280x720 against `arcade dev` (drive real inputs, or the game's autopilot if it has one), cut 15-30 s with the action in the first second, save it as `media/demo.mp4`, set `"demo_video"`, and run `arcade media preview`. That makes `media/preview.mp4` (the hover preview) and `media/preview.gif`, and sets both fields. Then the vertical demo: a portrait or both game records upright play at 390x844 with touch into `media/vertical/demo.mp4` (set `media_vertical.demo_video`); every game then runs `arcade media vertical` (for a landscape game it makes the whole vertical set from the landscape demo over a blurred fill). **A game with a demo must have its GIF**; `arcade publish` makes it when it's missing and refuses without ffmpeg. Watch the clips and look at the GIF before moving on. Bot-driven footage is fine; say so in `provenance.notes`. Keep recordings outside the game folder, since everything in it is uploaded. Recording needs Playwright and ffmpeg; if they're missing, ask before installing.
 
 ## Step 7. One dry run, one go, publish
 

package/skills/arcade-publishing/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: arcade-publishing
-description: Use when a browser game is ready, or nearly ready, to go live on Evolutionary Arcade (evolutionaryarcade.com) with the `arcade` CLI, or when you are shipping the next version of a game you already published. Covers filling in arcade.json and replacing the CLI's placeholder text, writing an honest Model card (models, harness, tokens, cost, prompts), capturing the thumbnail, screenshots, demo, and hover preview with Playwright and ffmpeg, reviewing `arcade publish --dry-run` and its Heads up list with the user before `arcade publish --yes`, fixing problems (exit code 2) including a flagged secret, finding generation ids with `arcade info` for `arcade main`, and taking a game down with `arcade unpublish`.
+description: Use when a browser game is ready, or nearly ready, to go live on Evolutionary Arcade (evolutionaryarcade.com) with the `arcade` CLI, or when you are shipping the next version of a game you already published. Covers filling in arcade.json and replacing the CLI's placeholder text, writing an honest Model card (models, harness, tokens, cost, prompts), deciding the game's orientation and capturing both media sets (landscape at 1280x720, vertical at 390x844 or the CLI's blurred fill) with Playwright and ffmpeg, reviewing `arcade publish --dry-run` and its Heads up list with the user before `arcade publish --yes`, fixing problems (exit code 2) including a flagged secret, finding generation ids with `arcade info` for `arcade main`, and taking a game down with `arcade unpublish`.
 ---
 
 # Publishing a game to Evolutionary Arcade
@@ -16,6 +16,7 @@ Not playable under the arcade's rules yet? Use `arcade-building-games`. First ti
 ## What good looks like
 
 - The thumbnail is a real frame of play, mid-action, 1280x720.
+- Phones get a vertical set that tells the truth about how the game plays: real upright play for a portrait game, or the landscape footage over a blurred fill for a game that only plays sideways.
 - The hover preview comes from this build's demo, and its first seconds show the game doing its best thing. No title screen, no loading.
 - A stranger understands the title and description, and the controls are exact.
 - The Model card is honest: filled in where you know, left out where you don't.
@@ -35,6 +36,8 @@ Required: `schema`, `slug`, `title`, `description`, `thumbnail`, and at least on
 - `profile_saves` (default `false`): the game saves progress to the player's profile with the `arcade-saves.js` helper. Set it only when the game uses the helper; `arcade-building-games` has the rules.
 - `leaderboards` (up to 4, default none): global leaderboards the game posts to with the `arcade-scores.js` helper. Each has an `id`, a `label`, and a `max`, and the dry run lists them with their limits. `arcade-building-games` has the rules.
 - `thumbnail` and `screenshots` (1 to 12) are .png, .jpg, or .webp. `demo_video` and `preview_video` are .mp4 or .webm. `preview_gif` is a .gif cut from the demo, required whenever there's a demo; `arcade media preview` (or `arcade publish`) makes it. Every path is relative to the folder, with no `..`.
+- `orientation` (default `"landscape"`): which way up the game plays on a phone. `"landscape"`, `"portrait"`, or `"both"`. See "Orientation and the vertical set" below.
+- `media_vertical` (optional): the phone (9:16) set, with the same fields as the landscape set: `thumbnail`, `screenshots` (up to 12), `demo_video`, `preview_video`, `preview_gif`. The top-level fields are the landscape set. A `portrait` or `both` game with `touch` must list a vertical thumbnail and at least one vertical screenshot, plus a vertical demo when it has a landscape demo. A landscape game's set is made by `arcade media vertical`.
 - `license` (optional): every game on the arcade is open source under MIT, so leave it out or set it to `"MIT"`. Anything else fails validation. The folder's `LICENSE` names the creator ("Copyright (c) <year> @handle"); if `arcade new` wrote it before you logged in, `arcade publish` fills in the handle. A license file at the top of the folder (`LICENSE`, `LICENSE.md`, `COPYING`, and the like) that isn't MIT stops the publish; other people's licenses go in `licenses/<name>/` or beside their code.
 - `lineage`: the CLI writes it. Don't edit it.
 - `provenance`: the Model card.
@@ -120,17 +123,52 @@ ffmpeg -ss 4 -i ../rec/<file>.webm -t 24 -an -vf scale=1280:720 \
 - **Budget:** the whole upload must stay under 50 MB and 800 files. The thumbnail and each screenshot must be at most 5 MB, and the demo, preview, and any other file at most 25 MB. A 24-second demo at CRF 23 is about 8 MB.
 - **Look at every file** before you publish. For video, a contact sheet is quick: `ffmpeg -i media/demo.mp4 -vf fps=1/3,scale=320:-1,tile=4x3 -frames:v 1 ../rec/sheet.png` (one image, covering 36 s). If headless WebGL renders black, run headed or pass GPU flags to Chromium (on macOS the seeds used `--use-angle=metal --ignore-gpu-blocklist`).
 
+## Orientation and the vertical set
+
+Phones are a big share of players, and a 16:9 card is a sliver on a phone held upright. So every game ships two media sets: landscape (the top-level fields) and vertical (`media_vertical`). The site shows phones the vertical set. One size doesn't fit all, and the vertical set has to be honest about how the game plays.
+
+**Decide the orientation by playing it on a phone.** Run `arcade dev`, open it in Playwright at 390x844 with touch emulation (or on a real phone), and play:
+- `"portrait"`: it plays upright and was built for it (a tall playfield, thumb controls at the bottom).
+- `"both"`: it lays out and plays well either way.
+- `"landscape"`: it needs the phone sideways. That's fine. Don't fake an upright mode.
+A game without touch controls is `"landscape"` unless you add them.
+
+**Capture both sets in one pass.** Same build, same `arcade dev` server, two contexts:
+
+```js
+// Landscape: as above, 1280x720.
+// Vertical (portrait and both games): a phone, with touch.
+const phone = await browser.newContext({
+  viewport: { width: 390, height: 844 },
+  deviceScaleFactor: 3,              // screenshots come out 1170x2532
+  isMobile: true,
+  hasTouch: true,
+  recordVideo: { dir: "../rec/vertical", size: { width: 390, height: 844 } },
+});
+const p = await phone.newPage();
+await p.goto("http://localhost:5173/?autopilot");
+await p.tap("canvas");               // a tap, not a click
+```
+
+Encode the vertical demo at 1080x1920: `ffmpeg -ss 4 -i ../rec/vertical/<file>.webm -t 24 -an -vf scale=1080:1920 -c:v libx264 -pix_fmt yuv420p -crf 23 -movflags +faststart media/vertical/demo.mp4`.
+
+**Choose the vertical treatment by orientation:**
+- **portrait or both:** real upright play. Save the vertical thumbnail and 2 to 4 screenshots in `media/vertical/`, the demo as `media/vertical/demo.mp4`, list them under `media_vertical`, then run `arcade media vertical`: it cuts the vertical hover preview (480x854) and GIF from your vertical demo. For `both`, still capture the landscape set at 1280x720; desktop shows it.
+- **landscape:** capture only the landscape set, then run `arcade media vertical`. It centers each landscape image and the demo at full width over a blurred, darkened copy of itself at 1080x1920, writes `media/vertical/` (thumbnail, screenshots, demo, preview, GIF), and sets `media_vertical`. `arcade publish` does this for you when the set is missing. Re-run it after a new landscape demo or thumbnail; the dry run warns when the vertical set is older.
+
+Look at the vertical files too (a contact sheet: `ffmpeg -i media/vertical/demo.mp4 -vf fps=1/3,scale=180:-1,tile=6x2 -frames:v 1 ../rec/vsheet.png`). Upright footage of a game that only plays sideways, or a blurred fill whose middle band is unreadable, is a false promise.
+
 ## The dry run
 
 Run `arcade publish --dry-run` and read all of it. It uploads nothing, but know what it is:
 
 - Signed out, it runs only the local checks (arcade.json, file types, license, media, secrets), prints any Heads up, and exits 1 asking you to sign in. The full dry run needs `arcade login` and a network connection, because the arcade checks the upload before anything is listed. Problems the arcade finds (a file over 25 MB, too many files, a slug that's taken, a stale base) exit before the file list prints.
 - Every problem it exits 2 on says what to produce: a missing thumbnail names the size and path to capture, a missing arcade.json lists the fields to write.
-- It may make `media/preview.mp4` and `media/preview.gif` and write `preview_video` and `preview_gif` into arcade.json.
+- It may make `media/preview.mp4` and `media/preview.gif` and write `preview_video` and `preview_gif` into arcade.json, and, for a landscape game, the vertical set in `media/vertical/` and `media_vertical`.
 - It lists the first 40 files, then "…and N more", but files inside hidden folders (like `.claude/`) are always listed. New files are tagged `new`. Review the whole tree yourself: `find . -type f -not -path './node_modules/*' -not -path './.git/*'`.
 - It follows symlinks only when they point inside the folder. Anything else is listed as skipped, and never uploaded.
 - It says "Published games are open source under MIT" under the action line. Anything bundled from others keeps its own license and must be the user's to share.
-- Its **Heads up** list flags likely mistakes without stopping the publish: a leftover `parents/`, `BLEND.md` or `PROMPT.md`, media already on the arcade on a fork, blend, or regen (so probably the parent's), starter text, a placeholder slug, a home-folder path in the prompt or notes, a thumbnail over 500 KB, and no model or prompt on the Model card. Fix each one, or tell the user why it's fine.
+- Its **Heads up** list flags likely mistakes without stopping the publish: a leftover `parents/`, `BLEND.md` or `PROMPT.md`, media already on the arcade on a fork, blend, or regen (so probably the parent's), starter text, a placeholder slug, a home-folder path in the prompt or notes, a thumbnail over 500 KB, no vertical thumbnail, a vertical set older than the landscape media, game code that calls `requestFullscreen` ("the arcade's player owns fullscreen; remove your fullscreen button"), and no model or prompt on the Model card. Fix each one, or tell the user why it's fine.
 - Its Model card shows the model, tokens, cost, time, process, and the prompt's length, not the prompt or notes text. Read those in arcade.json.
 
 What to check: