@origingame/engine 0.0.0-stage → 0.1.0

package/knowledge/skills/og-i18n/SKILL.md

@@ -0,0 +1,220 @@
+---
+name: og-i18n
+description: Localizing a game on Origin Engine with og.i18n — string tables per locale as .ogt, messages with arguments, plurals and select (ICU), the host's locale and the player's choice, font chains for Chinese, Japanese, Korean and Arabic, CJK line breaking (kinsoku), shaping and right-to-left layout in og.ui, the cook-time check for missing keys, and how to prove each locale with frames. Use when a game shows text to players in more than one language, adds a language, or shows boxes or broken Arabic.
+---
+
+Every string a player reads comes from a table, never from a literal in a
+system. `og.i18n` picks the table for the locale the host asks for (the
+browser's language, `og run --locale`) or the player chooses, formats the
+message, and hands og.ui the fonts and the direction for it. The API is in
+`reference/i18n.md`; the platform's `localization` skill covers store
+listings and the catalog's languages.
+
+## What works
+
+Two games written from this package alone (`examples/lantern-vale`,
+`examples/hollowbell`) ship English and Simplified Chinese from string
+tables: `og polish` found no locale gaps in either, the results template
+showed its localised Best and New best, a name was typed partly through an
+input method, and a skin copied without its CJK `fallback` was refused by
+the cook with the line named. The Kestrel Stair (`examples/kestrel-stair`)
+ships English and Japanese: its Noto Sans JP subset cut by the ui-kit's
+`tools/subset-font.py` needed no other step, and its locales playtest
+finds no English word of a template left in Japanese on eight screens.
+
+## 1. One table per locale
+
+```text
+type strings
+version 1
+---
+locale "ja"
+fonts "fonts/NotoSansJP-game.otf"        # this locale's font chain, first first
+string "menu.play" "プレイ"
+string "hud.coins" "{n, plural, other {コイン#枚}}"
+string "results.time" "タイム {time}"
+```
+
+- One file per locale under `assets/strings/` (`en.ogt`, `zh-CN.ogt`,
+  `ja.ogt`, `ko.ogt`, `ar.ogt`); keys are dotted by screen
+  (`menu.play`, `pause.resume`, `shop.buy`). Mark the base table `base
+  true` (else `en` is the base).
+- Load every table in `start`: `og.i18n.load(world, "strings/ja.ogt")`;
+  the active locale is negotiated again after each load (`ja-JP` takes
+  `ja`, `zh-TW` takes `zh-Hant` or `zh-TW`, else the base).
+- A key a table lacks falls back to its `fallback` table, then the base, and
+  `og cook` warns about it. Treat a cook warning as a bug: `og polish`
+  scores missing keys (og-build §5).
+
+## 2. Messages
+
+`og.i18n.t(world, "hud.coins", { n: coins })`. The forms:
+
+| Form | Example |
+|---|---|
+| an argument | `"Hello, {name}"` |
+| a number, grouped for the locale | `"{score, number} pts"` |
+| plural (CLDR categories `zero one two few many other`, `=N` exact, `#` the number) | `"{n, plural, =0 {No coins} one {# coin} other {# coins}}"` |
+| select | `"{g, select, f {She won} m {He won} other {They won}}"` |
+| a literal brace or quote | `'{'`, `''` |
+
+- Big numbers in a locale's own units (K, M, B in English; 万, 亿 in
+  Chinese) are table data too: a key for how many digits a unit spans and
+  a key per unit, read by one formatter (`templates/archetypes/idle`'s
+  `big` in `src/numbers.ts`).
+- Whole sentences per key, never concatenated pieces: word order differs
+  (Japanese puts the verb last, Arabic reads right to left).
+- Plurals in every table, even where the language has one form
+  (`{n, plural, other {コイン#枚}}`): the argument names stay the same in
+  every locale, and `og cook` checks they do.
+- Numbers, times and prices go through arguments, not string building.
+- og.ui's templates have words of their own (Retry, Share, "Best 1,200",
+  "New best", Cancel, Settings, Buy, Skip, "1 of 3", a racing HUD's
+  "lap", "Best 1:36.233", Pause and Boost): each is a field of
+  the template's desc with the English default, so a localised game passes
+  its table's: `ResultsDesc.bestLabel`, `newBestLabel`, `shareLabel`,
+  `actions`; `ConfirmDesc.confirmLabel`, `cancelLabel`; `SettingsDesc.title`,
+  `audioLabel`, `graphicsLabel`, `controlsLabel`, `languageLabel`,
+  `masterLabel`, `musicLabel`, `effectsLabel`, `muteLabel`, `qualityLabel`,
+  `lowLabel`, `mediumLabel`, `highLabel`, `fpsLabel`, `motionLabel`,
+  `contrastLabel`, `sensitivityLabel`, `invertLabel`, `vibrationLabel`,
+  `doneLabel`; `ShopDesc.title`, `currency`, `priceLabel`, `buyLabel`,
+  `shortLabel` (Buy while the balance is short: "Not enough"),
+  `ownedLabel`, `emptyLabel`; `InventoryDesc.title`, `useLabel`,
+  `hintLabel` (the detail panel with nothing selected), `countLabel`;
+  `LeaderboardDesc.title`, `empty`, `retryLabel` (under `error`, the
+  game's own message); `TutorialDesc.skipLabel`, `nextLabel`, `doneLabel`
+  (Next on the last step), `stepLabel`; `CutsceneDesc.skipLabel`;
+  `LevelSelectDesc.title`; `ResultsDesc.scoreLabel` (over the score:
+  "Total time"); `RacingHudDesc.lapLabel` (under the lap), `bestLabel`
+  ("Best {best}", the best lap as m:ss.mmm), `pauseLabel` (the pause
+  button's name), `boostLabel`, `brakeLabel`, `leftLabel`, `rightLabel`
+  (the touch pedals and arrows) and `unit`, and its `splits`' labels
+  (`S1`) are the game's. `bestLabel: og.i18n.t(world, "results.best")`
+  with `"Best {best}"` / `"最佳 {best}"` in the tables (the template fills
+  `{best}`, formatted); `stepLabel` the same with `"{step} of {count}"` /
+  `"第 {step} 步，共 {count} 步"`. templates/ui-kit passes every one of
+  these words from its five tables (`settings.*`, `shop.*`, `inventory.*`,
+  `leaderboard.*`, `tutorial.*`, `cutscene.*`).
+- Emphasis inside a sentence is rich-text markup in the message itself
+  (`"Your progress in slot [b]{slot}[/b] will be lost."`, shown with
+  `og.ui.richText`): each translation bolds or colours its own words, in
+  its own order, instead of the code splitting the sentence into styled
+  pieces.
+
+## 3. Fonts for every script
+
+- What a screen reader hears is words too, and the same rule holds: a
+  group or a picture the kit names for a reader takes its name from the
+  desc, with the English default. `LevelSelectDesc.backLabel` (its Back
+  button), `starsLabel` (`"{stars} of {max} stars"`, a card's stars and
+  the total's: `"{stars} de {max} estrellas"`), `lockedLabel` (`"{name},
+  locked"`, a locked card); `SettingsDesc.sectionLabel` (the tab row, the
+  select on a phone: "Section") and `languagesLabel` (the language list:
+  "Languages"), and `qualityLabel` names the presets as well as heading
+  them. Below the templates, `TabsDesc`, `RadioDesc` and `SelectDesc`
+  take a `label` (else the reader hears the id) and `IconDesc` and
+  `ImageDesc` a `label` (else an icon is its atlas name, `star`; `""` is
+  decoration): og-ui §4.
+- Latin and Cyrillic: the skin's font. Every other script: a subset of a
+  Noto face for that script holding exactly the characters your tables
+  use, named first in that table's `fonts` line.
+- What the engine ships: `fonts/NotoSansSC-Regular-subset.ttf`, in every
+  project (Simplified Chinese: GB2312's 6,763 hanzi, kana and Latin-1,
+  2.5 MB), the source for a Chinese subset and the skins' CJK `fallback`.
+  The ui-kit's `NotoSansJP-subset.otf`, `NotoSansKR-subset.otf` and its
+  Arabic, Hebrew and Devanagari subsets hold only the ui-kit's own strings
+  (the Japanese one 246 characters, 74 of them kanji): they are no source
+  for a game's text. A Japanese, Korean, Traditional Chinese or Arabic
+  game brings the whole Noto face (notofonts, SIL OFL; Noto Sans CJK's
+  Regular `.ttc` holds Japanese as face 0, Korean 1, Simplified 2,
+  Traditional 3) into a folder outside `assets/` (`tools/fonts/`), so the
+  cook never sees it, and records its licence.
+- Make the subset with `templates/ui-kit/tools/subset-font.py`, copied into
+  the project's `tools/`: it reads every `string` of `assets/strings/`
+  (`--locale ja` for one table, `--extra` for what players or playtests
+  type), writes the subset and its import settings (`chars` listing every
+  character) and exits 1 naming each character the source lacks. Run it
+  again after a string changes, then `og cook`:
+
+  ```sh
+  python3 tools/subset-font.py tools/fonts/NotoSansCJK-Regular.ttc assets/fonts/NotoSansJP-game.otf --face 0 --locale ja
+  python3 tools/subset-font.py assets/fonts/NotoSansSC-Regular-subset.ttf assets/fonts/NotoSansSC-game.ttf --locale zh-CN --cjk-only
+  ```
+
+  `--cjk-only` leaves Latin out, so a label mixing scripts takes its Latin
+  from the skin's face run by run; with Latin kept, the whole label is
+  drawn in the subset (og-ui §7 has the rule).
+- Never take Japanese from the Chinese face: it lacks the Japanese forms of
+  common kanji (鐘 鈴 険 続 設 語 楽 効 are not in it) and draws the kanji
+  both scripts share in their Chinese shapes. The fallback chain below is a
+  safety net for a character a subset missed, not a font for a language:
+  a Japanese string that reaches the skin's Chinese `fallback` is drawn in
+  Chinese forms, and one no font has is a box with a warning on the first
+  frame that draws it.
+- Each font's import settings (`<font>.ogt`) list its characters (`chars`)
+  or a charset: `ascii`, `latin`, `kana`, `hangul`, `arabic`. A font
+  cooked with the `arabic` charset also carries its joining forms and its
+  outlines, which og-ui's shaper needs.
+- og-ui looks a glyph up in the active locale's fonts first, then every
+  other loaded table's, then `UiDesc.fallbackFonts` (fonts for scripts no
+  table names: a Hebrew or Devanagari face), then the skin's. A box (tofu)
+  in a frame means a font lacks the character: add it to the subset and
+  to `chars`. The engine's log says so on the tick a character is first
+  drawn, once per character, naming it, the font's asset and what its atlas
+  holds (`WARN tick 2603 a frame drew "−" U+2212, which font
+  skins/neon/ChakraPetch-BoldItalic.ttf lacks (its atlas holds charset
+  latin punct)`): the packs cook `latin punct`, which has the hyphen-minus
+  `-` but not the minus sign U+2212 nor the arrows U+2190 to U+2193. One
+  label is drawn in one font, so the font that covers a
+  Hebrew word must also have the digits beside it.
+- Player-typed text (a name, a chat line) is not in any table: cook the
+  CJK face with `runtime true` in its import settings and the characters
+  outside its atlas are drawn at run time (about 1 to 2 ms each, once per
+  character), with a warning the first time. Keep `chars` for everything
+  the tables hold, so a frame never waits on them; `charset all` for CJK
+  is about 20 MB and never the answer.
+- Complex scripts are shaped from the font file the cook keeps: Arabic
+  joins, Devanagari conjuncts and pre-base vowel signs, marks over their
+  bases. Cook such a font with the script's charset (`arabic`) or its
+  `chars`; check a frame of every shaped string (a conjunct drawn as
+  separate letters means the font or its file is missing). Kerning pairs
+  apply in every font that has them: nothing to set.
+- Chinese, Japanese and Korean break between characters under kinsoku:
+  closing brackets and quotes, 、。，？！, small kana, ー and the iteration
+  marks never start a line, opening brackets never end one, and a katakana
+  word stays whole (オリジン・ / クエスト, not オリジン・クエス / ト);
+  Latin breaks at spaces. Nothing to configure: write the string as it
+  reads and check the frame.
+
+## 4. Right to left
+
+Arabic, Hebrew, Persian and Urdu locales set the UI's direction to
+right-to-left: og.ui mirrors the whole layout about the surface's centre
+(a corner anchored top-left moves top-right, rows run right to left),
+flips start and end alignment, and orders words by direction while numbers
+and Latin words inside stay left to right (by the Unicode bidirectional
+algorithm, over each whole line of `og.ui.richText`; a label takes the
+direction of its first strong character). Do not mirror the play field or
+the camera. Icons are drawn as they are: give a direction icon (back, next)
+its mirrored twin for right to left, and leave icons of objects alone.
+
+## 5. The player's choice
+
+The settings screen's language list calls `og.i18n.setLocale(world, tag)`
+and saves the choice with the other settings (`og.platform.saveSettings`).
+Restore it: `og.platform.loadSettings` on the first tick, and
+`og.i18n.setLocale` with the saved tag when it answers (og-platform-sdk §3);
+a game that only saves comes back in the host's language after a reload. `og.i18n.locale(world)`
+answers the requested and active locale, the direction and the font chain.
+
+## 6. Prove it
+
+- A playtest per locale that matters (`templates/ui-kit/tests/locales.og.ts`):
+  `locale:<tag>` in the command script switches the locale, then
+  `screenshot` each main screen and compare with references; read each
+  frame for boxes, clipped words and wrong direction.
+- Check text fits: the longest translation (German, Russian) of each
+  button in `dump_ui` stays inside its element.
+- `og cook` prints `warning:` lines for missing or mismatched keys; the
+  build is not done while any remain.

package/knowledge/skills/og-platform-sdk/SKILL.md

@@ -0,0 +1,199 @@
+---
+name: og-platform-sdk
+description: The OriginGame platform from inside an Origin Engine game — og.platform's store (saves with revisions and conflicts), leaderboards, telemetry, Origin Point, AI-content marks and the settings helpers, as requests answered at a later tick; how they work in the Player, on the stage and under og run; how to test them with dump_platform and --platform-store; and what to ask the platform for when a method is missing. Use when a game saves progress or settings, shows scores, files events or asks for points (the platform's og-platform skill covers the Player protocol around it).
+---
+
+Game code never talks to the platform. It asks the engine, `og.platform.*`,
+by method name and arguments; the host answers: the web shell over the
+Player's protocol 2 (to the Player framing the page, or, when the platform
+opens the published page itself at the top level, to its play origin over
+same-origin HTTP), falling back to the browser's own storage; `og run`
+from a local JSON store. No credential, URL or cookie reaches game code,
+and every call works (or answers `unavailable`) everywhere, so the game
+never branches on where it runs. The API is in `reference/platform.md`;
+the platform's `og-platform` skill is the Player and readiness side.
+
+## What works
+
+Hollowbell (`examples/hollowbell`, written from this package alone) keeps
+its run in the store (`og.platform.storeSet` at the revision it read, a
+conflict read again and written back) and proves Continue across a
+relaunch with a `store: "keep"` playtest; Lantern Vale
+(`examples/lantern-vale`) keeps its settings through
+`og.platform.saveSettings`. The relaunch worked the first time it was
+asked for as §4 says. The Kestrel Stair (`examples/kestrel-stair`) keeps
+its whole world at a waystone (`world.snapshot()`, about 78 KB of text, in
+parts under the store's 64 KiB a key) and continues it after a
+`store: "keep"` relaunch, its progress at the revision read with a
+conflict merged, and a won climb on an ascending leaderboard. The store's
+limits are the platform's (64 KiB a key, 64 keys and 1 MiB per player and
+game), so the world goes through `og.platform.saveSlot`: its parts
+(`run.a0`, `run.a1`) in whichever of the slot's two banks of keys
+(`<slot>.a0..`, `<slot>.b0..`) the last save did not use, then the
+manifest `run` at the revision read, so a save cut short leaves the
+previous one whole and two devices saving at once get a conflict, not a
+mix; one request a call. Its title reads `og.platform.loadSlot` with
+`metaOnly` for Continue's place and hour, and Continue reads the parts,
+checked against the manifest's length and checksum.
+
+## 1. Requests, answered later
+
+Every call returns a request number at once; the answer arrives at the
+start of a later tick, when `og.platform` sends `og.PlatformAnswered`.
+
+```ts
+// templates/archetypes/runner's Records system.
+if (time.tick === 0) {
+  const asked = og.platform.storeGet(world, "best");      // the request, at once
+  run.bestRequest[i] = asked.ok ? asked.value : 0;
+  return;
+}
+const request = run.bestRequest[i]!;
+if (request === 0) return;
+const answer = og.platform.result(world, request);       // null while in flight
+if (answer === null) return;
+run.bestRequest[i] = 0;
+if (answer.ok && typeof answer.data.value === "number") run.best[i] = Math.max(run.best[i]!, answer.data.value);
+```
+
+- Keep the request number in a component or resource (snapshots carry it),
+  never in a closure.
+- Answers are host input, like key presses: a replay records them, so the
+  same answers give the same world.
+- Every answer carries `time` (UTC ms): the host's clock when it was
+  answered. `og.platform.now(world)` is the host's clock at the last
+  answer (or when the platform attached) advanced by the ticks since, so
+  it is the one wall clock a game may read: the time away is a store
+  answer's `time` less the time the save wrote down
+  (`templates/archetypes/idle`, `tests/away.og.ts`). `info(world).clock`
+  says whose it is: `player`, `browser` (the web host's own, until the
+  Player sends its time), `system` (native), `fixed` (`og run --clock`,
+  playtests), `none` before the platform attaches (`now` answers 0).
+- An error has a stable `code` (`offline`, `timeout`, `invalid`,
+  `unauthorized`, `not_found`, `conflict`, `too_large`, `rate_limited`,
+  `unavailable`, `failed`) and `retryable`. Handle `unavailable` as
+  "this feature is off here" and keep playing.
+
+## 2. What to use
+
+| Need | Call | Notes |
+|---|---|---|
+| Progress, unlocks, a best score | `storeGet(world, key)`, `storeSet(world, { key, value, revision })`; the whole world: `world.snapshot()` text through `saveSlot(world, { slot, text, meta })` (as many keys as it needs, the manifest last, one request) and `loadSlot(world, { slot, metaOnly })`, back with `world.restore` (og-game §17) | one key per independent thing; values ≤ 64 KiB, at most 64 keys and 1 MiB per player and game; pass the revision you read to refuse a stale write (`conflict`, whose `error.revision` is where the key is now: read again and merge), `create: true` to write only a key never written, no revision for "the last write wins" |
+| Volume, controls, language | `loadSettings(world)`, `saveSettings(world, settings)` | the key `og.settings`, last save wins, local fallback when offline |
+| A leaderboard | `leaderboardSubmit(world, { board, score })`, `leaderboardTop`, `leaderboardAround` | the board keeps the player's best; show "around me" as well as the top |
+| Analytics | `telemetry(world, "round.over", { score, coins })` | one-way; a name of 1–64 letters, digits, `.` and `_` (the Player files it as `game.custom.<name>`), at most 16 scalar attributes; never personal data |
+| Origin Point | `point(world, { reason, amount })` | the platform decides what it grants (today nothing under a Player: `{ granted: 0, balance: null }` until an approved point policy; show nothing that depends on it) |
+| AI-generated content shown | `aiMark(world, { kind, label })` | disclosure, not permission |
+
+`og.platform.info(world)` says what answers here (`player`, `local` or
+`none`) and the methods it answers (`capabilities`): check it rather than
+trying.
+
+## 3. Rules
+
+- Read saves on the first tick and show defaults until they answer;
+  never block the title on the platform. On the web the title behind the
+  play gate is not tick 1's defaults: the shell takes the first tick, then
+  one more tick each time the store answers what that tick asked (the
+  settings, a slot's manifest, then its parts), up to 8 ticks, before the
+  first frame while the answers come within 300 ms and drawn as they land
+  for 5 s after (docs/web-export.md §The shell). So apply an answer the
+  tick it arrives (the language, Continue's label), and apply it before
+  the title is built that tick: systems run in `GameDesc.systems` order,
+  so the system that reads the answers comes before (or is) the one that
+  builds the title. A title built by a `Ui` system listed before an
+  `Answers` system draws that tick in the defaults even though the answer
+  landed, and the frame behind the gate is that tick's: the saved Spanish
+  shows only after the tap. The fix is the order: list the system that
+  reads every answer first (`systems: [Answers, ..., Ui, Saves]`, writes
+  last), or read the answers at the top of the system that builds the
+  title. A title that waits for a later tick, or a screen transition that
+  only starts after the tap, still shows its defaults behind the gate.
+- The frame behind the gate is a still of the opening title a few ticks
+  in, held until the tap, so anything on it that moves into place over
+  its first second stands part-way there: the skin's panel entrance and
+  its controls' stagger (about half a second), a transition, a fade the
+  game plays itself. Build the screen the game opens on settled while it
+  is that screen, and let every later screen enter as usual:
+  `og.ui.mainMenu("Title", { ..., instant: !g.leftTitle })` with
+  `g.leftTitle` set once the shown screen is another (examples/kestrel-stair
+  `src/ui.ts`); `og.ui.anchor` and `og.ui.transition` take the same
+  `instant`. A game's own intro on the title (a fade from black, a logo)
+  starts complete on the first tick, or plays after the player's first
+  press.
+- Settings are a pair: a game that calls `saveSettings` also calls
+  `loadSettings` on its first tick and, when it answers, applies every
+  field it saves, through the same code its settings screen uses. Ask
+  for the saved language with `og.i18n.setLocale` even when it matches
+  the default (the host's own locale may be another). Saving alone
+  passes every test that never relaunches, and every reload comes back
+  in the defaults. A `store: "keep"` playtest whose relaunch reads the
+  setting back proves it (§4; `templates/ui-kit/tests/settings-saved.og.ts`).
+- Save on meaningful moments (a new best, a level done, settings closed),
+  not every tick: writes are rate limited.
+- Never store anything the game can recompute, and never a secret: the
+  store belongs to the player, not to the game.
+- The engine exposes no identity (no player id, name or account): a game
+  that needs a display name asks for it (§5).
+
+The settings read, as the UI kit does it (`followSettings` in
+`templates/ui-kit/src/main.ts`, called by its system every tick):
+
+```ts
+if (time.tick === 0) {
+  d.settingsRequest = og.platform.loadSettings(world);   // og.settings, answered later
+} else if (d.settingsRequest !== 0) {
+  const answer = og.platform.result(world, d.settingsRequest);
+  if (answer !== null) {
+    d.settingsRequest = 0;
+    const saved = answer.ok ? (answer.data as { value?: unknown } | null)?.value : null;
+    if (saved && typeof saved === "object") takeSettings(world, d, saved as Partial<GameSettings>, true);  // volumes, language, contrast, motion
+  }
+}
+```
+
+## 4. Test it
+
+- `dump_platform[:file]` lists every call with its method, arguments, tick,
+  state and answer, and what answers them: assert on it in a playtest
+  (`templates/archetypes/runner/tests/records.og.ts`; a stale write read
+  again and merged: `templates/archetypes/idle/tests/offline.og.ts` and
+  `templates/archetypes/roguelike/tests/win.og.ts`).
+- `og run --platform-store save.json` keeps the local store in a file, so
+  a second run sees the first's save; without it the store is in memory
+  for the run. `og run --clock <UTC ms>` fixes the host clock at tick 0
+  (it then moves with the ticks); a playtest runs at 2026-01-01 00:00 UTC
+  unless its `clock` says otherwise.
+- A relaunch across processes: a playtest with `store: "keep"` keeps one
+  local store (`<out>/.store/platform.json`, a dot name no step's output
+  may take, so `dump_platform:platform.json` is safe) for its run and its `then` steps (`{ commands, clock }`,
+  each a fresh `og run`), and `check` reads each step's run in
+  `run.then[n]` (`templates/archetypes/idle/tests/away.og.ts`: saved at
+  `clock`, launched two hours later). A command that relaunches in the
+  same process stays for tests that need no second process.
+- In the browser, `packages/engine/tests/web/player.ts` shows the Player
+  side: a framed game's first calls wait for the Player's `hello`, then go
+  as protocol 2 `call`s (`store.get`, `store.set`, `leaderboard.around`,
+  `point.award`, `ai.mark`, as the hello lists them; `docs/web-export.md`
+  §Platform services has the mapping).
+- The same file then opens the build as a top-level page with a stand-in
+  play origin: the same calls go to `/__player/v2/<game>/<release>/call`
+  with the answers unchanged, so a game behaves the same framed or not
+  (`docs/web-export.md` §The top-level page). Nothing in game code changes
+  between the two, and nothing in it can tell them apart.
+
+## 5. When a method is missing: ask
+
+The engine maps what the Player's protocol 2 offers and answers the rest
+`unavailable`. Every ask the engine made (the engine repository's
+`docs/platform-asks.md`: the keyed store with per-key revisions,
+`leaderboard.around`, the best on submit, `point.award`, `ai.mark`,
+capabilities for a verification run, telemetry names) landed on
+2026-10-19; an older Player answers what its hello lists. One is open:
+the Player's `hello` and answers carrying its `time` (until then the web
+host's answers carry the browser's clock and `info(world).clock` says
+`browser`). When a game
+needs something none of them gives, do not work around it with a server of
+your own or by reaching the page: write the ask (the method, its arguments,
+its answer, why a game needs it) for the platform owners and keep the
+feature behind `info(world)` until it lands.