@nano133/nanoterra 0.9.0 → 0.10.0

package/CHANGELOG.md

@@ -1,5 +1,56 @@
 # Changelog
 
+## 0.10.0 (2026-11-01)
+
+- **No minimum price: a fraction of a cent works.** A look's `priceUsd` may have up to 4 decimals (`0.005` is half a cent, `0.0001` the smallest price
+  above 0); before, the looks check refused anything under a whole cent. New in `/looks`: `priceStepOk(usd)` (the new rule), `PRICE_STEP_USD`
+  (`0.0001`) and `usdDecimals(usd)`; `wholeCents` stays as it was. The shop already rounded the Nano amount up to a step of 0.0001 XNO (at least one
+  step), and the matcher compares exact amounts, so a half-cent order asks for 0.005 XNO at $1 and only that amount pays it.
+- `usdText` writes 2 to 4 decimals (`"$0.25"`, `"$1.00"`, `"$0.005"`), so the Buy key and the pay sheet no longer show a sub-cent price as a rounded
+  cent; `priceText` writes `0.5¢`. An order keeps its dollars as `usdDecimals` (`"0.25"` and `"1.00"` as before, `"0.005"`), not `toFixed(2)`.
+- The admin counts sales in steps of $0.0001, not cents (the Shelf, Earned, the best sellers), its price box takes 4 decimals, and the message for an
+  AI assistant says "at most 4 decimals".
+
+## 0.9.3 (2026-11-01)
+
+- **A session that ended at Buy.** A 401 from the server at Buy (the session ended, though the game's `signedIn()` still said yes) showed a
+  "Sign in" key that asked `signedIn()` again, got yes, and posted the same refused order again. The key now calls `signIn()` without asking, and the
+  new `onSessionEnd()` hook on `mountShop` lets the game mark the player signed out (the Echo Island worker found it).
+
+## 0.9.2 (2026-11-01)
+
+- Not published on npm: its changes reached npm in 0.9.3.
+- **`onSignInCancel(lookId, look)` on `mountShop`** (the Echo Island worker found the gap while it moved Echo's shop to `/shop`). A game with its own
+  looks sheet calls `shop.buy(lookId)`; when the player closes the sign-in without signing in, the kit now opens nothing (and closes its sheet if it
+  was open) and calls the hook, so the game shows its own sheet again. Before, the kit's own looks list opened. A Buy in the kit's own list still
+  goes back to that list and does not call the hook.
+- **`buy(lookId)` starts on the next frame.** A game's own `<dialog>` that closed just before has had its `close` event by then (Chromium fires it at
+  the frame), so the game's close handler can no longer take the focus and the Escape key from the kit's sheet. `dialog.close(); shop.buy(id)` is safe.
+  `shop.isOpen` is false until that frame; `open()` still opens at once. The README says to close the game's dialog first.
+- **Phone-first sizes by default** in the shop's sheets and the sign-in sheet: every text 16 px or more (was 11 to 15 px: the tabs, the Looks key,
+  each look's line, the notes, the price-source line, the time left, the address and labels by hand, the copy keys, the wallet tiles' names, "Or a
+  wallet app", the back key, the status, "Last used"), and every key, tab, close key, back key, fold summary, copy key, wallet tile and link 48 px or
+  more each way (was 44 px; the inline "open a wallet" link was 17 px tall). "Last used" sits in the flow now (under a wallet's name, at the end of
+  the passkey's row) so it never covers a word. A game that wants smaller text or keys sets them in its own stylesheet, after the kit's.
+
+## 0.9.1 (2026-11-01)
+
+- Not published on npm: its changes reached npm in 0.9.3.
+- **The words of the shop's sheets and of the player's sign-in sheet are the game's to set** (the coordinator asked for it: Echo Island's move to
+  `/shop` waited on it; Wes prefers fewer words). `words` on `mountShop`, `looksView` and `payPanel` (`ShopWords`, defaults `SHOP_WORDS`,
+  `shopWords()` merges) and on `mountPlayerSignin` and `signInView` (`PlayerSigninWords`, defaults `PLAYER_SIGNIN_WORDS`, `PlayerSigninWordsOption`
+  for a game's partial words and faults, `playerSigninWords()` merges). Every visible word, every key and every name for a screen reader; a text
+  with a value is a function (`buyTitle(look)`, `endsIn(time)`, `prices(sources)`, `waitingFor(wallet)`). `refusal(text, status)` turns the
+  server's refusals into the game's words. `faultWords(code, rpId, words?)` takes the words. Not the game's to change: the stamp "TEST MODE: DO
+  NOT PAY", and "Powered by CoinGecko" while CoinGecko is a price feed (`priceLine` adds it back).
+- **Shorter default words.** The pay sheet: 30 words in TEST MODE (was about 85) and 29 live (was about 47), no sentence over 10 words. Live:
+  "Send exactly 0.25 XNO", "Ends in 14:59.", "Waiting for payment…", "Price: Kraken, KuCoin. Powered by CoinGecko."; by hand: "Another amount
+  does not match." TEST MODE: the stamp, "Nothing can be paid here.", the wallet key "Wallet off: test mode", no timer and no status (nothing
+  waits for a payment). Paid late: "Paid after the order ended, so no look. The creator sends it back." The looks sheet: "Looks never change
+  play. Pay in Nano, straight to the creator." and "Sign in first to buy a look."; "Back" (was "Back to looks"). The sign-in sheet: the lines
+  over 10 words split or cut, with the same meaning (the spare key's note, the password manager's and the "two answers" faults, the QR lines).
+- `test/panel-words.test.ts` counts the words a player sees (happy-dom) and proves a game's words reach the page.
+
 ## 0.9.0 (2026-11-01)
 
 - **The player's sign-in** (`@nano133/nanoterra/player-signin`, `/player-signin/conformance`, `/player-signin/d1` with `/player-signin/d1.sql`,

package/README.md

@@ -91,7 +91,7 @@ Each path loads only what it needs. A page that reads a ticket loads no Three.js
 | `@nano133/nanoterra/shop` | the shop's rules and routes, the payment scan, a memory store, the CSP lists (server code; since 0.9.0) | no | 9.1 kB (all), 7.1 kB (`createShopHandler` alone) |
 | `@nano133/nanoterra/shop/d1`, `/shop/firestore` | the shop's store on D1 (the starter's tables, `/shop/d1.sql`) or Firestore: `createD1Shop`, `createFirestoreShop` (since 0.9.0) | no | 2.4 kB, 2.2 kB |
 | `@nano133/nanoterra/shop/worker` | the shop for a Worker with D1, from the starter's settings: `createShop` (since 0.9.0) | no | 10.0 kB (with the D1 store and Turnstile) |
-| `@nano133/nanoterra/shop/panel` | the Looks key, the looks sheet and the pay sheet with its own QR code: `mountShop`, and its stylesheet `@nano133/nanoterra/shop/style.css` (since 0.9.0) | no | 9.3 kB + 2.5 kB of CSS (gzip; 8.5 kB minified) |
+| `@nano133/nanoterra/shop/panel` | the Looks key, the looks sheet and the pay sheet with its own QR code: `mountShop`, and its stylesheet `@nano133/nanoterra/shop/style.css` (since 0.9.0) | no | 10.0 kB + 2.5 kB of CSS (gzip; 8.5 kB minified) |
 | `@nano133/nanoterra/shop/conformance` | the shop's money rules as test cases, for a store a game writes itself (since 0.9.0) | no | n/a |
 
 Measured 2026-10-26 (the friends paths 2026-10-30, the options, the emotes, the player sign-in and the shop paths 2026-11-01): `esbuild --bundle --minify --format=esm --external:three`, then `gzip -9`, without Three.js.
@@ -404,7 +404,7 @@ const text = looksJson(newLooks); // the new looks.json: one look on each line
 type Look = {
   id: string; // 1 to 40 lowercase letters, digits or dashes: "mint-cap"
   name: string; // 1 to 40 characters
-  priceUsd: number; // US dollars, at most 2 decimals; 0 is the free look
+  priceUsd: number; // US dollars, at most 4 decimals (0.005 is half a cent; since 0.10.0); 0 is the free look
   wear?: string; // the wear slot it fills: none (an outfit), or your game's own slot ("shovel"): see "Wear slots" below
   change?: { body: string; hat?: "cap" | "beanie" | "crown" | "tophat"; hatColor?: string }; // an outfit's colours ("#rrggbb"); an item of another slot has none
   slots?: Record<string, string>; // what YOUR game defines for itself: see "Slots" below. Optional.
@@ -478,8 +478,8 @@ The rules (the same as the starter's `AGENTS.md`):
 | `diffLooks(before, after)` | `{ added, removed, changed }` by id. A new order is not a change. |
 | `looksJson(looks)` | The text of `looks.json`, one look on each line, as the starter writes it. A change of one look is a change of one line. |
 | `slugId(name, taken)` | A free id for a name: `"Mint Cap"` gives `mint-cap`, then `mint-cap-2`. |
-| `PRICE_LADDER`, `rungOf(usd)`, `priceText(usd)` | The six steps nano133.com uses, from 1¢ to $1, and a price as a page writes it (`25¢`, `$1.10`). |
-| `usdText(usd)`, `wholeCents(usd)`, `HATS` | `"$0.25"`; whether a price has no fraction of a cent; the hats. |
+| `PRICE_LADDER`, `rungOf(usd)`, `priceText(usd)` | The six steps nano133.com uses, from 1¢ to $1, and a price as a page writes it (`0.5¢`, `25¢`, `$1.10`). |
+| `usdText(usd)`, `usdDecimals(usd)`, `priceStepOk(usd)`, `PRICE_STEP_USD`, `wholeCents(usd)`, `HATS` | `"$0.25"`, `"$0.005"` (2 to 4 decimals); the same without `$`, as an order keeps it; whether a price has at most 4 decimals (the looks rule since 0.10.0); `0.0001`, the smallest price above 0; whether a price has no fraction of a cent; the hats. |
 | `sameSlots(a, b)`, `cleanSlots(slots)`, `slotValueOk(v)`, `SLOTS_MAX` | Whether two looks have the same slots; a clean copy (none when empty); whether a value is a word or a colour; 8. |
 
 | Step | Price | For |
@@ -491,8 +491,10 @@ The rules (the same as the starter's `AGENTS.md`):
 | set | 50¢ | a few pieces that go together |
 | outfit | $1 | a whole look |
 
-The ladder is a suggestion. Any price with at most 2 decimals, up to $1000, is good. `wholeCents` accepts every price in whole cents (the starter's old check,
-`Math.round(x * 100) === x * 100`, refused $0.07, $0.29, $0.57 and $1.10 because of floating point).
+The ladder is a suggestion. Any price with at most 4 decimals, up to $1000, is good: there is no minimum, so a fraction of a cent works ($0.005, $0.0001;
+since 0.10.0, before it whole cents). The shop rounds the Nano amount up to a step of 0.0001 XNO and asks for at least one step, so a creator never gets
+less than the price. `priceStepOk` and `wholeCents` compare a price with its own decimal text (the starter's old check, `Math.round(x * 100) === x * 100`,
+refused $0.07, $0.29, $0.57 and $1.10 because of floating point).
 
 ## The admin (`/admin`; since 0.2.0)
 
@@ -1158,13 +1160,27 @@ const player = await signin.open();              // the shop's "sign in first":
   game's passkey, another passkey than the one just made, two answers for one passkey, the wrong host. None names a seed or a key; none says to delete a passkey.
 - A wallet: on a touch screen one key that opens the app; with a mouse its QR code. The page asks every 2 s, at most 5 minutes.
 - `signInView(options)` is the same content for a game with a sheet of its own (`{ node, stop, reset }`).
-- Phone first: every key 44 px or more, the sheet from the bottom on a phone held upright, a card in the middle on a wide or sideways screen; Escape, the close
-  key and the scrim close it; no browser dialog. Light and dark like the options panel (`data-n133-theme` on `<html>`, else the device), every colour a
+- Phone first (since 0.9.3 by default): every text 16 px or more, and every key, wallet tile, link, the back key and the close key 48 px or more each way
+  ("Last used" sits in the flow, under a wallet's name or at the end of the passkey's row). The sheet comes from the bottom on a phone held upright, and is
+  a card in the middle on a wide or sideways screen; Escape, the close key and the scrim close it; no browser dialog. Light and dark like the options panel (`data-n133-theme` on `<html>`, else the device), every colour a
   `--n133-*` variable with a `--n133-dark-*` twin; `--n133-signin-z` (default 1200) for its z-index.
 - The page loads the purse's signing code (`@nano133/signin/purse`, 40 kB gzip) only when a passkey signs in.
 - The browser remembers, in `localStorage["n133.player-signin.v1:<rpId>"]`, the ids of its passkeys, which were made here and never opened, and the last
   way: no secret and no address.
 
+**Its words** (since 0.9.3). `words` on `mountPlayerSignin` and `signInView` changes any word of the sheet, for the game's own words or language: the keys
+of `PlayerSigninWords` (the defaults are `PLAYER_SIGNIN_WORDS`), any of them, over the defaults. A text with a value in it is a function of that value, and
+`faults` changes the words of any passkey fault (`faultWords(code, rpId, words)` gives them). The wallets' names stay. `refusal(text, status)` turns the
+server's refusals (in English) into the game's words.
+
+```ts
+mountPlayerSignin(document.body, {
+  name: "My Game",
+  scheme: SCHEME,
+  words: { lead: "No password.", waitingFor: (wallet) => `Waiting for ${wallet}…`, faults: { cancelled: { title: "Stopped", text: "No passkey was used." } } },
+});
+```
+
 ## The shop (`/shop`; since 0.9.0)
 
 A shop that sells **looks** for Nano (XNO), the way the [game starter](https://github.com/nano133-com/nano-game-starter) sells them. A game
@@ -1305,12 +1321,46 @@ const shop = mountShop(document.getElementById("shop")!, {
   Wearing, or Buy. `picture(look)` gives the game's own picture instead of the swatch.
 - Buy: the game's sign-in (`signIn`) when nobody is signed in, then the person check, then the pay sheet: the amount, the QR code of the exact
   `nano:` link (drawn by the package as SVG: no QR library, no outside service), "Open wallet", the address and the amount by hand, the time
-  left, and a check every 5 seconds for 2 minutes ("Check again" after). Paid: "Paid. Thank you!" and `onOwned`. Paid late or expired: the
-  starter's words.
-- Phone first: every key 44 px or more (the buy and pay keys 48 px). On a phone held upright the sheet rises from the bottom; on a wide screen
-  it stands in the middle; on a phone held sideways the QR code stands alone on the left and the wallet key stays in view.
+  left (live only), and a check every 5 seconds for 2 minutes ("Check again" after). Paid: "Paid. Thank you!" and `onOwned`. Paid late: no look,
+  and the creator sends it back. Ended: a payment sent in time still counts.
+- Phone first (since 0.9.3 by default): every text 16 px or more (the price-source line, the time left, "Enter by hand"'s address and labels too), and
+  every key, tab, the Looks key, the close key, the fold "Enter by hand" and its copy keys 48 px or more each way. On a phone held upright the sheet
+  rises from the bottom; on a wide screen it stands in the middle; on a phone held sideways the QR code (or the stamp) stands alone on the left and
+  the wallet key stays in view. A game that wants smaller text sets it in its own stylesheet, after the kit's.
 - Light and dark: `theme: "light" | "dark" | "device"` (the default: the page's `data-n133-theme`, else the device's setting). Every colour is a
   `--n133-*` variable with a `--n133-dark-*` twin (and `--n133-sun` for Buy, `--n133-warn` for the stamp). The QR code stays dark on white.
+- **A shop that is a modal `<dialog>` of the game's own** (its own sheet around `open()`) closes it in its `signIn` hook before it opens the sign-in
+  sheet, or the sign-in sheet stays hidden behind it. The game starter's `src/client/main.ts` does this.
+- **Buy from a game's own `<dialog>`** (its own looks sheet calls `shop.buy(lookId)`): close the game's dialog first, and let it finish closing (its
+  `close` event) before the kit's sheet opens, or the game's close handler takes the focus and the Escape key from the kit's sheet. Since 0.9.2 the
+  kit does this itself: `buy(lookId)` starts on the next frame (Chromium fires a dialog's `close` event at the frame, after a `setTimeout(0)`; a
+  hidden page has no frames and starts at once), so `dialog.close(); shop.buy(id)` is safe. `shop.isOpen` is false until that frame. `open()` still opens at once.
+- **`onSessionEnd()`** (since 0.9.3): the server refused an order with 401 (the player's session ended, though `signedIn()` said yes). The
+  game marks the player signed out. The sheet's "Sign in" key then calls `signIn()` without asking `signedIn()` first, so a stale "yes" cannot
+  post the refused order again.
+- **`onSignInCancel(lookId, look)`** (since 0.9.3): when the game's own Buy (`buy(lookId)`) asks for a sign-in and the player closes it without signing
+  in, the kit opens nothing (it closes its sheet if it was open) and calls this hook: the game shows its own looks sheet again. A Buy in the kit's own
+  list goes back to that list, as before, and does not call it.
+
+  ```ts
+  const shop = mountShop(el, { ...options, key: false, onSignInCancel: () => myLooksDialog.showModal() });
+  myBuyKey.onclick = () => { myLooksDialog.close(); shop.buy(look.id); };
+  ```
+
+**Its words** (since 0.9.3). `words` on `mountShop` (and on `looksView` and `payPanel`) changes any word of the looks sheet and the pay sheet: the
+titles, the lines, every key, the states (waiting, paid, paid late, ended), the refusals (`refusal(text, status)`: the server's words are English) and
+the names for a screen reader. Give the keys of `ShopWords` you want, over the defaults (`SHOP_WORDS`); a text with a value in it is a function of
+that value:
+
+```ts
+mountShop(el, { ...options, words: { sendExactly: "Pay exactly", buyTitle: (look) => `Get ${look}` } });
+```
+
+The defaults are short: the pay sheet shows at most 30 words (TEST MODE and live) and no sentence has more than 10 (`test/panel-words.test.ts`).
+Two things are not the game's words: the stamp **"TEST MODE: DO NOT PAY"**, and **"Powered by CoinGecko"** while CoinGecko is one of the price feeds
+(its API terms; `priceLine` adds it when the game's `prices` leaves it out). Keep the meaning of the safety lines in any language: live, send the
+**exact** amount, and the order ends at the timer; in test mode nothing can be paid and the wallet key is off; a late payment gives no look and
+the creator sends it back.
 
 ### The page's Content Security Policy
 

package/ai/SPEC.md

@@ -106,7 +106,7 @@ export const LOOKS = checkLooks(rawLooksJson); // throws with the first mistake
 ```
 
 - Before a change goes live: `[...lookProblems(next), ...removalProblems(current, next, ownedLookIds)]`; show `diffLooks(current, next)`; write the file with `looksJson(next)`.
-- One free look (`priceUsd: 0`) at least. Never change or remove the id of a look that someone owns. Prices in US dollars with at most 2 decimals; the server reads the price from the file.
+- One free look (`priceUsd: 0`) at least. Never change or remove the id of a look that someone owns. Prices in US dollars with at most 4 decimals (no minimum: 0.005 is half a cent); the server reads the price from the file.
 - A look only changes how the character looks. No random look, no loot box, no look that changes a score.
 - `slots` (optional, at most 8: a name and a word or a `#rrggbb` colour) is where the game keeps its own parts of a look. Read `look.slots` from `checkLooks`. Never change the slots of a look that someone owns: add a new look.
 - `wear` (optional) is the wear slot a look fills: none for an outfit (the character's colours and hat, `change`), or the game's own slot (`"shovel"`, `"charm"`) for an item, which has no `change`. A player wears one look in each slot. Keep one free outfit. Never change the wear slot of a look that someone owns. Read outfits with `isOutfit(look)`.
@@ -216,6 +216,7 @@ npm install @nano133/nanoterra @nano133/signin
 6. **The sheet.** `mountPlayerSignin(document.body, { name, scheme: SCHEME, qr, personCheck, onSignedIn })` and the stylesheet; the account key and the
    shop's "sign in first" call `open()`. On `*.workers.dev` the sheet offers no passkey (it would be lost at the move to the game's own
    domain); give `mountAdmin` `playerPasskeys: true` so the admin says so. Do not write your own passkey or wallet code, and never store, log or send the seed.
+7. **The words.** For the game's own words or language, give the sheet `words` (keys of `PlayerSigninWords`, over `PLAYER_SIGNIN_WORDS`); never edit the kit's files.
 
 **Check:** on the game's real https address, with a phone (iOS 18 or a recent Android): Make a passkey, see "Keep a spare key", sign in, reload: still
 signed in; sign out, "Use my passkey": the same address. A desktop browser with no PRF shows the passkey last and its plain words. A wallet sign-in works only
@@ -241,6 +242,11 @@ import "@nano133/nanoterra/shop/style.css";
   code, no address and the wallet key off. Never show a pay screen to an address nobody holds the key for without that stamp.
 - Add the cron (`*/10 * * * *`) that calls `shop.scan()`, and give the admin `check: (at) => shop.scan(at)`.
 - Mount the panel with `onOwned(lookId)` (the game adds the look and wears it); `key: false` and `open()` when the game has its own Looks key.
+  A game with its own looks sheet calls `buy(lookId)` after it closes that sheet, and gives `onSignInCancel` to show the sheet again when the player
+  closes the sign-in without signing in.
+- The game's own words or language: `words` on `mountShop` (keys of `ShopWords`, over `SHOP_WORDS`). Keep each safety line's meaning; the stamp
+  "TEST MODE: DO NOT PAY" and "Powered by CoinGecko" are not the game's to change. A shop in a modal `<dialog>` of the game's own closes it in `signIn`
+  before the sign-in sheet opens, or the sheet stays hidden behind it.
 - Merge `SHOP_CSP` into the game's Content Security Policy with `mergeCsp`; never replace the game's policy.
 - "Delete my data" calls `store.forget(player, now)`; with `waitUntil`, ask the player to try again then.
 - Tests: the shop's money tests are the package's. The game's tests read the game's own looks file and test only the game's own routes and wiring.

package/dist/admin/amount.d.ts

@@ -3,3 +3,7 @@ export declare const RAW_PER_XNO: bigint;
 export declare function xnoText(raw: string): string;
 /** A raw amount that can be added: digits only, at most 39 of them. Anything else is not counted (a bad row must not break the summary). */
 export declare const isRawText: (s: unknown) => s is string;
+/** Dollars as plain decimals, as an order keeps them: at least 2 decimals and at most 4, "0.25", "1.00", "0.005", "0.0125". */
+export declare const usdDecimals: (usd: number) => string;
+/** "$0.25", "$1.00", "$0.005". */
+export declare const usdText: (usd: number) => string;

package/dist/admin/amount.js

@@ -9,3 +9,7 @@ export function xnoText(raw) {
 }
 /** A raw amount that can be added: digits only, at most 39 of them. Anything else is not counted (a bad row must not break the summary). */
 export const isRawText = (s) => typeof s === "string" && /^[0-9]{1,39}$/.test(s);
+/** Dollars as plain decimals, as an order keeps them: at least 2 decimals and at most 4, "0.25", "1.00", "0.005", "0.0125". */
+export const usdDecimals = (usd) => usd.toFixed(4).replace(/(\.\d\d\d*?)0+$/, "$1");
+/** "$0.25", "$1.00", "$0.005". */
+export const usdText = (usd) => `$${usdDecimals(usd)}`;

package/dist/admin/panel/dom.d.ts

@@ -15,6 +15,6 @@ export declare function copyKey(value: string, label: string, icon?: Element): H
 export declare function ago(ms: number, now?: number): string;
 /** "3 orders", "1 order" */
 export declare const plural: (n: number, word: string) => string;
-/** "$1.25" from cents. */
+/** "$1.25" from cents, "$0.005" from half a cent. */
 export declare const dollars: (cents: number) => string;
 export {};

package/dist/admin/panel/dom.js

@@ -1,4 +1,5 @@
 // A tiny helper to build page elements without innerHTML (safe for any text, and fine under a strict CSP). The panel runs in a browser.
+import { usdText } from "../amount.js";
 export function h(tag, attrs = {}, ...children) {
     const el = document.createElement(tag);
     for (const [k, v] of Object.entries(attrs)) {
@@ -68,5 +69,5 @@ export function ago(ms, now = Date.now()) {
 }
 /** "3 orders", "1 order" */
 export const plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
-/** "$1.25" from cents. */
-export const dollars = (cents) => `$${(cents / 100).toFixed(2)}`;
+/** "$1.25" from cents, "$0.005" from half a cent. */
+export const dollars = (cents) => usdText(cents / 100);

package/dist/admin/panel/shelf.js

@@ -388,7 +388,7 @@ export function shelfView(first, looks, picture = lookPicture, repoHelp = "To ge
                     l.id = slugId(l.name, [...draft.filter((x) => x !== l).map((x) => x.id), ...owned()]);
                 sync();
             } });
-        const priceInput = h("input", { class: "input input-num", type: "number", step: 0.01, min: 0, max: 1000, inputmode: "decimal", value: Number.isFinite(l.priceUsd) ? l.priceUsd : "", "aria-label": `Price in US dollars of ${l.name}`, oninput: (e) => {
+        const priceInput = h("input", { class: "input input-num", type: "number", step: 0.0001, min: 0, max: 1000, inputmode: "decimal", value: Number.isFinite(l.priceUsd) ? l.priceUsd : "", "aria-label": `Price in US dollars of ${l.name}`, oninput: (e) => {
                 const v = e.target.value;
                 l.priceUsd = v === "" ? Number.NaN : Number(v);
                 sync();

package/dist/admin/panel/shelfData.d.ts

@@ -20,7 +20,7 @@ export type LookStats = {
     /** Orders that were paid after the order ran out (the money is to be sent back; the look was not given). */
     late: number;
 };
-/** "0.25" is 25 cents. */
+/** "0.25" is 25 cents; "0.005" is half a cent (cents keep 2 decimals: a price has at most 4). */
 export declare const centsOf: (usd: string) => number;
 /** The stats for each look id that appears in the orders or in a player's looks. */
 export declare function shelfStats(orders: readonly ShelfOrder[], players: readonly ShelfPlayer[]): Map<string, LookStats>;

package/dist/admin/panel/shelfData.js

@@ -1,9 +1,9 @@
 // The numbers and the words of the Shelf screen in /admin (shelf.ts draws it). Pure: no page, no network. Everything
 // here comes from the game's own database (the admin summary) and from looks.json; nothing is sent anywhere.
-import { ID_PATTERN } from "../../looks/look.js";
+import { ID_PATTERN, usdText } from "../../looks/look.js";
 const none = () => ({ owners: 0, paid: 0, paidCents: 0, late: 0 });
-/** "0.25" is 25 cents. */
-export const centsOf = (usd) => Math.round(Number(usd) * 100) || 0;
+/** "0.25" is 25 cents; "0.005" is half a cent (cents keep 2 decimals: a price has at most 4). */
+export const centsOf = (usd) => Math.round(Number(usd) * 10_000) / 100 || 0;
 /** The stats for each look id that appears in the orders or in a player's looks. */
 export function shelfStats(orders, players) {
     const stats = new Map();
@@ -12,7 +12,7 @@ export function shelfStats(orders, players) {
         if (o.status === "paid") {
             const s = of(o.lookId);
             s.paid++;
-            s.paidCents += centsOf(o.usd);
+            s.paidCents = Math.round((s.paidCents + centsOf(o.usd)) * 100) / 100;
         }
         else if (o.status === "paid_late")
             of(o.lookId).late++;
@@ -35,7 +35,7 @@ export function changeText(d) {
 export function soldText(s) {
     if (!s || (!s.paid && !s.owners))
         return "Not sold yet";
-    return `${s.paid} sold, $${(s.paidCents / 100).toFixed(2)}, ${plural(s.owners, "owner")}`;
+    return `${s.paid} sold, ${usdText(s.paidCents / 100)}, ${plural(s.owners, "owner")}`;
 }
 /**
  * A message to give to an AI assistant that works in the game's repository: the whole new looks.json, what changed, and the rules.
@@ -57,7 +57,7 @@ export function aiPrompt(text, diff, owned, before) {
         diff.changed.length ? `Changed: ${names(diff.changed.map((c) => c.after))}.` : "",
         "",
         `Looks that players own and that must stay in the file with the same id: ${ownedOk.length ? quote(ownedOk) : "none yet"}${odd ? ` (and ${odd} more with an id that is not a valid look id: do not remove any look)` : ""}.`,
-        `Rules: keep one free outfit (priceUsd 0, no "wear"), prices in US dollars with at most 2 decimals, never change or remove the id of a look that someone owns, never change the wear slot or the slots of a look that someone owns (a look with "wear" is an item of that slot, such as a shovel, and has no "change"; slots are words and #rrggbb colours that the game reads, at most 8 on a look), and a look never changes a score or a rule. (The file had ${before.length} looks before.)`,
+        `Rules: keep one free outfit (priceUsd 0, no "wear"), prices in US dollars with at most 4 decimals (0.005 is half a cent), never change or remove the id of a look that someone owns, never change the wear slot or the slots of a look that someone owns (a look with "wear" is an item of that slot, such as a shovel, and has no "change"; slots are words and #rrggbb colours that the game reads, at most 8 on a look), and a look never changes a score or a rule. (The file had ${before.length} looks before.)`,
         "",
         "looks.json:",
         "```json",

package/dist/admin/summary.d.ts

@@ -14,7 +14,7 @@ export type OrderRow = {
     hash: string | null;
 };
 export declare const ORDERS_SHOWN = 500;
-/** Money from rows that are all of one status: the count, the XNO text of the raw sum and the dollars (summed in cents, so 0.1 + 0.2 is 0.30). */
+/** Money from rows that are all of one status: the count, the XNO text of the raw sum and the dollars (summed in whole $0.0001 steps, so 0.1 + 0.2 is 0.30). */
 export declare function moneyOf(rows: readonly {
     amountRaw: string;
     usd: string;

package/dist/admin/summary.js

@@ -1,23 +1,23 @@
 // The numbers of the summary from the rows of the orders, the same for every adapter: the counts by status, the totals and the shape of an order.
 // An adapter reads its rows; this file turns them into a `StoreSummary`.
-import { isRawText, xnoText } from "./amount.js";
+import { isRawText, usdDecimals, xnoText } from "./amount.js";
 export const ORDERS_SHOWN = 500;
-/** Cents from a dollar text like "0.25". Anything that is not plain dollars (a sign, an exponent, hex) counts as 0: a bad row must not change a total. */
-const toCents = (usd) => {
+/** Steps of $0.0001 from a dollar text like "0.25" or "0.005". Anything that is not plain dollars (a sign, an exponent, hex) counts as 0: a bad row must not change a total. */
+const toSteps = (usd) => {
     if (typeof usd !== "string" || !/^\d{1,9}(\.\d{1,8})?$/.test(usd))
         return 0;
-    return Math.round(Number(usd) * 100);
+    return Math.round(Number(usd) * 10_000);
 };
-/** Money from rows that are all of one status: the count, the XNO text of the raw sum and the dollars (summed in cents, so 0.1 + 0.2 is 0.30). */
+/** Money from rows that are all of one status: the count, the XNO text of the raw sum and the dollars (summed in whole $0.0001 steps, so 0.1 + 0.2 is 0.30). */
 export function moneyOf(rows) {
     let raw = 0n;
-    let cents = 0;
+    let steps = 0;
     for (const r of rows) {
         if (isRawText(r.amountRaw))
             raw += BigInt(r.amountRaw);
-        cents += toCents(r.usd);
+        steps += toSteps(r.usd);
     }
-    return { count: rows.length, xno: xnoText(raw.toString()), usd: (cents / 100).toFixed(2) };
+    return { count: rows.length, xno: xnoText(raw.toString()), usd: usdDecimals(steps / 10_000) };
 }
 /** Where an order counts: an open order past its expiry counts as expired. */
 export const statusOf = (status, expiresAt, now) => (status === "open" && expiresAt < now ? "expired" : status);

package/dist/looks/index.d.ts

@@ -1,4 +1,4 @@
-export { HATS, ID_PATTERN, COLOR_PATTERN, NAME_MAX, OUTFIT, PRICE_MAX_USD, SLOTS_MAX, SLOT_NAME_PATTERN, SLOT_WORD_PATTERN, RESERVED_SLOT_NAMES, wholeCents, lookProblems, checkLooks, cleanSlots, slotValueOk, usdText, wearOf, isOutfit } from "./look.js";
+export { HATS, ID_PATTERN, COLOR_PATTERN, NAME_MAX, OUTFIT, PRICE_MAX_USD, PRICE_STEP_USD, SLOTS_MAX, SLOT_NAME_PATTERN, SLOT_WORD_PATTERN, RESERVED_SLOT_NAMES, wholeCents, priceStepOk, lookProblems, checkLooks, cleanSlots, slotValueOk, usdDecimals, usdText, wearOf, isOutfit } from "./look.js";
 export type { Change, Hat, Look, Problem, Slots } from "./look.js";
 export { PRICE_LADDER, rungUsd, rungOf, priceText } from "./ladder.js";
 export type { Rung } from "./ladder.js";

package/dist/looks/index.js

@@ -1,4 +1,4 @@
-export { HATS, ID_PATTERN, COLOR_PATTERN, NAME_MAX, OUTFIT, PRICE_MAX_USD, SLOTS_MAX, SLOT_NAME_PATTERN, SLOT_WORD_PATTERN, RESERVED_SLOT_NAMES, wholeCents, lookProblems, checkLooks, cleanSlots, slotValueOk, usdText, wearOf, isOutfit } from "./look.js";
+export { HATS, ID_PATTERN, COLOR_PATTERN, NAME_MAX, OUTFIT, PRICE_MAX_USD, PRICE_STEP_USD, SLOTS_MAX, SLOT_NAME_PATTERN, SLOT_WORD_PATTERN, RESERVED_SLOT_NAMES, wholeCents, priceStepOk, lookProblems, checkLooks, cleanSlots, slotValueOk, usdDecimals, usdText, wearOf, isOutfit } from "./look.js";
 export { PRICE_LADDER, rungUsd, rungOf, priceText } from "./ladder.js";
 export { removalProblems, diffLooks, sameSlots } from "./change.js";
 export { looksJson, slugId } from "./json.js";

package/dist/looks/ladder.d.ts

@@ -10,5 +10,5 @@ export declare const PRICE_LADDER: readonly Rung[];
 export declare const rungUsd: (r: Rung) => number;
 /** The rung that has exactly this price, or undefined. */
 export declare function rungOf(usd: number): Rung | undefined;
-/** A price as a page writes it: 1¢, 25¢, $1, $1.10. */
+/** A price as a page writes it: 0.5¢, 1¢, 25¢, $1, $1.10, $1.005. */
 export declare function priceText(usd: number): string;

package/dist/looks/ladder.js

@@ -1,5 +1,6 @@
 // The price ladder: the six steps from a cent to a dollar that nano133.com uses for its own cosmetics and shows on /build/cosmetics.
-// It is a suggestion. A look can have any price with at most 2 decimals, up to $1000.
+// It is a suggestion. A look can have any price with at most 4 decimals ($0.0001 steps), up to $1000.
+import { usdText } from "./look.js";
 export const PRICE_LADDER = [
     { name: "dye", cents: 1, for: "a colour" },
     { name: "charm", cents: 2, for: "a small mark or a badge" },
@@ -14,11 +15,10 @@ export const rungUsd = (r) => r.cents / 100;
 export function rungOf(usd) {
     return PRICE_LADDER.find((r) => Math.abs(rungUsd(r) - usd) < 1e-9);
 }
-/** A price as a page writes it: 1¢, 25¢, $1, $1.10. */
+/** A price as a page writes it: 0.5¢, 1¢, 25¢, $1, $1.10, $1.005. */
 export function priceText(usd) {
-    const cents = Math.round(usd * 100);
-    if (cents < 100)
-        return `${cents}¢`;
-    const dollars = cents / 100;
-    return Number.isInteger(dollars) ? `$${dollars}` : `$${dollars.toFixed(2)}`;
+    const steps = Math.round(usd * 10_000);
+    if (steps < 10_000)
+        return `${steps / 100}¢`;
+    return steps % 10_000 === 0 ? `$${steps / 10_000}` : usdText(steps / 10_000);
 }

package/dist/looks/look.d.ts

@@ -12,7 +12,7 @@ export type Look = {
     id: string;
     /** What the player reads, 1 to 40 characters. */
     name: string;
-    /** The price in US dollars with at most 2 decimals, for example 0.25. 0 means free for everyone. */
+    /** The price in US dollars with at most 4 decimals, for example 0.25 or 0.005. 0 means free for everyone. */
     priceUsd: number;
     /**
      * The wear slot that the look fills: none (or "outfit") for an outfit, or a slot of the game's own ("shovel", "charm"): 1 to 24 lowercase letters, digits
@@ -61,6 +61,10 @@ export type Problem = {
  * and 1e-9 would pass): a price is whole cents when it is exactly the number that its own two-decimal text names.
  */
 export declare function wholeCents(usd: number): boolean;
+/** The smallest step of a price: $0.0001, a hundredth of a cent. A price above 0 is at least this, and the shop asks for at least one 0.0001 XNO step. */
+export declare const PRICE_STEP_USD = 0.0001;
+/** Whether a price has at most 4 decimals (whole steps of $0.0001), by the same rule as `wholeCents`: it is exactly the number its own four-decimal text names. */
+export declare function priceStepOk(usd: number): boolean;
 /** Every mistake in a list of looks (looks.json as it was read), in the order of the list. An empty array means the list is good. */
 export declare function lookProblems(raw: unknown): Problem[];
 /** Whether a slot's value is good: a word or a colour. */
@@ -73,7 +77,8 @@ export declare function cleanSlots(slots: Slots | undefined): Slots | undefined;
 /** The looks, or an Error that says the first mistake in plain words. The same words as the starter's `checkLooks`. */
 export declare function checkLooks(rawInput: unknown): Look[];
 /** "$0.25" */
-export declare const usdText: (usd: number) => string;
+/** "$0.25", "$1.00", "$0.005"; and the same without "$", as an order keeps it ("0.005"). The money code's own helpers. */
+export { usdDecimals, usdText } from "../admin/amount.js";
 /** The wear slot that a look fills: OUTFIT for an outfit (no `wear`), or the game's own slot. */
 export declare const wearOf: (l: Pick<Look, "wear">) => string;
 /** Whether a look is an outfit (the character's own look, with its `change`), not an item of another wear slot. */

package/dist/looks/look.js

@@ -27,6 +27,12 @@ export const PRICE_MAX_USD = 1000;
 export function wholeCents(usd) {
     return typeof usd === "number" && Number.isFinite(usd) && Number(usd.toFixed(2)) === usd;
 }
+/** The smallest step of a price: $0.0001, a hundredth of a cent. A price above 0 is at least this, and the shop asks for at least one 0.0001 XNO step. */
+export const PRICE_STEP_USD = 0.0001;
+/** Whether a price has at most 4 decimals (whole steps of $0.0001), by the same rule as `wholeCents`: it is exactly the number its own four-decimal text names. */
+export function priceStepOk(usd) {
+    return typeof usd === "number" && Number.isFinite(usd) && Number(usd.toFixed(4)) === usd;
+}
 /** Every mistake in a list of looks (looks.json as it was read), in the order of the list. An empty array means the list is good. */
 export function lookProblems(raw) {
     const out = [];
@@ -48,8 +54,8 @@ export function lookProblems(raw) {
             add("name", '"name" must be 1 to 40 characters');
         if (typeof v.priceUsd !== "number" || !Number.isFinite(v.priceUsd) || v.priceUsd < 0 || v.priceUsd > PRICE_MAX_USD)
             add("priceUsd", '"priceUsd" must be a number from 0 to 1000');
-        else if (!wholeCents(v.priceUsd))
-            add("priceUsd", '"priceUsd" can have at most 2 decimals (cents)');
+        else if (!priceStepOk(v.priceUsd))
+            add("priceUsd", '"priceUsd" can have at most 4 decimals (0.0001 is the smallest price above 0)');
         const wearOk = v.wear === undefined || (typeof v.wear === "string" && SLOT_NAME_PATTERN.test(v.wear) && !RESERVED_SLOT_NAMES.includes(v.wear));
         if (!wearOk)
             add("wear", `"wear" must be "${OUTFIT}" or the name of a wear slot: 1 to 24 lowercase letters, digits or dashes, starting with a letter ("shovel")`);
@@ -131,7 +137,8 @@ export function checkLooks(rawInput) {
     });
 }
 /** "$0.25" */
-export const usdText = (usd) => `$${usd.toFixed(2)}`;
+/** "$0.25", "$1.00", "$0.005"; and the same without "$", as an order keeps it ("0.005"). The money code's own helpers. */
+export { usdDecimals, usdText } from "../admin/amount.js";
 /** The wear slot that a look fills: OUTFIT for an outfit (no `wear`), or the game's own slot. */
 export const wearOf = (l) => l.wear ?? OUTFIT;
 /** Whether a look is an outfit (the character's own look, with its `change`), not an item of another wear slot. */

package/dist/player-signin/panel/index.d.ts

@@ -3,7 +3,7 @@ export type { MountedPlayerSignin, PlayerSigninMountOptions } from "./mount.js";
 export { hostFits, passkeyName, signInView } from "./view.js";
 export { PASSKEY_PREVIEW_NOTE, previewHost } from "../host.js";
 export type { PlayerSigninView, PlayerSigninViewOptions, SignedIn } from "./view.js";
-export { faultWords } from "./words.js";
-export type { FaultWords } from "./words.js";
+export { PLAYER_SIGNIN_WORDS, faultWords, playerSigninWords } from "./words.js";
+export type { FaultText, FaultWords, PlayerSigninWords, PlayerSigninWordsOption } from "./words.js";
 export { readMemo } from "./memo.js";
 export type { SigninMemo } from "./memo.js";

package/dist/player-signin/panel/index.js

@@ -1,7 +1,8 @@
 // "@nano133/nanoterra/player-signin/panel": the player's sign-in sheet in the browser. `mountPlayerSignin` is the sheet (call `open()`);
-// `signInView` is its content, for a game that has a sheet of its own. Add "@nano133/nanoterra/player-signin/style.css" to the page.
+// `signInView` is its content, for a game that has a sheet of its own. Add "@nano133/nanoterra/player-signin/style.css" to the page. Every word of
+// the sheet can be the game's own: `words` (PlayerSigninWords; PLAYER_SIGNIN_WORDS are the defaults).
 export { mountPlayerSignin } from "./mount.js";
 export { hostFits, passkeyName, signInView } from "./view.js";
 export { PASSKEY_PREVIEW_NOTE, previewHost } from "../host.js";
-export { faultWords } from "./words.js";
+export { PLAYER_SIGNIN_WORDS, faultWords, playerSigninWords } from "./words.js";
 export { readMemo } from "./memo.js";

package/dist/player-signin/panel/mount.d.ts

@@ -1,6 +1,6 @@
 import { type PlayerSigninViewOptions, type SignedIn } from "./view.js";
 export type PlayerSigninMountOptions = PlayerSigninViewOptions & {
-    /** The sheet's title. Default "Sign in". */
+    /** The sheet's title. Default: `words.title` ("Sign in"). */
     title?: string;
     /** How long "Signed in as …" shows before the sheet closes, in ms. Default 900. */
     closeAfterMs?: number;

package/dist/player-signin/panel/mount.js

@@ -1,10 +1,11 @@
 // The sign-in sheet of a game: `mountPlayerSignin(element, options)`. It draws no key of its own: the game's account key, the shop's "sign in
 // first" and anything else call `open()`, which resolves with the player once they are signed in, or null when the sheet closes. Plain DOM; a
 // modal sheet with a scrim: from the bottom on a phone held upright, in the middle on a wide or sideways screen. Escape, the close key and a press
-// on the scrim close it. Every key is 44 px or more.
+// on the scrim close it. Phone first: text 16 px, every key 48 px or more each way.
 import { h, releaseFocus } from "../../admin/panel/dom.js";
 import { icon } from "../../admin/panel/icons.js";
 import { signInView } from "./view.js";
+import { playerSigninWords } from "./words.js";
 let mounts = 0;
 export function mountPlayerSignin(root, options) {
     const n = ++mounts;
@@ -12,6 +13,7 @@ export function mountPlayerSignin(root, options) {
     let pending = null;
     let before = null;
     let closing;
+    const words = playerSigninWords(options.words);
     const settle = (p) => {
         const was = pending;
         pending = null;
@@ -25,8 +27,8 @@ export function mountPlayerSignin(root, options) {
             closing = setTimeout(close, Math.max(0, options.closeAfterMs ?? 900));
         },
     });
-    const titleEl = h("h2", { class: "n133s-title", id: `n133s-title-${n}` }, options.title ?? "Sign in");
-    const closeKey = h("button", { class: "n133s-close", type: "button", "aria-label": "Close" }, icon("close", 20));
+    const titleEl = h("h2", { class: "n133s-title", id: `n133s-title-${n}` }, options.title ?? words.title);
+    const closeKey = h("button", { class: "n133s-close", type: "button", "aria-label": words.close }, icon("close", 20));
     const scrim = h("div", { class: "n133s-scrim" });
     const panel = h("section", { class: "n133s-panel", role: "dialog", "aria-modal": "true", "aria-labelledby": `n133s-title-${n}` }, h("header", { class: "n133s-head" }, titleEl, closeKey), h("div", { class: "n133s-body" }, view.node));
     const wrap = h("div", { class: "n133-signin n133s-sheet", "data-open": "false" }, scrim, panel);

package/dist/player-signin/panel/view.d.ts

@@ -1,5 +1,6 @@
 import { type PasskeyScheme } from "@nano133/signin/passkey";
 import { type Way } from "../types.js";
+import { type PlayerSigninWordsOption } from "./words.js";
 export type SignedIn = {
     address: string;
     via: "wallet" | "passkey";
@@ -30,6 +31,8 @@ export type PlayerSigninViewOptions = {
     fetch?: typeof fetch;
     /** A touch screen (one key that opens the app) or not (a QR code). Default: `(pointer: coarse)`. */
     touch?: boolean;
+    /** The game's words for the sheet, over the defaults (PLAYER_SIGNIN_WORDS): `{ lead: "No password.", faults: { cancelled: { ... } } }`. */
+    words?: PlayerSigninWordsOption;
 };
 export type PlayerSigninView = {
     node: HTMLElement;