cuju-render 0.1.0__py3-none-any.whl

cuju/render/_text/messages.py

@@ -0,0 +1,1396 @@
+# Copyright 2026 The cuju Authors
+# SPDX-License-Identifier: Apache-2.0
+
+"""The messages of the server that the page shows to people, each with an id and English text.
+
+An answer or an entry that the page shows carries the English text in `error`, as it always has,
+and beside it the id of its message in `error_id` and the values of its placeholders in
+`error_values`, so the page shows the text in its own language. The command line and every
+English answer read the same text as before. A template names its placeholders in braces, such
+as `{scenario}`, as the language files of the page do, and Python fills it the way the page does,
+with every value as text, so both read the same.
+
+`MESSAGES` holds every id with its English template, and the part `server` of the language
+files holds the same ids, which `compare` checks. A template whose words agree with a number is
+an object of plural forms, keyed `one` and `other` and by exact counts such as `=0`, as in the
+language files, and the value `count` picks the form. A template may mark words as the language
+files do, **strong** and `code`, which the page shows as such, while `text` reads them without the
+marks, so the command line and English answers read plain text.
+"""
+
+from __future__ import annotations
+
+import importlib
+import re
+import sys
+from typing import Any
+
+from cuju.errors import ArgumentError
+
+# A placeholder of a template, as the page's own runtime, web/js/core/i18n.js, reads it. Any other
+# brace, such as that of `{"colors": [...]}`, is text.
+_PLACEHOLDER = re.compile(r'\{([A-Za-z0-9_]+)\}')
+# The marks of a template, strong emphasis in double asterisks and code in backticks, as the page
+# reads them. A mark that does not close is text.
+_MARK = re.compile(r'\*\*(.+?)\*\*|`([^`]+)`')
+
+MESSAGES: dict[str, str | dict[str, str]] = {
+    'server.bench.challenges': 'expected a list of distinct challenges, found {challenges}',
+    'server.bench.fields': (
+        'expected teams, challenges, keep_recordings and workers, found {unknown}'
+    ),
+    'server.bench.no_bench': 'no such benchmark',
+    'server.bench.teams': 'expected a list of distinct teams of the registry, found {teams}',
+    'server.bench.workers': 'expected from 1 to {most} runs at once, found {workers}',
+    'server.body_size': 'expected a request body of at most 110 MB',
+    'server.challenges.ability': 'expected the ability {ability}, found {found}',
+    'server.challenges.attempt': 'expected an attempt from 0 to {last}, found {attempt}',
+    'server.challenges.attempt_recording': (
+        'the recording {match} cannot be attempt {attempt}, {reason}'
+    ),
+    'server.challenges.attempts': 'expected from 1 to {most} attempts, found {attempts}',
+    'server.challenges.default_name': 'expected default_name as true or false, found {value}',
+    'server.challenges.distinct': 'expected a distinct recording for each attempt',
+    'server.challenges.exit': 'the run ended with exit code {code}',
+    'server.challenges.exit_detail': 'the run ended with exit code {code}, {detail}',
+    'server.challenges.keep_recordings': 'expected keep_recordings as true or false, found {value}',
+    'server.challenges.left_matches': {
+        'one': 'expected the recording of the attempt played, found {matches}',
+        'other': 'expected from 1 to {count} recordings of the attempts played, found {matches}',
+    },
+    'server.challenges.matches': {
+        'one': 'expected the recording of the attempt, found {matches}',
+        'other': 'expected the {count} recordings of the attempts in order, found {matches}',
+    },
+    'server.challenges.name_length': 'expected a name of 1 to {most} characters, found {value}',
+    'server.challenges.name_text': 'expected a name as text, found {value}',
+    'server.challenges.no_challenge': 'no challenge {identifier}',
+    'server.challenges.no_provenance': 'the recording holds no provenance',
+    'server.challenges.no_run': 'no such run',
+    'server.challenges.person_fields': (
+        'expected person, matches, keep_recordings and default_name, found {unknown}'
+    ),
+    'server.challenges.policy': 'expected a policy function, found {policy}',
+    'server.challenges.provenance': 'expected `{key}` {value} for attempt {attempt}, found {found}',
+    'server.challenges.recording': 'expected a recording of the library, found {match}',
+    'server.challenges.run_fields': 'expected a person with matches, or a team with attempts',
+    'server.challenges.team': 'expected a team of the registry, found {team}',
+    'server.challenges.team_or_policy': 'expected either a team of the registry or a policy',
+    'server.challenges.unknown': 'expected a challenge, one of {challenges}, found {identifier}',
+    'server.clips.animation': 'expected animation {index} to hold channels and samplers',
+    'server.clips.animations_count': 'expected at most {most} animations in a clip, found {count}',
+    'server.clips.animations_none': 'expected a clip with at least one animation, found none',
+    'server.clips.asset_version': 'expected a glTF 2.0 file, whose asset names version 2.0',
+    'server.clips.binary': 'expected a binary glTF file, .glb, found other bytes',
+    'server.clips.body': 'expected a bone for the joint body, the pelvis, which every rig has',
+    'server.clips.buffer': 'expected the binary chunk that the buffer of the file needs',
+    'server.clips.buffer_length': 'expected a binary chunk as long as the buffer of the file',
+    'server.clips.channels': 'expected the channels of animation {index} to name nodes',
+    'server.clips.chunks': 'expected one JSON chunk and at most one binary chunk after it',
+    'server.clips.count': 'expected at most {most} clips for a team',
+    'server.clips.cut': 'expected whole chunks in the binary glTF file, found a cut one',
+    'server.clips.extension': 'expected a clip without {extension}, which the page cannot read',
+    'server.clips.joints': 'expected the joints as names of bones by joint, found {joints}',
+    'server.clips.json': 'expected the JSON chunk of a glTF file, found {error}',
+    'server.clips.json_first': 'expected a binary glTF file with its JSON chunk first',
+    'server.clips.json_object': 'expected the JSON chunk of a glTF file to hold an object',
+    'server.clips.length': (
+        'expected a binary glTF file of the length its header gives, {length} bytes, found {size}'
+    ),
+    'server.clips.link': 'expected a self-contained clip, found a link to {uri}',
+    'server.clips.missing_bones': 'expected bones of the clip, found {bones}',
+    'server.clips.name': (
+        'expected a clip name of up to 40 lowercase letters, digits and underscores, found {name}'
+    ),
+    'server.clips.padding': 'expected chunks padded to four bytes inside the file',
+    'server.clips.size': 'expected a clip of at most 10 MB, found {size} bytes',
+    'server.clips.skin_joints': 'expected a skin with joints, found an empty one',
+    'server.clips.skinned': 'expected a skinned skeleton, a glTF file with a skin, found none',
+    'server.clips.total': (
+        'expected at most 40 MB of clips for a team, found {total} bytes with this one'
+    ),
+    'server.clips.unknown': 'expected a clip of the team, found {name}',
+    'server.clips.unknown_joints': "expected joints of GRF's skeleton, found {joints}",
+    'server.clips.version': 'expected a binary glTF file of version 2, found version {version}',
+    'server.content_length': 'expected a Content-Length of digits',
+    'server.doctor.check.disk_space': 'disk space',
+    'server.doctor.check.home_folder': 'home folder',
+    'server.doctor.check.page_files': 'page files',
+    'server.doctor.check.samples': 'samples',
+    'server.doctor.check.server_file': 'server file',
+    'server.doctor.check.server_version': 'server version',
+    'server.doctor.check.video_export': 'video export',
+    'server.doctor.check.writing': 'writing',
+    'server.doctor.disk.free': '{size} GB free',
+    'server.doctor.disk.low': '{size} GB free, recordings **may fail** to save',
+    'server.doctor.disk.unknown': 'unknown',
+    'server.doctor.home.exists': '{path} exists',
+    'server.doctor.home.file': 'the home folder is a file',
+    'server.doctor.home.missing': 'the home folder is missing, the server makes it as it starts',
+    'server.doctor.home.readonly': 'the home folder is **not writable**',
+    'server.doctor.home.under': 'the home folder lies under a file',
+    'server.doctor.page.missing': 'the page is missing, **install** `cuju` again',
+    'server.doctor.page.ok': 'the files of the page are in place',
+    'server.doctor.samples': {
+        'one': '{count} sample recording ships with the package',
+        'other': '{count} sample recordings ship with the package',
+    },
+    'server.doctor.server_file.none': 'no server runs',
+    'server.doctor.server_file.running': 'the server of the folder answers',
+    'server.doctor.server_file.stale': (
+        'a stale `server.json` names a server that does not answer, the next start replaces it'
+    ),
+    'server.doctor.server_version': (
+        'the server runs cuju {server}, this command {command}, **restart** the server'
+    ),
+    'server.doctor.video.found': 'a browser is found, `{browser}`',
+    'server.doctor.writing.fail': (
+        'the server **cannot write** its folder, choose another with `--home`'
+    ),
+    'server.doctor.writing.ok': 'the server can write its folder',
+    'server.draw.left': (
+        'expected a team of the pool that can play the left side of {scenario}, found none'
+    ),
+    'server.draw.pool': 'expected the pool as a list of teams of the registry, found {pool}',
+    'server.draw.right': (
+        'expected a team of the pool that can play the right side of {scenario}, found none'
+    ),
+    'server.draw.same_team': 'expected same_team as true or false, found {value}',
+    'server.draw.scenario': (
+        'expected a scenario that a team of the pool can play on each side, found none'
+    ),
+    'server.feed.follow.auto': 'a live source while one streams, else the newest recording',
+    'server.feed.follow.latest': 'the newest recording of the library',
+    'server.feed.follow.live': 'the newest live source',
+    'server.feed.follow.live_named': 'the live source {name}',
+    'server.feed.follow.queue': 'the newest finished requested match',
+    'server.feed.follow.tournament': 'the newest finished match of the newest tournament',
+    'server.feed.follow.tournament_named': 'the matches of the tournament {name}',
+    'server.feed.no_live': 'No live source streams now',
+    'server.feed.no_live_named': 'No live source named {name} streams now',
+    'server.feed.no_recording': 'The library holds no recording {name}',
+    'server.feed.no_recordings': 'The library holds no recording yet',
+    'server.feed.no_request': 'No requested match has finished yet',
+    'server.feed.no_tournament': 'No tournament yet',
+    'server.feed.no_tournament_named': 'No tournament named {name}',
+    'server.feed.nothing_after': 'expected nothing after the source {source}, found {value}',
+    'server.feed.recording_name': 'expected the identifier of a recording after recording:',
+    'server.feed.source': (
+        'expected a source of {sources}, a kind with a name such as live:Evaluation, or the '
+        'identifier of a recording, found {value}'
+    ),
+    'server.feed.tournament_waits': '{name} has no finished match yet',
+    'server.feed.tournament_waits_unnamed': 'The tournament has no finished match yet',
+    'server.game.answered': 'the game answered {status}',
+    'server.game.busy': 'a game already plays, quit it first',
+    'server.game.exit': 'the game ended with exit code {code}',
+    'server.game.exit_detail': 'the game ended with exit code {code}, {detail}',
+    'server.game.humans': (
+        'expected two flags for a person on the left and right, one true, found {humans}'
+    ),
+    'server.game.input_fields': 'expected side, held and pressed, found {unknown}',
+    'server.game.input_list': 'expected {key} as a list of {allowed}',
+    'server.game.paused': 'expected paused as true or false, found {paused}',
+    'server.game.person': 'expected a person on at least one side',
+    'server.game.record': 'expected record as true or false, found {record}',
+    'server.game.registry_teams': 'expected two registry teams, found {teams}',
+    'server.game.side': 'expected a side that a person plays in this game, {sides}, found {side}',
+    'server.game.sides_both': '0 for the left or 1 for the right',
+    'server.game.sides_left': '0 for the left',
+    'server.game.sides_right': '1 for the right',
+    'server.game.silent': 'the game did not answer, {error}',
+    'server.game.teams': 'expected two registry teams, left and right, found {teams}',
+    'server.game.unknown': 'no such game',
+    'server.help.sample_names': 'expected names as a list of samples, found {names}',
+    'server.invalid': 'the server could not take the request, {error}',
+    'server.json': (
+        'expected a request body of JSON, found a mistake at line {line}, column {column}'
+    ),
+    'server.json_object': 'expected a JSON object',
+    'server.json_query': (
+        'expected `{name}` as JSON, found a mistake at line {line}, column {column}'
+    ),
+    'server.json_text': 'expected a request body of JSON in UTF-8',
+    'server.language.code': (
+        'expected a language code of letters and digits in parts joined by hyphens, such as pt or '
+        'pt-BR, found {code}'
+    ),
+    'server.language.json': 'expected a language file, a JSON object with its header @language',
+    'server.language.keep': 'the language {code} ships with cuju and stays',
+    'server.language.malformed': 'expected well formed messages, found {first}',
+    'server.language.none': 'no language {code}',
+    'server.language.problem.caption': (
+        'expected a caption as a text, captions have no plural forms'
+    ),
+    'server.language.problem.categories': (
+        'expected the plural categories of {language}, the file lacks {lacking}'
+    ),
+    'server.language.problem.code': (
+        'expected a code of letters and digits in parts joined by hyphens, such as `pt` or '
+        '`pt-BR`, found {code}'
+    ),
+    'server.language.problem.dir': 'expected `dir` as `ltr` or `rtl`, found {value}',
+    'server.language.problem.document': 'expected a JSON object keyed by message id',
+    'server.language.problem.extra': 'expected the placeholders of English, found {extra}',
+    'server.language.problem.file_code': 'expected the code {code} of the file name, found {found}',
+    'server.language.problem.form_names': (
+        'expected plural categories or exact counts such as `=0`, found {unknown}'
+    ),
+    'server.language.problem.form_texts': 'expected plural forms as texts',
+    'server.language.problem.forms_expected': 'expected plural forms, as the English message has',
+    'server.language.problem.forms_lacking': 'expected the plural forms {lacking} of the language',
+    'server.language.problem.header': (
+        'expected `@language` as an object with code, name, dir and plurals'
+    ),
+    'server.language.problem.id': 'expected an id of letters, digits, _, . and -',
+    'server.language.problem.kind': 'expected a text or an object of plural forms',
+    'server.language.problem.lost': 'expected the placeholders {lost} of English',
+    'server.language.problem.marks': (
+        'expected as many code spans as English, for its commands, names and shortcuts'
+    ),
+    'server.language.problem.name': (
+        'expected the name of the language in itself, such as Português (Brasil)'
+    ),
+    'server.language.problem.other': 'expected the plural category `other` among the plurals',
+    'server.language.problem.plurals': (
+        'expected `plurals` as a list of the categories {categories}, found {value}'
+    ),
+    'server.language.problem.text': 'expected `{key}` as text, found {value}',
+    'server.language.problem.text_expected': 'expected a text, as the English message is',
+    'server.language.problem_at': '{id}, {problem}',
+    'server.language.shipped': (
+        'the language {code} ships with cuju, name your file with another code, '
+        'such as {code}-x-mine'
+    ),
+    'server.language.size': 'expected a language file of at most {most} MB',
+    'server.library.favorite': 'expected favorite as true or false, found {favorite}',
+    'server.library.folder_size': (
+        'expected a folder of at most 8 names of 64 characters, found {folder}'
+    ),
+    'server.library.folder_text': 'expected a folder as text, found {folder}',
+    'server.library.group_trash': 'no such group of recordings in the Trash',
+    'server.library.group_unknown': 'no such group of recordings in the library',
+    'server.library.notes': 'expected notes as text of at most ten thousand characters',
+    'server.library.samples': 'expected a sample from {shipped}, found {unknown}',
+    'server.library.tags': 'expected up to twenty tags, each of one to forty characters',
+    'server.library.title': 'expected a title with at least one character',
+    'server.library.unknown': 'expected a recording of the library, found {identifier}',
+    'server.live.answered': 'the live source answered {status}',
+    'server.live.environment': 'expected an environment from 0 to {last}, found {environment}',
+    'server.live.grid_range': (
+        'expected a first environment from 0 to {last} and a count from 1 to {most}, found '
+        '{first} and {count}'
+    ),
+    'server.live.no_grid': 'this live source offers no grid, it comes from an older cuju',
+    'server.live.silent': 'the live source did not answer, {error}',
+    'server.live.unknown': 'no such live source',
+    'server.live.whole_number': 'expected a whole number for {name}, found {text}',
+    'server.loopback': 'expected a request to this server by its loopback address',
+    # Names and titles that cuju makes, which travel as labels.
+    'server.names.against': '{left} against {right}',
+    'server.names.builtin': "GRF's built-in AI",
+    'server.names.challenge_attempt': '{challenge}, attempt {attempt}, {competitor}',
+    'server.names.challenge_run': '{challenge}, {competitor}',
+    'server.names.default_person': 'Player',
+    'server.names.demo': 'Demo, the built-in AI against itself',
+    'server.names.left': 'Left',
+    'server.names.live': '{scenario}, environment {environment}, process {process}',
+    'server.names.medal_bronze': 'bronze',
+    'server.names.medal_gold': 'gold',
+    'server.names.medal_silver': 'silver',
+    'server.names.person_with': '{person} with {team}',
+    'server.names.player': 'Player {number}',
+    'server.names.python_policy': 'Python policy',
+    'server.names.random': 'Random',
+    'server.names.recorder': '{scenario}, environment {environment}',
+    'server.names.right': 'Right',
+    'server.names.run_attempts': '{value} of {attempts}',
+    'server.names.run_left': 'left after {played} of {attempts}',
+    'server.names.run_margin': 'goal difference {value}',
+    'server.names.run_medal': '{value}, {medal} medal',
+    'server.names.run_no_medal': '{value}, no medal',
+    'server.names.run_playing': 'under way, {played} of {attempts} played',
+    'server.names.run_practice': '{value}, practice',
+    'server.names.run_stopped': 'stopped after {played} of {attempts}',
+    'server.names.sample_11v11': 'Sample match, 11 vs 11',
+    'server.names.sample_5v5': 'Sample match, 5 vs 5',
+    'server.names.you': 'You',
+    'server.no_clip': 'no such clip',
+    'server.no_file': 'no such file',
+    'server.no_image': 'no such image',
+    'server.no_item': 'no such item',
+    'server.no_match': 'no such match',
+    'server.no_model': 'no such model',
+    'server.no_package_file': 'no such file of the package',
+    'server.no_resource': 'no such resource',
+    'server.no_sound': 'no such sound',
+    'server.origin': 'expected a request from the page of this server',
+    'server.play.scenario': 'expected a scenario from the renderer scenario list, found {scenario}',
+    'server.policy.action_set': 'expected the v2 action set to hand players to the AI',
+    'server.policy.error': 'the policy failed, {reason}',
+    'server.policy.error_action': {
+        'one': (
+            'the policy failed, it answered the action {value}, outside its action set of {count} '
+            'action, 0 to {last}'
+        ),
+        'other': (
+            'the policy failed, it answered the action {value}, outside its action set of {count} '
+            'actions, 0 to {last}'
+        ),
+    },
+    'server.policy.failed': 'the policy of {player} failed, {reason}',
+    'server.policy.failed_action': {
+        'one': (
+            'the policy of {player} failed, it answered the action {value}, outside its action set '
+            'of {count} action, 0 to {last}'
+        ),
+        'other': (
+            'the policy of {player} failed, it answered the action {value}, outside its action set '
+            'of {count} actions, 0 to {last}'
+        ),
+    },
+    'server.policy.first': {
+        'one': 'the policy did not answer its first observation within {count} second',
+        'other': 'the policy did not answer its first observation within {count} seconds',
+    },
+    'server.policy.load': {
+        'one': 'the policies did not load within {count} second',
+        'other': 'the policies did not load within {count} seconds',
+    },
+    'server.policy.silent': {
+        'one': 'the policy has not answered for {count} second',
+        'other': 'the policy has not answered for {count} seconds',
+    },
+    'server.preflight.failed': 'the check of the team failed, {reason}',
+    'server.preflight.left_out': (
+        'the pre-flight left out the teams that failed it, and the tournament cannot be made '
+        'with the entrants that remain, {error}'
+    ),
+    'server.preflight.timeout': {
+        'one': 'the check of the team took longer than {count} minute',
+        'other': 'the check of the team took longer than {count} minutes',
+    },
+    'server.requests.cancelled': 'cancelled',
+    'server.requests.exit': 'the match ended with exit code {code}',
+    'server.requests.exit_detail': 'the match ended with exit code {code}, {detail}',
+    'server.requests.history': 'could not save the request history, {error}',
+    'server.requests.interrupted': 'interrupted by a server restart',
+    'server.requests.interrupted_playing': (
+        'interrupted by a server restart while playing, its recording may still appear in the '
+        'library'
+    ),
+    'server.requests.timeout': 'the match ran past {minutes} minutes',
+    'server.samples.team': 'expected a sample team from {teams}, found {name}',
+    'server.samples.unknown': 'expected samples from {every}, found {unknown}',
+    'server.scenario': 'expected a shipped scenario, found {scenario}',
+    'server.search.date': 'expected `{key}:` as a date such as 2026-11-10, found {value}',
+    'server.search.filter': 'expected a filter of {filters}, found `{key}:`',
+    'server.search.kind': 'expected a kind of moment such as `goal` or `corner`, found {name}',
+    'server.search.limit': 'expected a limit as a whole number, found {limit}',
+    'server.search.limit_range': 'expected a limit from 1 to {most}, found {limit}',
+    'server.search.limit_text': 'expected `limit:` as a whole number, found {value}',
+    'server.search.minutes': (
+        'expected `{key}:` as minutes of the clock, such as 60, 60:30 or 90s, found {value}'
+    ),
+    'server.search.score': (
+        'expected `score:` as leading, level, trailing or a score such as 2-1, found {value}'
+    ),
+    'server.search.source': (
+        'expected `source:` as requested, game, challenge, recorder, live, tournament or unknown, '
+        'found {value}'
+    ),
+    'server.search.target': 'expected a recording of the library or a `.cjr` file, found {target}',
+    'server.search.unknown_filter': 'expected a filter, found `{key}:`',
+    'server.seed': 'expected a seed from 0 to 2**64 - 1, found {value}',
+    'server.sizes.area': (
+        'expected a picture of at most {area} pixels, as 3840 by 2160, found {width} by {height}'
+    ),
+    'server.sizes.even_height': 'expected an even height, found {value}',
+    'server.sizes.even_width': 'expected an even width, found {value}',
+    'server.sizes.graphics': (
+        'expected a scale of the graphics from {lowest} to {highest}, found {value}'
+    ),
+    'server.sizes.height': 'expected a height from {lowest} to {highest}, found {value}',
+    'server.sizes.safe': (
+        'expected a safe area of {modes} or a percentage from 0 to {most}, found {value}'
+    ),
+    'server.sizes.size': 'expected a size such as `1280x720` or one of {presets}, found {value}',
+    'server.sizes.width': 'expected a width from {lowest} to {highest}, found {value}',
+    'server.strict.both': '{home}, and {away}',
+    'server.strict.call_time': {
+        'one': '{player} did not answer action call {call} within {count} second',
+        'other': '{player} did not answer action call {call} within {count} seconds',
+    },
+    'server.strict.changed': 'the files of {player} changed since its pre-flight',
+    'server.strict.crash': '{player} failed in an action call, {reason}',
+    'server.strict.deterministic': (
+        '{player} answered differently when the same steps played again from the same seed'
+    ),
+    'server.strict.first_time': {
+        'one': '{player} did not answer its first action call within {count} second',
+        'other': '{player} did not answer its first action call within {count} seconds',
+    },
+    'server.strict.folder_size': (
+        '{player} holds {size} MB in its folder, above the limit of {limit} MB'
+    ),
+    'server.strict.invalid_count': '{player} answered a wrong count of actions, {reason}',
+    'server.strict.invalid_range': '{player} answered an action outside its action set, {reason}',
+    'server.strict.invalid_type': '{player} answered an action that is no whole number, {reason}',
+    'server.strict.load': '{player} failed to load, {reason}',
+    'server.strict.load_time': {
+        'one': '{player} did not load within {count} second',
+        'other': '{player} did not load within {count} seconds',
+    },
+    'server.strict.mean': (
+        '{player} took {mean} ms for an action call on average, above the limit of {limit} ms'
+    ),
+    'server.strict.memory': '{player} used {used} MB of memory, above the limit of {limit} MB',
+    'server.strict.memory_out': '{player} ran out of its memory of {limit} MB',
+    'server.strict.process': '{player} started another process, which strict rules refuse',
+    'server.strict.reset': '{player} failed in its reset, {reason}',
+    'server.strict.reset_time': {
+        'one': '{player} did not reset within {count} second',
+        'other': '{player} did not reset within {count} seconds',
+    },
+    'server.strict.threads': (
+        '{player} ran {found} threads, above the {limit} that its process may run'
+    ),
+    'server.strict.total_time': (
+        '{player} computed for {total} seconds in all, above the limit of {limit} seconds for a '
+        'match'
+    ),
+    'server.strict.warning_action': (
+        '{player} answered the action {action} in {share}% of its actions.'
+    ),
+    'server.strict.warning_deterministic': (
+        '{player} answered differently when the same steps played again from the same seed.'
+    ),
+    'server.strict.warning_setting': 'The setting {setting} of {file} is unknown to cuju render.',
+    'server.teams.ability': 'expected an ability from 0 to 1, found {value}',
+    'server.teams.ability_pair': 'expected a pair of abilities, left and right, found {ability}',
+    'server.teams.agent_function': 'expected an agent function in the submission {identifier}',
+    'server.teams.archive.device': (
+        'expected archive members whose names open no device on Windows and end in no dot or '
+        'space, found {member}'
+    ),
+    'server.teams.archive.limits': (
+        'expected an archive of at most 10,000 files and 500 MB unpacked'
+    ),
+    'server.teams.archive.outside': 'expected archive members inside the archive, found {member}',
+    'server.teams.archive.plain': 'expected plain files in the archive, found {member}',
+    'server.teams.archive.tar': 'expected a readable .tar.gz archive, found {error}',
+    'server.teams.archive.zip': 'expected a readable .zip archive, found {error}',
+    'server.teams.badge': 'expected a badge of at most three characters, found {value}',
+    'server.teams.beside_count': {
+        '=0': (
+            '{team} cannot play beside a person in {scenario}, which has no controllable player on '
+            'that side'
+        ),
+        'one': (
+            '{team} cannot play beside a person in {scenario}, which has {count} controllable '
+            'player on that side'
+        ),
+        'other': (
+            '{team} cannot play beside a person in {scenario}, which has {count} controllable '
+            'players on that side'
+        ),
+    },
+    'server.teams.beside_dynamic': 'expected dynamic assignment for {team} beside a person',
+    'server.teams.cannot_play': '{team} cannot play {scenario}, {reason}',
+    'server.teams.celebration': 'expected the name of a celebration, found {value}',
+    'server.teams.celebrations': 'expected a list of at most 32 celebrations',
+    'server.teams.choice': 'expected {name} as one of {choices}, found {value}',
+    'server.teams.color': 'expected {name} as three integers from 0 to 255, found {value}',
+    'server.teams.color_pair': 'expected colors as #rrggbb, found {old} and {new}',
+    'server.teams.colors': 'expected the colors as a dictionary by model, found {value}',
+    'server.teams.colors_count': {
+        'one': 'expected at most {count} color for {model}',
+        'other': 'expected at most {count} colors for {model}',
+    },
+    'server.teams.control.fields': (
+        'expected players, assignment, selection, goalkeeper and action_set'
+    ),
+    'server.teams.control.goalkeeper_builtin': (
+        'scenario makes the goalkeeper uncontrollable, choose scenario'
+    ),
+    'server.teams.control.goalkeeper_fixed': (
+        'expected fixed assignment for a goalkeeper handed to the AI'
+    ),
+    'server.teams.control.goalkeeper_outside': (
+        'expected the goalkeeper outside the fixed selection'
+    ),
+    'server.teams.control.goalkeeper_scenario': (
+        'scenario has a controllable goalkeeper, choose agent or builtin'
+    ),
+    'server.teams.control.goalkeeper_selected': 'expected the goalkeeper in the fixed selection',
+    'server.teams.control.goalkeeper_uncontrollable': (
+        'scenario makes the goalkeeper uncontrollable'
+    ),
+    'server.teams.control.legacy_goalkeeper': (
+        'expected 10 players for the earlier goalkeeper setting'
+    ),
+    'server.teams.control.none_present': 'scenario holds none of the selected players',
+    'server.teams.control.players': 'expected from 1 to {most} controlled players',
+    'server.teams.control.select_player': 'scenario cannot select player {player}',
+    'server.teams.control.selection_count': 'expected one selection for each controlled player',
+    'server.teams.control.selection_distinct': 'expected distinct player indices or GRF role names',
+    'server.teams.control.selection_empty': 'expected an empty selection for dynamic assignment',
+    'server.teams.control.selection_list': 'expected a list of player indices or roles',
+    'server.teams.control.too_few': {
+        '=0': 'scenario has no controllable player',
+        'one': 'scenario has only {count} controllable player',
+        'other': 'scenario has only {count} controllable players',
+    },
+    'server.teams.controlled_players': 'expected a number of controlled players, found {players}',
+    'server.teams.crowd': 'expected the crowd as {"colors": [...]}, found {value}',
+    'server.teams.crowd_colors': 'expected one to four colors of the fans',
+    'server.teams.custom_model': 'expected an uploaded model before choosing the custom model',
+    'server.teams.duplicate_builtin': (
+        'expected a registered submission to duplicate, found the built-in AI'
+    ),
+    'server.teams.editor': 'expected the JSON document of the editor, found {error}',
+    'server.teams.field.action_set': 'action set',
+    'server.teams.field.assignment': '`assignment`',
+    'server.teams.field.colors_model': 'the model of the colors',
+    'server.teams.field.fans_color': 'a color of the fans',
+    'server.teams.field.format': 'the format',
+    'server.teams.field.goalkeeper': '`goalkeeper`',
+    'server.teams.field.hair': 'the hair',
+    'server.teams.field.hair_color': 'the hair color',
+    'server.teams.field.image_slot': 'the image slot',
+    'server.teams.field.model': 'the model',
+    'server.teams.field.numbers': 'the numbers',
+    'server.teams.field.pattern': 'the pattern',
+    'server.teams.field.player_model': 'the player model',
+    'server.teams.field.skin': 'the skin',
+    'server.teams.field.sound_slot': 'the sound slot',
+    'server.teams.folder.files': 'expected the files that the index of the folder lists',
+    'server.teams.folder.index': 'expected the index of a submission folder, found {error}',
+    'server.teams.folder.index_list': (
+        'expected the index of a submission folder, a list of its files'
+    ),
+    'server.teams.folder.short': 'expected the files of a submission folder, found too few bytes',
+    'server.teams.hidden_numbers': (
+        'expected hidden_numbers as a list of model names, found {value}'
+    ),
+    'server.teams.image_size': 'expected an image of at most 8 MB, found {size} bytes',
+    'server.teams.image_type': 'expected a PNG, JPEG or WebP image',
+    'server.teams.model.binary': 'expected a binary glTF file, .glb, found other bytes',
+    'server.teams.model.body': (
+        'expected a bone for the joint body, the pelvis, which every rig has'
+    ),
+    'server.teams.model.bones': 'expected bones of the model',
+    'server.teams.model.joints': 'expected the joints as names of bones by joint, found {joints}',
+    'server.teams.model.json': 'expected the JSON chunk of a glTF file, found {error}',
+    'server.teams.model.json_first': 'expected a binary glTF 2.0 file with its JSON chunk first',
+    'server.teams.model.json_object': 'expected the JSON chunk of a glTF file to hold an object',
+    'server.teams.model.limits': 'expected a model of the limits with a joint for body',
+    'server.teams.model.link': 'expected a self-contained model, found a link to {uri}',
+    'server.teams.model.missing_bones': 'expected bones of the model, found {bones}',
+    'server.teams.model.rigged': 'expected a rigged model, a glTF file with a skin, found none',
+    'server.teams.model.size': 'expected a model of at most 30 MB, found {size} bytes',
+    'server.teams.model.too_large': 'expected a model of at most 30 MB',
+    'server.teams.model.unknown_joints': "expected joints of GRF's skeleton, found {joints}",
+    'server.teams.name': 'expected a team name with at least one character',
+    'server.teams.player': 'expected player {index} as a dictionary, found {value}',
+    'server.teams.player_entry': 'expected an entry of a player, found {key}',
+    'server.teams.player_name': 'expected a name of at most 24 characters, found {name}',
+    'server.teams.players': {
+        'one': 'expected at most {count} player entry, found {value}',
+        'other': 'expected at most {count} player entries, found {value}',
+    },
+    'server.teams.scenario_format': 'expected a scenario of {format} for {team}, found {scenario}',
+    'server.teams.shirt_number': 'expected a shirt number from 0 to 99, found {number}',
+    'server.teams.sound_size': 'expected a sound of at most 2 MB, found {size} bytes',
+    'server.teams.sound_type': 'expected an Ogg, MP3 or WAV sound',
+    'server.teams.sound_damaged': (
+        'expected a whole {kind} sound, the file ends early or holds no sound'
+    ),
+    'server.teams.style': 'expected a style as a dictionary, found {value}',
+    'server.teams.style_entry': 'expected an entry of a style, found {key}',
+    'server.teams.style_part': 'expected a part of {key}, found {part}',
+    'server.teams.style_part_object': 'expected {key} as a dictionary, found {value}',
+    'server.teams.submission.kind': (
+        'expected a submission folder, a .py file or a .tar.gz or .zip archive, found {filename}'
+    ),
+    'server.teams.submission.main_folder': (
+        'expected {main} in the folder {folder}, as Kaggle requires'
+    ),
+    'server.teams.submission.main_top': (
+        'expected {main} at the top of the submission, as Kaggle requires'
+    ),
+    'server.teams.submission.size': 'expected a submission of at most 100 MB, found {size} bytes',
+    'server.teams.submission.unpack': 'expected a submission whose files unpack, found {error}',
+    'server.teams.unknown': 'expected a team of the registry, found {identifier}',
+    'server.teams.unknown_kaggle': 'expected a Kaggle team of the registry, found {identifier}',
+    'server.tournament.ability': (
+        'expected the ability of entrant {entrant} from 0 to 1, found {ability}'
+    ),
+    'server.tournament.best_places': 'stage {stage} names best places without a position',
+    'server.tournament.bracket_byes': {
+        'one': (
+            'a bracket of {size} with byes needs from {lowest} to {size} entrants, and {count} '
+            'enters {where}'
+        ),
+        'other': (
+            'a bracket of {size} with byes needs from {lowest} to {size} entrants, and {count} '
+            'enter {where}'
+        ),
+    },
+    'server.tournament.bracket_exact': {
+        'one': 'a bracket of {size} needs exactly {size} entrants, and {count} enters {where}',
+        'other': 'a bracket of {size} needs exactly {size} entrants, and {count} enter {where}',
+    },
+    'server.tournament.bracket_play_in': {
+        'one': (
+            'a bracket of {size} with a play-in round needs from {size} to {highest} entrants, and '
+            '{count} enters {where}'
+        ),
+        'other': (
+            'a bracket of {size} with a play-in round needs from {size} to {highest} entrants, and '
+            '{count} enter {where}'
+        ),
+    },
+    'server.tournament.bracket_power': 'expected a bracket size of {where} that is a power of two',
+    'server.tournament.cancel_state': (
+        'expected a tournament that runs or stopped, found it {state}'
+    ),
+    'server.tournament.cannot_play': '{entrant} cannot play {scenario} in stage {stage}, {reason}',
+    'server.tournament.cannot_play_decider': (
+        '{entrant} cannot play {scenario}, the scenario of the deciding matches of stage {stage}, '
+        '{reason}, so choose another scenario for them or settle drawn ties without them'
+    ),
+    'server.tournament.cards': 'expected cards as two pairs of counts, found {cards}',
+    'server.tournament.choice': 'expected {name} from {choices}, found {value}',
+    'server.tournament.count': 'expected {name} from {lowest} to {highest}, found {value}',
+    'server.tournament.count_exact': 'expected {name} to be {lowest}, found {value}',
+    'server.tournament.defaults': 'expected the defaults as an object',
+    'server.tournament.description': 'expected a description of at most 400 characters',
+    'server.tournament.double_byes': 'a double elimination bracket fills with byes, in {where}',
+    'server.tournament.ended': 'expected a tournament that has ended, cancel it first',
+    'server.tournament.entrant_fields': 'entrant {entrant} has unknown fields {fields}',
+    'server.tournament.entrant_object': 'expected entrant {entrant} as an object, found {value}',
+    'server.tournament.entrant_team': (
+        'expected a registered team for entrant {entrant}, found {team}, the built-in AI '
+        'enters with the kind builtin'
+    ),
+    'server.tournament.entrants': 'expected from 2 to {most} entrants, found {count}',
+    'server.tournament.field.added_legs': 'the legs to add to {where}',
+    'server.tournament.field.advance': 'the entrants that advance from {where}',
+    'server.tournament.field.best_count': 'the best places of position {position} of {where}',
+    'server.tournament.field.best_position': 'the position of the best places of {where}',
+    'server.tournament.field.bracket': 'the bracket of {where}',
+    'server.tournament.field.bye_points': 'the bye points of {where}',
+    'server.tournament.field.concurrency': 'the matches at once',
+    'server.tournament.field.cycles': 'the cycles of {where}',
+    'server.tournament.field.decider_length': 'the decider length of {where}',
+    'server.tournament.field.draws': 'the draws of {where}',
+    'server.tournament.field.each': 'each of {name}',
+    'server.tournament.field.entrant_kind': 'the kind of entrant {number}',
+    'server.tournament.field.entrant_name': 'an entrant name',
+    'server.tournament.field.final_legs': 'the legs of the final of {where}',
+    'server.tournament.field.forfeit_score': 'the forfeit score',
+    'server.tournament.field.format': 'the format of {where}',
+    'server.tournament.field.grand_final_reset': 'grand final reset',
+    'server.tournament.field.group_size': 'the group size of {where}',
+    'server.tournament.field.groups': 'the number of groups of {where}',
+    'server.tournament.field.ladder_rounds': 'the rounds of the ladder of {where}',
+    'server.tournament.field.laps': 'the laps of {where}',
+    'server.tournament.field.legs': 'the legs of {where}',
+    'server.tournament.field.length': 'the length of {where}',
+    'server.tournament.field.name': 'a name',
+    'server.tournament.field.points_draw': 'the points of a draw in {where}',
+    'server.tournament.field.points_loss': 'the points of a loss in {where}',
+    'server.tournament.field.points_win': 'the points of a win in {where}',
+    'server.tournament.field.pots': 'the pots of {where}',
+    'server.tournament.field.preset_title': 'a preset title',
+    'server.tournament.field.qualifiers': 'the qualifiers of group {group} of {where}',
+    'server.tournament.field.replays': 'the replays of {where}',
+    'server.tournament.field.seed': 'the seed',
+    'server.tournament.field.seeding': 'the seeding of {where}',
+    'server.tournament.field.settle': 'the settlements of {where}',
+    'server.tournament.field.strict': 'strict rules',
+    'server.tournament.field.strict_call_seconds': (
+        'the seconds of each later action call under strict rules'
+    ),
+    'server.tournament.field.strict_deterministic': 'deterministic teams',
+    'server.tournament.field.strict_first_call_seconds': (
+        'the seconds of the first action call under strict rules'
+    ),
+    'server.tournament.field.strict_folder_mb': (
+        "the megabytes of a team's folder under strict rules"
+    ),
+    'server.tournament.field.strict_frozen': 'frozen team folders',
+    'server.tournament.field.strict_gpu': 'the GPU of a team',
+    'server.tournament.field.strict_load_seconds': 'the seconds to load under strict rules',
+    'server.tournament.field.strict_match_seconds': (
+        "the seconds of all a team's action calls of a match under strict rules"
+    ),
+    'server.tournament.field.strict_mean_call_ms': (
+        'the mean milliseconds of an action call under strict rules'
+    ),
+    'server.tournament.field.strict_memory_mb': (
+        "the megabytes of memory of a team's process under strict rules"
+    ),
+    'server.tournament.field.strict_reset_seconds': 'the seconds of a reset under strict rules',
+    'server.tournament.field.strict_threads': 'the threads of each team under strict rules',
+    'server.tournament.field.swiss_rounds': (
+        'the rounds of the Swiss {where}, which pairs {entrants} entrants without rematches,'
+    ),
+    'server.tournament.field.third_place': 'third place',
+    'server.tournament.field.tiebreakers': 'the tiebreakers of {where}',
+    'server.tournament.field.tournament_seeding': 'the seeding',
+    'server.tournament.flag': 'expected {setting} of {where} as true or false',
+    'server.tournament.foreign': (
+        'stopped, since this install did not write its file, resume it to play its matches'
+    ),
+    'server.tournament.group_minimum': {
+        'one': (
+            'every group of {where} needs at least 2 entrants, and {count} entrant makes groups of '
+            '{sizes}'
+        ),
+        'other': (
+            'every group of {where} needs at least 2 entrants, and {count} entrants make groups of '
+            '{sizes}'
+        ),
+    },
+    'server.tournament.group_sizes': 'expected group sizes as a list of counts in {where}',
+    'server.tournament.group_total': {
+        'one': 'the group sizes of {where} hold {total} entrants, and {count} enters it',
+        'other': 'the group sizes of {where} hold {total} entrants, and {count} enter it',
+    },
+    'server.tournament.groups_advance': (
+        'the groups of {where} send {advance} on, by qualifiers and best places'
+    ),
+    'server.tournament.groups_few': 'the groups of {where} send fewer than 2 entrants on',
+    'server.tournament.include': (
+        'expected the added entrants as a list of at most {most} entrants, none of them a person'
+    ),
+    'server.tournament.knockout_advance': {
+        'one': 'the knockout of {where} stops at {count}, so {count} advances',
+        'other': 'the knockout of {where} stops at {count}, so {count} advance',
+    },
+    'server.tournament.knockout_stop': (
+        'expected the knockout of {where} to stop at a power of two below {size}'
+    ),
+    'server.tournament.label.builtin': 'Built-in AI',
+    'server.tournament.label.builtin_ability': 'Built-in AI {ability}',
+    'server.tournament.label.challenge': 'Challenge {number}',
+    'server.tournament.label.challenges': 'Challenges',
+    'server.tournament.label.decider': '{match}, decider',
+    'server.tournament.label.final': 'Final',
+    'server.tournament.label.grand_final': 'Grand final',
+    'server.tournament.label.grand_final_reset': 'Grand final, deciding match',
+    'server.tournament.label.group': 'Group {group}',
+    'server.tournament.label.group_matchday': 'Group {group}, matchday {number}',
+    'server.tournament.label.ladder_tie': 'Round {round}, places {upper} and {lower}',
+    'server.tournament.label.lap': 'Lap {number}',
+    'server.tournament.label.leg': '{match}, leg {number}',
+    'server.tournament.label.loser_of': 'Loser of {match}',
+    'server.tournament.label.losers_final': 'Losers final',
+    'server.tournament.label.losers_round': 'Losers round {number}',
+    'server.tournament.label.matchday': 'Matchday {number}',
+    'server.tournament.label.numbered': '{name} {number}',
+    'server.tournament.label.play_in': 'Play-in {number}',
+    'server.tournament.label.play_in_round': 'Play-in round',
+    'server.tournament.label.quarter_final': 'Quarter-final {number}',
+    'server.tournament.label.quarter_finals': 'Quarter-finals',
+    'server.tournament.label.random': 'Random',
+    'server.tournament.label.replay': '{match}, replay',
+    'server.tournament.label.round': 'Round {number}',
+    'server.tournament.label.round_of': 'Round of {count}',
+    'server.tournament.label.round_of_tie': 'Round of {count}, tie {number}',
+    'server.tournament.label.semi_final': 'Semi-final {number}',
+    'server.tournament.label.semi_finals': 'Semi-finals',
+    'server.tournament.label.stage.cup': 'Cup',
+    'server.tournament.label.stage.double_elimination': 'Double elimination',
+    'server.tournament.label.stage.gauntlet': 'Gauntlet',
+    'server.tournament.label.stage.group_stage': 'Group stage',
+    'server.tournament.label.stage.groups': 'Groups',
+    'server.tournament.label.stage.king_of_the_hill': 'King of the hill',
+    'server.tournament.label.stage.knockout': 'Knockout',
+    'server.tournament.label.stage.knockout_stage': 'Knockout stage',
+    'server.tournament.label.stage.ladder': 'Ladder',
+    'server.tournament.label.stage.league': 'League',
+    'server.tournament.label.stage.league_phase': 'League phase',
+    'server.tournament.label.stage.playoffs': 'Playoffs',
+    'server.tournament.label.stage.regular_season': 'Regular season',
+    'server.tournament.label.stage.round_robin': 'Round robin',
+    'server.tournament.label.stage.swiss': 'Swiss',
+    'server.tournament.label.step': 'Step {number}',
+    'server.tournament.label.third_place': 'Third place match',
+    'server.tournament.label.tie': '{round}, tie {number}',
+    'server.tournament.label.title': '{tournament}, {match}, {home} against {away}',
+    'server.tournament.label.tournament': 'Tournament',
+    'server.tournament.label.winner_of': 'Winner of {match}',
+    'server.tournament.label.winners_final': 'Winners final',
+    'server.tournament.label.winners_round': 'Winners round {number}',
+    'server.tournament.legs_cancelled': 'a cancelled tournament takes no more legs',
+    'server.tournament.legs_format': (
+        'expected the last stage, {where}, to be a league or groups to take more legs'
+    ),
+    'server.tournament.legs_most': 'the last stage, {where}, already plays the most legs, {most}',
+    'server.tournament.length': (
+        'expected a length from {lowest} to {highest} steps, found {length}'
+    ),
+    'server.tournament.limit': 'expected {name} from {lowest} to {highest}, found {value}',
+    'server.tournament.list': 'expected {name} as a list without repeats, found {value}',
+    'server.tournament.match_failed': '{label} failed, {error}',
+    'server.tournament.match_failed_more': {
+        'one': '{label} failed, {error}, and {count} more match failed',
+        'other': '{label} failed, {error}, and {count} more matches failed',
+    },
+    'server.tournament.match_failed_one_more': '{label} failed, {error}, and 1 more match failed',
+    'server.tournament.match_key': 'expected a match of the tournament still to play, found {key}',
+    'server.tournament.mixed_sizes': (
+        '{five} is a team of 5v5 and {eleven} a team of 11v11, and {scenario} of stage {stage} '
+        'fits one size alone, so enter teams of one size or choose {fitting}, which fits both '
+        'sizes and the players each team controls'
+    ),
+    'server.tournament.mixed_sizes_none': (
+        '{five} is a team of 5v5 and {eleven} a team of 11v11, and {scenario} of stage {stage} '
+        'fits one size alone, and no scenario fits both sizes and the players each team '
+        'controls, so enter teams of one size'
+    ),
+    'server.tournament.name_taken': (
+        'expected a name of its own for entrant {entrant}, '
+        'found {name}, the name of entrant {other}'
+    ),
+    'server.tournament.no_frame': 'the recording {identifier} holds no frame',
+    'server.tournament.no_replay': 'the match {key} kept no seed and actions to replay',
+    'server.tournament.no_result': 'the match gave no result',
+    'server.tournament.note.early': (
+        'The game ended before full time, so the match waits to be played again.'
+    ),
+    'server.tournament.note.failed': (
+        'The game stopped, {error}. Award the match to either side, or play it again.'
+    ),
+    'server.tournament.note.gone': 'The game of this match ended without a result.',
+    'server.tournament.note.unreadable': 'The result could not be read, {error}',
+    'server.tournament.object': 'expected the tournament as an object',
+    'server.tournament.other_process': 'the tournament belongs to another process',
+    'server.tournament.other_process_change': (
+        'the tournament runs in another process, {owner}, which can change it'
+    ),
+    'server.tournament.other_process_runs': 'the tournament runs in another process, {owner}',
+    'server.tournament.other_process_silent': (
+        'the process {owner} that runs the tournament did not answer, send the change to its '
+        'server as {route}'
+    ),
+    'server.tournament.people_page': 'the matches of people play on the page of the server',
+    'server.tournament.person_match': 'expected a match of a person',
+    'server.tournament.person_names': 'expected a name for each person',
+    'server.tournament.playing': 'the match is playing now',
+    'server.tournament.points': (
+        'expected points for a win, draw and loss in {where}, found {points}'
+    ),
+    'server.tournament.preflight': 'expected the pre-flight as true or false, found {value}',
+    'server.tournament.preset': 'expected a preset from {presets}, found {name}',
+    'server.tournament.preset_name': (
+        'expected a preset name of small letters, digits, dashes and underscores that names no '
+        'shipped preset, found {name}'
+    ),
+    'server.tournament.preset_object': 'expected a preset as an object',
+    'server.tournament.preset_settings': 'the preset has unknown settings {settings}',
+    'server.tournament.qualifiers': (
+        'expected the qualifiers of stage {stage} as a count or one count a group'
+    ),
+    'server.tournament.rating': 'expected a rating from 0 to 10000, found {rating}',
+    'server.tournament.recording': 'expected the recording of a result as text, found {match}',
+    'server.tournament.refused': 'the process that runs it refused the change',
+    'server.tournament.result': 'expected a result with a score, found {result}',
+    'server.tournament.running': 'expected a running tournament, found it {state}',
+    'server.tournament.score': 'expected a score of two counts, found {score}',
+    'server.tournament.settings': 'the tournament has unknown settings {settings}',
+    'server.tournament.stage_ability': 'expected the ability of {where} from 0 to 1',
+    'server.tournament.stage_entrants': {
+        '=0': '{where} needs at least 2 entrants, and none reaches it',
+        'one': '{where} needs at least 2 entrants, and {count} reaches it',
+        'other': '{where} needs at least 2 entrants, and {count} reach it',
+    },
+    'server.tournament.stage_name': 'expected the name of {where} as text',
+    'server.tournament.stage_object': 'expected stage {stage} as an object, found {value}',
+    'server.tournament.stage_scenario': (
+        'expected a shipped scenario for stage {stage}, found {scenario}'
+    ),
+    'server.tournament.stage_settings': 'stage {stage} has unknown settings {settings}',
+    'server.tournament.stages': 'expected from 1 to {most} stages',
+    'server.tournament.standard_ability': (
+        'expected the standard ability from 0 to 1, found {ability}'
+    ),
+    'server.tournament.stopped': 'expected a stopped tournament, found it {state}',
+    'server.tournament.strict': (
+        'expected strict rules as true, false or an object of limits, found {value}'
+    ),
+    'server.tournament.strict_settings': (
+        'expected limits of strict rules among threads, load_seconds, first_call_seconds, '
+        'call_seconds, reset_seconds, mean_call_ms, folder_mb, memory_mb, match_seconds, '
+        'frozen, gpu and deterministic, found {settings}'
+    ),
+    'server.tournament.swiss': 'no Swiss pairing without a rematch exists for this round',
+    'server.tournament.team_format': 'it is a team of {format}',
+    'server.tournament.teammates': 'expected registered teammates, found {mates}',
+    'server.tournament.text': 'expected {name} as text, found {value}',
+    'server.tournament.text_length': 'expected {name} of 1 to {most} characters, found {value}',
+    'server.tournament.unknown': 'no such tournament',
+    'server.tournament.unknown_identifier': 'expected a tournament, found {identifier}',
+    'server.tournament.waiting': 'waiting for cuju render tournament run',
+    'server.tournament.watched': 'expected the watched matches as a list of up to 10000 keys',
+    'server.tournament.where': 'stage {number}',
+    'server.tournament.winner': 'expected the winning side as home or away, found {side}',
+    'server.trash.unknown': 'no such recording in the Trash',
+    'server.tutorial.done': 'expected done as a list of lessons from {known}, found {done}',
+    'server.tutorial.lesson': 'expected a lesson from {lessons}, found {identifier}',
+    'server.tutorial.unknown': 'expected lessons from {known}, found {unknown}',
+    'server.unexpected': 'the server **failed** unexpectedly, {error}',
+    'server.video.annotations': 'expected annotations as true or false, found {annotations}',
+    'server.video.arena': 'expected an arena of {arenas}, found {arena}',
+    'server.video.busy': 'an export already runs, wait for it or cancel it',
+    'server.video.camera': 'expected a camera of {cameras}, found {camera}',
+    'server.video.cdp_closed': '`Chrome` closed the debugging connection',
+    'server.video.cdp_method': '`Chrome` could not run {method}, {error}',
+    'server.video.cdp_refused': '`Chrome` refused the debugging connection, {header}',
+    'server.video.cdp_start': '`Chrome` closed the debugging connection at its start',
+    'server.video.chrome_exit': (
+        '`Chrome` stopped at its start with exit code {code}. `Chrome` in some containers needs '
+        '`--no-sandbox`.'
+    ),
+    'server.video.chrome_page': '`Chrome` opened no page',
+    'server.video.chrome_port': '`Chrome` did not open its debugging port within {seconds} s',
+    'server.video.empty_range': (
+        'expected a range that holds frames, the recording runs from 0 to {duration} seconds, '
+        'found {start} to {end}'
+    ),
+    'server.video.exit': 'the export ended with exit code {code}',
+    'server.video.exit_detail': 'the export ended with exit code {code}, {detail}',
+    'server.video.ffmpeg_exit': '`ffmpeg` failed with exit code {code}, {detail}',
+    'server.video.ffmpeg_stopped': '`ffmpeg` stopped while encoding, {detail}',
+    'server.video.fields': 'expected the fields {known}, found {unknown}',
+    'server.video.goal': 'expected a goal number from 1, found {goal}',
+    'server.video.goal_range': {
+        '=0': 'expected a goal, found none in the recording, asked for goal {goal}',
+        'one': 'expected goal 1, the only goal of the recording, found goal {goal}',
+        'other': 'expected a goal from 1 to {count}, found goal {goal}',
+    },
+    'server.video.hour': 'expected an hour from 0 to 24, found {hour}',
+    'server.video.length': 'expected at most {most} seconds of video, found {length} seconds',
+    'server.video.max_length': (
+        'expected at most {most} seconds of video, the range from {start} to {end} runs {length} '
+        'seconds, so choose a shorter range or raise the maximum length'
+    ),
+    'server.video.max_megabytes': 'expected a maximum size from 1 to {most} MB, found {value}',
+    'server.video.max_seconds': (
+        'expected a maximum length above 0 and up to {most} seconds, found {value}'
+    ),
+    'server.video.max_size': (
+        'the video reached its **maximum size** of {most} MB, so choose a shorter range or raise '
+        'the maximum size'
+    ),
+    'server.video.missing_both': '{chrome} {ffmpeg}',
+    'server.video.missing_chrome': (
+        'Video export needs `Chrome` or `Chromium`, found neither. Install `Google Chrome` or '
+        '`Chromium`, from https://www.google.com/chrome/ or with the package manager, such as '
+        '`apt install chromium`, or name the program with `$CUJU_CHROME` in the environment of '
+        '`cuju render serve`, then **restart** the server.'
+    ),
+    'server.video.missing_chrome_command': (
+        'Video export needs `Chrome` or `Chromium`, found neither. Install `Google Chrome` or '
+        '`Chromium`, from https://www.google.com/chrome/ or with the package manager, such as '
+        '`apt install chromium`, or name the program with `--chrome` or `$CUJU_CHROME`.'
+    ),
+    'server.video.missing_ffmpeg': (
+        'Video export needs `ffmpeg`, found none. Install `ffmpeg`, from '
+        'https://ffmpeg.org/download.html or with the package manager, such as '
+        '`apt install ffmpeg`, `brew install ffmpeg` or `winget install ffmpeg`, or name the '
+        'program with `$CUJU_FFMPEG` in the environment of `cuju render serve`, then **restart** '
+        'the server.'
+    ),
+    'server.video.missing_ffmpeg_command': (
+        'Video export needs `ffmpeg`, found none. Install `ffmpeg`, from '
+        'https://ffmpeg.org/download.html or with the package manager, such as '
+        '`apt install ffmpeg`, `brew install ffmpeg` or `winget install ffmpeg`, or name the '
+        'program with `--ffmpeg` or `$CUJU_FFMPEG`.'
+    ),
+    'server.video.no_frames': '{path} holds no frames',
+    'server.video.output': 'expected an output file ending in `.mp4` or `.webm`, found {name}',
+    'server.video.output_format': (
+        'expected an output file ending in `{suffix}` for the format {format}, found {name}'
+    ),
+    'server.video.format': 'expected a format of {formats}, found {format}',
+    'server.video.no_h264': (
+        'expected a browser that encodes H.264 for an MP4, found none in {browser}, so use `Google '
+        'Chrome` or `Edge`, or install `ffmpeg`, which then encodes the MP4'
+    ),
+    'server.video.no_h264_webm': (
+        'expected a browser that encodes H.264 for an MP4, found none in {browser}, so use `Google '
+        'Chrome` or `Edge`, ask for WebM with `--format webm`, or install `ffmpeg`, which then '
+        'encodes the MP4'
+    ),
+    'server.video.no_webm': (
+        'expected a browser that encodes VP9 or VP8 for a WebM, found none in {browser}, so update '
+        'it or use `Google Chrome` or `Edge`'
+    ),
+    'server.video.no_encoder': (
+        'expected a browser that encodes video, found none in {browser}, so update it or use '
+        '`Google Chrome` or `Edge`, or install `ffmpeg`, which then encodes an MP4'
+    ),
+    'server.video.host': 'the page of the export did not load within {seconds} s',
+    'server.video.host_errors': 'the page of the export did not load within {seconds} s, {errors}',
+    'server.video.encoder': "the browser's video encoder stopped, {error}",
+    'server.video.codec': (
+        'expected a browser that encodes the format asked for, found none at this size'
+    ),
+    'server.video.lost': 'the browser lost the finished video before it was saved',
+    'server.video.bytes': 'expected {size} bytes of video from the browser, found {found}',
+    'server.video.page_draw': 'the page cannot draw in this `Chrome`, {error}',
+    'server.video.page_failed': 'the page failed, {error}',
+    'server.video.page_ready': 'the page did not open the recording within {seconds} s',
+    'server.video.page_ready_errors': (
+        'the page did not open the recording within {seconds} s, {errors}'
+    ),
+    'server.video.program': 'expected a program at {given}, found none',
+    'server.video.quality': 'expected a quality of {qualities}, found {quality}',
+    'server.video.range': 'expected an end after the start, found {start} to {end}',
+    'server.video.rate': (
+        'expected a frame rate of whole frames a second from 1 to {most}, found {fps}'
+    ),
+    'server.video.safe': 'expected the safe area as text or a percentage, found {safe}',
+    'server.video.scale': 'expected the scale of the graphics as a number, found {graphics}',
+    'server.video.score': 'expected score as true or false, found {score}',
+    'server.video.seconds': 'expected {name} as seconds from 0, found {value}',
+    'server.video.source': (
+        'expected a `.cjr` file or the identifier of a recording of the library, found {source}'
+    ),
+    'server.video.unknown': 'no such video',
+    'server.video.unknown_match': 'expected a recording of the library, found {match}',
+    'server.video.unreadable': '{path} is not a readable recording, {error}',
+}
+
+
+def text(message_id: str, /, **values: Any) -> str:
+    """Returns the English text of a message with its placeholders filled from `values`.
+
+    A value is text, or a label that `label` returns, which reads as its English text.
+
+    Raises:
+        KeyError: If the id is unknown, or a placeholder of its template has no value.
+    """
+    template = plain(form(MESSAGES[message_id], values.get('count')))
+    return _PLACEHOLDER.sub(lambda match: _shown(values[match.group(1)]), template)
+
+
+def plain(template: str) -> str:
+    """Returns a template without its marks, the words of **strong** and `code` as they are."""
+    return _MARK.sub(lambda match: match.group(1) or match.group(2) or '', template)
+
+
+def form(template: str | dict[str, str], count: Any) -> str:
+    """Returns the English form of a template for a count, as the page picks it.
+
+    A plain template is its own form. A plural one takes the form of the exact count, such as
+    `=0`, else `one` for a count of 1 written without decimals, else `other`.
+    """
+    if isinstance(template, str):
+        return template
+    shown = _shown(count).strip() if count is not None else ''
+    if f'={shown}' in template:
+        return template[f'={shown}']
+    return template['one'] if shown == '1' and 'one' in template else template['other']
+
+
+def counted(count: Any, one: str, other: str | None = None) -> str:
+    """Returns a count with its noun in English, as `1 recording` or `2 recordings`.
+
+    Args:
+        count: The number, which reads as one only when it is 1 without decimals.
+        one: The noun for one.
+        other: The noun for any other count, by default `one` with an s.
+    """
+    shown = f'{count:g}' if isinstance(count, float) else str(count)
+    return f'{shown} {one if shown == "1" else (other or one + "s")}'
+
+
+def _shown(value: Any) -> str:
+    """Returns the English text of a value of a message, a label or anything else as text."""
+    if isinstance(value, dict) and isinstance(value.get('text'), str):
+        return value['text']
+    return str(value)
+
+
+def _value(value: Any) -> Any:
+    """Returns a value of a message as it travels, a label as it is and anything else as text."""
+    if isinstance(value, dict) and isinstance(value.get('text'), str):
+        return value
+    return str(value)
+
+
+def label(message_id: str, /, **values: Any) -> dict[str, Any]:
+    """Returns a name or a label that cuju makes, such as a round or the built-in AI, as data.
+
+    The label holds the message `id`, its English `text` and its `values`, so the page shows it
+    in its own language while the command line and the files read the English text. A value may
+    itself be a label, such as the name of an entrant inside the title of a match.
+
+    Raises:
+        KeyError: If the id is unknown, or a placeholder of its template has no value.
+    """
+    kept = {key: _value(value) for key, value in values.items()}
+    return {'id': message_id, 'text': text(message_id, **kept), 'values': kept}
+
+
+def scenario(name: str) -> dict[str, Any]:
+    """Returns a scenario as a value of a message, which the page shows by its name there."""
+    return {'kind': 'scenario', 'name': str(name), 'text': str(name)}
+
+
+def named(field: str, value: dict[str, Any] | str | None) -> dict[str, Any]:
+    """Returns the fields of a name in an answer, `field` with its English text and, for a label,
+    `field_id` and `field_values` beside it, as the page's `serverText` reads them.
+
+    A name that a person gave is text and travels alone.
+    """
+    if isinstance(value, dict) and isinstance(value.get('text'), str):
+        return {
+            field: value['text'],
+            f'{field}_id': value.get('id'),
+            f'{field}_values': dict(value.get('values') or {}),
+        }
+    return {field: value}
+
+
+# The kinds of value that the page shows by a name of its own, a scenario and a challenge.
+_KINDS = ('scenario', 'challenge')
+
+
+def valid_label(value: Any) -> bool:
+    """Returns whether a stored value is a label of a known message, its values text or labels."""
+    if not isinstance(value, dict) or not isinstance(value.get('text'), str):
+        return False
+    if 'kind' in value:
+        return value['kind'] in _KINDS and isinstance(value.get('name'), str)
+    values = value.get('values')
+    return (
+        value.get('id') in MESSAGES
+        and isinstance(values, dict)
+        and all(isinstance(item, str) or valid_label(item) for item in values.values())
+        and placeholders(MESSAGES[value['id']]) <= set(values)
+    )
+
+
+def placeholders(template: Any) -> set[str]:
+    """Returns the names of the placeholders of a template, of every form of a plural one."""
+    if isinstance(template, dict):
+        return {name for text in template.values() for name in _PLACEHOLDER.findall(str(text))}
+    return set(_PLACEHOLDER.findall(template)) if isinstance(template, str) else set()
+
+
+# The classes that only add the id of a message to another exception, by the module and name
+# they were defined with.
+_WRAPPERS: dict[tuple[str, str], type] = {}
+
+
+def _stamp(cls: type) -> None:
+    """Gives a class that only adds an id the module and name of the exception it stands for."""
+    for base in cls.__mro__[1:]:
+        if base is Message or base.__dict__.get('_wrapper'):
+            continue
+        cls.__module__, cls.__qualname__, cls.__name__ = (
+            base.__module__,
+            base.__qualname__,
+            base.__name__,
+        )
+        return
+
+
+def public_names() -> None:
+    """Stamps every class that only adds an id again, after the public classes took their module.
+
+    `cuju.render` gives its public errors its own name as their module once it has imported
+    them, so a class defined before then takes the public name here.
+    """
+    for cls in _WRAPPERS.values():
+        _stamp(cls)
+
+
+def _rebuild(defined: tuple[str, str], message_id: str, values: dict[str, Any]) -> BaseException:
+    """Returns the exception that `Message.__reduce__` pickled, of the class it was defined as."""
+    module, name = defined
+    importlib.import_module(module)
+    cls = _WRAPPERS.get(defined) or getattr(sys.modules[module], name)
+    return cls(message_id, **values)
+
+
+class Message:
+    """A mixin of exceptions whose text is a message of `MESSAGES`.
+
+    The exception reads as the English text, and carries the id in `message_id` and the values of
+    its placeholders, each as text, in `values`. A class that only adds the id to another
+    exception, which sets `_wrapper`, reads as that exception in a traceback and in its `repr`,
+    such as `cuju.errors.ArgumentError`, and an `except` of either class catches it.
+    """
+
+    # A class that only adds the id to another exception names that exception in an answer.
+    _wrapper = True
+    message_id: str
+    values: dict[str, str]
+
+    def __init_subclass__(cls, **options: Any) -> None:
+        super().__init_subclass__(**options)
+        if cls.__dict__.get('_wrapper'):
+            cls._defined = (cls.__module__, cls.__qualname__)
+            _WRAPPERS[cls._defined] = cls
+            _stamp(cls)
+
+    def __init__(self, message_id: str, /, **values: Any) -> None:
+        self.message_id = message_id
+        self.values = {key: _value(value) for key, value in values.items()}
+        super().__init__(text(message_id, **self.values))
+
+    def __reduce__(self) -> Any:
+        cls = type(self)
+        defined = cls.__dict__.get('_defined') or (cls.__module__, cls.__qualname__)
+        return (_rebuild, (defined, self.message_id, self.values))
+
+
+class MessageError(Message, ArgumentError):
+    """An `ArgumentError` whose text is a message of `MESSAGES`, which the page translates."""
+
+    _wrapper = True
+
+
+def argument_error(error: BaseException) -> ArgumentError:
+    """Returns an `ArgumentError` with the text of `error`, and its id when it carries one."""
+    message_id = getattr(error, 'message_id', None)
+    if isinstance(message_id, str) and message_id in MESSAGES:
+        return MessageError(message_id, **getattr(error, 'values', {}))
+    return ArgumentError(str(error))
+
+
+def kind(error: BaseException) -> str:
+    """Returns the name of the exception that an answer shows, without the classes of ids.
+
+    A `MessageError` reads as the `ArgumentError` it stands for, so an answer of the form
+    `ArgumentError: ...` reads as before.
+    """
+    for cls in type(error).__mro__:
+        if cls is Message or cls.__dict__.get('_wrapper'):
+            continue
+        return cls.__name__
+    return type(error).__name__
+
+
+def described(error: BaseException) -> str:
+    """Returns the text `Kind: message` of an error, as answers and reports show it."""
+    return f'{kind(error)}: {error}'
+
+
+def fields(message_id: str, /, **values: Any) -> dict[str, Any]:
+    """Returns the error fields of an answer or an entry for a message of `MESSAGES`."""
+    shown = {key: _value(value) for key, value in values.items()}
+    return {'error': text(message_id, **shown), 'error_id': message_id, 'error_values': shown}
+
+
+def error_fields(error: BaseException, shown: str | None = None) -> dict[str, Any]:
+    """Returns the error fields for an exception, with its id when it carries one.
+
+    Args:
+        error: The exception.
+        shown: The text of the answer, by default `str(error)`.
+    """
+    result: dict[str, Any] = {'error': str(error) if shown is None else shown}
+    message_id = getattr(error, 'message_id', None)
+    if isinstance(message_id, str) and message_id in MESSAGES:
+        result['error_id'] = message_id
+        result['error_values'] = dict(getattr(error, 'values', {}) or {})
+    return result
+
+
+def id_fields(error: BaseException) -> dict[str, Any]:
+    """Returns `error_id` and `error_values` of an exception that carries an id, else nothing."""
+    found = error_fields(error)
+    found.pop('error')
+    return found
+
+
+def entry_fields(error: BaseException | str | None, shown: str | None = None) -> dict[str, Any]:
+    """Returns the error fields of an entry, always all three, `None` where it has none.
+
+    Args:
+        error: The exception, or a text without an id, or `None` for no error.
+        shown: The text that the entry shows for an exception, by default `str(error)`.
+    """
+    result: dict[str, Any] = {'error': None, 'error_id': None, 'error_values': None}
+    if isinstance(error, BaseException):
+        result.update(error_fields(error, shown))
+    elif error is not None:
+        result['error'] = error
+    return result
+
+
+def exit_fields(message_id: str, code: Any, detail: str = '') -> dict[str, Any]:
+    """Returns the error fields of a child process that ended with `code`.
+
+    The message `message_id` names the exit code, and `message_id` with `_detail` added names the
+    last lines that the process wrote as well, when it wrote any.
+    """
+    if detail:
+        return fields(f'{message_id}_detail', code=code, detail=detail)
+    return fields(message_id, code=code)
+
+
+def report_fields(report: dict[str, Any]) -> dict[str, Any]:
+    """Returns the error fields of an entry from the report of a child process.
+
+    The id and values pass on only when they name a message of `MESSAGES` with a text value for
+    each of its placeholders, so a report of another version leaves its error without an id.
+    """
+    error = report.get('error')
+    result: dict[str, Any] = {
+        'error': error if isinstance(error, str) else None,
+        'error_id': None,
+        'error_values': None,
+    }
+    message_id, values = report.get('error_id'), report.get('error_values')
+    if (
+        isinstance(error, str)
+        and isinstance(message_id, str)
+        and message_id in MESSAGES
+        and isinstance(values, dict)
+        and all(isinstance(value, str) or valid_label(value) for value in values.values())
+        and placeholders(MESSAGES[message_id]) <= set(values)
+    ):
+        result.update(error_id=message_id, error_values=dict(values))
+    return result
+
+
+def compare(messages: dict[str, Any]) -> list[str]:
+    """Returns the differences between `MESSAGES` and the `server.` messages of a language file.
+
+    Args:
+        messages: The messages of a language file, such as the parsed `web/languages/en.json`.
+            For English each text must equal the registry's, and for another language each
+            message must hold the same placeholders.
+
+    Returns:
+        One line for each id missing from either side, each text that differs from the English,
+        and each placeholder that differs, empty when they agree.
+    """
+    english = messages.get('@language', {}).get('code', 'en') == 'en'
+    found = {key: value for key, value in messages.items() if key.startswith('server.')}
+    # A translation may lack messages, which the page then shows in English.
+    problems = [f'missing {key}' for key in MESSAGES if key not in found and english]
+    problems += [f'unknown {key}' for key in found if key not in MESSAGES]
+    for key, template in MESSAGES.items():
+        if key not in found:
+            continue
+        value = found[key]
+        plural = isinstance(value, dict) and all(isinstance(text, str) for text in value.values())
+        if not isinstance(value, str) and not plural:
+            problems.append(f'{key} is not a text or an object of plural forms')
+        elif isinstance(template, str) and plural and 'count' not in placeholders(template):
+            problems.append(f'{key} has plural forms, and the registry has no count')
+        elif english and value != template:
+            problems.append(f'{key} reads {value!r}, the registry {template!r}')
+        elif placeholders(value) != placeholders(template):
+            problems.append(f'{key} has the placeholders {sorted(placeholders(value))}')
+    return problems