juicyjuicy 0.8.0 → 0.9.0

package/dist/index.js

@@ -19807,7 +19807,7 @@ function date4(params) {
 }
 
 // ../shared/src/cli.ts
-var CLI_RELEASE = "0.8.0";
+var CLI_RELEASE = "0.9.0";
 function cliCommand(args) {
   return `npx -y juicyjuicy@${CLI_RELEASE} ${args}`;
 }
@@ -19888,6 +19888,10 @@ var RATE_LIMITS = {
    * so it also bounds how many rooms a member can open.
    */
   roomTicket: { limit: 60, windowSeconds: 10 * 60 },
+  /** Highscores sent (D56); the player sends at most one per game every 5 s, and only a new best. */
+  scoreSubmit: { limit: 60, windowSeconds: 10 * 60 },
+  /** Leaderboard reads (D56), per member or, for visitors, per network. */
+  scoreRead: { limit: 120, windowSeconds: 10 * 60 },
   /** Thumbnails uploaded from the dashboard (each publish can bring one too). */
   thumbnail: { limit: 20, windowSeconds: 60 * 60, newAccountLimit: 10 },
   /**
@@ -20240,7 +20244,14 @@ var GAME_MESSAGES = {
    */
   room: "juicyjuicy:room",
   /** `{ type, code }`: show the share sheet for an invite link to this room (D54). No answer. */
-  invite: "juicyjuicy:invite"
+  invite: "juicyjuicy:invite",
+  /**
+   * `{ type, id, score, order, format }`: the member's score, kept on the game's leaderboard when
+   * it beats their best (D56). Answered with `scored`.
+   */
+  score: "juicyjuicy:score",
+  /** `{ type, id, limit }`: the game's leaderboard, its top `limit` (D56). Answered with `leaderboard`. */
+  scores: "juicyjuicy:scores"
 };
 
 // ../shared/src/features.ts
@@ -20285,10 +20296,15 @@ var GAME_FEATURES = [
   {
     id: "highscores",
     name: "Global highscores",
-    adds: "A leaderboard shared by every player, kept by JuicyJuicy.",
+    summary: "A leaderboard of every signed-in player's best, in the game and on its page.",
+    adds: "A leaderboard kept by JuicyJuicy with its juicy.scores snippet: each signed-in player's best score or time, shown in the game and on its page on JuicyJuicy.",
     why: "Players compete with everyone who played, not just their own best, and come back to climb.",
-    detection: { kind: "declared" },
-    status: "coming-soon"
+    detection: { kind: "marker", marker: GAME_MESSAGES.score },
+    status: "available",
+    recipe: "reference/highscores.md",
+    task: "add JuicyJuicy global highscores: send each finished run's score and show the leaderboard in the game",
+    docs: "/docs/publish#highscores",
+    missingHint: "paste the juicy.scores snippet (https://juicyjuicy.games/docs/publish/cli#highscores) and send scores with juicy.scores.submit(), or take it out of features"
   },
   {
     id: "multiplayer",
@@ -21175,6 +21191,9 @@ var ROOM_CODE_ALPHABET = "ABCDEFGHJKMNPQRSTUVWXYZ23456789";
 var ROOM_CODE_LENGTH = 6;
 var ROOM_CODE_PATTERN = new RegExp(`^[${ROOM_CODE_ALPHABET}]{${ROOM_CODE_LENGTH}}$`);
 
+// ../shared/src/scores.ts
+var points = new Intl.NumberFormat("en-US");
+
 // ../shared/src/security-headers.ts
 var DENIED_FEATURES = [
   "camera",
@@ -24702,7 +24721,7 @@ var program = new Command();
 // package.json
 var package_default = {
   name: "juicyjuicy",
-  version: "0.8.0",
+  version: "0.9.0",
   description: "Publish AI-made browser games to juicyjuicy.games",
   type: "module",
   license: "MIT",

package/dist/skill/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: juicyjuicy-publish
-description: Publish or update a browser game on JuicyJuicy (juicyjuicy.games) and give the user a link to play it. Use when the user asks to publish, upload, share, deploy, update or release a game "on JuicyJuicy" or "to juicyjuicy.games", or to get a playable link for a web game they made with you. Also use to remix a game from JuicyJuicy (download a remixable game, change it, publish the remix), and to add a JuicyJuicy upgrade to a game (cloud saves, multiplayer, more languages, a browser-friendly menu).
+description: Publish or update a browser game on JuicyJuicy (juicyjuicy.games) and give the user a link to play it. Use when the user asks to publish, upload, share, deploy, update or release a game "on JuicyJuicy" or "to juicyjuicy.games", or to get a playable link for a web game they made with you. Also use to remix a game from JuicyJuicy (download a remixable game, change it, publish the remix), and to add a JuicyJuicy upgrade to a game (cloud saves, global highscores, multiplayer, more languages, a browser-friendly menu).
 ---
 
 # Publish a game to JuicyJuicy
@@ -9,19 +9,19 @@ JuicyJuicy hosts **static browser games** (HTML/JS/CSS/assets, WebAssembly) and
 
 Run every CLI command with `--json`. Each output line is a JSON object; the **last** line is the result, either `{"ok": true, …}` or `{"ok": false, "error": {"code", "message", "details"?, "hint"?}}`. The exit code is `0` (ok), `1` (fix the game or `juicy.json`), `2` (log in) or `3` (network or server problem, so retry).
 
-Run the CLI exactly as written here, `npx -y juicyjuicy@0.8.0 …`: this skill is made for that release. If JuicyJuicy answers that the CLI is out of date, run the command its message gives. It updates the CLI and this skill together; read this skill again afterwards and use the release it names from then on.
+Run the CLI exactly as written here, `npx -y juicyjuicy@0.9.0 …`: this skill is made for that release. If JuicyJuicy answers that the CLI is out of date, run the command its message gives. It updates the CLI and this skill together; read this skill again afterwards and use the release it names from then on.
 
 ## Procedure
 
 ### 1. Make sure the CLI is logged in
 
 ```bash
-npx -y juicyjuicy@0.8.0 whoami --json
+npx -y juicyjuicy@0.9.0 whoami --json
 ```
 
 If it exits with `2`, log in. `login` opens the user's browser and **waits up to 10 minutes** for them to approve:
 
-- Run `npx -y juicyjuicy@0.8.0 login --json` in the background if your shell can, and read its first output line (`{"event": "device_code", "userCode", "verificationUrl"}`) right away, and show the user the code and link without waiting for them to ask: the page shows the same code, and that's how they know the login is theirs.
+- Run `npx -y juicyjuicy@0.9.0 login --json` in the background if your shell can, and read its first output line (`{"event": "device_code", "userCode", "verificationUrl"}`) right away, and show the user the code and link without waiting for them to ask: the page shows the same code, and that's how they know the login is theirs.
 - Then tell the user, with the real code and link: *"A JuicyJuicy page opened in your browser. Check it shows the code **WXTZ-BCDF** and click **Approve**. If no page opened, go to <verificationUrl>."*
 - If your shell can't run commands in the background, say that first (without a code: it doesn't exist yet), then run it in the foreground with a timeout of at least 10 minutes. The code is also printed as `Your code: …`.
 - The user needs a JuicyJuicy account (it's invite-only for now). If the page says they can't sign in, they need an invite link from a friend who's a member.
@@ -45,7 +45,7 @@ Files and folders starting with `.` (`.env`, `.git/`, …) and `node_modules/` a
 `juicy.json` sits in the project folder and describes the game. Create or update it with `init`, filling in what you know from the game you built:
 
 ```bash
-npx -y juicyjuicy@0.8.0 init --yes --json \
+npx -y juicyjuicy@0.9.0 init --yes --json \
   --title "Snake Deluxe" \
   --description "Eat the apples, don't bite your tail. Arrow keys or swipe." \
   --made-with "<your model name>, <the tool you run in>" \
@@ -84,7 +84,7 @@ To replace it, the user saves a screenshot as `thumbnail.png` in the project fol
 
 Do this **every time**, also for updates. It protects the user and their players; JuicyJuicy's server runs its own checks as well, so this is help, not a formality to get past.
 
-1. **Check.** Run `npx -y juicyjuicy@0.8.0 check --json`. Errors (a failed result) must be fixed: explain each one (`details` has a `rule` and a `path`), and offer to fix it. If the user says no, **stop and don't publish**: the server would refuse it anyway. Warnings in the result (`findings`) go into step 2.
+1. **Check.** Run `npx -y juicyjuicy@0.9.0 check --json`. Errors (a failed result) must be fixed: explain each one (`details` has a `rule` and a `path`), and offer to fix it. If the user says no, **stop and don't publish**: the server would refuse it anyway. Warnings in the result (`findings`) go into step 2.
    Every file in the result's `files` will be public. If `unusualFiles` isn't empty (names that look like keys or private data, project files like `package.json`, notes and other files a web game doesn't load), **show the user that list and ask whether those files should be public** before publishing; offer to move them out of the build folder or set `buildDir` to a folder with just the game.
 2. **Security review.** Follow [reference/review.md](reference/review.md): keys and tokens, `innerHTML`/`eval` on network or multiplayer data, `http://` loads, trackers, login or payment forms, anything that leaves the page. Same rule: for what it marks as must-fix, fix it or don't publish.
 3. **Standards.** Check the game against these and tell the user, in a sentence or two, what falls short; offer to fix it. A "no" still publishes: not every game can have touch controls.
@@ -113,7 +113,7 @@ Keep it short when there's nothing to say: "Checked: no problems found" is enoug
 ### 6. Publish
 
 ```bash
-npx -y juicyjuicy@0.8.0 publish --json --message "<what changed, in a few words>"
+npx -y juicyjuicy@0.9.0 publish --json --message "<what changed, in a few words>"
 ```
 
 This makes the new version live: when the user says "publish", that's what they want. Don't add `--draft` (see "Other commands") unless they asked in words for it not to go live yet. Not for a first publish, a big game or one you're unsure of either: the user would have to find the dashboard and make it live themselves.
@@ -134,12 +134,13 @@ The game's page under My games on JuicyJuicy has an **Upgrades** panel; its Add
 |---|---|---|
 | Browser-friendly menu | [reference/browser-menu.md](reference/browser-menu.md) | `"features": ["browser-menu"]` |
 | Cloud saves | [reference/cloud-saves.md](reference/cloud-saves.md) | `"features": ["cloud-saves"]` |
+| Global highscores | [reference/highscores.md](reference/highscores.md) | `"features": ["highscores"]` |
 | Multi-language | [reference/languages.md](reference/languages.md) | `"languages": ["en", …]` |
 | Multiplayer | [reference/multiplayer.md](reference/multiplayer.md) | `"features": ["multiplayer"]` |
 
-Other features on the panel (global highscores, touch controls, gamepad, mouse lock, auto-pause) are "Coming soon" and have no recipe yet: if asked for one, say so, and build it your own way only if the user wants.
+Other features on the panel (touch controls, gamepad, mouse lock, auto-pause) are "Coming soon" and have no recipe yet: if asked for one, say so, and build it your own way only if the user wants.
 
-1. **Find the project.** Log in first (step 1). The project is the folder whose `juicy.json` has the game's `slug`: the current folder, or one the user points you to. **If it isn't on this computer** (or you're in a chat app or sandbox), download the live version: `npx -y juicyjuicy@0.8.0 pull <slug> --json` writes it into a new folder named after the slug (`dir` in the result) with its `juicy.json`, and you work there. Read the result's `next`: the download is the built game, so for a bundled one (minified code), ask whether the user has the source somewhere, or use `sourceUrl`, before changing the bundle itself. `pull` only works for the user's own games (`NOT_FOUND` otherwise).
+1. **Find the project.** Log in first (step 1). The project is the folder whose `juicy.json` has the game's `slug`: the current folder, or one the user points you to. **If it isn't on this computer** (or you're in a chat app or sandbox), download the live version: `npx -y juicyjuicy@0.9.0 pull <slug> --json` writes it into a new folder named after the slug (`dir` in the result) with its `juicy.json`, and you work there. Read the result's `next`: the download is the built game, so for a bundled one (minified code), ask whether the user has the source somewhere, or use `sourceUrl`, before changing the bundle itself. `pull` only works for the user's own games (`NOT_FOUND` otherwise).
 2. **Read the recipe** for the upgrade and make the change. Keep everything else about the game as it is.
 3. **Build and try it** (step 2), then **declare it** in `juicy.json` as the table says, adding to what's already listed.
 4. **Review and publish** as steps 5–7 say, with `--message "Add <upgrade>"`. In step 5's `check` result, `features.detected` lists what JuicyJuicy found in the files; a `feature-missing` warning means a declared upgrade isn't there yet: fix it before publishing.
@@ -147,14 +148,14 @@ Other features on the panel (global highscores, touch controls, gamepad, mouse l
 
 ## Bring all my games up to date
 
-When the user asks to bring their JuicyJuicy games up to date or fix a **Needs update** badge, when `check` warns `requirement-missing`, or after updating the CLI: follow [reference/update-all-games.md](reference/update-all-games.md). It starts with `npx -y juicyjuicy@0.8.0 check-games --json`, which checks every game of the user's at once and settles what a script can; the rest are code changes, one game at a time.
+When the user asks to bring their JuicyJuicy games up to date or fix a **Needs update** badge, when `check` warns `requirement-missing`, or after updating the CLI: follow [reference/update-all-games.md](reference/update-all-games.md). It starts with `npx -y juicyjuicy@0.9.0 check-games --json`, which checks every game of the user's at once and settles what a script can; the rest are code changes, one game at a time.
 
 ## Remix a game
 
 A game marked remixable on JuicyJuicy can be downloaded, changed and published as a new game that links back to it. Log in first (step 1), then:
 
 ```bash
-npx -y juicyjuicy@0.8.0 remix <slug> --json
+npx -y juicyjuicy@0.9.0 remix <slug> --json
 ```
 
 - The first line is `{"event": "license", "name", "text"}`: the remix license. Tell the user in a sentence what it says. In short: the remix may be published **on JuicyJuicy only**, never anywhere else, and the files aren't to be passed on. The full text is:
@@ -189,9 +190,9 @@ Everything else is in [reference/troubleshooting.md](reference/troubleshooting.m
 
 ## Other commands
 
-- `npx -y juicyjuicy@0.8.0 list --json`: the user's games; `list <slug>` shows one game's versions. `--all` lists every game on JuicyJuicy instead (60 a page, `--page 2` and on; `nextPage` in the result), `--owner <username>` another creator's. Narrow and order any list with `--search <title text>`, `--tag`, `--engine`, `--remixes`, `--sort newest|upvoted|downvoted|played` and `--period 24h|week|month|all`, e.g. to find a game to remix.
-- `npx -y juicyjuicy@0.8.0 publish --draft --json`: uploads a new version without making it live (players keep the current one). Only when the user asks for that in words (e.g. "upload it but don't put it live yet"), never on your own judgment. The result has `draft: true`; when they say so, make it live with `rollback <version>`, or they can on the dashboard.
-- `npx -y juicyjuicy@0.8.0 rollback <version> --slug <slug> --json`: makes an earlier version or a draft live, e.g. when the user says the last update broke the game. Run `list <slug>` first to pick the version with the user; one waiting for an admin's review can't be made live (`FORBIDDEN`).
-- `npx -y juicyjuicy@0.8.0 pull <slug> --json`: downloads the live version of one of the user's own games into a new folder with its `juicy.json`, to change it when the project isn't on this computer (see "Add a JuicyJuicy upgrade").
-- `npx -y juicyjuicy@0.8.0 check-games --json`: checks all the user's games against JuicyJuicy's features and required updates, declares the features it finds where a game never declared them, and lists what still needs a change (see "Bring all my games up to date").
-- `npx -y juicyjuicy@0.8.0 open <slug>`: opens the game page in the browser.
+- `npx -y juicyjuicy@0.9.0 list --json`: the user's games; `list <slug>` shows one game's versions. `--all` lists every game on JuicyJuicy instead (60 a page, `--page 2` and on; `nextPage` in the result), `--owner <username>` another creator's. Narrow and order any list with `--search <title text>`, `--tag`, `--engine`, `--remixes`, `--sort newest|upvoted|downvoted|played` and `--period 24h|week|month|all`, e.g. to find a game to remix.
+- `npx -y juicyjuicy@0.9.0 publish --draft --json`: uploads a new version without making it live (players keep the current one). Only when the user asks for that in words (e.g. "upload it but don't put it live yet"), never on your own judgment. The result has `draft: true`; when they say so, make it live with `rollback <version>`, or they can on the dashboard.
+- `npx -y juicyjuicy@0.9.0 rollback <version> --slug <slug> --json`: makes an earlier version or a draft live, e.g. when the user says the last update broke the game. Run `list <slug>` first to pick the version with the user; one waiting for an admin's review can't be made live (`FORBIDDEN`).
+- `npx -y juicyjuicy@0.9.0 pull <slug> --json`: downloads the live version of one of the user's own games into a new folder with its `juicy.json`, to change it when the project isn't on this computer (see "Add a JuicyJuicy upgrade").
+- `npx -y juicyjuicy@0.9.0 check-games --json`: checks all the user's games against JuicyJuicy's features and required updates, declares the features it finds where a game never declared them, and lists what still needs a change (see "Bring all my games up to date").
+- `npx -y juicyjuicy@0.9.0 open <slug>`: opens the game page in the browser.

package/dist/skill/reference/highscores.md

@@ -0,0 +1,147 @@
+# Global highscores: `juicy.scores`
+
+On JuicyJuicy a game can have a **leaderboard** shared by every player: each signed-in player's best score (or time), kept by JuicyJuicy, shown in the game and on the game's page. The game sends a finished run's score and reads the top of the board with a small snippet. Players who aren't signed in keep their best in the game's own `localStorage` (it doesn't move to their account later). Outside JuicyJuicy (opened on its own, a local server, the automatic screenshot) the snippet uses that local best alone.
+
+## Adding it to a published game
+When the user asks for global highscores (the JuicyJuicy Upgrades panel's prompt names this file), follow "Add a JuicyJuicy upgrade" in SKILL.md, and in the game:
+1. **Decide what's ranked**, from the game, and say it in your summary: a score where more is better (`order: "high"`, the default), or a time or count where less is better (`order: "low"`); points (`format: "points"`) or milliseconds (`format: "time"`, shown as `1:23.45`). A game with several modes or levels ranks one thing: the main mode, or a total. If it isn't clear, ask the user in one short question.
+2. Paste the snippet below and use it as "Using it" says: send the score when a run ends, and show the leaderboard on the game-over screen (and in the menu if there's room).
+3. Add `"highscores"` to `features` in `juicy.json`: `"features": ["highscores"]`. JuicyJuicy also finds the snippet's `juicyjuicy:score` in the files; `check` warns when `features` lists highscores and the files don't have it, and its result's `features.detected` includes `highscores` once they do.
+
+## The snippet
+Paste it as is, before the game's own code: an inline `<script>` in `index.html`, or the top of the main script. Don't change it; it only posts messages to the page around the frame. It works next to the cloud-saves and multiplayer snippets, in any order (an older copy of the cloud-saves snippet, without `window.juicy.save ||` near its top, must come first).
+
+```js
+// JuicyJuicy highscores: https://juicyjuicy.games/docs/publish#highscores
+window.juicy = window.juicy || {};
+window.juicy.scores || (function (juicy) {
+  var KEY = "juicyjuicy:best";
+  var framed = window.parent !== window;
+  var onSite = false;
+  var next = 0;
+  var waiting = {};
+  window.addEventListener("message", function (event) {
+    var m = event.data;
+    if (event.source !== window.parent || !m || typeof m.id !== "string") return;
+    if (m.type !== "juicyjuicy:scored" && m.type !== "juicyjuicy:leaderboard") return;
+    var done = waiting[m.id];
+    if (!done) return;
+    delete waiting[m.id];
+    onSite = true;
+    done(m);
+  });
+  // The player's answer, or null when nothing answered (not on JuicyJuicy).
+  function ask(message) {
+    return new Promise(function (resolve) {
+      if (!framed) return resolve(null);
+      var id = "scores-" + ++next;
+      var timer = setTimeout(function () {
+        delete waiting[id];
+        resolve(null);
+      }, onSite ? 30000 : 10000);
+      waiting[id] = function (m) {
+        clearTimeout(timer);
+        resolve(m);
+      };
+      message.id = id;
+      window.parent.postMessage(message, "*");
+    });
+  }
+  function failed(m) {
+    var error = new Error(m ? m.error.message : "JuicyJuicy didn't answer");
+    error.code = m ? m.error.code : "TIMEOUT";
+    return error;
+  }
+  function readLocal() {
+    try {
+      var best = JSON.parse(localStorage.getItem(KEY));
+      return best && typeof best.score === "number" ? best : null;
+    } catch (e) {
+      return null;
+    }
+  }
+  function keepLocal(score, order, format) {
+    var best = readLocal();
+    var improved = !best || (order === "low" ? score < best.score : score > best.score);
+    if (improved) {
+      best = { score: score, order: order, format: format };
+      try {
+        localStorage.setItem(KEY, JSON.stringify(best));
+      } catch (e) {}
+    }
+    return { cloud: false, best: best.score, rank: null, improved: improved };
+  }
+  juicy.scores = {
+    // Sends a finished run's score: a whole number, or milliseconds for a time. Options (pass the
+    // same ones every time): order "high" (more is better, the default) or "low", format "points"
+    // (the default) or "time". Resolves to { cloud: true, best, rank, improved } or
+    // { cloud: false, best, rank: null, improved } (signed out: kept in this browser); rejects with
+    // an error that has a code.
+    submit: function (score, options) {
+      var order = (options && options.order) || "high";
+      var format = (options && options.format) || "points";
+      var message = { type: "juicyjuicy:score", score: score, order: order, format: format };
+      return ask(message).then(function (m) {
+        if (!m) {
+          if (onSite) throw failed(null);
+          return keepLocal(score, order, format);
+        }
+        if (m.ok) return { cloud: true, best: m.best, rank: m.rank, improved: m.improved };
+        if (m.error.code === "SIGNED_OUT") return keepLocal(score, order, format);
+        throw failed(m);
+      });
+    },
+    // The leaderboard's top "limit" (10 by default, at most 100): { cloud, signedIn, order,
+    // format, entries: [{ rank, name, score, me }], me: { rank, score } or null }.
+    top: function (limit) {
+      return ask({ type: "juicyjuicy:scores", limit: limit || 10 }).then(function (m) {
+        if (!m) {
+          if (onSite) throw failed(null);
+          var best = readLocal();
+          return {
+            cloud: false,
+            signedIn: false,
+            order: best ? best.order : null,
+            format: best ? best.format : null,
+            entries: best ? [{ rank: 1, name: "You", score: best.score, me: true }] : [],
+            me: best ? { rank: 1, score: best.score } : null
+          };
+        }
+        if (!m.ok) throw failed(m);
+        return {
+          cloud: true,
+          signedIn: m.signedIn,
+          order: m.order,
+          format: m.format,
+          entries: m.entries,
+          me: m.me
+        };
+      });
+    }
+  };
+})(window.juicy);
+```
+
+## Using it
+```js
+const BOARD = { order: "high", format: "points" }; // or { order: "low", format: "time" } for times in ms
+
+// When a run ends (game over, level cleared, race finished):
+juicy.scores.submit(score, BOARD).then((result) => {
+  // result: { cloud, best, rank, improved }; rank is null when the best is only kept in this browser
+  if (result.improved) showNewBest(result.best, result.rank);
+}).catch(() => {});
+
+// On the game-over screen:
+const board = await juicy.scores.top(10);
+// board: { cloud, signedIn, order, format, entries: [{ rank, name, score, me }], me: { rank, score } or null }
+```
+
+- **Send every finished run**, not just new bests, and don't wait for the answer before showing the game-over screen. Only a player's best counts; JuicyJuicy sends at most one score every 5 seconds, keeping the best.
+- **Scores are whole numbers** (`Math.round` first); times are milliseconds and can't be negative. Pass **the same `BOARD` options every time**: the first score sets how the board ranks, and a score sent another way is refused (`INVALID`) until the creator resets the board on the game's page.
+- **Show the board** with each entry's `rank`, `name` (the player's JuicyJuicy username) and `score`, highlight `me`, and when `board.me` isn't among the entries show it under them ("You: #42"). Format times as `m:ss.cc`. Put names on screen with `textContent` or the engine's text object, **never `innerHTML`** (anyone picks their own username). When `board.signedIn` is false, add a line like "Sign in on JuicyJuicy to get on the leaderboard".
+- **An empty board** (`entries` is `[]`) says "No scores yet: be the first!".
+- `submit()` resolves to `{ cloud: true, best, rank, improved }`, or `{ cloud: false, best, rank: null, improved }` when the player isn't signed in (kept in this browser), and rejects with an `Error` whose `code` is `INVALID`, `RATE_LIMITED`, `PAUSED` (highscores paused for a while), `FAILED` or `TIMEOUT`. `top()` rejects with the same codes. The game keeps running either way; just leave the board out.
+- **A game that already keeps a local high score** keeps showing it as "your best" if it likes; the leaderboard is what `top()` returns. Don't send old local high scores to `submit()`: a board is about runs played on JuicyJuicy.
+- **Scores are what the game sends.** Don't add anti-cheat code; JuicyJuicy's creator and admins remove scores that look wrong.
+- **Godot, Unity and other engines** call the same functions from JavaScript: Godot's `JavaScriptBridge.eval`, a Unity `.jslib` plugin. Put the snippet in the exported `index.html` (Godot: the HTML shell's head include; Unity: the WebGL template).

package/dist/skill/reference/languages.md

@@ -16,4 +16,4 @@ JuicyJuicy offers English, French, Italian, German, Spanish and Polish (`en`, `f
 Run the game, switch to each language and go through the menus and the first minute of play: no missing keys (an untranslated key shows up as the key's name), no clipped text, and the choice is still there after a reload.
 
 ## Declare it
-Set `languages` in `juicy.json` to every language the game now has, English first, e.g. `"languages": ["en", "fr", "pl"]` (or `npx -y juicyjuicy@0.8.0 init --yes --json --languages en,fr,pl`). Don't add it to `features`: JuicyJuicy reads `languages`, and shows the game in each language's filter.
+Set `languages` in `juicy.json` to every language the game now has, English first, e.g. `"languages": ["en", "fr", "pl"]` (or `npx -y juicyjuicy@0.9.0 init --yes --json --languages en,fr,pl`). Don't add it to `features`: JuicyJuicy reads `languages`, and shows the game in each language's filter.

package/dist/skill/reference/troubleshooting.md

@@ -6,7 +6,7 @@ With `--json`, a failed command's last line is `{"ok": false, "error": {"code",
 
 | Code | Meaning | Fix |
 |---|---|---|
-| `UNAUTHORIZED` | No saved login, or the token was revoked. | `npx -y juicyjuicy@0.8.0 login --json` (the user approves in the browser). In CI, set `JUICY_TOKEN`. |
+| `UNAUTHORIZED` | No saved login, or the token was revoked. | `npx -y juicyjuicy@0.9.0 login --json` (the user approves in the browser). In CI, set `JUICY_TOKEN`. |
 | `EXPIRED_TOKEN` | The login code expired (10 minutes) or was used. | Run `login` again. |
 | `ACCESS_DENIED` | The user clicked Deny. | Ask them, then run `login` again. |
 

package/dist/skill/reference/update-all-games.md

@@ -5,7 +5,7 @@ For "bring my JuicyJuicy games up to date", "fix the required updates", a **Need
 1. **Check every game at once.** Log in first (SKILL.md step 1), then run:
 
    ```bash
-   npx -y juicyjuicy@0.8.0 check-games --json
+   npx -y juicyjuicy@0.9.0 check-games --json
    ```
 
    JuicyJuicy checks the live version of each of the user's games on its side. It records which features each one has and, for a game whose `juicy.json` never listed its `features`, declares what it finds in the files (like cloud saves). Nothing is uploaded and no new version is made. The result has one entry per game in `games` (`features` with `on`/`off`/`unknown`, `requirements` with `passed`), `toFix` (the games that still need a code change, each with its `prompts`), `notReached` and `next`.
@@ -13,7 +13,7 @@ For "bring my JuicyJuicy games up to date", "fix the required updates", a **Need
 2. **If `notReached` isn't empty**, run `check-games` again: it had no time for those games.
 
 3. **For each game in `toFix`**, one at a time:
-   - Find its project, or download the live version with `npx -y juicyjuicy@0.8.0 pull <slug> --json` (SKILL.md, "Add a JuicyJuicy upgrade", step 1).
+   - Find its project, or download the live version with `npx -y juicyjuicy@0.9.0 pull <slug> --json` (SKILL.md, "Add a JuicyJuicy upgrade", step 1).
    - Do what each prompt says, with the recipe it names when it names one.
    - Make sure `juicy.json` has `features` (`[]` if the game has none of the upgrades).
    - Check and publish an update as SKILL.md steps 5–7 say, with `--message "Required update: <what>"`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "juicyjuicy",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Publish AI-made browser games to juicyjuicy.games",
   "type": "module",
   "license": "MIT",