@nano133/nanoterra 0.3.0 → 0.3.1

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 0.3.1 (2026-10-29)
+
+- **`@nano133/nanoterra/input`: a character that does not walk on by itself.** A key that is down when the player leaves the page (another tab, another window, a pop-up,
+  Cmd+Tab, another app on a phone) never sends its keyup to your game, so a "held keys" set kept it and the character walked on by itself on return (nano133.com's own
+  island had it, and the starter: Wes, 2026-10-29). `releaseWhenLost(release)` calls your `release` at a blur, a focus, a page hide, a hidden tab, the Cmd key and a
+  menu (keys only), and, new, drops every key REPEAT after a leave until a key goes down again (one more repeat could arrive after the release and put the key back: the
+  player now presses the key again to walk on). `pauseWhenLeft(pause)` calls your `pause` when the tab is hidden or the window loses the focus to another window.
+  `swallowsKeyup(event)` is for a keydown with Cmd, which is never held. No package, plain browser events. A round that costs money must not pause: keep the release
+  and leave `pauseWhenLeft` out.
+- **`ISLAND_MODEL`'s zone is a disc of 9 m radius** (18 m across), not 10 m (20 m across). nano133.com made its creator plots 30 m across instead of 36 m
+  (Wes, 2026-10-28; the gates' standing places moved in, so the plot's free middle is 9 m). A model that reaches 9.0 to 10.0 m from its middle passed 0.3.0
+  and fails now: the fix line names the zone as before (18.0 m across).
+
 ## 0.3.0 (2026-10-28)
 
 - **Sockets** (`@nano133/nanoterra/character`): three attach points on the character, `c.socket("head" | "hand" | "back")`, each a `THREE.Object3D` on a bone

package/README.md

@@ -4,11 +4,12 @@ Stage: Pre-alpha. What this means: https://nano133.com/stages
 
 Nanoterra for your game, in **one package**. [Nanoterra](https://nano133.com/build/nanoterra) is
 nano133.com's island. A player who is signed in there presses Play, and arrives at your game as
-themselves. This package gives your game three things:
+themselves. This package gives your game four things:
 
 - **The sign-in ticket** (`/ticket`): the player's name, Nano address and character, read in the browser. No server, no secret.
 - **The player's character** (`/character`): the same toon body that the player has on the island, drawn with Three.js. Six bases, faces, hair, clothes, sizes and colours.
 - **The looks ladder** (`/looks`): the rules of `looks.json`, the price steps, and what a change does to the players who own a look.
+- **Held input that does not stick** (`/input`, since 0.3.1): lets go of the keys and the stick when the player leaves the page, so the character never walks on by itself, and pauses a free round.
 
 It replaces `@nano133/character` 0.1.0, `@nano133/ticket` 0.1.0 and `@nano133/looks` 0.1.0
 (see "Moving from the three old packages"). Sign-in, checkout and late returns stay in their own packages
@@ -62,6 +63,7 @@ Each path loads only what it needs. A page that reads a ticket loads no Three.js
 | `@nano133/nanoterra/looks` | the looks ladder | no | 1.9 kB (all), 0.9 kB (`checkLooks` alone) |
 | `@nano133/nanoterra/character` | the builder and `createCharacter` (it includes the record), with the three sockets | yes | 21.8 kB (all, with the sockets and `createLookPreview` of 0.3.0; 20.4 kB on 0.2.0), 17.8 kB (`createCharacter` alone, measured on 0.2.0) |
 | `@nano133/nanoterra/model` | the 3D model check: a `.glb` against the island's limits or a cosmetic's (since 0.3.0) | no | 8.8 kB |
+| `@nano133/nanoterra/input` | let go of held keys and sticks when the player leaves the page, and pause: `releaseWhenLost`, `pauseWhenLeft`, `swallowsKeyup` (since 0.3.1) | no | 0.5 kB |
 | `@nano133/nanoterra/admin` | the admin of a game: the guard, the handler, the store type (server code; since 0.2.0) | no | 3.7 kB |
 | `@nano133/nanoterra/admin/d1`, `/admin/firestore` | the admin store for D1 (the starter's tables) or Firestore (a small interface, no Firebase dependency): `createD1Store`, `createFirestoreStore` (since 0.2.0) | no | 1.5 kB each |
 | `@nano133/nanoterra/admin/panel` | the admin page, drawn in the browser into one element, and its stylesheet `@nano133/nanoterra/admin/style.css` (since 0.2.0) | no | 10.6 kB on 0.3.0 (8.5 kB measured on 0.2.0) + 2.4 kB of CSS |
@@ -226,11 +228,40 @@ tall, its origin the socket's point (a hand item's `grip_R` marker when it has o
 | `HEAD_ITEM` | 0.9 x 0.9 x 0.8, from 0.1 below the socket | 3,000 | 1 of 512 px | 2 | 300 KB |
 | `HAND_ITEM` | 0.96 x 0.68 x 1.6, from 1.17 below the grip to 0.43 above (a tool held near its top) | 3,000 | 1 of 512 px | 2 | 300 KB |
 | `BACK_ITEM` | 1.0 x 0.6 x 1.2, from 0.6 below the socket | 4,000 | 1 of 512 px | 2 | 400 KB |
-| `ISLAND_MODEL` | a disc of 10 m radius, 18 m high, from the ground | 50,000 | 8 of 1,024 px | no limit | 5 MB |
+| `ISLAND_MODEL` | a disc of 9 m radius (18 m across), 18 m high, from the ground | 50,000 | 8 of 1,024 px | no limit | 5 MB |
 
 Every preset refuses skins, animations, morph targets, lights, external files and compressed meshes (Draco, meshopt): a worn thing is rigid on its socket.
 `COSMETIC_LIMITS` gives the preset of each socket by its name. The island preset is nano133.com's (its "Launch my game" check uses this same code).
 
+## Leaving the page (`@nano133/nanoterra/input`; since 0.3.1)
+
+The browser sends a key's "up" only to the window that has the focus. A key that is down when the player leaves the page (another tab, another window, a pop-up,
+Cmd+Tab, another app on a phone) never sends it to your game. A game that keeps a "held keys" set keeps the key, and the character **walks on by itself** when the
+player comes back. nano133.com's island had this, and so did the starter. One call fixes it, and one more pauses a free round:
+
+```ts
+import { pauseWhenLeft, releaseWhenLost, swallowsKeyup } from "@nano133/nanoterra/input";
+
+const keys = new Set<string>();
+window.addEventListener("keydown", (e) => { if (!swallowsKeyup(e)) keys.add(e.key); }); // a key with Cmd is the browser's shortcut: never held
+window.addEventListener("keyup", (e) => keys.delete(e.key));
+releaseWhenLost(() => { keys.clear(); stick.reset(); queuedJump = false; });             // at each leave: let go of everything
+pauseWhenLeft(() => { game.paused = true; resumeCard.hidden = false; });                // a FREE round: stop the clock, show Resume
+```
+
+- `releaseWhenLost(release, keysOnly?)` calls `release` at a window **blur**, **focus**, **pagehide**, a **hidden tab**, and the **Cmd key** (on a Mac a key that is released
+  while Cmd is down sends no keyup). `keysOnly` is called when a menu opens (a right click): a menu takes a keyup, but a long press on a touch screen asks for a menu too,
+  so a thumb on a stick must not lose its walk for it. A menu that your page stopped (`preventDefault`) lets go of nothing.
+- **After a leave, a key repeat is dropped until a key goes down again.** One more repeat of the held key can arrive after the release, or the repeats go on when the
+  player comes back, and they put the key back (its keyup went to the other window). The helper stops such a repeat in the capture phase, so your own key handlers
+  never see it. The player presses the key again to walk on. A menu is no leave: its repeats still put the key back.
+- `pauseWhenLeft(pause)` calls `pause` when the tab is hidden or the window loses the focus to another window (a real `blur`: not a script's, and not a focus that moves
+  inside your page into a dialog). It can call `pause` twice for one leave, so make it safe to call twice. Show a Resume key and start nothing until it is tapped.
+- **A round that costs money must not pause**: its deadline must not move (nano133.com's arcade has the same rule). Keep `releaseWhenLost` (the character always stops)
+  and leave `pauseWhenLeft` out.
+- It returns the function that takes its listeners away. It names no package and reads only plain browser events. The same code runs in nano133.com's island and rooms,
+  and in the [game starter](https://github.com/nano133-com/nano-game-starter).
+
 ## The sign-in ticket
 
 `@nano133/nanoterra/ticket` reads and checks a sign-in ticket in the player's browser. It is for a game on a **static site**: no server, no secret.

package/ai/SPEC.md

@@ -1,8 +1,8 @@
 # Nanoterra for a game: implementation spec
 
 Package: `@nano133/nanoterra` (0.1.0 or later). Follow these steps in order. Each step ends with a check. Ask the owner when a step says
-"ask". The package has three parts, on three paths: the sign-in ticket (`/ticket`), the player's character (`/character`, Three.js) and the
-looks ladder (`/looks`). Use only the parts the game needs. It has no network, wallet or Nano code. Read the package README first.
+"ask". The package has four parts, on four paths: the sign-in ticket (`/ticket`), the player's character (`/character`, Three.js), the
+looks ladder (`/looks`) and held input that does not stick (`/input`). Use only the parts the game needs. It has no network, wallet or Nano code. Read the package README first.
 
 ## 0. What the owner decides (ask)
 
@@ -104,7 +104,19 @@ export const LOOKS = checkLooks(rawLooksJson); // throws with the first mistake
 
 **Check:** `checkLooks` passes at start; a removed look that is owned is refused; a changed slot on an owned look is refused.
 
-## 8. Do not
+## 8. Leaving the page (any game that a player walks in with keys or a stick)
+
+```ts
+import { pauseWhenLeft, releaseWhenLost, swallowsKeyup } from "@nano133/nanoterra/input";
+```
+
+- A key that is down when the player leaves the page never sends its keyup, so the character walks on by itself on return. Call `releaseWhenLost(release)` once; in `release`
+  clear every held key, stick, drag and queued jump. A keydown with `swallowsKeyup(e)` true (Cmd is down) is never held. After a leave the helper drops key repeats until a key goes down again.
+- Call `pauseWhenLeft(pause)` for a **free** round: stop the clock, show a Resume key, start nothing until it is tapped. A round that costs money must **not** pause (its deadline must not move): keep `releaseWhenLost`, leave `pauseWhenLeft` out.
+
+**Check:** hold a move key, hide the tab or switch windows, come back: the character stands still until the key is pressed again.
+
+## 9. Do not
 
 - Do not edit the geometry, the skeleton or the toon and ink materials.
 - Do not add the katana, the headband or other brands' art. A game's own worn model goes on a socket (`c.socket("head" | "hand" | "back")` or

package/dist/input/index.d.ts

@@ -0,0 +1,32 @@
+type Listens = Pick<EventTarget, "addEventListener" | "removeEventListener">;
+/**
+ * Calls `release` each time what is held may be wrong. In it, clear every held key, thumb stick and drag, and any jump or tool that a key press queued.
+ * `keysOnly`, when given, is called when a menu opens (a right click): a menu takes a keyup, but on a touch screen a long press also asks for a menu,
+ * and a thumb that rests on a stick must not lose its walk for that. A menu that your page stopped (`preventDefault`) did not open: nothing is let go.
+ *
+ * After a leave (blur, focus, page hide, the tab hidden or shown), a key REPEAT does not reach your key handlers until a key goes down for the first
+ * time (`repeat` false). The player presses the key again to walk on. A menu is no leave: the held key that a menu took comes back by its repeat.
+ * The repeat is stopped in the capture phase (`stopImmediatePropagation`), so register your own key handlers as usual: they never see it.
+ *
+ * Returns the function that takes the listeners away. `win` and `doc` are given in a test.
+ */
+export declare function releaseWhenLost(release: () => void, keysOnly?: () => void, win?: Listens, doc?: Listens & {
+    hidden?: boolean;
+}): () => void;
+/** A keydown whose keyup may never come (Cmd is down, or it is the Cmd key): it must not go into your held set. */
+export declare const swallowsKeyup: (e: {
+    metaKey?: boolean;
+    key?: string;
+}) => boolean;
+/**
+ * Calls `pause` when the player leaves: the tab or the window is hidden (`visibilitychange`: another tab, a minimized window, a locked phone,
+ * another app on a phone), or the window loses the focus to another window (a real `blur`: not a script's, and not a focus that moves inside
+ * your page into a dialog or a field). It may call `pause` twice for one leave (a blur, then the tab hiding): make `pause` safe to call twice.
+ * Show a Resume key and stop your clock in it; start nothing again until the player taps Resume. Returns the function that takes the listeners away.
+ * `win` and `doc` are given in a test.
+ */
+export declare function pauseWhenLeft(pause: () => void, win?: Listens, doc?: Listens & {
+    hidden?: boolean;
+    hasFocus?: () => boolean;
+}): () => void;
+export {};

package/dist/input/index.js

@@ -0,0 +1,102 @@
+// Held input that a page can no longer trust, and a pause for when the player leaves. For a game that a player walks in with keys, a thumb stick
+// or a drag, in the browser.
+//
+// THE FAULT: the browser sends a key's "up" only to the window that has the focus. A key that is down when the player leaves the page (another
+// tab, another window, a pop-up, Cmd+Tab, another app on a phone) never sends its "up" here. A game that keeps a "held keys" set keeps the key,
+// and the character walks on by itself when the player comes back (nano133.com's own island and rooms had it: "my character is now moving by
+// himself"). The ways that were found:
+//   - the tab or the window changes while a key is down (Cmd+Tab, Ctrl+Tab, Cmd+a number, a click elsewhere)
+//   - on a Mac, a key that is released while Cmd is down sends NO keyup (Cmd+Shift+4 for a picture, Cmd+C, ...)
+//   - a menu of the browser or the system opens (a right click, a long press) and takes the keyup
+//   - a pointer of a thumb stick ends where the page does not get it (the edge of the screen, a system gesture)
+//   - ONE MORE REPEAT of the held key arrives after the page was let go, or the repeats go on when the player comes back: it puts the key back
+//     into the held set, and its keyup went to the other window. A repeat only says that a key was down at some time.
+//
+// `releaseWhenLost(release)` calls your `release` at each of them, and drops key repeats after a leave until a key goes down again. `pauseWhenLeft(pause)`
+// calls your `pause` when the player really left (a free round stops its clock and shows a Resume key). No package: plain browser events.
+//
+// A ROUND THAT COSTS MONEY must not pause: its deadline must not move. Keep `releaseWhenLost` (the character always stops) and leave `pauseWhenLeft` out.
+/**
+ * Calls `release` each time what is held may be wrong. In it, clear every held key, thumb stick and drag, and any jump or tool that a key press queued.
+ * `keysOnly`, when given, is called when a menu opens (a right click): a menu takes a keyup, but on a touch screen a long press also asks for a menu,
+ * and a thumb that rests on a stick must not lose its walk for that. A menu that your page stopped (`preventDefault`) did not open: nothing is let go.
+ *
+ * After a leave (blur, focus, page hide, the tab hidden or shown), a key REPEAT does not reach your key handlers until a key goes down for the first
+ * time (`repeat` false). The player presses the key again to walk on. A menu is no leave: the held key that a menu took comes back by its repeat.
+ * The repeat is stopped in the capture phase (`stopImmediatePropagation`), so register your own key handlers as usual: they never see it.
+ *
+ * Returns the function that takes the listeners away. `win` and `doc` are given in a test.
+ */
+export function releaseWhenLost(release, keysOnly, win = window, doc = document) {
+    // Set by each leave; a key that goes down (not a repeat) ends it. While it is set, repeats do not reach the page's handlers.
+    let stale = false;
+    const lost = () => {
+        stale = true;
+        release();
+    };
+    const hidden = () => {
+        // Either way the page was left for a while: a repeat that comes now may belong to a key that went up elsewhere.
+        stale = true;
+        if (doc.hidden !== false)
+            release();
+    };
+    // Cmd (Meta) going down or up: each key that is released in between sends no keyup. The OS key on Windows is the same key.
+    const meta = (e) => {
+        const k = e;
+        if (k.key === "Meta" || k.key === "OS" || k.metaKey)
+            release();
+        if (e.type !== "keydown")
+            return;
+        if (!k.repeat)
+            stale = false;
+        else if (stale)
+            e.stopImmediatePropagation();
+    };
+    // At the window, after your own handlers: a handler that stopped the menu has done so by now.
+    const menu = (e) => {
+        if (!e.defaultPrevented)
+            keysOnly?.();
+    };
+    const windowEvents = ["blur", "focus", "pagehide"];
+    for (const type of windowEvents)
+        win.addEventListener(type, lost);
+    win.addEventListener("contextmenu", menu);
+    doc.addEventListener("visibilitychange", hidden);
+    // Capture: before your key handler, which then leaves a key with Cmd out (`swallowsKeyup`), and which a stale repeat never reaches.
+    win.addEventListener("keydown", meta, true);
+    win.addEventListener("keyup", meta, true);
+    return () => {
+        for (const type of windowEvents)
+            win.removeEventListener(type, lost);
+        win.removeEventListener("contextmenu", menu);
+        doc.removeEventListener("visibilitychange", hidden);
+        win.removeEventListener("keydown", meta, true);
+        win.removeEventListener("keyup", meta, true);
+    };
+}
+/** A keydown whose keyup may never come (Cmd is down, or it is the Cmd key): it must not go into your held set. */
+export const swallowsKeyup = (e) => !!e.metaKey || e.key === "Meta" || e.key === "OS";
+/**
+ * Calls `pause` when the player leaves: the tab or the window is hidden (`visibilitychange`: another tab, a minimized window, a locked phone,
+ * another app on a phone), or the window loses the focus to another window (a real `blur`: not a script's, and not a focus that moves inside
+ * your page into a dialog or a field). It may call `pause` twice for one leave (a blur, then the tab hiding): make `pause` safe to call twice.
+ * Show a Resume key and stop your clock in it; start nothing again until the player taps Resume. Returns the function that takes the listeners away.
+ * `win` and `doc` are given in a test.
+ */
+export function pauseWhenLeft(pause, win = window, doc = document) {
+    const hidden = () => {
+        if (doc.hidden)
+            pause();
+    };
+    const blur = (e) => {
+        if (!e.isTrusted || doc.hasFocus?.())
+            return;
+        pause();
+    };
+    win.addEventListener("blur", blur);
+    doc.addEventListener("visibilitychange", hidden);
+    return () => {
+        win.removeEventListener("blur", blur);
+        doc.removeEventListener("visibilitychange", hidden);
+    };
+}

package/dist/model/limits.d.ts

@@ -68,9 +68,10 @@ export type ModelLimits = {
 export declare const PLAIN_EXTENSIONS: readonly ["KHR_texture_transform", "KHR_texture_basisu", "EXT_texture_webp", "KHR_mesh_quantization", "KHR_materials_emissive_strength", "KHR_materials_unlit", "KHR_materials_ior", "KHR_materials_specular", "KHR_materials_clearcoat", "KHR_materials_sheen", "KHR_materials_transmission", "KHR_materials_volume", "KHR_materials_iridescence", "KHR_materials_anisotropy", "KHR_materials_dispersion", "KHR_xmp_json_ld"];
 /**
  * A creator's island model (the creator islands gameplan, phase 2; Wes approved it on 2026-10-27): the entry of their
- * game on their plot. 5 MB, 50,000 triangles, 8 textures of at most 1,024 px, inside a disc of 10 m radius (20 m across)
+ * game on their plot. 5 MB, 50,000 triangles, 8 textures of at most 1,024 px, inside a disc of 9 m radius (18 m across)
  * and 18 m high on the plot's middle: the plot's free middle (PLOT_FREE_R in app/nanoterra/wheel/plots.ts; Wes chose the
- * disc over a 24 x 24 m box on 2026-10-28, as the box reached the gates' standing places); an empty `nano_door` where Play stands, an optional empty `nano_spawn` (the arrival point) and an
+ * disc over a 24 x 24 m box on 2026-10-28, as the box reached the gates' standing places; it was 10 m radius until the plots
+ * were made 30 m across instead of 36 m, 2026-10-28); an empty `nano_door` where Play stands, an optional empty `nano_spawn` (the arrival point) and an
  * optional simple `nano_collide` mesh. No lights, no scripts, nothing outside the file. A still model for now.
  */
 export declare const ISLAND_MODEL: ModelLimits;

package/dist/model/limits.js

@@ -22,9 +22,10 @@ export const PLAIN_EXTENSIONS = [
 ];
 /**
  * A creator's island model (the creator islands gameplan, phase 2; Wes approved it on 2026-10-27): the entry of their
- * game on their plot. 5 MB, 50,000 triangles, 8 textures of at most 1,024 px, inside a disc of 10 m radius (20 m across)
+ * game on their plot. 5 MB, 50,000 triangles, 8 textures of at most 1,024 px, inside a disc of 9 m radius (18 m across)
  * and 18 m high on the plot's middle: the plot's free middle (PLOT_FREE_R in app/nanoterra/wheel/plots.ts; Wes chose the
- * disc over a 24 x 24 m box on 2026-10-28, as the box reached the gates' standing places); an empty `nano_door` where Play stands, an optional empty `nano_spawn` (the arrival point) and an
+ * disc over a 24 x 24 m box on 2026-10-28, as the box reached the gates' standing places; it was 10 m radius until the plots
+ * were made 30 m across instead of 36 m, 2026-10-28); an empty `nano_door` where Play stands, an optional empty `nano_spawn` (the arrival point) and an
  * optional simple `nano_collide` mesh. No lights, no scripts, nothing outside the file. A still model for now.
  */
 export const ISLAND_MODEL = {
@@ -34,7 +35,7 @@ export const ISLAND_MODEL = {
     maxTriangles: 50_000,
     maxTextures: 8,
     maxTextureSide: 1024,
-    zone: { radius: 10, height: 18, below: 0 },
+    zone: { radius: 9, height: 18, below: 0 },
     markers: [
         { name: "nano_door", required: true, kind: "empty", purpose: "where Play stands" },
         { name: "nano_spawn", required: false, kind: "empty", purpose: "where players arrive" },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nano133/nanoterra",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Nanoterra for a creator's game, in one package: the player's sign-in ticket, the player's character (a toon body on the island's skeleton) and the looks ladder.",
   "type": "module",
   "main": "dist/index.js",
@@ -12,6 +12,7 @@
     "./ticket": { "types": "./dist/ticket/index.d.ts", "import": "./dist/ticket/index.js" },
     "./looks": { "types": "./dist/looks/index.d.ts", "import": "./dist/looks/index.js" },
     "./model": { "types": "./dist/model/index.d.ts", "import": "./dist/model/index.js" },
+    "./input": { "types": "./dist/input/index.d.ts", "import": "./dist/input/index.js" },
     "./admin": { "types": "./dist/admin/index.d.ts", "import": "./dist/admin/index.js" },
     "./admin/conformance": { "types": "./dist/admin/conformance.d.ts", "import": "./dist/admin/conformance.js" },
     "./admin/d1": { "types": "./dist/admin/adapters/d1.d.ts", "import": "./dist/admin/adapters/d1.js" },

package/src/input/index.ts

@@ -0,0 +1,97 @@
+// Held input that a page can no longer trust, and a pause for when the player leaves. For a game that a player walks in with keys, a thumb stick
+// or a drag, in the browser.
+//
+// THE FAULT: the browser sends a key's "up" only to the window that has the focus. A key that is down when the player leaves the page (another
+// tab, another window, a pop-up, Cmd+Tab, another app on a phone) never sends its "up" here. A game that keeps a "held keys" set keeps the key,
+// and the character walks on by itself when the player comes back (nano133.com's own island and rooms had it: "my character is now moving by
+// himself"). The ways that were found:
+//   - the tab or the window changes while a key is down (Cmd+Tab, Ctrl+Tab, Cmd+a number, a click elsewhere)
+//   - on a Mac, a key that is released while Cmd is down sends NO keyup (Cmd+Shift+4 for a picture, Cmd+C, ...)
+//   - a menu of the browser or the system opens (a right click, a long press) and takes the keyup
+//   - a pointer of a thumb stick ends where the page does not get it (the edge of the screen, a system gesture)
+//   - ONE MORE REPEAT of the held key arrives after the page was let go, or the repeats go on when the player comes back: it puts the key back
+//     into the held set, and its keyup went to the other window. A repeat only says that a key was down at some time.
+//
+// `releaseWhenLost(release)` calls your `release` at each of them, and drops key repeats after a leave until a key goes down again. `pauseWhenLeft(pause)`
+// calls your `pause` when the player really left (a free round stops its clock and shows a Resume key). No package: plain browser events.
+//
+// A ROUND THAT COSTS MONEY must not pause: its deadline must not move. Keep `releaseWhenLost` (the character always stops) and leave `pauseWhenLeft` out.
+
+type Listens = Pick<EventTarget, "addEventListener" | "removeEventListener">;
+
+/**
+ * Calls `release` each time what is held may be wrong. In it, clear every held key, thumb stick and drag, and any jump or tool that a key press queued.
+ * `keysOnly`, when given, is called when a menu opens (a right click): a menu takes a keyup, but on a touch screen a long press also asks for a menu,
+ * and a thumb that rests on a stick must not lose its walk for that. A menu that your page stopped (`preventDefault`) did not open: nothing is let go.
+ *
+ * After a leave (blur, focus, page hide, the tab hidden or shown), a key REPEAT does not reach your key handlers until a key goes down for the first
+ * time (`repeat` false). The player presses the key again to walk on. A menu is no leave: the held key that a menu took comes back by its repeat.
+ * The repeat is stopped in the capture phase (`stopImmediatePropagation`), so register your own key handlers as usual: they never see it.
+ *
+ * Returns the function that takes the listeners away. `win` and `doc` are given in a test.
+ */
+export function releaseWhenLost(release: () => void, keysOnly?: () => void, win: Listens = window, doc: Listens & { hidden?: boolean } = document): () => void {
+  // Set by each leave; a key that goes down (not a repeat) ends it. While it is set, repeats do not reach the page's handlers.
+  let stale = false;
+  const lost = () => {
+    stale = true;
+    release();
+  };
+  const hidden = () => {
+    // Either way the page was left for a while: a repeat that comes now may belong to a key that went up elsewhere.
+    stale = true;
+    if (doc.hidden !== false) release();
+  };
+  // Cmd (Meta) going down or up: each key that is released in between sends no keyup. The OS key on Windows is the same key.
+  const meta = (e: Event) => {
+    const k = e as KeyboardEvent;
+    if (k.key === "Meta" || k.key === "OS" || k.metaKey) release();
+    if (e.type !== "keydown") return;
+    if (!k.repeat) stale = false;
+    else if (stale) e.stopImmediatePropagation();
+  };
+  // At the window, after your own handlers: a handler that stopped the menu has done so by now.
+  const menu = (e: Event) => {
+    if (!e.defaultPrevented) keysOnly?.();
+  };
+  const windowEvents = ["blur", "focus", "pagehide"] as const;
+  for (const type of windowEvents) win.addEventListener(type, lost);
+  win.addEventListener("contextmenu", menu);
+  doc.addEventListener("visibilitychange", hidden);
+  // Capture: before your key handler, which then leaves a key with Cmd out (`swallowsKeyup`), and which a stale repeat never reaches.
+  win.addEventListener("keydown", meta, true);
+  win.addEventListener("keyup", meta, true);
+  return () => {
+    for (const type of windowEvents) win.removeEventListener(type, lost);
+    win.removeEventListener("contextmenu", menu);
+    doc.removeEventListener("visibilitychange", hidden);
+    win.removeEventListener("keydown", meta, true);
+    win.removeEventListener("keyup", meta, true);
+  };
+}
+
+/** A keydown whose keyup may never come (Cmd is down, or it is the Cmd key): it must not go into your held set. */
+export const swallowsKeyup = (e: { metaKey?: boolean; key?: string }) => !!e.metaKey || e.key === "Meta" || e.key === "OS";
+
+/**
+ * Calls `pause` when the player leaves: the tab or the window is hidden (`visibilitychange`: another tab, a minimized window, a locked phone,
+ * another app on a phone), or the window loses the focus to another window (a real `blur`: not a script's, and not a focus that moves inside
+ * your page into a dialog or a field). It may call `pause` twice for one leave (a blur, then the tab hiding): make `pause` safe to call twice.
+ * Show a Resume key and stop your clock in it; start nothing again until the player taps Resume. Returns the function that takes the listeners away.
+ * `win` and `doc` are given in a test.
+ */
+export function pauseWhenLeft(pause: () => void, win: Listens = window, doc: Listens & { hidden?: boolean; hasFocus?: () => boolean } = document): () => void {
+  const hidden = () => {
+    if (doc.hidden) pause();
+  };
+  const blur = (e: Event) => {
+    if (!e.isTrusted || doc.hasFocus?.()) return;
+    pause();
+  };
+  win.addEventListener("blur", blur);
+  doc.addEventListener("visibilitychange", hidden);
+  return () => {
+    win.removeEventListener("blur", blur);
+    doc.removeEventListener("visibilitychange", hidden);
+  };
+}

package/src/model/limits.ts

@@ -78,9 +78,10 @@ export const PLAIN_EXTENSIONS = [
 
 /**
  * A creator's island model (the creator islands gameplan, phase 2; Wes approved it on 2026-10-27): the entry of their
- * game on their plot. 5 MB, 50,000 triangles, 8 textures of at most 1,024 px, inside a disc of 10 m radius (20 m across)
+ * game on their plot. 5 MB, 50,000 triangles, 8 textures of at most 1,024 px, inside a disc of 9 m radius (18 m across)
  * and 18 m high on the plot's middle: the plot's free middle (PLOT_FREE_R in app/nanoterra/wheel/plots.ts; Wes chose the
- * disc over a 24 x 24 m box on 2026-10-28, as the box reached the gates' standing places); an empty `nano_door` where Play stands, an optional empty `nano_spawn` (the arrival point) and an
+ * disc over a 24 x 24 m box on 2026-10-28, as the box reached the gates' standing places; it was 10 m radius until the plots
+ * were made 30 m across instead of 36 m, 2026-10-28); an empty `nano_door` where Play stands, an optional empty `nano_spawn` (the arrival point) and an
  * optional simple `nano_collide` mesh. No lights, no scripts, nothing outside the file. A still model for now.
  */
 export const ISLAND_MODEL: ModelLimits = {
@@ -90,7 +91,7 @@ export const ISLAND_MODEL: ModelLimits = {
   maxTriangles: 50_000,
   maxTextures: 8,
   maxTextureSide: 1024,
-  zone: { radius: 10, height: 18, below: 0 },
+  zone: { radius: 9, height: 18, below: 0 },
   markers: [
     { name: "nano_door", required: true, kind: "empty", purpose: "where Play stands" },
     { name: "nano_spawn", required: false, kind: "empty", purpose: "where players arrive" },