@PlainText.RenderSubmit(Answer, Catalogue.IsMeasured)
@PlainText.RenderSubmit(Answer, Catalogue.IsMeasured, Tag)
@SubmitCopy.Lede
@SubmitCopy.Lede(Tag)
@answer.Sentence
@link.Label
@SubmitCopy.NoCatalogue
@SubmitCopy.NoCatalogue(Tag)
plain text
@L("a11y.plainText")
@Series.Sentence
days in UTC · @Series.From.ToString("d MMM yyyy") – @Series.To.ToString("d MMM yyyy")
@Sentence
@L("trend.range", ("from", Series.From), ("to", Series.To))
Nothing counted in this range.
@L("trend.empty")
is + // what the server sent and is not a string in any bundle. "read as" rather than "encoded + // in", because that is the honest verb — it is what we decoded the bytes with, and a game + // that declares one encoding and sends another makes those two different sentences. + ["ansi.suppressed"] = "The owner asked us not to republish this game's connect screen.", + ["ansi.absent"] = "No connect screen has been captured from this game.", + ["ansi.tooSmall"] = "{count, plural, one {Only # row came back — too little to show.} other {Only # rows came back — too little to show.}}", + ["ansi.asSent"] = "as sent by the server", + ["ansi.size"] = "{columns}×{rows}", + ["ansi.size.doubleWidth"] = "{columns}×{rows}, double-width", + ["ansi.depth.colour"] = "16-colour SGR", + ["ansi.depth.plain"] = "no colour", + ["ansi.readAs"] = "read as {charset}", + ["ansi.captured"] = "captured", + ["ansi.frozen"] = "frozen — the last screen we saw", + ["ansi.alt.named"] = "ASCII art: the connect screen of {game}. Its text is under \"read as text\", below.", + ["ansi.alt"] = "ASCII art: this game's connect screen. Its text is under \"read as text\", below.", + ["ansi.plain.rows"] = "{count, plural, one {connect screen: # line, text only} other {connect screen: # lines, text only}}", + ["ansi.plain.rows.readAs"] = "{count, plural, one {connect screen: # line, text only, read as {charset}} other {connect screen: # lines, text only, read as {charset}}}", + + // ── the capability matrix's disagreements, said in prose ────────────────────────────── + ["capability.disagree.declaredNotOffered"] = "the game declares it, and the server has never offered it in a handshake.", + ["capability.disagree.offeredNotDeclared"] = "the server offers it, and the game's own record says it does not.", + ["capability.disagree.note"] = "Usually a stale hand-typed field, not a lie. Shown because a client should not rely on what the two disagree about.", + + // ── the rest of the game page ───────────────────────────────────────────────────────── + ["game.notFound"] = "Not found", + ["game.notFound.hint"] = "No game at this address. Check the spelling.", + ["game.endpoint.lastAnswered"] = "last answered", + ["game.stale"] = "{count, plural, one {# is past its refresh window. Old, not wrong.} other {# are past their refresh window. Old, not wrong.}}", + ["game.referrals.lists"] = "This game's own referral list names:", + ["game.referrals.listedBy"] = "Named by the referral list of:", + ["game.referral.since"] = "since {date}", + ["game.referral.dropped"] = "no longer listed, last seen", + + // The archive plate. "Still probed" is the promise §7.5 makes and the reason the page is + // still here at all, so it is said rather than implied by the page continuing to exist. + ["game.archived.lastAnswered"] = "Last answered {date}, {ago} ago.", + ["game.archived.stillProbed"] = "Still probed weekly; this page updates the day it answers.", + ["game.archived.knownLive"] = "{span} known live", + + // The two ways out of the listing that are not archiving. They say different things because + // the decisions are different: an exclusion is OURS and has to be arguable, so it prints the + // argument; an unlisting is THEIRS, so it prints no reason at all. + ["game.excluded"] = "Not in the listing, the rankings or the daily figure: we do not think this address is a game somebody can play. Everything below is what it told us, unchanged.", + ["game.excluded.reason"] = "Our reason: {why}", + ["game.unlisted"] = "Not in the listing, the rankings or the daily figure, at the request of the people who run it. Everything below is preserved as it was, this page and every address it has ever had go on answering, and we are not dialling it.", + + // ── the plain surface's own headings for this page ──────────────────────────────────── + ["game.plain.playersNow"] = "Players now: {count}", + // The graphical caption pluralises this and the plain one did not, so one surface said "1 of + // 6 disagrees" and its own mirror said "1 of 6 disagree" about the same six rows. + ["game.plain.capabilities"] = "Capabilities ({disagreeing, plural, one {# of {total} disagrees} other {# of {total} disagree}})", + ["game.plain.declared"] = "Declared by the game", + ["game.plain.connectScreen"] = "Connect screen", + ["game.plain.whatChanged"] = "What changed", + ["game.plain.measured"] = "measured", + ["game.plain.declared.column"] = "declared", + ["game.plain.disagree"] = "** disagree", + + // ══ appended block: the listing row's own labels and the last three chips ══════════════ + // + // The two column heads, repeated per row for assistive technology only. The visible head is + // said once over the column and stays `aria-hidden`, because a reader who can see it does + // not need it five hundred times; a reader who cannot see it has no column at all, and a + // bare "12" and "2h ago" name neither the count nor the age. Two ids rather than splitting + // `listing.columns` on its separator: a locale is free to order or punctuate that head + // however it reads best, and a split would make the row's labels a function of its + // typography. + ["listing.row.connected"] = "connected", + ["listing.row.reached"] = "reached", + + // The chips the active-filter row builds itself rather than reading off a facet group. + // They are the last three that were still English on a translated page: two are questions + // the query asks that no facet answers, and "included" is the only chip value that is a + // state of ours rather than a token a game gave us. + ["facet.group.search"] = "search", + ["facet.group.archived"] = "archived", + ["facet.group.adult"] = "adult", + ["facet.value.included"] = "included", + + // ── added by the accessibility review, second pass ──────────────────────────────────── + // Kept in one block at the end because several agents are appending to this file at once. + + // The game page's live figure when there is no count to put in it — rule 2's third state on + // the hero rather than on a heatmap cell. + // + // `PlayersNow` is null for an hour nobody measured, for a probe that answered with nothing + // countable, and for a count older than the window this figure covers: one null over three + // situations the page cannot tell apart. It said `state.notCounted`, which the glossary + // reserves for an unreadable count — so a game we have never once reached was described as + // one we probed and failed to count, which is our silence published as their measurement. + // What is left is the absence itself, naming no cause. + ["game.count.none"] = "no count", + ["game.count.none.why"] = "no current count, and nothing here says why", + ["game.plain.playersNoCount"] = "Players now: no count (nothing here says why)", + + // ══ appended: the last surfaces that were still English on a localized page ═══════════ + // + // Three gaps, found after the sweep that walked visible text and title/aria-label/ + // placeholder — none of which reaches a element or a mirror. + // + // ── the crawler strip, whose sentence was English around a localized age ────────────── + // The age used to be the only localized part, so a German reader met "crawler live · last + // probe 4m" — one German fragment inside an English line, on the one strip whose whole job + // is to let a reader discount every number above it. The age comes in as an argument + // because the ladder that builds it already localizes, and because a language that puts + // the age first has nowhere to say so if the two are concatenated. + ["crawler.live"] = "crawler live · last probe {age}", + ["crawler.quiet"] = "crawler quiet · last probe {age}", + ["crawler.noProbe"] = "no probe has finished here yet", + + // Three counters, each agreeing with its own number. English inflects none of them and + // several languages inflect all three, which is exactly the case a concatenation cannot be + // translated out of. + ["crawler.cycle.nothingDue"] = "nothing due this cycle", + ["crawler.cycle"] = "{considered, plural, one {# due} other {# due}}" + + " · {answered, plural, one {# answered} other {# answered}}" + + " · {failed, plural, one {# failed} other {# failed}}", + ["crawler.registry"] = "{targets, plural, one {# address in the registry} other {# addresses in the registry}}" + + ", {due, plural, one {# due now} other {# due now}}", + + // ── what this site says about itself where it is not this site ──────────────────────── + // The , the meta description and the Open Graph tags. A German page advertised + // itself in English to a reader, a search engine and every link preview — the three places + // a reader has least ability to check what they were told, and the one surface the demo + // banner cannot follow a link into. + // + // The wordmark is not here. "mu*index" is the site's name, machine voice like a hostname or + // a codebase string, so it arrives as {site} rather than as text a translator could edit. + ["preview.documentTitle"] = "{page} — {site}", + ["preview.site"] = "A directory of the MU* hobby — MUSHes, MUDs, MUCKs, MOOs — where every " + + "fact carries how it was obtained and how old it is.", + ["preview.demo"] = "Demo data — nothing here was measured. {description}", + ["preview.cardAlt"] = "{site} — measured, not asserted", + ["preview.cardAlt.named"] = "{title} on {site}", + + // One id per page, title and description apart: a title is a noun phrase and a description + // is a sentence, and a language that declines the first differently from the second has + // nowhere to stand if they share an id. + ["preview.title.games"] = "Games", + ["preview.title.archive"] = "The archive", + ["preview.title.rankings"] = "Rankings", + ["preview.title.ecosystem"] = "The ecosystem", + ["preview.title.reference"] = "Reference", + ["preview.title.about"] = "About", + ["preview.title.notFound"] = "Not found", + ["preview.title.random"] = "Random game", + ["preview.title.account"] = "Your games", + ["preview.title.claim"] = "Claim {game}", + + ["preview.desc.games"] = "Every MU* we have reached, faceted on what we measured: codebase, " + + "the protocols a server offered in the handshake, TLS, charset, language, and when we " + + "last got in.", + ["preview.desc.archive"] = "The games that went dark, kept. Each keeps its page, history and " + + "URL, is still probed weekly, and returns to the listing on one successful connection.", + ["preview.desc.rankings"] = "Busiest, most reachable, longest running — computed from " + + "measurements only. No votes, stars or ratings anywhere on this site.", + ["preview.desc.ecosystem"] = "Codebase share and protocol adoption across the games we " + + "measure, with what servers offer set beside what they declare. Shares, never totals.", + ["preview.desc.reference"] = "Hand-written pages on the codebases, clients and protocols of " + + "the MU* hobby, cross-linked to counts taken from the crawl.", + ["preview.desc.about"] = "How this catalogue is built: what the crawler does, what it refuses " + + "to do, and how to make it stop.", + ["preview.desc.notFound"] = "No game at this address. Nothing here is ever deleted, so a game " + + "that once lived at this URL still does — check the spelling.", + ["preview.desc.random"] = "One game from the catalogue, chosen at random and never the same " + + "one twice.", + ["preview.desc.account"] = "The listings you have claimed, and what a claim lets you change.", + ["preview.desc.claim"] = "Prove you run this game by publishing a token where only its " + + "operator could put it.", + + // A game's own preview. The name, the host and the port stay machine voice; everything the + // site says *about* them is here. The unknown count is a sentence and never a zero (rule 4), + // and the archived plate says "still probed" because that is §7.5's promise. + ["preview.game.archived"] = "Archived — last reachable {age}, and still probed", + ["preview.game.archived.undated"] = "Archived, and still probed", + ["preview.game.countUnknown"] = "Player count unknown — the game answers, and publishes no " + + "number we can read", + ["preview.game.count"] = "{count, plural, one {# player} other {# players}}, {how} {age}", + + // ── the plain mirror's feed headings and home counts ────────────────────────────────── + // Uppercased at the call site like every other plain heading, so the id carries the words + // and not the casing — a locale whose script has no case gets the words unharmed. + // The empty states are not here: feed.nothingNew and its two siblings already exist and are + // already translated, and the graphical cards and this mirror say the same sentence. + ["feed.plain.newlyDiscovered"] = "Newly discovered", + ["feed.plain.wentDark"] = "Went dark", + ["feed.plain.cameBack"] = "Came back", + + // The four figures the front page tiles carry, as whole sentences rather than a number + // glued to a tile label — the mirror has no tiles to put a label beside. English inflects + // only the first; the other three carry both branches anyway, because a language that + // inflects them has nowhere else to say so. + ["home.plain.known"] = "{count, plural, one {# game known} other {# games known}}", + ["home.plain.connectedNow"] = "{count, plural, one {# connected now (measured)} other {# connected now (measured)}}", + ["home.plain.uncounted"] = "{count, plural, one {# answering, uncounted} other {# answering, uncounted}}", + ["home.plain.archived"] = "{count, plural, one {# archived, still probed} other {# archived, still probed}}", + + // ── THE REFERENCE SECTION'S CHROME ──────────────────────────────────────────────────── + // ═════════════════════════════════════════════════════════════════════════════════════ + // + // Appended as one marked block on purpose: another surface is appending to this file at the + // same time, and a block at the end is a merge that adds rather than one that collides. + // + // **The articles are not here.** The Markdown under content/reference is a set of documents + // somebody owns, translated as documents and by their own route; a bundle holds strings the + // site says, and an article is not one. What is here is the furniture round them — and it + // says nothing about what language an article is in, because that is the content layer's + // fact to state and it is changing. + // + // **Every acronym stays out of the bundle.** MSSP, GMCP, TTYPE, CHARSET and the codebase and + // client names arrive as arguments or sit in the markup. This is the surface most *about* + // machine voice and so the one where a locale is likeliest to reach for a word — and a + // translated TTYPE is destroyed evidence rather than a localized string. + ["reference.title"] = "Reference", + ["reference.lede"] = "What the codebases are, what the clients do, and what the protocols " + + "mean. Written by hand and kept in the repository beside the crawler — not a wiki, and " + + "there is nothing on this page to edit. Every {number} here is a different thing: it " + + "comes from the catalogue and is recomputed each time you load the page.", + + // The emphasised word, placed by the message rather than wrapped round a fragment of it: a + // language that stresses a different word in that clause has somewhere to move the emphasis + // to, and the bundle still holds no markup. Sentences.Place walks it. + ["reference.lede.number"] = "number", + ["reference.plain.lede"] = "Hand-written, single-author, and versioned in git. The prose here " + + "is ours; every number beside it was measured by the crawler and is recomputed on each " + + "request. This is not a wiki, and there is no way to edit it from this page.", + + // The four section headings, and the four kind words beside a page's title. One English word + // does both jobs for three of them — a heading over a list, and a label naming what one page + // is — and inflected languages routinely need different forms, so they are eight ids. + ["reference.section.orientation"] = "Start here", + ["reference.section.codebase"] = "Codebases", + ["reference.section.client"] = "Clients", + ["reference.section.protocol"] = "Protocols", + ["reference.kind.orientation"] = "orientation", + ["reference.kind.codebase"] = "codebase", + ["reference.kind.client"] = "client", + ["reference.kind.protocol"] = "protocol", + + // A gap in a hand-written section is work nobody has done, and the page says so rather than + // implying something was taken away — §7.5 in the one place a reader could reasonably read a + // deletion into a 404. + ["reference.notFound.title"] = "Not found", + ["reference.notFound.body"] = "No reference page here. This section is hand-written, so a gap " + + "is work nobody has done rather than something that was removed — {index}.", + ["reference.notFound.index"] = "see what there is", + + // ── a codebase page's measured half ─────────────────────────────────────────────────── + // The zero is a sentence and never a bare 0 (rule 4): none identified is a statement about + // this crawler's reach, and reads as a statement about the codebase unless it is spelled out. + ["reference.codebase.heading"] = "Games running it", + ["reference.codebase.none"] = "We have not identified any yet. That is a fact about what this " + + "crawler has measured, not about what exists — a game we have not reached, or whose " + + "codebase we could not read, is not counted here.", + ["reference.codebase.listed"] = "{count, plural, one {# listed} other {# listed}}", + ["reference.codebase.archived"] = "{count, plural, one {# archived} other {# archived}}", + + // Rule 1, in three words, and its own id in every register it appears in. It must not soften + // into "verified" or "from our data": what it says is that nothing on this line was taken + // from anybody's self-description. + ["reference.measuredNeverAsserted"] = "measured, never asserted", + ["reference.codebase.note"] = "Counted from the catalogue on this request, over the same " + + "filter the link above carries — so this number and that listing are one query and " + + "cannot drift apart.", + + // The protocol list is machine voice and arrives whole, joined by the markup. A locale + // orders the sentence round it and never touches what is inside. + ["reference.codebase.offered"] = "offered in their handshakes: {protocols}", + + // ── a protocol page's measured half ─────────────────────────────────────────────────── + ["reference.protocol.heading"] = "Measured adoption", + ["reference.protocol.none"] = "Nothing measured yet.", + ["reference.protocol.share"] = "of {listed, plural, one {# listed game} other {# listed games}} — {percent}", + + // **The remainder is not a measurement and the page has to say so.** A locale that shortened + // this to "the rest do not support it" would file our own unread handshakes as a fact about + // somebody's game, which is rule 5 exactly. The sentence names both halves of what the + // remainder mixes, and a translation has to keep them two. + ["reference.protocol.remainder"] = "The games not counted here are not games without the " + + "protocol. A game is counted when we observed its server offering the option in a " + + "handshake; the rest are servers that did not offer it to us and servers whose " + + "handshake we have not read, and we cannot tell you which.", + ["reference.protocol.caption"] = "Games observed offering {protocol} in a handshake, by the " + + "codebase we identified them as running.", + ["reference.protocol.column.codebase"] = "codebase", + ["reference.protocol.column.offered"] = "offered it", + ["reference.protocol.column.identified"] = "identified", + ["reference.seeAlso"] = "See also", + + // ── the client capability matrix, which is documentation rather than measurement ─────── + // Every cell here is somebody's documentation read by us, and the table is a sibling of the + // game pages' measured matrix rather than a copy of it. The caveat carries that difference + // and takes the unknown word as an argument, so the sentence and the cells cannot disagree + // about which word they are quoting. + ["reference.capabilities.heading"] = "Capabilities", + ["reference.capabilities.established"] = "{count, plural, one {# of {total} established from the project's own documentation} other {# of {total} established from the project's own documentation}}", + ["reference.capabilities.caveat"] = "Read off each project's own documentation, not measured " + + "by us — a client has no handshake for us to observe. \"{unknown}\" means we looked and " + + "did not establish it. It never means no.", + ["reference.capabilities.caption"] = "Client capabilities, each read off the project's own " + + "documentation. Unknown means we did not establish it, and never that the client lacks " + + "it.", + ["reference.capabilities.column.documented"] = "documented", + ["reference.capabilities.column.source"] = "source", + ["reference.capabilities.noSource"] = "we did not find one", + + // Three words for three states, and the third is the one that matters. An unknown is what we + // looked for and did not establish; a locale that rendered it as the no beside it would turn + // our reading into the project's absence. They are ids of their own rather than the game + // pages' capability words, which answer a different question — offered on a wire. + ["reference.capability.yes"] = "yes", + ["reference.capability.no"] = "no", + ["reference.capability.unknown"] = "unknown", + + // ── the plain mirror's own wording ──────────────────────────────────────────────────── + // Where the plain surface says the same sentence as the page it mirrors it shares the id + // above; these are the lines it words differently because it has no panel round them. + ["reference.plain.runsOn"] = "Runs on: {platforms}", + ["reference.plain.codebase.heading"] = "Games we have identified as running this codebase", + ["reference.plain.codebase.none"] = "None yet. That is a statement about what we have " + + "measured, not about what exists — a game we have not reached, or whose codebase we " + + "could not read, is not counted here.", + ["reference.plain.codebase.counts"] = "{listed, plural, one {# listed} other {# listed}}, {archived, plural, one {# archived} other {# archived}}", + ["reference.plain.codebase.offered"] = "Measured in their handshakes: {protocols}", + ["reference.plain.codebase.nothingOffered"] = "Nothing was offered in any handshake we have " + + "read from them.", + ["reference.plain.protocol.share"] = "{offering} of {listed, plural, one {# listed game} other {# listed games}} were observed offering it ({percent})", + ["reference.plain.protocol.byCodebase"] = "By codebase, of the games we identified", + ["reference.plain.protocol.row"] = "{offering} of {identified} offered it", + ["reference.plain.capabilities.unknown"] = "{count, plural, one {# of {total} rows is unknown} other {# of {total} rows are unknown}}: we did not find the project's own documentation saying either way. A short honest table beats a long guessed one.", + + // ══ APPENDED BLOCK: the owner dashboard and the claim flow ════════════════════════════ + // The last two page surfaces that were still English whatever language they were asked + // for. Kept as one block at the end of the dictionary so that a parallel append merges + // additively rather than interleaving. + // + // These surfaces address a game's operator in the second person — "your games", "a game + // you run" — and the English says "you" deliberately. A translator should render them in + // whatever second person their language uses for one person being addressed directly; the + // catalogue surfaces are impersonal and these are not. Do not neutralise them. + // + // Nothing here may blur the two provenances. An owner's answer is a DECLARATION stored + // beside what the crawler measured; a claim is a fact about our records and never a + // measurement of the game; an opt-out is honoured and is never a deletion. Where a + // sentence carries that distinction it is called out on the id. + + // ── the dashboard's frame ───────────────────────────────────────────────────────────── + // account.title is its own id rather than preview.title.account's: a heading is the first + // line of a document and a title is a noun phrase in a browser tab, and the languages that + // decline the two differently have nowhere to stand if they share one. + ["account.title"] = "Your games", + ["account.noDatabase"] = "Accounts need a database behind them, and this site is running on " + + "the demo fixture.", + ["account.signInButton"] = "Sign in", + ["account.signedInAs"] = "Signed in as {name}.", + ["account.signOut"] = "Sign out", + + // The empty state's sentence places its own link and its own quoted control, so the word + // order belongs to the language rather than to the markup. {claimControl} names the button + // on a game's page; it is a separate id from game.claim because that one is the control's + // own label and this one is prose quoting it — a language that capitalises or declines a + // quoted control differently has nowhere else to say so. + ["account.empty.body"] = "You have not claimed anything yet. Find your game in {listing} " + + "and press {claimControl} on its page.", + ["account.empty.listing"] = "the listing", + ["account.empty.claimControl"] = "claim this game", + + // ── the one banner a POST comes back with ───────────────────────────────────────────── + // Resigning is not deleting: §7.5 keeps the record, and §8.4 lets the same person prove + // control again. A translation that renders this as "removed" or "deleted" contradicts the + // rule the sentence exists to state. + ["account.resigned.lead"] = "Given up.", + ["account.resigned.body"] = "The record of it is kept, and you can prove control again any " + + "time by publishing a fresh token.", + ["account.saved.lead"] = "Saved.", + + // One sentence per write. The game's name is its own bytes and arrives as an argument, so + // a language that puts the subject elsewhere can move it; {game} is never translated. + // These say what WE did — stopped republishing, stopped dialling, took out of the listing — + // and never that anything about the game was measured or removed. + ["account.saved.thatGame"] = "That game", + ["account.saved.fields"] = "{game}'s page now shows it as owner-declared.", + ["account.saved.screenHidden"] = "We have stopped republishing {game}'s connect screen. The " + + "page says so plainly rather than leaving a hole.", + ["account.saved.screenShown"] = "{game}'s connect screen is on its page again.", + ["account.saved.crawlStopped"] = "We have stopped dialling {game}, on every address we have " + + "for it. Its page keeps everything measured before you asked.", + ["account.saved.crawlResumed"] = "We are dialling {game} again, from its next turn in the " + + "schedule.", + ["account.saved.unlisted"] = "{game} is out of the listing, the rankings and the daily " + + "figure. Its page and every URL it has ever had go on answering.", + ["account.saved.relisted"] = "{game} is back in the listing. One probe that answers is all " + + "it needs to be measured again.", + + // Refused out loud (§8.5). {field} is a registry field name — machine voice, an argument. + // The second sentence is the site's whole claim and may not soften: nobody edits a + // measurement, and that includes us. + ["account.refused.lead"] = "{field} was not changed.", + ["account.refused.tooLong"] = "These are one-line answers; {max} characters is the most we " + + "store.", + ["account.refused.measured"] = "That field is measured. A claim lets you add what MSSP has " + + "no room for; it never lets anybody edit what we observed, and that includes us.", + + // ── a claimed game's block ──────────────────────────────────────────────────────────── + // "verified {date}" is a fact about OUR record — the date we read this owner's token — and + // not a measurement of the game. Two ids rather than a suffix glued on, because the beacon + // note lands in a different place in most languages. + ["account.claimed.heading"] = "Claimed", + ["account.claim.verified"] = "verified {date}", + ["account.claim.verifiedAndSeen"] = "verified {date}, token last seen {seen}", + ["account.claim.mssp"] = "check your MSSP", + ["account.claim.coOwners"] = "{count, plural," + + " one {Also owned by {names} — who verified a token of their own.}" + + " other {Also owned by {names} — each having verified a token of their own.}}", + ["account.coOwner.unnamed"] = "another account", + + // The badge snippet. {unknown} and {archived} are the badge's own bytes rather than words + // to translate: a badge answers one address to everybody, so a German page promising a + // German word would be promising something the image never says. {json} is an acronym and + // machine voice for the same reason every protocol name here is. + ["account.badge.summary"] = "put your player count on your own site", + ["account.badge.carries"] = "The badge carries the count and when we measured it, because a " + + "number with no age is the thing this site exists to replace.", + ["account.badge.states"] = "It says {unknown} rather than nought when we could not count, " + + "and {archived} if the game stops answering.", + ["account.badge.json"] = "There is {json} too, if you would rather draw your own.", + + // ── the audit log ───────────────────────────────────────────────────────────────────── + // The vocabulary is ClaimEventKind's, spelled for a person. beaconMissing reads as an + // observation and never as a warning: a probe not reading the token happens for reasons + // that have nothing to do with the owner, and absence never revokes (§8.4). + ["account.history.summary"] = "history", + ["account.event.issued"] = "token issued", + ["account.event.reissued"] = "token issued again", + ["account.event.verified"] = "verified — we read your token", + ["account.event.beaconSeen"] = "token still published", + ["account.event.beaconMissing"] = "token not read this time", + ["account.event.revoked"] = "claim given up", + ["account.event.expired"] = "token expired unused", + ["account.event.counterClaimed"] = "another account proved control and took the game over", + ["account.event.checkRequested"] = "check requested", + + // Giving up a claim. {word} is the literal an operator types into the box and is never + // translated — a translated confirmation word would be one the form does not accept. + ["account.resign.summary"] = "give up this claim", + ["account.resign.confirm"] = "Type {word} to confirm. Nothing is deleted and you can prove " + + "control again by publishing a fresh token; the game stays claimed if anybody else " + + "owns it.", + ["account.resign.button"] = "Give up {game}", + + // ── waiting on a token, and the passkeys ────────────────────────────────────────────── + ["account.pending.heading"] = "Waiting on a token", + ["account.pending.dates"] = "token issued {issued}, good until {expires}", + ["account.passkeys.heading"] = "Passkeys", + ["account.passkey.unnamed"] = "unnamed", + ["account.passkey.added"] = "added {date}", + ["account.passkey.addedOneDevice"] = "added {date} · on one device only", + ["account.passkey.single"] = "This passkey lives on one device. If you lose it you can " + + "still get back in by publishing a fresh token on your game, but a second passkey is " + + "quicker.", + ["account.passkey.add"] = "Add another passkey", + + // ── claiming a game you run ─────────────────────────────────────────────────────────── + // claim.title is its own id rather than preview.title.claim's, for the reason account.title + // is: a heading and a browser-tab title are not the same noun phrase. + ["claim.noGame"] = "No such game", + ["claim.title"] = "Claim {game}", + ["claim.noDatabase"] = "Claiming needs a database behind it, and this site is running on " + + "the demo fixture.", + ["claim.needAccount"] = "You need an account first. It takes a passkey and a name.", + ["claim.signIn"] = "Sign in or create an account", + ["claim.yourGames"] = "Your games", + + // The game already has owners, and nothing in a probe can tell joining from taking over — + // both publish the identical line. So the choice is made here, in words, before the token + // exists. The owner count agrees inside the message rather than being chosen in C#. + ["claim.hasOwners"] = "{count, plural," + + " one {This game already has an owner who proved control of the server.}" + + " other {This game already has # owners who proved control of the server.}}" + + " You can prove it too — the test is the same either way — but we need to know what " + + "you mean by it, because we cannot tell from the token.", + ["claim.join.button"] = "I run it too — add me as an owner", + ["claim.join.note"] = "Everyone keeps their claim. This is two people running one game.", + ["claim.assume.button"] = "I have taken it over — transfer it to me", + ["claim.assume.note"] = "{count, plural," + + " one {When your token verifies, the existing claim is revoked and the game is yours.}" + + " other {When your token verifies, the existing claims are revoked and the game is yours.}}" + + " They will see why in their own history. Nothing is deleted, and they can prove " + + "control again the same way you are about to.", + + // Verified. Two ids and not one with the channel slotted in: "from the game's MSSP report" + // and "from the connect screen" take different prepositions and different cases in the + // languages that have them, and a single sentence with a {channel} hole has nowhere to + // say so. Both state what WE read, which is a fact about our records. + ["claim.verified.lead"] = "Verified.", + ["claim.verified.viaMssp"] = "We read your token from the game's MSSP report on {date}.", + ["claim.verified.viaScreen"] = "We read your token from the connect screen on {date}.", + ["claim.verified.leaveIt"] = "Leave the token where it is. It doubles as an identity " + + "signal, so this game stays recognisable if it moves host or changes name. Removing " + + "it will not un-claim you.", + + // Publishing the token. Every variable name, file name and prefix below is machine voice + // and arrives as an argument: a translated MSSP variable is one no crawler reads. + ["claim.publish"] = "Publish this token anywhere the game shows it to an anonymous " + + "connection. The next probe picks it up, which proves you can write to that server.", + ["claim.transfer.lead"] = "This is a transfer.", + ["claim.transfer.body"] = "{count, plural," + + " one {When we read this token, the current owner's claim on this game is revoked and it becomes yours.}" + + " other {When we read this token, the current owners' claims on this game are revoked and it becomes yours.}}", + ["claim.either.heading"] = "Either of these will do", + ["claim.mssp.heading"] = "An MSSP variable", + ["claim.mssp.note"] = "In {codebase} that is a line in {file}; every codebase with MSSP has " + + "an equivalent.", + ["claim.mssp.aliases"] = "{aliases} are accepted too.", + ["claim.screen.heading"] = "A line on the connect screen", + ["claim.screen.note"] = "Anywhere in the screen, and colour codes around it are fine.", + ["claim.then.heading"] = "Then", + ["claim.then.body"] = "We check on the ordinary crawl schedule. This token is good until " + + "{date}. Come back any time; nothing needs writing down.", + + // Asking us to look sooner moves the game to the front of the queue; the crawler still + // does the dialling on its own schedule and under CRAWL DELAY. Neither sentence may + // promise a probe, because pressing a button here is our decision and not a measurement. + ["claim.check.button"] = "Look sooner", + ["claim.check.can"] = "Brings your game to the front of the queue. We dial on our own " + + "schedule, so this is sooner rather than now.", + ["claim.check.rationed"] = "Just asked. Try again in a few minutes — it is rationed because " + + "it dials a real server sooner than we would have.", + + // ── what a claim actually grants (the owner panel, §8.5 and §11) ────────────────────── + // Everything on this panel is enrichment. An owner's answer is DECLARED: stored under its + // own field source beside whatever the crawler measured, shown with its age, and it never + // replaces, hides or silences a measurement. A translation that lets "you told us" read as + // "we measured" breaks the one rule the whole site rests on. + ["owner.declare.heading"] = "What only you can tell us about {game}", + ["owner.declare.lede"] = "These are the things MSSP has no field for. They appear on your " + + "game's page as {declared}, with the date you last confirmed them, beside what we " + + "measured — never instead of it. Nothing measured can be edited from here, by you or " + + "by us.", + ["owner.field.declared"] = "declared {age}. Empty this box to withdraw it — the record of " + + "what it said is kept either way.", + ["owner.save"] = "Save what you declared", + + ["owner.override.heading"] = "What {game} reports, and what you would rather we showed", + ["owner.override.lede"] = "Your MSSP is what every crawler reads, and we go on showing it " + + "beside anything you put here — an answer of yours does not hide one of your game's.", + ["owner.override.nothingMeasured"] = "Nothing measured can be edited from here: not a " + + "player count, not a capability, not an hour of reachability.", + ["owner.override.fixItThere"] = "If a line below is wrong in your {file}, fixing it there " + + "fixes it everywhere.", + ["owner.report.value"] = "your game reports {value}, confirmed {age}", + ["owner.report.none"] = "your game reports nothing here", + ["owner.rename.note"] = "Changing the name changes what {game} is listed as and the " + + "address of its page. The old address goes on working for ever — every URL this game " + + "has ever had redirects to its current one — and clearing the box hands the name back " + + "to whatever your MSSP says.", + + ["owner.screen.heading"] = "Your connect screen", + ["owner.screen.suppressed"] = "We are not republishing it. The page says so plainly rather " + + "than leaving a hole, and the crawler goes on reading it — it is how we recognise " + + "your game if it moves.", + ["owner.screen.show"] = "Show it again", + ["owner.screen.shown"] = "We show it because your server sends it to every anonymous " + + "connection. If you would rather we did not, say so and we stop. We will not ask why.", + ["owner.screen.stop"] = "Stop showing our connect screen", + + // §11. An opt-out is honoured, never a deletion — and the empty hours it leaves may not be + // given a cause, because "you asked us to stop" is OUR fact and not a measurement of the + // game (rule 5, rule 2). {ourFact} is placed by the message so a language can put the + // emphasised clause where it belongs. + ["owner.crawl.heading"] = "Being crawled", + ["owner.crawl.stopped"] = "We have stopped. Nothing on {game} is dialled, and the page " + + "keeps everything measured before you asked — the empty hours name no cause, because " + + "{ourFact} is our fact and not a measurement of your game.", + ["owner.crawl.ourFact"] = "you asked us to stop", + ["owner.crawl.resume"] = "Start crawling us again", + ["owner.crawl.standing"] = "This one came from your own server rather than from here — " + + "{routes}. To be crawled again, stop publishing it; we will hear that on the next " + + "cycle.", + ["owner.crawl.route.mssp"] = "your MSSP report publishes {variable}", + ["owner.crawl.route.dns"] = "a {label} TXT record asks us to stop", + ["owner.crawl.route.recorded"] = "a request we recorded", + // Neither state, and shown as neither: rounding this to "stopped" would tell an owner we + // had left them alone while we went on dialling the port that is still open. + ["owner.crawl.partial"] = "We have stopped on {stopped} and are still dialling {dialling}. " + + "That is usually a port added after the opt-out.", + ["owner.crawl.stopAll"] = "Stop on every address too", + ["owner.crawl.dialling"] = "We dial {game} on a schedule and read what any anonymous " + + "connection is shown. If you would rather we did not, say so and we stop — within " + + "one cycle, on every address we have for you, and we will not ask why.", + ["owner.crawl.selfService"] = "Nothing already measured is deleted: your page keeps its " + + "history and its URL, and one probe after you take this back starts it again. You " + + "can also say it without us, in your own config — {mssp} in MSSP, or a {dns} TXT " + + "record — and we honour those whether or not anybody has ever claimed the game here.", + ["owner.crawl.stop"] = "Stop crawling us", + + // Migration 0025's second decision, and a second one rather than a stronger version of the + // first. Nothing is deleted here either: the page answers, every URL it ever had still + // redirects to it, and it stops being somewhere a reader arrives by browsing. + ["owner.listing.heading"] = "Being listed", + ["owner.listing.unlisted"] = "{game} is out of the listing, out of the rankings and out of " + + "the daily figure. Its page and every URL it has ever had go on answering, and " + + "everything measured before you asked is still on it. Nothing was deleted; it is " + + "simply not somewhere a reader arrives by browsing.", + ["owner.listing.relist"] = "Put us back in the listing", + ["owner.listing.probeRelists"] = "One probe that answers does this too. While your opt-out " + + "stands we do not dial, so nothing will — but the day you take it back, the address " + + "comes up within a week and the probe that gets an answer puts you back. You do not " + + "have to ask us twice.", + ["owner.listing.mayUnlist"] = "We have stopped dialling you, and your page is still in the " + + "listing with what we measured before that. If you would rather it were not, say so " + + "and it comes out — of the listing, the rankings and the daily figure.", + ["owner.listing.reversible"] = "Nothing is deleted and nothing breaks: the page answers, " + + "every URL it has ever had still redirects to it, and anyone you send there sees it. " + + "It stops being somewhere a reader can arrive by browsing. Reversible from here, and " + + "by any probe that answers after you take your opt-out back.", + ["owner.listing.unlist"] = "Take us out of the listing too", + // ══ END APPENDED BLOCK ════════════════════════════════════════════════════════════════ + + // ══ WHAT WE COULD MEASURE ═════════════════════════════════════════════════════════════ + // The handoff's last panel group: two independent switches over the two reasons a listing + // row carries no number. Every string here describes *our* reach and none of them describes + // a game, which is rule 5 — the note exists because the gesture these controls offer is the + // one most likely to be read as a claim about the games it removes. + ["facet.group.measure"] = "what we could measure", + + // The design's own sentence, with its first clause made true of the control that shipped: + // the panel's rows are tri-state, so hiding is the "−" rather than an untick. The second + // clause is the load-bearing one and is carried verbatim. + ["facet.measure.note"] = "Hiding these takes them out of your listing; it does not mean the " + + "game is empty.", + + // Named for what we did and never for what the game is. "could not count" is a fact about + // our parsers meeting a dialect; "no players" would be that same fact filed in somebody + // else's public record. + ["facet.group.uncounted"] = "could not count", + ["facet.group.unreachable"] = "could not reach", + + // What the chip says when a reader has dropped one of the two. Deliberately not "not + // uncounted": a double negative reads as an assertion about the games, and this is an + // assertion about the listing. Two ids carrying one English sentence, because they are two + // different facts and a language that inflects will not spell them the same way. + ["facet.excluded.uncounted"] = "hidden from this listing", + ["facet.excluded.unreachable"] = "hidden from this listing", + + // The plain surface's own key to its left column. It drew "only these" and "anything but + // these" with one star until these two switches arrived, whose ordinary gesture is the + // second — so the surface with the least else to go on was the one that could not show the + // third state at all. + ["facet.plain.marks"] = "In the left column, * is a value this listing is filtered to and - " + + "is one it is filtered against. Both are choices in the query, not facts about a game.", + // ══ END WHAT WE COULD MEASURE ═════════════════════════════════════════════════════════ + }; + + /// <summary> + /// The bundles, by tag. + /// </summary> + /// <remarks> + /// <para> + /// <b>Only English is complete, and that is the honest state of this work rather than a gap in + /// it.</b> The order of work is explicit: the glossary is written and human-translated before a + /// reader is sent anywhere, and no locale is offered until it is. What ships here is the + /// machinery, exercised end to end by the two test-only bundles below. + /// </para> + /// <para> + /// <c>qps-ploc</c> is a pseudolocale — accented and expanded English. It is not a language and + /// nobody claims it is one; it exists so routing, fallback, plural selection and the nav's 1.4x + /// width budget are all exercised by something real. <c>ru-x-canary</c> is machine-translated, + /// never shipped, and deliberately incomplete: it is what makes a missing plural form fail a + /// build instead of reaching a reader. + /// </para> + /// </remarks> + private static readonly Dictionary<string, Dictionary<string, string>> TestBundles = + new(StringComparer.OrdinalIgnoreCase) + { + // Every message, mechanically transformed. Generated rather than typed so it cannot + // fall behind the source bundle it is derived from. + ["qps-ploc"] = English.ToDictionary(e => e.Key, e => Pseudo(e.Value), StringComparer.Ordinal), + + // Three plural categories, and one message that is missing its `few` and `many` branches + // on purpose. That omission is what the completeness test turns into a build failure. + ["ru-x-canary"] = new(StringComparer.Ordinal) + { + ["facet.count"] = "{count, plural, one {# игра} few {# игры} many {# игр} other {# игры}}", + ["listing.total"] = "{count, plural, one {# игра} other {# игр}}, каждый факт измерен.", + ["provenance.count.measured"] = "измерена", + ["provenance.game.measured"] = "измерено", + ["provenance.capability.measured"] = "измерены", + ["kicker.measured"] = "ИЗМЕРЕНО", + }, + }; + + /// <summary> + /// One message, rendered for a locale — or the English, where that locale has no approved one. + /// </summary> + /// <remarks> + /// The fallback is silent to the reader and loud to the build. A reader meeting one English + /// phrase inside a German sentence learns something true: this particular claim has not been + /// translated yet. What must never happen is the other thing — a smoothed-over approximation of + /// a locked string, which teaches them something false and gives them no way to tell. + /// </remarks> + public static string For(string tag, string id, IReadOnlyDictionary<string, object?>? args = null) + { + ArgumentNullException.ThrowIfNull(tag); + ArgumentNullException.ThrowIfNull(id); + + var pattern = Pattern(tag, id) + ?? throw new KeyNotFoundException($"No message '{id}' in any bundle, including English."); + + return IcuMessage.Format(pattern, tag, args); + } + + /// <summary> + /// The same, with the arguments named inline rather than built into a dictionary first. + /// </summary> + /// <remarks> + /// <b>One helper, because there were eleven.</b> Every component that renders more than one + /// message had grown its own private wrapper turning a tuple array into an ordinal dictionary + /// and calling <see cref="For"/> — the same six lines, copied, and twice inside one file. + /// <c>StringComparer.Ordinal</c> is the part that mattered and the part a twelfth copy would + /// eventually get wrong: an argument name is a token in a pattern, matched exactly, and a + /// dictionary that folded case would answer a lookup the parser never asked for. + /// </remarks> + public static string Say(string tag, string id, params (string Key, object? Value)[] args) + { + ArgumentNullException.ThrowIfNull(args); + + return For(tag, id, args.ToDictionary(a => a.Key, a => a.Value, StringComparer.Ordinal)); + } + + /// <summary>A count and its noun, agreeing — the commonest call by a long way.</summary> + public static string Count(string tag, int count) => + For(tag, "facet.count", new Dictionary<string, object?> { ["count"] = count }); + + /// <summary>The raw pattern a locale would use, English included, or null.</summary> + public static string? Pattern(string tag, string id) + { + ArgumentNullException.ThrowIfNull(tag); + ArgumentNullException.ThrowIfNull(id); + + return Own(tag, id) ?? English.GetValueOrDefault(id); + } + + /// <summary>Whether a locale carries its own text for an id, rather than falling back.</summary> + public static bool HasOwn(string tag, string id) => Own(tag, id) is not null; + + /// <summary> + /// What a locale itself says for an id — from its resx, or from a test bundle — or null. + /// </summary> + /// <remarks> + /// <c>ResourceNotFound</c> is the load-bearing check. <see cref="IStringLocalizer"/> answers a + /// missing key with the key itself rather than with null, so a lookup that trusted the string it + /// got back would render <c>facet.count</c> to a reader and call it a translation. + /// </remarks> + private static string? Own(string tag, string id) + { + if (TestBundles.TryGetValue(tag, out var bundle)) + { + return bundle.GetValueOrDefault(id); + } + + // The source language reads its own compiled-in copy: it is the fallback for every other + // locale, and a fallback that depends on a satellite assembly having loaded is not one. + if (string.Equals(tag, Locales.SourceTag, StringComparison.OrdinalIgnoreCase)) + { + return English.GetValueOrDefault(id); + } + + if (Culture(tag) is not { } culture) + { + return null; + } + + // The resource set for this culture *alone*, with tryParents off — which is the whole point. + // GetString walks up to the neutral resources, so it answers the English for a locale that + // has translated nothing, and a caller asking "does this locale carry its own words for this + // id" would be told yes for every id in the site. The fallback is deliberate elsewhere and + // wrong here. + // + // A ResourceManager rather than IStringLocalizer, and that is not a rejection of the pattern + // — IStringLocalizer *is* a ResourceManager with the culture read off the ambient thread. + // This lookup is static and is called from Razor markup, from the plain-text renderer and + // from headless component tests alike, and it is handed the locale rather than inferring + // one; the DI wrapper would mean it could not answer at all without a host behind it, which + // is most of where it is called from. AddMuiLocalization still registers the injected form + // for anything that wants it. + try + { + return Resources.GetResourceSet(culture, createIfNotExists: true, tryParents: false) + ?.GetString(id); + } + catch (MissingManifestResourceException) + { + return null; + } + } + + /// <summary> + /// The satellite assemblies, keyed off the marker type so the base name cannot drift. + /// </summary> + /// <remarks> + /// One per culture, compiled by the SDK from <c>Resources/Messages.<culture>.resx</c> with + /// no <c><EmbeddedResource></c> entries in the project file. A culture with no satellite + /// answers null here rather than throwing, which is the fallback path. + /// </remarks> + private static readonly ResourceManager Resources = new(typeof(Web.Resources.Messages)); + + private static CultureInfo? Culture(string tag) + { + try + { + return CultureInfo.GetCultureInfo(tag); + } + catch (CultureNotFoundException) + { + return null; + } + } + + /// <summary>The source text for an id, which is what a resx has to agree with.</summary> + public static string? Source(string id) => English.GetValueOrDefault(id); + + + + /// <summary>Every id the site says, in the order the source bundle declares them.</summary> + public static IReadOnlyList<string> Ids { get; } = [.. English.Keys]; + + /// <summary>The ids a locale has not translated yet.</summary> + /// <remarks> + /// The release checklist's own question, answerable from code rather than from a spreadsheet. + /// A locale may not be moved to <see cref="LocaleStatus.Shipped"/> while any <em>locked</em> id + /// is in this list — which is the rule the completeness test enforces. + /// </remarks> + public static IReadOnlyList<string> MissingFor(string tag) => + [.. Ids.Where(id => !HasOwn(tag, id))]; + + /// <summary> + /// Accented, expanded English — a language nobody speaks, which is the point. + /// </summary> + /// <remarks> + /// Two jobs. The accents prove a string came through the pipeline rather than being hard-coded + /// in a template, and the padding gives every string the 1.4x width the handoff says to review + /// a locale at — German and Russian run 30–40% longer on short UI nouns, and the nav bar was + /// tightened to fit English exactly. The ICU syntax is stepped over rather than transformed: + /// mangling a branch keyword would make the message unparseable and prove nothing. + /// </remarks> + private static string Pseudo(string pattern) + { + var b = new System.Text.StringBuilder(pattern.Length * 2); + var depth = 0; + + foreach (var c in pattern) + { + if (c == '{') { depth++; b.Append(c); continue; } + if (c == '}') { depth--; b.Append(c); continue; } + + // Inside braces the text is syntax — argument names and branch keywords — and accenting + // it would make the message unparseable, which proves nothing. + b.Append(depth > 0 ? c : Accent(c)); + } + + // The padding goes outside the braces so no argument name is touched. + return "⟦" + b + "⟧"; + } + + private static char Accent(char c) => c switch + { + 'a' => 'á', 'e' => 'é', 'i' => 'í', 'o' => 'ó', 'u' => 'ú', 'n' => 'ñ', 'c' => 'ç', + 'A' => 'Á', 'E' => 'É', 'I' => 'Í', 'O' => 'Ó', 'U' => 'Ú', 'N' => 'Ñ', 'C' => 'Ç', + _ => c, + }; +} diff --git a/src/MUI.Web/Localization/PluralOperands.cs b/src/MUI.Web/Localization/PluralOperands.cs new file mode 100644 index 0000000..ebaf00c --- /dev/null +++ b/src/MUI.Web/Localization/PluralOperands.cs @@ -0,0 +1,106 @@ +using System.Globalization; + +namespace MUI.Web.Localization; + +/// <summary> +/// The six values a CLDR plural rule is written in terms of. +/// </summary> +/// <param name="N">The absolute value of the number.</param> +/// <param name="I">Its integer digits.</param> +/// <param name="V">How many fraction digits are <em>visible</em>, trailing zeros included.</param> +/// <param name="W">How many are visible with trailing zeros removed.</param> +/// <param name="F">The visible fraction digits as an integer, trailing zeros included.</param> +/// <param name="T">The same with trailing zeros removed.</param> +/// <param name="E">The compact-decimal exponent, which is zero for everything this site formats.</param> +/// <remarks> +/// <para> +/// <b>Visible is the load-bearing word, and it is why this type exists rather than an <c>int</c>.</b> +/// In English <c>1</c> is <c>one</c> and <c>1.0</c> is <c>other</c> — "1.0 stars" is correct and +/// "1.0 star" is not — and the two are the same quantity. A rule cannot tell them apart from the +/// value alone; it needs to know how the number was <em>written</em>. That is what <c>v</c> and +/// <c>f</c> carry, and it is the single most commonly missed thing in a hand-rolled plural +/// implementation. +/// </para> +/// <para> +/// Every count this site pluralises is an integer, so <c>v</c> is zero throughout and none of this +/// changes an answer today. It is here because a plural implementation that only works for integers +/// is one that silently gives the wrong form the first time somebody formats a rate or an average, +/// and because the rules below are transcribed from CLDR in the operands CLDR states them in — a +/// transcription into a different vocabulary is a transcription that cannot be checked. +/// </para> +/// <para> +/// <b>These are absolute values and this type cannot print a number.</b> CLDR takes the absolute +/// value to choose a category, never to display one, so a <c>Format</c> here would drop the sign of +/// every number it was handed — and it did, along with the group separator, which put "1234 games" +/// in a sentence beside "1,234" in the column. Rendering belongs to <see cref="IcuMessage"/>, which +/// still holds the signed value the caller passed. +/// </para> +/// </remarks> +public readonly record struct PluralOperands( + decimal N, + long I, + int V, + int W, + long F, + long T, + int E) +{ + /// <summary>The operands of an integer, where every fractional one is zero.</summary> + public static PluralOperands Of(long value) + { + var n = Math.Abs(value); + + return new PluralOperands(n, n, 0, 0, 0, 0, 0); + } + + /// <summary> + /// The operands of a number as it will actually be written. + /// </summary> + /// <param name="value">The quantity.</param> + /// <param name="visibleFractionDigits"> + /// How many fraction digits the rendered string shows, or null to read them off the value. + /// </param> + /// <remarks> + /// The parameter is what makes <c>1</c> and <c>1.0</c> different: a caller formatting to two + /// decimal places has to say so, because by the time the number reaches here as a + /// <see cref="decimal"/> the trailing zeros it will be printed with are a fact about the format + /// string and not about the value. + /// </remarks> + public static PluralOperands Of(decimal value, int? visibleFractionDigits = null) + { + var n = Math.Abs(value); + var i = (long)decimal.Truncate(n); + + // decimal keeps its own scale, so 1.50m already knows it has two fraction digits. That is + // the right default: a caller who did not say otherwise gets the digits the value carries. + var scale = (byte)((decimal.GetBits(n)[3] >> 16) & 0x7f); + var v = visibleFractionDigits ?? scale; + + var fractional = n - i; + var f = v == 0 ? 0L : (long)decimal.Round(fractional * Pow10(v), 0, MidpointRounding.AwayFromZero); + + // w and t are v and f with trailing zeros taken off: 1.50 has v=2, f=50, w=1, t=5. + var w = v; + var t = f; + + while (w > 0 && t % 10 == 0) + { + t /= 10; + w--; + } + + return new PluralOperands(n, i, v, w, f, t, E: 0); + } + + private static decimal Pow10(int power) + { + var result = 1m; + + for (var at = 0; at < power; at++) + { + result *= 10m; + } + + return result; + } +} diff --git a/src/MUI.Web/Localization/PluralRules.cs b/src/MUI.Web/Localization/PluralRules.cs new file mode 100644 index 0000000..be62fe8 --- /dev/null +++ b/src/MUI.Web/Localization/PluralRules.cs @@ -0,0 +1,402 @@ +namespace MUI.Web.Localization; + +/// <summary>The CLDR plural categories.</summary> +/// <remarks> +/// Six of them exist across all languages; no single language uses more than five, and most use one +/// or two. <see cref="Other"/> is the one every language has and the only one a message must +/// declare. +/// </remarks> +public enum PluralCategory +{ + Zero, + One, + Two, + Few, + Many, + Other, +} + +/// <summary>Cardinal counts one thing; ordinal ranks it.</summary> +/// <remarks> +/// They are different rule sets and getting them from one table is a bug rather than a shortcut. In +/// English the cardinal rule has two forms — <em>1 game, 2 games</em> — and the ordinal rule has +/// four — <em>1st, 2nd, 3rd, 4th</em> — and neither can produce the other's answers. +/// </remarks> +public enum PluralKind +{ + Cardinal, + Ordinal, +} + +/// <summary> +/// Which plural form a number takes, per locale, per kind. +/// </summary> +/// <remarks> +/// <para> +/// <b>Transcribed from CLDR 46's plural charts, in the operands CLDR states them in.</b> Each rule +/// below is written the way the chart writes it — <c>i = 1 and v = 0</c> rather than +/// <c>count == 1</c> — so it can be checked against the source line by line. A transcription into a +/// different vocabulary is a transcription nobody can verify. +/// </para> +/// <para> +/// <b>Hand-written rather than taken from a library, and that is a judgement rather than a +/// preference.</b> The .NET options are thin: ICU4N is an alpha pinned to ICU 60, whose CLDR data +/// predates several of the rules below, and the MessageFormat ports are 0.1.x forks of an abandoned +/// project. Neither is a dependency worth the credibility of a site whose entire product is being +/// right about what it knows. The cost is that this table has to be maintained against CLDR when a +/// locale is added, which is why <see cref="LocalesCovered"/> exists and is asserted against the +/// locales the site actually commits to. +/// </para> +/// <para> +/// <b>An unlisted language answers <see cref="PluralCategory.Other"/>.</b> That is correct for a +/// language with one form and safe for one whose rule is not written here — the message still +/// renders, in the form every language has. What stops that being a silent wrong answer is the test +/// that walks every offered locale and refuses one this table does not cover. +/// </para> +/// </remarks> +public static class PluralRules +{ + /// <summary>The CLDR release these rules were transcribed from.</summary> + public const string CldrVersion = "46"; + + /// <summary> + /// The languages this table states a rule for, cardinal or ordinal. + /// </summary> + /// <remarks> + /// The gate on adding a locale: a tag whose language is not here falls back to <c>other</c> for + /// every count, which is right for Chinese and wrong for German. Asserted in the tests against + /// <see cref="Locales.All"/>. + /// </remarks> + public static IReadOnlyList<string> LocalesCovered { get; } = + [ + "en", "de", "nl", "sv", "da", "no", "fi", "et", "el", "it", "es", "fr", "pt", + "ru", "uk", "be", "pl", "cs", "sk", "hi", "th", "vi", "id", "ms", "ja", "ko", "zh", + "tr", "he", "ar", "qps", + ]; + + /// <summary>The category <paramref name="count"/> takes.</summary> + public static PluralCategory Of(string tag, long count, PluralKind kind = PluralKind.Cardinal) => + Of(tag, PluralOperands.Of(count), kind); + + /// <summary>The category a number written a particular way takes.</summary> + public static PluralCategory Of(string tag, PluralOperands o, PluralKind kind = PluralKind.Cardinal) + { + ArgumentNullException.ThrowIfNull(tag); + + var language = Language(tag); + + return kind is PluralKind.Ordinal ? Ordinal(language, o) : Cardinal(language, o); + } + + private static PluralCategory Cardinal(string language, PluralOperands o) => language switch + { + // one: i = 1 and v = 0 + // + // The v = 0 is why this file carries operands at all: "1.0 stars" is other, not one, and + // the two quantities are equal. `qps` is the pseudolocale and is English underneath, so it + // has to select exactly what English selects or it exercises the wrong branch. + "en" or "de" or "nl" or "sv" or "fi" or "et" or "qps" => + o is { I: 1, V: 0 } ? PluralCategory.One : PluralCategory.Other, + + // one: n = 1 + // + // <b>Not the line above, and 1.0 is the whole of the difference.</b> Greek, Norwegian, + // Spanish and Turkish say `one` for it where English says `other`. All four had been given + // English's rule, because on the integers the two agree — and the integers are all anybody + // checks. Turkish had `n = 0..1` besides, which is a real CLDR rule belonging to Akan and + // Punjabi and puts zero in the form Turkish keeps for exactly one thing. + "el" or "no" or "tr" => o.N == 1m ? PluralCategory.One : PluralCategory.Other, + + // one: n = 1 or t != 0 and i = 0,1 + // + // Danish alone, and the only `one` in this table that reaches a quantity which is not 1: + // "0,5 stjerne" rather than "0,5 stjerner". Copied from Swedish, it loses that clause + // silently — the integers, again, agree. + "da" => o.N == 1m || (o.T != 0 && o.I is 0 or 1) + ? PluralCategory.One + : PluralCategory.Other, + + // one: i = 1 and v = 0 (it) + // n = 1 (es) + // i = 0,1 (fr, pt) + // many: e = 0 and i != 0 and i % 1000000 = 0 and v = 0 (all four) + // + // The Romance millions rule — "un millón de juegos", with the preposition the other forms + // do not take. fr and pt carried it; it and es were folded into English's rule above and so + // had no `many` at all, which is a form a translator would have been asked to write and + // never given anywhere to put. + "it" => Millions(o) ? PluralCategory.Many + : o is { I: 1, V: 0 } ? PluralCategory.One + : PluralCategory.Other, + + "es" => Millions(o) ? PluralCategory.Many + : o.N == 1m ? PluralCategory.One + : PluralCategory.Other, + + "fr" or "pt" => Millions(o) ? PluralCategory.Many + : o.I is 0 or 1 ? PluralCategory.One + : PluralCategory.Other, + + // one: v = 0 and i % 10 = 1 and i % 100 != 11 + // few: v = 0 and i % 10 = 2..4 and i % 100 != 12..14 + // many: v = 0 and (i % 10 = 0 or i % 10 = 5..9 or i % 100 = 11..14) + // other: everything with a visible fraction + // + // 11 and 12 end in 1 and 2 and take neither `one` nor `few`. A rule written from the first + // three examples anybody tries is wrong for both. + "ru" or "uk" => o.V != 0 ? PluralCategory.Other + : (o.I % 10, o.I % 100) switch + { + (1, not 11) => PluralCategory.One, + (2 or 3 or 4, not (12 or 13 or 14)) => PluralCategory.Few, + _ => PluralCategory.Many, + }, + + // one: n % 10 = 1 and n % 100 != 11 + // few: n % 10 = 2..4 and n % 100 != 12..14 + // many: n % 10 = 0 or n % 10 = 5..9 or n % 100 = 11..14 + // + // Belarusian states Russian's shape on `n` rather than on `i` with `v = 0`, so 1.0 is + // `one` here and `other` there. It had been folded in with Russian above: right for every + // integer, wrong for every number written with a decimal place. + "be" => !Whole(o) ? PluralCategory.Other + : (o.I % 10, o.I % 100) switch + { + (1, not 11) => PluralCategory.One, + (2 or 3 or 4, not (12 or 13 or 14)) => PluralCategory.Few, + _ => PluralCategory.Many, + }, + + // one: i = 1 and v = 0 + // few: v = 0 and i % 10 = 2..4 and i % 100 != 12..14 + // many: v = 0 and i != 1 and (i % 10 = 0..1 or i % 10 = 5..9 or i % 100 = 12..14) + "pl" => o.V != 0 ? PluralCategory.Other + : o.I == 1 ? PluralCategory.One + : (o.I % 10, o.I % 100) switch + { + (2 or 3 or 4, not (12 or 13 or 14)) => PluralCategory.Few, + _ => PluralCategory.Many, + }, + + // one: i = 1 and v = 0 + // few: i = 2..4 and v = 0 + // many: v != 0 + "cs" or "sk" => o.V != 0 ? PluralCategory.Many + : o.I switch + { + 1 => PluralCategory.One, + 2 or 3 or 4 => PluralCategory.Few, + _ => PluralCategory.Other, + }, + + // one: i = 0 or n = 1 + "hi" => o.I == 0 || o.N == 1m ? PluralCategory.One : PluralCategory.Other, + + // one: i = 1 and v = 0 or i = 0 and v != 0 + // two: i = 2 and v = 0 + // + // The `many` this rule used to carry for multiples of ten was withdrawn from CLDR before + // 46, and so was every one of Hebrew's ordinals. A table still stating them selects a + // branch nobody was ever asked to translate — which the `other` fallback cannot catch, + // because the branch is present and simply wrong. + "he" => o switch + { + { I: 1, V: 0 } or { I: 0, V: not 0 } => PluralCategory.One, + { I: 2, V: 0 } => PluralCategory.Two, + _ => PluralCategory.Other, + }, + + // zero: n = 0 one: n = 1 two: n = 2 + // few: n % 100 = 3..10 many: n % 100 = 11..99 + // + // Six categories, which is the count the review cites — and Arabic is render-only here, so + // this rule exists for correctness of the table rather than for a locale that ships. + "ar" => o.N switch + { + 0 => PluralCategory.Zero, + 1 => PluralCategory.One, + 2 => PluralCategory.Two, + _ when !Whole(o) => PluralCategory.Other, + _ => (o.I % 100) switch + { + >= 3 and <= 10 => PluralCategory.Few, + >= 11 and <= 99 => PluralCategory.Many, + _ => PluralCategory.Other, + }, + }, + + // No plural inflection at all. This is exactly why Chinese cannot be the locale a string + // architecture is validated against: it agrees with any shape, including a wrong one. + "zh" or "ja" or "ko" or "th" or "vi" or "id" or "ms" => PluralCategory.Other, + + _ => PluralCategory.Other, + }; + + private static PluralCategory Ordinal(string language, PluralOperands o) => language switch + { + // one: n % 10 = 1 and n % 100 != 11 (1st, 21st, but 11th) + // two: n % 10 = 2 and n % 100 != 12 (2nd, 22nd, but 12th) + // few: n % 10 = 3 and n % 100 != 13 (3rd, 23rd, but 13th) + "en" or "qps" => !Whole(o) ? PluralCategory.Other + : (o.I % 10, o.I % 100) switch + { + (1, not 11) => PluralCategory.One, + (2, not 12) => PluralCategory.Two, + (3, not 13) => PluralCategory.Few, + _ => PluralCategory.Other, + }, + + // one: n % 10 = 1,2 and n % 100 != 11,12 (1:a and 2:a, then 3:e — and 11:e, 12:e) + "sv" => !Whole(o) ? PluralCategory.Other + : (o.I % 10, o.I % 100) switch + { + (1 or 2, not (11 or 12)) => PluralCategory.One, + _ => PluralCategory.Other, + }, + + // one: n = 1 (1er / 1re, then 2e, 3e …) + "fr" => o.N == 1m ? PluralCategory.One : PluralCategory.Other, + + // few: n % 10 = 3 and n % 100 != 13 + "uk" => !Whole(o) ? PluralCategory.Other + : (o.I % 10, o.I % 100) switch + { + (3, not 13) => PluralCategory.Few, + _ => PluralCategory.Other, + }, + + // few: n % 10 = 2,3 and n % 100 != 12,13 + "be" => !Whole(o) ? PluralCategory.Other + : (o.I % 10, o.I % 100) switch + { + (2 or 3, not (12 or 13)) => PluralCategory.Few, + _ => PluralCategory.Other, + }, + + // many: n = 11,8,80,800 + "it" => Whole(o) && o.I is 11 or 8 or 80 or 800 ? PluralCategory.Many : PluralCategory.Other, + + // one: n = 1 two: n = 2,3 few: n = 4 many: n = 6 + "hi" => !Whole(o) ? PluralCategory.Other + : o.I switch + { + 1 => PluralCategory.One, + 2 or 3 => PluralCategory.Two, + 4 => PluralCategory.Few, + 6 => PluralCategory.Many, + _ => PluralCategory.Other, + }, + + // one: n = 1 + "vi" or "ms" => o.N == 1m ? PluralCategory.One : PluralCategory.Other, + + // Every other language this site knows about has one ordinal form: German, Spanish, Danish, + // Norwegian, Greek, Dutch, Finnish, Estonian, Polish, Czech, Slovak, Russian, Portuguese, + // Thai, Indonesian, Chinese, Japanese, Korean, Turkish, Arabic — and Hebrew, whose six-way + // ordinal table CLDR withdrew before 46. + _ => PluralCategory.Other, + }; + + /// <summary>The Romance millions rule, which CLDR states identically for all four languages.</summary> + /// <remarks> + /// <c>many: e = 0 and i != 0 and i % 1000000 = 0 and v = 0</c>. <c>e</c> is the compact-decimal + /// exponent and is zero for everything this site formats, so the clause CLDR adds for compact + /// notation cannot be reached from here. + /// </remarks> + private static bool Millions(PluralOperands o) => + o is { E: 0, V: 0, I: not 0 } && o.I % 1_000_000 == 0; + + /// <summary>Whether the number is a whole one, which is all a CLDR range can ever match.</summary> + /// <remarks> + /// <c>n % 100 = 3..10</c> is a range over integers: 3.5 is not in it, however its integer part + /// reads. Testing <c>i</c> in its place gives every fraction the category of the whole number + /// below it — the wrong form for a rate and for an average alike, and invisible in a table + /// exercised only with counts. + /// </remarks> + private static bool Whole(PluralOperands o) => o.N == o.I; + + /// <summary> + /// Every category a locale can produce, which is what a message has to cover. + /// </summary> + /// <remarks> + /// The assertion the Russian canary is for. A message declaring only <c>one</c> and <c>other</c> + /// is complete in English and silently wrong in Russian, where a count of two takes a form + /// neither branch supplies — and a wrong plural does not read as a typo to a native speaker, it + /// reads as illiterate. + /// </remarks> + public static IReadOnlyList<PluralCategory> CategoriesOf( + string tag, PluralKind kind = PluralKind.Cardinal) + { + ArgumentNullException.ThrowIfNull(tag); + + // Derived by exercising the rule rather than by keeping a second table beside it, so the + // two cannot disagree. The probes cover every boundary the rules above test — the teens, + // the tens, the millions, and a fraction, which is the case that separates `one` from + // `other` in English. + var seen = new List<PluralCategory>(); + + foreach (var probe in Probes) + { + var category = Of(tag, probe, kind); + + if (!seen.Contains(category)) + { + seen.Add(category); + } + } + + return seen; + } + + /// <summary>Numbers that between them reach every branch of every rule above.</summary> + private static IReadOnlyList<PluralOperands> Probes { get; } = + [ + .. new long[] + { + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 20, 21, 22, 23, 24, 25, + 80, 100, 101, 102, 103, 111, 112, 113, 800, 1000, 1_000_000, 2_000_000, + }.Select(n => PluralOperands.Of(n)), + + // A visible fraction, which is `other` in English and in Russian and `many` in Czech. + PluralOperands.Of(1.0m, visibleFractionDigits: 1), + PluralOperands.Of(1.5m, visibleFractionDigits: 1), + ]; + + /// <summary>The keyword a message branch is spelled with.</summary> + public static string Keyword(PluralCategory category) => category switch + { + PluralCategory.Zero => "zero", + PluralCategory.One => "one", + PluralCategory.Two => "two", + PluralCategory.Few => "few", + PluralCategory.Many => "many", + _ => "other", + }; + + /// <summary>Whether a word is one of the six category keywords.</summary> + public static bool IsCategory(string word) => + word is "zero" or "one" or "two" or "few" or "many" or "other"; + + /// <summary>Whether this table states a rule for a tag's language at all.</summary> + public static bool Covers(string tag) + { + ArgumentNullException.ThrowIfNull(tag); + + return LocalesCovered.Contains(Language(tag), StringComparer.Ordinal); + } + + /// <summary> + /// The language subtag, which is what a plural rule is keyed on. + /// </summary> + /// <remarks> + /// <c>zh-Hans</c> and <c>zh-Hant</c> pluralise identically, and so do <c>ru</c> and the CI + /// canary's <c>ru-x-canary</c> — the script and the private-use subtag change which glyphs are + /// drawn and which bundle is read, never how a number agrees. + /// </remarks> + private static string Language(string tag) + { + var dash = tag.IndexOf('-', StringComparison.Ordinal); + + return (dash < 0 ? tag : tag[..dash]).ToLowerInvariant(); + } +} diff --git a/src/MUI.Web/Localization/Sentences.cs b/src/MUI.Web/Localization/Sentences.cs new file mode 100644 index 0000000..a55cf20 --- /dev/null +++ b/src/MUI.Web/Localization/Sentences.cs @@ -0,0 +1,100 @@ +namespace MUI.Web.Localization; + +/// <summary> +/// A sentence whose word order belongs to the locale and whose markup belongs to the site. +/// </summary> +/// <remarks> +/// <para> +/// Some sentences have a link or an emphasised word inside them. Gluing English round an anchor +/// gives a language that wants the link first, or a different preposition before it, nowhere to say +/// so; formatting the anchor <em>into</em> the string and trusting the result through a +/// <c>MarkupString</c> would make every bundle a place a tag could be put. So the message places a +/// marker, this walks it, and what a translator writes is text either way. +/// </para> +/// <para> +/// The markers are private-use code points, which no translation contains by accident and no script +/// the site offers uses. They are assigned in the order the slots are passed and never appear in +/// what a reader is shown: a marker that survives into the output is a slot the message did not +/// place, and the run for it is simply absent — which is visible rather than silent. +/// </para> +/// <para> +/// This was two copies before it was one file. The random-game empty state placed two links this +/// way and the reference section needed the same thing for its own two sentences, at which point the +/// marker constant, the walk and the "translator writes no markup" argument were about to exist +/// twice. +/// </para> +/// </remarks> +public static class Sentences +{ + /// <summary>The first marker. One code point per slot, upwards from here.</summary> + private const char Marker = '\uE000'; + + /// <summary> + /// The most slots one sentence may place. Well past anything readable, and a bound rather than + /// an open range so a stray private-use character in a translation cannot be read as a slot. + /// </summary> + private const int MaxSlots = 8; + + /// <summary>One piece of a sentence: plain text, or the text of a named slot.</summary> + /// <param name="Text">What the reader sees, already in their language.</param> + /// <param name="Slot"> + /// The argument name the message placed, or null for the prose between the slots. The caller + /// switches on this to decide what markup goes round the run. + /// </param> + public sealed record Run(string Text, string? Slot); + + /// <summary> + /// A message, split into the runs its markup renders — the slots in the order the + /// <em>message</em> puts them, which is the locale's order and not this call's. + /// </summary> + public static IReadOnlyList<Run> Place(string tag, string id, params (string Name, string Text)[] slots) + { + ArgumentNullException.ThrowIfNull(slots); + ArgumentOutOfRangeException.ThrowIfGreaterThan(slots.Length, MaxSlots); + + var sentence = Messages.For(tag, id, slots + .Select((slot, i) => (slot.Name, Value: (object?)((char)(Marker + i)).ToString())) + .ToDictionary(s => s.Name, s => s.Value, StringComparer.Ordinal)); + + var runs = new List<Run>(); + var run = new System.Text.StringBuilder(); + + foreach (var c in sentence) + { + var slot = c - Marker; + + if (slot < 0 || slot >= slots.Length) + { + run.Append(c); + continue; + } + + if (run.Length > 0) + { + runs.Add(new Run(run.ToString(), null)); + run.Clear(); + } + + runs.Add(new Run(slots[slot].Text, slots[slot].Name)); + } + + if (run.Length > 0) + { + runs.Add(new Run(run.ToString(), null)); + } + + return runs; + } + + /// <summary> + /// The same sentence with the slots substituted rather than marked — for the plain surface, + /// which has no markup to put round them and must still say every word the page does. + /// </summary> + public static string Flat(string tag, string id, params (string Name, string Text)[] slots) + { + ArgumentNullException.ThrowIfNull(slots); + + return Messages.For(tag, id, slots.ToDictionary( + s => s.Name, s => (object?)s.Text, StringComparer.Ordinal)); + } +} diff --git a/src/MUI.Web/MUI.Web.csproj b/src/MUI.Web/MUI.Web.csproj index 2da38cb..4320d0f 100644 --- a/src/MUI.Web/MUI.Web.csproj +++ b/src/MUI.Web/MUI.Web.csproj @@ -30,6 +30,15 @@ <ItemGroup> <EmbeddedResource Include="..\..\content\reference\*.md" Link="Content\reference\%(Filename)%(Extension)" /> + + <!-- + And one directory per locale beside it. The English is the source and stays at the top level; + a translation is the same article with the same slug in another language, so it is named the + same and filed under its tag. The resource name that results carries the tag as a segment, + which is what the library keys on. + --> + <EmbeddedResource Include="..\..\content\reference\*\*.md" + Link="Content\reference\%(RecursiveDir)%(Filename)%(Extension)" /> </ItemGroup> <!-- diff --git a/src/MUI.Web/Reference/ClientCapabilities.cs b/src/MUI.Web/Reference/ClientCapabilities.cs index 3552ffa..9f666ac 100644 --- a/src/MUI.Web/Reference/ClientCapabilities.cs +++ b/src/MUI.Web/Reference/ClientCapabilities.cs @@ -1,4 +1,5 @@ using MUI.Catalog; +using MUI.Web.Localization; namespace MUI.Web.Reference; @@ -65,13 +66,20 @@ .. Rows.Select(row => document.Capabilities } /// <summary> - /// The word for a state. Never a glyph on its own, and <em>unknown</em> is spelled out rather - /// than left blank: a blank cell reads as a no to a human exactly as it does to a parser. + /// The word for a state, in the reader's language. Never a glyph on its own, and + /// <em>unknown</em> is spelled out rather than left blank: a blank cell reads as a no to a human + /// exactly as it does to a parser. /// </summary> - public static string Word(CapabilityState state) => state switch + /// <remarks> + /// Three ids rather than three literals, and they are this table's own rather than the game + /// pages' capability words: those answer <em>was it offered on a wire</em> and these answer + /// <em>does the project's documentation say so</em>. A locale that let the third collapse into + /// the second would publish our own failure to find a page as the client lacking the feature. + /// </remarks> + public static string Word(string tag, CapabilityState state) => Messages.For(tag, state switch { - CapabilityState.Present => "yes", - CapabilityState.Absent => "no", - _ => "unknown", - }; + CapabilityState.Present => "reference.capability.yes", + CapabilityState.Absent => "reference.capability.no", + _ => "reference.capability.unknown", + }); } diff --git a/src/MUI.Web/Reference/ReferenceLibrary.cs b/src/MUI.Web/Reference/ReferenceLibrary.cs index 9d99183..8f878b0 100644 --- a/src/MUI.Web/Reference/ReferenceLibrary.cs +++ b/src/MUI.Web/Reference/ReferenceLibrary.cs @@ -1,6 +1,8 @@ using System.Collections.Frozen; using System.Reflection; +using MUI.Web.Localization; + namespace MUI.Web.Reference; /// <summary> @@ -54,15 +56,81 @@ private ReferenceLibrary(IReadOnlyList<ReferenceDocument> documents) /// </summary> public static ReferenceLibrary Shipped { get; } = Load(typeof(ReferenceLibrary).Assembly); - public static ReferenceLibrary Load(Assembly assembly) + /// <summary> + /// The library a reader in this locale gets: their language where we have it, English where we + /// do not. + /// </summary> + /// <remarks> + /// <para> + /// <b>A translation supplies prose and nothing else.</b> The document handed out is the English + /// record with its title, summary and body replaced — so the slug, the kind, the + /// <c>see-also</c> graph, the protocol name and the upstream link come from one file in one + /// language, whatever a translator does to their copy. A slug is a URL and a URL has one page; + /// this makes that true by construction rather than by asking forty files to agree. + /// </para> + /// <para> + /// An article with no translation is served in English rather than withheld. The alternative is + /// a reference section that is missing pages in four languages, and a missing page is worse + /// than a page in the wrong language: one of them still answers the question. + /// </para> + /// </remarks> + public static ReferenceLibrary For(string tag) + { + ArgumentNullException.ThrowIfNull(tag); + + return Localized.GetOrAdd(tag, static t => + { + if (string.Equals(t, Locales.SourceTag, StringComparison.OrdinalIgnoreCase)) + { + return Shipped; + } + + var translated = Load(typeof(ReferenceLibrary).Assembly, t) + .Documents.ToDictionary(d => d.Path, StringComparer.OrdinalIgnoreCase); + + return new ReferenceLibrary( + [ + .. Shipped.Documents.Select(english => + translated.TryGetValue(english.Path, out var localized) + ? english with + { + Title = localized.Title, + Summary = localized.Summary, + Body = localized.Body, + } + : english), + ]); + }); + } + + private static readonly System.Collections.Concurrent.ConcurrentDictionary<string, ReferenceLibrary> Localized = + new(StringComparer.OrdinalIgnoreCase); + + public static ReferenceLibrary Load(Assembly assembly) => Load(assembly, tag: null); + + /// <param name="tag"> + /// The locale directory to read, or null for the English articles at the top level. The two are + /// told apart by the resource name: a translation carries its tag as a segment before the file + /// name, so <c>…reference.de.protocol-mssp.md</c> is German and <c>…reference.protocol-mssp.md</c> + /// is the source. + /// </param> + public static ReferenceLibrary Load(Assembly assembly, string? tag) { ArgumentNullException.ThrowIfNull(assembly); + // MSBuild builds a manifest name out of the file's path and replaces what cannot appear in + // an identifier, so `content/reference/zh-Hans/` is embedded as `…reference.zh_Hans.…`. The + // tag is BCP-47 and its only such character is the dash. Without this, Chinese was the one + // locale whose articles loaded and were never found — three locales working is exactly the + // evidence that hides it, which is why the test below names zh-Hans rather than "a locale". + var prefix = tag is null ? ".reference." : $".reference.{tag.Replace('-', '_')}."; + var documents = new List<ReferenceDocument>(); foreach (var resource in assembly.GetManifestResourceNames() - .Where(n => n.Contains(".reference.", StringComparison.Ordinal) - && n.EndsWith(".md", StringComparison.Ordinal)) + .Where(n => n.Contains(prefix, StringComparison.OrdinalIgnoreCase) + && n.EndsWith(".md", StringComparison.Ordinal) + && (tag is not null || !IsLocalized(n))) .Order(StringComparer.Ordinal)) { using var stream = assembly.GetManifestResourceStream(resource) @@ -85,6 +153,24 @@ public static ReferenceLibrary Load(Assembly assembly) return new ReferenceLibrary([.. documents.OrderBy(d => d.Kind).ThenBy(d => d.Title, StringComparer.OrdinalIgnoreCase)]); } + /// <summary> + /// Whether a resource name names a translation rather than a source article. + /// </summary> + /// <remarks> + /// The file names carry dashes and never dots, so everything between <c>.reference.</c> and + /// <c>.md</c> is one segment for a source article and two for a translation — and the extra + /// segment is the tag. <c>zh-Hans</c> survives that because its dash is not a separator here. + /// </remarks> + private static bool IsLocalized(string resource) + { + const string Marker = ".reference."; + + var start = resource.IndexOf(Marker, StringComparison.Ordinal) + Marker.Length; + var rest = resource[start..^".md".Length]; + + return rest.Contains('.', StringComparison.Ordinal); + } + public IReadOnlyList<ReferenceDocument> OfKind(ReferenceKind kind) => [.. Documents.Where(d => d.Kind == kind)]; diff --git a/src/MUI.Web/Reference/ReferenceMarkdown.cs b/src/MUI.Web/Reference/ReferenceMarkdown.cs index 7ae0ba2..ac07394 100644 --- a/src/MUI.Web/Reference/ReferenceMarkdown.cs +++ b/src/MUI.Web/Reference/ReferenceMarkdown.cs @@ -5,6 +5,7 @@ using Markdig.Syntax.Inlines; using MUI.Web.Components; +using MUI.Web.Localization; namespace MUI.Web.Reference; @@ -34,7 +35,19 @@ public static class ReferenceMarkdown .UsePipeTables() .Build(); - public static string ToHtml(string markdown) + /// <param name="tag"> + /// The locale this article is being read in, which its own cross-references are written in. + /// </param> + /// <remarks> + /// <b>The links inside the prose are localized here and not in the page.</b> The body reaches + /// the markup as one <c>MarkupString</c>, so nothing downstream can see the anchors inside it — + /// and every article in this section cites two or three others. A German reader following "see + /// MSSP" from a German page was put back into English by a link nobody had written on a page, + /// which is the same defect as the fifty in the components and invisible to the same sweep. + /// It is done on the parsed document rather than on the rendered HTML, because a rewrite over + /// markup is a second, worse HTML parser. + /// </remarks> + public static string ToHtml(string markdown, string tag = Locales.SourceTag) { var document = Markdown.Parse(markdown ?? string.Empty, Pipeline); @@ -45,6 +58,11 @@ public static string ToHtml(string markdown) image.IsImage = false; } + foreach (var link in document.Descendants<LinkInline>()) + { + link.Url = LocaleRouting.Link(tag, link.Url); + } + foreach (var heading in document.Descendants<HeadingBlock>()) { heading.Level = Math.Min(heading.Level + 1, 6); diff --git a/src/MUI.Web/Resources/Messages.cs b/src/MUI.Web/Resources/Messages.cs new file mode 100644 index 0000000..1b134ae --- /dev/null +++ b/src/MUI.Web/Resources/Messages.cs @@ -0,0 +1,22 @@ +namespace MUI.Web.Resources; + +/// <summary> +/// The marker <see cref="Microsoft.Extensions.Localization.IStringLocalizer{T}"/> resolves against. +/// </summary> +/// <remarks> +/// <para> +/// A type with no members, whose only job is to name a resource set: <c>Messages.resx</c> and every +/// <c>Messages.<culture>.resx</c> beside it are discovered from this class's namespace and +/// compiled into satellite assemblies by the SDK, with no <c><EmbeddedResource></c> entries in +/// the project file. The same shape SharpMUSH's portal uses for its own chrome. +/// </para> +/// <para> +/// <b>The values are ICU patterns, not composite-format strings.</b> That is where this parts +/// company with the usual .NET arrangement: <c>string.Format</c> and <c>CompositeFormat</c> take +/// <c>{0}</c> and can only substitute, so "23 games" has to be assembled from a number and a noun +/// somewhere in C# — which is the concatenation the whole pipeline exists to remove. resx supplies +/// the storage, the tooling and the satellite assemblies; <see cref="Localization.IcuMessage"/> +/// supplies the grammar. +/// </para> +/// </remarks> +public sealed class Messages; diff --git a/src/MUI.Web/Resources/Messages.de.resx b/src/MUI.Web/Resources/Messages.de.resx new file mode 100644 index 0000000..0d3a0e0 --- /dev/null +++ b/src/MUI.Web/Resources/Messages.de.resx @@ -0,0 +1,2877 @@ +<?xml version="1.0" encoding="utf-8"?> +<root> + <!-- + Deutsch, machine-translated and not reviewed by a person. + + Every page served in this locale carries the ◆ notice saying so, and the locale is reachable but + never offered: nothing sends a reader here. Promotion to LocaleStatus.Shipped is a person reading + the locked strings against Glossary.cs, not an edit to a status enum. + + The values are ICU MessageFormat. Argument names in braces are code. + --> + <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata"> + <xsd:import namespace="http://www.w3.org/XML/1998/namespace" /> + <xsd:element name="root" msdata:IsDataSet="true"> + <xsd:complexType> + <xsd:choice maxOccurs="unbounded"> + <xsd:element name="data"> + <xsd:complexType> + <xsd:sequence> + <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" /> + <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" /> + </xsd:sequence> + <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" /> + <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" /> + <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" /> + <xsd:attribute ref="xml:space" /> + </xsd:complexType> + </xsd:element> + <xsd:element name="resheader"> + <xsd:complexType> + <xsd:sequence> + <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" /> + </xsd:sequence> + <xsd:attribute name="name" type="xsd:string" use="required" /> + </xsd:complexType> + </xsd:element> + </xsd:choice> + </xsd:complexType> + </xsd:element> + </xsd:schema> + <resheader name="resmimetype"><value>text/microsoft-resx</value></resheader> + <resheader name="version"><value>2.0</value></resheader> + <resheader name="reader"><value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader> + <resheader name="writer"><value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader> + <data name="facet.count" xml:space="preserve"> + <value>{count, plural, one {# Spiel} other {# Spiele}}</value> + </data> + <data name="facet.value.include" xml:space="preserve"> + <value>{value}, {count, plural, one {# Spiel} other {# Spiele}}, nur</value> + </data> + <data name="facet.value.exclude" xml:space="preserve"> + <value>{value}, {count, plural, one {# Spiel} other {# Spiele}}, ausgeschlossen</value> + </data> + <data name="facet.value.choose" xml:space="preserve"> + <value>{value}, {count, plural, one {# Spiel} other {# Spiele}}</value> + </data> + <data name="facet.any" xml:space="preserve"> + <value>{facet}: beliebig, {count, plural, one {# Spiel} other {# Spiele}}</value> + </data> + <data name="listing.total" xml:space="preserve"> + <value>{count, plural, =0 {Keine Spiele eingetragen.} one {# Spiel, jede Tatsache nennt ihre Herkunft.} other {# Spiele, jede Tatsache nennt ihre Herkunft.}}</value> + </data> + <data name="chart.basis" xml:space="preserve"> + <value>{days, plural, one {# Tag} other {# Tage}} gemessen · {probes, plural, one {# Abfrage} other {# Abfragen}}</value> + </data> + <data name="window.samples" xml:space="preserve"> + <value>{days, plural, one {# Tag} other {# Tage}} · {count, plural, one {# Zählung} other {# Zählungen}}</value> + </data> + <data name="capabilities.agree" xml:space="preserve"> + <value>{disagreeing, plural, =0 {Keine der {total} widerspricht.} one {# von {total} widerspricht dem, was das Spiel angibt.} other {# von {total} widersprechen dem, was das Spiel angibt.}}</value> + </data> + <data name="find.matching" xml:space="preserve"> + <value>{count, plural, =0 {Keine Spiele passen zu allen Antworten.} one {# Spiel passt zu allen Antworten.} other {# Spiele passen zu allen Antworten.}}</value> + </data> + <data name="find.basis" xml:space="preserve"> + <value>von {listed, plural, one {# eingetragenem Spiel} other {# eingetragenen Spielen}} · {answers, plural, =0 {keine Antworten gegeben} one {# Antwort gegeben} other {# Antworten gegeben}}</value> + </data> + <data name="find.show" xml:space="preserve"> + <value>{count, plural, one {Das eine Spiel zeigen} other {Diese # Spiele zeigen}}</value> + </data> + <data name="find.drop" xml:space="preserve"> + <value>„{answer}“ entfernen — {count, plural, one {# Spiel} other {# Spiele}}</value> + </data> + <data name="find.clear" xml:space="preserve"> + <value>Antwort zurücksetzen: {question}</value> + </data> + <data name="find.title" xml:space="preserve"> + <value>Ein Spiel finden</value> + </data> + <data name="find.kicker" xml:space="preserve"> + <value>passend zu allen Antworten</value> + </data> + <data name="find.noun" xml:space="preserve"> + <value>{count, plural, one {Spiel} other {Spiele}}</value> + </data> + <data name="find.clearAll" xml:space="preserve"> + <value>alle Antworten zurücksetzen</value> + </data> + <data name="find.startAgain" xml:space="preserve"> + <value>neu beginnen</value> + </data> + <data name="find.more" xml:space="preserve"> + <value>{count, plural, one {# weiteres} other {# weitere}}</value> + </data> + <data name="find.answersGiven" xml:space="preserve"> + <value>gegebene Antworten</value> + </data> + <data name="find.wholeListing" xml:space="preserve"> + <value>das gesamte Verzeichnis</value> + </data> + <data name="find.refused" xml:space="preserve"> + <value>diese Anfrage wurde abgelehnt</value> + </data> + <data name="find.name.label" xml:space="preserve"> + <value>ein Name, falls Sie einen haben</value> + </data> + <data name="find.name.placeholder" xml:space="preserve"> + <value>Name oder Namensteil</value> + </data> + <data name="find.name.submit" xml:space="preserve"> + <value>Nach Namen suchen</value> + </data> + <data name="find.q.band" xml:space="preserve"> + <value>Spielt gerade jemand?</value> + </data> + <data name="find.q.genre" xml:space="preserve"> + <value>Was möchten Sie spielen?</value> + </data> + <data name="find.q.lineage" xml:space="preserve"> + <value>Welche Art von Spiel?</value> + </data> + <data name="find.q.language" xml:space="preserve"> + <value>In welcher Sprache?</value> + </data> + <data name="find.q.client" xml:space="preserve"> + <value>Braucht Ihr Client etwas?</value> + </data> + <data name="find.q.dark" xml:space="preserve"> + <value>Verstummte Spiele einbeziehen?</value> + </data> + <data name="find.any.band" xml:space="preserve"> + <value>egal</value> + </data> + <data name="find.any.genre" xml:space="preserve"> + <value>beliebiges Genre</value> + </data> + <data name="find.any.lineage" xml:space="preserve"> + <value>beliebige Art</value> + </data> + <data name="find.any.language" xml:space="preserve"> + <value>beliebige Sprache</value> + </data> + <data name="find.any.client" xml:space="preserve"> + <value>egal</value> + </data> + <data name="find.dark.no" xml:space="preserve"> + <value>nein, nur aktive Spiele</value> + </data> + <data name="find.dark.yes" xml:space="preserve"> + <value>ja, auch diese zeigen</value> + </data> + <data name="find.dark.chip" xml:space="preserve"> + <value>verstummte Spiele</value> + </data> + <data name="find.protocol.tls" xml:space="preserve"> + <value>TLS — verschlüsselt, Handshake von uns abgeschlossen</value> + </data> + <data name="find.protocol.mssp" xml:space="preserve"> + <value>MSSP — Selbstauskunft des Servers</value> + </data> + <data name="find.protocol.mccp" xml:space="preserve"> + <value>MCCP — komprimierte Ausgabe</value> + </data> + <data name="find.protocol.mxp" xml:space="preserve"> + <value>MXP — anklickbare Links</value> + </data> + <data name="find.protocol.gmcp" xml:space="preserve"> + <value>GMCP — strukturierte Client-Daten</value> + </data> + <data name="find.protocol.msdp" xml:space="preserve"> + <value>MSDP — strukturierte Client-Daten</value> + </data> + <data name="find.protocol.charset" xml:space="preserve"> + <value>CHARSET — Aushandlung der Kodierung</value> + </data> + <data name="find.protocol.utf8" xml:space="preserve"> + <value>UTF-8 — nichtlateinischer Text wird dargestellt</value> + </data> + <data name="find.protocol.ttype" xml:space="preserve"> + <value>TTYPE — Client nennt seinen Typ</value> + </data> + <data name="find.protocol.atcp" xml:space="preserve"> + <value>ATCP — strukturierte Client-Daten</value> + </data> + <data name="find.protocol.msp" xml:space="preserve"> + <value>MSP — Sound-Auslöser</value> + </data> + <data name="find.protocol.eor" xml:space="preserve"> + <value>EOR — Prompt-Markierung</value> + </data> + <data name="find.protocol.other" xml:space="preserve"> + <value>{token} — im Handshake gemessen</value> + </data> + <data name="provenance.count.measured" xml:space="preserve"> + <value>gemessen</value> + </data> + <data name="provenance.game.measured" xml:space="preserve"> + <value>gemessen</value> + </data> + <data name="provenance.capability.measured" xml:space="preserve"> + <value>gemessen</value> + </data> + <data name="provenance.screen.measured" xml:space="preserve"> + <value>gemessen</value> + </data> + <data name="kicker.measured" xml:space="preserve"> + <value>gemessen</value> + </data> + <data name="provenance.count.declared" xml:space="preserve"> + <value>angegeben</value> + </data> + <data name="provenance.game.declared" xml:space="preserve"> + <value>angegeben</value> + </data> + <data name="provenance.capability.declared" xml:space="preserve"> + <value>angegeben</value> + </data> + <data name="kicker.declared" xml:space="preserve"> + <value>angegeben</value> + </data> + <data name="provenance.derived" xml:space="preserve"> + <value>abgeleitet</value> + </data> + <data name="kicker.derived" xml:space="preserve"> + <value>abgeleitet</value> + </data> + <data name="state.notMeasured" xml:space="preserve"> + <value>nicht gemessen</value> + </data> + <data name="state.uncounted" xml:space="preserve"> + <value>ungezählt</value> + </data> + <data name="state.unreachable" xml:space="preserve"> + <value>nicht erreichbar</value> + </data> + <data name="state.notCounted" xml:space="preserve"> + <value>nicht gezählt</value> + </data> + <data name="listing.count.none" xml:space="preserve"> + <value>keine Zählung</value> + </data> + <data name="listing.plain.fromHere" xml:space="preserve"> + <value>von hier aus</value> + </data> + <data name="listing.plain.archived" xml:space="preserve"> + <value>archiviert</value> + </data> + <data name="listing.plain.claimed" xml:space="preserve"> + <value>beansprucht</value> + </data> + <data name="random.empty.title" xml:space="preserve"> + <value>Nichts zur Auswahl</value> + </data> + <data name="random.empty.body" xml:space="preserve"> + <value>Kein Spiel passt zu diesem Filter. {listing} versuchen oder {archive}.</value> + </data> + <data name="random.empty.listing" xml:space="preserve"> + <value>das gesamte Verzeichnis</value> + </data> + <data name="random.empty.archive" xml:space="preserve"> + <value>das Archiv einbeziehen</value> + </data> + <data name="term.connected" xml:space="preserve"> + <value>Verbindungen</value> + </data> + <data name="term.unclaimed" xml:space="preserve"> + <value>nicht beansprucht</value> + </data> + <data name="term.claimedByOwner" xml:space="preserve"> + <value>vom Betreiber beansprucht</value> + </data> + <data name="term.stillProbed" xml:space="preserve"> + <value>wird weiter abgefragt</value> + </data> + <data name="term.typical" xml:space="preserve"> + <value>typisch</value> + </data> + <data name="term.peak" xml:space="preserve"> + <value>Spitze</value> + </data> + <data name="a11y.readAsText" xml:space="preserve"> + <value>als Text lesen</value> + </data> + <data name="a11y.plainText" xml:space="preserve"> + <value>Textfassung</value> + </data> + <data name="a11y.skipToContent" xml:space="preserve"> + <value>zum Inhalt springen</value> + </data> + <data name="a11y.asciiBanner" xml:space="preserve"> + <value>ASCII-Banner: der Verbindungsbildschirm von {game}.</value> + </data> + <data name="nav.catalogues" xml:space="preserve"> + <value>Kataloge</value> + </data> + <data name="nav.account" xml:space="preserve"> + <value>Diese Website und Ihr Konto</value> + </data> + <data name="nav.browse" xml:space="preserve"> + <value>stöbern</value> + </data> + <data name="nav.learn" xml:space="preserve"> + <value>lernen</value> + </data> + <data name="nav.thisSite" xml:space="preserve"> + <value>diese Website</value> + </data> + <data name="nav.menu" xml:space="preserve"> + <value>Menü</value> + </data> + <data name="nav.games" xml:space="preserve"> + <value>Spiele</value> + </data> + <data name="nav.find" xml:space="preserve"> + <value>finden</value> + </data> + <data name="nav.random" xml:space="preserve"> + <value>zufällig</value> + </data> + <data name="nav.archive" xml:space="preserve"> + <value>Archiv</value> + </data> + <data name="nav.reference" xml:space="preserve"> + <value>Referenz</value> + </data> + <data name="nav.ecosystem" xml:space="preserve"> + <value>Ökosystem</value> + </data> + <data name="nav.rankings" xml:space="preserve"> + <value>Ranglisten</value> + </data> + <data name="nav.about" xml:space="preserve"> + <value>über uns</value> + </data> + <data name="nav.submit" xml:space="preserve"> + <value>eintragen</value> + </data> + <data name="nav.submitGame" xml:space="preserve"> + <value>Spiel eintragen</value> + </data> + <data name="nav.signIn" xml:space="preserve"> + <value>anmelden</value> + </data> + <data name="nav.yourGames" xml:space="preserve"> + <value>Ihre Spiele</value> + </data> + <data name="theme.label" xml:space="preserve"> + <value>Design</value> + </data> + <data name="theme.auto" xml:space="preserve"> + <value>automatisch</value> + </data> + <data name="theme.light" xml:space="preserve"> + <value>hell</value> + </data> + <data name="theme.dark" xml:space="preserve"> + <value>dunkel</value> + </data> + <data name="banner.demo.lead" xml:space="preserve"> + <value>Demodaten.</value> + </data> + <data name="banner.demo" xml:space="preserve"> + <value>Es ist keine Datenbank konfiguriert, daher sind dies Beispieldaten. Nichts davon wurde gemessen.</value> + </data> + <data name="footer.allGames" xml:space="preserve"> + <value>alle Spiele</value> + </data> + <data name="footer.archive" xml:space="preserve"> + <value>Archiv</value> + </data> + <data name="footer.declaredByGame" xml:space="preserve"> + <value>vom Spiel angegeben</value> + </data> + <data name="footer.whatChanged" xml:space="preserve"> + <value>was sich geändert hat</value> + </data> + <data name="home.title" xml:space="preserve"> + <value>Ein Verzeichnis des MU*-Hobbys</value> + </data> + <data name="home.lede" xml:space="preserve"> + <value>Jede Tatsache nennt ihre Herkunft und ihr Alter: von unserem Crawler gemessen oder vom Spiel angegeben und als solche gekennzeichnet.</value> + </data> + <data name="home.search.label" xml:space="preserve"> + <value>Spiele nach Name, Thema, Codebase oder Host suchen</value> + </data> + <data name="home.search.placeholder" xml:space="preserve"> + <value>nach Name, Thema, Codebase oder Host suchen</value> + </data> + <data name="home.search.submit" xml:space="preserve"> + <value>suchen</value> + </data> + <data name="tile.gamesKnown" xml:space="preserve"> + <value>bekannte Spiele</value> + </data> + <data name="tile.connectedNow" xml:space="preserve"> + <value>jetzt verbunden</value> + </data> + <data name="tile.answeringUncounted" xml:space="preserve"> + <value>antwortend, ungezählt</value> + </data> + <data name="tile.archived" xml:space="preserve"> + <value>archiviert</value> + </data> + <data name="feed.newlyDiscovered" xml:space="preserve"> + <value>neu entdeckt</value> + </data> + <data name="feed.wentDark" xml:space="preserve"> + <value>verstummt — wird weiter abgefragt</value> + </data> + <data name="feed.cameBack" xml:space="preserve"> + <value>wieder da</value> + </data> + <data name="feed.nothingNew" xml:space="preserve"> + <value>Nichts Neues.</value> + </data> + <data name="feed.nothingDark" xml:space="preserve"> + <value>Nichts ist verstummt.</value> + </data> + <data name="feed.nothingBack" xml:space="preserve"> + <value>Nichts ist zurückgekehrt. Wir klopfen weiter.</value> + </data> + <data name="feed.live" xml:space="preserve"> + <value>live</value> + </data> + <data name="games.title" xml:space="preserve"> + <value>Spiele</value> + </data> + <data name="listing.sortedBy" xml:space="preserve"> + <value>sortiert nach {order}</value> + </data> + <data name="listing.random" xml:space="preserve"> + <value>zufällig</value> + </data> + <data name="listing.columns" xml:space="preserve"> + <value>Verbindungen · erreicht</value> + </data> + <data name="listing.fromHere" xml:space="preserve"> + <value>von hier aus</value> + </data> + <data name="listing.empty.head" xml:space="preserve"> + <value>Keine Treffer.</value> + </data> + <data name="listing.empty.hint" xml:space="preserve"> + <value>Weniger Wörter versuchen oder einen Filter entfernen.</value> + </data> + <data name="listing.clearFilters" xml:space="preserve"> + <value>Filter zurücksetzen</value> + </data> + <data name="listing.aboutCodebase" xml:space="preserve"> + <value>über {codebase}</value> + </data> + <data name="listing.never" xml:space="preserve"> + <value>nie</value> + </data> + <data name="listing.claimed" xml:space="preserve"> + <value>vom Betreiber beansprucht</value> + </data> + <data name="listing.unknownCodebase" xml:space="preserve"> + <value>Unbekannte Codebase</value> + </data> + <data name="listing.unknownCodebase.title" xml:space="preserve"> + <value>wir konnten die Codebase dieses Spiels nicht identifizieren</value> + </data> + <data name="listing.moreProtocols" xml:space="preserve"> + <value>und {count, plural, one {# weiteres} other {# weitere}}: {names}</value> + </data> + <data name="switch.order" xml:space="preserve"> + <value>Sortierung</value> + </data> + <data name="switch.window" xml:space="preserve"> + <value>Zeitraum</value> + </data> + <data name="switch.now" xml:space="preserve"> + <value>jetzt</value> + </data> + <data name="switch.typical" xml:space="preserve"> + <value>typisch</value> + </data> + <data name="switch.peak" xml:space="preserve"> + <value>Spitze</value> + </data> + <data name="switch.name" xml:space="preserve"> + <value>Name</value> + </data> + <data name="switch.reached" xml:space="preserve"> + <value>erreicht</value> + </data> + <data name="window.7" xml:space="preserve"> + <value>7 Tage</value> + </data> + <data name="window.30" xml:space="preserve"> + <value>30 Tage</value> + </data> + <data name="window.90" xml:space="preserve"> + <value>90 Tage</value> + </data> + <data name="filters.search.label" xml:space="preserve"> + <value>Spiele suchen</value> + </data> + <data name="filters.search.placeholder" xml:space="preserve"> + <value>Spiele suchen</value> + </data> + <data name="filters.summary" xml:space="preserve"> + <value>Filter</value> + </data> + <data name="filters.showing" xml:space="preserve"> + <value>angezeigt</value> + </data> + <data name="filters.clearAll" xml:space="preserve"> + <value>alle zurücksetzen</value> + </data> + <data name="filters.stopFiltering" xml:space="preserve"> + <value>— nicht mehr danach filtern</value> + </data> + <data name="facet.anyValue" xml:space="preserve"> + <value>beliebig</value> + </data> + <data name="facet.more" xml:space="preserve"> + <value>weitere Filter ({count})</value> + </data> + <data name="facet.moreValues" xml:space="preserve"> + <value>{count, plural, one {# weiterer} other {# weitere}}</value> + </data> + <data name="facet.alsoShow" xml:space="preserve"> + <value>zusätzlich zeigen</value> + </data> + <data name="facet.alsoShow.note" xml:space="preserve"> + <value>Standardmäßig aus. Keines von beiden ist ein Urteil über das Spiel.</value> + </data> + <data name="facet.archived" xml:space="preserve"> + <value>archiviert</value> + </data> + <data name="facet.adult" xml:space="preserve"> + <value>Erwachseneninhalte</value> + </data> + <data name="facet.archived.state" xml:space="preserve"> + <value>archivierte Spiele, {shown, select, true {angezeigt} other {verborgen}}</value> + </data> + <data name="facet.adult.state" xml:space="preserve"> + <value>Spiele, die Erwachseneninhalte angeben, {shown, select, true {angezeigt} other {verborgen}}</value> + </data> + <data name="facet.countsNote" xml:space="preserve"> + <value>Zahlen sind gemessene Spiele, nie Schätzungen.</value> + </data> + <data name="facet.key.summary" xml:space="preserve"> + <value>was die Kennzeichen und die Leerstellen bedeuten</value> + </data> + <data name="facet.key.blank" xml:space="preserve"> + <value>Eine Leerstelle ist eine Lücke in unserer Messung, kein Nein. Jede Facette benennt ihre eigene: nicht identifiziert, nicht angegeben, nichts ausgehandelt.</value> + </data> + <data name="facet.key.zero" xml:space="preserve"> + <value>Eine gemessene Null ist eine Zählung. Eine unbekannte Zählung ist keine Null und wird nie als solche sortiert.</value> + </data> + <data name="facet.key.openEnded" xml:space="preserve"> + <value>Offene Facetten listen ihre {count} häufigsten Werte. Der Rest ist über die Suche und über die URL erreichbar.</value> + </data> + <data name="facet.presence.note" xml:space="preserve"> + <value>Nicht angehakt heißt nicht gemessen — nicht, dass es dem Spiel fehlt.</value> + </data> + <data name="facet.group.band" xml:space="preserve"> + <value>Aktivität</value> + </data> + <data name="facet.group.seen" xml:space="preserve"> + <value>zuletzt gesehen</value> + </data> + <data name="facet.group.protocol" xml:space="preserve"> + <value>angebotene Protokolle</value> + </data> + <data name="facet.group.tls" xml:space="preserve"> + <value>verschlüsselt</value> + </data> + <data name="facet.group.charset" xml:space="preserve"> + <value>Kodierung</value> + </data> + <data name="facet.group.codebase" xml:space="preserve"> + <value>Codebase</value> + </data> + <data name="facet.group.version" xml:space="preserve"> + <value>Version</value> + </data> + <data name="facet.group.lineage" xml:space="preserve"> + <value>Abstammung</value> + </data> + <data name="facet.group.family" xml:space="preserve"> + <value>Familie</value> + </data> + <data name="facet.group.genre" xml:space="preserve"> + <value>Genre</value> + </data> + <data name="facet.group.language" xml:space="preserve"> + <value>Sprache</value> + </data> + <data name="facet.band.playersNow" xml:space="preserve"> + <value>jetzt verbunden</value> + </data> + <data name="facet.band.activeThisWeek" xml:space="preserve"> + <value>diese Woche aktiv</value> + </data> + <data name="facet.band.quiet" xml:space="preserve"> + <value>ruhig — nie mehr als 0 gezählt</value> + </data> + <data name="facet.band.dark" xml:space="preserve"> + <value>verstummt — seit einem Monat nicht erreicht</value> + </data> + <data name="facet.band.archived" xml:space="preserve"> + <value>archiviert</value> + </data> + <data name="facet.seen.day" xml:space="preserve"> + <value>in den letzten 24 Stunden</value> + </data> + <data name="facet.seen.week" xml:space="preserve"> + <value>in den letzten 7 Tagen</value> + </data> + <data name="facet.seen.month" xml:space="preserve"> + <value>in den letzten 30 Tagen</value> + </data> + <data name="facet.seen.older" xml:space="preserve"> + <value>länger her</value> + </data> + <data name="facet.seen.never" xml:space="preserve"> + <value>nie erreicht</value> + </data> + <data name="facet.unknown.charset" xml:space="preserve"> + <value>nichts ausgehandelt</value> + </data> + <data name="facet.unknown.codebase" xml:space="preserve"> + <value>nicht identifiziert</value> + </data> + <data name="facet.unknown.other" xml:space="preserve"> + <value>nicht angegeben</value> + </data> + <data name="facet.tls.yes" xml:space="preserve"> + <value>über TLS verbunden</value> + </data> + <data name="facet.excluded" xml:space="preserve"> + <value>nicht {value}</value> + </data> + <data name="facet.known.charset" xml:space="preserve"> + <value>etwas ausgehandelt</value> + </data> + <data name="facet.known.codebase" xml:space="preserve"> + <value>überhaupt identifiziert</value> + </data> + <data name="facet.known.other" xml:space="preserve"> + <value>überhaupt angegeben</value> + </data> + <data name="evidence.measured.meaning" xml:space="preserve"> + <value>wir haben das selbst beobachtet</value> + </data> + <data name="evidence.declared.meaning" xml:space="preserve"> + <value>das Spiel sagt es, und wir haben es nicht geprüft</value> + </data> + <data name="evidence.derived.meaning" xml:space="preserve"> + <value>wir haben gruppiert, was das Spiel uns mitgeteilt hat</value> + </data> + <data name="sort.name" xml:space="preserve"> + <value>Name</value> + </data> + <data name="sort.players" xml:space="preserve"> + <value>jetzt verbunden</value> + </data> + <data name="sort.reached" xml:space="preserve"> + <value>zuletzt erreicht</value> + </data> + <data name="sort.medianWeek" xml:space="preserve"> + <value>typisch verbunden · 7 Tage</value> + </data> + <data name="sort.medianMonth" xml:space="preserve"> + <value>typisch verbunden · 30 Tage</value> + </data> + <data name="sort.medianQuarter" xml:space="preserve"> + <value>typisch verbunden · 90 Tage</value> + </data> + <data name="sort.peakWeek" xml:space="preserve"> + <value>meiste gleichzeitig · 7 Tage</value> + </data> + <data name="sort.peakMonth" xml:space="preserve"> + <value>meiste gleichzeitig · 30 Tage</value> + </data> + <data name="sort.peakQuarter" xml:space="preserve"> + <value>meiste gleichzeitig · 90 Tage</value> + </data> + <data name="sort.group.row" xml:space="preserve"> + <value>jetzt in der Zeile</value> + </data> + <data name="sort.group.typical" xml:space="preserve"> + <value>typisch</value> + </data> + <data name="sort.group.peak" xml:space="preserve"> + <value>Spitze</value> + </data> + <data name="sort.unranked.players" xml:space="preserve"> + <value>Unbekannte Zählung</value> + </data> + <data name="sort.unranked.reached" xml:space="preserve"> + <value>noch nie erreicht — nicht etwa vor langer Zeit erreicht</value> + </data> + <data name="sort.unranked.median" xml:space="preserve"> + <value>weniger als {minimum} Zählungen im Zeitraum oder gar keine — nicht etwa eine typische Zählung von null</value> + </data> + <data name="sort.unranked.window" xml:space="preserve"> + <value>nichts, was wir im Zeitraum zählen konnten — nicht etwa ein Spiel, mit dem niemand verbunden war</value> + </data> + <data name="sort.window.median" xml:space="preserve"> + <value>Median {value} · {days, plural, one {# Tag} other {# Tage}} · {count, plural, one {# Zählung} other {# Zählungen}}</value> + </data> + <data name="sort.window.peak" xml:space="preserve"> + <value>meiste {value} gleichzeitig · {days, plural, one {# Tag} other {# Tage}} · {count, plural, one {# Zählung} other {# Zählungen}}</value> + </data> + <data name="game.connectScreen" xml:space="preserve"> + <value>Verbindungsbildschirm</value> + </data> + <data name="game.connectionsByHour" xml:space="preserve"> + <value>Verbindungen nach Stunde</value> + </data> + <data name="game.howMany" xml:space="preserve"> + <value>Wie viele, im Zeitverlauf</value> + </data> + <data name="game.reachable" xml:space="preserve"> + <value>Erreichbar</value> + </data> + <data name="game.whatChanged" xml:space="preserve"> + <value>Was sich geändert hat</value> + </data> + <data name="game.capabilities" xml:space="preserve"> + <value>Fähigkeiten</value> + </data> + <data name="game.declaredByGame" xml:space="preserve"> + <value>Vom Spiel angegeben</value> + </data> + <data name="game.referrals" xml:space="preserve"> + <value>Verweise</value> + </data> + <data name="game.unclaimed" xml:space="preserve"> + <value>Nicht beansprucht — alles hier wurde gemessen.</value> + </data> + <data name="game.claimed" xml:space="preserve"> + <value>Vom Betreiber beansprucht — die gemessenen Tatsachen unten sind weiterhin unsere.</value> + </data> + <data name="game.claim" xml:space="preserve"> + <value>Dieses Spiel beanspruchen</value> + </data> + <data name="game.answeringSince" xml:space="preserve"> + <value>antwortet seit {date}</value> + </data> + <data name="game.readAsTextRows" xml:space="preserve"> + <value>als Text lesen — {count, plural, one {# Zeile} other {# Zeilen}}</value> + </data> + <data name="capability.column" xml:space="preserve"> + <value>Fähigkeit</value> + </data> + <data name="capability.age" xml:space="preserve"> + <value>Alter</value> + </data> + <data name="capability.offered" xml:space="preserve"> + <value>angeboten</value> + </data> + <data name="capability.silent" xml:space="preserve"> + <value>stumm</value> + </data> + <data name="capability.absent" xml:space="preserve"> + <value>fehlend</value> + </data> + <data name="capability.denied" xml:space="preserve"> + <value>verweigert</value> + </data> + <data name="capability.claimed" xml:space="preserve"> + <value>behauptet</value> + </data> + <data name="capability.disagrees" xml:space="preserve"> + <value>widerspricht</value> + </data> + <data name="capability.whereTheyDisagree" xml:space="preserve"> + <value>wo sie widersprechen ({count})</value> + </data> + <data name="activity.cell.counted" xml:space="preserve"> + <value>{day} {time} — {count, plural, =0 {0 Spieler, gemessen} one {durchschnittlich # Spieler} other {durchschnittlich # Spieler}}</value> + </data> + <data name="activity.cell.notCounted" xml:space="preserve"> + <value>{day} {time} — abgefragt, keine Zählung ablesbar</value> + </data> + <data name="activity.cell.notMeasured" xml:space="preserve"> + <value>{day} {time} — keine Messung in dieser Stunde</value> + </data> + <data name="activity.none" xml:space="preserve"> + <value>Wir haben die Aktivität dieses Spiels noch nicht gemessen.</value> + </data> + <data name="activity.noCount" xml:space="preserve"> + <value>Keine Stunde der Woche hat eine Zählung ergeben.</value> + </data> + <data name="activity.allZero" xml:space="preserve"> + <value>Jede Stunde gemessen, und in keiner war jemand verbunden.</value> + </data> + <data name="activity.gap.day" xml:space="preserve"> + <value>{count, plural, one {Für # Stunde am {day} liegt noch keine Messung vor.} other {Für # Stunden am {day} liegt noch keine Messung vor.}}</value> + </data> + <data name="activity.gap.week" xml:space="preserve"> + <value>{count, plural, one {Für # Stunde der Woche liegt noch keine Messung vor.} other {Für # Stunden der Woche liegt noch keine Messung vor.}}</value> + </data> + <data name="activity.uncounted.day" xml:space="preserve"> + <value>{count, plural, one {# Stunde am {day} hat geantwortet, aber keine Zählung ergeben.} other {# Stunden am {day} haben geantwortet, aber keine Zählung ergeben.}}</value> + </data> + <data name="activity.uncounted.week" xml:space="preserve"> + <value>{count, plural, one {# Stunde der Woche hat geantwortet, aber keine Zählung ergeben.} other {# Stunden der Woche haben geantwortet, aber keine Zählung ergeben.}}</value> + </data> + <data name="activity.busiest.everyDay" xml:space="preserve"> + <value>Jeden Tag am belebtesten, {window}.</value> + </data> + <data name="activity.busiest.everyDay.part" xml:space="preserve"> + <value>Jeden Tag am belebtesten, {part}, {window}.</value> + </data> + <data name="activity.busiest.days" xml:space="preserve"> + <value>{days} am belebtesten, {window}.</value> + </data> + <data name="activity.busiest.days.part" xml:space="preserve"> + <value>{days} am belebtesten, {part}, {window}.</value> + </data> + <data name="activity.quiet" xml:space="preserve"> + <value>Verlässlich ruhig {who}, {window}.</value> + </data> + <data name="activity.quiet.part" xml:space="preserve"> + <value>Verlässlich ruhig {who} {part}, {window}.</value> + </data> + <data name="activity.quiet.everyDay" xml:space="preserve"> + <value>jeden Tag</value> + </data> + <data name="activity.quiet.everyMeasuredDay" xml:space="preserve"> + <value>an jedem gemessenen Tag</value> + </data> + <data name="activity.quiet.weekdays" xml:space="preserve"> + <value>an Wochentagen</value> + </data> + <data name="activity.quiet.onDays" xml:space="preserve"> + <value>an {days}</value> + </data> + <data name="activity.part.morning" xml:space="preserve"> + <value>morgens</value> + </data> + <data name="activity.part.afternoon" xml:space="preserve"> + <value>nachmittags</value> + </data> + <data name="activity.part.evening" xml:space="preserve"> + <value>abends</value> + </data> + <data name="activity.part.smallHours" xml:space="preserve"> + <value>nachts</value> + </data> + <data name="activity.parts.morning" xml:space="preserve"> + <value>morgens</value> + </data> + <data name="activity.parts.afternoon" xml:space="preserve"> + <value>nachmittags</value> + </data> + <data name="activity.parts.evening" xml:space="preserve"> + <value>abends</value> + </data> + <data name="activity.parts.smallHours" xml:space="preserve"> + <value>nachts</value> + </data> + <data name="activity.days.list" xml:space="preserve"> + <value>{list}, {next}</value> + </data> + <data name="activity.days.pair" xml:space="preserve"> + <value>{first} und {second}</value> + </data> + <data name="activity.sparse.kicker" xml:space="preserve"> + <value>noch nicht genug Messungen</value> + </data> + <data name="activity.sparse.none" xml:space="preserve"> + <value>Für keine Stunde der Woche liegt bisher eine Messung vor.</value> + </data> + <data name="activity.sparse.uncounted" xml:space="preserve"> + <value>{count, plural, one {# Stunde hat geantwortet und keine Zählung ergeben.} other {# Stunden haben geantwortet und keine Zählung ergeben.}}</value> + </data> + <data name="activity.sparse.wait" xml:space="preserve"> + <value>Das Raster erscheint, sobald für jeden Wochentag eine Messung vorliegt.</value> + </data> + <data name="activity.sparse.days" xml:space="preserve"> + <value>{days, plural, one {Bisher an # von sieben Tagen gemessen; das Raster erscheint, sobald jeder Tag eine gemessene Stunde hat.} other {Bisher an # von sieben Tagen gemessen; das Raster erscheint, sobald jeder Tag eine gemessene Stunde hat.}}</value> + </data> + <data name="activity.sample.zero" xml:space="preserve"> + <value>{count, plural, one {# Stunde gemessen, darin war niemand verbunden.} other {# Stunden gemessen, in allen war niemand verbunden.}}</value> + </data> + <data name="activity.sample.peak" xml:space="preserve"> + <value>{count, plural, one {# Stunde gemessen, die belebteste mit {peak} am {day} um {time} UTC.} other {# Stunden gemessen, die belebteste mit {peak} am {day} um {time} UTC.}}</value> + </data> + <data name="activity.sample.more" xml:space="preserve"> + <value>{count, plural, one {# weitere Stunde hat geantwortet und keine Zählung ergeben.} other {# weitere Stunden haben geantwortet und keine Zählung ergeben.}}</value> + </data> + <data name="activity.day.line" xml:space="preserve"> + <value>{day} — {facts}</value> + </data> + <data name="activity.day.facts" xml:space="preserve"> + <value>{first}, {second}</value> + </data> + <data name="activity.day.allZero" xml:space="preserve"> + <value>den ganzen Tag null gemessen</value> + </data> + <data name="activity.day.peak" xml:space="preserve"> + <value>Spitze {count} um {time}</value> + </data> + <data name="activity.day.nobodyOn" xml:space="preserve"> + <value>niemand verbunden {window}</value> + </data> + <data name="activity.day.noCount" xml:space="preserve"> + <value>in keiner Stunde eine Zählung</value> + </data> + <data name="activity.day.notMeasured" xml:space="preserve"> + <value>{count, plural, one {# Stunde nicht gemessen} other {# Stunden nicht gemessen}}</value> + </data> + <data name="activity.day.notCounted" xml:space="preserve"> + <value>{count, plural, one {# Stunde abgefragt, aber nicht zählbar} other {# Stunden abgefragt, aber nicht zählbar}}</value> + </data> + <data name="activity.column.day" xml:space="preserve"> + <value>Tag</value> + </data> + <data name="activity.column.quietest" xml:space="preserve"> + <value>ruhigste</value> + </data> + <data name="activity.column.busiest" xml:space="preserve"> + <value>belebteste</value> + </data> + <data name="activity.column.at" xml:space="preserve"> + <value>um</value> + </data> + <data name="activity.column.noCount" xml:space="preserve"> + <value>keine Zählung</value> + </data> + <data name="activity.caption" xml:space="preserve"> + <value>Verbundene Spieler nach Tag, in UTC. {window}.</value> + </data> + <data name="activity.times" xml:space="preserve"> + <value>Zeiten in UTC · {window}</value> + </data> + <data name="activity.rollingAverage" xml:space="preserve"> + <value>{weeks, plural, one {gleitender Durchschnitt über # Woche} other {gleitender Durchschnitt über # Wochen}}</value> + </data> + <data name="activity.legend.counted" xml:space="preserve"> + <value>gezählt, auch eine gemessene Null</value> + </data> + <data name="activity.legend.notCounted" xml:space="preserve"> + <value>abgefragt, keine Zählung ablesbar</value> + </data> + <data name="activity.legend.notMeasured" xml:space="preserve"> + <value>keine Messung in dieser Stunde</value> + </data> + <data name="activity.plain.heading" xml:space="preserve"> + <value>Wann Spieler verbunden sind (UTC)</value> + </data> + <data name="activity.key.counted" xml:space="preserve"> + <value>gezählt</value> + </data> + <data name="activity.key.counted.meaning" xml:space="preserve"> + <value>wir sind hineingekommen und haben eine Zahl abgelesen, auch eine gemessene Null</value> + </data> + <data name="activity.key.uncounted.meaning" xml:space="preserve"> + <value>wir sind hineingekommen, aber keine Zahl war ablesbar</value> + </data> + <data name="activity.key.notMeasured.meaning" xml:space="preserve"> + <value>für diese Stunde liegt uns keine Messung vor</value> + </data> + <data name="locale.label" xml:space="preserve"> + <value>Sprache</value> + </data> + <data name="locale.submit" xml:space="preserve"> + <value>Sprache wechseln</value> + </data> + <data name="about.title" xml:space="preserve"> + <value>Über mu*index</value> + </data> + <data name="about.lede" xml:space="preserve"> + <value>Jedes Spiel hier wurde von einer Maschine gemessen, die sich mit ihm verbunden hat, und jeder Wert nennt seine Herkunft und seinen Zeitpunkt. Diese Seite behandelt, was das belegt, was wir falsch machen, wessen Verzeichnisse wir lesen und wie sich der Crawler stoppen lässt.</value> + </data> + <data name="about.measures.heading" xml:space="preserve"> + <value>Was hier eine Tatsache ist</value> + </data> + <data name="about.measures.declared.lead" xml:space="preserve"> + <value>Gemessen schlägt angegeben, und beides wird gezeigt.</value> + </data> + <data name="about.measures.declared.body" xml:space="preserve"> + <value>Der MSSP-Bericht eines Spiels ist das Spiel, das sich selbst beschreibt. Der Telnet-Handshake ist das, was wir es haben tun sehen. Beides steht auf seiner Seite, versehen mit dem Wie und dem Wann. Wo beides sich widerspricht, zeigen wir den Widerspruch.</value> + </data> + <data name="about.measures.count.lead" xml:space="preserve"> + <value>Eine Spielerzahl nennt ihre Herkunft.</value> + </data> + <data name="about.measures.count.body" xml:space="preserve"> + <value>Entweder ein WHO oder DOING, am Verbindungsbildschirm gelesen und von uns gezählt, oder das MSSP-Feld PLAYERS des Spiels selbst, das es veröffentlicht hat. Niemals zusammengeführt.</value> + </data> + <data name="about.measures.unknown.lead" xml:space="preserve"> + <value>Eine Antwort, die wir nicht lesen können, ist unbekannt, niemals null.</value> + </data> + <data name="about.measures.unknown.body" xml:space="preserve"> + <value>Server passen ihre WHO-Kopfzeilen frei an, und ab einem gewissen Punkt kann unser Parser eine solche nicht mehr lesen. Das ist unzählbar, ein eigener Zustand. Eine gemessene Null — wir sind hineingekommen, und niemand war da — ist eine Zählung und wird als solche ausgegeben.</value> + </data> + <data name="about.measures.reachable.lead" xml:space="preserve"> + <value>Erreichbar, niemals Uptime.</value> + </data> + <data name="about.measures.reachable.body" xml:space="preserve"> + <value>Wir öffnen in Abständen einen Socket von einem einzigen Host aus. Ein Spiel, zu dem wir keine Route finden, ist nicht erreichbar und dennoch völlig lebendig. Nichts hier behauptet die Uptime eines Spiels, denn nichts hier hat sie gemessen.</value> + </data> + <data name="about.measures.hour.lead" xml:space="preserve"> + <value>Eine Stunde ist gezählt, unzählbar oder nicht gemessen.</value> + </data> + <data name="about.measures.hour.body" xml:space="preserve"> + <value>Das Aktivitätsraster hat drei Zustände. Der dritte ist leer und nennt keine Ursache: eine Stunde, die wir nicht erreichen konnten, und eine Stunde, die wir nie abgefragt haben, sind dieselbe Leerstelle, und keine von beiden ist die Ausfallzeit dieses Servers.</value> + </data> + <data name="about.limits.heading" xml:space="preserve"> + <value>Was wir falsch machen, soweit wir es wissen</value> + </data> + <data name="about.limits.grace.lead" xml:space="preserve"> + <value>Die Schonfrist bis zum Archiv wird ab dem Tag gemessen, an dem wir Sie gefunden haben.</value> + </data> + <data name="about.limits.grace.body" xml:space="preserve"> + <value>Ein Spiel, das nicht mehr antwortet, verlässt nach seiner Schonfrist das Standardverzeichnis: ein Viertel der erreichbaren Zeit, die wir abgefragt haben, mindestens 60 und höchstens 365 Tage. Ein Spiel, das seit 1995 läuft, beginnt am Tag seiner Entdeckung beim Minimum. Wir importieren nichts, um die Jahre vor unserer Ankunft aufzufüllen.</value> + </data> + <data name="about.limits.created.lead" xml:space="preserve"> + <value>MSSP CREATED wird auf diese Schonfrist nicht angerechnet.</value> + </data> + <data name="about.limits.created.body" xml:space="preserve"> + <value>Es ist eine von Hand getippte Zeile in einer Konfigurationsdatei; sie anzurechnen würde die Archivschwelle manipulierbar machen. Sie wird als Angabe gezeigt und bringt nichts ein.</value> + </data> + <data name="about.limits.claim.lead" xml:space="preserve"> + <value>Ein beanspruchtes Spiel erhält das Maximum.</value> + </data> + <data name="about.limits.claim.body" xml:space="preserve"> + <value>Der Nachweis von Serverzugriff ist das volle Jahr Schonfrist wert, gleich wie lange wir schon zusehen.</value> + </data> + <data name="about.limits.oneHost.lead" xml:space="preserve"> + <value>Alles hier ist ein einziger Host, der in Abständen hinsieht.</value> + </data> + <data name="about.limits.oneHost.body" xml:space="preserve"> + <value>Ein Prozentsatz erreichbarer Zeit ist ein Anteil des von uns beobachteten Zeitraums, nie eines anderen. Keine Grafik hier füllt den Rest auf.</value> + </data> + <data name="about.limits.deletion.lead" xml:space="preserve"> + <value>Nichts wird jemals gelöscht.</value> + </data> + <data name="about.limits.deletion.body" xml:space="preserve"> + <value>Das Archivieren nimmt ein Spiel aus dem Standardverzeichnis, aus den Ranglisten und aus der Zahl der heute aktiven Spiele heraus, und sonst nichts. Seine Seite, seine URL, seine Geschichte und seine Adresse bleiben, es wird weiter abgefragt, und eine einzige erfolgreiche Abfrage bringt es zurück.</value> + </data> + <data name="about.never.heading" xml:space="preserve"> + <value>Was diese Website nicht tut</value> + </data> + <data name="about.never.votes.lead" xml:space="preserve"> + <value>Keine Stimmen, Sterne, Bewertungen oder Empfehlungen.</value> + </data> + <data name="about.never.votes.body" xml:space="preserve"> + <value>Ranglisten werden ausschließlich aus gemessenen Daten berechnet. Ein Verzeichnis, das danach sortiert, wer die meisten Klicks mobilisieren kann, beschreibt den Wahlkampf und nicht das Hobby — und genau daran sind die Vorgänger zugrunde gegangen.</value> + </data> + <data name="about.never.forums.lead" xml:space="preserve"> + <value>Keine Foren, Rezensionen, Wikis, Kommentare oder Spielerprofile.</value> + </data> + <data name="about.never.forums.body" xml:space="preserve"> + <value>Einführendes Material — was ein MUSH ist, welche Codebase zu gemeinsamem Rollenspiel passt — wird geschrieben, namentlich gezeichnet und versioniert wie der Rest der Website.</value> + </data> + <data name="about.never.names.lead" xml:space="preserve"> + <value>Spielernamen werden nie gespeichert.</value> + </data> + <data name="about.never.names.body" xml:space="preserve"> + <value>Eine WHO-Antwort wird im Arbeitsspeicher auf eine Zahl und die Form der Kopfzeile hin ausgewertet. Die Namen werden nicht festgehalten; Aggregate verwenden einen gesalzenen Hash mit rotierendem Salt.</value> + </data> + <data name="about.never.population.lead" xml:space="preserve"> + <value>Es wird keine absolute Spielerzahl veröffentlicht.</value> + </data> + <data name="about.never.population.body" xml:space="preserve"> + <value>Anteile pro Codebase und pro Protokoll werden veröffentlicht: Ein Verhältnis über die gemessene Menge übersteht die Spiele, die wir nicht zählen können. „Wie viele Menschen spielen MU*“ übersteht das nicht, denn diese Zahl würde es nicht überstehen, zitiert zu werden.</value> + </data> + <data name="about.crawler.heading" xml:space="preserve"> + <value>Der Crawler und wie er sich stoppen lässt</value> + </data> + <data name="about.crawler.probe.lead" xml:space="preserve"> + <value>Eine Abfrage ist eine Verbindung, die sich nie anmeldet.</value> + </data> + <data name="about.crawler.probe.body" xml:space="preserve"> + <value>Sie öffnet einen Socket, handelt Telnet-Optionen aus, liest den Verbindungsbildschirm, fragt MSSP über Option 70 an, sendet {commands} und trennt die Verbindung. Kein Charakter, keine Anmeldung, nichts auf der Gegenseite verändert. Ein Timeout begrenzt die Sitzung, damit eine hängengebliebene Abfrage keinen Verbindungsplatz belegt.</value> + </data> + <data name="about.crawler.delay.lead" xml:space="preserve"> + <value>CRAWL DELAY hat Vorrang.</value> + </data> + <data name="about.crawler.delay.body" xml:space="preserve"> + <value>Ein Spiel, das in seinem MSSP-Bericht einen bevorzugten Mindestabstand nennt, bekommt ihn — in beide Richtungen vor unserem eigenen Zeitplan: 720 Stunden heißt monatlich, nicht wöchentlich. Ein verstummtes Spiel wird im längeren Abstand für immer weiter versucht; so trägt es sich selbst wieder ein, wenn es zurückkommt.</value> + </data> + <data name="about.crawler.referral.lead" xml:space="preserve"> + <value>Eine per Verweis genannte Adresse wird geprüft, nie geglaubt.</value> + </data> + <data name="about.crawler.referral.body" xml:space="preserve"> + <value>MSSP erlaubt es einem Spiel, andere Spiele zu nennen. Jeder Name wird aufgelöst, bevor irgendetwas angewählt wird, und abgelehnt, sofern nicht jede Adresse, auf die er auflöst, global routbar ist. Eine gemischte Antwort lehnt das ganze Ziel ab. Unsere Ablehnung wird als unsere verbucht und erscheint nie als Ausfallzeit im Datensatz eines Spiels.</value> + </data> + <data name="about.crawler.screens.lead" xml:space="preserve"> + <value>Verbindungsbildschirme werden gezeigt, weil sie an alle gesendet werden.</value> + </data> + <data name="about.crawler.screens.body" xml:space="preserve"> + <value>Ein Server malt seinen Verbindungsbildschirm ohne Anmeldung an jede anonyme Verbindung. Wir zeigen ihn als Beleg und kennzeichnen ihn. Auf Bitte hin verschwindet er.</value> + </data> + <data name="about.crawler.stop.lead" xml:space="preserve"> + <value>Ein Stopp genügt, und wir hören auf — auf drei Wegen.</value> + </data> + <data name="about.crawler.stop.body" xml:space="preserve"> + <value>Veröffentlichen Sie {variable} 1 in Ihrem MSSP-Bericht, dann ist die Abfrage, die es liest, die letzte. Oder veröffentlichen Sie einen TXT-Eintrag unter {label}.your.host mit dem Inhalt „{value}“, wofür es keine MSSP-Unterstützung und kein Konto hier braucht. Oder schreiben Sie einer Person. Alle drei werden innerhalb eines Crawl-Zyklus befolgt, mit Datum und dem Gelesenen festgehalten und auch im Eintragungsformular durchgesetzt.</value> + </data> + <data name="about.crawler.scope.lead" xml:space="preserve"> + <value>Das MSSP-Feld stoppt diesen Listener; der TXT-Eintrag stoppt den Host.</value> + </data> + <data name="about.crawler.scope.body" xml:space="preserve"> + <value>MSSP wird von dem Port veröffentlicht, der geantwortet hat, und spricht daher für diesen Port — beim MU*-Hosting laufen regelmäßig unabhängige Spiele auf einer Domain, und keines darf sein Nachbarspiel zum Schweigen bringen. Ein TXT-Eintrag umfasst jeden Port, sofern er nicht einen einzelnen nennt, etwa „{value}=4201“. Alles dort, was wir nicht als Portliste lesen können, meint den ganzen Host; deshalb funktioniert auch „{value}=all“.</value> + </data> + <data name="about.crawler.dns.lead" xml:space="preserve"> + <value>Der Weg über DNS ist der, den Sie ohne Rückfrage bei uns rückgängig machen können.</value> + </data> + <data name="about.crawler.dns.body" xml:space="preserve"> + <value>Ein TXT-Eintrag lässt sich lesen, ohne sich mit einem Server zu verbinden, der uns das untersagt hat; deshalb lesen wir ihn vor jeder Anwahl neu. Löschen Sie ihn, und wir wählen binnen einer Woche wieder an. Ein MSSP-Feld lässt sich nicht neu lesen, ohne genau das zu tun, was Sie uns untersagt haben; deshalb gelten ein Ausschluss per MSSP und schriftliche Bitten so lange, bis Sie etwas anderes sagen. Dieser TXT-Abruf ist alles, was eine ausgeschlossene Adresse noch bekommt: Er berührt Ihren Nameserver, nie Ihr Spiel.</value> + </data> + <data name="about.crawler.stopping.lead" xml:space="preserve"> + <value>Aufhören ist kein Löschen, und es ist keine Ausfallzeit.</value> + </data> + <data name="about.crawler.stopping.body" xml:space="preserve"> + <value>Ein Spiel, das sich ausschließen lässt, behält seine Seite, seine Adresse und alles, was wir vor der Bitte gemessen haben. Nur neue Daten hören auf: Das Aktivitätsraster gewinnt keine Stunden mehr hinzu und nennt keine Ursache, denn unsere Entscheidung, nicht mehr anzuklopfen, ist eine Tatsache über uns. Sie wird bei dem Crawl festgehalten, der nicht stattgefunden hat, und im Register derer, die darum gebeten haben.</value> + </data> + <data name="about.crawler.unlist.lead" xml:space="preserve"> + <value>Wenn Aufhören nicht genügt, kann auch der Eintrag verschwinden.</value> + </data> + <data name="about.crawler.unlist.body" xml:space="preserve"> + <value>Sobald wir für jede Adresse, unter der Ihr Spiel antwortet, aufgehört haben, bietet Ihre Übersicht eine weitere Möglichkeit: es aus dem Verzeichnis, aus den Ranglisten und aus der Tageszahl herauszunehmen. Die Seite und jede Adresse, die es je hatte, antworten weiterhin, und nichts wird gelöscht — es ist nur kein Ort mehr, an dem man beim Stöbern ankommt. Dafür braucht es einen bestätigten Anspruch, denn es ist eine Entscheidung über Ihr Spiel, und wir halten fest, wer sie getroffen hat. Und eine Abfrage macht sie rückgängig: Nehmen Sie Ihren Ausschluss zurück, dann bringt die nächste Anwahl, die eine Antwort erhält, Sie wieder ins Verzeichnis, ohne dass Sie uns ein zweites Mal fragen müssen.</value> + </data> + <data name="about.identity.announced" xml:space="preserve"> + <value>Der Crawler nennt sich {name}, wenn ein Server fragt, was er ist.</value> + </data> + <data name="about.identity.unannounced" xml:space="preserve"> + <value>Der Crawler ist so konfiguriert, dass er sich {name} nennt, kann das aber noch nicht mitteilen. Seine Telnet-Bibliothek bietet einem Client keine Möglichkeit, den Terminaltyp zu setzen; deshalb steht in Ihren Logs der Standardwert dieser Bibliothek, und NEW-ENVIRON wird aus der Umgebung des Crawler-Hosts beantwortet. Beides sind Lücken in der Bibliothek und von uns dort zu beheben. Bis dahin erkennen Sie eine Abfrage an ihrer Form: eine Verbindung, keine Anmeldung, ein kurzer, nur lesender Befehlssatz, weg.</value> + </data> + <data name="about.identity.crawler" xml:space="preserve"> + <value>Crawler</value> + </data> + <data name="about.identity.contact" xml:space="preserve"> + <value>Kontakt</value> + </data> + <data name="about.identity.crawler.line" xml:space="preserve"> + <value>Crawler: {name}</value> + </data> + <data name="about.identity.contact.line" xml:space="preserve"> + <value>Kontakt: {url}</value> + </data> + <data name="about.identity.placeholder" xml:space="preserve"> + <value>— Platzhalter; diese Installation hat keine Kontaktadresse gesetzt</value> + </data> + <data name="about.identity.placeholder.plain" xml:space="preserve"> + <value>Es ist keine Kontaktadresse konfiguriert; die obige ist daher ein Platzhalter und antwortet niemandem.</value> + </data> + <data name="about.sources.heading" xml:space="preserve"> + <value>Woher die Liste der Spiele stammt</value> + </data> + <data name="about.sources.addresses.lead" xml:space="preserve"> + <value>Wir übernehmen Adressen. Sonst nichts.</value> + </data> + <data name="about.sources.addresses.body" xml:space="preserve"> + <value>Ein Backfill übernimmt einen Host und einen Port. Keine Spielerzahlen, keine Erreichbarkeitsverläufe, keine Beschreibungen, keine Felder und keinen Vermerk, von welcher Website eine Adresse stammt.</value> + </data> + <data name="about.sources.less.lead" xml:space="preserve"> + <value>Bewusst weniger, als diese Websites hergeben.</value> + </data> + <data name="about.sources.less.body" xml:space="preserve"> + <value>Mehrere davon halten jahrelange, datierte Spielerzahlen bereit. Diese zu importieren würde die Aktivitätsraster genau der Spiele füllen, die schon jemand anderes beobachtet hat, und die zentrale Behauptung dieser Website auf die Abfragen eines Dritten stützen.</value> + </data> + <data name="about.sources.origin.lead" xml:space="preserve"> + <value>Die Herkunft eines Spiels ist keine einzelne Tatsache.</value> + </data> + <data name="about.sources.origin.body" xml:space="preserve"> + <value>Jedes Spiel, das einen Eintrag wert ist, steht in mehreren dieser Verzeichnisse; „importiert aus“ würde also nur den Abruf nennen, der zuerst lief. Dass ein Spiel existiert, ist öffentlich bekannt; wo wir es gelesen haben, fügt nichts hinzu und ist der Teil fremder Arbeit, auf den wir am wenigsten Anspruch haben.</value> + </data> + <data name="about.sources.etiquette.lead" xml:space="preserve"> + <value>Die Website eines anderen zu lesen bleibt: die Website eines anderen zu lesen.</value> + </data> + <data name="about.sources.etiquette.body" xml:space="preserve"> + <value>Wir bitten vor dem Scrapen um einen Massenexport oder einen dokumentierten Endpunkt, lesen zuerst robots.txt und drosseln Scrapes stark. Eine Quelle, die das Einverständnis ihrer Betreuung braucht, wird erst abgerufen, wenn eine Person bestätigen kann, dass gefragt wurde.</value> + </data> + <data name="about.source.read" xml:space="preserve"> + <value>gelesen — nur Adressen</value> + </data> + <data name="about.source.withheld" xml:space="preserve"> + <value>nicht gelesen — Erlaubnis ausstehend</value> + </data> + <data name="about.source.tintinMssp.note" xml:space="preserve"> + <value>Eine Seite, eine Anfrage. Veröffentlicht von einem Crawler, der sich mit jedem Spiel verbindet und ausgibt, was er gelesen hat.</value> + </data> + <data name="about.source.tintinMsdp.note" xml:space="preserve"> + <value>Die MSDP-Liste desselben Crawlers. Fast eine Teilmenge ihres MSSP-Gegenstücks; gelesen wegen der wenigen Adressen, die sie erreicht und das andere nicht.</value> + </data> + <data name="about.source.mudConnector.note" xml:space="preserve"> + <value>Veröffentlicht seinen gesamten Katalog auf einer Seite, das Lesen kostet also eine einzige Anfrage. Unsere größte Quelle für Adressen und für keinerlei Messungen.</value> + </data> + <data name="about.source.mudStats.note" xml:space="preserve"> + <value>Eine Übersichtsseite und je eine Seite pro Welt, also ein Scrape statt eines Exports. Am 30. Juli 2026 haben wir 143 ihrer Seiten abgerufen, im Abstand von fünfzehn Sekunden und unter Beachtung von robots.txt, aber bevor ihnen jemand geschrieben hatte. Das hätte nicht geschehen dürfen. Die Sperre verlangt nun eine Person, die bestätigt, dass die Betreuung gefragt wurde.</value> + </data> + <data name="about.source.mudVerse.note" xml:space="preserve"> + <value>Implementiert, getestet, nie ausgeführt. Die stärkste Quelle hier in jeder Hinsicht außer der Erlaubnis; es wird nichts abgerufen, bevor ihnen jemand geschrieben hat.</value> + </data> + <data name="about.licence.heading" xml:space="preserve"> + <value>Lizenz</value> + </data> + <data name="about.licence.code.lead" xml:space="preserve"> + <value>Der Code steht unter MIT.</value> + </data> + <data name="about.licence.code.body" xml:space="preserve"> + <value>Die Website, der Crawler und die Parser sind Open Source unter der MIT-Lizenz.</value> + </data> + <data name="about.licence.open.lead" xml:space="preserve"> + <value>Die Lizenz für die Daten ist eine offene Frage.</value> + </data> + <data name="about.licence.open.body" xml:space="preserve"> + <value>Eine vom Code getrennte Entscheidung, und noch nicht getroffen. Die Bedingungen unten sind die derzeitige Antwort dieser Installation, nicht die feststehende Haltung des Projekts. Dass ein konkurrierendes Verzeichnis den gesamten Katalog übernimmt, gilt hier als Erfolg; was auch immer festgelegt wird, wird einem solchen nicht im Weg stehen.</value> + </data> + <data name="about.licence.codeLabel" xml:space="preserve"> + <value>Code</value> + </data> + <data name="about.licence.dataLabel" xml:space="preserve"> + <value>Daten, so wie diese Installation sie ausliefert</value> + </data> + <data name="about.licence.creditLabel" xml:space="preserve"> + <value>Namensnennung als</value> + </data> + <data name="about.licence.code.line" xml:space="preserve"> + <value>Code: {licence}</value> + </data> + <data name="about.licence.data.line" xml:space="preserve"> + <value>Daten: {licence}</value> + </data> + <data name="about.licence.credit.line" xml:space="preserve"> + <value>Namensnennung als: {credit}</value> + </data> + <data name="about.licence.deployment" xml:space="preserve"> + <value>(was diese Installation ausliefert. Die eigene Antwort des Projekts ist noch offen.)</value> + </data> + <data name="submit.title" xml:space="preserve"> + <value>Ein Spiel eintragen</value> + </data> + <data name="submit.lede" xml:space="preserve"> + <value>Uns mitteilen, wo ein Spiel ist. Ein Host und ein Port sind das ganze Formular; alles andere auf dieser Website misst unser eigener Crawler.</value> + </data> + <data name="submit.host.label" xml:space="preserve"> + <value>Host</value> + </data> + <data name="submit.port.label" xml:space="preserve"> + <value>Port</value> + </data> + <data name="submit.host.hint" xml:space="preserve"> + <value>mud.example.org, oder mud.example.org:4201 einfügen und den Port leer lassen</value> + </data> + <data name="submit.button" xml:space="preserve"> + <value>Eintragen</value> + </data> + <data name="submit.noCatalogue" xml:space="preserve"> + <value>Das Eintragen braucht eine Datenbank, und diese Website läuft auf den Demodaten. Es gibt kein Crawl-Register zum Hineinschreiben, deshalb fehlt das Formular, statt still nichts zu tun.</value> + </data> + <data name="submit.notHere" xml:space="preserve"> + <value>Nicht hier</value> + </data> + <data name="submit.what.heading" xml:space="preserve"> + <value>Was mit einer Adresse geschieht</value> + </data> + <data name="submit.what.resolve" xml:space="preserve"> + <value>Wir lösen die Adresse auf, bevor wir sie anwählen, und lehnen alles ab, was außerhalb des öffentlichen Internets auflöst. Das ist eine Entscheidung über unseren eigenen Socket, nie eine Tatsache über ein Spiel.</value> + </data> + <data name="submit.what.optOut" xml:space="preserve"> + <value>Wenn die Betreiber dieses Hosts uns gebeten haben, ihn nicht zu crawlen, nehmen wir die Adresse nicht an, gleich wer sie einträgt. Fremde können Ihr Spiel nicht zurück auf diese Website bringen.</value> + </data> + <data name="submit.what.schedule" xml:space="preserve"> + <value>Antwortet sie, lesen wir, was der Server über sich selbst sagt, und lesen es nach seinem eigenen Zeitplan für immer weiter. Eine Adresse muss nur einmal genannt werden.</value> + </data> + <data name="submit.what.claim" xml:space="preserve"> + <value>Nichts erscheint auf der Website, bis jemand nachweist, dass er es betreibt. Ein Anspruch braucht einen Passkey und eine im Spiel selbst veröffentlichte Zeile.</value> + </data> + <data name="submit.what.duplicate" xml:space="preserve"> + <value>Eine Adresse, die wir bereits haben, fällt mit dem bestehenden Eintrag zusammen. Zweimal senden erzeugt keinen zweiten Eintrag und zieht keine Abfrage vor.</value> + </data> + <data name="submit.answer.thatAddress" xml:space="preserve"> + <value>diese Adresse</value> + </data> + <data name="submit.accepted.heading" xml:space="preserve"> + <value>Im Register.</value> + </data> + <data name="submit.accepted.sentence" xml:space="preserve"> + <value>{address} wird im nächsten Crawl-Zyklus angewählt, danach für immer nach eigenem Zeitplan. Sobald jemand nachweist, dass er es betreibt, erscheint es hier — kommen Sie mit derselben Adresse zu diesem Formular zurück, dann bekommen Sie hier den Link dazu.</value> + </data> + <data name="submit.unclaimed.heading" xml:space="preserve"> + <value>Wir haben es, nicht beansprucht.</value> + </data> + <data name="submit.unclaimed.sentence" xml:space="preserve"> + <value>{address} messen wir bereits. Es bleibt von der Website fern, bis jemand nachweist, dass er es betreibt. Sind Sie das, geht es hier hinein.</value> + </data> + <data name="submit.known.heading" xml:space="preserve"> + <value>Das haben wir schon.</value> + </data> + <data name="submit.known.sentence" xml:space="preserve"> + <value>{address} ist ein Spiel, das wir bereits messen. Es wurde nichts angelegt und nichts geändert.</value> + </data> + <data name="submit.knownAddress.heading" xml:space="preserve"> + <value>Diese Adresse haben wir schon.</value> + </data> + <data name="submit.knownAddress.sentence" xml:space="preserve"> + <value>{address} ist uns bereits bekannt. Es wurde nichts angelegt und nichts geändert.</value> + </data> + <data name="submit.queued.heading" xml:space="preserve"> + <value>Wartet bereits.</value> + </data> + <data name="submit.queued.sentence" xml:space="preserve"> + <value>{address} steht im Crawl-Register und hat noch nicht geantwortet. Erneutes Senden zieht sie nicht vor: Ein Ziel behält seinen eigenen Zeitplan, damit niemand uns am Server eines anderen antreiben kann.</value> + </data> + <data name="submit.malformed.heading" xml:space="preserve"> + <value>Keine Adresse, die wir anwählen können.</value> + </data> + <data name="submit.malformed.sentence" xml:space="preserve"> + <value>Ein Host braucht einen Punkt oder einen Doppelpunkt, und ein Port ist eine Zahl zwischen 1 und 65535. Beide Felder ausfüllen oder mud.example.org:4201 in das erste einfügen.</value> + </data> + <data name="submit.undialable.heading" xml:space="preserve"> + <value>Das können wir nicht anwählen.</value> + </data> + <data name="submit.undialable.sentence" xml:space="preserve"> + <value>Für {address} führen drei Dinge zu dieser Antwort: Der Name löst womöglich nicht auf, er löst womöglich außerhalb des öffentlichen Internets auf, oder die Betreiber dieses Hosts haben uns gebeten, fernzubleiben. Wir sagen bewusst nicht, welches davon, denn das für Fremde zu beantworten kartiert ein Netz von außen. Über die Adresse wurde nichts festgehalten; die Entscheidung war unsere und ist als unsere verbucht.</value> + </data> + <data name="submit.tooMany.heading" xml:space="preserve"> + <value>Genug für jetzt.</value> + </data> + <data name="submit.tooMany.sentence" xml:space="preserve"> + <value>Dieses Formular ist pro Absender begrenzt, und Sie haben die Grenze erreicht. Kommen Sie in einer Stunde wieder. Nichts ging verloren — was wir angenommen haben, steht bereits im Register.</value> + </data> + <data name="submit.link.claim" xml:space="preserve"> + <value>dieses Spiel beanspruchen</value> + </data> + <data name="account.signIn.title" xml:space="preserve"> + <value>Anmelden</value> + </data> + <data name="account.signIn.preview" xml:space="preserve"> + <value>Melden Sie sich mit einem Passkey an, um ein Spiel zu beanspruchen, das Sie betreiben. Es gibt kein Passwort, das verloren gehen, und keines, das gestohlen werden kann.</value> + </data> + <data name="account.signIn.noDatabase" xml:space="preserve"> + <value>Das Beanspruchen braucht eine Datenbank, und diese Website läuft auf den Demodaten. Es gibt nichts, wo man sich anmelden könnte.</value> + </data> + <data name="account.signIn.passkey.lead" xml:space="preserve"> + <value>Die Anmeldung ist ein Passkey.</value> + </data> + <data name="account.signIn.passkey.body" xml:space="preserve"> + <value>Ihr Gerät oder Ihr Passwortmanager hält den privaten Schlüssel; wir halten nur die öffentliche Hälfte. Kein Passwort, keine E-Mail.</value> + </data> + <data name="account.signIn.button" xml:space="preserve"> + <value>Mit einem Passkey anmelden</value> + </data> + <data name="account.signIn.script" xml:space="preserve"> + <value>Die einzige Seite hier, die JavaScript braucht. Passkeys funktionieren ohne es nicht.</value> + </data> + <data name="account.register.heading" xml:space="preserve"> + <value>Noch kein Konto?</value> + </data> + <data name="account.register.lede" xml:space="preserve"> + <value>Sie brauchen eines nur, um ein Spiel zu beanspruchen, das Sie betreiben. Wählen Sie einen Namen, unter dem Sie erscheinen — eine Beschriftung neben Ihrem Anspruch, kein echter Name.</value> + </data> + <data name="account.register.name.label" xml:space="preserve"> + <value>Name</value> + </data> + <data name="account.register.name.placeholder" xml:space="preserve"> + <value>z. B. corvid-admin</value> + </data> + <data name="account.register.button" xml:space="preserve"> + <value>Konto mit einem Passkey anlegen</value> + </data> + <data name="account.store.heading" xml:space="preserve"> + <value>Was wir speichern</value> + </data> + <data name="account.store.name" xml:space="preserve"> + <value>Den Namen, den Sie gewählt haben.</value> + </data> + <data name="account.store.keys" xml:space="preserve"> + <value>Den öffentlichen Schlüssel jedes Passkeys, den Sie registrieren, und den Namen, den Ihr Gerät ihm gegeben hat.</value> + </data> + <data name="account.store.claims" xml:space="preserve"> + <value>Welche Spiele Sie beansprucht haben und wann.</value> + </data> + <data name="account.store.note" xml:space="preserve"> + <value>Keine E-Mail-Adresse, kein Passwort, kein an Ihr Konto gebundenes IP-Protokoll. Verlieren Sie alle Passkeys, können Sie einen frischen Anspruchs-Token in Ihrem Spiel veröffentlichen und von vorn beginnen: Der Beweis ist das Spiel, nicht das Konto.</value> + </data> + <data name="date.absolute" xml:space="preserve"> + <value>{day}. {month} {year}</value> + </data> + <data name="date.stamp" xml:space="preserve"> + <value>{date} {time} UTC</value> + </data> + <data name="age.short.now" xml:space="preserve"> + <value>jetzt</value> + </data> + <data name="age.short.minutes" xml:space="preserve"> + <value>{count, plural, one {# Min} other {# Min}}</value> + </data> + <data name="age.short.hours" xml:space="preserve"> + <value>{count, plural, one {# Std} other {# Std}}</value> + </data> + <data name="age.short.days" xml:space="preserve"> + <value>{count, plural, one {# T} other {# T}}</value> + </data> + <data name="age.short.weeks" xml:space="preserve"> + <value>{count, plural, one {# W} other {# W}}</value> + </data> + <data name="age.short.months" xml:space="preserve"> + <value>{count, plural, one {# Mon} other {# Mon}}</value> + </data> + <data name="age.short.years" xml:space="preserve"> + <value>{count, plural, one {# J} other {# J}}</value> + </data> + <data name="age.ago.now" xml:space="preserve"> + <value>gerade eben</value> + </data> + <data name="age.ago.minutes" xml:space="preserve"> + <value>{count, plural, one {vor # Min} other {vor # Min}}</value> + </data> + <data name="age.ago.hours" xml:space="preserve"> + <value>{count, plural, one {vor # Std} other {vor # Std}}</value> + </data> + <data name="age.ago.days" xml:space="preserve"> + <value>{count, plural, one {vor # T} other {vor # T}}</value> + </data> + <data name="age.ago.weeks" xml:space="preserve"> + <value>{count, plural, one {vor # W} other {vor # W}}</value> + </data> + <data name="age.ago.months" xml:space="preserve"> + <value>{count, plural, one {vor # Mon} other {vor # Mon}}</value> + </data> + <data name="age.ago.years" xml:space="preserve"> + <value>{count, plural, one {vor # J} other {vor # J}}</value> + </data> + <data name="age.dark.now" xml:space="preserve"> + <value>gerade eben</value> + </data> + <data name="age.dark.minutes" xml:space="preserve"> + <value>{count, plural, one {vor # Min} other {vor # Min}}</value> + </data> + <data name="age.dark.hours" xml:space="preserve"> + <value>{count, plural, one {vor # Std} other {vor # Std}}</value> + </data> + <data name="age.dark.days" xml:space="preserve"> + <value>{count, plural, one {vor # T} other {vor # T}}</value> + </data> + <data name="age.dark.weeks" xml:space="preserve"> + <value>{count, plural, one {vor # W} other {vor # W}}</value> + </data> + <data name="age.dark.months" xml:space="preserve"> + <value>{count, plural, one {vor # Mon} other {vor # Mon}}</value> + </data> + <data name="age.dark.years" xml:space="preserve"> + <value>{count, plural, one {vor # J} other {vor # J}}</value> + </data> + <data name="time.title" xml:space="preserve"> + <value>{age}, {stamp}</value> + </data> + <data name="time.spoken" xml:space="preserve"> + <value>, {stamp}</value> + </data> + <data name="chip.title" xml:space="preserve"> + <value>{value} — {how}, Quelle: {source}, zuletzt bestätigt {date}</value> + </data> + <data name="chip.title.stale" xml:space="preserve"> + <value>{value} — {how}, Quelle: {source}, zuletzt bestätigt {date} (Aktualisierung überfällig)</value> + </data> + <data name="chip.plain" xml:space="preserve"> + <value>({how}, {age})</value> + </data> + <data name="chip.plain.stale" xml:space="preserve"> + <value>({how}, {age}, überfällig)</value> + </data> + <data name="provenance.game.ownerDeclared" xml:space="preserve"> + <value>vom Betreiber angegeben</value> + </data> + <data name="source.staff" xml:space="preserve"> + <value>Redaktion</value> + </data> + <data name="source.handshake" xml:space="preserve"> + <value>der Telnet-Handshake</value> + </data> + <data name="source.owner" xml:space="preserve"> + <value>der Betreiber</value> + </data> + <data name="source.who" xml:space="preserve"> + <value>WHO</value> + </data> + <data name="source.i3" xml:space="preserve"> + <value>I3</value> + </data> + <data name="source.mssp" xml:space="preserve"> + <value>MSSP</value> + </data> + <data name="source.info" xml:space="preserve"> + <value>INFO</value> + </data> + <data name="source.i3Mudlist" xml:space="preserve"> + <value>die I3-Mudlist</value> + </data> + <data name="source.banner" xml:space="preserve"> + <value>der Verbindungsbildschirm</value> + </data> + <data name="ecosystem.title" xml:space="preserve"> + <value>Das Ökosystem</value> + </data> + <data name="ecosystem.noTotals" xml:space="preserve"> + <value>Anteile, niemals Gesamtzahlen. Wir veröffentlichen keine Zahl dazu, wie viele Menschen MU* spielen: Ein Verhältnis über die von uns gemessenen Spiele übersteht die, die wir nicht erreichen können; eine Kopfzahl nicht.</value> + </data> + <data name="ecosystem.listed" xml:space="preserve"> + <value>{count, plural, one {{value} Spiel eingetragen} other {{value} Spiele eingetragen}}</value> + </data> + <data name="ecosystem.handshakes" xml:space="preserve"> + <value>{count, plural, one {{value} Spiel, dessen Handshake wir abgeschlossen haben} other {{value} Spiele, deren Handshake wir abgeschlossen haben}}</value> + </data> + <data name="ecosystem.msspReports" xml:space="preserve"> + <value>{count, plural, one {{value} Spiel, dessen MSSP-Bericht uns vorliegt} other {{value} Spiele, deren MSSP-Bericht uns vorliegt}}</value> + </data> + <data name="ecosystem.oldestHandshake" xml:space="preserve"> + <value>Ältester Handshake hier: bestätigt vor {age}.</value> + </data> + <data name="ecosystem.share" xml:space="preserve"> + <value>{count, number} von {total, number} ({fraction, number, ::percent .0})</value> + </data> + <data name="ecosystem.share.nothing" xml:space="preserve"> + <value>{count, number} von {total, number} — noch nichts gemessen</value> + </data> + <data name="ecosystem.share.percent" xml:space="preserve"> + <value>{fraction, number, ::percent .0}</value> + </data> + <data name="ecosystem.codebases.title" xml:space="preserve"> + <value>Codebases</value> + </data> + <data name="ecosystem.codebases.basis" xml:space="preserve"> + <value>Von {listed, plural, one {# eingetragenen Spiel} other {# eingetragenen Spielen}} haben uns {identified, number} mitgeteilt, was sie ausführen, und jeder Anteil unten bezieht sich auf diese {identified, number}. Eine Codebase, die wir nicht lesen konnten, bleibt aus dem Nenner heraus und wird nie als etwas anderes gezählt.</value> + </data> + <data name="ecosystem.codebases.none" xml:space="preserve"> + <value>Noch kein eingetragenes Spiel hat uns seine Codebase mitgeteilt.</value> + </data> + <data name="ecosystem.soleUse" xml:space="preserve"> + <value>{share} führen eine Codebase aus, die kein anderes eingetragenes Spiel ausführt — je ein Spiel, was ein Name ist und kein Anteil. Sie stecken im Nenner oben und sind aus den Balken herausgefaltet, nicht entfernt:</value> + </data> + <data name="ecosystem.lineages.title" xml:space="preserve"> + <value>Abstammungen</value> + </data> + <data name="ecosystem.lineages.basis" xml:space="preserve"> + <value>Dieselben Spiele, gruppiert nach der Tradition, von der ihr Server abstammt — unsere Lesart der Codebase, nicht etwas, das ein Spiel veröffentlicht hätte. Kein Spiel meldet „MUSH“: MSSP kennt keinen solchen Wert, und der größte Teil der MUSH-Welt veröffentlicht überhaupt kein MSSP, deshalb lässt sich die Frage nur so stellen.</value> + </data> + <data name="ecosystem.lineages.none" xml:space="preserve"> + <value>Noch kein eingetragenes Spiel führt eine Codebase aus, die wir einer Abstammung zuordnen.</value> + </data> + <data name="ecosystem.lineages.notClassified" xml:space="preserve"> + <value>{count, plural, one {# dieser Spiele führt eine Codebase aus} other {# dieser Spiele führen Codebases aus}}, die wir keiner Abstammung zuordnen — mehrere sagen das selbst und veröffentlichen {family}. Sie stecken im Nenner oben und in niemandes Anteil.</value> + </data> + <data name="ecosystem.protocols.title" xml:space="preserve"> + <value>Protokolle</value> + </data> + <data name="ecosystem.protocols.floor" xml:space="preserve"> + <value>Jede gemessene Zahl unten ist als Untergrenze zu lesen. MSSP fragen wir namentlich an, dort ist Schweigen also eine Antwort. Sonst wird hier nichts angefragt, und ein Server kann ein Protokoll unterstützen, ohne es je anzubieten.</value> + </data> + <data name="ecosystem.mssp.instrument" xml:space="preserve"> + <value>{instrument} ist die einzige Zeile unten, die keine Untergrenze ist: Wir fragen jeden Server namentlich danach, die Spiele, die es nicht angeboten haben, wurden also gefragt und haben abgelehnt. Es ist zugleich die einzige ohne angegebene Zahl, denn jedes Spiel, dessen Bericht uns vorliegt, unterstützt es durch Vorführung, und eine Zählung derer, die es zusätzlich aufgeführt haben, würde daran nur eine Gewohnheit messen.</value> + </data> + <data name="ecosystem.mssp.gap" xml:space="preserve"> + <value>Uns liegen {reports, number} Berichte vor, und {offered, plural, one {# Spiel bietet} other {# Spiele bieten}} MSSP heute an: Die übrigen {gap, number} haben nach unserem Lesen aufgehört, einen zu veröffentlichen, und ein Bericht wird nicht verworfen, weil er nicht mehr neu ausgegeben wird.</value> + </data> + <data name="ecosystem.protocols.caption" xml:space="preserve"> + <value>Verbreitung der Protokolle. Gemessen ist, was ein Server in einem abgeschlossenen Handshake angeboten hat; angegeben ist, was sein MSSP behauptet. Zwei Mengen von Spielen, also zwei Nenner.</value> + </data> + <data name="ecosystem.column.protocol" xml:space="preserve"> + <value>Protokoll</value> + </data> + <data name="ecosystem.column.measured" xml:space="preserve"> + <value>gemessen — von {basis}</value> + </data> + <data name="ecosystem.column.declared" xml:space="preserve"> + <value>angegeben — von {basis}</value> + </data> + <data name="ecosystem.measured.never" xml:space="preserve"> + <value>nicht gemessen — nie beobachtet</value> + </data> + <data name="ecosystem.measured.declined" xml:space="preserve"> + <value>{share} · {declined, plural, one {# Spiel hat} other {# Spiele haben}} auf Nachfrage abgelehnt</value> + </data> + <data name="ecosystem.measured.unasked" xml:space="preserve"> + <value>{share} · bei {unobserved, plural, one {# Spiel} other {# Spielen}} weder angeboten noch nachgefragt</value> + </data> + <data name="ecosystem.measured.declinedAndUnasked" xml:space="preserve"> + <value>{share} · {declined, plural, one {# Spiel hat} other {# Spiele haben}} auf Nachfrage abgelehnt · bei {unobserved, plural, one {# Spiel} other {# Spielen}} weder angeboten noch nachgefragt</value> + </data> + <data name="ecosystem.declared.none" xml:space="preserve"> + <value>nicht nachgefragt — jeder Bericht hier ist die Antwort</value> + </data> + <data name="ecosystem.curve.title" xml:space="preserve"> + <value>Verbreitung im Zeitverlauf</value> + </data> + <data name="ecosystem.curve.caveat" xml:space="preserve"> + <value>Jeder Punkt ist ein Anteil an den Spielen, die wir an jenem Tag gemessen hatten; diese Linie bewegt sich also aus zwei Gründen: weil ein Spiel ändert, was es anbietet, und weil sich die Menge der messbaren Spiele darum herum ändert. Nur das Erste ist Verbreitung. Die Zahl der Wechsel unten ist der Teil, der rein aus Spielen besteht, die es sich anders überlegt haben.</value> + </data> + <data name="ecosystem.curve.caption" xml:space="preserve"> + <value>Gemessener Anteil je Protokoll, älteste Messung zuerst</value> + </data> + <data name="ecosystem.curve.then" xml:space="preserve"> + <value>damals</value> + </data> + <data name="ecosystem.curve.now" xml:space="preserve"> + <value>jetzt</value> + </data> + <data name="ecosystem.curve.notMeasured" xml:space="preserve"> + <value>nicht gemessen</value> + </data> + <data name="ecosystem.snapshot.title" xml:space="preserve"> + <value>Eine Momentaufnahme, keine Kurve</value> + </data> + <data name="ecosystem.snapshot" xml:space="preserve"> + <value>Eine Momentaufnahme dessen, was wir jetzt messen können. Eine Verbreitungskurve zeichnet Spiele, die es sich anders überlegen; wir halten eine Änderung fest, wenn sie geschieht, die Kurve wird also zeichenbar, sobald genug davon erfasst sind. Zu zeichnen, wann wir jedes Spiel zuerst erreicht haben, würde den Crawl messen und nicht das Hobby.</value> + </data> + <data name="ecosystem.transitions" xml:space="preserve"> + <value>{count, plural, one {# geänderte Fähigkeit} other {# geänderte Fähigkeiten}} bisher erfasst — das Material, aus dem eine Kurve gezeichnet wird.</value> + </data> + <data name="ecosystem.transitions.none" xml:space="preserve"> + <value>Noch hat sich keine gemessene Fähigkeit geändert, es gibt also nichts zu zeichnen.</value> + </data> + <data name="ecosystem.plain.denominators" xml:space="preserve"> + <value>Gemessen bezieht sich auf {measured}; angegeben auf {declared}. Zwei Mengen von Spielen, also zwei Nenner.</value> + </data> + <data name="ecosystem.plain.counts" xml:space="preserve"> + <value>{listed} · {handshakes} · {mssp}.</value> + </data> + <data name="ecosystem.plain.oldestHandshake" xml:space="preserve"> + <value>Der älteste Handshake in diesem Bild wurde zuletzt vor {age} bestätigt.</value> + </data> + <data name="ecosystem.plain.lineages" xml:space="preserve"> + <value>Dieselben Spiele, gruppiert nach der Tradition, von der ihr Server abstammt. Das ist {evidence} — {meaning} — und nicht etwas, das ein Spiel veröffentlicht hätte: Kein Spiel meldet „MUSH“, denn MSSP kennt keinen solchen Wert, und der größte Teil der MUSH-Welt veröffentlicht überhaupt kein MSSP.</value> + </data> + <data name="ecosystem.plain.measured" xml:space="preserve"> + <value>gemessen: {value}</value> + </data> + <data name="ecosystem.plain.declared" xml:space="preserve"> + <value>angegeben: {value}</value> + </data> + <data name="rankings.title" xml:space="preserve"> + <value>Ranglisten</value> + </data> + <data name="rankings.noVote" xml:space="preserve"> + <value>Ausschließlich aus gemessenen Daten berechnet. Keine Stimmen, Sterne oder Bewertungen, niemals. Nichts hier ordnet nach Qualität. Die haben wir nicht gemessen.</value> + </data> + <data name="rankings.busiest.title" xml:space="preserve"> + <value>Am belebtesten, nach gemessenen gleichzeitigen Spielern</value> + </data> + <data name="rankings.window.label" xml:space="preserve"> + <value>Zeitraum der Rangliste</value> + </data> + <data name="rankings.span" xml:space="preserve"> + <value>{days, plural, one {# Tag} other {# Tage}}</value> + </data> + <data name="rankings.basis.median" xml:space="preserve"> + <value>Median der Spielerzahlen, die wir in {days, plural, one {dem letzten # Tag} other {den letzten # Tagen}} gemessen haben.</value> + </data> + <data name="rankings.basis.none" xml:space="preserve"> + <value>Noch kein Spiel hat die {samples, number} Zählungen über {days, plural, one {# Tag} other {# Tage}}, die ein Median braucht.</value> + </data> + <data name="rankings.basis.eligible" xml:space="preserve"> + <value>{eligible, plural, one {# von {listed, number} Spielen hat} other {# von {listed, number} Spielen haben}} die nötigen {samples, number} Zählungen über {days, plural, one {# Tag} other {# Tage}}.</value> + </data> + <data name="rankings.basis.zero" xml:space="preserve"> + <value>Eine gemessene Null zählt; eine unlesbare Zählung nicht.</value> + </data> + <data name="rankings.spanChoice" xml:space="preserve"> + <value>Eine Woche sagt, wer jetzt belebt ist; ein Quartal sagt, wer belebt gewesen ist. Das sind verschiedene Fragen, und ein Spiel kann die eine anführen und die andere nicht. Tage sind ganze Tage, in UTC.</value> + </data> + <data name="rankings.busiest.empty" xml:space="preserve"> + <value>Noch hat kein eingetragenes Spiel genug Zählungen für eine Rangfolge — eine Aussage darüber, wie lange wir schon messen, nicht darüber, wie belebt irgendjemand ist.</value> + </data> + <data name="rankings.busiest.caption" xml:space="preserve"> + <value>Spiele, geordnet nach dem Median der Spielerzahlen, die wir in {days, plural, one {dem letzten # Tag} other {den letzten # Tagen}} gemessen haben. Spiele mit demselben Median teilen sich einen Platz; nichts hier entscheidet den Gleichstand.</value> + </data> + <data name="rankings.column.place" xml:space="preserve"> + <value>#</value> + </data> + <data name="rankings.column.game" xml:space="preserve"> + <value>Spiel</value> + </data> + <data name="rankings.column.median" xml:space="preserve"> + <value>Median</value> + </data> + <data name="rankings.column.peak" xml:space="preserve"> + <value>Spitze</value> + </data> + <data name="rankings.column.samples" xml:space="preserve"> + <value>Zählungen</value> + </data> + <data name="rankings.column.days" xml:space="preserve"> + <value>gemessene Tage</value> + </data> + <data name="rankings.spells.title" xml:space="preserve"> + <value>Längste durchgehende Erreichbarkeit</value> + </data> + <data name="rankings.spells.basis" xml:space="preserve"> + <value>Jede Abfrage seit dem genannten Datum hat das Spiel erreichbar vorgefunden. Erreichbar, nicht online: Wir messen einen Socket von einem einzigen Host aus, und ein Spiel, zu dem wir keine Route finden, ist dennoch völlig lebendig. Eine solche Strecke kann nicht länger sein, als wir zusehen, deshalb ist das Datum die Tatsache und die Dauer folgt daraus.</value> + </data> + <data name="rankings.spells.empty" xml:space="preserve"> + <value>Zurzeit ist kein eingetragenes Spiel durchgehend erreichbar.</value> + </data> + <data name="rankings.spells.caption" xml:space="preserve"> + <value>Spiele, bei denen jede Abfrage seit dem genannten Datum sie erreichbar vorgefunden hat. Spiele, die seit demselben Datum erreichbar sind, teilen sich einen Platz; nichts hier entscheidet den Gleichstand.</value> + </data> + <data name="rankings.column.since" xml:space="preserve"> + <value>erreichbar seit</value> + </data> + <data name="rankings.column.duration" xml:space="preserve"> + <value>das sind</value> + </data> + <data name="rankings.archivedNote" xml:space="preserve"> + <value>Archivierte Spiele sind aus beiden Tabellen heraus und aus sonst nichts; eine einzige erfolgreiche Abfrage bringt sie zurück.</value> + </data> + <data name="rankings.plain.busiest" xml:space="preserve"> + <value>Am belebtesten — Median der gemessenen Spieler, {days, plural, one {letzter # Tag} other {letzte # Tage}}</value> + </data> + <data name="rankings.plain.windows" xml:space="preserve"> + <value>Zeiträume:</value> + </data> + <data name="rankings.plain.thisOne" xml:space="preserve"> + <value>dieser</value> + </data> + <data name="rankings.plain.row" xml:space="preserve"> + <value>Median {median, number} · Spitze {peak, number} · {samples, plural, one {# Zählung} other {# Zählungen}} an {days, number} von {window, number} Tagen</value> + </data> + <data name="rankings.plain.spellRow" xml:space="preserve"> + <value>bei jeder Abfrage seit {date} erreichbar · {duration}</value> + </data> + <data name="archive.title" xml:space="preserve"> + <value>Das Archiv</value> + </data> + <data name="archive.lede" xml:space="preserve"> + <value>Spiele, die nicht mehr antworten. Nichts wurde gelöscht. Sie werden weiterhin wöchentlich abgefragt, und eine einzige erfolgreiche Abfrage bringt ein Spiel noch am selben Tag zurück ins Verzeichnis.</value> + </data> + <data name="archive.search.legend" xml:space="preserve"> + <value>das Archiv durchsuchen</value> + </data> + <data name="archive.search.label" xml:space="preserve"> + <value>Archivierte Spiele suchen</value> + </data> + <data name="archive.search.placeholder" xml:space="preserve"> + <value>Name, Codebase oder Beschreibung</value> + </data> + <data name="archive.search.submit" xml:space="preserve"> + <value>zeigen</value> + </data> + <data name="archive.count" xml:space="preserve"> + <value>{count, plural, =0 {Keine archivierten Spiele} one {# archiviertes Spiel} other {# archivierte Spiele}}</value> + </data> + <data name="archive.badge" xml:space="preserve"> + <value>archiviert</value> + </data> + <data name="archive.lastReachable" xml:space="preserve"> + <value>zuletzt erreichbar</value> + </data> + <data name="archive.knownLive" xml:space="preserve"> + <value>nachweislich aktiv</value> + </data> + <data name="archive.darkFor" xml:space="preserve"> + <value>(vor {age})</value> + </data> + <data name="archive.empty" xml:space="preserve"> + <value>Keine Treffer.</value> + </data> + <data name="archive.neverReachable" xml:space="preserve"> + <value>nie, in nichts, was wir gemessen haben</value> + </data> + <data name="archive.noReachableTime" xml:space="preserve"> + <value>keine erreichbare Zeit gemessen</value> + </data> + <data name="archive.darkFor.unknown" xml:space="preserve"> + <value>unbekannt</value> + </data> + <data name="archive.knownLive.years" xml:space="preserve"> + <value>{years, number, ::.#} Jahre</value> + </data> + <data name="archive.knownLive.days" xml:space="preserve"> + <value>{days, plural, one {# Tag} other {# Tage}}</value> + </data> + <data name="archive.run" xml:space="preserve"> + <value>{from} – {to} · {span}</value> + </data> + <data name="archive.run.months" xml:space="preserve"> + <value>{count, plural, one {# Monat} other {# Monate}}</value> + </data> + <data name="archive.run.years" xml:space="preserve"> + <value>{count, plural, one {# Jahr} other {# Jahre}}</value> + </data> + <data name="archive.plain.matching" xml:space="preserve"> + <value>{count, plural, one {# Spiel passt} other {# Spiele passen}} zu „{query}“</value> + </data> + <data name="archive.plain.count" xml:space="preserve"> + <value>{count, plural, one {# Spiel} other {# Spiele}}</value> + </data> + <data name="archive.plain.lastReachable" xml:space="preserve"> + <value>Zuletzt erreichbar:</value> + </data> + <data name="archive.plain.knownLive" xml:space="preserve"> + <value>Nachweislich aktiv:</value> + </data> + <data name="archive.plain.knownLiveValue" xml:space="preserve"> + <value>{value} gemessener erreichbarer Zeit</value> + </data> + <data name="archive.plain.run" xml:space="preserve"> + <value>Laufzeit:</value> + </data> + <data name="archive.plain.codebase" xml:space="preserve"> + <value>Codebase:</value> + </data> + <data name="footer.randomGame" xml:space="preserve"> + <value>zufälliges Spiel</value> + </data> + <data name="trend.day.counted" xml:space="preserve"> + <value>{d, date, medium} — durchschnittlich {typical}, {low}–{high} über {probes, plural, one {# Abfrage} other {# Abfragen}}</value> + </data> + <data name="trend.day.flat" xml:space="preserve"> + <value>{d, date, medium} — {count, plural, =0 {0 Spieler} one {# Spieler} other {# Spieler}}, in jeder von {probes, plural, one {# Abfrage} other {# Abfragen}}</value> + </data> + <data name="trend.day.notCounted" xml:space="preserve"> + <value>{d, date, medium} — abgefragt, keine Zählung ablesbar</value> + </data> + <data name="trend.day.notMeasured" xml:space="preserve"> + <value>{d, date, medium} — keine Messung</value> + </data> + <data name="trend.summary" xml:space="preserve"> + <value>Typischerweise {typical} verbunden, Spitze {peak}, an {counted} von {days, plural, one {# Tag} other {# Tagen}}.</value> + </data> + <data name="trend.direction.steady" xml:space="preserve"> + <value>Über den Zeitraum hinweg gleichbleibend.</value> + </data> + <data name="trend.direction.up" xml:space="preserve"> + <value>Vom Anfang des Zeitraums bis zum Ende um etwa {change, number, percent} gestiegen.</value> + </data> + <data name="trend.direction.down" xml:space="preserve"> + <value>Vom Anfang des Zeitraums bis zum Ende um etwa {change, number, percent} gefallen.</value> + </data> + <data name="trend.none.probed" xml:space="preserve"> + <value>In diesem Zeitraum abgefragt, und aus nichts davon war eine Spielerzahl ablesbar.</value> + </data> + <data name="trend.none.notMeasured" xml:space="preserve"> + <value>Keine Messung in diesem Zeitraum.</value> + </data> + <data name="trend.empty" xml:space="preserve"> + <value>In diesem Zeitraum nichts gezählt.</value> + </data> + <data name="trend.week.span" xml:space="preserve"> + <value>{from, date, d MMM}–{to, date, d MMM}</value> + </data> + <data name="trend.week.oneDay" xml:space="preserve"> + <value>{d, date, d MMM}</value> + </data> + <data name="trend.week.counted" xml:space="preserve"> + <value>{span}: typischerweise {typical}, Spitze {peak}, {days, plural, one {# Tag} other {# Tage}} gezählt</value> + </data> + <data name="trend.week.notCounted" xml:space="preserve"> + <value>{span}: abgefragt, keine Zählung ablesbar</value> + </data> + <data name="trend.week.notMeasured" xml:space="preserve"> + <value>{span}: nicht gemessen</value> + </data> + <data name="trend.week.uncounted" xml:space="preserve"> + <value>{count, plural, one {# Tag ohne Zählung abgefragt} other {# Tage ohne Zählung abgefragt}}</value> + </data> + <data name="trend.week.unmeasured" xml:space="preserve"> + <value>{count, plural, one {# Tag nicht gemessen} other {# Tage nicht gemessen}}</value> + </data> + <data name="trend.week.and" xml:space="preserve"> + <value>{line}, {clause}</value> + </data> + <data name="trend.range" xml:space="preserve"> + <value>Tage in UTC · {from, date, medium} – {to, date, medium}</value> + </data> + <data name="trend.ceiling" xml:space="preserve"> + <value>{value} ganz oben</value> + </data> + <data name="trend.counted" xml:space="preserve"> + <value>{counted} von {days, plural, one {# Tag} other {# Tagen}} gezählt</value> + </data> + <data name="trend.axis.month" xml:space="preserve"> + <value>{d, date, MMM}</value> + </data> + <data name="trend.axis.monthYear" xml:space="preserve"> + <value>{d, date, MMM yyyy}</value> + </data> + <data name="trend.legend.mean" xml:space="preserve"> + <value>Mittel der an dem Tag gelesenen Zählungen</value> + </data> + <data name="trend.legend.peak" xml:space="preserve"> + <value>bis zur höchsten Zählung des Tages</value> + </data> + <data name="trend.legend.band" xml:space="preserve"> + <value>niedrigste bis höchste Zählung des Tages</value> + </data> + <data name="trend.legend.notCounted" xml:space="preserve"> + <value>abgefragt, keine Zählung ablesbar</value> + </data> + <data name="trend.legend.notMeasured.bar" xml:space="preserve"> + <value>nicht gemessen — gar kein Balken</value> + </data> + <data name="trend.legend.notMeasured.line" xml:space="preserve"> + <value>nicht gemessen — eine Lücke in der Linie</value> + </data> + <data name="trend.spans.label" xml:space="preserve"> + <value>Zeitraum des Verlaufs</value> + </data> + <data name="trend.shapes.label" xml:space="preserve"> + <value>Form des Verlaufs</value> + </data> + <data name="trend.preset" xml:space="preserve"> + <value>{days, plural, one {# Tag} other {# Tage}}</value> + </data> + <data name="trend.earlier" xml:space="preserve"> + <value>← früher</value> + </data> + <data name="trend.later" xml:space="preserve"> + <value>später →</value> + </data> + <data name="trend.shape.line" xml:space="preserve"> + <value>Linie</value> + </data> + <data name="trend.shape.bar" xml:space="preserve"> + <value>Balken</value> + </data> + <data name="trend.plain.heading" xml:space="preserve"> + <value>Wie viele, im Zeitverlauf</value> + </data> + <data name="trend.plain.range" xml:space="preserve"> + <value>{from, date, medium} – {to, date, medium}, UTC</value> + </data> + <data name="trend.plain.earlier" xml:space="preserve"> + <value>früher</value> + </data> + <data name="trend.plain.note" xml:space="preserve"> + <value>eine Woche wird über die in ihr gezählten Tage zusammengefasst; eine Woche ohne solche sagt das</value> + </data> + <data name="reach.kicker" xml:space="preserve"> + <value>erreichbar · {days, plural, one {letzter # Tag} other {letzte # Tage}}</value> + </data> + <data name="reach.stat.reachable" xml:space="preserve"> + <value>erreichbar</value> + </data> + <data name="reach.stat.longestOutage" xml:space="preserve"> + <value>längste Unterbrechung</value> + </data> + <data name="reach.stat.lastCause" xml:space="preserve"> + <value>letzte Ursache</value> + </data> + <data name="reach.noOutage" xml:space="preserve"> + <value>keine im Zeitraum</value> + </data> + <data name="reach.noCause" xml:space="preserve"> + <value>nichts festgehalten</value> + </data> + <data name="reach.scale.ago" xml:space="preserve"> + <value>{days, plural, one {vor # Tag} other {vor # Tagen}}</value> + </data> + <data name="reach.scale.today" xml:space="preserve"> + <value>heute</value> + </data> + <data name="reach.legend.reachable" xml:space="preserve"> + <value>erreichbar</value> + </data> + <data name="reach.legend.degraded" xml:space="preserve"> + <value>eingeschränkt — geantwortet, nicht abgeschlossen</value> + </data> + <data name="reach.legend.unreachable" xml:space="preserve"> + <value>nicht erreichbar</value> + </data> + <data name="reach.legend.notMeasured" xml:space="preserve"> + <value>nicht gemessen</value> + </data> + <data name="reach.word.reachable" xml:space="preserve"> + <value>erreichbar</value> + </data> + <data name="reach.word.degraded" xml:space="preserve"> + <value>eingeschränkt</value> + </data> + <data name="reach.word.unreachable" xml:space="preserve"> + <value>nicht erreichbar</value> + </data> + <data name="reach.word.notMeasured" xml:space="preserve"> + <value>nicht gemessen</value> + </data> + <data name="reach.day.reachable" xml:space="preserve"> + <value>{d, date, d MMM} — den ganzen Tag erreichbar</value> + </data> + <data name="reach.day.degraded" xml:space="preserve"> + <value>{d, date, d MMM} — eingeschränkt ({cause}): geantwortet, nicht abgeschlossen</value> + </data> + <data name="reach.day.unreachable" xml:space="preserve"> + <value>{d, date, d MMM} — nicht erreichbar ({cause})</value> + </data> + <data name="reach.day.notMeasured" xml:space="preserve"> + <value>{d, date, d MMM} — nicht gemessen; wir haben dieses Spiel damals noch nicht beobachtet</value> + </data> + <data name="reach.none" xml:space="preserve"> + <value>{days, plural, one {Für den letzten # Tag noch nicht gemessen.} other {Für die letzten # Tage noch nicht gemessen.}}</value> + </data> + <data name="reach.fraction.window" xml:space="preserve"> + <value>{days, plural, one {Erreichbar in {percent} des letzten Tages.} other {Erreichbar in {percent} der letzten # Tage.}}</value> + </data> + <data name="reach.fraction.measured" xml:space="preserve"> + <value>{days, plural, one {Erreichbar in {percent} des einen Tages, den wir gemessen haben.} other {Erreichbar in {percent} der # Tage, die wir gemessen haben.}}</value> + </data> + <data name="reach.fraction.unknown" xml:space="preserve"> + <value>{days, plural, one {Die Erreichbarkeit des letzten Tages ist noch nicht gemessen.} other {Die Erreichbarkeit der letzten # Tage ist noch nicht gemessen.}}</value> + </data> + <data name="reach.unreachable.noneInWindow" xml:space="preserve"> + <value>An keinem Tag im Zeitraum war das Spiel nicht erreichbar.</value> + </data> + <data name="reach.unreachable.noneMeasured" xml:space="preserve"> + <value>An keinem von uns gemessenen Tag war das Spiel nicht erreichbar.</value> + </data> + <data name="reach.unreachable.days" xml:space="preserve"> + <value>{count, plural, one {# Tag nicht erreichbar.} other {# Tage nicht erreichbar.}}</value> + </data> + <data name="reach.degraded.days" xml:space="preserve"> + <value>{count, plural, one {# Tag eingeschränkt — wir sind hineingekommen und konnten nicht abschließen.} other {# Tage eingeschränkt — wir sind hineingekommen und konnten nicht abschließen.}}</value> + </data> + <data name="reach.longestOutage" xml:space="preserve"> + <value>Längste Unterbrechung {duration}.</value> + </data> + <data name="reach.longestOutage.cause" xml:space="preserve"> + <value>Längste Unterbrechung {duration} ({cause}).</value> + </data> + <data name="reach.predate" xml:space="preserve"> + <value>{count, plural, one {# Tag liegt vor allem, was wir gemessen haben.} other {# Tage liegen vor allem, was wir gemessen haben.}}</value> + </data> + <data name="reach.spell.range" xml:space="preserve"> + <value>{from, date, d MMM} – {to, date, d MMM}</value> + </data> + <data name="reach.spell.oneDay" xml:space="preserve"> + <value>{d, date, d MMM}</value> + </data> + <data name="reach.spell" xml:space="preserve"> + <value>{range}: {count, plural, one {# Tag} other {# Tage}} {word}</value> + </data> + <data name="reach.spell.cause" xml:space="preserve"> + <value>{range}: {count, plural, one {# Tag} other {# Tage}} {word} ({cause})</value> + </data> + <data name="reach.plain.heading" xml:space="preserve"> + <value>Erreichbar</value> + </data> + <data name="reach.plain.window" xml:space="preserve"> + <value>{days, plural, one {letzter # Tag} other {letzte # Tage}}</value> + </data> + <data name="reach.plain.fraction" xml:space="preserve"> + <value>Erreichbar: {percent} {days, plural, one {des letzten Tages} other {der letzten # Tage}}</value> + </data> + <data name="reach.plain.longestOutage" xml:space="preserve"> + <value>Längste Unterbrechung: {duration}</value> + </data> + <data name="cause.dns" xml:space="preserve"> + <value>dns hat nicht aufgelöst</value> + </data> + <data name="cause.refused" xml:space="preserve"> + <value>Verbindung abgelehnt</value> + </data> + <data name="cause.tls" xml:space="preserve"> + <value>tls fehlgeschlagen</value> + </data> + <data name="cause.timeout" xml:space="preserve"> + <value>Zeitüberschreitung</value> + </data> + <data name="cause.handshakeStalled" xml:space="preserve"> + <value>Handshake hängen geblieben</value> + </data> + <data name="cause.none" xml:space="preserve"> + <value>keine Ursache festgehalten</value> + </data> + <data name="ansi.suppressed" xml:space="preserve"> + <value>Der Betreiber hat uns gebeten, den Verbindungsbildschirm dieses Spiels nicht erneut zu veröffentlichen.</value> + </data> + <data name="ansi.absent" xml:space="preserve"> + <value>Von diesem Spiel wurde kein Verbindungsbildschirm aufgezeichnet.</value> + </data> + <data name="ansi.tooSmall" xml:space="preserve"> + <value>{count, plural, one {Nur # Zeile kam zurück — zu wenig zum Anzeigen.} other {Nur # Zeilen kamen zurück — zu wenig zum Anzeigen.}}</value> + </data> + <data name="ansi.asSent" xml:space="preserve"> + <value>so, wie der Server ihn gesendet hat</value> + </data> + <data name="ansi.size" xml:space="preserve"> + <value>{columns}×{rows}</value> + </data> + <data name="ansi.size.doubleWidth" xml:space="preserve"> + <value>{columns}×{rows}, doppelte Breite</value> + </data> + <data name="ansi.depth.colour" xml:space="preserve"> + <value>16-Farben-SGR</value> + </data> + <data name="ansi.depth.plain" xml:space="preserve"> + <value>keine Farbe</value> + </data> + <data name="ansi.readAs" xml:space="preserve"> + <value>gelesen als {charset}</value> + </data> + <data name="ansi.captured" xml:space="preserve"> + <value>aufgezeichnet</value> + </data> + <data name="ansi.frozen" xml:space="preserve"> + <value>eingefroren — der letzte Bildschirm, den wir gesehen haben</value> + </data> + <data name="ansi.alt.named" xml:space="preserve"> + <value>ASCII-Grafik: der Verbindungsbildschirm von {game}. Sein Text steht unten unter „als Text lesen“.</value> + </data> + <data name="ansi.alt" xml:space="preserve"> + <value>ASCII-Grafik: der Verbindungsbildschirm dieses Spiels. Sein Text steht unten unter „als Text lesen“.</value> + </data> + <data name="ansi.plain.rows" xml:space="preserve"> + <value>{count, plural, one {Verbindungsbildschirm: # Zeile, nur Text} other {Verbindungsbildschirm: # Zeilen, nur Text}}</value> + </data> + <data name="ansi.plain.rows.readAs" xml:space="preserve"> + <value>{count, plural, one {Verbindungsbildschirm: # Zeile, nur Text, gelesen als {charset}} other {Verbindungsbildschirm: # Zeilen, nur Text, gelesen als {charset}}}</value> + </data> + <data name="capability.disagree.declaredNotOffered" xml:space="preserve"> + <value>das Spiel gibt es an, und der Server hat es in keinem Handshake je angeboten.</value> + </data> + <data name="capability.disagree.offeredNotDeclared" xml:space="preserve"> + <value>der Server bietet es an, und die eigene Angabe des Spiels sagt, dass er es nicht tut.</value> + </data> + <data name="capability.disagree.note" xml:space="preserve"> + <value>Meist ein veraltetes, von Hand getipptes Feld und keine Lüge. Gezeigt, weil ein Client sich auf das, worin beide sich widersprechen, nicht verlassen sollte.</value> + </data> + <data name="game.notFound" xml:space="preserve"> + <value>Nicht gefunden</value> + </data> + <data name="game.notFound.hint" xml:space="preserve"> + <value>Kein Spiel unter dieser Adresse. Schreibweise prüfen.</value> + </data> + <data name="game.endpoint.lastAnswered" xml:space="preserve"> + <value>zuletzt geantwortet</value> + </data> + <data name="game.stale" xml:space="preserve"> + <value>{count, plural, one {# ist über das Aktualisierungsfenster hinaus. Alt, nicht falsch.} other {# sind über das Aktualisierungsfenster hinaus. Alt, nicht falsch.}}</value> + </data> + <data name="game.referrals.lists" xml:space="preserve"> + <value>Die eigene Verweisliste dieses Spiels nennt:</value> + </data> + <data name="game.referrals.listedBy" xml:space="preserve"> + <value>Genannt von der Verweisliste von:</value> + </data> + <data name="game.referral.since" xml:space="preserve"> + <value>seit {date}</value> + </data> + <data name="game.referral.dropped" xml:space="preserve"> + <value>nicht mehr gelistet, zuletzt gesehen</value> + </data> + <data name="game.archived.lastAnswered" xml:space="preserve"> + <value>Zuletzt geantwortet am {date}, vor {ago}.</value> + </data> + <data name="game.archived.stillProbed" xml:space="preserve"> + <value>Wird weiterhin wöchentlich abgefragt; diese Seite aktualisiert sich an dem Tag, an dem es antwortet.</value> + </data> + <data name="game.archived.knownLive" xml:space="preserve"> + <value>{span} nachweislich aktiv</value> + </data> + <data name="game.excluded" xml:space="preserve"> + <value>Nicht im Verzeichnis, nicht in den Ranglisten und nicht in der Tageszahl: Wir halten diese Adresse nicht für ein Spiel, das sich spielen lässt. Alles unten ist das, was sie uns mitgeteilt hat, unverändert.</value> + </data> + <data name="game.excluded.reason" xml:space="preserve"> + <value>Unser Grund: {why}</value> + </data> + <data name="game.unlisted" xml:space="preserve"> + <value>Nicht im Verzeichnis, nicht in den Ranglisten und nicht in der Tageszahl, auf Bitte der Leute, die es betreiben. Alles unten bleibt erhalten, wie es war, diese Seite und jede Adresse, die es je hatte, antworten weiterhin, und wir wählen es nicht an.</value> + </data> + <data name="game.plain.playersNow" xml:space="preserve"> + <value>Jetzt verbunden: {count}</value> + </data> + <data name="game.plain.capabilities" xml:space="preserve"> + <value>Fähigkeiten ({disagreeing} von {total} widersprechen)</value> + </data> + <data name="game.plain.declared" xml:space="preserve"> + <value>Vom Spiel angegeben</value> + </data> + <data name="game.plain.connectScreen" xml:space="preserve"> + <value>Verbindungsbildschirm</value> + </data> + <data name="game.plain.whatChanged" xml:space="preserve"> + <value>Was sich geändert hat</value> + </data> + <data name="game.plain.measured" xml:space="preserve"> + <value>gemessen</value> + </data> + <data name="game.plain.declared.column" xml:space="preserve"> + <value>angegeben</value> + </data> + <data name="game.plain.disagree" xml:space="preserve"> + <value>** widersprechen</value> + </data> + <data name="listing.row.connected" xml:space="preserve"> + <value>Verbindungen</value> + </data> + <data name="listing.row.reached" xml:space="preserve"> + <value>erreicht</value> + </data> + <data name="facet.group.search" xml:space="preserve"> + <value>Suche</value> + </data> + <data name="facet.group.archived" xml:space="preserve"> + <value>archiviert</value> + </data> + <data name="facet.group.adult" xml:space="preserve"> + <value>Erwachseneninhalte</value> + </data> + <data name="facet.value.included" xml:space="preserve"> + <value>einbezogen</value> + </data> + <data name="game.count.none" xml:space="preserve"> + <value>keine Zählung</value> + </data> + <data name="game.count.none.why" xml:space="preserve"> + <value>keine aktuelle Zählung, und nichts hier nennt einen Grund</value> + </data> + <data name="game.plain.playersNoCount" xml:space="preserve"> + <value>Jetzt verbunden: keine Zählung (nichts hier nennt einen Grund)</value> + </data> + <data name="crawler.live" xml:space="preserve"> + <value>Crawler aktiv · letzte Abfrage {age}</value> + </data> + <data name="crawler.quiet" xml:space="preserve"> + <value>Crawler im Leerlauf · letzte Abfrage {age}</value> + </data> + <data name="crawler.noProbe" xml:space="preserve"> + <value>hier ist noch keine Abfrage abgeschlossen</value> + </data> + <data name="crawler.cycle.nothingDue" xml:space="preserve"> + <value>in diesem Zyklus nichts fällig</value> + </data> + <data name="crawler.cycle" xml:space="preserve"> + <value>{considered, plural, one {# fällig} other {# fällig}} · {answered, plural, one {# geantwortet} other {# geantwortet}} · {failed, plural, one {# fehlgeschlagen} other {# fehlgeschlagen}}</value> + </data> + <data name="crawler.registry" xml:space="preserve"> + <value>{targets, plural, one {# Adresse im Register} other {# Adressen im Register}}, {due, plural, one {# jetzt fällig} other {# jetzt fällig}}</value> + </data> + <data name="preview.documentTitle" xml:space="preserve"> + <value>{page} — {site}</value> + </data> + <data name="preview.site" xml:space="preserve"> + <value>Ein Verzeichnis des MU*-Hobbys — MUSHes, MUDs, MUCKs, MOOs — in dem jede Tatsache ihre Herkunft und ihr Alter nennt.</value> + </data> + <data name="preview.demo" xml:space="preserve"> + <value>Demodaten — nichts davon wurde gemessen. {description}</value> + </data> + <data name="preview.cardAlt" xml:space="preserve"> + <value>{site} — gemessen, nicht behauptet</value> + </data> + <data name="preview.cardAlt.named" xml:space="preserve"> + <value>{title} auf {site}</value> + </data> + <data name="preview.title.games" xml:space="preserve"> + <value>Spiele</value> + </data> + <data name="preview.title.archive" xml:space="preserve"> + <value>Das Archiv</value> + </data> + <data name="preview.title.rankings" xml:space="preserve"> + <value>Ranglisten</value> + </data> + <data name="preview.title.ecosystem" xml:space="preserve"> + <value>Das Ökosystem</value> + </data> + <data name="preview.title.reference" xml:space="preserve"> + <value>Referenz</value> + </data> + <data name="preview.title.about" xml:space="preserve"> + <value>Über uns</value> + </data> + <data name="preview.title.notFound" xml:space="preserve"> + <value>Nicht gefunden</value> + </data> + <data name="preview.title.random" xml:space="preserve"> + <value>Zufälliges Spiel</value> + </data> + <data name="preview.title.account" xml:space="preserve"> + <value>Ihre Spiele</value> + </data> + <data name="preview.title.claim" xml:space="preserve"> + <value>{game} beanspruchen</value> + </data> + <data name="preview.desc.games" xml:space="preserve"> + <value>Jedes MU*, das wir erreicht haben, gefiltert nach Gemessenem: Codebase, Protokolle aus dem Handshake, TLS, Kodierung, Sprache, letzter Zugang.</value> + </data> + <data name="preview.desc.archive" xml:space="preserve"> + <value>Verstummte Spiele, aufbewahrt. Jedes behält Seite, Verlauf und URL, wird wöchentlich abgefragt und kehrt bei einer erfolgreichen Verbindung zurück.</value> + </data> + <data name="preview.desc.rankings" xml:space="preserve"> + <value>Am belebtesten, am besten erreichbar, am längsten laufend — allein aus Messungen berechnet. Keine Stimmen, Sterne oder Bewertungen auf dieser Website.</value> + </data> + <data name="preview.desc.ecosystem" xml:space="preserve"> + <value>Codebase-Anteile und Protokollverbreitung über die von uns gemessenen Spiele, das Angebotene neben dem Angegebenen. Anteile, niemals Gesamtzahlen.</value> + </data> + <data name="preview.desc.reference" xml:space="preserve"> + <value>Von Hand geschriebene Seiten zu den Codebases, Clients und Protokollen des MU*-Hobbys, verlinkt mit Zahlen aus dem Crawl.</value> + </data> + <data name="preview.desc.about" xml:space="preserve"> + <value>Wie dieser Katalog entsteht: was der Crawler tut, was er zu tun verweigert und wie er sich stoppen lässt.</value> + </data> + <data name="preview.desc.notFound" xml:space="preserve"> + <value>Kein Spiel unter dieser Adresse. Hier wird nichts gelöscht, ein Spiel, das einmal unter dieser URL lag, liegt also weiterhin dort — Schreibweise prüfen.</value> + </data> + <data name="preview.desc.random" xml:space="preserve"> + <value>Ein Spiel aus dem Katalog, zufällig gewählt und nie zweimal dasselbe.</value> + </data> + <data name="preview.desc.account" xml:space="preserve"> + <value>Die Einträge, die Sie beansprucht haben, und was ein Anspruch Ihnen zu ändern erlaubt.</value> + </data> + <data name="preview.desc.claim" xml:space="preserve"> + <value>Weisen Sie nach, dass Sie dieses Spiel betreiben, indem Sie einen Token dort veröffentlichen, wo nur sein Betreiber ihn hinstellen könnte.</value> + </data> + <data name="preview.game.archived" xml:space="preserve"> + <value>Archiviert — zuletzt erreichbar {age}, wird weiter abgefragt</value> + </data> + <data name="preview.game.archived.undated" xml:space="preserve"> + <value>Archiviert, wird weiter abgefragt</value> + </data> + <data name="preview.game.countUnknown" xml:space="preserve"> + <value>Spielerzahl unbekannt — das Spiel antwortet und veröffentlicht keine Zahl, die wir lesen können</value> + </data> + <data name="preview.game.count" xml:space="preserve"> + <value>{count, plural, one {# Spieler} other {# Spieler}}, {how} {age}</value> + </data> + <data name="feed.plain.newlyDiscovered" xml:space="preserve"> + <value>Neu entdeckt</value> + </data> + <data name="feed.plain.wentDark" xml:space="preserve"> + <value>Verstummt</value> + </data> + <data name="feed.plain.cameBack" xml:space="preserve"> + <value>Wieder da</value> + </data> + <data name="home.plain.known" xml:space="preserve"> + <value>{count, plural, one {# Spiel bekannt} other {# Spiele bekannt}}</value> + </data> + <data name="home.plain.connectedNow" xml:space="preserve"> + <value>{count, plural, one {# jetzt verbunden (gemessen)} other {# jetzt verbunden (gemessen)}}</value> + </data> + <data name="home.plain.uncounted" xml:space="preserve"> + <value>{count, plural, one {# antwortend, ungezählt} other {# antwortend, ungezählt}}</value> + </data> + <data name="home.plain.archived" xml:space="preserve"> + <value>{count, plural, one {# archiviert, wird weiter abgefragt} other {# archiviert, werden weiter abgefragt}}</value> + </data> + <data name="reference.title" xml:space="preserve"> + <value>Referenz</value> + </data> + <data name="reference.lede" xml:space="preserve"> + <value>Was die Codebases sind, was die Clients tun und was die Protokolle bedeuten. Von Hand geschrieben und im Repository neben dem Crawler abgelegt — kein Wiki, und auf dieser Seite gibt es nichts zu bearbeiten. Jede {number} hier ist etwas anderes: Sie stammt aus dem Katalog und wird bei jedem Aufruf der Seite neu berechnet.</value> + </data> + <data name="reference.lede.number" xml:space="preserve"> + <value>Zahl</value> + </data> + <data name="reference.plain.lede" xml:space="preserve"> + <value>Von Hand geschrieben, namentlich gezeichnet und in git versioniert. Der Text hier ist unserer; jede Zahl daneben wurde vom Crawler gemessen und wird bei jeder Anfrage neu berechnet. Das ist kein Wiki, und von dieser Seite aus lässt sich nichts bearbeiten.</value> + </data> + <data name="reference.section.orientation" xml:space="preserve"> + <value>Hier anfangen</value> + </data> + <data name="reference.section.codebase" xml:space="preserve"> + <value>Codebases</value> + </data> + <data name="reference.section.client" xml:space="preserve"> + <value>Clients</value> + </data> + <data name="reference.section.protocol" xml:space="preserve"> + <value>Protokolle</value> + </data> + <data name="reference.kind.orientation" xml:space="preserve"> + <value>Orientierung</value> + </data> + <data name="reference.kind.codebase" xml:space="preserve"> + <value>Codebase</value> + </data> + <data name="reference.kind.client" xml:space="preserve"> + <value>Client</value> + </data> + <data name="reference.kind.protocol" xml:space="preserve"> + <value>Protokoll</value> + </data> + <data name="reference.notFound.title" xml:space="preserve"> + <value>Nicht gefunden</value> + </data> + <data name="reference.notFound.body" xml:space="preserve"> + <value>Hier gibt es keine Referenzseite. Dieser Abschnitt ist von Hand geschrieben; eine Lücke ist also Arbeit, die niemand gemacht hat, und nichts, was entfernt worden wäre — {index}.</value> + </data> + <data name="reference.notFound.index" xml:space="preserve"> + <value>sehen, was es gibt</value> + </data> + <data name="reference.codebase.heading" xml:space="preserve"> + <value>Spiele, die sie ausführen</value> + </data> + <data name="reference.codebase.none" xml:space="preserve"> + <value>Wir haben noch keines identifiziert. Das ist eine Tatsache darüber, was dieser Crawler gemessen hat, und keine darüber, was es gibt — ein Spiel, das wir nicht erreicht haben oder dessen Codebase wir nicht lesen konnten, wird hier nicht mitgezählt.</value> + </data> + <data name="reference.codebase.listed" xml:space="preserve"> + <value>{count, plural, one {# eingetragen} other {# eingetragen}}</value> + </data> + <data name="reference.codebase.archived" xml:space="preserve"> + <value>{count, plural, one {# archiviert} other {# archiviert}}</value> + </data> + <data name="reference.measuredNeverAsserted" xml:space="preserve"> + <value>gemessen, nie behauptet</value> + </data> + <data name="reference.codebase.note" xml:space="preserve"> + <value>Bei dieser Anfrage aus dem Katalog gezählt, über denselben Filter, den der Link oben trägt — diese Zahl und jenes Verzeichnis stammen also aus einer einzigen Abfrage und können nicht auseinanderlaufen.</value> + </data> + <data name="reference.codebase.offered" xml:space="preserve"> + <value>in ihren Handshakes angeboten: {protocols}</value> + </data> + <data name="reference.protocol.heading" xml:space="preserve"> + <value>Gemessene Verbreitung</value> + </data> + <data name="reference.protocol.none" xml:space="preserve"> + <value>Noch nichts gemessen.</value> + </data> + <data name="reference.protocol.share" xml:space="preserve"> + <value>von {listed, plural, one {# eingetragenen Spiel} other {# eingetragenen Spielen}} — {percent}</value> + </data> + <data name="reference.protocol.remainder" xml:space="preserve"> + <value>Die Spiele, die hier nicht mitgezählt sind, sind keine Spiele ohne das Protokoll. Ein Spiel zählt hier, wenn sein Server die Option in einem von uns beobachteten Handshake angeboten hat; der Rest sind Server, die sie uns nicht angeboten haben, und Server, deren Handshake wir nicht gelesen haben, und welches davon zutrifft, können wir Ihnen nicht sagen.</value> + </data> + <data name="reference.protocol.caption" xml:space="preserve"> + <value>Spiele, die {protocol} in einem von uns beobachteten Handshake angeboten haben, nach der Codebase, die wir bei ihnen identifiziert haben.</value> + </data> + <data name="reference.protocol.column.codebase" xml:space="preserve"> + <value>Codebase</value> + </data> + <data name="reference.protocol.column.offered" xml:space="preserve"> + <value>angeboten</value> + </data> + <data name="reference.protocol.column.identified" xml:space="preserve"> + <value>identifiziert</value> + </data> + <data name="reference.seeAlso" xml:space="preserve"> + <value>Siehe auch</value> + </data> + <data name="reference.capabilities.heading" xml:space="preserve"> + <value>Fähigkeiten</value> + </data> + <data name="reference.capabilities.established" xml:space="preserve"> + <value>{count, plural, one {# von {total} aus der Dokumentation des Projekts selbst festgestellt} other {# von {total} aus der Dokumentation des Projekts selbst festgestellt}}</value> + </data> + <data name="reference.capabilities.caveat" xml:space="preserve"> + <value>Aus der Dokumentation des jeweiligen Projekts abgelesen, nicht von uns gemessen — ein Client hat keinen Handshake, den wir beobachten könnten. „{unknown}“ heißt, dass wir nachgesehen und es nicht feststellen konnten. Es heißt nie nein.</value> + </data> + <data name="reference.capabilities.caption" xml:space="preserve"> + <value>Fähigkeiten der Clients, jede aus der Dokumentation des Projekts selbst abgelesen. Unbekannt heißt, dass wir sie nicht feststellen konnten, und nie, dass sie dem Client fehlt.</value> + </data> + <data name="reference.capabilities.column.documented" xml:space="preserve"> + <value>dokumentiert</value> + </data> + <data name="reference.capabilities.column.source" xml:space="preserve"> + <value>Quelle</value> + </data> + <data name="reference.capabilities.noSource" xml:space="preserve"> + <value>wir haben keine gefunden</value> + </data> + <data name="reference.capability.yes" xml:space="preserve"> + <value>ja</value> + </data> + <data name="reference.capability.no" xml:space="preserve"> + <value>nein</value> + </data> + <data name="reference.capability.unknown" xml:space="preserve"> + <value>unbekannt</value> + </data> + <data name="reference.plain.runsOn" xml:space="preserve"> + <value>Läuft auf: {platforms}</value> + </data> + <data name="reference.plain.codebase.heading" xml:space="preserve"> + <value>Spiele, bei denen wir diese Codebase identifiziert haben</value> + </data> + <data name="reference.plain.codebase.none" xml:space="preserve"> + <value>Noch keines. Das ist eine Aussage darüber, was wir gemessen haben, und keine darüber, was es gibt — ein Spiel, das wir nicht erreicht haben oder dessen Codebase wir nicht lesen konnten, wird hier nicht mitgezählt.</value> + </data> + <data name="reference.plain.codebase.counts" xml:space="preserve"> + <value>{listed, plural, one {# eingetragen} other {# eingetragen}}, {archived, plural, one {# archiviert} other {# archiviert}}</value> + </data> + <data name="reference.plain.codebase.offered" xml:space="preserve"> + <value>In ihren Handshakes gemessen: {protocols}</value> + </data> + <data name="reference.plain.codebase.nothingOffered" xml:space="preserve"> + <value>In keinem Handshake, den wir von ihnen gelesen haben, wurde etwas angeboten.</value> + </data> + <data name="reference.plain.protocol.share" xml:space="preserve"> + <value>{offering} von {listed, plural, one {# eingetragenen Spiel} other {# eingetragenen Spielen}} haben es in einem von uns beobachteten Handshake angeboten ({percent})</value> + </data> + <data name="reference.plain.protocol.byCodebase" xml:space="preserve"> + <value>Nach Codebase, unter den Spielen, die wir identifiziert haben</value> + </data> + <data name="reference.plain.protocol.row" xml:space="preserve"> + <value>{offering} von {identified} haben es angeboten</value> + </data> + <data name="reference.plain.capabilities.unknown" xml:space="preserve"> + <value>{count, plural, one {# von {total} Zeilen ist unbekannt} other {# von {total} Zeilen sind unbekannt}}: Wir haben in der Dokumentation des Projekts selbst nichts gefunden, was das eine oder das andere sagt. Eine kurze ehrliche Tabelle ist besser als eine lange geratene.</value> + </data> + <data name="account.title" xml:space="preserve"> + <value>Ihre Spiele</value> + </data> + <data name="account.noDatabase" xml:space="preserve"> + <value>Konten brauchen eine Datenbank, und diese Website läuft auf den Demodaten.</value> + </data> + <data name="account.signInButton" xml:space="preserve"> + <value>Anmelden</value> + </data> + <data name="account.signedInAs" xml:space="preserve"> + <value>Angemeldet als {name}.</value> + </data> + <data name="account.signOut" xml:space="preserve"> + <value>Abmelden</value> + </data> + <data name="account.empty.body" xml:space="preserve"> + <value>Sie haben noch nichts beansprucht. Suchen Sie Ihr Spiel in {listing} und drücken Sie auf seiner Seite {claimControl}.</value> + </data> + <data name="account.empty.listing" xml:space="preserve"> + <value>dem Verzeichnis</value> + </data> + <data name="account.empty.claimControl" xml:space="preserve"> + <value>Dieses Spiel beanspruchen</value> + </data> + <data name="account.resigned.lead" xml:space="preserve"> + <value>Aufgegeben.</value> + </data> + <data name="account.resigned.body" xml:space="preserve"> + <value>Der Vermerk darüber bleibt erhalten, und Sie können jederzeit erneut nachweisen, dass Sie das Spiel betreiben, indem Sie einen frischen Token veröffentlichen.</value> + </data> + <data name="account.saved.lead" xml:space="preserve"> + <value>Gespeichert.</value> + </data> + <data name="account.saved.thatGame" xml:space="preserve"> + <value>Dieses Spiel</value> + </data> + <data name="account.saved.fields" xml:space="preserve"> + <value>Die Seite von {game} zeigt es jetzt als vom Betreiber angegeben.</value> + </data> + <data name="account.saved.screenHidden" xml:space="preserve"> + <value>Wir veröffentlichen den Verbindungsbildschirm von {game} nicht mehr erneut. Die Seite sagt das deutlich, statt eine Leerstelle zu lassen.</value> + </data> + <data name="account.saved.screenShown" xml:space="preserve"> + <value>Der Verbindungsbildschirm von {game} steht wieder auf seiner Seite.</value> + </data> + <data name="account.saved.crawlStopped" xml:space="preserve"> + <value>Wir wählen {game} nicht mehr an, unter keiner Adresse, die wir dafür haben. Seine Seite behält alles, was vor Ihrer Bitte gemessen wurde.</value> + </data> + <data name="account.saved.crawlResumed" xml:space="preserve"> + <value>Wir wählen {game} wieder an, ab seinem nächsten Termin im Zeitplan.</value> + </data> + <data name="account.saved.unlisted" xml:space="preserve"> + <value>{game} ist aus dem Verzeichnis, aus den Ranglisten und aus der Tageszahl heraus. Seine Seite und jede URL, die es je hatte, antworten weiterhin.</value> + </data> + <data name="account.saved.relisted" xml:space="preserve"> + <value>{game} steht wieder im Verzeichnis. Eine einzige Abfrage, die eine Antwort erhält, genügt, damit es wieder gemessen wird.</value> + </data> + <data name="account.refused.lead" xml:space="preserve"> + <value>{field} wurde nicht geändert.</value> + </data> + <data name="account.refused.tooLong" xml:space="preserve"> + <value>Das sind einzeilige Angaben; mehr als {max} Zeichen speichern wir nicht.</value> + </data> + <data name="account.refused.measured" xml:space="preserve"> + <value>Dieses Feld ist gemessen. Ein Anspruch erlaubt Ihnen hinzuzufügen, wofür MSSP keinen Platz hat; er erlaubt niemandem, das zu ändern, was wir beobachtet haben, uns eingeschlossen.</value> + </data> + <data name="account.claimed.heading" xml:space="preserve"> + <value>Beansprucht</value> + </data> + <data name="account.claim.verified" xml:space="preserve"> + <value>bestätigt {date}</value> + </data> + <data name="account.claim.verifiedAndSeen" xml:space="preserve"> + <value>bestätigt {date}, Token zuletzt gesehen {seen}</value> + </data> + <data name="account.claim.mssp" xml:space="preserve"> + <value>Ihr MSSP prüfen</value> + </data> + <data name="account.claim.coOwners" xml:space="preserve"> + <value>{count, plural, one {Außerdem beansprucht von {names} — mit einem eigenen bestätigten Token.} other {Außerdem beansprucht von {names} — jeweils mit einem eigenen bestätigten Token.}}</value> + </data> + <data name="account.coOwner.unnamed" xml:space="preserve"> + <value>ein anderes Konto</value> + </data> + <data name="account.badge.summary" xml:space="preserve"> + <value>Ihre Spielerzahl auf Ihrer eigenen Website zeigen</value> + </data> + <data name="account.badge.carries" xml:space="preserve"> + <value>Das Abzeichen trägt die Zählung und den Zeitpunkt, an dem wir sie gemessen haben, denn eine Zahl ohne Alter ist genau das, was diese Website ersetzen soll.</value> + </data> + <data name="account.badge.states" xml:space="preserve"> + <value>Es sagt {unknown} statt null, wenn wir nicht zählen konnten, und {archived}, wenn das Spiel nicht mehr antwortet.</value> + </data> + <data name="account.badge.json" xml:space="preserve"> + <value>Es gibt auch {json}, falls Sie lieber selbst zeichnen möchten.</value> + </data> + <data name="account.history.summary" xml:space="preserve"> + <value>Verlauf</value> + </data> + <data name="account.event.issued" xml:space="preserve"> + <value>Token ausgegeben</value> + </data> + <data name="account.event.reissued" xml:space="preserve"> + <value>Token erneut ausgegeben</value> + </data> + <data name="account.event.verified" xml:space="preserve"> + <value>bestätigt — wir haben Ihren Token gelesen</value> + </data> + <data name="account.event.beaconSeen" xml:space="preserve"> + <value>Token weiterhin veröffentlicht</value> + </data> + <data name="account.event.beaconMissing" xml:space="preserve"> + <value>Token diesmal nicht gelesen</value> + </data> + <data name="account.event.revoked" xml:space="preserve"> + <value>Anspruch aufgegeben</value> + </data> + <data name="account.event.expired" xml:space="preserve"> + <value>Token ungenutzt abgelaufen</value> + </data> + <data name="account.event.counterClaimed" xml:space="preserve"> + <value>ein anderes Konto hat nachgewiesen, dass es das Spiel betreibt, und es übernommen</value> + </data> + <data name="account.event.checkRequested" xml:space="preserve"> + <value>Prüfung angefragt</value> + </data> + <data name="account.resign.summary" xml:space="preserve"> + <value>diesen Anspruch aufgeben</value> + </data> + <data name="account.resign.confirm" xml:space="preserve"> + <value>Tippen Sie {word} zur Bestätigung. Nichts wird gelöscht, und Sie können erneut nachweisen, dass Sie das Spiel betreiben, indem Sie einen frischen Token veröffentlichen; das Spiel bleibt beansprucht, solange es noch jemand anderes beansprucht.</value> + </data> + <data name="account.resign.button" xml:space="preserve"> + <value>{game} aufgeben</value> + </data> + <data name="account.pending.heading" xml:space="preserve"> + <value>Warten auf einen Token</value> + </data> + <data name="account.pending.dates" xml:space="preserve"> + <value>Token ausgegeben {issued}, gültig bis {expires}</value> + </data> + <data name="account.passkeys.heading" xml:space="preserve"> + <value>Passkeys</value> + </data> + <data name="account.passkey.unnamed" xml:space="preserve"> + <value>ohne Namen</value> + </data> + <data name="account.passkey.added" xml:space="preserve"> + <value>hinzugefügt {date}</value> + </data> + <data name="account.passkey.addedOneDevice" xml:space="preserve"> + <value>hinzugefügt {date} · nur auf einem Gerät</value> + </data> + <data name="account.passkey.single" xml:space="preserve"> + <value>Dieser Passkey liegt auf einem einzigen Gerät. Verlieren Sie ihn, kommen Sie weiterhin hinein, indem Sie einen frischen Token in Ihrem Spiel veröffentlichen, aber ein zweiter Passkey geht schneller.</value> + </data> + <data name="account.passkey.add" xml:space="preserve"> + <value>Einen weiteren Passkey hinzufügen</value> + </data> + <data name="claim.noGame" xml:space="preserve"> + <value>Kein solches Spiel</value> + </data> + <data name="claim.title" xml:space="preserve"> + <value>{game} beanspruchen</value> + </data> + <data name="claim.noDatabase" xml:space="preserve"> + <value>Das Beanspruchen braucht eine Datenbank, und diese Website läuft auf den Demodaten.</value> + </data> + <data name="claim.needAccount" xml:space="preserve"> + <value>Dafür brauchen Sie zuerst ein Konto. Es braucht einen Passkey und einen Namen.</value> + </data> + <data name="claim.signIn" xml:space="preserve"> + <value>Anmelden oder ein Konto anlegen</value> + </data> + <data name="claim.yourGames" xml:space="preserve"> + <value>Ihre Spiele</value> + </data> + <data name="claim.hasOwners" xml:space="preserve"> + <value>{count, plural, one {Dieses Spiel hat bereits einen Betreiber, der den Zugriff auf den Server nachgewiesen hat.} other {Dieses Spiel hat bereits # Betreiber, die den Zugriff auf den Server nachgewiesen haben.}} Sie können ihn ebenfalls nachweisen — die Prüfung ist in beiden Fällen dieselbe —, aber wir müssen wissen, was Sie damit meinen, denn am Token ist es nicht zu erkennen.</value> + </data> + <data name="claim.join.button" xml:space="preserve"> + <value>Ich betreibe es auch — mich als Betreiber eintragen</value> + </data> + <data name="claim.join.note" xml:space="preserve"> + <value>Alle behalten ihren Anspruch. Das sind zwei Menschen, die ein Spiel betreiben.</value> + </data> + <data name="claim.assume.button" xml:space="preserve"> + <value>Ich habe es übernommen — auf mich übertragen</value> + </data> + <data name="claim.assume.note" xml:space="preserve"> + <value>{count, plural, one {Sobald Ihr Token bestätigt ist, wird der bestehende Anspruch widerrufen und das Spiel gehört Ihnen.} other {Sobald Ihr Token bestätigt ist, werden die bestehenden Ansprüche widerrufen und das Spiel gehört Ihnen.}} In ihrem eigenen Verlauf steht, warum. Nichts wird gelöscht, und sie können erneut nachweisen, dass sie es betreiben, auf demselben Weg, den Sie gerade gehen.</value> + </data> + <data name="claim.verified.lead" xml:space="preserve"> + <value>Bestätigt.</value> + </data> + <data name="claim.verified.viaMssp" xml:space="preserve"> + <value>Wir haben Ihren Token am {date} aus dem MSSP-Bericht des Spiels gelesen.</value> + </data> + <data name="claim.verified.viaScreen" xml:space="preserve"> + <value>Wir haben Ihren Token am {date} vom Verbindungsbildschirm gelesen.</value> + </data> + <data name="claim.verified.leaveIt" xml:space="preserve"> + <value>Lassen Sie den Token, wo er ist. Er dient zugleich als Erkennungsmerkmal, damit dieses Spiel wiedererkennbar bleibt, wenn es den Host wechselt oder den Namen ändert. Ihn wegzunehmen hebt Ihren Anspruch nicht auf.</value> + </data> + <data name="claim.publish" xml:space="preserve"> + <value>Veröffentlichen Sie diesen Token irgendwo, wo das Spiel ihn einer anonymen Verbindung zeigt. Die nächste Abfrage liest ihn auf, und damit ist nachgewiesen, dass Sie auf diesen Server schreiben können.</value> + </data> + <data name="claim.transfer.lead" xml:space="preserve"> + <value>Das ist eine Übertragung.</value> + </data> + <data name="claim.transfer.body" xml:space="preserve"> + <value>{count, plural, one {Sobald wir diesen Token lesen, wird der Anspruch des bisherigen Betreibers auf dieses Spiel widerrufen und es gehört Ihnen.} other {Sobald wir diesen Token lesen, werden die Ansprüche der bisherigen Betreiber auf dieses Spiel widerrufen und es gehört Ihnen.}}</value> + </data> + <data name="claim.either.heading" xml:space="preserve"> + <value>Eines von beidem genügt</value> + </data> + <data name="claim.mssp.heading" xml:space="preserve"> + <value>Eine MSSP-Variable</value> + </data> + <data name="claim.mssp.note" xml:space="preserve"> + <value>In {codebase} ist das eine Zeile in {file}; jede Codebase mit MSSP hat eine Entsprechung.</value> + </data> + <data name="claim.mssp.aliases" xml:space="preserve"> + <value>{aliases} werden ebenfalls angenommen.</value> + </data> + <data name="claim.screen.heading" xml:space="preserve"> + <value>Eine Zeile auf dem Verbindungsbildschirm</value> + </data> + <data name="claim.screen.note" xml:space="preserve"> + <value>Irgendwo im Bildschirm, und Farbcodes darum herum sind kein Problem.</value> + </data> + <data name="claim.then.heading" xml:space="preserve"> + <value>Dann</value> + </data> + <data name="claim.then.body" xml:space="preserve"> + <value>Wir prüfen im gewöhnlichen Crawl-Zeitplan. Dieser Token ist gültig bis {date}. Kommen Sie jederzeit wieder; nichts davon muss notiert werden.</value> + </data> + <data name="claim.check.button" xml:space="preserve"> + <value>Früher nachsehen</value> + </data> + <data name="claim.check.can" xml:space="preserve"> + <value>Bringt Ihr Spiel an den Anfang der Warteschlange. Wir wählen nach unserem eigenen Zeitplan an, das heißt also früher und nicht jetzt.</value> + </data> + <data name="claim.check.rationed" xml:space="preserve"> + <value>Gerade eben schon angefragt. Versuchen Sie es in ein paar Minuten wieder — es ist begrenzt, weil es einen echten Server früher anwählt, als wir es getan hätten.</value> + </data> + <data name="owner.declare.heading" xml:space="preserve"> + <value>Was nur Sie uns über {game} sagen können</value> + </data> + <data name="owner.declare.lede" xml:space="preserve"> + <value>Das sind die Dinge, für die MSSP kein Feld hat. Sie erscheinen auf der Seite Ihres Spiels als {declared}, mit dem Datum, an dem Sie sie zuletzt bestätigt haben, neben dem, was wir gemessen haben — nie an dessen Stelle. Nichts Gemessenes lässt sich von hier aus ändern, weder von Ihnen noch von uns.</value> + </data> + <data name="owner.field.declared" xml:space="preserve"> + <value>angegeben {age}. Leeren Sie dieses Feld, um die Angabe zurückzuziehen — was darin stand, bleibt so oder so festgehalten.</value> + </data> + <data name="owner.save" xml:space="preserve"> + <value>Ihre Angaben speichern</value> + </data> + <data name="owner.override.heading" xml:space="preserve"> + <value>Was {game} meldet und was Sie stattdessen gezeigt sehen möchten</value> + </data> + <data name="owner.override.lede" xml:space="preserve"> + <value>Ihr MSSP ist das, was jeder Crawler liest, und wir zeigen es weiterhin neben allem, was Sie hier eintragen — eine Angabe von Ihnen verdeckt keine Ihres Spiels.</value> + </data> + <data name="owner.override.nothingMeasured" xml:space="preserve"> + <value>Nichts Gemessenes lässt sich von hier aus ändern: keine Spielerzahl, keine Fähigkeit, keine Stunde Erreichbarkeit.</value> + </data> + <data name="owner.override.fixItThere" xml:space="preserve"> + <value>Ist eine Zeile unten in Ihrer {file} falsch, dann genügt es, sie dort zu berichtigen — damit stimmt sie überall.</value> + </data> + <data name="owner.report.value" xml:space="preserve"> + <value>Ihr Spiel meldet {value}, bestätigt {age}</value> + </data> + <data name="owner.report.none" xml:space="preserve"> + <value>Ihr Spiel meldet hier nichts</value> + </data> + <data name="owner.rename.note" xml:space="preserve"> + <value>Den Namen zu ändern ändert, unter welchem Namen {game} eingetragen ist, und die Adresse seiner Seite. Die alte Adresse funktioniert für immer weiter — jede URL, die dieses Spiel je hatte, leitet auf die aktuelle weiter —, und wenn Sie das Feld leeren, gilt wieder der Name, den Ihr MSSP nennt.</value> + </data> + <data name="owner.screen.heading" xml:space="preserve"> + <value>Ihr Verbindungsbildschirm</value> + </data> + <data name="owner.screen.suppressed" xml:space="preserve"> + <value>Wir veröffentlichen ihn nicht erneut. Die Seite sagt das deutlich, statt eine Leerstelle zu lassen, und der Crawler liest ihn weiterhin — daran erkennen wir Ihr Spiel wieder, wenn es umzieht.</value> + </data> + <data name="owner.screen.show" xml:space="preserve"> + <value>Wieder zeigen</value> + </data> + <data name="owner.screen.shown" xml:space="preserve"> + <value>Wir zeigen ihn, weil Ihr Server ihn an jede anonyme Verbindung sendet. Ist Ihnen das nicht recht, sagen Sie es, und wir hören auf. Wir fragen nicht nach dem Grund.</value> + </data> + <data name="owner.screen.stop" xml:space="preserve"> + <value>Unseren Verbindungsbildschirm nicht mehr zeigen</value> + </data> + <data name="owner.crawl.heading" xml:space="preserve"> + <value>Gecrawlt werden</value> + </data> + <data name="owner.crawl.stopped" xml:space="preserve"> + <value>Wir haben aufgehört. Nichts an {game} wird angewählt, und die Seite behält alles, was vor Ihrer Bitte gemessen wurde — die leeren Stunden nennen keine Ursache, denn {ourFact} ist eine Tatsache über uns und keine Messung an Ihrem Spiel.</value> + </data> + <data name="owner.crawl.ourFact" xml:space="preserve"> + <value>dass Sie uns um den Stopp gebeten haben</value> + </data> + <data name="owner.crawl.resume" xml:space="preserve"> + <value>Uns wieder crawlen</value> + </data> + <data name="owner.crawl.standing" xml:space="preserve"> + <value>Dieser Ausschluss kam von Ihrem eigenen Server und nicht von hier — {routes}. Damit wir wieder crawlen, hören Sie auf, ihn zu veröffentlichen; wir bekommen das im nächsten Zyklus mit.</value> + </data> + <data name="owner.crawl.route.mssp" xml:space="preserve"> + <value>Ihr MSSP-Bericht veröffentlicht {variable}</value> + </data> + <data name="owner.crawl.route.dns" xml:space="preserve"> + <value>ein TXT-Eintrag unter {label} bittet uns aufzuhören</value> + </data> + <data name="owner.crawl.route.recorded" xml:space="preserve"> + <value>eine von uns festgehaltene Bitte</value> + </data> + <data name="owner.crawl.partial" xml:space="preserve"> + <value>Bei {stopped} haben wir aufgehört, und {dialling} wählen wir weiterhin an. Das ist meist ein Port, der nach dem Ausschluss hinzugekommen ist.</value> + </data> + <data name="owner.crawl.stopAll" xml:space="preserve"> + <value>Auch unter jeder Adresse aufhören</value> + </data> + <data name="owner.crawl.dialling" xml:space="preserve"> + <value>Wir wählen {game} nach einem Zeitplan an und lesen, was jeder anonymen Verbindung gezeigt wird. Ist Ihnen das nicht recht, sagen Sie es, und wir hören auf — innerhalb eines Zyklus, unter jeder Adresse, die wir von Ihnen haben, und wir fragen nicht nach dem Grund.</value> + </data> + <data name="owner.crawl.selfService" xml:space="preserve"> + <value>Nichts bereits Gemessenes wird gelöscht: Ihre Seite behält ihre Geschichte und ihre URL, und eine einzige Abfrage, nachdem Sie das zurückgenommen haben, setzt es wieder in Gang. Sie können es auch ohne uns sagen, in Ihrer eigenen Konfiguration — {mssp} in MSSP oder ein TXT-Eintrag unter {dns} —, und wir befolgen das, ob dieses Spiel hier jemals beansprucht wurde oder nicht.</value> + </data> + <data name="owner.crawl.stop" xml:space="preserve"> + <value>Uns nicht mehr crawlen</value> + </data> + <data name="owner.listing.heading" xml:space="preserve"> + <value>Eingetragen sein</value> + </data> + <data name="owner.listing.unlisted" xml:space="preserve"> + <value>{game} ist aus dem Verzeichnis, aus den Ranglisten und aus der Tageszahl heraus. Seine Seite und jede URL, die es je hatte, antworten weiterhin, und alles, was vor Ihrer Bitte gemessen wurde, steht weiterhin darauf. Es wurde nichts gelöscht; es ist nur kein Ort mehr, an dem man beim Stöbern ankommt.</value> + </data> + <data name="owner.listing.relist" xml:space="preserve"> + <value>Uns wieder ins Verzeichnis aufnehmen</value> + </data> + <data name="owner.listing.probeRelists" xml:space="preserve"> + <value>Eine Abfrage, die eine Antwort erhält, tut das ebenfalls. Solange Ihr Ausschluss gilt, wählen wir nicht an, es wird also keine geben — aber an dem Tag, an dem Sie ihn zurücknehmen, kommt die Adresse binnen einer Woche an die Reihe, und die Abfrage, die eine Antwort erhält, bringt Sie zurück. Sie müssen uns kein zweites Mal fragen.</value> + </data> + <data name="owner.listing.mayUnlist" xml:space="preserve"> + <value>Wir wählen Sie nicht mehr an, und Ihre Seite steht weiterhin im Verzeichnis, mit dem, was wir davor gemessen haben. Ist Ihnen das nicht recht, sagen Sie es, und sie kommt heraus — aus dem Verzeichnis, aus den Ranglisten und aus der Tageszahl.</value> + </data> + <data name="owner.listing.reversible" xml:space="preserve"> + <value>Nichts wird gelöscht und nichts geht kaputt: Die Seite antwortet, jede URL, die sie je hatte, leitet weiterhin auf sie, und wer von Ihnen dorthin geschickt wird, sieht sie. Sie ist nur kein Ort mehr, an dem ein Lesender beim Stöbern ankommt. Von hier aus rückgängig zu machen, und ebenso durch jede Abfrage, die nach der Rücknahme Ihres Ausschlusses eine Antwort erhält.</value> + </data> + <data name="owner.listing.unlist" xml:space="preserve"> + <value>Uns auch aus dem Verzeichnis nehmen</value> + </data> + <data name="facet.group.measure" xml:space="preserve"> + <value>was wir messen konnten</value> + </data> + <data name="facet.measure.note" xml:space="preserve"> + <value>Diese auszublenden nimmt sie aus der Auflistung heraus; es heißt nicht, dass das Spiel leer ist.</value> + </data> + <data name="facet.group.uncounted" xml:space="preserve"> + <value>ungezählt</value> + </data> + <data name="facet.group.unreachable" xml:space="preserve"> + <value>nicht erreichbar</value> + </data> + <data name="facet.excluded.uncounted" xml:space="preserve"> + <value>aus dieser Auflistung ausgeblendet</value> + </data> + <data name="facet.excluded.unreachable" xml:space="preserve"> + <value>aus dieser Auflistung ausgeblendet</value> + </data> + <data name="facet.plain.marks" xml:space="preserve"> + <value>In der linken Spalte steht * für einen Wert, nach dem diese Auflistung gefiltert ist, und - für einen, gegen den gefiltert wird. Beides sind Entscheidungen in der Suche, keine Tatsachen über ein Spiel.</value> + </data> +</root> diff --git a/src/MUI.Web/Resources/Messages.ja.resx b/src/MUI.Web/Resources/Messages.ja.resx new file mode 100644 index 0000000..84f452f --- /dev/null +++ b/src/MUI.Web/Resources/Messages.ja.resx @@ -0,0 +1,2877 @@ +<?xml version="1.0" encoding="utf-8"?> +<root> + <!-- + 日本語, machine-translated and not reviewed by a person. + + Every page served in this locale carries the ◆ notice saying so, and the locale is reachable but + never offered: nothing sends a reader here. Promotion to LocaleStatus.Shipped is a person reading + the locked strings against Glossary.cs, not an edit to a status enum. + + The values are ICU MessageFormat. Argument names in braces are code. + --> + <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata"> + <xsd:import namespace="http://www.w3.org/XML/1998/namespace" /> + <xsd:element name="root" msdata:IsDataSet="true"> + <xsd:complexType> + <xsd:choice maxOccurs="unbounded"> + <xsd:element name="data"> + <xsd:complexType> + <xsd:sequence> + <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" /> + <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" /> + </xsd:sequence> + <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" /> + <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" /> + <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" /> + <xsd:attribute ref="xml:space" /> + </xsd:complexType> + </xsd:element> + <xsd:element name="resheader"> + <xsd:complexType> + <xsd:sequence> + <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" /> + </xsd:sequence> + <xsd:attribute name="name" type="xsd:string" use="required" /> + </xsd:complexType> + </xsd:element> + </xsd:choice> + </xsd:complexType> + </xsd:element> + </xsd:schema> + <resheader name="resmimetype"><value>text/microsoft-resx</value></resheader> + <resheader name="version"><value>2.0</value></resheader> + <resheader name="reader"><value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader> + <resheader name="writer"><value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader> + <data name="facet.count" xml:space="preserve"> + <value>{count, plural, other {#件のゲーム}}</value> + </data> + <data name="facet.value.include" xml:space="preserve"> + <value>{value}、{count, plural, other {#件のゲーム}}、のみ</value> + </data> + <data name="facet.value.exclude" xml:space="preserve"> + <value>{value}、{count, plural, other {#件のゲーム}}、除外</value> + </data> + <data name="facet.value.choose" xml:space="preserve"> + <value>{value}、{count, plural, other {#件のゲーム}}</value> + </data> + <data name="facet.any" xml:space="preserve"> + <value>{facet}を問わない、{count, plural, other {#件のゲーム}}</value> + </data> + <data name="listing.total" xml:space="preserve"> + <value>{count, plural, =0 {ここに掲載しているゲームはなし。} other {#件のゲーム。どの事実にも、その出所が記されている。}}</value> + </data> + <data name="chart.basis" xml:space="preserve"> + <value>{days, plural, other {#日間実測}} · {probes, plural, other {#回の探査}}</value> + </data> + <data name="window.samples" xml:space="preserve"> + <value>{days, plural, other {#日}} · {count, plural, other {#件の計数}}</value> + </data> + <data name="capabilities.agree" xml:space="preserve"> + <value>{disagreeing, plural, =0 {{total}件のうち不一致はなし。} other {{total}件のうち#件がゲームの自己申告と不一致。}}</value> + </data> + <data name="find.matching" xml:space="preserve"> + <value>{count, plural, =0 {すべての回答に一致するゲームはなし。} other {すべての回答に一致するゲームは#件。}}</value> + </data> + <data name="find.basis" xml:space="preserve"> + <value>{listed, plural, other {掲載#件のゲーム}}のうち · {answers, plural, =0 {回答なし} other {回答#件}}</value> + </data> + <data name="find.show" xml:space="preserve"> + <value>{count, plural, other {この#件のゲームを表示}}</value> + </data> + <data name="find.drop" xml:space="preserve"> + <value>「{answer}」を解除 — {count, plural, other {#件のゲーム}}</value> + </data> + <data name="find.clear" xml:space="preserve"> + <value>回答を解除：{question}</value> + </data> + <data name="find.title" xml:space="preserve"> + <value>ゲームを探す</value> + </data> + <data name="find.kicker" xml:space="preserve"> + <value>すべての回答に一致</value> + </data> + <data name="find.noun" xml:space="preserve"> + <value>{count, plural, other {ゲーム}}</value> + </data> + <data name="find.clearAll" xml:space="preserve"> + <value>回答をすべて解除</value> + </data> + <data name="find.startAgain" xml:space="preserve"> + <value>やり直す</value> + </data> + <data name="find.more" xml:space="preserve"> + <value>{count, plural, other {他#件}}</value> + </data> + <data name="find.answersGiven" xml:space="preserve"> + <value>回答済み</value> + </data> + <data name="find.wholeListing" xml:space="preserve"> + <value>一覧全体</value> + </data> + <data name="find.refused" xml:space="preserve"> + <value>そのクエリは拒否された</value> + </data> + <data name="find.name.label" xml:space="preserve"> + <value>名前（分かっていれば）</value> + </data> + <data name="find.name.placeholder" xml:space="preserve"> + <value>名前、または名前の一部</value> + </data> + <data name="find.name.submit" xml:space="preserve"> + <value>名前で検索</value> + </data> + <data name="find.q.band" xml:space="preserve"> + <value>今プレイしている人はいる？</value> + </data> + <data name="find.q.genre" xml:space="preserve"> + <value>何をプレイしたい？</value> + </data> + <data name="find.q.lineage" xml:space="preserve"> + <value>どんな種類のゲーム？</value> + </data> + <data name="find.q.language" xml:space="preserve"> + <value>どの言語？</value> + </data> + <data name="find.q.client" xml:space="preserve"> + <value>クライアントに必要なものは？</value> + </data> + <data name="find.q.dark" xml:space="preserve"> + <value>消息不明のゲームも含める？</value> + </data> + <data name="find.any.band" xml:space="preserve"> + <value>問わない</value> + </data> + <data name="find.any.genre" xml:space="preserve"> + <value>ジャンルを問わない</value> + </data> + <data name="find.any.lineage" xml:space="preserve"> + <value>種類を問わない</value> + </data> + <data name="find.any.language" xml:space="preserve"> + <value>言語を問わない</value> + </data> + <data name="find.any.client" xml:space="preserve"> + <value>問わない</value> + </data> + <data name="find.dark.no" xml:space="preserve"> + <value>いいえ、ライブのゲームのみ</value> + </data> + <data name="find.dark.yes" xml:space="preserve"> + <value>はい、それらも表示</value> + </data> + <data name="find.dark.chip" xml:space="preserve"> + <value>消息不明のゲーム</value> + </data> + <data name="find.protocol.tls" xml:space="preserve"> + <value>TLS — 暗号化、ハンドシェイクは当サイトで完了</value> + </data> + <data name="find.protocol.mssp" xml:space="preserve"> + <value>MSSP — サーバーの自己申告</value> + </data> + <data name="find.protocol.mccp" xml:space="preserve"> + <value>MCCP — 出力の圧縮</value> + </data> + <data name="find.protocol.mxp" xml:space="preserve"> + <value>MXP — クリック可能なリンク</value> + </data> + <data name="find.protocol.gmcp" xml:space="preserve"> + <value>GMCP — 構造化クライアントデータ</value> + </data> + <data name="find.protocol.msdp" xml:space="preserve"> + <value>MSDP — 構造化クライアントデータ</value> + </data> + <data name="find.protocol.charset" xml:space="preserve"> + <value>CHARSET — エンコーディングのネゴシエーション</value> + </data> + <data name="find.protocol.utf8" xml:space="preserve"> + <value>UTF-8 — 非ラテン文字が表示される</value> + </data> + <data name="find.protocol.ttype" xml:space="preserve"> + <value>TTYPE — クライアントが自分の種類を伝える</value> + </data> + <data name="find.protocol.atcp" xml:space="preserve"> + <value>ATCP — 構造化クライアントデータ</value> + </data> + <data name="find.protocol.msp" xml:space="preserve"> + <value>MSP — サウンドのトリガー</value> + </data> + <data name="find.protocol.eor" xml:space="preserve"> + <value>EOR — プロンプトの区切り</value> + </data> + <data name="find.protocol.other" xml:space="preserve"> + <value>{token} — ハンドシェイクで実測</value> + </data> + <data name="provenance.count.measured" xml:space="preserve"> + <value>実測</value> + </data> + <data name="provenance.game.measured" xml:space="preserve"> + <value>実測</value> + </data> + <data name="provenance.capability.measured" xml:space="preserve"> + <value>実測</value> + </data> + <data name="provenance.screen.measured" xml:space="preserve"> + <value>実測</value> + </data> + <data name="kicker.measured" xml:space="preserve"> + <value>実測</value> + </data> + <data name="provenance.count.declared" xml:space="preserve"> + <value>自己申告</value> + </data> + <data name="provenance.game.declared" xml:space="preserve"> + <value>自己申告</value> + </data> + <data name="provenance.capability.declared" xml:space="preserve"> + <value>自己申告</value> + </data> + <data name="kicker.declared" xml:space="preserve"> + <value>自己申告</value> + </data> + <data name="provenance.derived" xml:space="preserve"> + <value>導出</value> + </data> + <data name="kicker.derived" xml:space="preserve"> + <value>導出</value> + </data> + <data name="state.notMeasured" xml:space="preserve"> + <value>未計測</value> + </data> + <data name="state.uncounted" xml:space="preserve"> + <value>接続数読み取り不可</value> + </data> + <data name="state.unreachable" xml:space="preserve"> + <value>到達不可</value> + </data> + <data name="state.notCounted" xml:space="preserve"> + <value>読み取り不可</value> + </data> + <data name="listing.count.none" xml:space="preserve"> + <value>計数なし</value> + </data> + <data name="listing.plain.fromHere" xml:space="preserve"> + <value>ここから</value> + </data> + <data name="listing.plain.archived" xml:space="preserve"> + <value>アーカイブ済</value> + </data> + <data name="listing.plain.claimed" xml:space="preserve"> + <value>申請済</value> + </data> + <data name="random.empty.title" xml:space="preserve"> + <value>選べるゲームがない</value> + </data> + <data name="random.empty.body" xml:space="preserve"> + <value>そのフィルターに一致するゲームはない。{listing}か、{archive}。</value> + </data> + <data name="random.empty.listing" xml:space="preserve"> + <value>一覧全体</value> + </data> + <data name="random.empty.archive" xml:space="preserve"> + <value>アーカイブも含める</value> + </data> + <data name="term.connected" xml:space="preserve"> + <value>接続数</value> + </data> + <data name="term.unclaimed" xml:space="preserve"> + <value>所有者未申請</value> + </data> + <data name="term.claimedByOwner" xml:space="preserve"> + <value>所有者により申請済み</value> + </data> + <data name="term.stillProbed" xml:space="preserve"> + <value>探査は継続中</value> + </data> + <data name="term.typical" xml:space="preserve"> + <value>通常</value> + </data> + <data name="term.peak" xml:space="preserve"> + <value>ピーク</value> + </data> + <data name="a11y.readAsText" xml:space="preserve"> + <value>テキストで読む</value> + </data> + <data name="a11y.plainText" xml:space="preserve"> + <value>プレーンテキスト</value> + </data> + <data name="a11y.skipToContent" xml:space="preserve"> + <value>本文へスキップ</value> + </data> + <data name="a11y.asciiBanner" xml:space="preserve"> + <value>ASCIIバナー：{game}の接続画面。</value> + </data> + <data name="nav.catalogues" xml:space="preserve"> + <value>カタログ</value> + </data> + <data name="nav.account" xml:space="preserve"> + <value>このサイトとアカウント</value> + </data> + <data name="nav.browse" xml:space="preserve"> + <value>閲覧</value> + </data> + <data name="nav.learn" xml:space="preserve"> + <value>学ぶ</value> + </data> + <data name="nav.thisSite" xml:space="preserve"> + <value>このサイト</value> + </data> + <data name="nav.menu" xml:space="preserve"> + <value>メニュー</value> + </data> + <data name="nav.games" xml:space="preserve"> + <value>ゲーム</value> + </data> + <data name="nav.find" xml:space="preserve"> + <value>探す</value> + </data> + <data name="nav.random" xml:space="preserve"> + <value>ランダム</value> + </data> + <data name="nav.archive" xml:space="preserve"> + <value>アーカイブ</value> + </data> + <data name="nav.reference" xml:space="preserve"> + <value>リファレンス</value> + </data> + <data name="nav.ecosystem" xml:space="preserve"> + <value>エコシステム</value> + </data> + <data name="nav.rankings" xml:space="preserve"> + <value>ランキング</value> + </data> + <data name="nav.about" xml:space="preserve"> + <value>概要</value> + </data> + <data name="nav.submit" xml:space="preserve"> + <value>登録</value> + </data> + <data name="nav.submitGame" xml:space="preserve"> + <value>ゲームを登録</value> + </data> + <data name="nav.signIn" xml:space="preserve"> + <value>サインイン</value> + </data> + <data name="nav.yourGames" xml:space="preserve"> + <value>自分のゲーム</value> + </data> + <data name="theme.label" xml:space="preserve"> + <value>テーマ</value> + </data> + <data name="theme.auto" xml:space="preserve"> + <value>自動</value> + </data> + <data name="theme.light" xml:space="preserve"> + <value>ライト</value> + </data> + <data name="theme.dark" xml:space="preserve"> + <value>ダーク</value> + </data> + <data name="banner.demo.lead" xml:space="preserve"> + <value>デモデータ。</value> + </data> + <data name="banner.demo" xml:space="preserve"> + <value>データベースが未設定のため、これはダミーデータ。ここにある値は実測ではない。</value> + </data> + <data name="footer.allGames" xml:space="preserve"> + <value>すべてのゲーム</value> + </data> + <data name="footer.archive" xml:space="preserve"> + <value>アーカイブ</value> + </data> + <data name="footer.declaredByGame" xml:space="preserve"> + <value>ゲームの自己申告</value> + </data> + <data name="footer.whatChanged" xml:space="preserve"> + <value>変更点</value> + </data> + <data name="home.title" xml:space="preserve"> + <value>MU*ホビーのディレクトリ</value> + </data> + <data name="home.lede" xml:space="preserve"> + <value>どの事実にも、その出所といつのものかが記されている：当サイトのクローラーが実測したものか、ゲームが自己申告し、そう明記したものか。</value> + </data> + <data name="home.search.label" xml:space="preserve"> + <value>名前・テーマ・コードベース・ホストでゲームを検索</value> + </data> + <data name="home.search.placeholder" xml:space="preserve"> + <value>名前・テーマ・コードベース・ホストで検索</value> + </data> + <data name="home.search.submit" xml:space="preserve"> + <value>検索</value> + </data> + <data name="tile.gamesKnown" xml:space="preserve"> + <value>既知のゲーム</value> + </data> + <data name="tile.connectedNow" xml:space="preserve"> + <value>現在の接続数</value> + </data> + <data name="tile.answeringUncounted" xml:space="preserve"> + <value>応答あり・読み取り不可</value> + </data> + <data name="tile.archived" xml:space="preserve"> + <value>アーカイブ済み</value> + </data> + <data name="feed.newlyDiscovered" xml:space="preserve"> + <value>新規発見</value> + </data> + <data name="feed.wentDark" xml:space="preserve"> + <value>消息不明 — 探査は継続中</value> + </data> + <data name="feed.cameBack" xml:space="preserve"> + <value>復帰</value> + </data> + <data name="feed.nothingNew" xml:space="preserve"> + <value>新規なし。</value> + </data> + <data name="feed.nothingDark" xml:space="preserve"> + <value>消息不明になったゲームはなし。</value> + </data> + <data name="feed.nothingBack" xml:space="preserve"> + <value>復帰したゲームはなし。探査は続ける。</value> + </data> + <data name="feed.live" xml:space="preserve"> + <value>ライブ</value> + </data> + <data name="games.title" xml:space="preserve"> + <value>ゲーム</value> + </data> + <data name="listing.sortedBy" xml:space="preserve"> + <value>{order}順</value> + </data> + <data name="listing.random" xml:space="preserve"> + <value>ランダム</value> + </data> + <data name="listing.columns" xml:space="preserve"> + <value>接続数 · 到達</value> + </data> + <data name="listing.fromHere" xml:space="preserve"> + <value>ここから</value> + </data> + <data name="listing.empty.head" xml:space="preserve"> + <value>該当なし。</value> + </data> + <data name="listing.empty.hint" xml:space="preserve"> + <value>語を減らすか、フィルターを外す。</value> + </data> + <data name="listing.clearFilters" xml:space="preserve"> + <value>フィルターを解除</value> + </data> + <data name="listing.aboutCodebase" xml:space="preserve"> + <value>{codebase}について</value> + </data> + <data name="listing.never" xml:space="preserve"> + <value>到達なし</value> + </data> + <data name="listing.claimed" xml:space="preserve"> + <value>所有者により申請済み</value> + </data> + <data name="listing.unknownCodebase" xml:space="preserve"> + <value>コードベース不明</value> + </data> + <data name="listing.unknownCodebase.title" xml:space="preserve"> + <value>このゲームのコードベースは特定できなかった</value> + </data> + <data name="listing.moreProtocols" xml:space="preserve"> + <value>ほか{count, plural, other {#件}}：{names}</value> + </data> + <data name="switch.order" xml:space="preserve"> + <value>並び順</value> + </data> + <data name="switch.window" xml:space="preserve"> + <value>期間</value> + </data> + <data name="switch.now" xml:space="preserve"> + <value>現在</value> + </data> + <data name="switch.typical" xml:space="preserve"> + <value>通常</value> + </data> + <data name="switch.peak" xml:space="preserve"> + <value>ピーク</value> + </data> + <data name="switch.name" xml:space="preserve"> + <value>名前</value> + </data> + <data name="switch.reached" xml:space="preserve"> + <value>到達</value> + </data> + <data name="window.7" xml:space="preserve"> + <value>7日</value> + </data> + <data name="window.30" xml:space="preserve"> + <value>30日</value> + </data> + <data name="window.90" xml:space="preserve"> + <value>90日</value> + </data> + <data name="filters.search.label" xml:space="preserve"> + <value>ゲームを検索</value> + </data> + <data name="filters.search.placeholder" xml:space="preserve"> + <value>ゲームを検索</value> + </data> + <data name="filters.summary" xml:space="preserve"> + <value>フィルター</value> + </data> + <data name="filters.showing" xml:space="preserve"> + <value>表示中</value> + </data> + <data name="filters.clearAll" xml:space="preserve"> + <value>すべて解除</value> + </data> + <data name="filters.stopFiltering" xml:space="preserve"> + <value>— この絞り込みを解除</value> + </data> + <data name="facet.anyValue" xml:space="preserve"> + <value>問わない</value> + </data> + <data name="facet.more" xml:space="preserve"> + <value>他のフィルター（{count}）</value> + </data> + <data name="facet.moreValues" xml:space="preserve"> + <value>{count, plural, other {他#件}}</value> + </data> + <data name="facet.alsoShow" xml:space="preserve"> + <value>追加で表示</value> + </data> + <data name="facet.alsoShow.note" xml:space="preserve"> + <value>既定ではオフ。どちらもゲームへの評価ではない。</value> + </data> + <data name="facet.archived" xml:space="preserve"> + <value>アーカイブ済み</value> + </data> + <data name="facet.adult" xml:space="preserve"> + <value>アダルト</value> + </data> + <data name="facet.archived.state" xml:space="preserve"> + <value>アーカイブ済みのゲーム、{shown, select, true {表示} other {非表示}}</value> + </data> + <data name="facet.adult.state" xml:space="preserve"> + <value>アダルト指定を自己申告したゲーム、{shown, select, true {表示} other {非表示}}</value> + </data> + <data name="facet.countsNote" xml:space="preserve"> + <value>件数は実測したゲーム数であり、推定値ではない。</value> + </data> + <data name="facet.key.summary" xml:space="preserve"> + <value>バッジと空欄の意味</value> + </data> + <data name="facet.key.blank" xml:space="preserve"> + <value>空欄は実測の欠落であり、否定ではない。ファセットごとに表記が異なる：特定できず、申告なし、ネゴシエーションなし。</value> + </data> + <data name="facet.key.zero" xml:space="preserve"> + <value>実測のゼロは計数である。接続数不明はゼロではなく、ゼロとして並べ替えられることもない。</value> + </data> + <data name="facet.key.openEnded" xml:space="preserve"> + <value>値が定まらないファセットは最頻の{count}件の値のみを挙げる。残りは検索とURLから到達可能。</value> + </data> + <data name="facet.presence.note" xml:space="preserve"> + <value>未チェックは未計測の意味 — ゲームに備わっていないという意味ではない。</value> + </data> + <data name="facet.group.band" xml:space="preserve"> + <value>活動</value> + </data> + <data name="facet.group.seen" xml:space="preserve"> + <value>最終確認</value> + </data> + <data name="facet.group.protocol" xml:space="preserve"> + <value>提供プロトコル</value> + </data> + <data name="facet.group.tls" xml:space="preserve"> + <value>暗号化</value> + </data> + <data name="facet.group.charset" xml:space="preserve"> + <value>エンコーディング</value> + </data> + <data name="facet.group.codebase" xml:space="preserve"> + <value>コードベース</value> + </data> + <data name="facet.group.version" xml:space="preserve"> + <value>バージョン</value> + </data> + <data name="facet.group.lineage" xml:space="preserve"> + <value>系統</value> + </data> + <data name="facet.group.family" xml:space="preserve"> + <value>ファミリー</value> + </data> + <data name="facet.group.genre" xml:space="preserve"> + <value>ジャンル</value> + </data> + <data name="facet.group.language" xml:space="preserve"> + <value>言語</value> + </data> + <data name="facet.band.playersNow" xml:space="preserve"> + <value>現在接続あり</value> + </data> + <data name="facet.band.activeThisWeek" xml:space="preserve"> + <value>今週アクティブ</value> + </data> + <data name="facet.band.quiet" xml:space="preserve"> + <value>閑散 — 計数は0を超えず</value> + </data> + <data name="facet.band.dark" xml:space="preserve"> + <value>消息不明 — 1か月間到達なし</value> + </data> + <data name="facet.band.archived" xml:space="preserve"> + <value>アーカイブ済み</value> + </data> + <data name="facet.seen.day" xml:space="preserve"> + <value>24時間以内</value> + </data> + <data name="facet.seen.week" xml:space="preserve"> + <value>7日以内</value> + </data> + <data name="facet.seen.month" xml:space="preserve"> + <value>30日以内</value> + </data> + <data name="facet.seen.older" xml:space="preserve"> + <value>それ以前</value> + </data> + <data name="facet.seen.never" xml:space="preserve"> + <value>一度も到達なし</value> + </data> + <data name="facet.unknown.charset" xml:space="preserve"> + <value>ネゴシエーションなし</value> + </data> + <data name="facet.unknown.codebase" xml:space="preserve"> + <value>特定できず</value> + </data> + <data name="facet.unknown.other" xml:space="preserve"> + <value>申告なし</value> + </data> + <data name="facet.tls.yes" xml:space="preserve"> + <value>TLSで接続</value> + </data> + <data name="facet.excluded" xml:space="preserve"> + <value>{value}以外</value> + </data> + <data name="facet.known.charset" xml:space="preserve"> + <value>ネゴシエーションあり</value> + </data> + <data name="facet.known.codebase" xml:space="preserve"> + <value>特定済み</value> + </data> + <data name="facet.known.other" xml:space="preserve"> + <value>申告あり</value> + </data> + <data name="evidence.measured.meaning" xml:space="preserve"> + <value>実際に観測した</value> + </data> + <data name="evidence.declared.meaning" xml:space="preserve"> + <value>ゲームの申告であり、検証はしていない</value> + </data> + <data name="evidence.derived.meaning" xml:space="preserve"> + <value>ゲームの申告を分類したもの</value> + </data> + <data name="sort.name" xml:space="preserve"> + <value>名前</value> + </data> + <data name="sort.players" xml:space="preserve"> + <value>現在の接続数</value> + </data> + <data name="sort.reached" xml:space="preserve"> + <value>最終到達</value> + </data> + <data name="sort.medianWeek" xml:space="preserve"> + <value>通常の接続数 · 7日</value> + </data> + <data name="sort.medianMonth" xml:space="preserve"> + <value>通常の接続数 · 30日</value> + </data> + <data name="sort.medianQuarter" xml:space="preserve"> + <value>通常の接続数 · 90日</value> + </data> + <data name="sort.peakWeek" xml:space="preserve"> + <value>同時接続ピーク · 7日</value> + </data> + <data name="sort.peakMonth" xml:space="preserve"> + <value>同時接続ピーク · 30日</value> + </data> + <data name="sort.peakQuarter" xml:space="preserve"> + <value>同時接続ピーク · 90日</value> + </data> + <data name="sort.group.row" xml:space="preserve"> + <value>行の現在値</value> + </data> + <data name="sort.group.typical" xml:space="preserve"> + <value>通常</value> + </data> + <data name="sort.group.peak" xml:space="preserve"> + <value>ピーク</value> + </data> + <data name="sort.unranked.players" xml:space="preserve"> + <value>接続数不明</value> + </data> + <data name="sort.unranked.reached" xml:space="preserve"> + <value>一度も到達なし — 到達が古いのではない</value> + </data> + <data name="sort.unranked.median" xml:space="preserve"> + <value>期間内の計数が{minimum}件未満、または皆無 — 通常の接続数がゼロなのではない</value> + </data> + <data name="sort.unranked.window" xml:space="preserve"> + <value>期間内に計数を読み取れず — 誰も接続していなかったのではない</value> + </data> + <data name="sort.window.median" xml:space="preserve"> + <value>中央値 {value} · {days, plural, other {#日}} · {count, plural, other {#件の計数}}</value> + </data> + <data name="sort.window.peak" xml:space="preserve"> + <value>同時最大 {value} · {days, plural, other {#日}} · {count, plural, other {#件の計数}}</value> + </data> + <data name="game.connectScreen" xml:space="preserve"> + <value>接続画面</value> + </data> + <data name="game.connectionsByHour" xml:space="preserve"> + <value>時間帯別の接続数</value> + </data> + <data name="game.howMany" xml:space="preserve"> + <value>接続数の推移</value> + </data> + <data name="game.reachable" xml:space="preserve"> + <value>到達可能</value> + </data> + <data name="game.whatChanged" xml:space="preserve"> + <value>変更点</value> + </data> + <data name="game.capabilities" xml:space="preserve"> + <value>機能</value> + </data> + <data name="game.declaredByGame" xml:space="preserve"> + <value>ゲームの自己申告</value> + </data> + <data name="game.referrals" xml:space="preserve"> + <value>リファラル</value> + </data> + <data name="game.unclaimed" xml:space="preserve"> + <value>所有者未申請 — ここにある情報はすべて実測。</value> + </data> + <data name="game.claimed" xml:space="preserve"> + <value>所有者により申請済み — 以下の実測値は引き続き当サイトのもの。</value> + </data> + <data name="game.claim" xml:space="preserve"> + <value>このゲームを申請する</value> + </data> + <data name="game.answeringSince" xml:space="preserve"> + <value>{date}から応答</value> + </data> + <data name="game.readAsTextRows" xml:space="preserve"> + <value>テキストで読む — {count, plural, other {#行}}</value> + </data> + <data name="capability.column" xml:space="preserve"> + <value>機能</value> + </data> + <data name="capability.age" xml:space="preserve"> + <value>経過</value> + </data> + <data name="capability.offered" xml:space="preserve"> + <value>提供</value> + </data> + <data name="capability.silent" xml:space="preserve"> + <value>無応答</value> + </data> + <data name="capability.absent" xml:space="preserve"> + <value>なし</value> + </data> + <data name="capability.denied" xml:space="preserve"> + <value>拒否</value> + </data> + <data name="capability.claimed" xml:space="preserve"> + <value>自己申告</value> + </data> + <data name="capability.disagrees" xml:space="preserve"> + <value>不一致</value> + </data> + <data name="capability.whereTheyDisagree" xml:space="preserve"> + <value>不一致の箇所（{count}）</value> + </data> + <data name="activity.cell.counted" xml:space="preserve"> + <value>{day} {time} — {count, plural, =0 {接続数0、実測} other {平均#人}}</value> + </data> + <data name="activity.cell.notCounted" xml:space="preserve"> + <value>{day} {time} — 探査したが接続数は読み取れず</value> + </data> + <data name="activity.cell.notMeasured" xml:space="preserve"> + <value>{day} {time} — この時間は未計測</value> + </data> + <data name="activity.none" xml:space="preserve"> + <value>このゲームの活動はまだ実測していない。</value> + </data> + <data name="activity.noCount" xml:space="preserve"> + <value>週のどの時間にも接続数は得られていない。</value> + </data> + <data name="activity.allZero" xml:space="preserve"> + <value>すべての時間を実測し、どの時間も接続はなかった。</value> + </data> + <data name="activity.gap.day" xml:space="preserve"> + <value>{count, plural, other {{day}の#時間はまだ未計測。}}</value> + </data> + <data name="activity.gap.week" xml:space="preserve"> + <value>{count, plural, other {週全体で#時間がまだ未計測。}}</value> + </data> + <data name="activity.uncounted.day" xml:space="preserve"> + <value>{count, plural, other {{day}の#時間は応答したが接続数は読み取れず。}}</value> + </data> + <data name="activity.uncounted.week" xml:space="preserve"> + <value>{count, plural, other {週全体で#時間が応答したが接続数は読み取れず。}}</value> + </data> + <data name="activity.busiest.everyDay" xml:space="preserve"> + <value>毎日、{window}が最も多い。</value> + </data> + <data name="activity.busiest.everyDay.part" xml:space="preserve"> + <value>毎日、{part}の{window}が最も多い。</value> + </data> + <data name="activity.busiest.days" xml:space="preserve"> + <value>{days}は{window}が最も多い。</value> + </data> + <data name="activity.busiest.days.part" xml:space="preserve"> + <value>{days}は{part}、{window}が最も多い。</value> + </data> + <data name="activity.quiet" xml:space="preserve"> + <value>{who}の{window}は常に接続が少ない。</value> + </data> + <data name="activity.quiet.part" xml:space="preserve"> + <value>{who}の{part}、{window}は常に接続が少ない。</value> + </data> + <data name="activity.quiet.everyDay" xml:space="preserve"> + <value>毎日</value> + </data> + <data name="activity.quiet.everyMeasuredDay" xml:space="preserve"> + <value>実測できたすべての日</value> + </data> + <data name="activity.quiet.weekdays" xml:space="preserve"> + <value>平日</value> + </data> + <data name="activity.quiet.onDays" xml:space="preserve"> + <value>{days}</value> + </data> + <data name="activity.part.morning" xml:space="preserve"> + <value>午前</value> + </data> + <data name="activity.part.afternoon" xml:space="preserve"> + <value>午後</value> + </data> + <data name="activity.part.evening" xml:space="preserve"> + <value>夜</value> + </data> + <data name="activity.part.smallHours" xml:space="preserve"> + <value>深夜</value> + </data> + <data name="activity.parts.morning" xml:space="preserve"> + <value>午前</value> + </data> + <data name="activity.parts.afternoon" xml:space="preserve"> + <value>午後</value> + </data> + <data name="activity.parts.evening" xml:space="preserve"> + <value>夜</value> + </data> + <data name="activity.parts.smallHours" xml:space="preserve"> + <value>深夜</value> + </data> + <data name="activity.days.list" xml:space="preserve"> + <value>{list}、{next}</value> + </data> + <data name="activity.days.pair" xml:space="preserve"> + <value>{first}と{second}</value> + </data> + <data name="activity.sparse.kicker" xml:space="preserve"> + <value>実測がまだ足りない</value> + </data> + <data name="activity.sparse.none" xml:space="preserve"> + <value>週のどの時間もまだ未計測。</value> + </data> + <data name="activity.sparse.uncounted" xml:space="preserve"> + <value>{count, plural, other {#時間は応答したが接続数は読み取れず。}}</value> + </data> + <data name="activity.sparse.wait" xml:space="preserve"> + <value>週のすべての曜日に実測が入るとグリッドが表示される。</value> + </data> + <data name="activity.sparse.days" xml:space="preserve"> + <value>{days, plural, other {これまでに7日のうち#日を実測。すべての曜日に1時間でも入るとグリッドが表示される。}}</value> + </data> + <data name="activity.sample.zero" xml:space="preserve"> + <value>{count, plural, other {#時間を実測、いずれも接続なし。}}</value> + </data> + <data name="activity.sample.peak" xml:space="preserve"> + <value>{count, plural, other {#時間を実測、最多は{day} {time} UTCの{peak}。}}</value> + </data> + <data name="activity.sample.more" xml:space="preserve"> + <value>{count, plural, other {他に#時間が応答したが接続数は読み取れず。}}</value> + </data> + <data name="activity.day.line" xml:space="preserve"> + <value>{day} — {facts}</value> + </data> + <data name="activity.day.facts" xml:space="preserve"> + <value>{first}、{second}</value> + </data> + <data name="activity.day.allZero" xml:space="preserve"> + <value>終日ゼロを実測</value> + </data> + <data name="activity.day.peak" xml:space="preserve"> + <value>{time}にピーク{count}</value> + </data> + <data name="activity.day.nobodyOn" xml:space="preserve"> + <value>{window}は接続なし</value> + </data> + <data name="activity.day.noCount" xml:space="preserve"> + <value>どの時間も接続数を読み取れず</value> + </data> + <data name="activity.day.notMeasured" xml:space="preserve"> + <value>{count, plural, other {#時間が未計測}}</value> + </data> + <data name="activity.day.notCounted" xml:space="preserve"> + <value>{count, plural, other {#時間は探査したが読み取り不可}}</value> + </data> + <data name="activity.column.day" xml:space="preserve"> + <value>曜日</value> + </data> + <data name="activity.column.quietest" xml:space="preserve"> + <value>最少</value> + </data> + <data name="activity.column.busiest" xml:space="preserve"> + <value>最多</value> + </data> + <data name="activity.column.at" xml:space="preserve"> + <value>時刻</value> + </data> + <data name="activity.column.noCount" xml:space="preserve"> + <value>読み取り不可</value> + </data> + <data name="activity.caption" xml:space="preserve"> + <value>曜日別の接続数（UTC）。{window}。</value> + </data> + <data name="activity.times" xml:space="preserve"> + <value>時刻はUTC · {window}</value> + </data> + <data name="activity.rollingAverage" xml:space="preserve"> + <value>{weeks, plural, other {#週の移動平均}}</value> + </data> + <data name="activity.legend.counted" xml:space="preserve"> + <value>計数あり（実測のゼロを含む）</value> + </data> + <data name="activity.legend.notCounted" xml:space="preserve"> + <value>探査したが接続数は読み取れず</value> + </data> + <data name="activity.legend.notMeasured" xml:space="preserve"> + <value>その時間は未計測</value> + </data> + <data name="activity.plain.heading" xml:space="preserve"> + <value>人がいる時間帯（UTC）</value> + </data> + <data name="activity.key.counted" xml:space="preserve"> + <value>計数あり</value> + </data> + <data name="activity.key.counted.meaning" xml:space="preserve"> + <value>接続でき、数値を読み取れた（実測のゼロを含む）</value> + </data> + <data name="activity.key.uncounted.meaning" xml:space="preserve"> + <value>接続できたが、数値は読み取れなかった</value> + </data> + <data name="activity.key.notMeasured.meaning" xml:space="preserve"> + <value>その時間の実測がない</value> + </data> + <data name="locale.label" xml:space="preserve"> + <value>言語</value> + </data> + <data name="locale.submit" xml:space="preserve"> + <value>言語を変更</value> + </data> + <data name="about.title" xml:space="preserve"> + <value>mu*indexについて</value> + </data> + <data name="about.lede" xml:space="preserve"> + <value>ここにあるゲームはすべて、接続した機械が実測したもの。どの値にも、出所といつのものかが記されている。このページでは、それが何を証明するのか、何を誤ると分かっているのか、誰のディレクトリを読んでいるのか、そしてクローラーを止める方法を扱う。</value> + </data> + <data name="about.measures.heading" xml:space="preserve"> + <value>ここでの事実とは何か</value> + </data> + <data name="about.measures.declared.lead" xml:space="preserve"> + <value>実測は自己申告に優先し、どちらも表示する。</value> + </data> + <data name="about.measures.declared.body" xml:space="preserve"> + <value>ゲームのMSSPレポートは、そのゲームが自分自身を説明したもの。telnetハンドシェイクは、当サイトがそのゲームの振る舞いを実際に見たもの。どちらもそのゲームのページに、方法と時期を添えて表示する。両者が食い違う場合は、その不一致を示す。</value> + </data> + <data name="about.measures.count.lead" xml:space="preserve"> + <value>接続数は、その出所を明示する。</value> + </data> + <data name="about.measures.count.body" xml:space="preserve"> + <value>接続画面で読み取ったWHOかDOING（当サイトが数えたもの）、あるいはゲーム自身が公開したMSSPのPLAYERSフィールドのいずれか。両者を混ぜることはない。</value> + </data> + <data name="about.measures.unknown.lead" xml:space="preserve"> + <value>読み取れなかった応答は不明であって、ゼロではない。</value> + </data> + <data name="about.measures.unknown.body" xml:space="preserve"> + <value>サーバーはWHOのヘッダーを自由に書き換えるので、ある程度を超えると当サイトのパーサーは読み取れない。それは接続数読み取り不可という、それ自体で一つの状態。実測のゼロ — 接続でき、誰もいなかった — は計数であり、計数として表示する。</value> + </data> + <data name="about.measures.reachable.lead" xml:space="preserve"> + <value>到達可能であって、稼働率ではない。</value> + </data> + <data name="about.measures.reachable.body" xml:space="preserve"> + <value>当サイトは1台のホストから一定の間隔でソケットを開く。経路が通らないゲームは到達不可であり、それでいて健在。実測していない以上、ここではどのゲームの稼働率も主張しない。</value> + </data> + <data name="about.measures.hour.lead" xml:space="preserve"> + <value>1時間は、計数あり、読み取り不可、未計測のいずれか。</value> + </data> + <data name="about.measures.hour.body" xml:space="preserve"> + <value>活動グリッドには3つの状態がある。3つ目は空欄であり、原因を名指ししない：到達できなかった時間も、一度も探査しなかった時間も、同じ欠落であって、どちらもそのサーバーの停止時間ではない。</value> + </data> + <data name="about.limits.heading" xml:space="preserve"> + <value>誤ると分かっていること</value> + </data> + <data name="about.limits.grace.lead" xml:space="preserve"> + <value>アーカイブまでの猶予は、こちらが見つけた日から数える。</value> + </data> + <data name="about.limits.grace.body" xml:space="preserve"> + <value>応答しなくなったゲームは、猶予期間を過ぎると既定の一覧から外れる：猶予は探査した到達可能時間の4分の1で、下限60日、上限365日。1995年から動いているゲームでも、発見した日には下限から始まる。当サイトが来る前の年月を埋めるためのインポートは一切しない。</value> + </data> + <data name="about.limits.created.lead" xml:space="preserve"> + <value>MSSPのCREATEDはその猶予に算入しない。</value> + </data> + <data name="about.limits.created.body" xml:space="preserve"> + <value>設定ファイルに手で書かれた1行にすぎず、算入すればアーカイブのしきい値を操作できてしまう。自己申告として表示するが、それで得られるものはない。</value> + </data> + <data name="about.limits.claim.lead" xml:space="preserve"> + <value>ゲームを申請すれば上限が得られる。</value> + </data> + <data name="about.limits.claim.body" xml:space="preserve"> + <value>サーバーへのアクセスを証明すれば、観測してきた期間の長さにかかわらず、猶予は満1年になる。</value> + </data> + <data name="about.limits.oneHost.lead" xml:space="preserve"> + <value>ここにあるものはすべて、1台のホストが一定間隔で見た結果。</value> + </data> + <data name="about.limits.oneHost.body" xml:space="preserve"> + <value>到達可能時間の割合は、観測した期間に対する割合であって、観測しなかった期間に対するものではない。ここにあるどの図も、残りを埋めることはしない。</value> + </data> + <data name="about.limits.deletion.lead" xml:space="preserve"> + <value>削除は一切しない。</value> + </data> + <data name="about.limits.deletion.body" xml:space="preserve"> + <value>アーカイブはゲームを既定の一覧、ランキング、本日アクティブの数値から外すだけで、それ以上のことはしない。ページ、URL、履歴、アドレスはそのまま残り、探査は続き、1回の探査が成功すれば元に戻る。</value> + </data> + <data name="about.never.heading" xml:space="preserve"> + <value>このサイトがしないこと</value> + </data> + <data name="about.never.votes.lead" xml:space="preserve"> + <value>投票も、星も、評価も、おすすめもない。</value> + </data> + <data name="about.never.votes.body" xml:space="preserve"> + <value>ランキングは実測データのみから算出する。最も多くクリックを動員できた者で順位が決まるディレクトリが表すのは、その動員活動であってこのホビーではない。先行したディレクトリを滅ぼしたのはそれだ。</value> + </data> + <data name="about.never.forums.lead" xml:space="preserve"> + <value>フォーラムも、レビューも、ウィキも、コメントも、プレイヤープロフィールもない。</value> + </data> + <data name="about.never.forums.body" xml:space="preserve"> + <value>入門的な解説 — MUSHとは何か、共同ロールプレイにはどのコードベースが向くか — は、サイトの他の部分と同じく、執筆され、署名され、バージョン管理される。</value> + </data> + <data name="about.never.names.lead" xml:space="preserve"> + <value>プレイヤー名は一切保存しない。</value> + </data> + <data name="about.never.names.body" xml:space="preserve"> + <value>WHOの応答は、人数とヘッダーの形を得るためにメモリ上で解析する。名前は書き出さない。集計には、ローテーションするソルトを用いたソルト付きハッシュを使う。</value> + </data> + <data name="about.never.population.lead" xml:space="preserve"> + <value>人口の絶対数は公表しない。</value> + </data> + <data name="about.never.population.body" xml:space="preserve"> + <value>コードベース別・プロトコル別のシェアは公開する：実測した集合に対する比率は、計数できないゲームがあっても意味を保つ。「MU*を遊んでいる人は何人か」は保たない。その数字は引用に耐えないから。</value> + </data> + <data name="about.crawler.heading" xml:space="preserve"> + <value>クローラーと、その止め方</value> + </data> + <data name="about.crawler.probe.lead" xml:space="preserve"> + <value>探査とは、ログインしない1本の接続のこと。</value> + </data> + <data name="about.crawler.probe.body" xml:space="preserve"> + <value>ソケットを開き、telnetオプションをネゴシエートし、接続画面を読み、オプション70のネゴシエーションでMSSPを要求し、{commands}を送り、切断する。キャラクターも作らず、ログインもせず、相手側では何も変わらない。セッションにはタイムアウトを設けてあり、詰まった探査が接続枠を占有し続けることはない。</value> + </data> + <data name="about.crawler.delay.lead" xml:space="preserve"> + <value>CRAWL DELAYが優先する。</value> + </data> + <data name="about.crawler.delay.body" xml:space="preserve"> + <value>MSSPレポートで希望する最小間隔を示したゲームには、そのとおりにする。当サイト自身のスケジュールより双方向に優先する：720時間なら週次ではなく月次。消息不明のゲームも、その長い間隔で永久に試し続ける。復帰したときに自力で一覧に戻るのは、そのおかげ。</value> + </data> + <data name="about.crawler.referral.lead" xml:space="preserve"> + <value>紹介されたアドレスは検証する。信用はしない。</value> + </data> + <data name="about.crawler.referral.body" xml:space="preserve"> + <value>MSSPでは、ゲームが他のゲームを名指しできる。名前はダイヤルする前にすべて解決し、解決先のアドレスがすべてグローバルに到達可能でなければ拒否する。混在した応答は、その対象全体を拒否する。この拒否は当サイトの判断として記録し、ゲームの記録に停止時間として現れることはない。</value> + </data> + <data name="about.crawler.screens.lead" xml:space="preserve"> + <value>接続画面を表示するのは、それが誰にでも送られるものだから。</value> + </data> + <data name="about.crawler.screens.body" xml:space="preserve"> + <value>サーバーは接続画面を、認証なしで、すべての匿名接続に描き出す。当サイトはそれを証拠として表示し、ラベルを付ける。求められれば取り下げる。</value> + </data> + <data name="about.crawler.stop.lead" xml:space="preserve"> + <value>止めろと言われれば止める — 方法は3つ。</value> + </data> + <data name="about.crawler.stop.body" xml:space="preserve"> + <value>MSSPレポートに{variable} 1を公開すれば、それを読んだ探査が最後になる。または{label}.your.hostに「{value}」と書いたTXTレコードを公開する。MSSPへの対応も当サイトのアカウントも要らない。あるいは人に連絡する。3つとも1回のクロールサイクル以内に反映し、日付と読み取った内容とともに記録し、登録フォームにも適用する。</value> + </data> + <data name="about.crawler.scope.lead" xml:space="preserve"> + <value>MSSPフィールドはそのリスナーを止め、レコードはホストを止める。</value> + </data> + <data name="about.crawler.scope.body" xml:space="preserve"> + <value>MSSPは応答したポートが公開するものなので、そのポートについてしか語らない — MU*のホスティングでは無関係なゲームが1つのドメインで動いているのが普通であり、一方が隣を黙らせてはならない。TXTレコードは、「{value}=4201」のようにポートを名指ししない限り、すべてのポートを対象とする。そこにポート一覧として読めないものが書かれていればホスト全体を意味するので、「{value}=all」でも通る。</value> + </data> + <data name="about.crawler.dns.lead" xml:space="preserve"> + <value>DNSによる方法は、こちらに頼まずに自分で取り消せる唯一の方法。</value> + </data> + <data name="about.crawler.dns.body" xml:space="preserve"> + <value>TXTレコードは、来るなと言ったサーバーに接続しなくても読めるので、ダイヤルのたびに読み直す。削除すれば1週間以内にまたダイヤルする。MSSPフィールドは、止めてくれと言われたその行為をしなければ読み直せない。そのためMSSPによる離脱と書面での要請は、撤回の連絡があるまで有効なまま。離脱したアドレスに対して行うのはそのTXT参照だけ：触れるのはネームサーバーであって、ゲームではない。</value> + </data> + <data name="about.crawler.stopping.lead" xml:space="preserve"> + <value>停止は削除ではないし、停止時間でもない。</value> + </data> + <data name="about.crawler.stopping.body" xml:space="preserve"> + <value>離脱したゲームも、ページ、アドレス、そして要請より前に実測したものはすべて残る。止まるのは新しいデータだけ：活動グリッドは時間が増えなくなり、原因は名指ししない。ノックをやめるという判断は当サイトについての事実だから。それは行われなかったクロールの記録として、また誰が要請したかの台帳に記録する。</value> + </data> + <data name="about.crawler.unlist.lead" xml:space="preserve"> + <value>停止だけで足りなければ、掲載も取り下げられる。</value> + </data> + <data name="about.crawler.unlist.body" xml:space="preserve"> + <value>そのゲームが応答するすべてのアドレスで探査を止めたあと、ダッシュボードにもう一つの選択肢が出る：一覧、ランキング、日次の数値から取り下げること。ページも、これまで持っていたすべてのアドレスも応答し続け、何も削除されない — 閲覧してたどり着ける場所ではなくなるだけ。これには検証済みの申請が要る。あなたのゲームについての判断であり、誰が下したかを記録するから。そして探査がそれを取り消す：離脱を撤回すれば、次に応答が返ったダイヤルで、二度頼まなくても一覧に戻る。</value> + </data> + <data name="about.identity.announced" xml:space="preserve"> + <value>サーバーから何者かと尋ねられたとき、クローラーは自らを{name}と名乗る。</value> + </data> + <data name="about.identity.unannounced" xml:space="preserve"> + <value>クローラーは自らを{name}と名乗るよう設定されているが、まだそう伝えられない。使っているtelnetライブラリには、クライアント側から端末種別を設定する手段がなく、そちらのログにはそのライブラリの既定値が見える。NEW-ENVIRONもクローラーホストの環境から応答される。どちらもライブラリ側の欠落であり、そこを直すのは当方の仕事。それまでは、探査はその形で見分けられる：1本の接続、ログインなし、読み取り専用の短いコマンド列、そして退出。</value> + </data> + <data name="about.identity.crawler" xml:space="preserve"> + <value>クローラー</value> + </data> + <data name="about.identity.contact" xml:space="preserve"> + <value>連絡先</value> + </data> + <data name="about.identity.crawler.line" xml:space="preserve"> + <value>クローラー：{name}</value> + </data> + <data name="about.identity.contact.line" xml:space="preserve"> + <value>連絡先：{url}</value> + </data> + <data name="about.identity.placeholder" xml:space="preserve"> + <value>— プレースホルダー。このデプロイでは連絡先が設定されていない</value> + </data> + <data name="about.identity.placeholder.plain" xml:space="preserve"> + <value>連絡先が設定されていないため、上のものはプレースホルダーであり、誰にもつながらない。</value> + </data> + <data name="about.sources.heading" xml:space="preserve"> + <value>ゲーム一覧の出どころ</value> + </data> + <data name="about.sources.addresses.lead" xml:space="preserve"> + <value>受け取るのはアドレス。それ以外は何も。</value> + </data> + <data name="about.sources.addresses.body" xml:space="preserve"> + <value>バックフィルが受け取るのはホストとポート。接続数も、到達可能性の履歴も、説明も、各種フィールドも、アドレスがどのサイト由来かの記録も取らない。</value> + </data> + <data name="about.sources.less.lead" xml:space="preserve"> + <value>それらのサイトが渡せるものより、意図的に少なく。</value> + </data> + <data name="about.sources.less.body" xml:space="preserve"> + <value>いくつかは何年分もの日付付き接続数を持っている。それを取り込めば、他人がすでに観測していたゲームのヒートマップが埋まり、このサイトの中心的な主張が他者の探査機に寄りかかることになる。</value> + </data> + <data name="about.sources.origin.lead" xml:space="preserve"> + <value>ゲームの出どころは一つの事実ではない。</value> + </data> + <data name="about.sources.origin.body" xml:space="preserve"> + <value>掲載する価値のあるゲームは、これらのディレクトリのいくつもに載っている。だから「インポート元」は、たまたま先に走った取得を指すだけになる。ゲームが存在することは公開情報。どこで読んだかは何も足さず、他人の仕事のうち当サイトのものだと最も言いにくい部分でもある。</value> + </data> + <data name="about.sources.etiquette.lead" xml:space="preserve"> + <value>他人のサイトを読むことは、やはり他人のサイトを読むこと。</value> + </data> + <data name="about.sources.etiquette.body" xml:space="preserve"> + <value>スクレイプの前に一括エクスポートか文書化されたエンドポイントを求め、まずrobots.txtを読み、スクレイプには厳しくレート制限をかける。管理者の了承が要る情報源は、依頼した旨を人が明言できるまで取得しない。</value> + </data> + <data name="about.source.read" xml:space="preserve"> + <value>読み取り済み — アドレスのみ</value> + </data> + <data name="about.source.withheld" xml:space="preserve"> + <value>未読 — 許諾待ち</value> + </data> + <data name="about.source.tintinMssp.note" xml:space="preserve"> + <value>1ページ、1リクエスト。各ゲームに接続して読み取った内容を出力するクローラーが公開している。</value> + </data> + <data name="about.source.tintinMsdp.note" xml:space="preserve"> + <value>同じクローラーによるMSDPの一覧。ほぼMSSP版の部分集合で、そちらでは届かない少数のアドレスのために読んでいる。</value> + </data> + <data name="about.source.mudConnector.note" xml:space="preserve"> + <value>カタログ全体を1ページで公開しているので、読むのに要するリクエストは1回。最大のアドレス供給源であり、実測値は一つも取っていない。</value> + </data> + <data name="about.source.mudStats.note" xml:space="preserve"> + <value>インデックスが1ページと、ワールドごとに1ページなので、エクスポートではなくスクレイプになる。2026年7月30日、robots.txtを守り15秒間隔で、先方の143ページを取得した。ただし誰も先方に連絡していなかった。あれは起きてはならなかった。現在の関門は、管理者に依頼したと明言する用意のある人を要求する。</value> + </data> + <data name="about.source.mudVerse.note" xml:space="preserve"> + <value>実装済み、テスト済み、実行はしていない。許諾を除くあらゆる軸でここでは最も優れた情報源だが、誰かが先方に連絡するまで何も取得しない。</value> + </data> + <data name="about.licence.heading" xml:space="preserve"> + <value>ライセンス</value> + </data> + <data name="about.licence.code.lead" xml:space="preserve"> + <value>コードはMIT。</value> + </data> + <data name="about.licence.code.body" xml:space="preserve"> + <value>サイトもクローラーもパーサーも、MITライセンスのオープンソース。</value> + </data> + <data name="about.licence.open.lead" xml:space="preserve"> + <value>データのライセンスは未解決の問題。</value> + </data> + <data name="about.licence.open.body" xml:space="preserve"> + <value>コードとは別の判断であり、まだ下していない。以下の条件は、このデプロイの現時点での答えであって、プロジェクトとして定まった立場ではない。競合するディレクトリがカタログ全体を持っていくことはここでは成功条件なので、どう決まるにせよそれを妨げることはない。</value> + </data> + <data name="about.licence.codeLabel" xml:space="preserve"> + <value>コード</value> + </data> + <data name="about.licence.dataLabel" xml:space="preserve"> + <value>データ、このデプロイが提供する形での</value> + </data> + <data name="about.licence.creditLabel" xml:space="preserve"> + <value>クレジット表記</value> + </data> + <data name="about.licence.code.line" xml:space="preserve"> + <value>コード：{licence}</value> + </data> + <data name="about.licence.data.line" xml:space="preserve"> + <value>データ：{licence}</value> + </data> + <data name="about.licence.credit.line" xml:space="preserve"> + <value>クレジット表記：{credit}</value> + </data> + <data name="about.licence.deployment" xml:space="preserve"> + <value>（このデプロイが提供する内容。プロジェクト自身の答えはまだ未定。）</value> + </data> + <data name="submit.title" xml:space="preserve"> + <value>ゲームを登録</value> + </data> + <data name="submit.lede" xml:space="preserve"> + <value>ゲームの所在を教えてほしい。フォームはホストとポートだけ。このサイトのそれ以外はすべて、当サイト自身のクローラーが実測する。</value> + </data> + <data name="submit.host.label" xml:space="preserve"> + <value>ホスト</value> + </data> + <data name="submit.port.label" xml:space="preserve"> + <value>ポート</value> + </data> + <data name="submit.host.hint" xml:space="preserve"> + <value>mud.example.org、または mud.example.org:4201 を貼り付けてポートは空のまま</value> + </data> + <data name="submit.button" xml:space="preserve"> + <value>登録</value> + </data> + <data name="submit.noCatalogue" xml:space="preserve"> + <value>登録にはデータベースが必要だが、このサイトはデモ用のダミーデータで動いている。書き込む先のクロール登録簿がないので、黙って何もしないフォームを出すのではなく、フォーム自体を置いていない。</value> + </data> + <data name="submit.notHere" xml:space="preserve"> + <value>ここにはない</value> + </data> + <data name="submit.what.heading" xml:space="preserve"> + <value>アドレスに何が起きるか</value> + </data> + <data name="submit.what.resolve" xml:space="preserve"> + <value>ダイヤルの前にアドレスを解決し、公開インターネットの外に解決するものは拒否する。それは当サイト自身のソケットについての判断であり、ゲームについての事実ではない。</value> + </data> + <data name="submit.what.optOut" xml:space="preserve"> + <value>そのホストを運用している人からクロールしないよう要請されている場合、誰が登録しようとそのアドレスは受け取らない。他人があなたのゲームをこのサイトに戻すことはできない。</value> + </data> + <data name="submit.what.schedule" xml:space="preserve"> + <value>応答があれば、サーバーが自分について語る内容を読み、そのゲーム自身のスケジュールで永久に読み続ける。アドレスを渡すのは一度でいい。</value> + </data> + <data name="submit.what.claim" xml:space="preserve"> + <value>運用者だと誰かが証明するまで、サイトには何も出ない。申請にはパスキーと、ゲーム自体に公開する1行が要る。</value> + </data> + <data name="submit.what.duplicate" xml:space="preserve"> + <value>すでに持っているアドレスは既存の項目にまとめられる。二度送っても掲載が二つになることはなく、探査が早まることもない。</value> + </data> + <data name="submit.answer.thatAddress" xml:space="preserve"> + <value>そのアドレス</value> + </data> + <data name="submit.accepted.heading" xml:space="preserve"> + <value>登録簿に入った。</value> + </data> + <data name="submit.accepted.sentence" xml:space="preserve"> + <value>{address}は次のクロールサイクルでダイヤルし、以降はそのゲーム自身のスケジュールで永久に続ける。運用者だと誰かが証明した時点でここに現れる — 同じアドレスでこのフォームに戻れば、そのリンクを渡す。</value> + </data> + <data name="submit.unclaimed.heading" xml:space="preserve"> + <value>こちらにはある、所有者未申請。</value> + </data> + <data name="submit.unclaimed.sentence" xml:space="preserve"> + <value>{address}はすでに実測しているもの。運用者だと誰かが証明するまで、サイトには出ないまま。それがあなたなら、ここが入口。</value> + </data> + <data name="submit.known.heading" xml:space="preserve"> + <value>それはすでにある。</value> + </data> + <data name="submit.known.sentence" xml:space="preserve"> + <value>{address}はすでに実測しているゲーム。何も作られず、何も変わっていない。</value> + </data> + <data name="submit.knownAddress.heading" xml:space="preserve"> + <value>そのアドレスはすでにある。</value> + </data> + <data name="submit.knownAddress.sentence" xml:space="preserve"> + <value>{address}はすでに把握している。何も作られず、何も変わっていない。</value> + </data> + <data name="submit.queued.heading" xml:space="preserve"> + <value>すでに待機中。</value> + </data> + <data name="submit.queued.sentence" xml:space="preserve"> + <value>{address}はクロール登録簿にあり、まだ応答がない。もう一度送っても順番は早まらない：対象はそれぞれ自分のスケジュールを保つので、他人のサーバーに対して当サイトを急かすことは誰にもできない。</value> + </data> + <data name="submit.malformed.heading" xml:space="preserve"> + <value>ダイヤルできるアドレスではない。</value> + </data> + <data name="submit.malformed.sentence" xml:space="preserve"> + <value>ホストにはドットかコロンが要り、ポートは1から65535までの数値。両方の欄を埋めるか、最初の欄に mud.example.org:4201 を貼り付ける。</value> + </data> + <data name="submit.undialable.heading" xml:space="preserve"> + <value>それにはダイヤルできない。</value> + </data> + <data name="submit.undialable.sentence" xml:space="preserve"> + <value>{address}にこの答えが出る理由は3つ：名前が解決しない、公開インターネットの外に解決する、あるいはそのホストを運用している人から近寄らないよう要請されている。どれなのかは意図的に言わない。見知らぬ相手にそれを答えることは、ネットワークを外側から地図にすることだから。アドレスについては何も記録していない。この判断は当サイトのものであり、当サイトのものとして記録する。</value> + </data> + <data name="submit.tooMany.heading" xml:space="preserve"> + <value>今はここまで。</value> + </data> + <data name="submit.tooMany.sentence" xml:space="preserve"> + <value>このフォームは送信者ごとにレート制限があり、その上限に達した。1時間後にまた来てほしい。失われたものはない — 受け取ったものはすでに登録簿にある。</value> + </data> + <data name="submit.link.claim" xml:space="preserve"> + <value>このゲームを申請する</value> + </data> + <data name="account.signIn.title" xml:space="preserve"> + <value>サインイン</value> + </data> + <data name="account.signIn.preview" xml:space="preserve"> + <value>自分が運用するゲームを申請するには、パスキーでサインインする。失くすパスワードも、盗まれるパスワードもない。</value> + </data> + <data name="account.signIn.noDatabase" xml:space="preserve"> + <value>申請にはデータベースが必要だが、このサイトはデモ用のダミーデータで動いている。サインインする先がない。</value> + </data> + <data name="account.signIn.passkey.lead" xml:space="preserve"> + <value>サインインはパスキーで行う。</value> + </data> + <data name="account.signIn.passkey.body" xml:space="preserve"> + <value>秘密鍵はあなたの端末かパスワードマネージャーが持ち、当サイトが持つのは公開鍵の側だけ。パスワードもメールアドレスもない。</value> + </data> + <data name="account.signIn.button" xml:space="preserve"> + <value>パスキーでサインイン</value> + </data> + <data name="account.signIn.script" xml:space="preserve"> + <value>このサイトでJavaScriptを必要とする唯一のページ。パスキーはそれなしでは動かない。</value> + </data> + <data name="account.register.heading" xml:space="preserve"> + <value>アカウントがまだない場合</value> + </data> + <data name="account.register.lede" xml:space="preserve"> + <value>アカウントが要るのは、自分が運用するゲームを申請するときだけ。名乗る名前を選ぶ — 申請の横に並ぶラベルであって、本名ではない。</value> + </data> + <data name="account.register.name.label" xml:space="preserve"> + <value>名前</value> + </data> + <data name="account.register.name.placeholder" xml:space="preserve"> + <value>例：corvid-admin</value> + </data> + <data name="account.register.button" xml:space="preserve"> + <value>パスキーでアカウントを作成</value> + </data> + <data name="account.store.heading" xml:space="preserve"> + <value>保存するもの</value> + </data> + <data name="account.store.name" xml:space="preserve"> + <value>選んだ名前。</value> + </data> + <data name="account.store.keys" xml:space="preserve"> + <value>登録した各パスキーの公開鍵と、端末が付けた名称。</value> + </data> + <data name="account.store.claims" xml:space="preserve"> + <value>申請したゲームと、その時期。</value> + </data> + <data name="account.store.note" xml:space="preserve"> + <value>アカウントに紐づくメールアドレスも、パスワードも、IPの記録もない。パスキーをすべて失っても、ゲームに新しい申請トークンを公開すればやり直せる：証明になるのはゲームであって、アカウントではない。</value> + </data> + <data name="date.absolute" xml:space="preserve"> + <value>{year}年{month}{day}日</value> + </data> + <data name="date.stamp" xml:space="preserve"> + <value>{date} {time} UTC</value> + </data> + <data name="age.short.now" xml:space="preserve"> + <value>今</value> + </data> + <data name="age.short.minutes" xml:space="preserve"> + <value>{count, plural, other {#分}}</value> + </data> + <data name="age.short.hours" xml:space="preserve"> + <value>{count, plural, other {#時間}}</value> + </data> + <data name="age.short.days" xml:space="preserve"> + <value>{count, plural, other {#日}}</value> + </data> + <data name="age.short.weeks" xml:space="preserve"> + <value>{count, plural, other {#週}}</value> + </data> + <data name="age.short.months" xml:space="preserve"> + <value>{count, plural, other {#か月}}</value> + </data> + <data name="age.short.years" xml:space="preserve"> + <value>{count, plural, other {#年}}</value> + </data> + <data name="age.ago.now" xml:space="preserve"> + <value>たった今</value> + </data> + <data name="age.ago.minutes" xml:space="preserve"> + <value>{count, plural, other {#分前}}</value> + </data> + <data name="age.ago.hours" xml:space="preserve"> + <value>{count, plural, other {#時間前}}</value> + </data> + <data name="age.ago.days" xml:space="preserve"> + <value>{count, plural, other {#日前}}</value> + </data> + <data name="age.ago.weeks" xml:space="preserve"> + <value>{count, plural, other {#週前}}</value> + </data> + <data name="age.ago.months" xml:space="preserve"> + <value>{count, plural, other {#か月前}}</value> + </data> + <data name="age.ago.years" xml:space="preserve"> + <value>{count, plural, other {#年前}}</value> + </data> + <data name="age.dark.now" xml:space="preserve"> + <value>たった今</value> + </data> + <data name="age.dark.minutes" xml:space="preserve"> + <value>{count, plural, other {#分前}}</value> + </data> + <data name="age.dark.hours" xml:space="preserve"> + <value>{count, plural, other {#時間前}}</value> + </data> + <data name="age.dark.days" xml:space="preserve"> + <value>{count, plural, other {#日前}}</value> + </data> + <data name="age.dark.weeks" xml:space="preserve"> + <value>{count, plural, other {#週前}}</value> + </data> + <data name="age.dark.months" xml:space="preserve"> + <value>{count, plural, other {#か月前}}</value> + </data> + <data name="age.dark.years" xml:space="preserve"> + <value>{count, plural, other {#年前}}</value> + </data> + <data name="time.title" xml:space="preserve"> + <value>{age}、{stamp}</value> + </data> + <data name="time.spoken" xml:space="preserve"> + <value>、{stamp}</value> + </data> + <data name="chip.title" xml:space="preserve"> + <value>{value} — {source}による{how}、最終確認{date}</value> + </data> + <data name="chip.title.stale" xml:space="preserve"> + <value>{value} — {source}による{how}、最終確認{date}（想定の更新期間を過ぎている）</value> + </data> + <data name="chip.plain" xml:space="preserve"> + <value>（{how}、{age}）</value> + </data> + <data name="chip.plain.stale" xml:space="preserve"> + <value>（{how}、{age}、更新期間超過）</value> + </data> + <data name="provenance.game.ownerDeclared" xml:space="preserve"> + <value>所有者申告</value> + </data> + <data name="source.staff" xml:space="preserve"> + <value>スタッフ</value> + </data> + <data name="source.handshake" xml:space="preserve"> + <value>telnetハンドシェイク</value> + </data> + <data name="source.owner" xml:space="preserve"> + <value>所有者</value> + </data> + <data name="source.who" xml:space="preserve"> + <value>WHO</value> + </data> + <data name="source.i3" xml:space="preserve"> + <value>I3</value> + </data> + <data name="source.mssp" xml:space="preserve"> + <value>MSSP</value> + </data> + <data name="source.info" xml:space="preserve"> + <value>INFO</value> + </data> + <data name="source.i3Mudlist" xml:space="preserve"> + <value>I3のmudlist</value> + </data> + <data name="source.banner" xml:space="preserve"> + <value>接続画面</value> + </data> + <data name="ecosystem.title" xml:space="preserve"> + <value>エコシステム</value> + </data> + <data name="ecosystem.noTotals" xml:space="preserve"> + <value>示すのはシェアであって、総数ではない。MU*を遊んでいる人数の数値は公表しない：実測したゲームに対する比率は、到達できないゲームがあっても意味を保つが、人数の総計は保たない。</value> + </data> + <data name="ecosystem.listed" xml:space="preserve"> + <value>{count, plural, other {掲載ゲーム{value}件}}</value> + </data> + <data name="ecosystem.handshakes" xml:space="preserve"> + <value>{count, plural, other {ハンドシェイクを完了したゲーム{value}件}}</value> + </data> + <data name="ecosystem.msspReports" xml:space="preserve"> + <value>{count, plural, other {MSSPレポートを保有するゲーム{value}件}}</value> + </data> + <data name="ecosystem.oldestHandshake" xml:space="preserve"> + <value>ここで最も古いハンドシェイク：{age}前に確認。</value> + </data> + <data name="ecosystem.share" xml:space="preserve"> + <value>{total, number}件中{count, number}件（{fraction, number, ::percent .0}）</value> + </data> + <data name="ecosystem.share.nothing" xml:space="preserve"> + <value>{total, number}件中{count, number}件 — 実測はまだなし</value> + </data> + <data name="ecosystem.share.percent" xml:space="preserve"> + <value>{fraction, number, ::percent .0}</value> + </data> + <data name="ecosystem.codebases.title" xml:space="preserve"> + <value>コードベース</value> + </data> + <data name="ecosystem.codebases.basis" xml:space="preserve"> + <value>掲載している{listed, plural, other {#件のゲーム}}のうち、{identified, number}件が動かしているものを伝えてきた。以下のシェアはすべてその{identified, number}件に対するもの。読み取れなかったコードベースは分母から外し、別の何かとして数えることはしない。</value> + </data> + <data name="ecosystem.codebases.none" xml:space="preserve"> + <value>コードベースを伝えてきた掲載ゲームはまだない。</value> + </data> + <data name="ecosystem.soleUse" xml:space="preserve"> + <value>{share}は、他のどの掲載ゲームも使っていないコードベースを動かしている — それぞれ1件ずつで、シェアというより名前。上の分母には含まれており、棒グラフからまとめて外してあるだけで、除外はしていない：</value> + </data> + <data name="ecosystem.lineages.title" xml:space="preserve"> + <value>系統</value> + </data> + <data name="ecosystem.lineages.basis" xml:space="preserve"> + <value>同じゲームを、サーバーが受け継いだ伝統ごとにまとめたもの — コードベースについての当サイトの読み取りであって、ゲームが公開した内容ではない。「MUSH」と報告するゲームはない：MSSPにその値はなく、MUSH界の大半はそもそもMSSPを公開していないので、この問いを立てる方法はこれしかない。</value> + </data> + <data name="ecosystem.lineages.none" xml:space="preserve"> + <value>系統に位置づけているコードベースを動かしている掲載ゲームは、まだない。</value> + </data> + <data name="ecosystem.lineages.notClassified" xml:space="preserve"> + <value>{count, plural, other {そのうち#件は、どの系統にも位置づけていないコードベースを動かしている}} — {family}を公開して、そう自ら述べているものもいくつかある。上の分母には含まれており、どのシェアにも入っていない。</value> + </data> + <data name="ecosystem.protocols.title" xml:space="preserve"> + <value>プロトコル</value> + </data> + <data name="ecosystem.protocols.floor" xml:space="preserve"> + <value>以下の実測値はいずれも下限として読むこと。MSSPは名指しで要求するので、そこでの沈黙は一つの答え。それ以外は要求していないので、サーバーが一度も提供しないまま対応していることもありうる。</value> + </data> + <data name="ecosystem.mssp.instrument" xml:space="preserve"> + <value>{instrument}は、以下で唯一、下限ではない行：すべてのサーバーに名指しで要求しているので、提供しなかったゲームは訊かれたうえで断ったことになる。自己申告の数値がない唯一の行でもある。レポートを保有しているゲームは実演によって対応を示しており、そのうえで自ら列挙したゲームを数えても、測れるのは習慣のほうだから。</value> + </data> + <data name="ecosystem.mssp.gap" xml:space="preserve"> + <value>保有しているレポートは{reports, number}件で、現在MSSPを提供しているのは{offered, plural, other {#件のゲーム}}：残る{gap, number}件は、こちらが読んだあとに公開をやめたもの。再発行されなくなったからといって、レポートを捨てることはしない。</value> + </data> + <data name="ecosystem.protocols.caption" xml:space="preserve"> + <value>プロトコルの採用状況。実測は完了したハンドシェイクでサーバーが提供したもの、自己申告はそのMSSPが主張するもの。ゲームの集合が2つなので、分母も2つ。</value> + </data> + <data name="ecosystem.column.protocol" xml:space="preserve"> + <value>プロトコル</value> + </data> + <data name="ecosystem.column.measured" xml:space="preserve"> + <value>実測 — {basis}中</value> + </data> + <data name="ecosystem.column.declared" xml:space="preserve"> + <value>自己申告 — {basis}中</value> + </data> + <data name="ecosystem.measured.never" xml:space="preserve"> + <value>未計測 — 一度も観測なし</value> + </data> + <data name="ecosystem.measured.declined" xml:space="preserve"> + <value>{share} · {declined, plural, other {#件のゲーム}}が要求に対して辞退</value> + </data> + <data name="ecosystem.measured.unasked" xml:space="preserve"> + <value>{share} · {unobserved, plural, other {#件のゲーム}}は提供も要求もなし</value> + </data> + <data name="ecosystem.measured.declinedAndUnasked" xml:space="preserve"> + <value>{share} · {declined, plural, other {#件のゲーム}}が要求に対して辞退 · {unobserved, plural, other {#件のゲーム}}は提供も要求もなし</value> + </data> + <data name="ecosystem.declared.none" xml:space="preserve"> + <value>要求せず — ここにあるレポートのすべてが答え</value> + </data> + <data name="ecosystem.curve.title" xml:space="preserve"> + <value>採用状況の推移</value> + </data> + <data name="ecosystem.curve.caveat" xml:space="preserve"> + <value>各点は、その日までに実測していたゲームに対するシェアなので、この線が動く理由は2つある：ゲームが提供内容を変えること、そして実測できるゲームの集合が周りで変わること。採用と言えるのは前者だけ。以下の変化件数は、純粋にゲームが考えを変えた分。</value> + </data> + <data name="ecosystem.curve.caption" xml:space="preserve"> + <value>プロトコルごとの実測シェア、古い読み取りから順に</value> + </data> + <data name="ecosystem.curve.then" xml:space="preserve"> + <value>当時</value> + </data> + <data name="ecosystem.curve.now" xml:space="preserve"> + <value>現在</value> + </data> + <data name="ecosystem.curve.notMeasured" xml:space="preserve"> + <value>未計測</value> + </data> + <data name="ecosystem.snapshot.title" xml:space="preserve"> + <value>曲線ではなくスナップショット</value> + </data> + <data name="ecosystem.snapshot" xml:space="preserve"> + <value>現在実測できるもののスナップショット。採用曲線が描くのはゲームが考えを変えた点であり、当サイトは変化が起きたときにそれを記録しているので、十分な数がたまれば曲線を描けるようになる。各ゲームに最初に到達した時点を描いても、測れるのはクロールであってホビーではない。</value> + </data> + <data name="ecosystem.transitions" xml:space="preserve"> + <value>{count, plural, other {これまでに記録した機能の変化は#件}} — 曲線を描くための材料。</value> + </data> + <data name="ecosystem.transitions.none" xml:space="preserve"> + <value>実測した機能はまだ一つも変化していないので、描くものがない。</value> + </data> + <data name="ecosystem.plain.denominators" xml:space="preserve"> + <value>実測は{measured}に対するもの、自己申告は{declared}に対するもの。ゲームの集合が2つなので、分母も2つ。</value> + </data> + <data name="ecosystem.plain.counts" xml:space="preserve"> + <value>{listed} · {handshakes} · {mssp}。</value> + </data> + <data name="ecosystem.plain.oldestHandshake" xml:space="preserve"> + <value>この図で最も古いハンドシェイクの最終確認は{age}前。</value> + </data> + <data name="ecosystem.plain.lineages" xml:space="preserve"> + <value>同じゲームを、サーバーが受け継いだ伝統ごとにまとめたもの。これは{evidence} — {meaning} — であって、ゲームが公開した内容ではない：「MUSH」と報告するゲームはない。MSSPにその値はなく、MUSH界の大半はそもそもMSSPを公開していないから。</value> + </data> + <data name="ecosystem.plain.measured" xml:space="preserve"> + <value>実測：{value}</value> + </data> + <data name="ecosystem.plain.declared" xml:space="preserve"> + <value>自己申告：{value}</value> + </data> + <data name="rankings.title" xml:space="preserve"> + <value>ランキング</value> + </data> + <data name="rankings.noVote" xml:space="preserve"> + <value>実測データのみから算出。投票も、星も、評価も一切ない。ここでは品質の順位づけはしない。それは実測していない。</value> + </data> + <data name="rankings.busiest.title" xml:space="preserve"> + <value>最も賑わうゲーム、実測の同時接続数順</value> + </data> + <data name="rankings.window.label" xml:space="preserve"> + <value>ランキングの期間</value> + </data> + <data name="rankings.span" xml:space="preserve"> + <value>{days, plural, other {#日}}</value> + </data> + <data name="rankings.basis.median" xml:space="preserve"> + <value>直近{days, plural, other {#日}}に実測した接続数の中央値。</value> + </data> + <data name="rankings.basis.none" xml:space="preserve"> + <value>中央値に必要な、{days, plural, other {#日}}にわたる{samples, number}件のサンプルを満たすゲームは、まだない。</value> + </data> + <data name="rankings.basis.eligible" xml:space="preserve"> + <value>掲載{listed, number}件のうち{eligible, plural, other {#件のゲーム}}が、必要な、{days, plural, other {#日}}にわたる{samples, number}件のサンプルを満たしている。</value> + </data> + <data name="rankings.basis.zero" xml:space="preserve"> + <value>実測のゼロは数に入る。読み取れなかった計数は入らない。</value> + </data> + <data name="rankings.spanChoice" xml:space="preserve"> + <value>1週間は今誰が賑わっているかを、四半期はこれまで誰が賑わってきたかを示す。別々の問いであり、一方で首位のゲームが他方でもそうとは限らない。日は暦日、UTC。</value> + </data> + <data name="rankings.busiest.empty" xml:space="preserve"> + <value>順位づけに足るだけの計数サンプルがある掲載ゲームは、まだない — これは実測を続けてきた期間についての言明であって、誰かの賑わいについてのものではない。</value> + </data> + <data name="rankings.busiest.caption" xml:space="preserve"> + <value>直近{days, plural, other {#日}}に実測した接続数の中央値でゲームを順位づけたもの。中央値が同じゲームは同順位で、ここでは同点を崩さない。</value> + </data> + <data name="rankings.column.place" xml:space="preserve"> + <value>#</value> + </data> + <data name="rankings.column.game" xml:space="preserve"> + <value>ゲーム</value> + </data> + <data name="rankings.column.median" xml:space="preserve"> + <value>中央値</value> + </data> + <data name="rankings.column.peak" xml:space="preserve"> + <value>ピーク</value> + </data> + <data name="rankings.column.samples" xml:space="preserve"> + <value>計数サンプル</value> + </data> + <data name="rankings.column.days" xml:space="preserve"> + <value>実測日数</value> + </data> + <data name="rankings.spells.title" xml:space="preserve"> + <value>到達可能が途切れなかった最長期間</value> + </data> + <data name="rankings.spells.basis" xml:space="preserve"> + <value>示した日付以降、すべての探査でそのゲームは到達可能だった。稼働ではなく到達可能：1台のホストからソケットを実測しているだけで、経路が通らないゲームも健在。この期間が観測してきた期間より長くなることはないので、事実は日付のほうであり、長さはそこから導かれる。</value> + </data> + <data name="rankings.spells.empty" xml:space="preserve"> + <value>現在、到達可能が途切れずに続いている掲載ゲームはない。</value> + </data> + <data name="rankings.spells.caption" xml:space="preserve"> + <value>示した日付以降のすべての探査で到達可能だったゲーム。到達可能の起点が同じゲームは同順位で、ここでは同点を崩さない。</value> + </data> + <data name="rankings.column.since" xml:space="preserve"> + <value>到達可能の起点</value> + </data> + <data name="rankings.column.duration" xml:space="preserve"> + <value>その長さ</value> + </data> + <data name="rankings.archivedNote" xml:space="preserve"> + <value>アーカイブ済みのゲームは両方の表から外れるだけで、それ以外は何も変わらない。1回の探査が成功すれば戻る。</value> + </data> + <data name="rankings.plain.busiest" xml:space="preserve"> + <value>最も賑わうゲーム — 実測接続数の中央値、直近{days, plural, other {#日}}</value> + </data> + <data name="rankings.plain.windows" xml:space="preserve"> + <value>期間：</value> + </data> + <data name="rankings.plain.thisOne" xml:space="preserve"> + <value>これ</value> + </data> + <data name="rankings.plain.row" xml:space="preserve"> + <value>中央値{median, number} · ピーク{peak, number} · {window, number}日のうち{days, number}日で{samples, plural, other {計数サンプル#件}}</value> + </data> + <data name="rankings.plain.spellRow" xml:space="preserve"> + <value>{date}以降のすべての探査で到達可能 · {duration}</value> + </data> + <data name="archive.title" xml:space="preserve"> + <value>アーカイブ</value> + </data> + <data name="archive.lede" xml:space="preserve"> + <value>応答しなくなったゲーム。削除はしていない。毎週の探査は続いており、1回の探査が成功すれば、その日のうちに一覧へ戻る。</value> + </data> + <data name="archive.search.legend" xml:space="preserve"> + <value>アーカイブを検索</value> + </data> + <data name="archive.search.label" xml:space="preserve"> + <value>アーカイブ済みのゲームを検索</value> + </data> + <data name="archive.search.placeholder" xml:space="preserve"> + <value>名前・コードベース・説明</value> + </data> + <data name="archive.search.submit" xml:space="preserve"> + <value>表示</value> + </data> + <data name="archive.count" xml:space="preserve"> + <value>{count, plural, =0 {アーカイブ済みのゲームなし} other {アーカイブ済みのゲーム#件}}</value> + </data> + <data name="archive.badge" xml:space="preserve"> + <value>アーカイブ済み</value> + </data> + <data name="archive.lastReachable" xml:space="preserve"> + <value>最終到達</value> + </data> + <data name="archive.knownLive" xml:space="preserve"> + <value>稼働確認期間</value> + </data> + <data name="archive.darkFor" xml:space="preserve"> + <value>（{age}前）</value> + </data> + <data name="archive.empty" xml:space="preserve"> + <value>該当なし。</value> + </data> + <data name="archive.neverReachable" xml:space="preserve"> + <value>実測した範囲では一度もなし</value> + </data> + <data name="archive.noReachableTime" xml:space="preserve"> + <value>到達可能時間の実測なし</value> + </data> + <data name="archive.darkFor.unknown" xml:space="preserve"> + <value>不明</value> + </data> + <data name="archive.knownLive.years" xml:space="preserve"> + <value>{years, number, ::.#}年</value> + </data> + <data name="archive.knownLive.days" xml:space="preserve"> + <value>{days, plural, other {#日}}</value> + </data> + <data name="archive.run" xml:space="preserve"> + <value>{from} – {to} · {span}</value> + </data> + <data name="archive.run.months" xml:space="preserve"> + <value>{count, plural, other {#か月}}</value> + </data> + <data name="archive.run.years" xml:space="preserve"> + <value>{count, plural, other {#年}}</value> + </data> + <data name="archive.plain.matching" xml:space="preserve"> + <value>「{query}」に一致する{count, plural, other {#件のゲーム}}</value> + </data> + <data name="archive.plain.count" xml:space="preserve"> + <value>{count, plural, other {#件のゲーム}}</value> + </data> + <data name="archive.plain.lastReachable" xml:space="preserve"> + <value>最終到達：</value> + </data> + <data name="archive.plain.knownLive" xml:space="preserve"> + <value>稼働確認期間：</value> + </data> + <data name="archive.plain.knownLiveValue" xml:space="preserve"> + <value>実測した到達可能時間のうち{value}</value> + </data> + <data name="archive.plain.run" xml:space="preserve"> + <value>稼働期間：</value> + </data> + <data name="archive.plain.codebase" xml:space="preserve"> + <value>コードベース：</value> + </data> + <data name="footer.randomGame" xml:space="preserve"> + <value>ランダムなゲーム</value> + </data> + <data name="trend.day.counted" xml:space="preserve"> + <value>{d, date, medium} — 平均{typical}、{probes, plural, other {#回の探査}}で{low}〜{high}</value> + </data> + <data name="trend.day.flat" xml:space="preserve"> + <value>{d, date, medium} — {count, plural, =0 {接続数0} other {#人}}、{probes, plural, other {#回の探査}}のいずれでも同じ</value> + </data> + <data name="trend.day.notCounted" xml:space="preserve"> + <value>{d, date, medium} — 探査したが接続数は読み取れず</value> + </data> + <data name="trend.day.notMeasured" xml:space="preserve"> + <value>{d, date, medium} — 実測なし</value> + </data> + <data name="trend.summary" xml:space="preserve"> + <value>{days, plural, other {#日}}のうち{counted}日で、通常{typical}、ピークは{peak}。</value> + </data> + <data name="trend.direction.steady" xml:space="preserve"> + <value>この範囲を通じて横ばい。</value> + </data> + <data name="trend.direction.up" xml:space="preserve"> + <value>範囲の始めから終わりまでで約{change, number, percent}の増加。</value> + </data> + <data name="trend.direction.down" xml:space="preserve"> + <value>範囲の始めから終わりまでで約{change, number, percent}の減少。</value> + </data> + <data name="trend.none.probed" xml:space="preserve"> + <value>この範囲では探査したが、そのどこからも接続数は読み取れず。</value> + </data> + <data name="trend.none.notMeasured" xml:space="preserve"> + <value>この範囲に実測なし。</value> + </data> + <data name="trend.empty" xml:space="preserve"> + <value>この範囲に計数なし。</value> + </data> + <data name="trend.week.span" xml:space="preserve"> + <value>{from, date, d MMM}〜{to, date, d MMM}</value> + </data> + <data name="trend.week.oneDay" xml:space="preserve"> + <value>{d, date, d MMM}</value> + </data> + <data name="trend.week.counted" xml:space="preserve"> + <value>{span}：通常{typical}、ピーク{peak}、{days, plural, other {#日}}を計数</value> + </data> + <data name="trend.week.notCounted" xml:space="preserve"> + <value>{span}：探査したが接続数は読み取れず</value> + </data> + <data name="trend.week.notMeasured" xml:space="preserve"> + <value>{span}：未計測</value> + </data> + <data name="trend.week.uncounted" xml:space="preserve"> + <value>{count, plural, other {#日は探査したが計数なし}}</value> + </data> + <data name="trend.week.unmeasured" xml:space="preserve"> + <value>{count, plural, other {#日は未計測}}</value> + </data> + <data name="trend.week.and" xml:space="preserve"> + <value>{line}、{clause}</value> + </data> + <data name="trend.range" xml:space="preserve"> + <value>日付はUTC · {from, date, medium} – {to, date, medium}</value> + </data> + <data name="trend.ceiling" xml:space="preserve"> + <value>上端は{value}</value> + </data> + <data name="trend.counted" xml:space="preserve"> + <value>{days, plural, other {#日}}のうち{counted}日を計数</value> + </data> + <data name="trend.axis.month" xml:space="preserve"> + <value>{d, date, MMM}</value> + </data> + <data name="trend.axis.monthYear" xml:space="preserve"> + <value>{d, date, MMM yyyy}</value> + </data> + <data name="trend.legend.mean" xml:space="preserve"> + <value>その日に読み取った計数の平均</value> + </data> + <data name="trend.legend.peak" xml:space="preserve"> + <value>その日の最多の計数まで</value> + </data> + <data name="trend.legend.band" xml:space="preserve"> + <value>その日の最少から最多までの計数</value> + </data> + <data name="trend.legend.notCounted" xml:space="preserve"> + <value>探査したが接続数は読み取れず</value> + </data> + <data name="trend.legend.notMeasured.bar" xml:space="preserve"> + <value>未計測 — 棒そのものなし</value> + </data> + <data name="trend.legend.notMeasured.line" xml:space="preserve"> + <value>未計測 — 線が途切れる</value> + </data> + <data name="trend.spans.label" xml:space="preserve"> + <value>推移の範囲</value> + </data> + <data name="trend.shapes.label" xml:space="preserve"> + <value>推移の形</value> + </data> + <data name="trend.preset" xml:space="preserve"> + <value>{days, plural, other {#日}}</value> + </data> + <data name="trend.earlier" xml:space="preserve"> + <value>← 前の期間</value> + </data> + <data name="trend.later" xml:space="preserve"> + <value>後の期間 →</value> + </data> + <data name="trend.shape.line" xml:space="preserve"> + <value>折れ線</value> + </data> + <data name="trend.shape.bar" xml:space="preserve"> + <value>棒</value> + </data> + <data name="trend.plain.heading" xml:space="preserve"> + <value>接続数の推移</value> + </data> + <data name="trend.plain.range" xml:space="preserve"> + <value>{from, date, medium} – {to, date, medium}、UTC</value> + </data> + <data name="trend.plain.earlier" xml:space="preserve"> + <value>前の期間</value> + </data> + <data name="trend.plain.note" xml:space="preserve"> + <value>週は、その週のうち計数できた日をまとめたもの。1日もない週はそう記す</value> + </data> + <data name="reach.kicker" xml:space="preserve"> + <value>到達可能 · 直近{days, plural, other {#日}}</value> + </data> + <data name="reach.stat.reachable" xml:space="preserve"> + <value>到達可能</value> + </data> + <data name="reach.stat.longestOutage" xml:space="preserve"> + <value>最長の途絶</value> + </data> + <data name="reach.stat.lastCause" xml:space="preserve"> + <value>直近の原因</value> + </data> + <data name="reach.noOutage" xml:space="preserve"> + <value>期間内になし</value> + </data> + <data name="reach.noCause" xml:space="preserve"> + <value>記録なし</value> + </data> + <data name="reach.scale.ago" xml:space="preserve"> + <value>{days, plural, other {#日前}}</value> + </data> + <data name="reach.scale.today" xml:space="preserve"> + <value>今日</value> + </data> + <data name="reach.legend.reachable" xml:space="preserve"> + <value>到達可能</value> + </data> + <data name="reach.legend.degraded" xml:space="preserve"> + <value>劣化 — 応答はあったが完了せず</value> + </data> + <data name="reach.legend.unreachable" xml:space="preserve"> + <value>到達不可</value> + </data> + <data name="reach.legend.notMeasured" xml:space="preserve"> + <value>未計測</value> + </data> + <data name="reach.word.reachable" xml:space="preserve"> + <value>到達可能</value> + </data> + <data name="reach.word.degraded" xml:space="preserve"> + <value>劣化</value> + </data> + <data name="reach.word.unreachable" xml:space="preserve"> + <value>到達不可</value> + </data> + <data name="reach.word.notMeasured" xml:space="preserve"> + <value>未計測</value> + </data> + <data name="reach.day.reachable" xml:space="preserve"> + <value>{d, date, d MMM} — 終日到達可能</value> + </data> + <data name="reach.day.degraded" xml:space="preserve"> + <value>{d, date, d MMM} — 劣化（{cause}）：応答はあったが完了せず</value> + </data> + <data name="reach.day.unreachable" xml:space="preserve"> + <value>{d, date, d MMM} — 到達不可（{cause}）</value> + </data> + <data name="reach.day.notMeasured" xml:space="preserve"> + <value>{d, date, d MMM} — 未計測。このゲームはまだ観測していなかった</value> + </data> + <data name="reach.none" xml:space="preserve"> + <value>{days, plural, other {直近#日はまだ未計測。}}</value> + </data> + <data name="reach.fraction.window" xml:space="preserve"> + <value>直近{days, plural, other {#日}}のうち{percent}が到達可能。</value> + </data> + <data name="reach.fraction.measured" xml:space="preserve"> + <value>実測した{days, plural, other {#日}}のうち{percent}が到達可能。</value> + </data> + <data name="reach.fraction.unknown" xml:space="preserve"> + <value>{days, plural, other {直近#日の到達可能性は、まだ未計測。}}</value> + </data> + <data name="reach.unreachable.noneInWindow" xml:space="preserve"> + <value>期間内に到達不可の日はなし。</value> + </data> + <data name="reach.unreachable.noneMeasured" xml:space="preserve"> + <value>実測した日に到達不可はなし。</value> + </data> + <data name="reach.unreachable.days" xml:space="preserve"> + <value>{count, plural, other {#日が到達不可。}}</value> + </data> + <data name="reach.degraded.days" xml:space="preserve"> + <value>{count, plural, other {#日が劣化 — 接続はできたが完了できず。}}</value> + </data> + <data name="reach.longestOutage" xml:space="preserve"> + <value>最長の途絶は{duration}。</value> + </data> + <data name="reach.longestOutage.cause" xml:space="preserve"> + <value>最長の途絶は{duration}（{cause}）。</value> + </data> + <data name="reach.predate" xml:space="preserve"> + <value>{count, plural, other {#日は、実測が始まる前。}}</value> + </data> + <data name="reach.spell.range" xml:space="preserve"> + <value>{from, date, d MMM} – {to, date, d MMM}</value> + </data> + <data name="reach.spell.oneDay" xml:space="preserve"> + <value>{d, date, d MMM}</value> + </data> + <data name="reach.spell" xml:space="preserve"> + <value>{range}：{count, plural, other {#日}}{word}</value> + </data> + <data name="reach.spell.cause" xml:space="preserve"> + <value>{range}：{count, plural, other {#日}}{word}（{cause}）</value> + </data> + <data name="reach.plain.heading" xml:space="preserve"> + <value>到達可能</value> + </data> + <data name="reach.plain.window" xml:space="preserve"> + <value>{days, plural, other {直近#日}}</value> + </data> + <data name="reach.plain.fraction" xml:space="preserve"> + <value>到達可能：{days, plural, other {直近#日}}のうち{percent}</value> + </data> + <data name="reach.plain.longestOutage" xml:space="preserve"> + <value>最長の途絶：{duration}</value> + </data> + <data name="cause.dns" xml:space="preserve"> + <value>dnsが解決しなかった</value> + </data> + <data name="cause.refused" xml:space="preserve"> + <value>接続を拒否された</value> + </data> + <data name="cause.tls" xml:space="preserve"> + <value>tlsが失敗した</value> + </data> + <data name="cause.timeout" xml:space="preserve"> + <value>タイムアウトした</value> + </data> + <data name="cause.handshakeStalled" xml:space="preserve"> + <value>ハンドシェイクが止まった</value> + </data> + <data name="cause.none" xml:space="preserve"> + <value>原因の記録なし</value> + </data> + <data name="ansi.suppressed" xml:space="preserve"> + <value>このゲームの接続画面を再公開しないよう、所有者から要請があった。</value> + </data> + <data name="ansi.absent" xml:space="preserve"> + <value>このゲームから接続画面は取得できていない。</value> + </data> + <data name="ansi.tooSmall" xml:space="preserve"> + <value>{count, plural, other {返ってきたのは#行だけ — 表示するには少なすぎる。}}</value> + </data> + <data name="ansi.asSent" xml:space="preserve"> + <value>サーバーが送ったまま</value> + </data> + <data name="ansi.size" xml:space="preserve"> + <value>{columns}×{rows}</value> + </data> + <data name="ansi.size.doubleWidth" xml:space="preserve"> + <value>{columns}×{rows}、倍幅</value> + </data> + <data name="ansi.depth.colour" xml:space="preserve"> + <value>16色SGR</value> + </data> + <data name="ansi.depth.plain" xml:space="preserve"> + <value>色なし</value> + </data> + <data name="ansi.readAs" xml:space="preserve"> + <value>{charset}として読み取り</value> + </data> + <data name="ansi.captured" xml:space="preserve"> + <value>取得</value> + </data> + <data name="ansi.frozen" xml:space="preserve"> + <value>凍結 — 最後に見た画面</value> + </data> + <data name="ansi.alt.named" xml:space="preserve"> + <value>ASCIIアート：{game}の接続画面。その文字は下の「テキストで読む」にある。</value> + </data> + <data name="ansi.alt" xml:space="preserve"> + <value>ASCIIアート：このゲームの接続画面。その文字は下の「テキストで読む」にある。</value> + </data> + <data name="ansi.plain.rows" xml:space="preserve"> + <value>{count, plural, other {接続画面：#行、テキストのみ}}</value> + </data> + <data name="ansi.plain.rows.readAs" xml:space="preserve"> + <value>{count, plural, other {接続画面：#行、テキストのみ、{charset}として読み取り}}</value> + </data> + <data name="capability.disagree.declaredNotOffered" xml:space="preserve"> + <value>ゲームは申告しているが、サーバーはハンドシェイクで一度も提供していない。</value> + </data> + <data name="capability.disagree.offeredNotDeclared" xml:space="preserve"> + <value>サーバーは提供しているが、ゲーム自身の記載では非対応となっている。</value> + </data> + <data name="capability.disagree.note" xml:space="preserve"> + <value>たいていは手書きのフィールドが古いだけで、嘘ではない。両者が食い違う点にクライアントが依存すべきではないので表示している。</value> + </data> + <data name="game.notFound" xml:space="preserve"> + <value>見つからない</value> + </data> + <data name="game.notFound.hint" xml:space="preserve"> + <value>このアドレスにゲームはない。綴りを確認。</value> + </data> + <data name="game.endpoint.lastAnswered" xml:space="preserve"> + <value>最終応答</value> + </data> + <data name="game.stale" xml:space="preserve"> + <value>{count, plural, other {#件が更新期間を過ぎている。古いだけで、誤りではない。}}</value> + </data> + <data name="game.referrals.lists" xml:space="preserve"> + <value>このゲーム自身のリファラル一覧が挙げているもの：</value> + </data> + <data name="game.referrals.listedBy" xml:space="preserve"> + <value>このゲームを挙げているリファラル一覧：</value> + </data> + <data name="game.referral.since" xml:space="preserve"> + <value>{date}から</value> + </data> + <data name="game.referral.dropped" xml:space="preserve"> + <value>掲載終了、最終確認</value> + </data> + <data name="game.archived.lastAnswered" xml:space="preserve"> + <value>最終応答は{date}、{ago}前。</value> + </data> + <data name="game.archived.stillProbed" xml:space="preserve"> + <value>毎週の探査は継続中。応答があれば、その日のうちにこのページが更新される。</value> + </data> + <data name="game.archived.knownLive" xml:space="preserve"> + <value>稼働確認期間{span}</value> + </data> + <data name="game.excluded" xml:space="preserve"> + <value>一覧、ランキング、日次の数値には含まれない：このアドレスが誰かの遊べるゲームだとは考えていない。以下はすべて、このアドレスが伝えてきた内容そのまま。</value> + </data> + <data name="game.excluded.reason" xml:space="preserve"> + <value>当サイトの理由：{why}</value> + </data> + <data name="game.unlisted" xml:space="preserve"> + <value>運用している人たちの要請により、一覧、ランキング、日次の数値には含まれない。以下はすべてそのまま保存されており、このページとこれまで持っていたすべてのアドレスは応答し続け、当サイトはダイヤルしていない。</value> + </data> + <data name="game.plain.playersNow" xml:space="preserve"> + <value>現在の接続数：{count}</value> + </data> + <data name="game.plain.capabilities" xml:space="preserve"> + <value>機能（{total}件のうち{disagreeing}件が不一致）</value> + </data> + <data name="game.plain.declared" xml:space="preserve"> + <value>ゲームの自己申告</value> + </data> + <data name="game.plain.connectScreen" xml:space="preserve"> + <value>接続画面</value> + </data> + <data name="game.plain.whatChanged" xml:space="preserve"> + <value>変更点</value> + </data> + <data name="game.plain.measured" xml:space="preserve"> + <value>実測</value> + </data> + <data name="game.plain.declared.column" xml:space="preserve"> + <value>自己申告</value> + </data> + <data name="game.plain.disagree" xml:space="preserve"> + <value>** 不一致</value> + </data> + <data name="listing.row.connected" xml:space="preserve"> + <value>接続数</value> + </data> + <data name="listing.row.reached" xml:space="preserve"> + <value>到達</value> + </data> + <data name="facet.group.search" xml:space="preserve"> + <value>検索</value> + </data> + <data name="facet.group.archived" xml:space="preserve"> + <value>アーカイブ済み</value> + </data> + <data name="facet.group.adult" xml:space="preserve"> + <value>アダルト</value> + </data> + <data name="facet.value.included" xml:space="preserve"> + <value>含む</value> + </data> + <data name="game.count.none" xml:space="preserve"> + <value>計数なし</value> + </data> + <data name="game.count.none.why" xml:space="preserve"> + <value>現在の計数なし、理由もここには記されていない</value> + </data> + <data name="game.plain.playersNoCount" xml:space="preserve"> + <value>現在の接続数：計数なし（理由もここには記されていない）</value> + </data> + <data name="crawler.live" xml:space="preserve"> + <value>クローラー実行中 · 最終探査{age}</value> + </data> + <data name="crawler.quiet" xml:space="preserve"> + <value>クローラー待機中 · 最終探査{age}</value> + </data> + <data name="crawler.noProbe" xml:space="preserve"> + <value>ここではまだ探査が一度も完了していない</value> + </data> + <data name="crawler.cycle.nothingDue" xml:space="preserve"> + <value>このサイクルに探査予定なし</value> + </data> + <data name="crawler.cycle" xml:space="preserve"> + <value>{considered, plural, other {#件が探査予定}} · {answered, plural, other {#件が応答}} · {failed, plural, other {#件が失敗}}</value> + </data> + <data name="crawler.registry" xml:space="preserve"> + <value>登録簿に{targets, plural, other {#件のアドレス}}、{due, plural, other {うち#件が現在探査予定}}</value> + </data> + <data name="preview.documentTitle" xml:space="preserve"> + <value>{page} — {site}</value> + </data> + <data name="preview.site" xml:space="preserve"> + <value>MU*ホビーのディレクトリ — MUSH、MUD、MUCK、MOO — どの事実にも、その出所といつのものかが記されている。</value> + </data> + <data name="preview.demo" xml:space="preserve"> + <value>デモデータ — ここにある値は実測ではない。{description}</value> + </data> + <data name="preview.cardAlt" xml:space="preserve"> + <value>{site} — 実測であって、申告ではない</value> + </data> + <data name="preview.cardAlt.named" xml:space="preserve"> + <value>{site}の{title}</value> + </data> + <data name="preview.title.games" xml:space="preserve"> + <value>ゲーム</value> + </data> + <data name="preview.title.archive" xml:space="preserve"> + <value>アーカイブ</value> + </data> + <data name="preview.title.rankings" xml:space="preserve"> + <value>ランキング</value> + </data> + <data name="preview.title.ecosystem" xml:space="preserve"> + <value>エコシステム</value> + </data> + <data name="preview.title.reference" xml:space="preserve"> + <value>リファレンス</value> + </data> + <data name="preview.title.about" xml:space="preserve"> + <value>概要</value> + </data> + <data name="preview.title.notFound" xml:space="preserve"> + <value>見つからない</value> + </data> + <data name="preview.title.random" xml:space="preserve"> + <value>ランダムなゲーム</value> + </data> + <data name="preview.title.account" xml:space="preserve"> + <value>自分のゲーム</value> + </data> + <data name="preview.title.claim" xml:space="preserve"> + <value>{game}を申請</value> + </data> + <data name="preview.desc.games" xml:space="preserve"> + <value>到達したすべてのMU*を、実測した内容で絞り込む：コードベース、サーバーがハンドシェイクで提供したプロトコル、TLS、エンコーディング、言語、そして最後に到達した時期。</value> + </data> + <data name="preview.desc.archive" xml:space="preserve"> + <value>消息不明になったゲームを、そのまま保持している。ページも履歴もURLも残り、毎週の探査は続き、1回接続できれば一覧に戻る。</value> + </data> + <data name="preview.desc.rankings" xml:space="preserve"> + <value>最も賑わう、最も到達可能、最も長く続く — 実測データのみから算出。投票も、星も、評価も、このサイトのどこにもない。</value> + </data> + <data name="preview.desc.ecosystem" xml:space="preserve"> + <value>実測しているゲーム全体でのコードベースのシェアとプロトコルの採用状況。サーバーが提供するものを、自己申告の内容と並べて示す。示すのはシェアであって、総数ではない。</value> + </data> + <data name="preview.desc.reference" xml:space="preserve"> + <value>MU*ホビーのコードベース、クライアント、プロトコルについて、人の手で書いたページ。クロールから得た件数と相互にリンクしている。</value> + </data> + <data name="preview.desc.about" xml:space="preserve"> + <value>このカタログの作り方：クローラーが何をするか、何を拒むか、そしてどう止めるか。</value> + </data> + <data name="preview.desc.notFound" xml:space="preserve"> + <value>このアドレスにゲームはない。ここでは何も削除しないので、かつてこのURLにあったゲームは今もある — 綴りを確認。</value> + </data> + <data name="preview.desc.random" xml:space="preserve"> + <value>カタログから1件、ランダムに選んだゲーム。同じものが二度出ることはない。</value> + </data> + <data name="preview.desc.account" xml:space="preserve"> + <value>申請した掲載と、申請によって何を変えられるか。</value> + </data> + <data name="preview.desc.claim" xml:space="preserve"> + <value>運用者にしか置けない場所にトークンを公開して、このゲームを運用していることを証明する。</value> + </data> + <data name="preview.game.archived" xml:space="preserve"> + <value>アーカイブ済み — 最終到達{age}、探査は継続中</value> + </data> + <data name="preview.game.archived.undated" xml:space="preserve"> + <value>アーカイブ済み、探査は継続中</value> + </data> + <data name="preview.game.countUnknown" xml:space="preserve"> + <value>接続数不明 — ゲームは応答するが、読み取れる数値は公開していない</value> + </data> + <data name="preview.game.count" xml:space="preserve"> + <value>{count, plural, other {#人}}、{how}、{age}</value> + </data> + <data name="feed.plain.newlyDiscovered" xml:space="preserve"> + <value>新規発見</value> + </data> + <data name="feed.plain.wentDark" xml:space="preserve"> + <value>消息不明</value> + </data> + <data name="feed.plain.cameBack" xml:space="preserve"> + <value>復帰</value> + </data> + <data name="home.plain.known" xml:space="preserve"> + <value>{count, plural, other {既知のゲーム#件}}</value> + </data> + <data name="home.plain.connectedNow" xml:space="preserve"> + <value>{count, plural, other {現在接続中#人（実測）}}</value> + </data> + <data name="home.plain.uncounted" xml:space="preserve"> + <value>{count, plural, other {応答あり・読み取り不可#件}}</value> + </data> + <data name="home.plain.archived" xml:space="preserve"> + <value>{count, plural, other {アーカイブ済み#件、探査は継続中}}</value> + </data> + <data name="reference.title" xml:space="preserve"> + <value>リファレンス</value> + </data> + <data name="reference.lede" xml:space="preserve"> + <value>コードベースとは何か、クライアントは何をするか、プロトコルは何を意味するか。人の手で書き、クローラーと同じリポジトリに置いている — ウィキではなく、このページに編集できるものはない。ここにある{number}はどれも別物：カタログから取り、ページを読み込むたびに再計算している。</value> + </data> + <data name="reference.lede.number" xml:space="preserve"> + <value>数値</value> + </data> + <data name="reference.plain.lede" xml:space="preserve"> + <value>人の手で書き、著者は一人、gitでバージョン管理している。ここにある文章は当サイトのもの。その横にある数値はすべてクローラーが実測し、リクエストのたびに再計算している。ウィキではなく、このページから編集する方法もない。</value> + </data> + <data name="reference.section.orientation" xml:space="preserve"> + <value>はじめに</value> + </data> + <data name="reference.section.codebase" xml:space="preserve"> + <value>コードベース</value> + </data> + <data name="reference.section.client" xml:space="preserve"> + <value>クライアント</value> + </data> + <data name="reference.section.protocol" xml:space="preserve"> + <value>プロトコル</value> + </data> + <data name="reference.kind.orientation" xml:space="preserve"> + <value>入門</value> + </data> + <data name="reference.kind.codebase" xml:space="preserve"> + <value>コードベース</value> + </data> + <data name="reference.kind.client" xml:space="preserve"> + <value>クライアント</value> + </data> + <data name="reference.kind.protocol" xml:space="preserve"> + <value>プロトコル</value> + </data> + <data name="reference.notFound.title" xml:space="preserve"> + <value>見つからない</value> + </data> + <data name="reference.notFound.body" xml:space="preserve"> + <value>ここにリファレンスのページはない。この節は人の手で書いているので、空白は誰も手をつけていない仕事であって、削除されたものではない — {index}。</value> + </data> + <data name="reference.notFound.index" xml:space="preserve"> + <value>何があるかを見る</value> + </data> + <data name="reference.codebase.heading" xml:space="preserve"> + <value>これを動かしているゲーム</value> + </data> + <data name="reference.codebase.none" xml:space="preserve"> + <value>まだ一つも特定していない。これはこのクローラーが実測した内容についての事実であって、存在するものについてのものではない — 到達していないゲームや、コードベースを読み取れなかったゲームは、ここには数えていない。</value> + </data> + <data name="reference.codebase.listed" xml:space="preserve"> + <value>{count, plural, other {掲載#件}}</value> + </data> + <data name="reference.codebase.archived" xml:space="preserve"> + <value>{count, plural, other {アーカイブ済み#件}}</value> + </data> + <data name="reference.measuredNeverAsserted" xml:space="preserve"> + <value>実測であって、申告ではない</value> + </data> + <data name="reference.codebase.note" xml:space="preserve"> + <value>このリクエストの時点でカタログから数えたもので、上のリンクが持つのと同じフィルターによる — この数値とその一覧は一つのクエリであり、食い違うことはない。</value> + </data> + <data name="reference.codebase.offered" xml:space="preserve"> + <value>ハンドシェイクで提供していたもの：{protocols}</value> + </data> + <data name="reference.protocol.heading" xml:space="preserve"> + <value>実測した採用状況</value> + </data> + <data name="reference.protocol.none" xml:space="preserve"> + <value>まだ実測なし。</value> + </data> + <data name="reference.protocol.share" xml:space="preserve"> + <value>{listed, plural, other {掲載#件のゲーム}}のうち — {percent}</value> + </data> + <data name="reference.protocol.remainder" xml:space="preserve"> + <value>ここに数えていないゲームは、そのプロトコルを持たないゲームということではない。数えるのは、そのサーバーがハンドシェイクでそのオプションを提供するのを観測したとき。残りは、当サイトに提供しなかったサーバーと、ハンドシェイクをまだ読んでいないサーバーであり、どちらなのかは言えない。</value> + </data> + <data name="reference.protocol.caption" xml:space="preserve"> + <value>ハンドシェイクで{protocol}を提供するのを観測したゲームを、動かしていると特定したコードベース別に示したもの。</value> + </data> + <data name="reference.protocol.column.codebase" xml:space="preserve"> + <value>コードベース</value> + </data> + <data name="reference.protocol.column.offered" xml:space="preserve"> + <value>提供あり</value> + </data> + <data name="reference.protocol.column.identified" xml:space="preserve"> + <value>特定済み</value> + </data> + <data name="reference.seeAlso" xml:space="preserve"> + <value>関連項目</value> + </data> + <data name="reference.capabilities.heading" xml:space="preserve"> + <value>機能</value> + </data> + <data name="reference.capabilities.established" xml:space="preserve"> + <value>{count, plural, other {{total}件のうち#件はプロジェクト自身のドキュメントで確認}}</value> + </data> + <data name="reference.capabilities.caveat" xml:space="preserve"> + <value>各プロジェクト自身のドキュメントから読み取ったものであり、当サイトの実測ではない — クライアントには観測できるハンドシェイクがない。「{unknown}」は、調べたが確認できなかったという意味。「いいえ」の意味では決してない。</value> + </data> + <data name="reference.capabilities.caption" xml:space="preserve"> + <value>クライアントの機能。いずれも各プロジェクト自身のドキュメントから読み取ったもの。不明は確認できなかったという意味であって、そのクライアントに備わっていないという意味ではない。</value> + </data> + <data name="reference.capabilities.column.documented" xml:space="preserve"> + <value>文書化</value> + </data> + <data name="reference.capabilities.column.source" xml:space="preserve"> + <value>典拠</value> + </data> + <data name="reference.capabilities.noSource" xml:space="preserve"> + <value>見つけられなかった</value> + </data> + <data name="reference.capability.yes" xml:space="preserve"> + <value>はい</value> + </data> + <data name="reference.capability.no" xml:space="preserve"> + <value>いいえ</value> + </data> + <data name="reference.capability.unknown" xml:space="preserve"> + <value>不明</value> + </data> + <data name="reference.plain.runsOn" xml:space="preserve"> + <value>動作環境：{platforms}</value> + </data> + <data name="reference.plain.codebase.heading" xml:space="preserve"> + <value>このコードベースを動かしていると特定したゲーム</value> + </data> + <data name="reference.plain.codebase.none" xml:space="preserve"> + <value>まだない。これは当サイトが実測した内容についての言明であって、存在するものについてのものではない — 到達していないゲームや、コードベースを読み取れなかったゲームは、ここには数えていない。</value> + </data> + <data name="reference.plain.codebase.counts" xml:space="preserve"> + <value>{listed, plural, other {掲載#件}}、{archived, plural, other {アーカイブ済み#件}}</value> + </data> + <data name="reference.plain.codebase.offered" xml:space="preserve"> + <value>ハンドシェイクで実測：{protocols}</value> + </data> + <data name="reference.plain.codebase.nothingOffered" xml:space="preserve"> + <value>これまで読んだどのハンドシェイクでも、何も提供されなかった。</value> + </data> + <data name="reference.plain.protocol.share" xml:space="preserve"> + <value>{listed, plural, other {掲載#件のゲーム}}のうち{offering}件で提供を観測（{percent}）</value> + </data> + <data name="reference.plain.protocol.byCodebase" xml:space="preserve"> + <value>特定できたゲームの、コードベース別</value> + </data> + <data name="reference.plain.protocol.row" xml:space="preserve"> + <value>{identified}件のうち{offering}件が提供</value> + </data> + <data name="reference.plain.capabilities.unknown" xml:space="preserve"> + <value>{count, plural, other {{total}行のうち#行が不明}}：どちらとも述べたプロジェクト自身のドキュメントを見つけられなかった。短くて正直な表のほうが、長くて当て推量の表よりよい。</value> + </data> + <data name="account.title" xml:space="preserve"> + <value>自分のゲーム</value> + </data> + <data name="account.noDatabase" xml:space="preserve"> + <value>アカウントにはデータベースが必要だが、このサイトはデモ用のダミーデータで動いている。</value> + </data> + <data name="account.signInButton" xml:space="preserve"> + <value>サインイン</value> + </data> + <data name="account.signedInAs" xml:space="preserve"> + <value>{name}としてサインイン中。</value> + </data> + <data name="account.signOut" xml:space="preserve"> + <value>サインアウト</value> + </data> + <data name="account.empty.body" xml:space="preserve"> + <value>まだ何も申請していない。{listing}で自分のゲームを見つけ、そのページで{claimControl}を押す。</value> + </data> + <data name="account.empty.listing" xml:space="preserve"> + <value>一覧</value> + </data> + <data name="account.empty.claimControl" xml:space="preserve"> + <value>このゲームを申請する</value> + </data> + <data name="account.resigned.lead" xml:space="preserve"> + <value>手放した。</value> + </data> + <data name="account.resigned.body" xml:space="preserve"> + <value>その記録は残る。新しいトークンを公開すれば、いつでもまた管理していることを証明できる。</value> + </data> + <data name="account.saved.lead" xml:space="preserve"> + <value>保存した。</value> + </data> + <data name="account.saved.thatGame" xml:space="preserve"> + <value>そのゲーム</value> + </data> + <data name="account.saved.fields" xml:space="preserve"> + <value>{game}のページに、所有者申告として表示されるようになった。</value> + </data> + <data name="account.saved.screenHidden" xml:space="preserve"> + <value>{game}の接続画面の再公開をやめた。ページには穴を残さず、そのことを明記する。</value> + </data> + <data name="account.saved.screenShown" xml:space="preserve"> + <value>{game}の接続画面を、またそのページに表示している。</value> + </data> + <data name="account.saved.crawlStopped" xml:space="preserve"> + <value>把握しているすべてのアドレスで、{game}へのダイヤルをやめた。そのページには、要請より前に実測したものがすべて残る。</value> + </data> + <data name="account.saved.crawlResumed" xml:space="preserve"> + <value>スケジュールで次の順番が来たときから、{game}へのダイヤルを再開する。</value> + </data> + <data name="account.saved.unlisted" xml:space="preserve"> + <value>{game}は一覧、ランキング、日次の数値から外れた。そのページと、これまで持っていたすべてのURLは応答し続ける。</value> + </data> + <data name="account.saved.relisted" xml:space="preserve"> + <value>{game}は一覧に戻った。また実測されるのに要るのは、応答が返る探査1回だけ。</value> + </data> + <data name="account.refused.lead" xml:space="preserve"> + <value>{field}は変更していない。</value> + </data> + <data name="account.refused.tooLong" xml:space="preserve"> + <value>ここは1行で答える欄で、保存するのは最大{max}文字まで。</value> + </data> + <data name="account.refused.measured" xml:space="preserve"> + <value>その項目は実測。申請で足せるのはMSSPに収まらない内容であって、観測した内容は誰にも編集できない。当サイト自身にも。</value> + </data> + <data name="account.claimed.heading" xml:space="preserve"> + <value>申請済み</value> + </data> + <data name="account.claim.verified" xml:space="preserve"> + <value>{date}に検証</value> + </data> + <data name="account.claim.verifiedAndSeen" xml:space="preserve"> + <value>{date}に検証、トークンの最終確認{seen}</value> + </data> + <data name="account.claim.mssp" xml:space="preserve"> + <value>MSSPを確認する</value> + </data> + <data name="account.claim.coOwners" xml:space="preserve"> + <value>{count, plural, other {{names}も所有者 — それぞれ自分のトークンを検証している。}}</value> + </data> + <data name="account.coOwner.unnamed" xml:space="preserve"> + <value>別のアカウント</value> + </data> + <data name="account.badge.summary" xml:space="preserve"> + <value>自分のサイトに接続数を載せる</value> + </data> + <data name="account.badge.carries" xml:space="preserve"> + <value>バッジは接続数と、それを実測した時期を併せて示す。古さの分からない数値こそ、このサイトが置き換えるために存在するものだから。</value> + </data> + <data name="account.badge.states" xml:space="preserve"> + <value>数えられなかったときはゼロではなく{unknown}と表示し、ゲームが応答しなくなれば{archived}と表示する。</value> + </data> + <data name="account.badge.json" xml:space="preserve"> + <value>自分で描きたければ{json}もある。</value> + </data> + <data name="account.history.summary" xml:space="preserve"> + <value>履歴</value> + </data> + <data name="account.event.issued" xml:space="preserve"> + <value>トークン発行</value> + </data> + <data name="account.event.reissued" xml:space="preserve"> + <value>トークン再発行</value> + </data> + <data name="account.event.verified" xml:space="preserve"> + <value>検証 — トークンを読み取った</value> + </data> + <data name="account.event.beaconSeen" xml:space="preserve"> + <value>トークンは引き続き公開中</value> + </data> + <data name="account.event.beaconMissing" xml:space="preserve"> + <value>今回はトークンを読み取れず</value> + </data> + <data name="account.event.revoked" xml:space="preserve"> + <value>申請を手放した</value> + </data> + <data name="account.event.expired" xml:space="preserve"> + <value>トークンが未使用のまま期限切れ</value> + </data> + <data name="account.event.counterClaimed" xml:space="preserve"> + <value>別のアカウントが管理していることを証明し、ゲームを引き継いだ</value> + </data> + <data name="account.event.checkRequested" xml:space="preserve"> + <value>確認を要請</value> + </data> + <data name="account.resign.summary" xml:space="preserve"> + <value>この申請を手放す</value> + </data> + <data name="account.resign.confirm" xml:space="preserve"> + <value>確認のため{word}と入力する。何も削除されず、新しいトークンを公開すればまた管理していることを証明できる。他に所有者がいれば、ゲームは申請済みのまま。</value> + </data> + <data name="account.resign.button" xml:space="preserve"> + <value>{game}を手放す</value> + </data> + <data name="account.pending.heading" xml:space="preserve"> + <value>トークン待ち</value> + </data> + <data name="account.pending.dates" xml:space="preserve"> + <value>トークン発行{issued}、有効期限{expires}</value> + </data> + <data name="account.passkeys.heading" xml:space="preserve"> + <value>パスキー</value> + </data> + <data name="account.passkey.unnamed" xml:space="preserve"> + <value>名称なし</value> + </data> + <data name="account.passkey.added" xml:space="preserve"> + <value>追加{date}</value> + </data> + <data name="account.passkey.addedOneDevice" xml:space="preserve"> + <value>追加{date} · 端末1台のみ</value> + </data> + <data name="account.passkey.single" xml:space="preserve"> + <value>このパスキーは1台の端末にしかない。失くしても、ゲームに新しいトークンを公開すれば入り直せるが、2つ目のパスキーがあるほうが早い。</value> + </data> + <data name="account.passkey.add" xml:space="preserve"> + <value>パスキーをもう1つ追加</value> + </data> + <data name="claim.noGame" xml:space="preserve"> + <value>そのゲームはない</value> + </data> + <data name="claim.title" xml:space="preserve"> + <value>{game}を申請</value> + </data> + <data name="claim.noDatabase" xml:space="preserve"> + <value>申請にはデータベースが必要だが、このサイトはデモ用のダミーデータで動いている。</value> + </data> + <data name="claim.needAccount" xml:space="preserve"> + <value>先にアカウントが要る。要るのはパスキーと名前だけ。</value> + </data> + <data name="claim.signIn" xml:space="preserve"> + <value>サインイン、またはアカウントを作成</value> + </data> + <data name="claim.yourGames" xml:space="preserve"> + <value>自分のゲーム</value> + </data> + <data name="claim.hasOwners" xml:space="preserve"> + <value>{count, plural, other {このゲームには、サーバーを管理していることを証明した所有者がすでに#人いる。}}こちらも証明できる — 確かめ方はどちらでも同じ — が、それが何を意味するのかは伝えてもらう必要がある。トークンからは判別できないから。</value> + </data> + <data name="claim.join.button" xml:space="preserve"> + <value>こちらも運用している — 所有者に加えてほしい</value> + </data> + <data name="claim.join.note" xml:space="preserve"> + <value>全員が自分の申請を保つ。1つのゲームを2人で運用している状態。</value> + </data> + <data name="claim.assume.button" xml:space="preserve"> + <value>引き継いだ — こちらに移してほしい</value> + </data> + <data name="claim.assume.note" xml:space="preserve"> + <value>{count, plural, other {トークンが検証された時点で、既存の申請は取り消され、ゲームはこちらのものになる。}}相手には自分の履歴でその理由が見える。何も削除されず、相手はこれから行うのと同じ方法で、また管理していることを証明できる。</value> + </data> + <data name="claim.verified.lead" xml:space="preserve"> + <value>検証できた。</value> + </data> + <data name="claim.verified.viaMssp" xml:space="preserve"> + <value>{date}、そのゲームのMSSPレポートからトークンを読み取った。</value> + </data> + <data name="claim.verified.viaScreen" xml:space="preserve"> + <value>{date}、接続画面からトークンを読み取った。</value> + </data> + <data name="claim.verified.leaveIt" xml:space="preserve"> + <value>トークンはそのままにしておく。同一性の手がかりも兼ねるので、ホストを移しても名前を変えても、このゲームは見分けがつく。外しても申請が解けるわけではない。</value> + </data> + <data name="claim.publish" xml:space="preserve"> + <value>匿名の接続に見える場所であれば、どこにこのトークンを公開してもよい。次の探査がそれを拾い、それがそのサーバーに書き込めることの証明になる。</value> + </data> + <data name="claim.transfer.lead" xml:space="preserve"> + <value>これは移管。</value> + </data> + <data name="claim.transfer.body" xml:space="preserve"> + <value>{count, plural, other {このトークンを読み取った時点で、このゲームに対する現所有者の申請は取り消され、こちらのものになる。}}</value> + </data> + <data name="claim.either.heading" xml:space="preserve"> + <value>どちらか一方でよい</value> + </data> + <data name="claim.mssp.heading" xml:space="preserve"> + <value>MSSPの変数</value> + </data> + <data name="claim.mssp.note" xml:space="preserve"> + <value>{codebase}では{file}の1行。MSSPを持つコードベースには、どれも同じものがある。</value> + </data> + <data name="claim.mssp.aliases" xml:space="preserve"> + <value>{aliases}も受け付ける。</value> + </data> + <data name="claim.screen.heading" xml:space="preserve"> + <value>接続画面の1行</value> + </data> + <data name="claim.screen.note" xml:space="preserve"> + <value>画面内のどこでもよく、周りに色コードがあっても構わない。</value> + </data> + <data name="claim.then.heading" xml:space="preserve"> + <value>そのあと</value> + </data> + <data name="claim.then.body" xml:space="preserve"> + <value>確認は通常のクロールスケジュールで行う。このトークンの有効期限は{date}。いつ戻ってきてもよく、書き留めておくものは何もない。</value> + </data> + <data name="claim.check.button" xml:space="preserve"> + <value>早めに見に行く</value> + </data> + <data name="claim.check.can" xml:space="preserve"> + <value>自分のゲームを待ち行列の先頭に入れる。ダイヤルは当サイト自身のスケジュールで行うので、今すぐではなく、早まるだけ。</value> + </data> + <data name="claim.check.rationed" xml:space="preserve"> + <value>今要請したばかり。数分おいてからもう一度 — 本来より早く実際のサーバーにダイヤルすることになるので、回数を制限している。</value> + </data> + <data name="owner.declare.heading" xml:space="preserve"> + <value>{game}について、運用者にしか伝えられないこと</value> + </data> + <data name="owner.declare.lede" xml:space="preserve"> + <value>ここにあるのは、MSSPに対応する欄がないもの。自分のゲームのページには、最後に確認した日付を添えて{declared}として、実測した内容と並べて表示する — 実測に代えて表示することは決してない。実測したものは、ここからは誰にも編集できない。運用者にも当サイトにも。</value> + </data> + <data name="owner.field.declared" xml:space="preserve"> + <value>{age}に自己申告。取り下げるにはこの欄を空にする — どちらにせよ、何と書かれていたかの記録は残る。</value> + </data> + <data name="owner.save" xml:space="preserve"> + <value>自己申告した内容を保存</value> + </data> + <data name="owner.override.heading" xml:space="preserve"> + <value>{game}が報告している内容と、代わりに表示してほしい内容</value> + </data> + <data name="owner.override.lede" xml:space="preserve"> + <value>MSSPはどのクローラーも読むものであり、ここに入れた内容の横に、当サイトはそれを表示し続ける — 運用者の回答が、ゲーム自身の回答を隠すことはない。</value> + </data> + <data name="owner.override.nothingMeasured" xml:space="preserve"> + <value>実測したものは、ここからは何も編集できない：接続数も、機能も、到達可能だった1時間も。</value> + </data> + <data name="owner.override.fixItThere" xml:space="preserve"> + <value>下の行が{file}で誤っているなら、そこで直せばすべての場所で直る。</value> + </data> + <data name="owner.report.value" xml:space="preserve"> + <value>ゲームの報告は{value}、確認は{age}</value> + </data> + <data name="owner.report.none" xml:space="preserve"> + <value>ゲームはここで何も報告していない</value> + </data> + <data name="owner.rename.note" xml:space="preserve"> + <value>名前を変えると、{game}の掲載名と、そのページのアドレスが変わる。古いアドレスは永久に動き続け — このゲームがこれまで持っていたすべてのURLは現在のURLへ転送される — 欄を空にすれば、名前はMSSPの内容に戻る。</value> + </data> + <data name="owner.screen.heading" xml:space="preserve"> + <value>自分の接続画面</value> + </data> + <data name="owner.screen.suppressed" xml:space="preserve"> + <value>再公開はしていない。ページには穴を残さず、そのことを明記しており、クローラーは読み続けている — ゲームが移ったときに見分ける手がかりがそれだから。</value> + </data> + <data name="owner.screen.show" xml:space="preserve"> + <value>また表示する</value> + </data> + <data name="owner.screen.shown" xml:space="preserve"> + <value>表示しているのは、サーバーがそれをすべての匿名接続に送っているから。表示してほしくなければ、そう言えばやめる。理由は訊かない。</value> + </data> + <data name="owner.screen.stop" xml:space="preserve"> + <value>接続画面の表示をやめてほしい</value> + </data> + <data name="owner.crawl.heading" xml:space="preserve"> + <value>クロールされること</value> + </data> + <data name="owner.crawl.stopped" xml:space="preserve"> + <value>停止した。{game}へは一切ダイヤルしておらず、ページには要請より前に実測したものがすべて残る — 空いた時間は原因を名指ししない。{ourFact}というのは当サイトについての事実であって、そのゲームについての実測ではないから。</value> + </data> + <data name="owner.crawl.ourFact" xml:space="preserve"> + <value>停止を要請された</value> + </data> + <data name="owner.crawl.resume" xml:space="preserve"> + <value>またクロールしてほしい</value> + </data> + <data name="owner.crawl.standing" xml:space="preserve"> + <value>これはここからではなく、サーバー自身から来たもの — {routes}。またクロールされるには、その公開をやめる。次のサイクルでそれを受け取る。</value> + </data> + <data name="owner.crawl.route.mssp" xml:space="preserve"> + <value>MSSPレポートが{variable}を公開している</value> + </data> + <data name="owner.crawl.route.dns" xml:space="preserve"> + <value>{label}のTXTレコードが停止を求めている</value> + </data> + <data name="owner.crawl.route.recorded" xml:space="preserve"> + <value>記録済みの要請</value> + </data> + <data name="owner.crawl.partial" xml:space="preserve"> + <value>{stopped}では停止し、{dialling}には引き続きダイヤルしている。たいていは離脱のあとに追加されたポート。</value> + </data> + <data name="owner.crawl.stopAll" xml:space="preserve"> + <value>すべてのアドレスでも停止してほしい</value> + </data> + <data name="owner.crawl.dialling" xml:space="preserve"> + <value>{game}へは一定のスケジュールでダイヤルし、匿名の接続に見えるものを読んでいる。やめてほしければ、そう言えばやめる — 1回のサイクル以内に、把握しているすべてのアドレスで。理由は訊かない。</value> + </data> + <data name="owner.crawl.selfService" xml:space="preserve"> + <value>すでに実測したものは何も削除されない：ページは履歴とURLを保ち、これを撤回したあとの探査1回で再開する。当サイトを通さず、自分の設定で伝えることもできる — MSSPの{mssp}か、{dns}のTXTレコード — このゲームをここで誰かが申請しているかどうかにかかわらず、それに従う。</value> + </data> + <data name="owner.crawl.stop" xml:space="preserve"> + <value>クロールをやめてほしい</value> + </data> + <data name="owner.listing.heading" xml:space="preserve"> + <value>掲載されること</value> + </data> + <data name="owner.listing.unlisted" xml:space="preserve"> + <value>{game}は一覧からも、ランキングからも、日次の数値からも外れている。ページと、これまで持っていたすべてのURLは応答し続け、要請より前に実測したものはすべてそこに残っている。何も削除していない。閲覧してたどり着ける場所ではなくなるだけ。</value> + </data> + <data name="owner.listing.relist" xml:space="preserve"> + <value>一覧に戻してほしい</value> + </data> + <data name="owner.listing.probeRelists" xml:space="preserve"> + <value>応答が返る探査1回でも同じことが起きる。離脱が有効な間はダイヤルしないので、そうなることはない — ただし撤回した日から1週間以内にそのアドレスの順番が来て、応答が返った探査が一覧に戻す。二度頼む必要はない。</value> + </data> + <data name="owner.listing.mayUnlist" xml:space="preserve"> + <value>ダイヤルは停止しており、ページはそれ以前に実測した内容とともに一覧に残っている。残したくなければ、そう言えば外す — 一覧からも、ランキングからも、日次の数値からも。</value> + </data> + <data name="owner.listing.reversible" xml:space="preserve"> + <value>何も削除されず、何も壊れない：ページは応答し、これまで持っていたすべてのURLは今もそこへ転送され、案内した相手には見える。閲覧してたどり着ける場所ではなくなるだけ。ここから元に戻せるし、離脱を撤回したあとに応答が返った探査でも元に戻る。</value> + </data> + <data name="owner.listing.unlist" xml:space="preserve"> + <value>一覧からも外してほしい</value> + </data> + <data name="facet.group.measure" xml:space="preserve"> + <value>実測できたもの</value> + </data> + <data name="facet.measure.note" xml:space="preserve"> + <value>非表示にすると一覧から外れる — そのゲームが無人だという意味ではない。</value> + </data> + <data name="facet.group.uncounted" xml:space="preserve"> + <value>接続数読み取り不可</value> + </data> + <data name="facet.group.unreachable" xml:space="preserve"> + <value>到達不可</value> + </data> + <data name="facet.excluded.uncounted" xml:space="preserve"> + <value>この一覧では非表示</value> + </data> + <data name="facet.excluded.unreachable" xml:space="preserve"> + <value>この一覧では非表示</value> + </data> + <data name="facet.plain.marks" xml:space="preserve"> + <value>左の列で、* はこの一覧が絞り込みに使っている値、- は除外に使っている値。どちらもクエリでの選択であって、ゲームについての事実ではない。</value> + </data> +</root> diff --git a/src/MUI.Web/Resources/Messages.nl.resx b/src/MUI.Web/Resources/Messages.nl.resx new file mode 100644 index 0000000..56549b8 --- /dev/null +++ b/src/MUI.Web/Resources/Messages.nl.resx @@ -0,0 +1,2877 @@ +<?xml version="1.0" encoding="utf-8"?> +<root> + <!-- + Nederlands, machine-translated and not reviewed by a person. + + Every page served in this locale carries the ◆ notice saying so, and the locale is reachable but + never offered: nothing sends a reader here. Promotion to LocaleStatus.Shipped is a person reading + the locked strings against Glossary.cs, not an edit to a status enum. + + The values are ICU MessageFormat. Argument names in braces are code. + --> + <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata"> + <xsd:import namespace="http://www.w3.org/XML/1998/namespace" /> + <xsd:element name="root" msdata:IsDataSet="true"> + <xsd:complexType> + <xsd:choice maxOccurs="unbounded"> + <xsd:element name="data"> + <xsd:complexType> + <xsd:sequence> + <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" /> + <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" /> + </xsd:sequence> + <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" /> + <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" /> + <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" /> + <xsd:attribute ref="xml:space" /> + </xsd:complexType> + </xsd:element> + <xsd:element name="resheader"> + <xsd:complexType> + <xsd:sequence> + <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" /> + </xsd:sequence> + <xsd:attribute name="name" type="xsd:string" use="required" /> + </xsd:complexType> + </xsd:element> + </xsd:choice> + </xsd:complexType> + </xsd:element> + </xsd:schema> + <resheader name="resmimetype"><value>text/microsoft-resx</value></resheader> + <resheader name="version"><value>2.0</value></resheader> + <resheader name="reader"><value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader> + <resheader name="writer"><value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader> + <data name="facet.count" xml:space="preserve"> + <value>{count, plural, one {# spel} other {# spellen}}</value> + </data> + <data name="facet.value.include" xml:space="preserve"> + <value>{value}, {count, plural, one {# spel} other {# spellen}}, alleen</value> + </data> + <data name="facet.value.exclude" xml:space="preserve"> + <value>{value}, {count, plural, one {# spel} other {# spellen}}, uitgesloten</value> + </data> + <data name="facet.value.choose" xml:space="preserve"> + <value>{value}, {count, plural, one {# spel} other {# spellen}}</value> + </data> + <data name="facet.any" xml:space="preserve"> + <value>ongeacht {facet}, {count, plural, one {# spel} other {# spellen}}</value> + </data> + <data name="listing.total" xml:space="preserve"> + <value>{count, plural, =0 {Hier staan geen spellen.} one {# spel, waarvan elk feit vermeldt hoe het verkregen is.} other {# spellen, waarvan elk feit vermeldt hoe het verkregen is.}}</value> + </data> + <data name="chart.basis" xml:space="preserve"> + <value>{days, plural, one {# dag} other {# dagen}} gemeten · {probes, plural, one {# peiling} other {# peilingen}}</value> + </data> + <data name="window.samples" xml:space="preserve"> + <value>{days, plural, one {#d} other {#d}} · {count, plural, one {# telling} other {# tellingen}}</value> + </data> + <data name="capabilities.agree" xml:space="preserve"> + <value>{disagreeing, plural, =0 {Geen van de {total} wijkt af.} one {# van de {total} wijkt af van wat het spel opgeeft.} other {# van de {total} wijken af van wat het spel opgeeft.}}</value> + </data> + <data name="find.matching" xml:space="preserve"> + <value>{count, plural, =0 {Geen spel past bij elk antwoord.} one {# spel past bij elk antwoord.} other {# spellen passen bij elk antwoord.}}</value> + </data> + <data name="find.basis" xml:space="preserve"> + <value>van {listed, plural, one {# vermeld spel} other {# vermelde spellen}} · {answers, plural, =0 {geen antwoorden gegeven} one {# antwoord gegeven} other {# antwoorden gegeven}}</value> + </data> + <data name="find.show" xml:space="preserve"> + <value>{count, plural, one {Toon het ene spel} other {Toon deze # spellen}}</value> + </data> + <data name="find.drop" xml:space="preserve"> + <value>"{answer}" laten vallen — {count, plural, one {# spel} other {# spellen}}</value> + </data> + <data name="find.clear" xml:space="preserve"> + <value>antwoord wissen op: {question}</value> + </data> + <data name="find.title" xml:space="preserve"> + <value>Een spel zoeken</value> + </data> + <data name="find.kicker" xml:space="preserve"> + <value>passend bij alle antwoorden</value> + </data> + <data name="find.noun" xml:space="preserve"> + <value>{count, plural, one {spel} other {spellen}}</value> + </data> + <data name="find.clearAll" xml:space="preserve"> + <value>alle antwoorden wissen</value> + </data> + <data name="find.startAgain" xml:space="preserve"> + <value>opnieuw beginnen</value> + </data> + <data name="find.more" xml:space="preserve"> + <value>{count, plural, one {# meer} other {# meer}}</value> + </data> + <data name="find.answersGiven" xml:space="preserve"> + <value>gegeven antwoorden</value> + </data> + <data name="find.wholeListing" xml:space="preserve"> + <value>de hele lijst</value> + </data> + <data name="find.refused" xml:space="preserve"> + <value>die zoekopdracht is geweigerd</value> + </data> + <data name="find.name.label" xml:space="preserve"> + <value>een naam, als je er een hebt</value> + </data> + <data name="find.name.placeholder" xml:space="preserve"> + <value>naam, of een deel ervan</value> + </data> + <data name="find.name.submit" xml:space="preserve"> + <value>Zoeken op naam</value> + </data> + <data name="find.q.band" xml:space="preserve"> + <value>Speelt er nu iemand?</value> + </data> + <data name="find.q.genre" xml:space="preserve"> + <value>Wat wil je spelen?</value> + </data> + <data name="find.q.lineage" xml:space="preserve"> + <value>Wat voor spel?</value> + </data> + <data name="find.q.language" xml:space="preserve"> + <value>In welke taal?</value> + </data> + <data name="find.q.client" xml:space="preserve"> + <value>Heeft je client iets nodig?</value> + </data> + <data name="find.q.dark" xml:space="preserve"> + <value>Ook stilgevallen spellen meenemen?</value> + </data> + <data name="find.any.band" xml:space="preserve"> + <value>maakt niet uit</value> + </data> + <data name="find.any.genre" xml:space="preserve"> + <value>elk genre</value> + </data> + <data name="find.any.lineage" xml:space="preserve"> + <value>elke soort</value> + </data> + <data name="find.any.language" xml:space="preserve"> + <value>elke taal</value> + </data> + <data name="find.any.client" xml:space="preserve"> + <value>maakt niet uit</value> + </data> + <data name="find.dark.no" xml:space="preserve"> + <value>nee, alleen live spellen</value> + </data> + <data name="find.dark.yes" xml:space="preserve"> + <value>ja, toon die ook</value> + </data> + <data name="find.dark.chip" xml:space="preserve"> + <value>stilgevallen spellen</value> + </data> + <data name="find.protocol.tls" xml:space="preserve"> + <value>TLS — versleuteld, handshake door ons voltooid</value> + </data> + <data name="find.protocol.mssp" xml:space="preserve"> + <value>MSSP — zelfbeschrijving van de server</value> + </data> + <data name="find.protocol.mccp" xml:space="preserve"> + <value>MCCP — gecomprimeerde uitvoer</value> + </data> + <data name="find.protocol.mxp" xml:space="preserve"> + <value>MXP — klikbare links</value> + </data> + <data name="find.protocol.gmcp" xml:space="preserve"> + <value>GMCP — gestructureerde clientgegevens</value> + </data> + <data name="find.protocol.msdp" xml:space="preserve"> + <value>MSDP — gestructureerde clientgegevens</value> + </data> + <data name="find.protocol.charset" xml:space="preserve"> + <value>CHARSET — onderhandeling over codering</value> + </data> + <data name="find.protocol.utf8" xml:space="preserve"> + <value>UTF-8 — niet-Latijnse tekst wordt weergegeven</value> + </data> + <data name="find.protocol.ttype" xml:space="preserve"> + <value>TTYPE — client meldt zijn type</value> + </data> + <data name="find.protocol.atcp" xml:space="preserve"> + <value>ATCP — gestructureerde clientgegevens</value> + </data> + <data name="find.protocol.msp" xml:space="preserve"> + <value>MSP — geluidstriggers</value> + </data> + <data name="find.protocol.eor" xml:space="preserve"> + <value>EOR — promptmarkering</value> + </data> + <data name="find.protocol.other" xml:space="preserve"> + <value>{token} — gemeten in de handshake</value> + </data> + <data name="provenance.count.measured" xml:space="preserve"> + <value>gemeten</value> + </data> + <data name="provenance.game.measured" xml:space="preserve"> + <value>gemeten</value> + </data> + <data name="provenance.capability.measured" xml:space="preserve"> + <value>gemeten</value> + </data> + <data name="provenance.screen.measured" xml:space="preserve"> + <value>gemeten</value> + </data> + <data name="kicker.measured" xml:space="preserve"> + <value>gemeten</value> + </data> + <data name="provenance.count.declared" xml:space="preserve"> + <value>opgegeven</value> + </data> + <data name="provenance.game.declared" xml:space="preserve"> + <value>opgegeven</value> + </data> + <data name="provenance.capability.declared" xml:space="preserve"> + <value>opgegeven</value> + </data> + <data name="kicker.declared" xml:space="preserve"> + <value>opgegeven</value> + </data> + <data name="provenance.derived" xml:space="preserve"> + <value>afgeleid</value> + </data> + <data name="kicker.derived" xml:space="preserve"> + <value>afgeleid</value> + </data> + <data name="state.notMeasured" xml:space="preserve"> + <value>niet gemeten</value> + </data> + <data name="state.uncounted" xml:space="preserve"> + <value>ongeteld</value> + </data> + <data name="state.unreachable" xml:space="preserve"> + <value>onbereikbaar</value> + </data> + <data name="state.notCounted" xml:space="preserve"> + <value>niet geteld</value> + </data> + <data name="listing.count.none" xml:space="preserve"> + <value>geen telling</value> + </data> + <data name="listing.plain.fromHere" xml:space="preserve"> + <value>van hieruit</value> + </data> + <data name="listing.plain.archived" xml:space="preserve"> + <value>gearchiveerd</value> + </data> + <data name="listing.plain.claimed" xml:space="preserve"> + <value>geclaimd</value> + </data> + <data name="random.empty.title" xml:space="preserve"> + <value>Niets om uit te kiezen</value> + </data> + <data name="random.empty.body" xml:space="preserve"> + <value>Geen spel past bij dat filter. Probeer {listing}, of {archive}.</value> + </data> + <data name="random.empty.listing" xml:space="preserve"> + <value>de hele lijst</value> + </data> + <data name="random.empty.archive" xml:space="preserve"> + <value>het archief meenemen</value> + </data> + <data name="term.connected" xml:space="preserve"> + <value>verbonden</value> + </data> + <data name="term.unclaimed" xml:space="preserve"> + <value>niet geclaimd</value> + </data> + <data name="term.claimedByOwner" xml:space="preserve"> + <value>geclaimd door de eigenaar</value> + </data> + <data name="term.stillProbed" xml:space="preserve"> + <value>wordt nog gepeild</value> + </data> + <data name="term.typical" xml:space="preserve"> + <value>typisch</value> + </data> + <data name="term.peak" xml:space="preserve"> + <value>piek</value> + </data> + <data name="a11y.readAsText" xml:space="preserve"> + <value>als tekst lezen</value> + </data> + <data name="a11y.plainText" xml:space="preserve"> + <value>platte tekst</value> + </data> + <data name="a11y.skipToContent" xml:space="preserve"> + <value>naar de inhoud</value> + </data> + <data name="a11y.asciiBanner" xml:space="preserve"> + <value>ASCII-banner: het verbindingsscherm van {game}.</value> + </data> + <data name="nav.catalogues" xml:space="preserve"> + <value>Catalogi</value> + </data> + <data name="nav.account" xml:space="preserve"> + <value>Deze site en je account</value> + </data> + <data name="nav.browse" xml:space="preserve"> + <value>bladeren</value> + </data> + <data name="nav.learn" xml:space="preserve"> + <value>uitleg</value> + </data> + <data name="nav.thisSite" xml:space="preserve"> + <value>deze site</value> + </data> + <data name="nav.menu" xml:space="preserve"> + <value>menu</value> + </data> + <data name="nav.games" xml:space="preserve"> + <value>spellen</value> + </data> + <data name="nav.find" xml:space="preserve"> + <value>zoeken</value> + </data> + <data name="nav.random" xml:space="preserve"> + <value>willekeurig</value> + </data> + <data name="nav.archive" xml:space="preserve"> + <value>archief</value> + </data> + <data name="nav.reference" xml:space="preserve"> + <value>naslag</value> + </data> + <data name="nav.ecosystem" xml:space="preserve"> + <value>ecosysteem</value> + </data> + <data name="nav.rankings" xml:space="preserve"> + <value>ranglijsten</value> + </data> + <data name="nav.about" xml:space="preserve"> + <value>over</value> + </data> + <data name="nav.submit" xml:space="preserve"> + <value>aanmelden</value> + </data> + <data name="nav.submitGame" xml:space="preserve"> + <value>een spel aanmelden</value> + </data> + <data name="nav.signIn" xml:space="preserve"> + <value>inloggen</value> + </data> + <data name="nav.yourGames" xml:space="preserve"> + <value>je spellen</value> + </data> + <data name="theme.label" xml:space="preserve"> + <value>thema</value> + </data> + <data name="theme.auto" xml:space="preserve"> + <value>automatisch</value> + </data> + <data name="theme.light" xml:space="preserve"> + <value>licht</value> + </data> + <data name="theme.dark" xml:space="preserve"> + <value>donker</value> + </data> + <data name="banner.demo.lead" xml:space="preserve"> + <value>Demogegevens.</value> + </data> + <data name="banner.demo" xml:space="preserve"> + <value>Er is geen database geconfigureerd, dus dit zijn testgegevens. Niets hiervan is gemeten.</value> + </data> + <data name="footer.allGames" xml:space="preserve"> + <value>alle spellen</value> + </data> + <data name="footer.archive" xml:space="preserve"> + <value>archief</value> + </data> + <data name="footer.declaredByGame" xml:space="preserve"> + <value>opgegeven door het spel</value> + </data> + <data name="footer.whatChanged" xml:space="preserve"> + <value>wat er veranderd is</value> + </data> + <data name="home.title" xml:space="preserve"> + <value>Een gids voor de MU*-hobby</value> + </data> + <data name="home.lede" xml:space="preserve"> + <value>Elk feit vermeldt hoe het verkregen is en hoe oud het is: gemeten door onze crawler, of opgegeven door het spel en als zodanig gemarkeerd.</value> + </data> + <data name="home.search.label" xml:space="preserve"> + <value>Spellen zoeken op naam, thema, codebase of host</value> + </data> + <data name="home.search.placeholder" xml:space="preserve"> + <value>zoeken op naam, thema, codebase of host</value> + </data> + <data name="home.search.submit" xml:space="preserve"> + <value>zoeken</value> + </data> + <data name="tile.gamesKnown" xml:space="preserve"> + <value>bekende spellen</value> + </data> + <data name="tile.connectedNow" xml:space="preserve"> + <value>nu verbonden</value> + </data> + <data name="tile.answeringUncounted" xml:space="preserve"> + <value>antwoordt, ongeteld</value> + </data> + <data name="tile.archived" xml:space="preserve"> + <value>gearchiveerd</value> + </data> + <data name="feed.newlyDiscovered" xml:space="preserve"> + <value>nieuw ontdekt</value> + </data> + <data name="feed.wentDark" xml:space="preserve"> + <value>stilgevallen — wordt nog gepeild</value> + </data> + <data name="feed.cameBack" xml:space="preserve"> + <value>weer terug</value> + </data> + <data name="feed.nothingNew" xml:space="preserve"> + <value>Niets nieuws.</value> + </data> + <data name="feed.nothingDark" xml:space="preserve"> + <value>Er is niets stilgevallen.</value> + </data> + <data name="feed.nothingBack" xml:space="preserve"> + <value>Er is niets teruggekomen. We blijven kloppen.</value> + </data> + <data name="feed.live" xml:space="preserve"> + <value>live</value> + </data> + <data name="games.title" xml:space="preserve"> + <value>Spellen</value> + </data> + <data name="listing.sortedBy" xml:space="preserve"> + <value>gesorteerd op {order}</value> + </data> + <data name="listing.random" xml:space="preserve"> + <value>willekeurig</value> + </data> + <data name="listing.columns" xml:space="preserve"> + <value>verbonden · bereikt</value> + </data> + <data name="listing.fromHere" xml:space="preserve"> + <value>van hieruit</value> + </data> + <data name="listing.empty.head" xml:space="preserve"> + <value>Geen treffers.</value> + </data> + <data name="listing.empty.hint" xml:space="preserve"> + <value>Probeer minder woorden, of laat een filter vallen.</value> + </data> + <data name="listing.clearFilters" xml:space="preserve"> + <value>filters wissen</value> + </data> + <data name="listing.aboutCodebase" xml:space="preserve"> + <value>over {codebase}</value> + </data> + <data name="listing.never" xml:space="preserve"> + <value>nooit</value> + </data> + <data name="listing.claimed" xml:space="preserve"> + <value>geclaimd door de eigenaar</value> + </data> + <data name="listing.unknownCodebase" xml:space="preserve"> + <value>Onbekende codebase</value> + </data> + <data name="listing.unknownCodebase.title" xml:space="preserve"> + <value>we konden niet vaststellen op welke codebase dit spel draait</value> + </data> + <data name="listing.moreProtocols" xml:space="preserve"> + <value>en {count, plural, one {# meer} other {# meer}}: {names}</value> + </data> + <data name="switch.order" xml:space="preserve"> + <value>Volgorde</value> + </data> + <data name="switch.window" xml:space="preserve"> + <value>Periode</value> + </data> + <data name="switch.now" xml:space="preserve"> + <value>nu</value> + </data> + <data name="switch.typical" xml:space="preserve"> + <value>typisch</value> + </data> + <data name="switch.peak" xml:space="preserve"> + <value>piek</value> + </data> + <data name="switch.name" xml:space="preserve"> + <value>naam</value> + </data> + <data name="switch.reached" xml:space="preserve"> + <value>bereikt</value> + </data> + <data name="window.7" xml:space="preserve"> + <value>7 dagen</value> + </data> + <data name="window.30" xml:space="preserve"> + <value>30 dagen</value> + </data> + <data name="window.90" xml:space="preserve"> + <value>90 dagen</value> + </data> + <data name="filters.search.label" xml:space="preserve"> + <value>Spellen zoeken</value> + </data> + <data name="filters.search.placeholder" xml:space="preserve"> + <value>spellen zoeken</value> + </data> + <data name="filters.summary" xml:space="preserve"> + <value>filters</value> + </data> + <data name="filters.showing" xml:space="preserve"> + <value>getoond</value> + </data> + <data name="filters.clearAll" xml:space="preserve"> + <value>alles wissen</value> + </data> + <data name="filters.stopFiltering" xml:space="preserve"> + <value>— hier niet meer op filteren</value> + </data> + <data name="facet.anyValue" xml:space="preserve"> + <value>alle</value> + </data> + <data name="facet.more" xml:space="preserve"> + <value>meer filters ({count})</value> + </data> + <data name="facet.moreValues" xml:space="preserve"> + <value>{count, plural, one {# meer} other {# meer}}</value> + </data> + <data name="facet.alsoShow" xml:space="preserve"> + <value>ook tonen</value> + </data> + <data name="facet.alsoShow.note" xml:space="preserve"> + <value>Standaard uit. Geen van beide is een oordeel over het spel.</value> + </data> + <data name="facet.archived" xml:space="preserve"> + <value>gearchiveerd</value> + </data> + <data name="facet.adult" xml:space="preserve"> + <value>voor volwassenen</value> + </data> + <data name="facet.archived.state" xml:space="preserve"> + <value>gearchiveerde spellen, {shown, select, true {getoond} other {verborgen}}</value> + </data> + <data name="facet.adult.state" xml:space="preserve"> + <value>spellen die inhoud voor volwassenen opgeven, {shown, select, true {getoond} other {verborgen}}</value> + </data> + <data name="facet.countsNote" xml:space="preserve"> + <value>Aantallen zijn spellen die we gemeten hebben, nooit schattingen.</value> + </data> + <data name="facet.key.summary" xml:space="preserve"> + <value>wat de badges en de lege plekken betekenen</value> + </data> + <data name="facet.key.blank" xml:space="preserve"> + <value>Een lege plek is een gat in onze meting, geen nee. Elk facet zegt het op zijn eigen manier: niet vastgesteld, niet opgegeven, niets onderhandeld.</value> + </data> + <data name="facet.key.zero" xml:space="preserve"> + <value>Een gemeten nul is een telling. Een onbekende telling is geen nul en wordt ook nooit als nul gesorteerd.</value> + </data> + <data name="facet.key.openEnded" xml:space="preserve"> + <value>Open facetten tonen hun {count} meest voorkomende waarden. De rest is bereikbaar via zoeken en via URL.</value> + </data> + <data name="facet.presence.note" xml:space="preserve"> + <value>Niet aangevinkt betekent niet gemeten — niet dat het spel het mist.</value> + </data> + <data name="facet.group.band" xml:space="preserve"> + <value>activiteit</value> + </data> + <data name="facet.group.seen" xml:space="preserve"> + <value>laatst gezien</value> + </data> + <data name="facet.group.protocol" xml:space="preserve"> + <value>aangeboden protocollen</value> + </data> + <data name="facet.group.tls" xml:space="preserve"> + <value>versleuteld</value> + </data> + <data name="facet.group.charset" xml:space="preserve"> + <value>codering</value> + </data> + <data name="facet.group.codebase" xml:space="preserve"> + <value>codebase</value> + </data> + <data name="facet.group.version" xml:space="preserve"> + <value>versie</value> + </data> + <data name="facet.group.lineage" xml:space="preserve"> + <value>afstamming</value> + </data> + <data name="facet.group.family" xml:space="preserve"> + <value>familie</value> + </data> + <data name="facet.group.genre" xml:space="preserve"> + <value>genre</value> + </data> + <data name="facet.group.language" xml:space="preserve"> + <value>taal</value> + </data> + <data name="facet.band.playersNow" xml:space="preserve"> + <value>nu verbonden</value> + </data> + <data name="facet.band.activeThisWeek" xml:space="preserve"> + <value>actief deze week</value> + </data> + <data name="facet.band.quiet" xml:space="preserve"> + <value>rustig — nooit boven 0 geteld</value> + </data> + <data name="facet.band.dark" xml:space="preserve"> + <value>stil — een maand niet bereikt</value> + </data> + <data name="facet.band.archived" xml:space="preserve"> + <value>gearchiveerd</value> + </data> + <data name="facet.seen.day" xml:space="preserve"> + <value>in de laatste 24 uur</value> + </data> + <data name="facet.seen.week" xml:space="preserve"> + <value>in de laatste 7 dagen</value> + </data> + <data name="facet.seen.month" xml:space="preserve"> + <value>in de laatste 30 dagen</value> + </data> + <data name="facet.seen.older" xml:space="preserve"> + <value>langer geleden</value> + </data> + <data name="facet.seen.never" xml:space="preserve"> + <value>nooit bereikt</value> + </data> + <data name="facet.unknown.charset" xml:space="preserve"> + <value>niets onderhandeld</value> + </data> + <data name="facet.unknown.codebase" xml:space="preserve"> + <value>niet vastgesteld</value> + </data> + <data name="facet.unknown.other" xml:space="preserve"> + <value>niet opgegeven</value> + </data> + <data name="facet.tls.yes" xml:space="preserve"> + <value>verbonden via TLS</value> + </data> + <data name="facet.excluded" xml:space="preserve"> + <value>niet {value}</value> + </data> + <data name="facet.known.charset" xml:space="preserve"> + <value>iets onderhandeld</value> + </data> + <data name="facet.known.codebase" xml:space="preserve"> + <value>wel vastgesteld</value> + </data> + <data name="facet.known.other" xml:space="preserve"> + <value>wel opgegeven</value> + </data> + <data name="evidence.measured.meaning" xml:space="preserve"> + <value>we hebben dit zien gebeuren</value> + </data> + <data name="evidence.declared.meaning" xml:space="preserve"> + <value>het spel zegt het, en wij hebben het niet gecontroleerd</value> + </data> + <data name="evidence.derived.meaning" xml:space="preserve"> + <value>we hebben gegroepeerd wat het spel ons vertelde</value> + </data> + <data name="sort.name" xml:space="preserve"> + <value>naam</value> + </data> + <data name="sort.players" xml:space="preserve"> + <value>nu verbonden</value> + </data> + <data name="sort.reached" xml:space="preserve"> + <value>laatst bereikt</value> + </data> + <data name="sort.medianWeek" xml:space="preserve"> + <value>typisch verbonden · 7 dagen</value> + </data> + <data name="sort.medianMonth" xml:space="preserve"> + <value>typisch verbonden · 30 dagen</value> + </data> + <data name="sort.medianQuarter" xml:space="preserve"> + <value>typisch verbonden · 90 dagen</value> + </data> + <data name="sort.peakWeek" xml:space="preserve"> + <value>meeste tegelijk verbonden · 7 dagen</value> + </data> + <data name="sort.peakMonth" xml:space="preserve"> + <value>meeste tegelijk verbonden · 30 dagen</value> + </data> + <data name="sort.peakQuarter" xml:space="preserve"> + <value>meeste tegelijk verbonden · 90 dagen</value> + </data> + <data name="sort.group.row" xml:space="preserve"> + <value>nu op de rij</value> + </data> + <data name="sort.group.typical" xml:space="preserve"> + <value>typisch</value> + </data> + <data name="sort.group.peak" xml:space="preserve"> + <value>piek</value> + </data> + <data name="sort.unranked.players" xml:space="preserve"> + <value>Onbekende telling</value> + </data> + <data name="sort.unranked.reached" xml:space="preserve"> + <value>nog nooit bereikt — niet dat het lang geleden bereikt is</value> + </data> + <data name="sort.unranked.median" xml:space="preserve"> + <value>minder dan {minimum} tellingen in de periode, of helemaal geen — geen typische telling van nul</value> + </data> + <data name="sort.unranked.window" xml:space="preserve"> + <value>niets dat we in de periode konden tellen — niet dat er niemand verbonden was</value> + </data> + <data name="sort.window.median" xml:space="preserve"> + <value>mediaan {value} · {days, plural, one {#d} other {#d}} · {count, plural, one {# telling} other {# tellingen}}</value> + </data> + <data name="sort.window.peak" xml:space="preserve"> + <value>meeste {value} tegelijk · {days, plural, one {#d} other {#d}} · {count, plural, one {# telling} other {# tellingen}}</value> + </data> + <data name="game.connectScreen" xml:space="preserve"> + <value>Verbindingsscherm</value> + </data> + <data name="game.connectionsByHour" xml:space="preserve"> + <value>Verbindingen per uur</value> + </data> + <data name="game.howMany" xml:space="preserve"> + <value>Hoeveel, in de loop van de tijd</value> + </data> + <data name="game.reachable" xml:space="preserve"> + <value>Bereikbaar</value> + </data> + <data name="game.whatChanged" xml:space="preserve"> + <value>Wat er veranderd is</value> + </data> + <data name="game.capabilities" xml:space="preserve"> + <value>Mogelijkheden</value> + </data> + <data name="game.declaredByGame" xml:space="preserve"> + <value>Opgegeven door het spel</value> + </data> + <data name="game.referrals" xml:space="preserve"> + <value>Verwijzingen</value> + </data> + <data name="game.unclaimed" xml:space="preserve"> + <value>Niet geclaimd — alles hier is gemeten.</value> + </data> + <data name="game.claimed" xml:space="preserve"> + <value>Geclaimd door de eigenaar — de gemeten feiten hieronder blijven van ons.</value> + </data> + <data name="game.claim" xml:space="preserve"> + <value>Dit spel claimen</value> + </data> + <data name="game.answeringSince" xml:space="preserve"> + <value>antwoordt sinds {date}</value> + </data> + <data name="game.readAsTextRows" xml:space="preserve"> + <value>als tekst lezen — {count, plural, one {# rij} other {# rijen}}</value> + </data> + <data name="capability.column" xml:space="preserve"> + <value>mogelijkheid</value> + </data> + <data name="capability.age" xml:space="preserve"> + <value>leeftijd</value> + </data> + <data name="capability.offered" xml:space="preserve"> + <value>aangeboden</value> + </data> + <data name="capability.silent" xml:space="preserve"> + <value>stil</value> + </data> + <data name="capability.absent" xml:space="preserve"> + <value>afwezig</value> + </data> + <data name="capability.denied" xml:space="preserve"> + <value>geweigerd</value> + </data> + <data name="capability.claimed" xml:space="preserve"> + <value>geclaimd</value> + </data> + <data name="capability.disagrees" xml:space="preserve"> + <value>wijkt af</value> + </data> + <data name="capability.whereTheyDisagree" xml:space="preserve"> + <value>waar ze afwijken ({count})</value> + </data> + <data name="activity.cell.counted" xml:space="preserve"> + <value>{day} {time} — {count, plural, =0 {0 spelers, gemeten} one {gemiddeld # speler} other {gemiddeld # spelers}}</value> + </data> + <data name="activity.cell.notCounted" xml:space="preserve"> + <value>{day} {time} — gepeild, geen telling kon worden gelezen</value> + </data> + <data name="activity.cell.notMeasured" xml:space="preserve"> + <value>{day} {time} — geen meting in dit uur</value> + </data> + <data name="activity.none" xml:space="preserve"> + <value>We hebben de activiteit van dit spel nog niet gemeten.</value> + </data> + <data name="activity.noCount" xml:space="preserve"> + <value>Geen enkel uur van de week heeft een spelerstelling opgeleverd.</value> + </data> + <data name="activity.allZero" xml:space="preserve"> + <value>Elk uur gemeten en in geen enkel uur was er iemand verbonden.</value> + </data> + <data name="activity.gap.day" xml:space="preserve"> + <value>{count, plural, one {# uur op {day} heeft nog geen meting.} other {# uren op {day} hebben nog geen meting.}}</value> + </data> + <data name="activity.gap.week" xml:space="preserve"> + <value>{count, plural, one {# uur in de week heeft nog geen meting.} other {# uren in de week hebben nog geen meting.}}</value> + </data> + <data name="activity.uncounted.day" xml:space="preserve"> + <value>{count, plural, one {# uur op {day} antwoordde maar leverde geen telling op.} other {# uren op {day} antwoordden maar leverden geen telling op.}}</value> + </data> + <data name="activity.uncounted.week" xml:space="preserve"> + <value>{count, plural, one {# uur in de week antwoordde maar leverde geen telling op.} other {# uren in de week antwoordden maar leverden geen telling op.}}</value> + </data> + <data name="activity.busiest.everyDay" xml:space="preserve"> + <value>Elke dag het drukst, {window}.</value> + </data> + <data name="activity.busiest.everyDay.part" xml:space="preserve"> + <value>Elke dag het drukst in de {part}, {window}.</value> + </data> + <data name="activity.busiest.days" xml:space="preserve"> + <value>Het drukst op {days}, {window}.</value> + </data> + <data name="activity.busiest.days.part" xml:space="preserve"> + <value>Het drukst op {days} in de {part}, {window}.</value> + </data> + <data name="activity.quiet" xml:space="preserve"> + <value>Steevast rustig {who}, {window}.</value> + </data> + <data name="activity.quiet.part" xml:space="preserve"> + <value>Steevast rustig {who} in de {part}, {window}.</value> + </data> + <data name="activity.quiet.everyDay" xml:space="preserve"> + <value>elke dag</value> + </data> + <data name="activity.quiet.everyMeasuredDay" xml:space="preserve"> + <value>elke dag die we konden meten</value> + </data> + <data name="activity.quiet.weekdays" xml:space="preserve"> + <value>op werkdagen</value> + </data> + <data name="activity.quiet.onDays" xml:space="preserve"> + <value>op {days}</value> + </data> + <data name="activity.part.morning" xml:space="preserve"> + <value>ochtend</value> + </data> + <data name="activity.part.afternoon" xml:space="preserve"> + <value>middag</value> + </data> + <data name="activity.part.evening" xml:space="preserve"> + <value>avond</value> + </data> + <data name="activity.part.smallHours" xml:space="preserve"> + <value>nachtelijke uren</value> + </data> + <data name="activity.parts.morning" xml:space="preserve"> + <value>ochtenden</value> + </data> + <data name="activity.parts.afternoon" xml:space="preserve"> + <value>middagen</value> + </data> + <data name="activity.parts.evening" xml:space="preserve"> + <value>avonden</value> + </data> + <data name="activity.parts.smallHours" xml:space="preserve"> + <value>nachtelijke uren</value> + </data> + <data name="activity.days.list" xml:space="preserve"> + <value>{list}, {next}</value> + </data> + <data name="activity.days.pair" xml:space="preserve"> + <value>{first} en {second}</value> + </data> + <data name="activity.sparse.kicker" xml:space="preserve"> + <value>nog te weinig metingen</value> + </data> + <data name="activity.sparse.none" xml:space="preserve"> + <value>Nog geen enkel uur van de week is gemeten.</value> + </data> + <data name="activity.sparse.uncounted" xml:space="preserve"> + <value>{count, plural, one {# uur antwoordde en leverde geen telling op.} other {# uren antwoordden en leverden geen telling op.}}</value> + </data> + <data name="activity.sparse.wait" xml:space="preserve"> + <value>Het raster verschijnt zodra elke dag van de week er een heeft.</value> + </data> + <data name="activity.sparse.days" xml:space="preserve"> + <value>{days, plural, one {Tot nu toe op # van de zeven dagen gemeten; het raster verschijnt zodra elke dag een uur bevat.} other {Tot nu toe op # van de zeven dagen gemeten; het raster verschijnt zodra elke dag een uur bevat.}}</value> + </data> + <data name="activity.sample.zero" xml:space="preserve"> + <value>{count, plural, one {# uur gemeten, met niemand verbonden.} other {# uren gemeten, allemaal met niemand verbonden.}}</value> + </data> + <data name="activity.sample.peak" xml:space="preserve"> + <value>{count, plural, one {# uur gemeten, het drukst met {peak} op {day} om {time} UTC.} other {# uren gemeten, het drukst met {peak} op {day} om {time} UTC.}}</value> + </data> + <data name="activity.sample.more" xml:space="preserve"> + <value>{count, plural, one {Nog # uur antwoordde en leverde geen telling op.} other {Nog # uren antwoordden en leverden geen telling op.}}</value> + </data> + <data name="activity.day.line" xml:space="preserve"> + <value>{day} — {facts}</value> + </data> + <data name="activity.day.facts" xml:space="preserve"> + <value>{first}, {second}</value> + </data> + <data name="activity.day.allZero" xml:space="preserve"> + <value>de hele dag op nul gemeten</value> + </data> + <data name="activity.day.peak" xml:space="preserve"> + <value>piek {count} om {time}</value> + </data> + <data name="activity.day.nobodyOn" xml:space="preserve"> + <value>niemand verbonden {window}</value> + </data> + <data name="activity.day.noCount" xml:space="preserve"> + <value>in geen enkel uur een telling</value> + </data> + <data name="activity.day.notMeasured" xml:space="preserve"> + <value>{count, plural, one {# uur niet gemeten} other {# uren niet gemeten}}</value> + </data> + <data name="activity.day.notCounted" xml:space="preserve"> + <value>{count, plural, one {# uur gepeild maar niet telbaar} other {# uren gepeild maar niet telbaar}}</value> + </data> + <data name="activity.column.day" xml:space="preserve"> + <value>dag</value> + </data> + <data name="activity.column.quietest" xml:space="preserve"> + <value>rustigst</value> + </data> + <data name="activity.column.busiest" xml:space="preserve"> + <value>drukst</value> + </data> + <data name="activity.column.at" xml:space="preserve"> + <value>om</value> + </data> + <data name="activity.column.noCount" xml:space="preserve"> + <value>geen telling</value> + </data> + <data name="activity.caption" xml:space="preserve"> + <value>Spelers verbonden per dag, in UTC. {window}.</value> + </data> + <data name="activity.times" xml:space="preserve"> + <value>tijden in UTC · {window}</value> + </data> + <data name="activity.rollingAverage" xml:space="preserve"> + <value>{weeks, plural, one {voortschrijdend gemiddelde over # week} other {voortschrijdend gemiddelde over # weken}}</value> + </data> + <data name="activity.legend.counted" xml:space="preserve"> + <value>geteld, inclusief een gemeten nul</value> + </data> + <data name="activity.legend.notCounted" xml:space="preserve"> + <value>gepeild, geen telling kon worden gelezen</value> + </data> + <data name="activity.legend.notMeasured" xml:space="preserve"> + <value>geen meting in dat uur</value> + </data> + <data name="activity.plain.heading" xml:space="preserve"> + <value>Wanneer er spelers verbonden zijn (UTC)</value> + </data> + <data name="activity.key.counted" xml:space="preserve"> + <value>geteld</value> + </data> + <data name="activity.key.counted.meaning" xml:space="preserve"> + <value>we kwamen binnen en lazen een getal, inclusief een gemeten nul</value> + </data> + <data name="activity.key.uncounted.meaning" xml:space="preserve"> + <value>we kwamen binnen en er was geen getal te lezen</value> + </data> + <data name="activity.key.notMeasured.meaning" xml:space="preserve"> + <value>we hebben geen meting voor dat uur</value> + </data> + <data name="locale.label" xml:space="preserve"> + <value>taal</value> + </data> + <data name="locale.submit" xml:space="preserve"> + <value>taal wijzigen</value> + </data> + <data name="about.title" xml:space="preserve"> + <value>Over mu*index</value> + </data> + <data name="about.lede" xml:space="preserve"> + <value>Elk spel hier is gemeten door een machine die er verbinding mee maakte, en elke waarde vermeldt waar hij vandaan komt en wanneer. Deze pagina behandelt wat dat bewijst, wat we fout doen, wiens gidsen we lezen, en hoe de crawler te stoppen is.</value> + </data> + <data name="about.measures.heading" xml:space="preserve"> + <value>Wat een feit hier is</value> + </data> + <data name="about.measures.declared.lead" xml:space="preserve"> + <value>Gemeten wint van opgegeven, en beide worden getoond.</value> + </data> + <data name="about.measures.declared.body" xml:space="preserve"> + <value>Het MSSP-rapport van een spel is het spel dat zichzelf beschrijft. De telnet-handshake is wat we het hebben zien doen. Beide staan op zijn pagina, gelabeld met hoe en wanneer. Waar ze van elkaar afwijken, tonen we de afwijking.</value> + </data> + <data name="about.measures.count.lead" xml:space="preserve"> + <value>Een spelerstelling vermeldt waar hij vandaan komt.</value> + </data> + <data name="about.measures.count.body" xml:space="preserve"> + <value>Ofwel een WHO of DOING die bij het verbindingsscherm gelezen is en door ons geteld, ofwel het eigen MSSP PLAYERS-veld van het spel, dat het zelf publiceerde. Nooit samengevoegd.</value> + </data> + <data name="about.measures.unknown.lead" xml:space="preserve"> + <value>Een antwoord dat we niet kunnen lezen is onbekend, nooit nul.</value> + </data> + <data name="about.measures.unknown.body" xml:space="preserve"> + <value>Servers passen hun WHO-koppen naar believen aan, en voorbij een zeker punt kan onze parser er geen meer lezen. Dat is niet telbaar, een toestand op zichzelf. Een gemeten nul — we kwamen binnen, er was niemand — is een telling, en wordt ook als telling weergegeven.</value> + </data> + <data name="about.measures.reachable.lead" xml:space="preserve"> + <value>Bereikbaar, nooit uptime.</value> + </data> + <data name="about.measures.reachable.body" xml:space="preserve"> + <value>We openen met tussenpozen een socket vanaf één host. Een spel waarheen we geen route hebben is onbereikbaar en volkomen springlevend. Niets hier beweert iets over de uptime van een spel, omdat niets hier die gemeten heeft.</value> + </data> + <data name="about.measures.hour.lead" xml:space="preserve"> + <value>Een uur is geteld, niet telbaar, of niet gemeten.</value> + </data> + <data name="about.measures.hour.body" xml:space="preserve"> + <value>Het activiteitenraster heeft drie toestanden. De derde is leeg en noemt geen oorzaak: een uur dat we niet konden bereiken en een uur dat we nooit gepeild hebben zijn dezelfde afwezigheid, en geen van beide is downtime van die server.</value> + </data> + <data name="about.limits.heading" xml:space="preserve"> + <value>Wat we weten dat we fout doen</value> + </data> + <data name="about.limits.grace.lead" xml:space="preserve"> + <value>Het archiefrespijt wordt gemeten vanaf de dag dat we je vonden.</value> + </data> + <data name="about.limits.grace.body" xml:space="preserve"> + <value>Een spel dat stopt met antwoorden verlaat de standaardlijst na zijn respijtperiode: een kwart van de bereikbare tijd die we gepeild hebben, met een ondergrens van 60 dagen en een bovengrens van 365. Een spel dat sinds 1995 draait, begint op de ondergrens op de dag dat we het ontdekken. We importeren niets om de jaren vóór onze komst in te vullen.</value> + </data> + <data name="about.limits.created.lead" xml:space="preserve"> + <value>We laten MSSP CREATED niet meetellen voor dat respijt.</value> + </data> + <data name="about.limits.created.body" xml:space="preserve"> + <value>Het is één met de hand ingetypte regel in een configuratiebestand, dus meetellen zou de archiefdrempel manipuleerbaar maken. Het wordt als opgave getoond en koopt niets.</value> + </data> + <data name="about.limits.claim.lead" xml:space="preserve"> + <value>Een spel claimen levert de bovengrens op.</value> + </data> + <data name="about.limits.claim.body" xml:space="preserve"> + <value>Aantonen dat er servertoegang is, is het volle jaar respijt waard, hoe lang we ook al meekijken.</value> + </data> + <data name="about.limits.oneHost.lead" xml:space="preserve"> + <value>Alles hier is één host die met tussenpozen kijkt.</value> + </data> + <data name="about.limits.oneHost.body" xml:space="preserve"> + <value>Een percentage bereikbare tijd is een deel van de periode die we waarnamen, nooit van een periode die we niet waarnamen. Geen enkele grafiek hier vult de rest in.</value> + </data> + <data name="about.limits.deletion.lead" xml:space="preserve"> + <value>Er wordt nooit iets verwijderd.</value> + </data> + <data name="about.limits.deletion.body" xml:space="preserve"> + <value>Archiveren haalt een spel uit de standaardlijst, de ranglijsten en het cijfer van vandaag actief, en verder niets. Zijn pagina, URL, geschiedenis en adres blijven bestaan, het wordt nog gepeild, en één geslaagde peiling zet het terug.</value> + </data> + <data name="about.never.heading" xml:space="preserve"> + <value>Wat deze site niet zal doen</value> + </data> + <data name="about.never.votes.lead" xml:space="preserve"> + <value>Geen stemmen, sterren, beoordelingen of aanbevelingen.</value> + </data> + <data name="about.never.votes.body" xml:space="preserve"> + <value>Ranglijsten worden alleen uit gemeten gegevens berekend. Een gids die gerangschikt is naar wie de meeste klikken kan mobiliseren, beschrijft de campagne en niet de hobby, en daaraan zijn de gevestigde gidsen ten onder gegaan.</value> + </data> + <data name="about.never.forums.lead" xml:space="preserve"> + <value>Geen forums, recensies, wiki’s, reacties of spelersprofielen.</value> + </data> + <data name="about.never.forums.body" xml:space="preserve"> + <value>Oriënterend materiaal — wat een MUSH is, welke codebase past bij gezamenlijk rollenspel — wordt geschreven, ondertekend en van versies voorzien zoals de rest van de site.</value> + </data> + <data name="about.never.names.lead" xml:space="preserve"> + <value>Spelersnamen worden nooit bewaard.</value> + </data> + <data name="about.never.names.body" xml:space="preserve"> + <value>Een WHO-antwoord wordt in het geheugen ontleed op een telling en de vorm van de kop. De namen worden niet vastgelegd; aggregaten gebruiken een gezouten hash met een roulerende salt.</value> + </data> + <data name="about.never.population.lead" xml:space="preserve"> + <value>Er wordt geen absoluut spelersaantal gepubliceerd.</value> + </data> + <data name="about.never.population.body" xml:space="preserve"> + <value>Aandelen per codebase en per protocol gaan wel de deur uit: een verhouding over de gemeten verzameling overleeft de spellen die we niet kunnen tellen. ‘Hoeveel mensen spelen MU*’ overleeft dat niet, want dat getal zou het niet houden zodra het geciteerd werd.</value> + </data> + <data name="about.crawler.heading" xml:space="preserve"> + <value>De crawler, en hoe die te stoppen is</value> + </data> + <data name="about.crawler.probe.lead" xml:space="preserve"> + <value>Een peiling is één verbinding die nooit inlogt.</value> + </data> + <data name="about.crawler.probe.body" xml:space="preserve"> + <value>Die opent een socket, onderhandelt over telnet-opties, leest het verbindingsscherm, vraagt om MSSP door optie 70 te onderhandelen, stuurt {commands} en verbreekt de verbinding. Geen personage, geen login, niets veranderd aan de andere kant. Een time-out begrenst de sessie, zodat een vastgelopen peiling geen verbindingsplek bezet kan houden.</value> + </data> + <data name="about.crawler.delay.lead" xml:space="preserve"> + <value>CRAWL DELAY wint.</value> + </data> + <data name="about.crawler.delay.body" xml:space="preserve"> + <value>Een spel dat in zijn MSSP-rapport een gewenste minimale tussenpoos opgeeft, krijgt die, boven ons eigen schema in beide richtingen: 720 uur betekent maandelijks, niet wekelijks. Bij een stilgevallen spel wordt voor altijd op de langere tussenpoos aangeklopt, en zo zet het zichzelf weer in de lijst wanneer het terugkomt.</value> + </data> + <data name="about.crawler.referral.lead" xml:space="preserve"> + <value>Een doorverwezen adres wordt geverifieerd, nooit vertrouwd.</value> + </data> + <data name="about.crawler.referral.body" xml:space="preserve"> + <value>Met MSSP kan een spel andere spellen noemen. Elke naam wordt opgelost voordat er ergens wordt aangeklopt, en geweigerd tenzij elk adres waarnaar hij oplost wereldwijd routeerbaar is. Een gemengd antwoord weigert het hele doel. Onze weigering wordt als de onze vastgelegd en verschijnt nooit als downtime in het dossier van een spel.</value> + </data> + <data name="about.crawler.screens.lead" xml:space="preserve"> + <value>Verbindingsschermen worden getoond omdat ze naar iedereen gestuurd worden.</value> + </data> + <data name="about.crawler.screens.body" xml:space="preserve"> + <value>Een server tekent zijn verbindingsscherm, zonder authenticatie, naar elke anonieme verbinding. We tonen het als bewijs en labelen het. Eén verzoek en het gaat eraf.</value> + </data> + <data name="about.crawler.stop.lead" xml:space="preserve"> + <value>Zeg stop, en we stoppen — op drie manieren.</value> + </data> + <data name="about.crawler.stop.body" xml:space="preserve"> + <value>Publiceer {variable} 1 in je MSSP-rapport, en de peiling die dat leest is de laatste. Of publiceer een TXT-record op {label}.jouw.host met de inhoud ‘{value}’, waarvoor geen MSSP-ondersteuning en geen account hier nodig is. Of schrijf een mens aan. Alle drie worden binnen één crawlcyclus gehonoreerd, vastgelegd met de datum en met wat we lazen, en ook op het aanmeldformulier afgedwongen.</value> + </data> + <data name="about.crawler.scope.lead" xml:space="preserve"> + <value>Het MSSP-veld stopt die luisterpoort; het record stopt de host.</value> + </data> + <data name="about.crawler.scope.body" xml:space="preserve"> + <value>MSSP wordt gepubliceerd door de poort die antwoordde, dus spreekt het voor die poort — bij MU*-hosting draaien routinematig ongerelateerde spellen op één domein, en het ene mag het andere niet het zwijgen opleggen. Een TXT-record geldt voor elke poort tenzij het er een noemt, als ‘{value}=4201’. Alles wat daar staat en wat we niet als poortenlijst kunnen lezen betekent de hele host, dus ‘{value}=all’ werkt.</value> + </data> + <data name="about.crawler.dns.lead" xml:space="preserve"> + <value>De DNS-route is de enige die je ongedaan kunt maken zonder het ons te vragen.</value> + </data> + <data name="about.crawler.dns.body" xml:space="preserve"> + <value>Een TXT-record is leesbaar zonder verbinding te maken met een server die dat verboden heeft, dus we lezen het opnieuw voordat we aankloppen. Verwijder het en we kloppen binnen een week weer aan. Een MSSP-veld kan niet opnieuw gelezen worden zonder precies te doen wat je ons gevraagd hebt te laten, dus afmeldingen via MSSP en schriftelijke verzoeken blijven staan tot je het tegendeel zegt. Die TXT-opzoeking is alles wat een afgemeld adres krijgt: ze raakt je nameserver, nooit je spel.</value> + </data> + <data name="about.crawler.stopping.lead" xml:space="preserve"> + <value>Stoppen is niet verwijderen, en het is geen downtime.</value> + </data> + <data name="about.crawler.stopping.body" xml:space="preserve"> + <value>Een spel dat zich afmeldt, houdt zijn pagina, zijn adres en alles wat we gemeten hebben voordat het erom vroeg. Alleen nieuwe gegevens stoppen: het activiteitenraster krijgt er geen uren meer bij en noemt geen oorzaak, want ons besluit om te stoppen met kloppen is een feit over ons. Het wordt vastgelegd bij de crawl die niet plaatsvond, en in het register van wie erom vroeg.</value> + </data> + <data name="about.crawler.unlist.lead" xml:space="preserve"> + <value>Als stoppen niet genoeg is, kan de vermelding er ook af.</value> + </data> + <data name="about.crawler.unlist.body" xml:space="preserve"> + <value>Zodra we gestopt zijn op elk adres waarop je spel antwoordt, biedt je dashboard nog één ding: het uit de lijst, de ranglijsten en het dagcijfer halen. De pagina en elk adres dat het ooit gehad heeft blijven antwoorden, en er wordt niets verwijderd — het houdt op een plek te zijn waar een lezer al bladerend aankomt. Er is een geverifieerde claim voor nodig, want het is een besluit over je spel en we leggen vast wie het genomen heeft. En een peiling maakt het ongedaan: trek je afmelding in, en de eerstvolgende keer dat er aangeklopt wordt en er antwoord komt, sta je weer in de lijst zonder dat je het ons nog eens hoeft te vragen.</value> + </data> + <data name="about.identity.announced" xml:space="preserve"> + <value>De crawler noemt zichzelf {name} wanneer een server vraagt wat hij is.</value> + </data> + <data name="about.identity.unannounced" xml:space="preserve"> + <value>De crawler is ingesteld om zichzelf {name} te noemen, maar kan dat nog niet zeggen. Zijn telnet-bibliotheek biedt een client geen manier om het terminaltype in te stellen, dus je logboeken zien de standaardwaarde van die bibliotheek, en NEW-ENVIRON wordt beantwoord vanuit de omgeving van de crawlerhost. Beide zijn gaten in de bibliotheek en aan ons om ze daar te dichten. Tot die tijd: herken een peiling aan de vorm ervan — één verbinding, geen login, een korte set alleen-lezen-commando’s, weg.</value> + </data> + <data name="about.identity.crawler" xml:space="preserve"> + <value>crawler</value> + </data> + <data name="about.identity.contact" xml:space="preserve"> + <value>contact</value> + </data> + <data name="about.identity.crawler.line" xml:space="preserve"> + <value>Crawler: {name}</value> + </data> + <data name="about.identity.contact.line" xml:space="preserve"> + <value>Contact: {url}</value> + </data> + <data name="about.identity.placeholder" xml:space="preserve"> + <value>— tijdelijke aanduiding; deze installatie heeft geen contactadres ingesteld</value> + </data> + <data name="about.identity.placeholder.plain" xml:space="preserve"> + <value>Er is geen contactadres ingesteld, dus het adres hierboven is een tijdelijke aanduiding en beantwoordt niemand.</value> + </data> + <data name="about.sources.heading" xml:space="preserve"> + <value>Waar de lijst met spellen vandaan komt</value> + </data> + <data name="about.sources.addresses.lead" xml:space="preserve"> + <value>We nemen adressen over. Verder niets.</value> + </data> + <data name="about.sources.addresses.body" xml:space="preserve"> + <value>Een backfill haalt een host en een poort op. Geen spelerstellingen, geen bereikbaarheidsgeschiedenis, geen beschrijvingen, geen velden, en geen aantekening van welke site een adres kwam.</value> + </data> + <data name="about.sources.less.lead" xml:space="preserve"> + <value>Bewust minder dan die sites kunnen geven.</value> + </data> + <data name="about.sources.less.body" xml:space="preserve"> + <value>Verschillende bewaren jaren aan gedateerde spelerstellingen. Dat importeren zou de heatmaps vullen van de spellen die iemand anders al in de gaten hield, en de centrale claim van deze site laten steunen op de peilingen van een ander.</value> + </data> + <data name="about.sources.origin.lead" xml:space="preserve"> + <value>De herkomst van een spel is niet één feit.</value> + </data> + <data name="about.sources.origin.body" xml:space="preserve"> + <value>Elk spel dat het vermelden waard is, staat in meerdere van deze gidsen, dus ‘geïmporteerd uit’ zou noemen welke ophaalronde toevallig het eerst liep. Dat een spel bestaat is openbare informatie; waar we het gelezen hebben voegt niets toe en is het deel van andermans werk waarop wij de minste aanspraak hebben.</value> + </data> + <data name="about.sources.etiquette.lead" xml:space="preserve"> + <value>Andermans site lezen blijft andermans site lezen.</value> + </data> + <data name="about.sources.etiquette.body" xml:space="preserve"> + <value>We vragen om een bulkexport of een gedocumenteerd endpoint voordat we scrapen, lezen eerst robots.txt, en beperken de snelheid van scrapes streng. Een bron waarvoor toestemming van de beheerder nodig is, wordt niet opgehaald tot een mens kan verklaren dat het gevraagd is.</value> + </data> + <data name="about.source.read" xml:space="preserve"> + <value>gelezen — alleen adressen</value> + </data> + <data name="about.source.withheld" xml:space="preserve"> + <value>niet gelezen — wacht op toestemming</value> + </data> + <data name="about.source.tintinMssp.note" xml:space="preserve"> + <value>Eén pagina, één verzoek. Gepubliceerd door een crawler die met elk spel verbinding maakt en afdrukt wat hij las.</value> + </data> + <data name="about.source.tintinMsdp.note" xml:space="preserve"> + <value>De MSDP-lijst van dezelfde crawler. Bijna een deelverzameling van zijn MSSP-tegenhanger, gelezen om de paar adressen die hij wel bereikt en de andere niet.</value> + </data> + <data name="about.source.mudConnector.note" xml:space="preserve"> + <value>Publiceert zijn hele catalogus op één pagina, dus het lezen ervan kost één verzoek. Onze grootste bron van adressen, en van geen enkele meting.</value> + </data> + <data name="about.source.mudStats.note" xml:space="preserve"> + <value>Eén indexpagina en één pagina per wereld, dus een scrape in plaats van een export. Op 30 juli 2026 hebben we 143 van hun pagina’s opgehaald, met vijftien seconden ertussen en met inachtneming van robots.txt, maar voordat iemand hun geschreven had. Dat had niet mogen gebeuren. De poort vraagt nu om een mens die wil verklaren dat de beheerder gevraagd is.</value> + </data> + <data name="about.source.mudVerse.note" xml:space="preserve"> + <value>Geïmplementeerd, getest, nooit uitgevoerd. De sterkste bron hier op elke as behalve toestemming, en er wordt niets opgehaald tot iemand hun geschreven heeft.</value> + </data> + <data name="about.licence.heading" xml:space="preserve"> + <value>Licentie</value> + </data> + <data name="about.licence.code.lead" xml:space="preserve"> + <value>De code is MIT.</value> + </data> + <data name="about.licence.code.body" xml:space="preserve"> + <value>De site, de crawler en de parsers zijn opensource onder de MIT-licentie.</value> + </data> + <data name="about.licence.open.lead" xml:space="preserve"> + <value>De licentie voor de gegevens is een open vraag.</value> + </data> + <data name="about.licence.open.body" xml:space="preserve"> + <value>Een besluit los van dat over de code, en nog niet genomen. Lees de voorwaarden hieronder als het huidige antwoord van deze installatie, niet als het vastgelegde standpunt van het project. Dat een concurrerende gids de hele catalogus overneemt geldt hier als succes, dus wat er ook wordt vastgelegd, het zal zo’n gids niet in de weg staan.</value> + </data> + <data name="about.licence.codeLabel" xml:space="preserve"> + <value>code</value> + </data> + <data name="about.licence.dataLabel" xml:space="preserve"> + <value>gegevens, zoals deze installatie ze aanbiedt</value> + </data> + <data name="about.licence.creditLabel" xml:space="preserve"> + <value>vermelden als</value> + </data> + <data name="about.licence.code.line" xml:space="preserve"> + <value>Code: {licence}</value> + </data> + <data name="about.licence.data.line" xml:space="preserve"> + <value>Gegevens: {licence}</value> + </data> + <data name="about.licence.credit.line" xml:space="preserve"> + <value>Vermelden als: {credit}</value> + </data> + <data name="about.licence.deployment" xml:space="preserve"> + <value>(wat deze installatie aanbiedt. Het antwoord van het project zelf ligt nog open.)</value> + </data> + <data name="submit.title" xml:space="preserve"> + <value>Een spel aanmelden</value> + </data> + <data name="submit.lede" xml:space="preserve"> + <value>Vertel ons waar een spel staat. Een host en een poort zijn het hele formulier; al het andere op deze site wordt door onze eigen crawler gemeten.</value> + </data> + <data name="submit.host.label" xml:space="preserve"> + <value>Host</value> + </data> + <data name="submit.port.label" xml:space="preserve"> + <value>Poort</value> + </data> + <data name="submit.host.hint" xml:space="preserve"> + <value>mud.example.org, of plak mud.example.org:4201 en laat de poort leeg</value> + </data> + <data name="submit.button" xml:space="preserve"> + <value>Aanmelden</value> + </data> + <data name="submit.noCatalogue" xml:space="preserve"> + <value>Aanmelden vereist een database, en deze site draait op de demofixture. Er is geen crawlregister om in te schrijven, dus het formulier ontbreekt in plaats van stilletjes niets te doen.</value> + </data> + <data name="submit.notHere" xml:space="preserve"> + <value>Niet hier</value> + </data> + <data name="submit.what.heading" xml:space="preserve"> + <value>Wat er met een adres gebeurt</value> + </data> + <data name="submit.what.resolve" xml:space="preserve"> + <value>We lossen het adres op voordat we aankloppen, en weigeren alles wat buiten het publieke internet uitkomt. Dat is een besluit over onze eigen socket, nooit een feit over een spel.</value> + </data> + <data name="submit.what.optOut" xml:space="preserve"> + <value>Als degene die die host draait ons gevraagd heeft er niet te crawlen, nemen we het adres niet aan, door wie het ook wordt aangemeld. Een vreemde kan je spel niet terugzetten op deze site.</value> + </data> + <data name="submit.what.schedule" xml:space="preserve"> + <value>Als het antwoordt, lezen we wat de server over zichzelf zegt en blijven we dat lezen op zijn eigen schema, voor altijd. Een adres hoeft maar één keer gegeven te worden.</value> + </data> + <data name="submit.what.claim" xml:space="preserve"> + <value>Er verschijnt niets op de site voordat iemand bewezen heeft het te draaien. Claimen vereist een passkey en één regel die op het spel zelf gepubliceerd wordt.</value> + </data> + <data name="submit.what.duplicate" xml:space="preserve"> + <value>Een adres dat we al hebben valt samen met de bestaande vermelding. Het twee keer sturen levert geen tweede vermelding op en haalt geen peiling naar voren.</value> + </data> + <data name="submit.answer.thatAddress" xml:space="preserve"> + <value>dat adres</value> + </data> + <data name="submit.accepted.heading" xml:space="preserve"> + <value>In het register.</value> + </data> + <data name="submit.accepted.sentence" xml:space="preserve"> + <value>Bij {address} wordt in de volgende crawlcyclus aangeklopt, daarna op zijn eigen schema, voor altijd. Het verschijnt hier zodra iemand bewijst het te draaien — kom met hetzelfde adres terug naar dit formulier en het geeft je de link.</value> + </data> + <data name="submit.unclaimed.heading" xml:space="preserve"> + <value>We hebben het, niet geclaimd.</value> + </data> + <data name="submit.unclaimed.sentence" xml:space="preserve"> + <value>{address} is er een die we al meten. Het blijft van de site af tot iemand bewijst het te draaien. Ben jij dat, dan is dit de weg naar binnen.</value> + </data> + <data name="submit.known.heading" xml:space="preserve"> + <value>Die hebben we al.</value> + </data> + <data name="submit.known.sentence" xml:space="preserve"> + <value>{address} is een spel dat we al meten. Er is niets aangemaakt en niets gewijzigd.</value> + </data> + <data name="submit.knownAddress.heading" xml:space="preserve"> + <value>Dat adres hebben we al.</value> + </data> + <data name="submit.knownAddress.sentence" xml:space="preserve"> + <value>{address} is bij ons al bekend. Er is niets aangemaakt en niets gewijzigd.</value> + </data> + <data name="submit.queued.heading" xml:space="preserve"> + <value>Staat al te wachten.</value> + </data> + <data name="submit.queued.sentence" xml:space="preserve"> + <value>{address} staat in het crawlregister en heeft nog niet geantwoord. Het opnieuw sturen haalt het niet naar voren: een doel houdt zijn eigen schema aan, dus niemand kan ons opjagen bij andermans server.</value> + </data> + <data name="submit.malformed.heading" xml:space="preserve"> + <value>Geen adres waar we kunnen aankloppen.</value> + </data> + <data name="submit.malformed.sentence" xml:space="preserve"> + <value>Een host heeft een punt of een dubbele punt nodig, en een poort is een getal tussen 1 en 65535. Vul beide velden in, of plak mud.example.org:4201 in het eerste.</value> + </data> + <data name="submit.undialable.heading" xml:space="preserve"> + <value>Daar kunnen we niet aankloppen.</value> + </data> + <data name="submit.undialable.sentence" xml:space="preserve"> + <value>Drie dingen leveren dit antwoord op voor {address}: de naam wordt misschien niet opgelost, hij komt misschien buiten het publieke internet uit, of degene die die host draait heeft ons misschien gevraagd weg te blijven. We zeggen bewust niet welke, want dat voor een vreemde beantwoorden brengt een netwerk van buitenaf in kaart. Er is niets over het adres vastgelegd; het besluit was het onze en het is als het onze vastgelegd.</value> + </data> + <data name="submit.tooMany.heading" xml:space="preserve"> + <value>Genoeg voor nu.</value> + </data> + <data name="submit.tooMany.sentence" xml:space="preserve"> + <value>Dit formulier is per afzender in snelheid beperkt, en je hebt de grens bereikt. Kom over een uur terug. Er is niets verloren gegaan — alles wat we aangenomen hebben staat al in het register.</value> + </data> + <data name="submit.link.claim" xml:space="preserve"> + <value>dit spel claimen</value> + </data> + <data name="account.signIn.title" xml:space="preserve"> + <value>Inloggen</value> + </data> + <data name="account.signIn.preview" xml:space="preserve"> + <value>Log in met een passkey om een spel te claimen dat je zelf draait. Er is geen wachtwoord om kwijt te raken en geen om te stelen.</value> + </data> + <data name="account.signIn.noDatabase" xml:space="preserve"> + <value>Claimen vereist een database, en deze site draait op de demofixture. Er is niets om op in te loggen.</value> + </data> + <data name="account.signIn.passkey.lead" xml:space="preserve"> + <value>Inloggen gaat met een passkey.</value> + </data> + <data name="account.signIn.passkey.body" xml:space="preserve"> + <value>Je apparaat of wachtwoordmanager houdt de privésleutel; wij houden alleen de publieke helft. Geen wachtwoord, geen e-mail.</value> + </data> + <data name="account.signIn.button" xml:space="preserve"> + <value>Inloggen met een passkey</value> + </data> + <data name="account.signIn.script" xml:space="preserve"> + <value>De enige pagina hier die JavaScript nodig heeft. Passkeys werken er niet zonder.</value> + </data> + <data name="account.register.heading" xml:space="preserve"> + <value>Nog geen account?</value> + </data> + <data name="account.register.lede" xml:space="preserve"> + <value>Je hebt er alleen een nodig om een spel te claimen dat je zelf draait. Kies een naam om onder bekend te staan — een label naast je claim, geen echte naam.</value> + </data> + <data name="account.register.name.label" xml:space="preserve"> + <value>Naam</value> + </data> + <data name="account.register.name.placeholder" xml:space="preserve"> + <value>bijv. corvid-admin</value> + </data> + <data name="account.register.button" xml:space="preserve"> + <value>Een account aanmaken met een passkey</value> + </data> + <data name="account.store.heading" xml:space="preserve"> + <value>Wat we opslaan</value> + </data> + <data name="account.store.name" xml:space="preserve"> + <value>De naam die je gekozen hebt.</value> + </data> + <data name="account.store.keys" xml:space="preserve"> + <value>De publieke sleutel van elke passkey die je registreert, en hoe je apparaat die noemde.</value> + </data> + <data name="account.store.claims" xml:space="preserve"> + <value>Welke spellen je geclaimd hebt, en wanneer.</value> + </data> + <data name="account.store.note" xml:space="preserve"> + <value>Geen e-mailadres, geen wachtwoord, geen IP-log gekoppeld aan je account. Raak je elke passkey kwijt, dan kun je een nieuw claimtoken op je spel publiceren en opnieuw beginnen: het spel is het bewijs, niet het account.</value> + </data> + <data name="date.absolute" xml:space="preserve"> + <value>{day} {month} {year}</value> + </data> + <data name="date.stamp" xml:space="preserve"> + <value>{date} {time} UTC</value> + </data> + <data name="age.short.now" xml:space="preserve"> + <value>nu</value> + </data> + <data name="age.short.minutes" xml:space="preserve"> + <value>{count, plural, one {#m} other {#m}}</value> + </data> + <data name="age.short.hours" xml:space="preserve"> + <value>{count, plural, one {#u} other {#u}}</value> + </data> + <data name="age.short.days" xml:space="preserve"> + <value>{count, plural, one {#d} other {#d}}</value> + </data> + <data name="age.short.weeks" xml:space="preserve"> + <value>{count, plural, one {#w} other {#w}}</value> + </data> + <data name="age.short.months" xml:space="preserve"> + <value>{count, plural, one {#mnd} other {#mnd}}</value> + </data> + <data name="age.short.years" xml:space="preserve"> + <value>{count, plural, one {#j} other {#j}}</value> + </data> + <data name="age.ago.now" xml:space="preserve"> + <value>zojuist</value> + </data> + <data name="age.ago.minutes" xml:space="preserve"> + <value>{count, plural, one {#m geleden} other {#m geleden}}</value> + </data> + <data name="age.ago.hours" xml:space="preserve"> + <value>{count, plural, one {#u geleden} other {#u geleden}}</value> + </data> + <data name="age.ago.days" xml:space="preserve"> + <value>{count, plural, one {#d geleden} other {#d geleden}}</value> + </data> + <data name="age.ago.weeks" xml:space="preserve"> + <value>{count, plural, one {#w geleden} other {#w geleden}}</value> + </data> + <data name="age.ago.months" xml:space="preserve"> + <value>{count, plural, one {#mnd geleden} other {#mnd geleden}}</value> + </data> + <data name="age.ago.years" xml:space="preserve"> + <value>{count, plural, one {#j geleden} other {#j geleden}}</value> + </data> + <data name="age.dark.now" xml:space="preserve"> + <value>zojuist</value> + </data> + <data name="age.dark.minutes" xml:space="preserve"> + <value>{count, plural, one {#m geleden} other {#m geleden}}</value> + </data> + <data name="age.dark.hours" xml:space="preserve"> + <value>{count, plural, one {#u geleden} other {#u geleden}}</value> + </data> + <data name="age.dark.days" xml:space="preserve"> + <value>{count, plural, one {#d geleden} other {#d geleden}}</value> + </data> + <data name="age.dark.weeks" xml:space="preserve"> + <value>{count, plural, one {#w geleden} other {#w geleden}}</value> + </data> + <data name="age.dark.months" xml:space="preserve"> + <value>{count, plural, one {#mnd geleden} other {#mnd geleden}}</value> + </data> + <data name="age.dark.years" xml:space="preserve"> + <value>{count, plural, one {#j geleden} other {#j geleden}}</value> + </data> + <data name="time.title" xml:space="preserve"> + <value>{age}, {stamp}</value> + </data> + <data name="time.spoken" xml:space="preserve"> + <value>, {stamp}</value> + </data> + <data name="chip.title" xml:space="preserve"> + <value>{value} — {how} via {source}, laatst bevestigd {date}</value> + </data> + <data name="chip.title.stale" xml:space="preserve"> + <value>{value} — {how} via {source}, laatst bevestigd {date} (voorbij de verwachte verversing)</value> + </data> + <data name="chip.plain" xml:space="preserve"> + <value>({how}, {age})</value> + </data> + <data name="chip.plain.stale" xml:space="preserve"> + <value>({how}, {age}, verouderd)</value> + </data> + <data name="provenance.game.ownerDeclared" xml:space="preserve"> + <value>opgegeven door de eigenaar</value> + </data> + <data name="source.staff" xml:space="preserve"> + <value>de redactie</value> + </data> + <data name="source.handshake" xml:space="preserve"> + <value>de telnet-handshake</value> + </data> + <data name="source.owner" xml:space="preserve"> + <value>de eigenaar</value> + </data> + <data name="source.who" xml:space="preserve"> + <value>WHO</value> + </data> + <data name="source.i3" xml:space="preserve"> + <value>I3</value> + </data> + <data name="source.mssp" xml:space="preserve"> + <value>MSSP</value> + </data> + <data name="source.info" xml:space="preserve"> + <value>INFO</value> + </data> + <data name="source.i3Mudlist" xml:space="preserve"> + <value>de I3-mudlist</value> + </data> + <data name="source.banner" xml:space="preserve"> + <value>het verbindingsscherm</value> + </data> + <data name="ecosystem.title" xml:space="preserve"> + <value>Het ecosysteem</value> + </data> + <data name="ecosystem.noTotals" xml:space="preserve"> + <value>Aandelen, nooit totalen. We publiceren geen cijfer voor hoeveel mensen MU* spelen: een verhouding over de spellen die we gemeten hebben overleeft de spellen die we niet kunnen bereiken, en een koppentelling niet.</value> + </data> + <data name="ecosystem.listed" xml:space="preserve"> + <value>{count, plural, one {{value} spel vermeld} other {{value} spellen vermeld}}</value> + </data> + <data name="ecosystem.handshakes" xml:space="preserve"> + <value>{count, plural, one {{value} spel waarvan we de handshake voltooiden} other {{value} spellen waarvan we de handshake voltooiden}}</value> + </data> + <data name="ecosystem.msspReports" xml:space="preserve"> + <value>{count, plural, one {{value} spel waarvan we het MSSP-rapport hebben} other {{value} spellen waarvan we het MSSP-rapport hebben}}</value> + </data> + <data name="ecosystem.oldestHandshake" xml:space="preserve"> + <value>Oudste handshake hier: {age} geleden bevestigd.</value> + </data> + <data name="ecosystem.share" xml:space="preserve"> + <value>{count, number} van {total, number} ({fraction, number, ::percent .0})</value> + </data> + <data name="ecosystem.share.nothing" xml:space="preserve"> + <value>{count, number} van {total, number} — nog niets gemeten</value> + </data> + <data name="ecosystem.share.percent" xml:space="preserve"> + <value>{fraction, number, ::percent .0}</value> + </data> + <data name="ecosystem.codebases.title" xml:space="preserve"> + <value>Codebases</value> + </data> + <data name="ecosystem.codebases.basis" xml:space="preserve"> + <value>Van de {listed, plural, one {# vermelde spel} other {# vermelde spellen}} hebben er {identified, number} ons verteld waarop ze draaien, en elk aandeel hieronder gaat over die {identified, number}. Een codebase die we niet konden lezen valt buiten de noemer, en wordt nooit als iets anders geteld.</value> + </data> + <data name="ecosystem.codebases.none" xml:space="preserve"> + <value>Nog geen vermeld spel heeft ons zijn codebase verteld.</value> + </data> + <data name="ecosystem.soleUse" xml:space="preserve"> + <value>{share} draait op een codebase die geen enkel ander vermeld spel draait — één spel per stuk, wat een naam is en geen aandeel. Ze vallen binnen de noemer hierboven en zijn uit de balken gevouwen, niet weggelaten:</value> + </data> + <data name="ecosystem.lineages.title" xml:space="preserve"> + <value>Afstammingen</value> + </data> + <data name="ecosystem.lineages.basis" xml:space="preserve"> + <value>Dezelfde spellen, gegroepeerd naar de traditie waar hun server van afstamt — onze lezing van de codebase, niet iets wat een spel gepubliceerd heeft. Geen enkel spel meldt ‘MUSH’: MSSP kent die waarde niet, en het grootste deel van de MUSH-wereld publiceert helemaal geen MSSP, dus alleen zo kan de vraag gesteld worden.</value> + </data> + <data name="ecosystem.lineages.none" xml:space="preserve"> + <value>Nog geen vermeld spel draait op een codebase die we in een afstamming plaatsen.</value> + </data> + <data name="ecosystem.lineages.notClassified" xml:space="preserve"> + <value>{count, plural, one {# van die spellen draait op een codebase} other {# van die spellen draaien op codebases}} die we in geen enkele afstamming plaatsen — verschillende zeggen dat zelf ook, door {family} te publiceren. Ze vallen binnen de noemer hierboven en in niemands aandeel.</value> + </data> + <data name="ecosystem.protocols.title" xml:space="preserve"> + <value>Protocollen</value> + </data> + <data name="ecosystem.protocols.floor" xml:space="preserve"> + <value>Lees elk gemeten cijfer hieronder als een ondergrens. We vragen MSSP met name aan, dus stilte daar is een antwoord. Om de rest hier wordt niet gevraagd, en een server kan een protocol ondersteunen zonder het ooit aan te bieden.</value> + </data> + <data name="ecosystem.mssp.instrument" xml:space="preserve"> + <value>{instrument} is de enige rij hieronder die geen ondergrens is: we vragen elke server er met name om, dus de spellen die het niet aanboden zijn gevraagd en hebben geweigerd. Het is ook de enige zonder opgegeven cijfer, want elk spel waarvan we het rapport hebben ondersteunt het bij wijze van bewijs, en een telling van de spellen die het ook vermeldden zou daartegen een gewoonte meten.</value> + </data> + <data name="ecosystem.mssp.gap" xml:space="preserve"> + <value>We hebben {reports, number} rapporten en {offered, plural, one {# spel biedt} other {# spellen bieden}} MSSP vandaag aan: de andere {gap, number} zijn gestopt met publiceren nadat we het gelezen hadden, en een rapport wordt niet weggegooid omdat het niet meer opnieuw uitgegeven wordt.</value> + </data> + <data name="ecosystem.protocols.caption" xml:space="preserve"> + <value>Protocoladoptie. Gemeten is wat een server aanbood in een voltooide handshake; opgegeven is wat zijn MSSP beweert. Twee verzamelingen spellen, dus twee noemers.</value> + </data> + <data name="ecosystem.column.protocol" xml:space="preserve"> + <value>protocol</value> + </data> + <data name="ecosystem.column.measured" xml:space="preserve"> + <value>gemeten — van {basis}</value> + </data> + <data name="ecosystem.column.declared" xml:space="preserve"> + <value>opgegeven — van {basis}</value> + </data> + <data name="ecosystem.measured.never" xml:space="preserve"> + <value>niet gemeten — nooit waargenomen</value> + </data> + <data name="ecosystem.measured.declined" xml:space="preserve"> + <value>{share} · {declined, plural, one {# spel weigerde toen we het vroegen} other {# spellen weigerden toen we het vroegen}}</value> + </data> + <data name="ecosystem.measured.unasked" xml:space="preserve"> + <value>{share} · {unobserved, plural, one {bij # spel niet aangeboden en niet gevraagd} other {bij # spellen niet aangeboden en niet gevraagd}}</value> + </data> + <data name="ecosystem.measured.declinedAndUnasked" xml:space="preserve"> + <value>{share} · {declined, plural, one {# spel weigerde toen we het vroegen} other {# spellen weigerden toen we het vroegen}} · {unobserved, plural, one {bij # spel niet aangeboden en niet gevraagd} other {bij # spellen niet aangeboden en niet gevraagd}}</value> + </data> + <data name="ecosystem.declared.none" xml:space="preserve"> + <value>niet gevraagd — elk rapport hier is het antwoord</value> + </data> + <data name="ecosystem.curve.title" xml:space="preserve"> + <value>Adoptie, in de loop van de tijd</value> + </data> + <data name="ecosystem.curve.caveat" xml:space="preserve"> + <value>Elk punt is een aandeel over de spellen die we die dag gemeten hadden, dus deze lijn beweegt om twee redenen: doordat een spel verandert wat het aanbiedt, en doordat de verzameling spellen die we kunnen meten eromheen verandert. Alleen het eerste is adoptie. De telling van veranderingen hieronder is het deel dat puur spellen zijn die van gedachten veranderen.</value> + </data> + <data name="ecosystem.curve.caption" xml:space="preserve"> + <value>Gemeten aandeel van elk protocol, oudste meting eerst</value> + </data> + <data name="ecosystem.curve.then" xml:space="preserve"> + <value>toen</value> + </data> + <data name="ecosystem.curve.now" xml:space="preserve"> + <value>nu</value> + </data> + <data name="ecosystem.curve.notMeasured" xml:space="preserve"> + <value>niet gemeten</value> + </data> + <data name="ecosystem.snapshot.title" xml:space="preserve"> + <value>Een momentopname, geen curve</value> + </data> + <data name="ecosystem.snapshot" xml:space="preserve"> + <value>Een momentopname van wat we nu kunnen meten. Een adoptiecurve zet spellen uit die van gedachten veranderen, en we leggen een verandering vast wanneer die gebeurt, dus de curve wordt tekenbaar zodra er genoeg vastgelegd zijn. Uitzetten wanneer we elk spel voor het eerst bereikten zou de crawl meten, niet de hobby.</value> + </data> + <data name="ecosystem.transitions" xml:space="preserve"> + <value>{count, plural, one {# wijziging in mogelijkheden} other {# wijzigingen in mogelijkheden}} tot nu toe vastgelegd — het materiaal waaruit een curve getekend wordt.</value> + </data> + <data name="ecosystem.transitions.none" xml:space="preserve"> + <value>Er is nog geen gemeten mogelijkheid veranderd, dus er valt niets uit te zetten.</value> + </data> + <data name="ecosystem.plain.denominators" xml:space="preserve"> + <value>Gemeten is van {measured}; opgegeven is van {declared}. Twee verzamelingen spellen, dus twee noemers.</value> + </data> + <data name="ecosystem.plain.counts" xml:space="preserve"> + <value>{listed} · {handshakes} · {mssp}.</value> + </data> + <data name="ecosystem.plain.oldestHandshake" xml:space="preserve"> + <value>De oudste handshake in dit beeld is {age} geleden voor het laatst bevestigd.</value> + </data> + <data name="ecosystem.plain.lineages" xml:space="preserve"> + <value>Dezelfde spellen, gegroepeerd naar de traditie waar hun server van afstamt. Dit is {evidence} — {meaning} — en niet iets wat een spel gepubliceerd heeft: geen enkel spel meldt ‘MUSH’, want MSSP kent die waarde niet en het grootste deel van de MUSH-wereld publiceert helemaal geen MSSP.</value> + </data> + <data name="ecosystem.plain.measured" xml:space="preserve"> + <value>gemeten: {value}</value> + </data> + <data name="ecosystem.plain.declared" xml:space="preserve"> + <value>opgegeven: {value}</value> + </data> + <data name="rankings.title" xml:space="preserve"> + <value>Ranglijsten</value> + </data> + <data name="rankings.noVote" xml:space="preserve"> + <value>Alleen berekend uit gemeten gegevens. Nooit stemmen, sterren of beoordelingen. Niets hier rangschikt kwaliteit. Die hebben we niet gemeten.</value> + </data> + <data name="rankings.busiest.title" xml:space="preserve"> + <value>Drukst, naar gemeten gelijktijdige spelers</value> + </data> + <data name="rankings.window.label" xml:space="preserve"> + <value>Ranglijstperiode</value> + </data> + <data name="rankings.span" xml:space="preserve"> + <value>{days, plural, one {# dag} other {# dagen}}</value> + </data> + <data name="rankings.basis.median" xml:space="preserve"> + <value>Mediaan van de spelerstellingen die we over de laatste {days, plural, one {# dag} other {# dagen}} gemeten hebben.</value> + </data> + <data name="rankings.basis.none" xml:space="preserve"> + <value>Nog geen spel heeft de {samples, number} tellingen over {days, plural, one {# dag} other {# dagen}} die een mediaan nodig heeft.</value> + </data> + <data name="rankings.basis.eligible" xml:space="preserve"> + <value>Van de {listed, number} spellen {eligible, plural, one {heeft # spel} other {hebben # spellen}} de {samples, number} tellingen over {days, plural, one {# dag} other {# dagen}} die daarvoor nodig zijn.</value> + </data> + <data name="rankings.basis.zero" xml:space="preserve"> + <value>Een gemeten nul telt mee; een onleesbare telling niet.</value> + </data> + <data name="rankings.spanChoice" xml:space="preserve"> + <value>Een week zegt wie er nu druk is; een kwartaal zegt wie druk is geweest. Dat zijn verschillende vragen, en een spel kan de ene aanvoeren en de andere niet. Dagen zijn hele dagen, UTC.</value> + </data> + <data name="rankings.busiest.empty" xml:space="preserve"> + <value>Nog geen vermeld spel heeft genoeg tellingen om te rangschikken — een uitspraak over hoe lang we al meten, niet over hoe druk het ergens is.</value> + </data> + <data name="rankings.busiest.caption" xml:space="preserve"> + <value>Spellen gerangschikt naar de mediaan van de spelerstellingen die we over de laatste {days, plural, one {# dag} other {# dagen}} gemeten hebben. Spellen met dezelfde mediaan delen een plaats; niets hier breekt de gelijkstand.</value> + </data> + <data name="rankings.column.place" xml:space="preserve"> + <value>#</value> + </data> + <data name="rankings.column.game" xml:space="preserve"> + <value>spel</value> + </data> + <data name="rankings.column.median" xml:space="preserve"> + <value>mediaan</value> + </data> + <data name="rankings.column.peak" xml:space="preserve"> + <value>piek</value> + </data> + <data name="rankings.column.samples" xml:space="preserve"> + <value>tellingen</value> + </data> + <data name="rankings.column.days" xml:space="preserve"> + <value>gemeten dagen</value> + </data> + <data name="rankings.spells.title" xml:space="preserve"> + <value>Langste ononderbroken bereikbaarheid</value> + </data> + <data name="rankings.spells.basis" xml:space="preserve"> + <value>Elke peiling sinds de genoemde datum trof het spel bereikbaar aan. Bereikbaar, niet ‘up’: we meten een socket vanaf één host, en een spel waarheen we geen route hebben is volkomen springlevend. Zo’n reeks kan niet langer zijn dan we al meekijken, dus de datum is het feit en de duur volgt daaruit.</value> + </data> + <data name="rankings.spells.empty" xml:space="preserve"> + <value>Geen vermeld spel zit op dit moment in een ononderbroken reeks bereikbaarheid.</value> + </data> + <data name="rankings.spells.caption" xml:space="preserve"> + <value>Spellen die bij elke peiling sinds de genoemde datum bereikbaar waren. Spellen die sinds dezelfde datum bereikbaar zijn delen een plaats; niets hier breekt de gelijkstand.</value> + </data> + <data name="rankings.column.since" xml:space="preserve"> + <value>bereikbaar sinds</value> + </data> + <data name="rankings.column.duration" xml:space="preserve"> + <value>dat is</value> + </data> + <data name="rankings.archivedNote" xml:space="preserve"> + <value>Gearchiveerde spellen staan buiten beide tabellen en verder niets; één geslaagde peiling zet ze terug.</value> + </data> + <data name="rankings.plain.busiest" xml:space="preserve"> + <value>Drukst — mediaan gemeten spelers, laatste {days, plural, one {# dag} other {# dagen}}</value> + </data> + <data name="rankings.plain.windows" xml:space="preserve"> + <value>periodes:</value> + </data> + <data name="rankings.plain.thisOne" xml:space="preserve"> + <value>deze</value> + </data> + <data name="rankings.plain.row" xml:space="preserve"> + <value>mediaan {median, number} · piek {peak, number} · {samples, plural, one {# telling} other {# tellingen}} over {days, number} van {window, number} dagen</value> + </data> + <data name="rankings.plain.spellRow" xml:space="preserve"> + <value>bereikbaar bij elke peiling sinds {date} · {duration}</value> + </data> + <data name="archive.title" xml:space="preserve"> + <value>Het archief</value> + </data> + <data name="archive.lede" xml:space="preserve"> + <value>Spellen die gestopt zijn met antwoorden. Er is niets verwijderd. Ze worden nog wekelijks gepeild, en één geslaagde peiling zet een spel diezelfde dag terug in de lijst.</value> + </data> + <data name="archive.search.legend" xml:space="preserve"> + <value>het archief doorzoeken</value> + </data> + <data name="archive.search.label" xml:space="preserve"> + <value>Gearchiveerde spellen zoeken</value> + </data> + <data name="archive.search.placeholder" xml:space="preserve"> + <value>naam, codebase of beschrijving</value> + </data> + <data name="archive.search.submit" xml:space="preserve"> + <value>tonen</value> + </data> + <data name="archive.count" xml:space="preserve"> + <value>{count, plural, =0 {Geen gearchiveerde spellen} one {# gearchiveerd spel} other {# gearchiveerde spellen}}</value> + </data> + <data name="archive.badge" xml:space="preserve"> + <value>gearchiveerd</value> + </data> + <data name="archive.lastReachable" xml:space="preserve"> + <value>laatst bereikbaar</value> + </data> + <data name="archive.knownLive" xml:space="preserve"> + <value>bekend live</value> + </data> + <data name="archive.darkFor" xml:space="preserve"> + <value>({age} geleden)</value> + </data> + <data name="archive.empty" xml:space="preserve"> + <value>Geen treffers.</value> + </data> + <data name="archive.neverReachable" xml:space="preserve"> + <value>nooit, in niets wat we gemeten hebben</value> + </data> + <data name="archive.noReachableTime" xml:space="preserve"> + <value>geen bereikbare tijd gemeten</value> + </data> + <data name="archive.darkFor.unknown" xml:space="preserve"> + <value>onbekend</value> + </data> + <data name="archive.knownLive.years" xml:space="preserve"> + <value>{years, number, ::.#} jaar</value> + </data> + <data name="archive.knownLive.days" xml:space="preserve"> + <value>{days, plural, one {# dag} other {# dagen}}</value> + </data> + <data name="archive.run" xml:space="preserve"> + <value>{from} – {to} · {span}</value> + </data> + <data name="archive.run.months" xml:space="preserve"> + <value>{count, plural, one {# maand} other {# maanden}}</value> + </data> + <data name="archive.run.years" xml:space="preserve"> + <value>{count, plural, one {# jaar} other {# jaar}}</value> + </data> + <data name="archive.plain.matching" xml:space="preserve"> + <value>{count, plural, one {# spel dat overeenkomt met ‘{query}’} other {# spellen die overeenkomen met ‘{query}’}}</value> + </data> + <data name="archive.plain.count" xml:space="preserve"> + <value>{count, plural, one {# spel} other {# spellen}}</value> + </data> + <data name="archive.plain.lastReachable" xml:space="preserve"> + <value>Laatst bereikbaar:</value> + </data> + <data name="archive.plain.knownLive" xml:space="preserve"> + <value>Bekend live:</value> + </data> + <data name="archive.plain.knownLiveValue" xml:space="preserve"> + <value>{value} van de gemeten bereikbare tijd</value> + </data> + <data name="archive.plain.run" xml:space="preserve"> + <value>Looptijd:</value> + </data> + <data name="archive.plain.codebase" xml:space="preserve"> + <value>Codebase:</value> + </data> + <data name="footer.randomGame" xml:space="preserve"> + <value>willekeurig spel</value> + </data> + <data name="trend.day.counted" xml:space="preserve"> + <value>{d, date, medium} — gemiddeld {typical}, {low}–{high} over {probes, plural, one {# peiling} other {# peilingen}}</value> + </data> + <data name="trend.day.flat" xml:space="preserve"> + <value>{d, date, medium} — {count, plural, =0 {0 spelers} one {# speler} other {# spelers}}, bij elk van {probes, plural, one {# peiling} other {# peilingen}}</value> + </data> + <data name="trend.day.notCounted" xml:space="preserve"> + <value>{d, date, medium} — gepeild, geen telling kon worden gelezen</value> + </data> + <data name="trend.day.notMeasured" xml:space="preserve"> + <value>{d, date, medium} — geen meting</value> + </data> + <data name="trend.summary" xml:space="preserve"> + <value>Typisch {typical} verbonden, met een piek van {peak}, over {counted} van {days, plural, one {# dag} other {# dagen}}.</value> + </data> + <data name="trend.direction.steady" xml:space="preserve"> + <value>Gelijkmatig over het hele bereik.</value> + </data> + <data name="trend.direction.up" xml:space="preserve"> + <value>Ongeveer {change, number, percent} omhoog van het begin van het bereik tot het eind.</value> + </data> + <data name="trend.direction.down" xml:space="preserve"> + <value>Ongeveer {change, number, percent} omlaag van het begin van het bereik tot het eind.</value> + </data> + <data name="trend.none.probed" xml:space="preserve"> + <value>In dit bereik gepeild, en uit niets ervan kon een spelerstelling worden gelezen.</value> + </data> + <data name="trend.none.notMeasured" xml:space="preserve"> + <value>Geen meting in dit bereik.</value> + </data> + <data name="trend.empty" xml:space="preserve"> + <value>Niets geteld in dit bereik.</value> + </data> + <data name="trend.week.span" xml:space="preserve"> + <value>{from, date, d MMM}–{to, date, d MMM}</value> + </data> + <data name="trend.week.oneDay" xml:space="preserve"> + <value>{d, date, d MMM}</value> + </data> + <data name="trend.week.counted" xml:space="preserve"> + <value>{span}: typisch {typical}, piek {peak}, {days, plural, one {# dag} other {# dagen}} geteld</value> + </data> + <data name="trend.week.notCounted" xml:space="preserve"> + <value>{span}: gepeild, geen telling kon worden gelezen</value> + </data> + <data name="trend.week.notMeasured" xml:space="preserve"> + <value>{span}: niet gemeten</value> + </data> + <data name="trend.week.uncounted" xml:space="preserve"> + <value>{count, plural, one {# dag gepeild zonder telling} other {# dagen gepeild zonder telling}}</value> + </data> + <data name="trend.week.unmeasured" xml:space="preserve"> + <value>{count, plural, one {# dag niet gemeten} other {# dagen niet gemeten}}</value> + </data> + <data name="trend.week.and" xml:space="preserve"> + <value>{line}, {clause}</value> + </data> + <data name="trend.range" xml:space="preserve"> + <value>dagen in UTC · {from, date, medium} – {to, date, medium}</value> + </data> + <data name="trend.ceiling" xml:space="preserve"> + <value>{value} bovenaan</value> + </data> + <data name="trend.counted" xml:space="preserve"> + <value>{counted} van {days, plural, one {# dag} other {# dagen}} geteld</value> + </data> + <data name="trend.axis.month" xml:space="preserve"> + <value>{d, date, MMM}</value> + </data> + <data name="trend.axis.monthYear" xml:space="preserve"> + <value>{d, date, MMM yyyy}</value> + </data> + <data name="trend.legend.mean" xml:space="preserve"> + <value>gemiddelde van de tellingen die we die dag lazen</value> + </data> + <data name="trend.legend.peak" xml:space="preserve"> + <value>tot aan de drukste telling van die dag</value> + </data> + <data name="trend.legend.band" xml:space="preserve"> + <value>laagste tot hoogste telling van die dag</value> + </data> + <data name="trend.legend.notCounted" xml:space="preserve"> + <value>gepeild, geen telling kon worden gelezen</value> + </data> + <data name="trend.legend.notMeasured.bar" xml:space="preserve"> + <value>niet gemeten — helemaal geen balk</value> + </data> + <data name="trend.legend.notMeasured.line" xml:space="preserve"> + <value>niet gemeten — een onderbreking in de lijn</value> + </data> + <data name="trend.spans.label" xml:space="preserve"> + <value>Trendbereik</value> + </data> + <data name="trend.shapes.label" xml:space="preserve"> + <value>Trendvorm</value> + </data> + <data name="trend.preset" xml:space="preserve"> + <value>{days, plural, one {# dag} other {# dagen}}</value> + </data> + <data name="trend.earlier" xml:space="preserve"> + <value>← eerder</value> + </data> + <data name="trend.later" xml:space="preserve"> + <value>later →</value> + </data> + <data name="trend.shape.line" xml:space="preserve"> + <value>lijn</value> + </data> + <data name="trend.shape.bar" xml:space="preserve"> + <value>staven</value> + </data> + <data name="trend.plain.heading" xml:space="preserve"> + <value>Hoeveel, in de loop van de tijd</value> + </data> + <data name="trend.plain.range" xml:space="preserve"> + <value>{from, date, medium} – {to, date, medium}, UTC</value> + </data> + <data name="trend.plain.earlier" xml:space="preserve"> + <value>eerder</value> + </data> + <data name="trend.plain.note" xml:space="preserve"> + <value>een week wordt samengevat over de dagen erin die we geteld hebben; een week zonder zegt dat</value> + </data> + <data name="reach.kicker" xml:space="preserve"> + <value>bereikbaar · laatste {days, plural, one {# dag} other {# dagen}}</value> + </data> + <data name="reach.stat.reachable" xml:space="preserve"> + <value>bereikbaar</value> + </data> + <data name="reach.stat.longestOutage" xml:space="preserve"> + <value>langste onderbreking</value> + </data> + <data name="reach.stat.lastCause" xml:space="preserve"> + <value>laatste oorzaak</value> + </data> + <data name="reach.noOutage" xml:space="preserve"> + <value>geen in de periode</value> + </data> + <data name="reach.noCause" xml:space="preserve"> + <value>niets vastgelegd</value> + </data> + <data name="reach.scale.ago" xml:space="preserve"> + <value>{days, plural, one {# dag geleden} other {# dagen geleden}}</value> + </data> + <data name="reach.scale.today" xml:space="preserve"> + <value>vandaag</value> + </data> + <data name="reach.legend.reachable" xml:space="preserve"> + <value>bereikbaar</value> + </data> + <data name="reach.legend.degraded" xml:space="preserve"> + <value>haperend — antwoordde, kon niet afronden</value> + </data> + <data name="reach.legend.unreachable" xml:space="preserve"> + <value>onbereikbaar</value> + </data> + <data name="reach.legend.notMeasured" xml:space="preserve"> + <value>niet gemeten</value> + </data> + <data name="reach.word.reachable" xml:space="preserve"> + <value>bereikbaar</value> + </data> + <data name="reach.word.degraded" xml:space="preserve"> + <value>haperend</value> + </data> + <data name="reach.word.unreachable" xml:space="preserve"> + <value>onbereikbaar</value> + </data> + <data name="reach.word.notMeasured" xml:space="preserve"> + <value>niet gemeten</value> + </data> + <data name="reach.day.reachable" xml:space="preserve"> + <value>{d, date, d MMM} — de hele dag bereikbaar</value> + </data> + <data name="reach.day.degraded" xml:space="preserve"> + <value>{d, date, d MMM} — haperend ({cause}): antwoordde, kon niet afronden</value> + </data> + <data name="reach.day.unreachable" xml:space="preserve"> + <value>{d, date, d MMM} — onbereikbaar ({cause})</value> + </data> + <data name="reach.day.notMeasured" xml:space="preserve"> + <value>{d, date, d MMM} — niet gemeten; we volgden dit spel toen nog niet</value> + </data> + <data name="reach.none" xml:space="preserve"> + <value>{days, plural, one {Nog niet gemeten over de laatste # dag.} other {Nog niet gemeten over de laatste # dagen.}}</value> + </data> + <data name="reach.fraction.window" xml:space="preserve"> + <value>Bereikbaar {percent} van de laatste {days, plural, one {# dag} other {# dagen}}.</value> + </data> + <data name="reach.fraction.measured" xml:space="preserve"> + <value>Bereikbaar {percent} van de {days, plural, one {# dag} other {# dagen}} die we gemeten hebben.</value> + </data> + <data name="reach.fraction.unknown" xml:space="preserve"> + <value>{days, plural, one {De bereikbaarheid over de laatste # dag is nog niet gemeten.} other {De bereikbaarheid over de laatste # dagen is nog niet gemeten.}}</value> + </data> + <data name="reach.unreachable.noneInWindow" xml:space="preserve"> + <value>Geen enkele dag in de periode was onbereikbaar.</value> + </data> + <data name="reach.unreachable.noneMeasured" xml:space="preserve"> + <value>Geen enkele dag die we gemeten hebben was onbereikbaar.</value> + </data> + <data name="reach.unreachable.days" xml:space="preserve"> + <value>{count, plural, one {# dag onbereikbaar.} other {# dagen onbereikbaar.}}</value> + </data> + <data name="reach.degraded.days" xml:space="preserve"> + <value>{count, plural, one {# dag haperend — we kwamen binnen en konden niet afronden.} other {# dagen haperend — we kwamen binnen en konden niet afronden.}}</value> + </data> + <data name="reach.longestOutage" xml:space="preserve"> + <value>Langste onderbreking {duration}.</value> + </data> + <data name="reach.longestOutage.cause" xml:space="preserve"> + <value>Langste onderbreking {duration} ({cause}).</value> + </data> + <data name="reach.predate" xml:space="preserve"> + <value>{count, plural, one {# dag ligt vóór alles wat we gemeten hebben.} other {# dagen liggen vóór alles wat we gemeten hebben.}}</value> + </data> + <data name="reach.spell.range" xml:space="preserve"> + <value>{from, date, d MMM} – {to, date, d MMM}</value> + </data> + <data name="reach.spell.oneDay" xml:space="preserve"> + <value>{d, date, d MMM}</value> + </data> + <data name="reach.spell" xml:space="preserve"> + <value>{range}: {count, plural, one {# dag} other {# dagen}} {word}</value> + </data> + <data name="reach.spell.cause" xml:space="preserve"> + <value>{range}: {count, plural, one {# dag} other {# dagen}} {word} ({cause})</value> + </data> + <data name="reach.plain.heading" xml:space="preserve"> + <value>Bereikbaar</value> + </data> + <data name="reach.plain.window" xml:space="preserve"> + <value>{days, plural, one {laatste # dag} other {laatste # dagen}}</value> + </data> + <data name="reach.plain.fraction" xml:space="preserve"> + <value>Bereikbaar: {percent} van de {days, plural, one {laatste # dag} other {laatste # dagen}}</value> + </data> + <data name="reach.plain.longestOutage" xml:space="preserve"> + <value>Langste onderbreking: {duration}</value> + </data> + <data name="cause.dns" xml:space="preserve"> + <value>dns loste niet op</value> + </data> + <data name="cause.refused" xml:space="preserve"> + <value>verbinding geweigerd</value> + </data> + <data name="cause.tls" xml:space="preserve"> + <value>tls mislukt</value> + </data> + <data name="cause.timeout" xml:space="preserve"> + <value>time-out</value> + </data> + <data name="cause.handshakeStalled" xml:space="preserve"> + <value>handshake liep vast</value> + </data> + <data name="cause.none" xml:space="preserve"> + <value>geen oorzaak vastgelegd</value> + </data> + <data name="ansi.suppressed" xml:space="preserve"> + <value>De eigenaar heeft ons gevraagd het verbindingsscherm van dit spel niet opnieuw te publiceren.</value> + </data> + <data name="ansi.absent" xml:space="preserve"> + <value>Van dit spel is geen verbindingsscherm vastgelegd.</value> + </data> + <data name="ansi.tooSmall" xml:space="preserve"> + <value>{count, plural, one {Er kwam maar # rij terug — te weinig om te tonen.} other {Er kwamen maar # rijen terug — te weinig om te tonen.}}</value> + </data> + <data name="ansi.asSent" xml:space="preserve"> + <value>zoals verzonden door de server</value> + </data> + <data name="ansi.size" xml:space="preserve"> + <value>{columns}×{rows}</value> + </data> + <data name="ansi.size.doubleWidth" xml:space="preserve"> + <value>{columns}×{rows}, dubbele breedte</value> + </data> + <data name="ansi.depth.colour" xml:space="preserve"> + <value>16-kleuren SGR</value> + </data> + <data name="ansi.depth.plain" xml:space="preserve"> + <value>geen kleur</value> + </data> + <data name="ansi.readAs" xml:space="preserve"> + <value>gelezen als {charset}</value> + </data> + <data name="ansi.captured" xml:space="preserve"> + <value>vastgelegd</value> + </data> + <data name="ansi.frozen" xml:space="preserve"> + <value>bevroren — het laatste scherm dat we zagen</value> + </data> + <data name="ansi.alt.named" xml:space="preserve"> + <value>ASCII-kunst: het verbindingsscherm van {game}. De tekst ervan staat onder ‘als tekst lezen’, hieronder.</value> + </data> + <data name="ansi.alt" xml:space="preserve"> + <value>ASCII-kunst: het verbindingsscherm van dit spel. De tekst ervan staat onder ‘als tekst lezen’, hieronder.</value> + </data> + <data name="ansi.plain.rows" xml:space="preserve"> + <value>{count, plural, one {verbindingsscherm: # regel, alleen tekst} other {verbindingsscherm: # regels, alleen tekst}}</value> + </data> + <data name="ansi.plain.rows.readAs" xml:space="preserve"> + <value>{count, plural, one {verbindingsscherm: # regel, alleen tekst, gelezen als {charset}} other {verbindingsscherm: # regels, alleen tekst, gelezen als {charset}}}</value> + </data> + <data name="capability.disagree.declaredNotOffered" xml:space="preserve"> + <value>het spel geeft het op, en de server heeft het nooit aangeboden in een handshake.</value> + </data> + <data name="capability.disagree.offeredNotDeclared" xml:space="preserve"> + <value>de server biedt het aan, en het spel zegt in zijn eigen opgave van niet.</value> + </data> + <data name="capability.disagree.note" xml:space="preserve"> + <value>Meestal een verouderd, met de hand ingetypt veld, geen leugen. Getoond omdat een client niet moet vertrouwen op datgene waarover de twee van elkaar afwijken.</value> + </data> + <data name="game.notFound" xml:space="preserve"> + <value>Niet gevonden</value> + </data> + <data name="game.notFound.hint" xml:space="preserve"> + <value>Geen spel op dit adres. Controleer de spelling.</value> + </data> + <data name="game.endpoint.lastAnswered" xml:space="preserve"> + <value>laatst geantwoord</value> + </data> + <data name="game.stale" xml:space="preserve"> + <value>{count, plural, one {# is voorbij zijn verversingstermijn. Oud, niet fout.} other {# zijn voorbij hun verversingstermijn. Oud, niet fout.}}</value> + </data> + <data name="game.referrals.lists" xml:space="preserve"> + <value>De eigen verwijzingslijst van dit spel noemt:</value> + </data> + <data name="game.referrals.listedBy" xml:space="preserve"> + <value>Genoemd door de verwijzingslijst van:</value> + </data> + <data name="game.referral.since" xml:space="preserve"> + <value>sinds {date}</value> + </data> + <data name="game.referral.dropped" xml:space="preserve"> + <value>niet meer vermeld, laatst gezien</value> + </data> + <data name="game.archived.lastAnswered" xml:space="preserve"> + <value>Laatst geantwoord op {date}, {ago} geleden.</value> + </data> + <data name="game.archived.stillProbed" xml:space="preserve"> + <value>Wordt nog wekelijks gepeild; deze pagina wordt bijgewerkt op de dag dat het antwoordt.</value> + </data> + <data name="game.archived.knownLive" xml:space="preserve"> + <value>{span} bekend live</value> + </data> + <data name="game.excluded" xml:space="preserve"> + <value>Niet in de lijst, de ranglijsten of het dagcijfer: we denken niet dat dit adres een spel is dat iemand kan spelen. Alles hieronder is wat het ons vertelde, ongewijzigd.</value> + </data> + <data name="game.excluded.reason" xml:space="preserve"> + <value>Onze reden: {why}</value> + </data> + <data name="game.unlisted" xml:space="preserve"> + <value>Niet in de lijst, de ranglijsten of het dagcijfer, op verzoek van de mensen die het draaien. Alles hieronder is bewaard zoals het was, deze pagina en elk adres dat het ooit gehad heeft blijven antwoorden, en we kloppen er niet aan.</value> + </data> + <data name="game.plain.playersNow" xml:space="preserve"> + <value>Spelers nu: {count}</value> + </data> + <data name="game.plain.capabilities" xml:space="preserve"> + <value>Mogelijkheden ({disagreeing} van {total} wijken af)</value> + </data> + <data name="game.plain.declared" xml:space="preserve"> + <value>Opgegeven door het spel</value> + </data> + <data name="game.plain.connectScreen" xml:space="preserve"> + <value>Verbindingsscherm</value> + </data> + <data name="game.plain.whatChanged" xml:space="preserve"> + <value>Wat er veranderd is</value> + </data> + <data name="game.plain.measured" xml:space="preserve"> + <value>gemeten</value> + </data> + <data name="game.plain.declared.column" xml:space="preserve"> + <value>opgegeven</value> + </data> + <data name="game.plain.disagree" xml:space="preserve"> + <value>** wijkt af</value> + </data> + <data name="listing.row.connected" xml:space="preserve"> + <value>verbonden</value> + </data> + <data name="listing.row.reached" xml:space="preserve"> + <value>bereikt</value> + </data> + <data name="facet.group.search" xml:space="preserve"> + <value>zoeken</value> + </data> + <data name="facet.group.archived" xml:space="preserve"> + <value>gearchiveerd</value> + </data> + <data name="facet.group.adult" xml:space="preserve"> + <value>voor volwassenen</value> + </data> + <data name="facet.value.included" xml:space="preserve"> + <value>opgenomen</value> + </data> + <data name="game.count.none" xml:space="preserve"> + <value>geen telling</value> + </data> + <data name="game.count.none.why" xml:space="preserve"> + <value>geen actuele telling, en niets hier zegt waarom</value> + </data> + <data name="game.plain.playersNoCount" xml:space="preserve"> + <value>Spelers nu: geen telling (niets hier zegt waarom)</value> + </data> + <data name="crawler.live" xml:space="preserve"> + <value>crawler actief · laatste peiling {age}</value> + </data> + <data name="crawler.quiet" xml:space="preserve"> + <value>crawler wacht · laatste peiling {age}</value> + </data> + <data name="crawler.noProbe" xml:space="preserve"> + <value>hier is nog geen peiling afgerond</value> + </data> + <data name="crawler.cycle.nothingDue" xml:space="preserve"> + <value>niets aan de beurt deze cyclus</value> + </data> + <data name="crawler.cycle" xml:space="preserve"> + <value>{considered, plural, one {# aan de beurt} other {# aan de beurt}} · {answered, plural, one {# beantwoord} other {# beantwoord}} · {failed, plural, one {# mislukt} other {# mislukt}}</value> + </data> + <data name="crawler.registry" xml:space="preserve"> + <value>{targets, plural, one {# adres in het register} other {# adressen in het register}}, {due, plural, one {# nu aan de beurt} other {# nu aan de beurt}}</value> + </data> + <data name="preview.documentTitle" xml:space="preserve"> + <value>{page} — {site}</value> + </data> + <data name="preview.site" xml:space="preserve"> + <value>Een gids voor de MU*-hobby — MUSHes, MUDs, MUCKs, MOOs — waar elk feit vermeldt hoe het verkregen is en hoe oud het is.</value> + </data> + <data name="preview.demo" xml:space="preserve"> + <value>Demogegevens — niets hiervan is gemeten. {description}</value> + </data> + <data name="preview.cardAlt" xml:space="preserve"> + <value>{site} — gemeten, niet beweerd</value> + </data> + <data name="preview.cardAlt.named" xml:space="preserve"> + <value>{title} op {site}</value> + </data> + <data name="preview.title.games" xml:space="preserve"> + <value>Spellen</value> + </data> + <data name="preview.title.archive" xml:space="preserve"> + <value>Het archief</value> + </data> + <data name="preview.title.rankings" xml:space="preserve"> + <value>Ranglijsten</value> + </data> + <data name="preview.title.ecosystem" xml:space="preserve"> + <value>Het ecosysteem</value> + </data> + <data name="preview.title.reference" xml:space="preserve"> + <value>Naslag</value> + </data> + <data name="preview.title.about" xml:space="preserve"> + <value>Over</value> + </data> + <data name="preview.title.notFound" xml:space="preserve"> + <value>Niet gevonden</value> + </data> + <data name="preview.title.random" xml:space="preserve"> + <value>Willekeurig spel</value> + </data> + <data name="preview.title.account" xml:space="preserve"> + <value>Je spellen</value> + </data> + <data name="preview.title.claim" xml:space="preserve"> + <value>{game} claimen</value> + </data> + <data name="preview.desc.games" xml:space="preserve"> + <value>Elke MU* die we bereikt hebben, gefacetteerd op onze metingen: codebase, protocollen uit de handshake, TLS, codering, taal, laatst gezien.</value> + </data> + <data name="preview.desc.archive" xml:space="preserve"> + <value>Stilgevallen spellen, bewaard. Elk houdt zijn pagina, geschiedenis en URL, wordt wekelijks gepeild en keert terug in de lijst bij één geslaagde verbinding.</value> + </data> + <data name="preview.desc.rankings" xml:space="preserve"> + <value>Drukst, best bereikbaar, langst draaiend — alleen berekend uit metingen. Nergens op deze site stemmen, sterren of beoordelingen.</value> + </data> + <data name="preview.desc.ecosystem" xml:space="preserve"> + <value>Aandeel per codebase en protocoladoptie over de spellen die we meten, met wat servers aanbieden naast wat ze opgeven. Aandelen, nooit totalen.</value> + </data> + <data name="preview.desc.reference" xml:space="preserve"> + <value>Met de hand geschreven pagina’s over de codebases, clients en protocollen van de MU*-hobby, met verwijzingen naar tellingen uit de crawl.</value> + </data> + <data name="preview.desc.about" xml:space="preserve"> + <value>Hoe deze catalogus gebouwd wordt: wat de crawler doet, wat hij weigert te doen, en hoe hij te stoppen is.</value> + </data> + <data name="preview.desc.notFound" xml:space="preserve"> + <value>Geen spel op dit adres. Hier wordt nooit iets verwijderd, dus een spel dat ooit op deze URL stond, staat er nog — controleer de spelling.</value> + </data> + <data name="preview.desc.random" xml:space="preserve"> + <value>Eén spel uit de catalogus, willekeurig gekozen en nooit twee keer hetzelfde.</value> + </data> + <data name="preview.desc.account" xml:space="preserve"> + <value>De vermeldingen die je geclaimd hebt, en wat je met een claim kunt wijzigen.</value> + </data> + <data name="preview.desc.claim" xml:space="preserve"> + <value>Bewijs dat je dit spel draait door een token te publiceren waar alleen wie het draait het kan neerzetten.</value> + </data> + <data name="preview.game.archived" xml:space="preserve"> + <value>Gearchiveerd — laatst bereikbaar {age}, en wordt nog gepeild</value> + </data> + <data name="preview.game.archived.undated" xml:space="preserve"> + <value>Gearchiveerd, en wordt nog gepeild</value> + </data> + <data name="preview.game.countUnknown" xml:space="preserve"> + <value>Spelerstelling onbekend — het spel antwoordt en publiceert geen getal dat wij kunnen lezen</value> + </data> + <data name="preview.game.count" xml:space="preserve"> + <value>{count, plural, one {# speler} other {# spelers}}, {how} {age}</value> + </data> + <data name="feed.plain.newlyDiscovered" xml:space="preserve"> + <value>Nieuw ontdekt</value> + </data> + <data name="feed.plain.wentDark" xml:space="preserve"> + <value>Stilgevallen</value> + </data> + <data name="feed.plain.cameBack" xml:space="preserve"> + <value>Weer terug</value> + </data> + <data name="home.plain.known" xml:space="preserve"> + <value>{count, plural, one {# bekend spel} other {# bekende spellen}}</value> + </data> + <data name="home.plain.connectedNow" xml:space="preserve"> + <value>{count, plural, one {# nu verbonden (gemeten)} other {# nu verbonden (gemeten)}}</value> + </data> + <data name="home.plain.uncounted" xml:space="preserve"> + <value>{count, plural, one {# antwoordt, ongeteld} other {# antwoorden, ongeteld}}</value> + </data> + <data name="home.plain.archived" xml:space="preserve"> + <value>{count, plural, one {# gearchiveerd, wordt nog gepeild} other {# gearchiveerd, worden nog gepeild}}</value> + </data> + <data name="reference.title" xml:space="preserve"> + <value>Naslag</value> + </data> + <data name="reference.lede" xml:space="preserve"> + <value>Wat de codebases zijn, wat de clients doen, en wat de protocollen betekenen. Met de hand geschreven en in de repository naast de crawler bewaard — geen wiki, en er valt op deze pagina niets te bewerken. Elk {number} hier is iets anders: het komt uit de catalogus en wordt opnieuw berekend telkens als de pagina geladen wordt.</value> + </data> + <data name="reference.lede.number" xml:space="preserve"> + <value>getal</value> + </data> + <data name="reference.plain.lede" xml:space="preserve"> + <value>Met de hand geschreven, door één auteur, en van versies voorzien in git. De tekst hier is van ons; elk getal ernaast is door de crawler gemeten en wordt bij elk verzoek opnieuw berekend. Dit is geen wiki, en vanaf deze pagina is er niets te bewerken.</value> + </data> + <data name="reference.section.orientation" xml:space="preserve"> + <value>Begin hier</value> + </data> + <data name="reference.section.codebase" xml:space="preserve"> + <value>Codebases</value> + </data> + <data name="reference.section.client" xml:space="preserve"> + <value>Clients</value> + </data> + <data name="reference.section.protocol" xml:space="preserve"> + <value>Protocollen</value> + </data> + <data name="reference.kind.orientation" xml:space="preserve"> + <value>oriëntatie</value> + </data> + <data name="reference.kind.codebase" xml:space="preserve"> + <value>codebase</value> + </data> + <data name="reference.kind.client" xml:space="preserve"> + <value>client</value> + </data> + <data name="reference.kind.protocol" xml:space="preserve"> + <value>protocol</value> + </data> + <data name="reference.notFound.title" xml:space="preserve"> + <value>Niet gevonden</value> + </data> + <data name="reference.notFound.body" xml:space="preserve"> + <value>Hier staat geen naslagpagina. Dit onderdeel is met de hand geschreven, dus een gat is werk dat niemand gedaan heeft en niet iets wat verwijderd is — {index}.</value> + </data> + <data name="reference.notFound.index" xml:space="preserve"> + <value>kijk wat er wel is</value> + </data> + <data name="reference.codebase.heading" xml:space="preserve"> + <value>Spellen die erop draaien</value> + </data> + <data name="reference.codebase.none" xml:space="preserve"> + <value>We hebben er nog geen vastgesteld. Dat is een feit over wat deze crawler gemeten heeft, niet over wat er bestaat — een spel dat we niet bereikt hebben, of waarvan we de codebase niet konden lezen, telt hier niet mee.</value> + </data> + <data name="reference.codebase.listed" xml:space="preserve"> + <value>{count, plural, one {# vermeld} other {# vermeld}}</value> + </data> + <data name="reference.codebase.archived" xml:space="preserve"> + <value>{count, plural, one {# gearchiveerd} other {# gearchiveerd}}</value> + </data> + <data name="reference.measuredNeverAsserted" xml:space="preserve"> + <value>gemeten, nooit beweerd</value> + </data> + <data name="reference.codebase.note" xml:space="preserve"> + <value>Geteld uit de catalogus bij dit verzoek, over hetzelfde filter als de link hierboven — dus dit getal en die lijst zijn één zoekopdracht en kunnen niet uit elkaar lopen.</value> + </data> + <data name="reference.codebase.offered" xml:space="preserve"> + <value>aangeboden in hun handshakes: {protocols}</value> + </data> + <data name="reference.protocol.heading" xml:space="preserve"> + <value>Gemeten adoptie</value> + </data> + <data name="reference.protocol.none" xml:space="preserve"> + <value>Nog niets gemeten.</value> + </data> + <data name="reference.protocol.share" xml:space="preserve"> + <value>van {listed, plural, one {# vermeld spel} other {# vermelde spellen}} — {percent}</value> + </data> + <data name="reference.protocol.remainder" xml:space="preserve"> + <value>De spellen die hier niet meetellen zijn geen spellen zonder het protocol. Een spel telt mee wanneer we zijn server de optie in een handshake hebben zien aanbieden; de rest zijn servers die het ons niet aangeboden hebben en servers waarvan we de handshake niet gelezen hebben, en welke van beide het is kunnen we niet zeggen.</value> + </data> + <data name="reference.protocol.caption" xml:space="preserve"> + <value>Spellen die we {protocol} in een handshake hebben zien aanbieden, naar de codebase waarvan we vaststelden dat ze erop draaien.</value> + </data> + <data name="reference.protocol.column.codebase" xml:space="preserve"> + <value>codebase</value> + </data> + <data name="reference.protocol.column.offered" xml:space="preserve"> + <value>bood het aan</value> + </data> + <data name="reference.protocol.column.identified" xml:space="preserve"> + <value>vastgesteld</value> + </data> + <data name="reference.seeAlso" xml:space="preserve"> + <value>Zie ook</value> + </data> + <data name="reference.capabilities.heading" xml:space="preserve"> + <value>Mogelijkheden</value> + </data> + <data name="reference.capabilities.established" xml:space="preserve"> + <value>{count, plural, one {# van de {total} vastgesteld uit de eigen documentatie van het project} other {# van de {total} vastgesteld uit de eigen documentatie van het project}}</value> + </data> + <data name="reference.capabilities.caveat" xml:space="preserve"> + <value>Afgelezen uit de eigen documentatie van elk project, niet door ons gemeten — een client heeft geen handshake die wij kunnen waarnemen. ‘{unknown}’ betekent dat we gekeken hebben en het niet vastgesteld hebben. Het betekent nooit nee.</value> + </data> + <data name="reference.capabilities.caption" xml:space="preserve"> + <value>Mogelijkheden van clients, elk afgelezen uit de eigen documentatie van het project. Onbekend betekent dat we het niet vastgesteld hebben, en nooit dat de client het mist.</value> + </data> + <data name="reference.capabilities.column.documented" xml:space="preserve"> + <value>gedocumenteerd</value> + </data> + <data name="reference.capabilities.column.source" xml:space="preserve"> + <value>bron</value> + </data> + <data name="reference.capabilities.noSource" xml:space="preserve"> + <value>we hebben er geen gevonden</value> + </data> + <data name="reference.capability.yes" xml:space="preserve"> + <value>ja</value> + </data> + <data name="reference.capability.no" xml:space="preserve"> + <value>nee</value> + </data> + <data name="reference.capability.unknown" xml:space="preserve"> + <value>onbekend</value> + </data> + <data name="reference.plain.runsOn" xml:space="preserve"> + <value>Draait op: {platforms}</value> + </data> + <data name="reference.plain.codebase.heading" xml:space="preserve"> + <value>Spellen waarvan we vastgesteld hebben dat ze op deze codebase draaien</value> + </data> + <data name="reference.plain.codebase.none" xml:space="preserve"> + <value>Nog geen. Dat is een uitspraak over wat we gemeten hebben, niet over wat er bestaat — een spel dat we niet bereikt hebben, of waarvan we de codebase niet konden lezen, telt hier niet mee.</value> + </data> + <data name="reference.plain.codebase.counts" xml:space="preserve"> + <value>{listed, plural, one {# vermeld} other {# vermeld}}, {archived, plural, one {# gearchiveerd} other {# gearchiveerd}}</value> + </data> + <data name="reference.plain.codebase.offered" xml:space="preserve"> + <value>Gemeten in hun handshakes: {protocols}</value> + </data> + <data name="reference.plain.codebase.nothingOffered" xml:space="preserve"> + <value>In geen enkele handshake die we van hen gelezen hebben, is er iets aangeboden.</value> + </data> + <data name="reference.plain.protocol.share" xml:space="preserve"> + <value>{offering} van {listed, plural, one {# vermeld spel} other {# vermelde spellen}} hebben we het zien aanbieden ({percent})</value> + </data> + <data name="reference.plain.protocol.byCodebase" xml:space="preserve"> + <value>Naar codebase, van de spellen die we hebben vastgesteld</value> + </data> + <data name="reference.plain.protocol.row" xml:space="preserve"> + <value>{offering} van {identified} boden het aan</value> + </data> + <data name="reference.plain.capabilities.unknown" xml:space="preserve"> + <value>{count, plural, one {# van de {total} rijen is onbekend} other {# van de {total} rijen zijn onbekend}}: we hebben in de eigen documentatie van het project niets gevonden dat het een of het ander zegt. Een korte eerlijke tabel is beter dan een lange geraden.</value> + </data> + <data name="account.title" xml:space="preserve"> + <value>Je spellen</value> + </data> + <data name="account.noDatabase" xml:space="preserve"> + <value>Accounts vereisen een database, en deze site draait op de demofixture.</value> + </data> + <data name="account.signInButton" xml:space="preserve"> + <value>Inloggen</value> + </data> + <data name="account.signedInAs" xml:space="preserve"> + <value>Ingelogd als {name}.</value> + </data> + <data name="account.signOut" xml:space="preserve"> + <value>Uitloggen</value> + </data> + <data name="account.empty.body" xml:space="preserve"> + <value>Je hebt nog niets geclaimd. Zoek je spel op in {listing} en druk op zijn pagina op {claimControl}.</value> + </data> + <data name="account.empty.listing" xml:space="preserve"> + <value>de lijst</value> + </data> + <data name="account.empty.claimControl" xml:space="preserve"> + <value>dit spel claimen</value> + </data> + <data name="account.resigned.lead" xml:space="preserve"> + <value>Afstand gedaan.</value> + </data> + <data name="account.resigned.body" xml:space="preserve"> + <value>Het blijft vastgelegd, en je kunt altijd opnieuw aantonen dat je de controle hebt door een nieuw token te publiceren.</value> + </data> + <data name="account.saved.lead" xml:space="preserve"> + <value>Opgeslagen.</value> + </data> + <data name="account.saved.thatGame" xml:space="preserve"> + <value>Dat spel</value> + </data> + <data name="account.saved.fields" xml:space="preserve"> + <value>De pagina van {game} toont het nu als opgegeven door de eigenaar.</value> + </data> + <data name="account.saved.screenHidden" xml:space="preserve"> + <value>We publiceren het verbindingsscherm van {game} niet meer opnieuw. De pagina zegt dat met zoveel woorden in plaats van een gat te laten.</value> + </data> + <data name="account.saved.screenShown" xml:space="preserve"> + <value>Het verbindingsscherm van {game} staat weer op zijn pagina.</value> + </data> + <data name="account.saved.crawlStopped" xml:space="preserve"> + <value>We kloppen niet meer aan bij {game}, op geen enkel adres dat we ervan hebben. Zijn pagina houdt alles wat vóór je verzoek gemeten is.</value> + </data> + <data name="account.saved.crawlResumed" xml:space="preserve"> + <value>We kloppen weer aan bij {game}, vanaf zijn volgende beurt in het schema.</value> + </data> + <data name="account.saved.unlisted" xml:space="preserve"> + <value>{game} staat niet meer in de lijst, de ranglijsten en het dagcijfer. Zijn pagina en elk adres dat het ooit gehad heeft blijven antwoorden.</value> + </data> + <data name="account.saved.relisted" xml:space="preserve"> + <value>{game} staat weer in de lijst. Eén peiling die antwoord krijgt is genoeg om het weer te meten.</value> + </data> + <data name="account.refused.lead" xml:space="preserve"> + <value>{field} is niet gewijzigd.</value> + </data> + <data name="account.refused.tooLong" xml:space="preserve"> + <value>Dit zijn antwoorden van één regel; {max} tekens is het meeste dat we opslaan.</value> + </data> + <data name="account.refused.measured" xml:space="preserve"> + <value>Dat veld is gemeten. Met een claim kun je toevoegen waar MSSP geen ruimte voor heeft; hij laat niemand wijzigen wat wij waargenomen hebben, ons ook niet.</value> + </data> + <data name="account.claimed.heading" xml:space="preserve"> + <value>Geclaimd</value> + </data> + <data name="account.claim.verified" xml:space="preserve"> + <value>geverifieerd {date}</value> + </data> + <data name="account.claim.verifiedAndSeen" xml:space="preserve"> + <value>geverifieerd {date}, token laatst gezien {seen}</value> + </data> + <data name="account.claim.mssp" xml:space="preserve"> + <value>je MSSP controleren</value> + </data> + <data name="account.claim.coOwners" xml:space="preserve"> + <value>{count, plural, one {Ook eigendom van {names} — die een eigen token geverifieerd heeft.} other {Ook eigendom van {names} — die elk een eigen token geverifieerd hebben.}}</value> + </data> + <data name="account.coOwner.unnamed" xml:space="preserve"> + <value>een ander account</value> + </data> + <data name="account.badge.summary" xml:space="preserve"> + <value>je spelerstelling op je eigen site zetten</value> + </data> + <data name="account.badge.carries" xml:space="preserve"> + <value>De badge draagt de telling én wanneer we die gemeten hebben, want een getal zonder ouderdom is precies wat deze site wil vervangen.</value> + </data> + <data name="account.badge.states" xml:space="preserve"> + <value>Hij zegt {unknown} in plaats van nul wanneer we niet konden tellen, en {archived} als het spel stopt met antwoorden.</value> + </data> + <data name="account.badge.json" xml:space="preserve"> + <value>Er is ook {json}, als je hem liever zelf tekent.</value> + </data> + <data name="account.history.summary" xml:space="preserve"> + <value>geschiedenis</value> + </data> + <data name="account.event.issued" xml:space="preserve"> + <value>token uitgegeven</value> + </data> + <data name="account.event.reissued" xml:space="preserve"> + <value>token opnieuw uitgegeven</value> + </data> + <data name="account.event.verified" xml:space="preserve"> + <value>geverifieerd — we hebben je token gelezen</value> + </data> + <data name="account.event.beaconSeen" xml:space="preserve"> + <value>token nog steeds gepubliceerd</value> + </data> + <data name="account.event.beaconMissing" xml:space="preserve"> + <value>token deze keer niet gelezen</value> + </data> + <data name="account.event.revoked" xml:space="preserve"> + <value>afstand gedaan van de claim</value> + </data> + <data name="account.event.expired" xml:space="preserve"> + <value>token ongebruikt verlopen</value> + </data> + <data name="account.event.counterClaimed" xml:space="preserve"> + <value>een ander account heeft de controle aangetoond en het spel overgenomen</value> + </data> + <data name="account.event.checkRequested" xml:space="preserve"> + <value>controle aangevraagd</value> + </data> + <data name="account.resign.summary" xml:space="preserve"> + <value>afstand doen van deze claim</value> + </data> + <data name="account.resign.confirm" xml:space="preserve"> + <value>Typ {word} om te bevestigen. Er wordt niets verwijderd en je kunt opnieuw aantonen dat je de controle hebt door een nieuw token te publiceren; het spel blijft geclaimd als iemand anders het ook in eigendom heeft.</value> + </data> + <data name="account.resign.button" xml:space="preserve"> + <value>Afstand doen van {game}</value> + </data> + <data name="account.pending.heading" xml:space="preserve"> + <value>Wachten op een token</value> + </data> + <data name="account.pending.dates" xml:space="preserve"> + <value>token uitgegeven {issued}, geldig tot {expires}</value> + </data> + <data name="account.passkeys.heading" xml:space="preserve"> + <value>Passkeys</value> + </data> + <data name="account.passkey.unnamed" xml:space="preserve"> + <value>naamloos</value> + </data> + <data name="account.passkey.added" xml:space="preserve"> + <value>toegevoegd {date}</value> + </data> + <data name="account.passkey.addedOneDevice" xml:space="preserve"> + <value>toegevoegd {date} · slechts op één apparaat</value> + </data> + <data name="account.passkey.single" xml:space="preserve"> + <value>Deze passkey staat op één apparaat. Raak je hem kwijt, dan kom je er nog steeds in door een nieuw token op je spel te publiceren, maar met een tweede passkey gaat het sneller.</value> + </data> + <data name="account.passkey.add" xml:space="preserve"> + <value>Nog een passkey toevoegen</value> + </data> + <data name="claim.noGame" xml:space="preserve"> + <value>Zo’n spel is er niet</value> + </data> + <data name="claim.title" xml:space="preserve"> + <value>{game} claimen</value> + </data> + <data name="claim.noDatabase" xml:space="preserve"> + <value>Claimen vereist een database, en deze site draait op de demofixture.</value> + </data> + <data name="claim.needAccount" xml:space="preserve"> + <value>Je hebt eerst een account nodig. Daar zijn een passkey en een naam voor nodig.</value> + </data> + <data name="claim.signIn" xml:space="preserve"> + <value>Inloggen of een account aanmaken</value> + </data> + <data name="claim.yourGames" xml:space="preserve"> + <value>Je spellen</value> + </data> + <data name="claim.hasOwners" xml:space="preserve"> + <value>{count, plural, one {Dit spel heeft al een eigenaar die de controle over de server heeft aangetoond.} other {Dit spel heeft al # eigenaren die de controle over de server hebben aangetoond.}} Jij kunt dat ook aantonen — de toets is in beide gevallen dezelfde — maar we moeten weten wat je ermee bedoelt, want aan het token kunnen we dat niet zien.</value> + </data> + <data name="claim.join.button" xml:space="preserve"> + <value>Ik draai het ook — voeg me toe als eigenaar</value> + </data> + <data name="claim.join.note" xml:space="preserve"> + <value>Iedereen houdt zijn claim. Dit zijn twee mensen die één spel draaien.</value> + </data> + <data name="claim.assume.button" xml:space="preserve"> + <value>Ik heb het overgenomen — draag het aan mij over</value> + </data> + <data name="claim.assume.note" xml:space="preserve"> + <value>{count, plural, one {Zodra je token geverifieerd is, wordt de bestaande claim ingetrokken en is het spel van jou.} other {Zodra je token geverifieerd is, worden de bestaande claims ingetrokken en is het spel van jou.}} Zij zien in hun eigen geschiedenis waarom. Er wordt niets verwijderd, en zij kunnen op dezelfde manier als jij nu opnieuw de controle aantonen.</value> + </data> + <data name="claim.verified.lead" xml:space="preserve"> + <value>Geverifieerd.</value> + </data> + <data name="claim.verified.viaMssp" xml:space="preserve"> + <value>We hebben je token op {date} uit het MSSP-rapport van het spel gelezen.</value> + </data> + <data name="claim.verified.viaScreen" xml:space="preserve"> + <value>We hebben je token op {date} van het verbindingsscherm gelezen.</value> + </data> + <data name="claim.verified.leaveIt" xml:space="preserve"> + <value>Laat het token staan waar het staat. Het dient ook als identiteitssignaal, zodat dit spel herkenbaar blijft als het van host of van naam verandert. Het weghalen maakt je claim niet ongedaan.</value> + </data> + <data name="claim.publish" xml:space="preserve"> + <value>Publiceer dit token overal waar het spel het aan een anonieme verbinding laat zien. De volgende peiling pikt het op, en daarmee is aangetoond dat je naar die server kunt schrijven.</value> + </data> + <data name="claim.transfer.lead" xml:space="preserve"> + <value>Dit is een overdracht.</value> + </data> + <data name="claim.transfer.body" xml:space="preserve"> + <value>{count, plural, one {Zodra we dit token lezen, wordt de claim van de huidige eigenaar op dit spel ingetrokken en wordt het van jou.} other {Zodra we dit token lezen, worden de claims van de huidige eigenaren op dit spel ingetrokken en wordt het van jou.}}</value> + </data> + <data name="claim.either.heading" xml:space="preserve"> + <value>Een van deze twee volstaat</value> + </data> + <data name="claim.mssp.heading" xml:space="preserve"> + <value>Een MSSP-variabele</value> + </data> + <data name="claim.mssp.note" xml:space="preserve"> + <value>In {codebase} is dat een regel in {file}; elke codebase met MSSP heeft een equivalent.</value> + </data> + <data name="claim.mssp.aliases" xml:space="preserve"> + <value>{aliases} worden ook geaccepteerd.</value> + </data> + <data name="claim.screen.heading" xml:space="preserve"> + <value>Een regel op het verbindingsscherm</value> + </data> + <data name="claim.screen.note" xml:space="preserve"> + <value>Overal op het scherm, en kleurcodes eromheen zijn geen probleem.</value> + </data> + <data name="claim.then.heading" xml:space="preserve"> + <value>Daarna</value> + </data> + <data name="claim.then.body" xml:space="preserve"> + <value>We kijken op het gewone crawlschema. Dit token is geldig tot {date}. Kom gerust later terug; er hoeft niets opgeschreven te worden.</value> + </data> + <data name="claim.check.button" xml:space="preserve"> + <value>Eerder kijken</value> + </data> + <data name="claim.check.can" xml:space="preserve"> + <value>Zet je spel vooraan in de rij. We kloppen aan op ons eigen schema, dus dit is eerder en niet nu.</value> + </data> + <data name="claim.check.rationed" xml:space="preserve"> + <value>Net gevraagd. Probeer het over een paar minuten opnieuw — het is gerantsoeneerd omdat er eerder bij een echte server wordt aangeklopt dan wij anders gedaan hadden.</value> + </data> + <data name="owner.declare.heading" xml:space="preserve"> + <value>Wat alleen jij ons over {game} kunt vertellen</value> + </data> + <data name="owner.declare.lede" xml:space="preserve"> + <value>Dit zijn de dingen waar MSSP geen veld voor heeft. Ze verschijnen op de pagina van je spel als {declared}, met de datum waarop je ze voor het laatst bevestigd hebt, naast wat wij gemeten hebben — nooit in plaats daarvan. Niets wat gemeten is kan hiervandaan gewijzigd worden, niet door jou en niet door ons.</value> + </data> + <data name="owner.field.declared" xml:space="preserve"> + <value>opgegeven {age}. Maak dit vak leeg om het in te trekken — wat erin stond blijft hoe dan ook vastgelegd.</value> + </data> + <data name="owner.save" xml:space="preserve"> + <value>Opslaan wat je opgegeven hebt</value> + </data> + <data name="owner.override.heading" xml:space="preserve"> + <value>Wat {game} meldt, en wat jij liever getoond ziet</value> + </data> + <data name="owner.override.lede" xml:space="preserve"> + <value>Je MSSP is wat elke crawler leest, en we blijven het tonen naast alles wat je hier neerzet — een antwoord van jou verbergt er geen van je spel.</value> + </data> + <data name="owner.override.nothingMeasured" xml:space="preserve"> + <value>Niets wat gemeten is kan hiervandaan gewijzigd worden: geen spelerstelling, geen mogelijkheid, geen uur bereikbaarheid.</value> + </data> + <data name="owner.override.fixItThere" xml:space="preserve"> + <value>Klopt een regel hieronder niet in je {file}, dan lost het daar oplossen het overal op.</value> + </data> + <data name="owner.report.value" xml:space="preserve"> + <value>je spel meldt {value}, bevestigd {age}</value> + </data> + <data name="owner.report.none" xml:space="preserve"> + <value>je spel meldt hier niets</value> + </data> + <data name="owner.rename.note" xml:space="preserve"> + <value>De naam wijzigen verandert waaronder {game} vermeld staat en het adres van zijn pagina. Het oude adres blijft voor altijd werken — elk adres dat dit spel ooit gehad heeft verwijst door naar het huidige — en het vak leegmaken geeft de naam terug aan wat je MSSP zegt.</value> + </data> + <data name="owner.screen.heading" xml:space="preserve"> + <value>Je verbindingsscherm</value> + </data> + <data name="owner.screen.suppressed" xml:space="preserve"> + <value>We publiceren het niet opnieuw. De pagina zegt dat met zoveel woorden in plaats van een gat te laten, en de crawler blijft het lezen — zo herkennen we je spel als het verhuist.</value> + </data> + <data name="owner.screen.show" xml:space="preserve"> + <value>Weer tonen</value> + </data> + <data name="owner.screen.shown" xml:space="preserve"> + <value>We tonen het omdat je server het naar elke anonieme verbinding stuurt. Wil je dat liever niet, zeg het dan en we stoppen ermee. We vragen niet waarom.</value> + </data> + <data name="owner.screen.stop" xml:space="preserve"> + <value>Toon ons verbindingsscherm niet meer</value> + </data> + <data name="owner.crawl.heading" xml:space="preserve"> + <value>Gecrawld worden</value> + </data> + <data name="owner.crawl.stopped" xml:space="preserve"> + <value>We zijn gestopt. Er wordt bij {game} nergens meer aangeklopt, en de pagina houdt alles wat vóór je verzoek gemeten is — de lege uren noemen geen oorzaak, want {ourFact} is een feit over ons en geen meting van je spel.</value> + </data> + <data name="owner.crawl.ourFact" xml:space="preserve"> + <value>dat je ons gevraagd hebt te stoppen</value> + </data> + <data name="owner.crawl.resume" xml:space="preserve"> + <value>Crawl ons weer</value> + </data> + <data name="owner.crawl.standing" xml:space="preserve"> + <value>Deze kwam van je eigen server en niet van hier — {routes}. Wil je weer gecrawld worden, stop dan met het publiceren ervan; dat horen we in de volgende cyclus.</value> + </data> + <data name="owner.crawl.route.mssp" xml:space="preserve"> + <value>je MSSP-rapport publiceert {variable}</value> + </data> + <data name="owner.crawl.route.dns" xml:space="preserve"> + <value>een TXT-record op {label} vraagt ons te stoppen</value> + </data> + <data name="owner.crawl.route.recorded" xml:space="preserve"> + <value>een verzoek dat we vastgelegd hebben</value> + </data> + <data name="owner.crawl.partial" xml:space="preserve"> + <value>We zijn gestopt op {stopped} en kloppen nog aan bij {dialling}. Dat is meestal een poort die na de afmelding is toegevoegd.</value> + </data> + <data name="owner.crawl.stopAll" xml:space="preserve"> + <value>Stop ook op elk adres</value> + </data> + <data name="owner.crawl.dialling" xml:space="preserve"> + <value>We kloppen volgens een schema aan bij {game} en lezen wat elke anonieme verbinding te zien krijgt. Wil je dat liever niet, zeg het dan en we stoppen — binnen één cyclus, op elk adres dat we van je hebben, en we vragen niet waarom.</value> + </data> + <data name="owner.crawl.selfService" xml:space="preserve"> + <value>Wat al gemeten is wordt niet verwijderd: je pagina houdt zijn geschiedenis en zijn adres, en één peiling nadat je dit intrekt begint het weer. Je kunt het ook zonder ons zeggen, in je eigen configuratie — {mssp} in MSSP, of een TXT-record op {dns} — en die honoreren we, of iemand het spel hier nu ooit geclaimd heeft of niet.</value> + </data> + <data name="owner.crawl.stop" xml:space="preserve"> + <value>Crawl ons niet meer</value> + </data> + <data name="owner.listing.heading" xml:space="preserve"> + <value>In de lijst staan</value> + </data> + <data name="owner.listing.unlisted" xml:space="preserve"> + <value>{game} staat niet meer in de lijst, niet in de ranglijsten en niet in het dagcijfer. Zijn pagina en elk adres dat het ooit gehad heeft blijven antwoorden, en alles wat vóór je verzoek gemeten is staat er nog op. Er is niets verwijderd; het is alleen geen plek meer waar een lezer al bladerend aankomt.</value> + </data> + <data name="owner.listing.relist" xml:space="preserve"> + <value>Zet ons terug in de lijst</value> + </data> + <data name="owner.listing.probeRelists" xml:space="preserve"> + <value>Eén peiling die antwoord krijgt doet dit ook. Zolang je afmelding staat kloppen we niet aan, dus gebeurt dat niet — maar de dag dat je haar intrekt, komt het adres binnen een week aan de beurt en zet de peiling die antwoord krijgt je terug. Je hoeft het ons geen tweede keer te vragen.</value> + </data> + <data name="owner.listing.mayUnlist" xml:space="preserve"> + <value>We kloppen niet meer bij je aan, en je pagina staat nog in de lijst met wat we daarvóór gemeten hebben. Wil je dat liever niet, zeg het dan en hij gaat eruit — uit de lijst, de ranglijsten en het dagcijfer.</value> + </data> + <data name="owner.listing.reversible" xml:space="preserve"> + <value>Er wordt niets verwijderd en er gaat niets stuk: de pagina antwoordt, elk adres dat hij ooit gehad heeft verwijst er nog naar door, en iedereen die je erheen stuurt ziet hem. Hij houdt op een plek te zijn waar een lezer al bladerend aankomt. Vanaf hier terug te draaien, en door elke peiling die antwoord krijgt nadat je je afmelding intrekt.</value> + </data> + <data name="owner.listing.unlist" xml:space="preserve"> + <value>Haal ons ook uit de lijst</value> + </data> + <data name="facet.group.measure" xml:space="preserve"> + <value>wat we konden meten</value> + </data> + <data name="facet.measure.note" xml:space="preserve"> + <value>Deze verbergen haalt ze uit deze lijst; het betekent niet dat het spel leeg is.</value> + </data> + <data name="facet.group.uncounted" xml:space="preserve"> + <value>konden niet tellen</value> + </data> + <data name="facet.group.unreachable" xml:space="preserve"> + <value>konden niet bereiken</value> + </data> + <data name="facet.excluded.uncounted" xml:space="preserve"> + <value>niet getoond in deze lijst</value> + </data> + <data name="facet.excluded.unreachable" xml:space="preserve"> + <value>niet getoond in deze lijst</value> + </data> + <data name="facet.plain.marks" xml:space="preserve"> + <value>In de linkerkolom is * een waarde waarop deze lijst gefilterd is en - een waarde die is uitgesloten. Beide zijn keuzes in de zoekopdracht, geen feiten over een spel.</value> + </data> +</root> diff --git a/src/MUI.Web/Resources/Messages.resx b/src/MUI.Web/Resources/Messages.resx new file mode 100644 index 0000000..0e39845 --- /dev/null +++ b/src/MUI.Web/Resources/Messages.resx @@ -0,0 +1,3823 @@ +<?xml version="1.0" encoding="utf-8"?> +<root> + <!-- + The chrome's strings, in ICU MessageFormat. + + resx because that is what .NET, every translation-management tool and every translator already + understand: the SDK compiles a Messages.<culture>.resx into a satellite assembly on its own, and + a translator receives a file their software opens rather than a C# dictionary they must not + break. The values are ICU patterns rather than composite-format strings, because {0} cannot + express agreement — see MessagePattern. + + A locked id may only be changed by a maintainer. Glossary.cs says which, and why for each. + --> + <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata"> + <xsd:import namespace="http://www.w3.org/XML/1998/namespace" /> + <xsd:element name="root" msdata:IsDataSet="true"> + <xsd:complexType> + <xsd:choice maxOccurs="unbounded"> + <xsd:element name="data"> + <xsd:complexType> + <xsd:sequence> + <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" /> + <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" /> + </xsd:sequence> + <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" /> + <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" /> + <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" /> + <xsd:attribute ref="xml:space" /> + </xsd:complexType> + </xsd:element> + <xsd:element name="resheader"> + <xsd:complexType> + <xsd:sequence> + <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" /> + </xsd:sequence> + <xsd:attribute name="name" type="xsd:string" use="required" /> + </xsd:complexType> + </xsd:element> + </xsd:choice> + </xsd:complexType> + </xsd:element> + </xsd:schema> + <resheader name="resmimetype"><value>text/microsoft-resx</value></resheader> + <resheader name="version"><value>2.0</value></resheader> + <resheader name="reader"><value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader> + <resheader name="writer"><value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader> + <data name="facet.count" xml:space="preserve"> + <value>{count, plural, one {# game} other {# games}}</value> + <comment>counts, which is where the concatenations were</comment> + </data> + <data name="facet.value.include" xml:space="preserve"> + <value>{value}, {count, plural, one {# game} other {# games}}, only</value> + <comment>counts, which is where the concatenations were</comment> + </data> + <data name="facet.value.exclude" xml:space="preserve"> + <value>{value}, {count, plural, one {# game} other {# games}}, excluded</value> + <comment>counts, which is where the concatenations were</comment> + </data> + <data name="facet.value.choose" xml:space="preserve"> + <value>{value}, {count, plural, one {# game} other {# games}}</value> + <comment>counts, which is where the concatenations were</comment> + </data> + <data name="facet.any" xml:space="preserve"> + <value>any {facet}, {count, plural, one {# game} other {# games}}</value> + <comment>counts, which is where the concatenations were</comment> + </data> + <data name="listing.total" xml:space="preserve"> + <value>{count, plural, =0 {No games listed here.} one {# game, each fact carrying how it was obtained.} other {# games, each fact carrying how it was obtained.}}</value> + <comment>counts, which is where the concatenations were</comment> + </data> + <data name="chart.basis" xml:space="preserve"> + <value>{days, plural, one {# day} other {# days}} measured · {probes, plural, one {# probe} other {# probes}}</value> + <comment>counts, which is where the concatenations were</comment> + </data> + <data name="window.samples" xml:space="preserve"> + <value>{days, plural, one {#d} other {#d}} · {count, plural, one {# count} other {# counts}}</value> + <comment>counts, which is where the concatenations were</comment> + </data> + <data name="capabilities.agree" xml:space="preserve"> + <value>{disagreeing, plural, =0 {None of the {total} disagree.} one {# of {total} disagrees with what the game declares.} other {# of {total} disagree with what the game declares.}}</value> + <comment>counts, which is where the concatenations were</comment> + </data> + <data name="find.matching" xml:space="preserve"> + <value>{count, plural, =0 {No games match every answer.} one {# game matches every answer.} other {# games match every answer.}}</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.basis" xml:space="preserve"> + <value>of {listed, plural, one {# listed game} other {# listed games}} · {answers, plural, =0 {no answers given} one {# answer given} other {# answers given}}</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.show" xml:space="preserve"> + <value>{count, plural, one {Show the one game} other {Show these # games}}</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.drop" xml:space="preserve"> + <value>drop "{answer}" — {count, plural, one {# game} other {# games}}</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.clear" xml:space="preserve"> + <value>clear answer to: {question}</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.title" xml:space="preserve"> + <value>Find a game</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.kicker" xml:space="preserve"> + <value>matching all answers</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.noun" xml:space="preserve"> + <value>{count, plural, one {game} other {games}}</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.clearAll" xml:space="preserve"> + <value>clear all answers</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.startAgain" xml:space="preserve"> + <value>start again</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.more" xml:space="preserve"> + <value>{count, plural, one {# more} other {# more}}</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.answersGiven" xml:space="preserve"> + <value>answers given</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.wholeListing" xml:space="preserve"> + <value>the whole listing</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.refused" xml:space="preserve"> + <value>that query was refused</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.name.label" xml:space="preserve"> + <value>a name, if you have one</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.name.placeholder" xml:space="preserve"> + <value>name, or part of one</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.name.submit" xml:space="preserve"> + <value>Search by name</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.q.band" xml:space="preserve"> + <value>Is anyone playing right now?</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.q.genre" xml:space="preserve"> + <value>What do you want to play?</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.q.lineage" xml:space="preserve"> + <value>What kind of game?</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.q.language" xml:space="preserve"> + <value>In which language?</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.q.client" xml:space="preserve"> + <value>Anything your client needs?</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.q.dark" xml:space="preserve"> + <value>Include games that have gone dark?</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.any.band" xml:space="preserve"> + <value>doesn't matter</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.any.genre" xml:space="preserve"> + <value>any genre</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.any.lineage" xml:space="preserve"> + <value>any kind</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.any.language" xml:space="preserve"> + <value>any language</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.any.client" xml:space="preserve"> + <value>doesn't matter</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.dark.no" xml:space="preserve"> + <value>no, only live games</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.dark.yes" xml:space="preserve"> + <value>yes, show me those too</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.dark.chip" xml:space="preserve"> + <value>games that have gone dark</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.protocol.tls" xml:space="preserve"> + <value>TLS — encrypted, handshake completed by us</value> + <comment>the client question's options</comment> + </data> + <data name="find.protocol.mssp" xml:space="preserve"> + <value>MSSP — server self-description</value> + <comment>the client question's options</comment> + </data> + <data name="find.protocol.mccp" xml:space="preserve"> + <value>MCCP — compressed output</value> + <comment>the client question's options</comment> + </data> + <data name="find.protocol.mxp" xml:space="preserve"> + <value>MXP — clickable links</value> + <comment>the client question's options</comment> + </data> + <data name="find.protocol.gmcp" xml:space="preserve"> + <value>GMCP — structured client data</value> + <comment>the client question's options</comment> + </data> + <data name="find.protocol.msdp" xml:space="preserve"> + <value>MSDP — structured client data</value> + <comment>the client question's options</comment> + </data> + <data name="find.protocol.charset" xml:space="preserve"> + <value>CHARSET — encoding negotiation</value> + <comment>the client question's options</comment> + </data> + <data name="find.protocol.utf8" xml:space="preserve"> + <value>UTF-8 — non-Latin text renders</value> + <comment>the client question's options</comment> + </data> + <data name="find.protocol.ttype" xml:space="preserve"> + <value>TTYPE — client tells its type</value> + <comment>the client question's options</comment> + </data> + <data name="find.protocol.atcp" xml:space="preserve"> + <value>ATCP — structured client data</value> + <comment>the client question's options</comment> + </data> + <data name="find.protocol.msp" xml:space="preserve"> + <value>MSP — sound triggers</value> + <comment>the client question's options</comment> + </data> + <data name="find.protocol.eor" xml:space="preserve"> + <value>EOR — prompt marking</value> + <comment>the client question's options</comment> + </data> + <data name="find.protocol.other" xml:space="preserve"> + <value>{token} — measured in the handshake</value> + <comment>the client question's options</comment> + </data> + <data name="provenance.count.measured" xml:space="preserve"> + <value>measured</value> + <comment>the locked provenance words, one id per context</comment> + </data> + <data name="provenance.game.measured" xml:space="preserve"> + <value>measured</value> + <comment>the locked provenance words, one id per context</comment> + </data> + <data name="provenance.capability.measured" xml:space="preserve"> + <value>measured</value> + <comment>the locked provenance words, one id per context</comment> + </data> + <data name="provenance.screen.measured" xml:space="preserve"> + <value>measured</value> + <comment>the locked provenance words, one id per context</comment> + </data> + <data name="kicker.measured" xml:space="preserve"> + <value>measured</value> + <comment>the locked provenance words, one id per context</comment> + </data> + <data name="provenance.count.declared" xml:space="preserve"> + <value>declared</value> + <comment>the locked provenance words, one id per context</comment> + </data> + <data name="provenance.game.declared" xml:space="preserve"> + <value>declared</value> + <comment>the locked provenance words, one id per context</comment> + </data> + <data name="provenance.capability.declared" xml:space="preserve"> + <value>declared</value> + <comment>the locked provenance words, one id per context</comment> + </data> + <data name="kicker.declared" xml:space="preserve"> + <value>declared</value> + <comment>the locked provenance words, one id per context</comment> + </data> + <data name="provenance.derived" xml:space="preserve"> + <value>derived</value> + <comment>the locked provenance words, one id per context</comment> + </data> + <data name="kicker.derived" xml:space="preserve"> + <value>derived</value> + <comment>the locked provenance words, one id per context</comment> + </data> + <data name="state.notMeasured" xml:space="preserve"> + <value>not measured</value> + <comment>the four kinds of absence</comment> + </data> + <data name="state.uncounted" xml:space="preserve"> + <value>uncounted</value> + <comment>the four kinds of absence</comment> + </data> + <data name="state.unreachable" xml:space="preserve"> + <value>unreachable</value> + <comment>the four kinds of absence</comment> + </data> + <data name="state.notCounted" xml:space="preserve"> + <value>not counted</value> + <comment>the four kinds of absence</comment> + </data> + <data name="listing.count.none" xml:space="preserve"> + <value>no count</value> + <comment>the listing's own absences, which are not the game page's</comment> + </data> + <data name="listing.plain.fromHere" xml:space="preserve"> + <value>from here</value> + <comment>the listing's own absences, which are not the game page's</comment> + </data> + <data name="listing.plain.archived" xml:space="preserve"> + <value>archived</value> + <comment>the listing's own absences, which are not the game page's</comment> + </data> + <data name="listing.plain.claimed" xml:space="preserve"> + <value>claimed</value> + <comment>the listing's own absences, which are not the game page's</comment> + </data> + <data name="random.empty.title" xml:space="preserve"> + <value>Nothing to pick from</value> + <comment>the listing's own absences, which are not the game page's</comment> + </data> + <data name="random.empty.body" xml:space="preserve"> + <value>No game matches that filter. Try {listing}, or {archive}.</value> + <comment>the listing's own absences, which are not the game page's</comment> + </data> + <data name="random.empty.listing" xml:space="preserve"> + <value>the whole listing</value> + <comment>the listing's own absences, which are not the game page's</comment> + </data> + <data name="random.empty.archive" xml:space="preserve"> + <value>include the archive</value> + <comment>the listing's own absences, which are not the game page's</comment> + </data> + <data name="term.connected" xml:space="preserve"> + <value>connected</value> + <comment>the words the product rests on</comment> + </data> + <data name="term.unclaimed" xml:space="preserve"> + <value>unclaimed</value> + <comment>the words the product rests on</comment> + </data> + <data name="term.claimedByOwner" xml:space="preserve"> + <value>claimed by its owner</value> + <comment>the words the product rests on</comment> + </data> + <data name="term.stillProbed" xml:space="preserve"> + <value>still probed</value> + <comment>the words the product rests on</comment> + </data> + <data name="term.typical" xml:space="preserve"> + <value>typical</value> + <comment>the words the product rests on</comment> + </data> + <data name="term.peak" xml:space="preserve"> + <value>peak</value> + <comment>the words the product rests on</comment> + </data> + <data name="a11y.readAsText" xml:space="preserve"> + <value>read as text</value> + <comment>the accessibility promises</comment> + </data> + <data name="a11y.plainText" xml:space="preserve"> + <value>plain text</value> + <comment>the accessibility promises</comment> + </data> + <data name="a11y.skipToContent" xml:space="preserve"> + <value>skip to content</value> + <comment>the accessibility promises</comment> + </data> + <data name="a11y.asciiBanner" xml:space="preserve"> + <value>ASCII banner: the connect screen of {game}.</value> + <comment>the accessibility promises</comment> + </data> + <data name="nav.catalogues" xml:space="preserve"> + <value>Catalogues</value> + <comment>site chrome</comment> + </data> + <data name="nav.account" xml:space="preserve"> + <value>This site and your account</value> + <comment>site chrome</comment> + </data> + <data name="nav.browse" xml:space="preserve"> + <value>browse</value> + <comment>site chrome</comment> + </data> + <data name="nav.learn" xml:space="preserve"> + <value>learn</value> + <comment>site chrome</comment> + </data> + <data name="nav.thisSite" xml:space="preserve"> + <value>this site</value> + <comment>site chrome</comment> + </data> + <data name="nav.menu" xml:space="preserve"> + <value>menu</value> + <comment>site chrome</comment> + </data> + <data name="nav.games" xml:space="preserve"> + <value>games</value> + <comment>site chrome</comment> + </data> + <data name="nav.find" xml:space="preserve"> + <value>find</value> + <comment>site chrome</comment> + </data> + <data name="nav.random" xml:space="preserve"> + <value>random</value> + <comment>site chrome</comment> + </data> + <data name="nav.archive" xml:space="preserve"> + <value>archive</value> + <comment>site chrome</comment> + </data> + <data name="nav.reference" xml:space="preserve"> + <value>reference</value> + <comment>site chrome</comment> + </data> + <data name="nav.ecosystem" xml:space="preserve"> + <value>ecosystem</value> + <comment>site chrome</comment> + </data> + <data name="nav.rankings" xml:space="preserve"> + <value>rankings</value> + <comment>site chrome</comment> + </data> + <data name="nav.about" xml:space="preserve"> + <value>about</value> + <comment>site chrome</comment> + </data> + <data name="nav.submit" xml:space="preserve"> + <value>submit</value> + <comment>site chrome</comment> + </data> + <data name="nav.submitGame" xml:space="preserve"> + <value>submit a game</value> + <comment>site chrome</comment> + </data> + <data name="nav.signIn" xml:space="preserve"> + <value>sign in</value> + <comment>site chrome</comment> + </data> + <data name="nav.yourGames" xml:space="preserve"> + <value>your games</value> + <comment>site chrome</comment> + </data> + <data name="theme.label" xml:space="preserve"> + <value>theme</value> + <comment>site chrome</comment> + </data> + <data name="theme.auto" xml:space="preserve"> + <value>auto</value> + <comment>site chrome</comment> + </data> + <data name="theme.light" xml:space="preserve"> + <value>light</value> + <comment>site chrome</comment> + </data> + <data name="theme.dark" xml:space="preserve"> + <value>dark</value> + <comment>site chrome</comment> + </data> + <data name="banner.demo.lead" xml:space="preserve"> + <value>Demo data.</value> + <comment>site chrome</comment> + </data> + <data name="banner.demo" xml:space="preserve"> + <value>No database is configured, so this is a fixture. Nothing here was measured.</value> + <comment>site chrome</comment> + </data> + <data name="footer.allGames" xml:space="preserve"> + <value>all games</value> + <comment>site chrome</comment> + </data> + <data name="footer.archive" xml:space="preserve"> + <value>archive</value> + <comment>site chrome</comment> + </data> + <data name="footer.declaredByGame" xml:space="preserve"> + <value>declared by the game</value> + <comment>site chrome</comment> + </data> + <data name="footer.whatChanged" xml:space="preserve"> + <value>what changed</value> + <comment>site chrome</comment> + </data> + <data name="home.title" xml:space="preserve"> + <value>A directory of the MU* hobby</value> + <comment>home</comment> + </data> + <data name="home.lede" xml:space="preserve"> + <value>Every fact carries how it was obtained and how old it is: measured by our crawler, or declared by the game and marked as such.</value> + <comment>home</comment> + </data> + <data name="home.search.label" xml:space="preserve"> + <value>Search games by name, theme, codebase or host</value> + <comment>home</comment> + </data> + <data name="home.search.placeholder" xml:space="preserve"> + <value>search by name, theme, codebase or host</value> + <comment>home</comment> + </data> + <data name="home.search.submit" xml:space="preserve"> + <value>search</value> + <comment>home</comment> + </data> + <data name="tile.gamesKnown" xml:space="preserve"> + <value>games known</value> + <comment>home</comment> + </data> + <data name="tile.connectedNow" xml:space="preserve"> + <value>connected now</value> + <comment>home</comment> + </data> + <data name="tile.answeringUncounted" xml:space="preserve"> + <value>answering, uncounted</value> + <comment>home</comment> + </data> + <data name="tile.archived" xml:space="preserve"> + <value>archived</value> + <comment>home</comment> + </data> + <data name="feed.newlyDiscovered" xml:space="preserve"> + <value>newly discovered</value> + <comment>home</comment> + </data> + <data name="feed.wentDark" xml:space="preserve"> + <value>went dark — still probed</value> + <comment>home</comment> + </data> + <data name="feed.cameBack" xml:space="preserve"> + <value>came back</value> + <comment>home</comment> + </data> + <data name="feed.nothingNew" xml:space="preserve"> + <value>Nothing new.</value> + <comment>home</comment> + </data> + <data name="feed.nothingDark" xml:space="preserve"> + <value>Nothing went dark.</value> + <comment>home</comment> + </data> + <data name="feed.nothingBack" xml:space="preserve"> + <value>Nothing came back. We keep knocking.</value> + <comment>home</comment> + </data> + <data name="feed.live" xml:space="preserve"> + <value>live</value> + <comment>home</comment> + </data> + <data name="games.title" xml:space="preserve"> + <value>Games</value> + <comment>the listing</comment> + </data> + <data name="listing.sortedBy" xml:space="preserve"> + <value>sorted by {order}</value> + <comment>the listing</comment> + </data> + <data name="listing.random" xml:space="preserve"> + <value>random</value> + <comment>the listing</comment> + </data> + <data name="listing.columns" xml:space="preserve"> + <value>connected · reached</value> + <comment>the listing</comment> + </data> + <data name="listing.fromHere" xml:space="preserve"> + <value>from here</value> + <comment>the listing</comment> + </data> + <data name="listing.empty.head" xml:space="preserve"> + <value>Nothing matched.</value> + <comment>the listing</comment> + </data> + <data name="listing.empty.hint" xml:space="preserve"> + <value>Try fewer words, or drop a filter.</value> + <comment>the listing</comment> + </data> + <data name="listing.clearFilters" xml:space="preserve"> + <value>clear filters</value> + <comment>the listing</comment> + </data> + <data name="listing.aboutCodebase" xml:space="preserve"> + <value>about {codebase}</value> + <comment>the listing</comment> + </data> + <data name="listing.never" xml:space="preserve"> + <value>never</value> + <comment>the listing</comment> + </data> + <data name="listing.claimed" xml:space="preserve"> + <value>claimed by its owner</value> + <comment>the listing</comment> + </data> + <data name="listing.unknownCodebase" xml:space="preserve"> + <value>Unknown Codebase</value> + <comment>the listing</comment> + </data> + <data name="listing.unknownCodebase.title" xml:space="preserve"> + <value>we could not identify the codebase this game runs</value> + <comment>the listing</comment> + </data> + <data name="listing.moreProtocols" xml:space="preserve"> + <value>and {count, plural, one {# more} other {# more}}: {names}</value> + <comment>the listing</comment> + </data> + <data name="switch.order" xml:space="preserve"> + <value>Order</value> + <comment>the order switch</comment> + </data> + <data name="switch.window" xml:space="preserve"> + <value>Window</value> + <comment>the order switch</comment> + </data> + <data name="switch.now" xml:space="preserve"> + <value>now</value> + <comment>the order switch</comment> + </data> + <data name="switch.typical" xml:space="preserve"> + <value>typical</value> + <comment>the order switch</comment> + </data> + <data name="switch.peak" xml:space="preserve"> + <value>peak</value> + <comment>the order switch</comment> + </data> + <data name="switch.name" xml:space="preserve"> + <value>name</value> + <comment>the order switch</comment> + </data> + <data name="switch.reached" xml:space="preserve"> + <value>reached</value> + <comment>the order switch</comment> + </data> + <data name="window.7" xml:space="preserve"> + <value>7 days</value> + <comment>the order switch</comment> + </data> + <data name="window.30" xml:space="preserve"> + <value>30 days</value> + <comment>the order switch</comment> + </data> + <data name="window.90" xml:space="preserve"> + <value>90 days</value> + <comment>the order switch</comment> + </data> + <data name="filters.search.label" xml:space="preserve"> + <value>Search games</value> + <comment>the filter panel</comment> + </data> + <data name="filters.search.placeholder" xml:space="preserve"> + <value>search games</value> + <comment>the filter panel</comment> + </data> + <data name="filters.summary" xml:space="preserve"> + <value>filters</value> + <comment>the filter panel</comment> + </data> + <data name="filters.showing" xml:space="preserve"> + <value>showing</value> + <comment>the filter panel</comment> + </data> + <data name="filters.clearAll" xml:space="preserve"> + <value>clear all</value> + <comment>the filter panel</comment> + </data> + <data name="filters.stopFiltering" xml:space="preserve"> + <value>— stop filtering by this</value> + <comment>the filter panel</comment> + </data> + <data name="facet.anyValue" xml:space="preserve"> + <value>any</value> + <comment>the filter panel</comment> + </data> + <data name="facet.more" xml:space="preserve"> + <value>more filters ({count})</value> + <comment>the filter panel</comment> + </data> + <data name="facet.moreValues" xml:space="preserve"> + <value>{count, plural, one {# more} other {# more}}</value> + <comment>the filter panel</comment> + </data> + <data name="facet.alsoShow" xml:space="preserve"> + <value>also show</value> + <comment>the filter panel</comment> + </data> + <data name="facet.alsoShow.note" xml:space="preserve"> + <value>Off by default. Neither is a judgement about the game.</value> + <comment>the filter panel</comment> + </data> + <data name="facet.archived" xml:space="preserve"> + <value>archived</value> + <comment>the filter panel</comment> + </data> + <data name="facet.adult" xml:space="preserve"> + <value>adult</value> + <comment>the filter panel</comment> + </data> + <data name="facet.archived.state" xml:space="preserve"> + <value>archived games, {shown, select, true {shown} other {hidden}}</value> + <comment>the filter panel</comment> + </data> + <data name="facet.adult.state" xml:space="preserve"> + <value>games declaring adult content, {shown, select, true {shown} other {hidden}}</value> + <comment>the filter panel</comment> + </data> + <data name="facet.countsNote" xml:space="preserve"> + <value>Counts are games we measured, never estimates.</value> + <comment>the filter panel</comment> + </data> + <data name="facet.key.summary" xml:space="preserve"> + <value>what the badges and the blanks mean</value> + <comment>the filter panel</comment> + </data> + <data name="facet.key.blank" xml:space="preserve"> + <value>A blank is a gap in our measurement, not a no. Each facet spells its own: not identified, not declared, nothing negotiated.</value> + <comment>the filter panel</comment> + </data> + <data name="facet.key.zero" xml:space="preserve"> + <value>A measured zero is a count. An unknown count is not a zero and never sorts as one.</value> + <comment>the filter panel</comment> + </data> + <data name="facet.key.openEnded" xml:space="preserve"> + <value>Open-ended facets list their {count} commonest values. The rest are reachable by search and by URL.</value> + <comment>the filter panel</comment> + </data> + <data name="facet.presence.note" xml:space="preserve"> + <value>Unticked means not measured — not that the game lacks it.</value> + <comment>the filter panel</comment> + </data> + <data name="facet.group.band" xml:space="preserve"> + <value>activity</value> + <comment>facet groups</comment> + </data> + <data name="facet.group.seen" xml:space="preserve"> + <value>last seen</value> + <comment>facet groups</comment> + </data> + <data name="facet.group.protocol" xml:space="preserve"> + <value>protocols offered</value> + <comment>facet groups</comment> + </data> + <data name="facet.group.tls" xml:space="preserve"> + <value>encrypted</value> + <comment>facet groups</comment> + </data> + <data name="facet.group.charset" xml:space="preserve"> + <value>encoding</value> + <comment>facet groups</comment> + </data> + <data name="facet.group.codebase" xml:space="preserve"> + <value>codebase</value> + <comment>facet groups</comment> + </data> + <data name="facet.group.version" xml:space="preserve"> + <value>version</value> + <comment>facet groups</comment> + </data> + <data name="facet.group.lineage" xml:space="preserve"> + <value>lineage</value> + <comment>facet groups</comment> + </data> + <data name="facet.group.family" xml:space="preserve"> + <value>family</value> + <comment>facet groups</comment> + </data> + <data name="facet.group.genre" xml:space="preserve"> + <value>genre</value> + <comment>facet groups</comment> + </data> + <data name="facet.group.language" xml:space="preserve"> + <value>language</value> + <comment>facet groups</comment> + </data> + <data name="facet.band.playersNow" xml:space="preserve"> + <value>connected now</value> + <comment>facet values</comment> + </data> + <data name="facet.band.activeThisWeek" xml:space="preserve"> + <value>active this week</value> + <comment>facet values</comment> + </data> + <data name="facet.band.quiet" xml:space="preserve"> + <value>quiet — no count above 0</value> + <comment>facet values</comment> + </data> + <data name="facet.band.dark" xml:space="preserve"> + <value>dark — not reached in a month</value> + <comment>facet values</comment> + </data> + <data name="facet.band.archived" xml:space="preserve"> + <value>archived</value> + <comment>facet values</comment> + </data> + <data name="facet.seen.day" xml:space="preserve"> + <value>in the last 24 hours</value> + <comment>facet values</comment> + </data> + <data name="facet.seen.week" xml:space="preserve"> + <value>in the last 7 days</value> + <comment>facet values</comment> + </data> + <data name="facet.seen.month" xml:space="preserve"> + <value>in the last 30 days</value> + <comment>facet values</comment> + </data> + <data name="facet.seen.older" xml:space="preserve"> + <value>longer ago</value> + <comment>facet values</comment> + </data> + <data name="facet.seen.never" xml:space="preserve"> + <value>never reached</value> + <comment>facet values</comment> + </data> + <data name="facet.unknown.charset" xml:space="preserve"> + <value>nothing negotiated</value> + <comment>facet values</comment> + </data> + <data name="facet.unknown.codebase" xml:space="preserve"> + <value>not identified</value> + <comment>facet values</comment> + </data> + <data name="facet.unknown.other" xml:space="preserve"> + <value>not declared</value> + <comment>facet values</comment> + </data> + <data name="facet.tls.yes" xml:space="preserve"> + <value>connected over TLS</value> + <comment>facet values</comment> + </data> + <data name="facet.excluded" xml:space="preserve"> + <value>not {value}</value> + <comment>facet values</comment> + </data> + <data name="facet.known.charset" xml:space="preserve"> + <value>something negotiated</value> + <comment>facet values</comment> + </data> + <data name="facet.known.codebase" xml:space="preserve"> + <value>identified at all</value> + <comment>facet values</comment> + </data> + <data name="facet.known.other" xml:space="preserve"> + <value>declared at all</value> + <comment>facet values</comment> + </data> + <data name="evidence.measured.meaning" xml:space="preserve"> + <value>we watched this happen</value> + <comment>evidence, and what each word means</comment> + </data> + <data name="evidence.declared.meaning" xml:space="preserve"> + <value>the game says so, and we did not check</value> + <comment>evidence, and what each word means</comment> + </data> + <data name="evidence.derived.meaning" xml:space="preserve"> + <value>we grouped what the game told us</value> + <comment>evidence, and what each word means</comment> + </data> + <data name="sort.name" xml:space="preserve"> + <value>name</value> + <comment>sort orders</comment> + </data> + <data name="sort.players" xml:space="preserve"> + <value>connected now</value> + <comment>sort orders</comment> + </data> + <data name="sort.reached" xml:space="preserve"> + <value>last reached</value> + <comment>sort orders</comment> + </data> + <data name="sort.medianWeek" xml:space="preserve"> + <value>typically on · 7 days</value> + <comment>sort orders</comment> + </data> + <data name="sort.medianMonth" xml:space="preserve"> + <value>typically on · 30 days</value> + <comment>sort orders</comment> + </data> + <data name="sort.medianQuarter" xml:space="preserve"> + <value>typically on · 90 days</value> + <comment>sort orders</comment> + </data> + <data name="sort.peakWeek" xml:space="preserve"> + <value>most on at once · 7 days</value> + <comment>sort orders</comment> + </data> + <data name="sort.peakMonth" xml:space="preserve"> + <value>most on at once · 30 days</value> + <comment>sort orders</comment> + </data> + <data name="sort.peakQuarter" xml:space="preserve"> + <value>most on at once · 90 days</value> + <comment>sort orders</comment> + </data> + <data name="sort.group.row" xml:space="preserve"> + <value>on the row now</value> + <comment>sort orders</comment> + </data> + <data name="sort.group.typical" xml:space="preserve"> + <value>typical</value> + <comment>sort orders</comment> + </data> + <data name="sort.group.peak" xml:space="preserve"> + <value>peak</value> + <comment>sort orders</comment> + </data> + <data name="sort.unranked.players" xml:space="preserve"> + <value>Unknown count</value> + <comment>sort orders</comment> + </data> + <data name="sort.unranked.reached" xml:space="preserve"> + <value>never once reached — not reached long ago</value> + <comment>sort orders</comment> + </data> + <data name="sort.unranked.median" xml:space="preserve"> + <value>fewer than {minimum} counts in the window, or none at all — not a typical count of zero</value> + <comment>sort orders</comment> + </data> + <data name="sort.unranked.window" xml:space="preserve"> + <value>nothing we could count in the window — not a game nobody was on</value> + <comment>sort orders</comment> + </data> + <data name="sort.window.median" xml:space="preserve"> + <value>median {value} · {days, plural, one {#d} other {#d}} · {count, plural, one {# count} other {# counts}}</value> + <comment>sort orders</comment> + </data> + <data name="sort.window.peak" xml:space="preserve"> + <value>most {value} at once · {days, plural, one {#d} other {#d}} · {count, plural, one {# count} other {# counts}}</value> + <comment>sort orders</comment> + </data> + <data name="game.connectScreen" xml:space="preserve"> + <value>Connect screen</value> + <comment>the game page's own headings</comment> + </data> + <data name="game.connectionsByHour" xml:space="preserve"> + <value>Connections by hour</value> + <comment>the game page's own headings</comment> + </data> + <data name="game.howMany" xml:space="preserve"> + <value>How many, over time</value> + <comment>the game page's own headings</comment> + </data> + <data name="game.reachable" xml:space="preserve"> + <value>Reachable</value> + <comment>the game page's own headings</comment> + </data> + <data name="game.whatChanged" xml:space="preserve"> + <value>What changed</value> + <comment>the game page's own headings</comment> + </data> + <data name="game.capabilities" xml:space="preserve"> + <value>Capabilities</value> + <comment>the game page's own headings</comment> + </data> + <data name="game.declaredByGame" xml:space="preserve"> + <value>Declared by the game</value> + <comment>the game page's own headings</comment> + </data> + <data name="game.referrals" xml:space="preserve"> + <value>Referrals</value> + <comment>the game page's own headings</comment> + </data> + <data name="game.unclaimed" xml:space="preserve"> + <value>Unclaimed — everything here was measured.</value> + <comment>the game page's own headings</comment> + </data> + <data name="game.claimed" xml:space="preserve"> + <value>Claimed by its owner — measured facts below are still ours.</value> + <comment>the game page's own headings</comment> + </data> + <data name="game.claim" xml:space="preserve"> + <value>Claim this game</value> + <comment>the game page's own headings</comment> + </data> + <data name="game.answeringSince" xml:space="preserve"> + <value>answering since {date}</value> + <comment>the game page's own headings</comment> + </data> + <data name="game.readAsTextRows" xml:space="preserve"> + <value>read as text — {count, plural, one {# row} other {# rows}}</value> + <comment>the game page's own headings</comment> + </data> + <data name="capability.column" xml:space="preserve"> + <value>capability</value> + <comment>the game page's own headings</comment> + </data> + <data name="capability.age" xml:space="preserve"> + <value>age</value> + <comment>the game page's own headings</comment> + </data> + <data name="capability.offered" xml:space="preserve"> + <value>offered</value> + <comment>the game page's own headings</comment> + </data> + <data name="capability.silent" xml:space="preserve"> + <value>silent</value> + <comment>the game page's own headings</comment> + </data> + <data name="capability.absent" xml:space="preserve"> + <value>absent</value> + <comment>the game page's own headings</comment> + </data> + <data name="capability.denied" xml:space="preserve"> + <value>denied</value> + <comment>the game page's own headings</comment> + </data> + <data name="capability.claimed" xml:space="preserve"> + <value>claimed</value> + <comment>the game page's own headings</comment> + </data> + <data name="capability.disagrees" xml:space="preserve"> + <value>disagrees</value> + <comment>the game page's own headings</comment> + </data> + <data name="capability.whereTheyDisagree" xml:space="preserve"> + <value>where they disagree ({count})</value> + <comment>the game page's own headings</comment> + </data> + <data name="activity.cell.counted" xml:space="preserve"> + <value>{day} {time} — {count, plural, =0 {0 players, measured} one {# player on average} other {# players on average}}</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.cell.notCounted" xml:space="preserve"> + <value>{day} {time} — probed, no count could be read</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.cell.notMeasured" xml:space="preserve"> + <value>{day} {time} — no measurement in this hour</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.none" xml:space="preserve"> + <value>We have not measured this game's activity yet.</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.noCount" xml:space="preserve"> + <value>No hour of the week has produced a player count.</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.allZero" xml:space="preserve"> + <value>Measured every hour and nobody has been on in any of them.</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.gap.day" xml:space="preserve"> + <value>{count, plural, one {# hour on {day} has no measurement yet.} other {# hours on {day} have no measurement yet.}}</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.gap.week" xml:space="preserve"> + <value>{count, plural, one {# hour across the week has no measurement yet.} other {# hours across the week have no measurement yet.}}</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.uncounted.day" xml:space="preserve"> + <value>{count, plural, one {# hour on {day} answered but produced no count.} other {# hours on {day} answered but produced no count.}}</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.uncounted.week" xml:space="preserve"> + <value>{count, plural, one {# hour across the week answered but produced no count.} other {# hours across the week answered but produced no count.}}</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.busiest.everyDay" xml:space="preserve"> + <value>Busiest every day, {window}.</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.busiest.everyDay.part" xml:space="preserve"> + <value>Busiest every day, {part}, {window}.</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.busiest.days" xml:space="preserve"> + <value>Busiest {days} {window}.</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.busiest.days.part" xml:space="preserve"> + <value>Busiest {days} {part}, {window}.</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.quiet" xml:space="preserve"> + <value>Reliably quiet {who}, {window}.</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.quiet.part" xml:space="preserve"> + <value>Reliably quiet {who} in the {part}, {window}.</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.quiet.everyDay" xml:space="preserve"> + <value>every day</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.quiet.everyMeasuredDay" xml:space="preserve"> + <value>every day we could measure</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.quiet.weekdays" xml:space="preserve"> + <value>on weekdays</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.quiet.onDays" xml:space="preserve"> + <value>on {days}</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.part.morning" xml:space="preserve"> + <value>morning</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.part.afternoon" xml:space="preserve"> + <value>afternoon</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.part.evening" xml:space="preserve"> + <value>evening</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.part.smallHours" xml:space="preserve"> + <value>small hours</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.parts.morning" xml:space="preserve"> + <value>mornings</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.parts.afternoon" xml:space="preserve"> + <value>afternoons</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.parts.evening" xml:space="preserve"> + <value>evenings</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.parts.smallHours" xml:space="preserve"> + <value>small hours</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.days.list" xml:space="preserve"> + <value>{list}, {next}</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.days.pair" xml:space="preserve"> + <value>{first} and {second}</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.sparse.kicker" xml:space="preserve"> + <value>not enough measurements yet</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.sparse.none" xml:space="preserve"> + <value>No hour of the week has a measurement yet.</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.sparse.uncounted" xml:space="preserve"> + <value>{count, plural, one {# hour answered and produced no count.} other {# hours answered and produced no count.}}</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.sparse.wait" xml:space="preserve"> + <value>The grid appears once every day of the week has one.</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.sparse.days" xml:space="preserve"> + <value>{days, plural, one {Measured on # of the seven days so far; the grid appears once every day has an hour in it.} other {Measured on # of the seven days so far; the grid appears once every day has an hour in it.}}</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.sample.zero" xml:space="preserve"> + <value>{count, plural, one {# hour measured, all of it at nobody on.} other {# hours measured, all of them at nobody on.}}</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.sample.peak" xml:space="preserve"> + <value>{count, plural, one {# hour measured, the busiest {peak} on {day} at {time} UTC.} other {# hours measured, the busiest {peak} on {day} at {time} UTC.}}</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.sample.more" xml:space="preserve"> + <value>{count, plural, one {# more hour answered and produced no count.} other {# more hours answered and produced no count.}}</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.day.line" xml:space="preserve"> + <value>{day} — {facts}</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.day.facts" xml:space="preserve"> + <value>{first}, {second}</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.day.allZero" xml:space="preserve"> + <value>measured at zero all day</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.day.peak" xml:space="preserve"> + <value>peak {count} at {time}</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.day.nobodyOn" xml:space="preserve"> + <value>nobody on {window}</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.day.noCount" xml:space="preserve"> + <value>no count in any hour</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.day.notMeasured" xml:space="preserve"> + <value>{count, plural, one {# hour not measured} other {# hours not measured}}</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.day.notCounted" xml:space="preserve"> + <value>{count, plural, one {# hour probed but uncountable} other {# hours probed but uncountable}}</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.column.day" xml:space="preserve"> + <value>day</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.column.quietest" xml:space="preserve"> + <value>quietest</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.column.busiest" xml:space="preserve"> + <value>busiest</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.column.at" xml:space="preserve"> + <value>at</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.column.noCount" xml:space="preserve"> + <value>no count</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.caption" xml:space="preserve"> + <value>Players on by day, in UTC. {window}.</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.times" xml:space="preserve"> + <value>times in UTC · {window}</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.rollingAverage" xml:space="preserve"> + <value>{weeks, plural, one {#-week rolling average} other {#-week rolling average}}</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.legend.counted" xml:space="preserve"> + <value>counted, including a measured zero</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.legend.notCounted" xml:space="preserve"> + <value>probed, no count could be read</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.legend.notMeasured" xml:space="preserve"> + <value>no measurement in that hour</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.plain.heading" xml:space="preserve"> + <value>When people are on (UTC)</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.key.counted" xml:space="preserve"> + <value>counted</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.key.counted.meaning" xml:space="preserve"> + <value>we got in and read a number, including a measured zero</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.key.uncounted.meaning" xml:space="preserve"> + <value>we got in and no number could be read</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.key.notMeasured.meaning" xml:space="preserve"> + <value>we have no measurement for that hour</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="locale.label" xml:space="preserve"> + <value>language</value> + <comment>the switcher's own chrome, which has to read in the locale being left</comment> + </data> + <data name="locale.submit" xml:space="preserve"> + <value>change language</value> + <comment>the switcher's own chrome, which has to read in the locale being left</comment> + </data> + <data name="about.title" xml:space="preserve"> + <value>About mu*index</value> + <comment>about: the page, and what a fact here is</comment> + </data> + <data name="about.lede" xml:space="preserve"> + <value>Every game here was measured by a machine that connected to it, and every value says where it came from and when. This page covers what that proves, what we get wrong, whose directories we read, and how to make the crawler stop.</value> + <comment>about: the page, and what a fact here is</comment> + </data> + <data name="about.measures.heading" xml:space="preserve"> + <value>What a fact here is</value> + <comment>about: the page, and what a fact here is</comment> + </data> + <data name="about.measures.declared.lead" xml:space="preserve"> + <value>Measured beats declared, and both are shown.</value> + <comment>about: the page, and what a fact here is</comment> + </data> + <data name="about.measures.declared.body" xml:space="preserve"> + <value>A game's MSSP report is the game describing itself. The telnet handshake is what we watched it do. Both appear on its page, labelled with how and when. Where they disagree, we show the disagreement.</value> + <comment>about: the page, and what a fact here is</comment> + </data> + <data name="about.measures.count.lead" xml:space="preserve"> + <value>A player count says where it came from.</value> + <comment>about: the page, and what a fact here is</comment> + </data> + <data name="about.measures.count.body" xml:space="preserve"> + <value>Either a WHO or DOING read at the connect screen, which we counted, or the game's own MSSP PLAYERS field, which it published. Never merged.</value> + <comment>about: the page, and what a fact here is</comment> + </data> + <data name="about.measures.unknown.lead" xml:space="preserve"> + <value>An answer we cannot read is unknown, never zero.</value> + <comment>about: the page, and what a fact here is</comment> + </data> + <data name="about.measures.unknown.body" xml:space="preserve"> + <value>Servers customise their WHO headers freely, and past a point our parser cannot read one. That is uncountable, its own state. A measured zero — we got in, nobody was there — is a count, and prints as one.</value> + <comment>about: the page, and what a fact here is</comment> + </data> + <data name="about.measures.reachable.lead" xml:space="preserve"> + <value>Reachable, never uptime.</value> + <comment>about: the page, and what a fact here is</comment> + </data> + <data name="about.measures.reachable.body" xml:space="preserve"> + <value>We open a socket from one host at intervals. A game we cannot route to is unreachable and perfectly alive. Nothing here claims a game's uptime, because nothing here measured it.</value> + <comment>about: the page, and what a fact here is</comment> + </data> + <data name="about.measures.hour.lead" xml:space="preserve"> + <value>An hour is counted, uncountable, or not measured.</value> + <comment>about: the page, and what a fact here is</comment> + </data> + <data name="about.measures.hour.body" xml:space="preserve"> + <value>The activity grid has three states. The third is empty and names no cause: an hour we could not reach and an hour we never probed are the same absence, and neither is that server's downtime.</value> + <comment>about: the page, and what a fact here is</comment> + </data> + <data name="about.limits.heading" xml:space="preserve"> + <value>What we know we get wrong</value> + <comment>about: what we know we get wrong</comment> + </data> + <data name="about.limits.grace.lead" xml:space="preserve"> + <value>Archive grace is measured from the day we found you.</value> + <comment>about: what we know we get wrong</comment> + </data> + <data name="about.limits.grace.body" xml:space="preserve"> + <value>A game that stops answering leaves the default listing after its grace period: a quarter of the reachable time we probed, floored at 60 days and capped at 365. A game running since 1995 starts at the floor on the day we discover it. We import nothing to fill in the years before we arrived.</value> + <comment>about: what we know we get wrong</comment> + </data> + <data name="about.limits.created.lead" xml:space="preserve"> + <value>We do not credit MSSP CREATED toward that grace.</value> + <comment>about: what we know we get wrong</comment> + </data> + <data name="about.limits.created.body" xml:space="preserve"> + <value>It is one hand-typed line in a config file, so crediting it would make the archive threshold gameable. It is shown as a declaration and buys nothing.</value> + <comment>about: what we know we get wrong</comment> + </data> + <data name="about.limits.claim.lead" xml:space="preserve"> + <value>Claiming a game earns the ceiling.</value> + <comment>about: what we know we get wrong</comment> + </data> + <data name="about.limits.claim.body" xml:space="preserve"> + <value>Proving server access is worth the full year of grace, however long we have been watching.</value> + <comment>about: what we know we get wrong</comment> + </data> + <data name="about.limits.oneHost.lead" xml:space="preserve"> + <value>Everything here is one host, looking at intervals.</value> + <comment>about: what we know we get wrong</comment> + </data> + <data name="about.limits.oneHost.body" xml:space="preserve"> + <value>A percentage of reachable time is a fraction of the window we observed, never of one we did not. No graphic here fills in the rest.</value> + <comment>about: what we know we get wrong</comment> + </data> + <data name="about.limits.deletion.lead" xml:space="preserve"> + <value>Nothing is ever deleted.</value> + <comment>about: what we know we get wrong</comment> + </data> + <data name="about.limits.deletion.body" xml:space="preserve"> + <value>Archiving takes a game out of the default listing, the rankings and the active-today figure, and nothing else. Its page, URL, history and address survive, it keeps being probed, and one successful probe puts it back.</value> + <comment>about: what we know we get wrong</comment> + </data> + <data name="about.never.heading" xml:space="preserve"> + <value>What this site will not do</value> + <comment>about: what this site will not do</comment> + </data> + <data name="about.never.votes.lead" xml:space="preserve"> + <value>No votes, stars, ratings or recommendations.</value> + <comment>about: what this site will not do</comment> + </data> + <data name="about.never.votes.body" xml:space="preserve"> + <value>Rankings are computed from measured data only. A directory ranked by who can mobilise the most clicks describes the campaigning, not the hobby, and that is what killed the incumbents.</value> + <comment>about: what this site will not do</comment> + </data> + <data name="about.never.forums.lead" xml:space="preserve"> + <value>No forums, reviews, wikis, comments or player profiles.</value> + <comment>about: what this site will not do</comment> + </data> + <data name="about.never.forums.body" xml:space="preserve"> + <value>Orientation material — what a MUSH is, which codebase suits collaborative roleplay — is written, signed and versioned like the rest of the site.</value> + <comment>about: what this site will not do</comment> + </data> + <data name="about.never.names.lead" xml:space="preserve"> + <value>Player names are never persisted.</value> + <comment>about: what this site will not do</comment> + </data> + <data name="about.never.names.body" xml:space="preserve"> + <value>A WHO reply is parsed in memory for a count and the shape of the header. The names are not written down; aggregates use a salted hash with a rotating salt.</value> + <comment>about: what this site will not do</comment> + </data> + <data name="about.never.population.lead" xml:space="preserve"> + <value>No absolute population figure is published.</value> + <comment>about: what this site will not do</comment> + </data> + <data name="about.never.population.body" xml:space="preserve"> + <value>Per-codebase and per-protocol shares ship: a ratio over the measured set survives the games we cannot count. "How many people play MU*" does not, because that number would not survive being quoted.</value> + <comment>about: what this site will not do</comment> + </data> + <data name="about.crawler.heading" xml:space="preserve"> + <value>The crawler, and how to make it stop</value> + <comment>about: the crawler, and how to make it stop</comment> + </data> + <data name="about.crawler.probe.lead" xml:space="preserve"> + <value>A probe is one connection that never logs in.</value> + <comment>about: the crawler, and how to make it stop</comment> + </data> + <data name="about.crawler.probe.body" xml:space="preserve"> + <value>It opens a socket, negotiates telnet options, reads the connect screen, asks for MSSP by negotiating option 70, sends {commands}, and disconnects. No character, no login, nothing changed on the far side. A timeout bounds the session so a wedged probe cannot sit on a connection slot.</value> + <comment>about: the crawler, and how to make it stop</comment> + </data> + <data name="about.crawler.delay.lead" xml:space="preserve"> + <value>CRAWL DELAY wins.</value> + <comment>about: the crawler, and how to make it stop</comment> + </data> + <data name="about.crawler.delay.body" xml:space="preserve"> + <value>A game that states a preferred minimum gap in its MSSP report gets it, over our own schedule in both directions: 720 hours means monthly, not weekly. A dark game is still tried for ever at the longer interval, which is how it re-lists itself when it comes back.</value> + <comment>about: the crawler, and how to make it stop</comment> + </data> + <data name="about.crawler.referral.lead" xml:space="preserve"> + <value>A referred address is verified, never trusted.</value> + <comment>about: the crawler, and how to make it stop</comment> + </data> + <data name="about.crawler.referral.body" xml:space="preserve"> + <value>MSSP lets a game name other games. Every name is resolved before anything is dialled, and refused unless every address it resolves to is globally routable. A mixed answer refuses the whole target. Our refusal is filed as ours and never appears in a game's record as downtime.</value> + <comment>about: the crawler, and how to make it stop</comment> + </data> + <data name="about.crawler.screens.lead" xml:space="preserve"> + <value>Connect screens are shown because they are sent to everybody.</value> + <comment>about: the crawler, and how to make it stop</comment> + </data> + <data name="about.crawler.screens.body" xml:space="preserve"> + <value>A server paints its connect screen, unauthenticated, to every anonymous connection. We display it as evidence and label it. Ask and it comes down.</value> + <comment>about: the crawler, and how to make it stop</comment> + </data> + <data name="about.crawler.stop.lead" xml:space="preserve"> + <value>Say stop, and we stop — three ways.</value> + <comment>about: the crawler, and how to make it stop</comment> + </data> + <data name="about.crawler.stop.body" xml:space="preserve"> + <value>Publish {variable} 1 in your MSSP report, and the probe that reads it is the last one. Or publish a TXT record at {label}.your.host reading "{value}", which needs no MSSP support and no account here. Or write to a person. All three are honoured within one crawl cycle, recorded with the date and what we read, and enforced on the submission form too.</value> + <comment>about: the crawler, and how to make it stop</comment> + </data> + <data name="about.crawler.scope.lead" xml:space="preserve"> + <value>The MSSP field stops that listener; the record stops the host.</value> + <comment>about: the crawler, and how to make it stop</comment> + </data> + <data name="about.crawler.scope.body" xml:space="preserve"> + <value>MSSP is published by the port that answered, so it speaks for that port — MU* hosting routinely runs unrelated games on one domain, and one must not silence its neighbour. A TXT record covers every port unless it names one, as "{value}=4201". Anything there we cannot read as a port list means the whole host, so "{value}=all" works.</value> + <comment>about: the crawler, and how to make it stop</comment> + </data> + <data name="about.crawler.dns.lead" xml:space="preserve"> + <value>The DNS route is the one you can undo without asking us.</value> + <comment>about: the crawler, and how to make it stop</comment> + </data> + <data name="about.crawler.dns.body" xml:space="preserve"> + <value>A TXT record is readable without connecting to a server that told us not to, so we re-read it before every dial. Delete it and we dial again within a week. An MSSP field cannot be re-read without doing the thing you asked us to stop, so MSSP opt-outs and written requests stand until you say otherwise. That TXT lookup is all an opted-out address gets: it touches your nameserver, never your game.</value> + <comment>about: the crawler, and how to make it stop</comment> + </data> + <data name="about.crawler.stopping.lead" xml:space="preserve"> + <value>Stopping is not deleting, and it is not downtime.</value> + <comment>about: the crawler, and how to make it stop</comment> + </data> + <data name="about.crawler.stopping.body" xml:space="preserve"> + <value>A game that opts out keeps its page, its address and everything we measured before it asked. Only new data stops: the activity grid stops gaining hours and names no cause, because our decision to stop knocking is a fact about us. It is recorded on the crawl that did not happen, and in the register of who asked.</value> + <comment>about: the crawler, and how to make it stop</comment> + </data> + <data name="about.crawler.unlist.lead" xml:space="preserve"> + <value>If stopping is not enough, the listing can go too.</value> + <comment>about: the crawler, and how to make it stop</comment> + </data> + <data name="about.crawler.unlist.body" xml:space="preserve"> + <value>Once we have stopped on every address your game answers on, your dashboard offers one more thing: take it out of the listing, the rankings and the daily figure. The page and every address it has ever had still answer, and nothing is deleted — it stops being somewhere a reader arrives by browsing. It needs a verified claim, because it is a decision about your game and we record who made it. And a probe undoes it: take your opt-out back, and the next dial that gets an answer puts you back in the listing without asking us twice.</value> + <comment>about: the crawler, and how to make it stop</comment> + </data> + <data name="about.identity.announced" xml:space="preserve"> + <value>The crawler names itself {name} when a server asks what it is.</value> + <comment>about: who is knocking</comment> + </data> + <data name="about.identity.unannounced" xml:space="preserve"> + <value>The crawler is configured to call itself {name} but cannot yet say so. Its telnet library gives a client no way to set the terminal type, so your logs see that library's default, and NEW-ENVIRON is answered from the crawler host's environment. Both are gaps in the library and ours to fix there. Until then, recognise a probe by its shape: one connection, no login, a short read-only command set, gone.</value> + <comment>about: who is knocking</comment> + </data> + <data name="about.identity.crawler" xml:space="preserve"> + <value>crawler</value> + <comment>about: who is knocking</comment> + </data> + <data name="about.identity.contact" xml:space="preserve"> + <value>contact</value> + <comment>about: who is knocking</comment> + </data> + <data name="about.identity.crawler.line" xml:space="preserve"> + <value>Crawler: {name}</value> + <comment>about: who is knocking</comment> + </data> + <data name="about.identity.contact.line" xml:space="preserve"> + <value>Contact: {url}</value> + <comment>about: who is knocking</comment> + </data> + <data name="about.identity.placeholder" xml:space="preserve"> + <value>— placeholder; this deployment set no contact address</value> + <comment>about: who is knocking</comment> + </data> + <data name="about.identity.placeholder.plain" xml:space="preserve"> + <value>No contact address is configured, so the one above is a placeholder and answers nobody.</value> + <comment>about: who is knocking</comment> + </data> + <data name="about.sources.heading" xml:space="preserve"> + <value>Where the list of games came from</value> + <comment>about: where the list of games came from</comment> + </data> + <data name="about.sources.addresses.lead" xml:space="preserve"> + <value>We take addresses. Nothing else.</value> + <comment>about: where the list of games came from</comment> + </data> + <data name="about.sources.addresses.body" xml:space="preserve"> + <value>A backfill takes a host and a port. No player counts, no reachability history, no descriptions, no fields, and no note of which site an address came from.</value> + <comment>about: where the list of games came from</comment> + </data> + <data name="about.sources.less.lead" xml:space="preserve"> + <value>Deliberately less than those sites can give.</value> + <comment>about: where the list of games came from</comment> + </data> + <data name="about.sources.less.body" xml:space="preserve"> + <value>Several hold years of dated player counts. Importing that would fill the heatmaps of the games somebody else was already watching, and rest this site's central claim on another party's prober.</value> + <comment>about: where the list of games came from</comment> + </data> + <data name="about.sources.origin.lead" xml:space="preserve"> + <value>A game's origin is not one fact.</value> + <comment>about: where the list of games came from</comment> + </data> + <data name="about.sources.origin.body" xml:space="preserve"> + <value>Any game worth listing appears in several of these directories, so "imported from" would name whichever fetch ran first. That a game exists is public information; where we read it adds nothing and is the part of somebody else's work with the least claim to be ours.</value> + <comment>about: where the list of games came from</comment> + </data> + <data name="about.sources.etiquette.lead" xml:space="preserve"> + <value>Reading somebody's site is still reading somebody's site.</value> + <comment>about: where the list of games came from</comment> + </data> + <data name="about.sources.etiquette.body" xml:space="preserve"> + <value>We ask for a bulk export or a documented endpoint before scraping, read robots.txt first, and rate-limit scrapes hard. A source that needs its maintainer's say-so is not fetched until a person can state they were asked.</value> + <comment>about: where the list of games came from</comment> + </data> + <data name="about.source.read" xml:space="preserve"> + <value>read — addresses only</value> + <comment>about: where the list of games came from</comment> + </data> + <data name="about.source.withheld" xml:space="preserve"> + <value>not read — awaiting permission</value> + <comment>about: where the list of games came from</comment> + </data> + <data name="about.source.tintinMssp.note" xml:space="preserve"> + <value>One page, one request. Published by a crawler that connects to each game and prints what it read.</value> + <comment>about: where the list of games came from</comment> + </data> + <data name="about.source.tintinMsdp.note" xml:space="preserve"> + <value>The same crawler's MSDP listing. Nearly a subset of its MSSP sibling, read for the few addresses it reaches that the other does not.</value> + <comment>about: where the list of games came from</comment> + </data> + <data name="about.source.mudConnector.note" xml:space="preserve"> + <value>Publishes its whole catalogue on one page, so reading it costs a single request. Our largest source of addresses, and of no measurements.</value> + <comment>about: where the list of games came from</comment> + </data> + <data name="about.source.mudStats.note" xml:space="preserve"> + <value>One index page and one page per world, so a scrape rather than an export. On 30 July 2026 we fetched 143 of their pages, fifteen seconds apart and honouring robots.txt, but before anyone had written to them. That should not have happened. The gate now takes a person willing to state the maintainer was asked.</value> + <comment>about: where the list of games came from</comment> + </data> + <data name="about.source.mudVerse.note" xml:space="preserve"> + <value>Implemented, tested, never run. The strongest source here on every axis except permission, and nothing will be fetched until somebody has written to them.</value> + <comment>about: where the list of games came from</comment> + </data> + <data name="about.licence.heading" xml:space="preserve"> + <value>Licence</value> + <comment>about: licence</comment> + </data> + <data name="about.licence.code.lead" xml:space="preserve"> + <value>The code is MIT.</value> + <comment>about: licence</comment> + </data> + <data name="about.licence.code.body" xml:space="preserve"> + <value>The site, the crawler and the parsers are open source under the MIT licence.</value> + <comment>about: licence</comment> + </data> + <data name="about.licence.open.lead" xml:space="preserve"> + <value>The licence for the data is an open question.</value> + <comment>about: licence</comment> + </data> + <data name="about.licence.open.body" xml:space="preserve"> + <value>A separate decision from the code's, and not yet taken. Treat the terms below as this deployment's current answer, not the project's settled position. A rival directory taking the whole catalogue is a success condition here, so whatever is settled will not stand in the way of one.</value> + <comment>about: licence</comment> + </data> + <data name="about.licence.codeLabel" xml:space="preserve"> + <value>code</value> + <comment>about: licence</comment> + </data> + <data name="about.licence.dataLabel" xml:space="preserve"> + <value>data, as this deployment serves it</value> + <comment>about: licence</comment> + </data> + <data name="about.licence.creditLabel" xml:space="preserve"> + <value>credit as</value> + <comment>about: licence</comment> + </data> + <data name="about.licence.code.line" xml:space="preserve"> + <value>Code: {licence}</value> + <comment>about: licence</comment> + </data> + <data name="about.licence.data.line" xml:space="preserve"> + <value>Data: {licence}</value> + <comment>about: licence</comment> + </data> + <data name="about.licence.credit.line" xml:space="preserve"> + <value>Credit as: {credit}</value> + <comment>about: licence</comment> + </data> + <data name="about.licence.deployment" xml:space="preserve"> + <value>(what this deployment serves. The project's own answer is still open.)</value> + <comment>about: licence</comment> + </data> + <data name="submit.title" xml:space="preserve"> + <value>Submit a game</value> + <comment>submit a game</comment> + </data> + <data name="submit.lede" xml:space="preserve"> + <value>Tell us where a game is. A host and a port is the whole form; everything else on this site is measured by our own crawler.</value> + <comment>submit a game</comment> + </data> + <data name="submit.host.label" xml:space="preserve"> + <value>Host</value> + <comment>submit a game</comment> + </data> + <data name="submit.port.label" xml:space="preserve"> + <value>Port</value> + <comment>submit a game</comment> + </data> + <data name="submit.host.hint" xml:space="preserve"> + <value>mud.example.org, or paste mud.example.org:4201 and leave the port empty</value> + <comment>submit a game</comment> + </data> + <data name="submit.button" xml:space="preserve"> + <value>Submit</value> + <comment>submit a game</comment> + </data> + <data name="submit.noCatalogue" xml:space="preserve"> + <value>Submitting needs a database, and this site is running on the demo fixture. There is no crawl registry to write into, so the form is absent rather than quietly doing nothing.</value> + <comment>submit a game</comment> + </data> + <data name="submit.notHere" xml:space="preserve"> + <value>Not here</value> + <comment>submit a game</comment> + </data> + <data name="submit.what.heading" xml:space="preserve"> + <value>What happens to an address</value> + <comment>submit a game</comment> + </data> + <data name="submit.what.resolve" xml:space="preserve"> + <value>We resolve the address before dialling it, and refuse anything that resolves off the public internet. That is a decision about our own socket, never a fact about a game.</value> + <comment>submit a game</comment> + </data> + <data name="submit.what.optOut" xml:space="preserve"> + <value>If whoever runs that host has asked us not to crawl it, we will not take the address, whoever submits it. A stranger cannot put your game back on this site.</value> + <comment>submit a game</comment> + </data> + <data name="submit.what.schedule" xml:space="preserve"> + <value>If it answers, we read what the server says for itself and keep reading it on its own schedule, for ever. An address only has to be given once.</value> + <comment>submit a game</comment> + </data> + <data name="submit.what.claim" xml:space="preserve"> + <value>Nothing appears on the site until somebody proves they run it. Claiming takes a passkey and one line published on the game itself.</value> + <comment>submit a game</comment> + </data> + <data name="submit.what.duplicate" xml:space="preserve"> + <value>An address we already have collapses onto the existing entry. Sending it twice makes no second listing and brings no probe forward.</value> + <comment>submit a game</comment> + </data> + <data name="submit.answer.thatAddress" xml:space="preserve"> + <value>that address</value> + <comment>submit a game</comment> + </data> + <data name="submit.accepted.heading" xml:space="preserve"> + <value>In the registry.</value> + <comment>submit a game</comment> + </data> + <data name="submit.accepted.sentence" xml:space="preserve"> + <value>{address} will be dialled on the next crawl cycle, then on its own schedule for ever. It appears here once somebody proves they run it — come back to this form with the same address and it will hand you the link.</value> + <comment>submit a game</comment> + </data> + <data name="submit.unclaimed.heading" xml:space="preserve"> + <value>We have it, unclaimed.</value> + <comment>submit a game</comment> + </data> + <data name="submit.unclaimed.sentence" xml:space="preserve"> + <value>{address} is one we already measure. It stays off the site until somebody proves they run it. If that is you, this is the way in.</value> + <comment>submit a game</comment> + </data> + <data name="submit.known.heading" xml:space="preserve"> + <value>We already have that one.</value> + <comment>submit a game</comment> + </data> + <data name="submit.known.sentence" xml:space="preserve"> + <value>{address} is a game we already measure. Nothing was created and nothing was changed.</value> + <comment>submit a game</comment> + </data> + <data name="submit.knownAddress.heading" xml:space="preserve"> + <value>We already have that address.</value> + <comment>submit a game</comment> + </data> + <data name="submit.knownAddress.sentence" xml:space="preserve"> + <value>{address} is already known to us. Nothing was created and nothing was changed.</value> + <comment>submit a game</comment> + </data> + <data name="submit.queued.heading" xml:space="preserve"> + <value>Already waiting.</value> + <comment>submit a game</comment> + </data> + <data name="submit.queued.sentence" xml:space="preserve"> + <value>{address} is in the crawl registry and has not answered yet. Sending it again does not bring it forward: a target keeps its own schedule, so nobody can hurry us at somebody else's server.</value> + <comment>submit a game</comment> + </data> + <data name="submit.malformed.heading" xml:space="preserve"> + <value>Not an address we can dial.</value> + <comment>submit a game</comment> + </data> + <data name="submit.malformed.sentence" xml:space="preserve"> + <value>A host needs a dot or a colon in it, and a port is a number between 1 and 65535. Fill in both boxes, or paste mud.example.org:4201 into the first.</value> + <comment>submit a game</comment> + </data> + <data name="submit.undialable.heading" xml:space="preserve"> + <value>We cannot dial that.</value> + <comment>submit a game</comment> + </data> + <data name="submit.undialable.sentence" xml:space="preserve"> + <value>Three things produce this answer for {address}: the name may not resolve, it may resolve off the public internet, or whoever runs that host may have asked us to stay away. We deliberately do not say which, because answering that for a stranger maps a network from outside it. Nothing was recorded about the address; the decision was ours and it is filed as ours.</value> + <comment>submit a game</comment> + </data> + <data name="submit.tooMany.heading" xml:space="preserve"> + <value>Enough for now.</value> + <comment>submit a game</comment> + </data> + <data name="submit.tooMany.sentence" xml:space="preserve"> + <value>This form is rate-limited by sender, and you have hit the bound. Come back in an hour. Nothing was lost — anything we took is already in the registry.</value> + <comment>submit a game</comment> + </data> + <data name="submit.link.claim" xml:space="preserve"> + <value>claim this game</value> + <comment>submit a game</comment> + </data> + <data name="account.signIn.title" xml:space="preserve"> + <value>Sign in</value> + <comment>signing in, which is a passkey and nothing else</comment> + </data> + <data name="account.signIn.preview" xml:space="preserve"> + <value>Sign in with a passkey to claim a game you run. There is no password to lose and none to steal.</value> + <comment>signing in, which is a passkey and nothing else</comment> + </data> + <data name="account.signIn.noDatabase" xml:space="preserve"> + <value>Claiming needs a database, and this site is running on the demo fixture. There is nothing to sign in to.</value> + <comment>signing in, which is a passkey and nothing else</comment> + </data> + <data name="account.signIn.passkey.lead" xml:space="preserve"> + <value>Sign-in is a passkey.</value> + <comment>signing in, which is a passkey and nothing else</comment> + </data> + <data name="account.signIn.passkey.body" xml:space="preserve"> + <value>Your device or password manager holds the private key; we hold only the public half. No password, no email.</value> + <comment>signing in, which is a passkey and nothing else</comment> + </data> + <data name="account.signIn.button" xml:space="preserve"> + <value>Sign in with a passkey</value> + <comment>signing in, which is a passkey and nothing else</comment> + </data> + <data name="account.signIn.script" xml:space="preserve"> + <value>The one page here that needs JavaScript. Passkeys cannot work without it.</value> + <comment>signing in, which is a passkey and nothing else</comment> + </data> + <data name="account.register.heading" xml:space="preserve"> + <value>No account yet?</value> + <comment>signing in, which is a passkey and nothing else</comment> + </data> + <data name="account.register.lede" xml:space="preserve"> + <value>You need one only to claim a game you run. Pick a name to be known by — a label beside your claim, not a real name.</value> + <comment>signing in, which is a passkey and nothing else</comment> + </data> + <data name="account.register.name.label" xml:space="preserve"> + <value>Name</value> + <comment>signing in, which is a passkey and nothing else</comment> + </data> + <data name="account.register.name.placeholder" xml:space="preserve"> + <value>e.g. corvid-admin</value> + <comment>signing in, which is a passkey and nothing else</comment> + </data> + <data name="account.register.button" xml:space="preserve"> + <value>Create an account with a passkey</value> + <comment>signing in, which is a passkey and nothing else</comment> + </data> + <data name="account.store.heading" xml:space="preserve"> + <value>What we store</value> + <comment>signing in, which is a passkey and nothing else</comment> + </data> + <data name="account.store.name" xml:space="preserve"> + <value>The name you chose.</value> + <comment>signing in, which is a passkey and nothing else</comment> + </data> + <data name="account.store.keys" xml:space="preserve"> + <value>The public key of each passkey you register, and what your device called it.</value> + <comment>signing in, which is a passkey and nothing else</comment> + </data> + <data name="account.store.claims" xml:space="preserve"> + <value>Which games you have claimed, and when.</value> + <comment>signing in, which is a passkey and nothing else</comment> + </data> + <data name="account.store.note" xml:space="preserve"> + <value>No email address, no password, no IP log tied to your account. Lose every passkey and you can publish a fresh claim token on your game and start again: the game is the proof, not the account.</value> + <comment>signing in, which is a passkey and nothing else</comment> + </data> + <data name="date.absolute" xml:space="preserve"> + <value>{day} {month} {year}</value> + <comment>dates, ages and provenance — the two shapes on nearly every page</comment> + </data> + <data name="date.stamp" xml:space="preserve"> + <value>{date} {time} UTC</value> + <comment>dates, ages and provenance — the two shapes on nearly every page</comment> + </data> + <data name="age.short.now" xml:space="preserve"> + <value>now</value> + <comment>the age ladder, in three registers</comment> + </data> + <data name="age.short.minutes" xml:space="preserve"> + <value>{count, plural, one {#m} other {#m}}</value> + <comment>the age ladder, in three registers</comment> + </data> + <data name="age.short.hours" xml:space="preserve"> + <value>{count, plural, one {#h} other {#h}}</value> + <comment>the age ladder, in three registers</comment> + </data> + <data name="age.short.days" xml:space="preserve"> + <value>{count, plural, one {#d} other {#d}}</value> + <comment>the age ladder, in three registers</comment> + </data> + <data name="age.short.weeks" xml:space="preserve"> + <value>{count, plural, one {#w} other {#w}}</value> + <comment>the age ladder, in three registers</comment> + </data> + <data name="age.short.months" xml:space="preserve"> + <value>{count, plural, one {#mo} other {#mo}}</value> + <comment>the age ladder, in three registers</comment> + </data> + <data name="age.short.years" xml:space="preserve"> + <value>{count, plural, one {#y} other {#y}}</value> + <comment>the age ladder, in three registers</comment> + </data> + <data name="age.ago.now" xml:space="preserve"> + <value>just now</value> + <comment>the age ladder, in three registers</comment> + </data> + <data name="age.ago.minutes" xml:space="preserve"> + <value>{count, plural, one {#m ago} other {#m ago}}</value> + <comment>the age ladder, in three registers</comment> + </data> + <data name="age.ago.hours" xml:space="preserve"> + <value>{count, plural, one {#h ago} other {#h ago}}</value> + <comment>the age ladder, in three registers</comment> + </data> + <data name="age.ago.days" xml:space="preserve"> + <value>{count, plural, one {#d ago} other {#d ago}}</value> + <comment>the age ladder, in three registers</comment> + </data> + <data name="age.ago.weeks" xml:space="preserve"> + <value>{count, plural, one {#w ago} other {#w ago}}</value> + <comment>the age ladder, in three registers</comment> + </data> + <data name="age.ago.months" xml:space="preserve"> + <value>{count, plural, one {#mo ago} other {#mo ago}}</value> + <comment>the age ladder, in three registers</comment> + </data> + <data name="age.ago.years" xml:space="preserve"> + <value>{count, plural, one {#y ago} other {#y ago}}</value> + <comment>the age ladder, in three registers</comment> + </data> + <data name="age.dark.now" xml:space="preserve"> + <value>just now</value> + <comment>the age ladder, in three registers</comment> + </data> + <data name="age.dark.minutes" xml:space="preserve"> + <value>{count, plural, one {#m ago} other {#m ago}}</value> + <comment>the age ladder, in three registers</comment> + </data> + <data name="age.dark.hours" xml:space="preserve"> + <value>{count, plural, one {#h ago} other {#h ago}}</value> + <comment>the age ladder, in three registers</comment> + </data> + <data name="age.dark.days" xml:space="preserve"> + <value>{count, plural, one {#d ago} other {#d ago}}</value> + <comment>the age ladder, in three registers</comment> + </data> + <data name="age.dark.weeks" xml:space="preserve"> + <value>{count, plural, one {#w ago} other {#w ago}}</value> + <comment>the age ladder, in three registers</comment> + </data> + <data name="age.dark.months" xml:space="preserve"> + <value>{count, plural, one {#mo ago} other {#mo ago}}</value> + <comment>the age ladder, in three registers</comment> + </data> + <data name="age.dark.years" xml:space="preserve"> + <value>{count, plural, one {#y ago} other {#y ago}}</value> + <comment>the age ladder, in three registers</comment> + </data> + <data name="time.title" xml:space="preserve"> + <value>{age}, {stamp}</value> + <comment>the age ladder, in three registers</comment> + </data> + <data name="time.spoken" xml:space="preserve"> + <value>, {stamp}</value> + <comment>the age ladder, in three registers</comment> + </data> + <data name="chip.title" xml:space="preserve"> + <value>{value} — {how} via {source}, last confirmed {date}</value> + <comment>the provenance chip's tooltip</comment> + </data> + <data name="chip.title.stale" xml:space="preserve"> + <value>{value} — {how} via {source}, last confirmed {date} (past its expected refresh)</value> + <comment>the provenance chip's tooltip</comment> + </data> + <data name="chip.plain" xml:space="preserve"> + <value>({how}, {age})</value> + <comment>the provenance chip's tooltip</comment> + </data> + <data name="chip.plain.stale" xml:space="preserve"> + <value>({how}, {age}, stale)</value> + <comment>the provenance chip's tooltip</comment> + </data> + <data name="provenance.game.ownerDeclared" xml:space="preserve"> + <value>owner-declared</value> + <comment>the provenance chip's tooltip</comment> + </data> + <data name="source.staff" xml:space="preserve"> + <value>staff</value> + <comment>how a value reached us, one id per source</comment> + </data> + <data name="source.handshake" xml:space="preserve"> + <value>the telnet handshake</value> + <comment>how a value reached us, one id per source</comment> + </data> + <data name="source.owner" xml:space="preserve"> + <value>the owner</value> + <comment>how a value reached us, one id per source</comment> + </data> + <data name="source.who" xml:space="preserve"> + <value>WHO</value> + <comment>how a value reached us, one id per source</comment> + </data> + <data name="source.i3" xml:space="preserve"> + <value>I3</value> + <comment>how a value reached us, one id per source</comment> + </data> + <data name="source.mssp" xml:space="preserve"> + <value>MSSP</value> + <comment>how a value reached us, one id per source</comment> + </data> + <data name="source.info" xml:space="preserve"> + <value>INFO</value> + <comment>how a value reached us, one id per source</comment> + </data> + <data name="source.i3Mudlist" xml:space="preserve"> + <value>the I3 mudlist</value> + <comment>how a value reached us, one id per source</comment> + </data> + <data name="source.banner" xml:space="preserve"> + <value>the connect screen</value> + <comment>how a value reached us, one id per source</comment> + </data> + <data name="ecosystem.title" xml:space="preserve"> + <value>The ecosystem</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.noTotals" xml:space="preserve"> + <value>Shares, never totals. We do not publish a figure for how many people play MU*: a ratio over the games we measured survives the ones we cannot reach, and a headcount does not.</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.listed" xml:space="preserve"> + <value>{count, plural, one {{value} game listed} other {{value} games listed}}</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.handshakes" xml:space="preserve"> + <value>{count, plural, one {{value} game whose handshake we completed} other {{value} games whose handshake we completed}}</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.msspReports" xml:space="preserve"> + <value>{count, plural, one {{value} game whose MSSP report we hold} other {{value} games whose MSSP report we hold}}</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.oldestHandshake" xml:space="preserve"> + <value>Oldest handshake here: confirmed {age} ago.</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.share" xml:space="preserve"> + <value>{count, number} of {total, number} ({fraction, number, ::percent .0})</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.share.nothing" xml:space="preserve"> + <value>{count, number} of {total, number} — nothing measured yet</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.share.percent" xml:space="preserve"> + <value>{fraction, number, ::percent .0}</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.codebases.title" xml:space="preserve"> + <value>Codebases</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.codebases.basis" xml:space="preserve"> + <value>Of the {listed, plural, one {# game} other {# games}} listed, {identified, number} told us what they run, and every share below is over those {identified, number}. A codebase we could not read is left out of the denominator, never counted as something else.</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.codebases.none" xml:space="preserve"> + <value>No listed game has told us its codebase yet.</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.soleUse" xml:space="preserve"> + <value>{share} run a codebase no other listed game runs — one game each, which is a name rather than a share. They are inside the denominator above and folded out of the bars, not dropped:</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.lineages.title" xml:space="preserve"> + <value>Lineages</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.lineages.basis" xml:space="preserve"> + <value>The same games, grouped by the tradition their server descends from — our reading of the codebase, not anything a game published. No game reports "MUSH": MSSP has no such value, and most of the MUSH world publishes no MSSP at all, so this is the only way the question can be asked.</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.lineages.none" xml:space="preserve"> + <value>No listed game runs a codebase we place in a lineage yet.</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.lineages.notClassified" xml:space="preserve"> + <value>{count, plural, one {# of those games runs a codebase} other {# of those games run codebases}} we do not place in any lineage — several say as much themselves, publishing {family}. They are inside the denominator above and in nobody's share.</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.protocols.title" xml:space="preserve"> + <value>Protocols</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.protocols.floor" xml:space="preserve"> + <value>Read every measured figure below as a floor. We ask for MSSP by name, so silence there is an answer. Nothing else here is requested, and a server may support a protocol without ever offering it.</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.mssp.instrument" xml:space="preserve"> + <value>{instrument} is the one row below that is not a floor: we ask every server for it by name, so the games that did not offer it were asked and declined. It is also the only one with no declared figure, because every game whose report we hold supports it by demonstration and a count of the ones that also listed it would measure a habit against that.</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.mssp.gap" xml:space="preserve"> + <value>We hold {reports, number} reports and {offered, plural, one {# game} other {# games}} offer MSSP today: the other {gap, number} stopped publishing one after we read it, and a report is not thrown away because it stopped being reissued.</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.protocols.caption" xml:space="preserve"> + <value>Protocol adoption. Measured is what a server offered in a completed handshake; declared is what its MSSP claims. Two sets of games, so two denominators.</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.column.protocol" xml:space="preserve"> + <value>protocol</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.column.measured" xml:space="preserve"> + <value>measured — of {basis}</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.column.declared" xml:space="preserve"> + <value>declared — of {basis}</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.measured.never" xml:space="preserve"> + <value>not measured — never observed</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.measured.declined" xml:space="preserve"> + <value>{share} · {declined, plural, one {# game} other {# games}} declined when asked</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.measured.unasked" xml:space="preserve"> + <value>{share} · {unobserved, plural, one {# game} other {# games}} neither offered nor asked</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.measured.declinedAndUnasked" xml:space="preserve"> + <value>{share} · {declined, plural, one {# game} other {# games}} declined when asked · {unobserved, plural, one {# game} other {# games}} neither offered nor asked</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.declared.none" xml:space="preserve"> + <value>not asked — every report here is the answer</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.curve.title" xml:space="preserve"> + <value>Adoption over time</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.curve.caveat" xml:space="preserve"> + <value>Each point is a share over the games we had measured that day, so this line moves for two reasons: a game changing what it offers, and the set of games we can measure changing around it. Only the first is adoption. The transition count below is the part that is purely games changing their minds.</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.curve.caption" xml:space="preserve"> + <value>Measured share of each protocol, oldest reading first</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.curve.then" xml:space="preserve"> + <value>then</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.curve.now" xml:space="preserve"> + <value>now</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.curve.notMeasured" xml:space="preserve"> + <value>not measured</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.snapshot.title" xml:space="preserve"> + <value>A snapshot, not a curve</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.snapshot" xml:space="preserve"> + <value>A snapshot of what we can measure now. An adoption curve plots games changing their minds, and we record a change when it happens, so the curve becomes drawable once enough have been recorded. Plotting when we first reached each game would measure the crawl, not the hobby.</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.transitions" xml:space="preserve"> + <value>{count, plural, one {# capability change} other {# capability changes}} recorded so far — the material a curve is drawn from.</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.transitions.none" xml:space="preserve"> + <value>No measured capability has changed yet, so there is nothing to plot.</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.plain.denominators" xml:space="preserve"> + <value>Measured is of {measured}; declared is of {declared}. Two sets of games, so two denominators.</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.plain.counts" xml:space="preserve"> + <value>{listed} · {handshakes} · {mssp}.</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.plain.oldestHandshake" xml:space="preserve"> + <value>The oldest handshake in this picture was last confirmed {age} ago.</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.plain.lineages" xml:space="preserve"> + <value>The same games, grouped by the tradition their server descends from. This is {evidence} — {meaning} — and not anything a game published: no game reports "MUSH", because MSSP has no such value and most of the MUSH world publishes no MSSP at all.</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.plain.measured" xml:space="preserve"> + <value>measured: {value}</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.plain.declared" xml:space="preserve"> + <value>declared: {value}</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="rankings.title" xml:space="preserve"> + <value>Rankings</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.noVote" xml:space="preserve"> + <value>Computed from measured data only. No votes, stars or ratings, ever. Nothing here ranks quality. We have not measured it.</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.busiest.title" xml:space="preserve"> + <value>Busiest, by measured concurrent players</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.window.label" xml:space="preserve"> + <value>Ranking window</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.span" xml:space="preserve"> + <value>{days, plural, one {# day} other {# days}}</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.basis.median" xml:space="preserve"> + <value>Median of the player counts we measured over the last {days, plural, one {# day} other {# days}}.</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.basis.none" xml:space="preserve"> + <value>No game yet has the {samples, number} samples across {days, plural, one {# day} other {# days}} that a median needs.</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.basis.eligible" xml:space="preserve"> + <value>{eligible, plural, one {# game} other {# games}} of {listed, number} have the {samples, number} samples across {days, plural, one {# day} other {# days}} it needs.</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.basis.zero" xml:space="preserve"> + <value>A measured zero counts; an unreadable count does not.</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.spanChoice" xml:space="preserve"> + <value>A week says who is busy now; a quarter says who has been busy. They are different questions and a game can lead one and not the other. Days are whole days, UTC.</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.busiest.empty" xml:space="preserve"> + <value>No listed game has enough counted samples to rank yet — a statement about how long we have been measuring, not about how busy anybody is.</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.busiest.caption" xml:space="preserve"> + <value>Games ranked by the median of the player counts we measured over the last {days, plural, one {# day} other {# days}}. Games on the same median share a place; nothing here breaks the tie.</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.column.place" xml:space="preserve"> + <value>#</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.column.game" xml:space="preserve"> + <value>game</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.column.median" xml:space="preserve"> + <value>median</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.column.peak" xml:space="preserve"> + <value>peak</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.column.samples" xml:space="preserve"> + <value>counted samples</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.column.days" xml:space="preserve"> + <value>days measured</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.spells.title" xml:space="preserve"> + <value>Longest unbroken reachable spell</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.spells.basis" xml:space="preserve"> + <value>Every probe since the date given found the game reachable. Reachable, not up: we measure a socket from one host, and a game we cannot route to is perfectly alive. A spell cannot be longer than we have been watching, so the date is the fact and the duration follows.</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.spells.empty" xml:space="preserve"> + <value>No listed game is in an unbroken reachable spell right now.</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.spells.caption" xml:space="preserve"> + <value>Games whose every probe since the date given found them reachable. Games reachable since the same date share a place; nothing here breaks the tie.</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.column.since" xml:space="preserve"> + <value>reachable since</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.column.duration" xml:space="preserve"> + <value>that is</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.archivedNote" xml:space="preserve"> + <value>Archived games are out of both tables and nothing else; one successful probe puts them back.</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.plain.busiest" xml:space="preserve"> + <value>Busiest — median measured players, last {days, plural, one {# day} other {# days}}</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.plain.windows" xml:space="preserve"> + <value>windows:</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.plain.thisOne" xml:space="preserve"> + <value>this one</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.plain.row" xml:space="preserve"> + <value>median {median, number} · peak {peak, number} · {samples, plural, one {# counted sample} other {# counted samples}} over {days, number} of {window, number} days</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.plain.spellRow" xml:space="preserve"> + <value>reachable on every probe since {date} · {duration}</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="archive.title" xml:space="preserve"> + <value>The archive</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.lede" xml:space="preserve"> + <value>Games that have stopped answering. Nothing was deleted. Still probed weekly, and one successful probe puts a game back in the listing the same day.</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.search.legend" xml:space="preserve"> + <value>search the archive</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.search.label" xml:space="preserve"> + <value>Search archived games</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.search.placeholder" xml:space="preserve"> + <value>name, codebase or description</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.search.submit" xml:space="preserve"> + <value>show</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.count" xml:space="preserve"> + <value>{count, plural, =0 {No archived games} one {# archived game} other {# archived games}}</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.badge" xml:space="preserve"> + <value>archived</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.lastReachable" xml:space="preserve"> + <value>last reachable</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.knownLive" xml:space="preserve"> + <value>known live</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.darkFor" xml:space="preserve"> + <value>({age} ago)</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.empty" xml:space="preserve"> + <value>Nothing matched.</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.neverReachable" xml:space="preserve"> + <value>never, in anything we measured</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.noReachableTime" xml:space="preserve"> + <value>no reachable time measured</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.darkFor.unknown" xml:space="preserve"> + <value>unknown</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.knownLive.years" xml:space="preserve"> + <value>{years, number, ::.#} years</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.knownLive.days" xml:space="preserve"> + <value>{days, plural, one {# day} other {# days}}</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.run" xml:space="preserve"> + <value>{from} – {to} · {span}</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.run.months" xml:space="preserve"> + <value>{count, plural, one {# month} other {# months}}</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.run.years" xml:space="preserve"> + <value>{count, plural, one {# year} other {# years}}</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.plain.matching" xml:space="preserve"> + <value>{count, plural, one {# game} other {# games}} matching "{query}"</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.plain.count" xml:space="preserve"> + <value>{count, plural, one {# game} other {# games}}</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.plain.lastReachable" xml:space="preserve"> + <value>Last reachable:</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.plain.knownLive" xml:space="preserve"> + <value>Known live:</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.plain.knownLiveValue" xml:space="preserve"> + <value>{value} of measured reachable time</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.plain.run" xml:space="preserve"> + <value>Run:</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.plain.codebase" xml:space="preserve"> + <value>Codebase:</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="footer.randomGame" xml:space="preserve"> + <value>random game</value> + <comment>/find's footer, which the rebuild left in English</comment> + </data> + <data name="trend.day.counted" xml:space="preserve"> + <value>{d, date, medium} — {typical} on average, {low}–{high} across {probes, plural, one {# probe} other {# probes}}</value> + <comment>the trend chart's per-day title, one per column</comment> + </data> + <data name="trend.day.flat" xml:space="preserve"> + <value>{d, date, medium} — {count, plural, =0 {0 players} one {# player} other {# players}}, every one of {probes, plural, one {# probe} other {# probes}}</value> + <comment>the trend chart's per-day title, one per column</comment> + </data> + <data name="trend.day.notCounted" xml:space="preserve"> + <value>{d, date, medium} — probed, no count could be read</value> + <comment>the trend chart's per-day title, one per column</comment> + </data> + <data name="trend.day.notMeasured" xml:space="preserve"> + <value>{d, date, medium} — no measurement</value> + <comment>the trend chart's per-day title, one per column</comment> + </data> + <data name="trend.summary" xml:space="preserve"> + <value>Typically {typical} on, peaking at {peak}, over {counted} of {days, plural, one {# day} other {# days}}.</value> + <comment>the sentence above the chart</comment> + </data> + <data name="trend.direction.steady" xml:space="preserve"> + <value>Steady across the range.</value> + <comment>the sentence above the chart</comment> + </data> + <data name="trend.direction.up" xml:space="preserve"> + <value>Up about {change, number, percent} from the start of the range to the end.</value> + <comment>the sentence above the chart</comment> + </data> + <data name="trend.direction.down" xml:space="preserve"> + <value>Down about {change, number, percent} from the start of the range to the end.</value> + <comment>the sentence above the chart</comment> + </data> + <data name="trend.none.probed" xml:space="preserve"> + <value>Probed in this range, and no player count could be read from any of it.</value> + <comment>the sentence above the chart</comment> + </data> + <data name="trend.none.notMeasured" xml:space="preserve"> + <value>No measurement in this range.</value> + <comment>the sentence above the chart</comment> + </data> + <data name="trend.empty" xml:space="preserve"> + <value>Nothing counted in this range.</value> + <comment>the sentence above the chart</comment> + </data> + <data name="trend.week.span" xml:space="preserve"> + <value>{from, date, d MMM}–{to, date, d MMM}</value> + <comment>the week lines, which are the text alternative and the plain surface both</comment> + </data> + <data name="trend.week.oneDay" xml:space="preserve"> + <value>{d, date, d MMM}</value> + <comment>the week lines, which are the text alternative and the plain surface both</comment> + </data> + <data name="trend.week.counted" xml:space="preserve"> + <value>{span}: typically {typical}, peak {peak}, {days, plural, one {# day} other {# days}} counted</value> + <comment>the week lines, which are the text alternative and the plain surface both</comment> + </data> + <data name="trend.week.notCounted" xml:space="preserve"> + <value>{span}: probed, no count could be read</value> + <comment>the week lines, which are the text alternative and the plain surface both</comment> + </data> + <data name="trend.week.notMeasured" xml:space="preserve"> + <value>{span}: not measured</value> + <comment>the week lines, which are the text alternative and the plain surface both</comment> + </data> + <data name="trend.week.uncounted" xml:space="preserve"> + <value>{count, plural, one {# day probed without a count} other {# days probed without a count}}</value> + <comment>the week lines, which are the text alternative and the plain surface both</comment> + </data> + <data name="trend.week.unmeasured" xml:space="preserve"> + <value>{count, plural, one {# day not measured} other {# days not measured}}</value> + <comment>the week lines, which are the text alternative and the plain surface both</comment> + </data> + <data name="trend.week.and" xml:space="preserve"> + <value>{line}, {clause}</value> + <comment>the week lines, which are the text alternative and the plain surface both</comment> + </data> + <data name="trend.range" xml:space="preserve"> + <value>days in UTC · {from, date, medium} – {to, date, medium}</value> + <comment>the chart's own chrome</comment> + </data> + <data name="trend.ceiling" xml:space="preserve"> + <value>{value} at the top</value> + <comment>the chart's own chrome</comment> + </data> + <data name="trend.counted" xml:space="preserve"> + <value>{counted} of {days, plural, one {# day} other {# days}} counted</value> + <comment>the chart's own chrome</comment> + </data> + <data name="trend.axis.month" xml:space="preserve"> + <value>{d, date, MMM}</value> + <comment>the chart's own chrome</comment> + </data> + <data name="trend.axis.monthYear" xml:space="preserve"> + <value>{d, date, MMM yyyy}</value> + <comment>the chart's own chrome</comment> + </data> + <data name="trend.legend.mean" xml:space="preserve"> + <value>mean of the counts we read that day</value> + <comment>the chart's own chrome</comment> + </data> + <data name="trend.legend.peak" xml:space="preserve"> + <value>up to the busiest count that day</value> + <comment>the chart's own chrome</comment> + </data> + <data name="trend.legend.band" xml:space="preserve"> + <value>lowest to highest count that day</value> + <comment>the chart's own chrome</comment> + </data> + <data name="trend.legend.notCounted" xml:space="preserve"> + <value>probed, no count could be read</value> + <comment>the chart's own chrome</comment> + </data> + <data name="trend.legend.notMeasured.bar" xml:space="preserve"> + <value>not measured — no bar at all</value> + <comment>the chart's own chrome</comment> + </data> + <data name="trend.legend.notMeasured.line" xml:space="preserve"> + <value>not measured — a break in the line</value> + <comment>the chart's own chrome</comment> + </data> + <data name="trend.spans.label" xml:space="preserve"> + <value>Trend range</value> + <comment>seeking and switching, which are links because the range is in the address</comment> + </data> + <data name="trend.shapes.label" xml:space="preserve"> + <value>Trend shape</value> + <comment>seeking and switching, which are links because the range is in the address</comment> + </data> + <data name="trend.preset" xml:space="preserve"> + <value>{days, plural, one {# day} other {# days}}</value> + <comment>seeking and switching, which are links because the range is in the address</comment> + </data> + <data name="trend.earlier" xml:space="preserve"> + <value>← earlier</value> + <comment>seeking and switching, which are links because the range is in the address</comment> + </data> + <data name="trend.later" xml:space="preserve"> + <value>later →</value> + <comment>seeking and switching, which are links because the range is in the address</comment> + </data> + <data name="trend.shape.line" xml:space="preserve"> + <value>line</value> + <comment>seeking and switching, which are links because the range is in the address</comment> + </data> + <data name="trend.shape.bar" xml:space="preserve"> + <value>bars</value> + <comment>seeking and switching, which are links because the range is in the address</comment> + </data> + <data name="trend.plain.heading" xml:space="preserve"> + <value>How many, over time</value> + <comment>seeking and switching, which are links because the range is in the address</comment> + </data> + <data name="trend.plain.range" xml:space="preserve"> + <value>{from, date, medium} – {to, date, medium}, UTC</value> + <comment>seeking and switching, which are links because the range is in the address</comment> + </data> + <data name="trend.plain.earlier" xml:space="preserve"> + <value>earlier</value> + <comment>seeking and switching, which are links because the range is in the address</comment> + </data> + <data name="trend.plain.note" xml:space="preserve"> + <value>a week is summarised over the days in it we counted; a week with none says so</value> + <comment>seeking and switching, which are links because the range is in the address</comment> + </data> + <data name="reach.kicker" xml:space="preserve"> + <value>reachable · last {days, plural, one {# day} other {# days}}</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.stat.reachable" xml:space="preserve"> + <value>reachable</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.stat.longestOutage" xml:space="preserve"> + <value>longest outage</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.stat.lastCause" xml:space="preserve"> + <value>last cause</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.noOutage" xml:space="preserve"> + <value>none in the window</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.noCause" xml:space="preserve"> + <value>nothing recorded</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.scale.ago" xml:space="preserve"> + <value>{days, plural, one {# day ago} other {# days ago}}</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.scale.today" xml:space="preserve"> + <value>today</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.legend.reachable" xml:space="preserve"> + <value>reachable</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.legend.degraded" xml:space="preserve"> + <value>degraded — answered, could not finish</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.legend.unreachable" xml:space="preserve"> + <value>unreachable</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.legend.notMeasured" xml:space="preserve"> + <value>not measured</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.word.reachable" xml:space="preserve"> + <value>reachable</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.word.degraded" xml:space="preserve"> + <value>degraded</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.word.unreachable" xml:space="preserve"> + <value>unreachable</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.word.notMeasured" xml:space="preserve"> + <value>not measured</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.day.reachable" xml:space="preserve"> + <value>{d, date, d MMM} — reachable all day</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.day.degraded" xml:space="preserve"> + <value>{d, date, d MMM} — degraded ({cause}): answered, could not finish</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.day.unreachable" xml:space="preserve"> + <value>{d, date, d MMM} — unreachable ({cause})</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.day.notMeasured" xml:space="preserve"> + <value>{d, date, d MMM} — not measured; we were not watching this game yet</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.none" xml:space="preserve"> + <value>{days, plural, one {Not yet measured over the last # day.} other {Not yet measured over the last # days.}}</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.fraction.window" xml:space="preserve"> + <value>Reachable {percent} of the last {days, plural, one {# day} other {# days}}.</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.fraction.measured" xml:space="preserve"> + <value>Reachable {percent} of the {days, plural, one {# day} other {# days}} we have measured.</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.fraction.unknown" xml:space="preserve"> + <value>{days, plural, one {Reachability over the last # day is not yet measured.} other {Reachability over the last # days is not yet measured.}}</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.unreachable.noneInWindow" xml:space="preserve"> + <value>No day in the window was unreachable.</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.unreachable.noneMeasured" xml:space="preserve"> + <value>No day we measured was unreachable.</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.unreachable.days" xml:space="preserve"> + <value>{count, plural, one {# day unreachable.} other {# days unreachable.}}</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.degraded.days" xml:space="preserve"> + <value>{count, plural, one {# day degraded — we got in and could not finish.} other {# days degraded — we got in and could not finish.}}</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.longestOutage" xml:space="preserve"> + <value>Longest outage {duration}.</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.longestOutage.cause" xml:space="preserve"> + <value>Longest outage {duration} ({cause}).</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.predate" xml:space="preserve"> + <value>{count, plural, one {# day predates anything we measured.} other {# days predate anything we measured.}}</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.spell.range" xml:space="preserve"> + <value>{from, date, d MMM} – {to, date, d MMM}</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.spell.oneDay" xml:space="preserve"> + <value>{d, date, d MMM}</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.spell" xml:space="preserve"> + <value>{range}: {count, plural, one {# day} other {# days}} {word}</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.spell.cause" xml:space="preserve"> + <value>{range}: {count, plural, one {# day} other {# days}} {word} ({cause})</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.plain.heading" xml:space="preserve"> + <value>Reachable</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.plain.window" xml:space="preserve"> + <value>{days, plural, one {last # day} other {last # days}}</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.plain.fraction" xml:space="preserve"> + <value>Reachable: {percent} of the {days, plural, one {last # day} other {last # days}}</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.plain.longestOutage" xml:space="preserve"> + <value>Longest outage: {duration}</value> + <comment>the reachability strip</comment> + </data> + <data name="cause.dns" xml:space="preserve"> + <value>dns did not resolve</value> + <comment>why a dial did not complete, in a person's words</comment> + </data> + <data name="cause.refused" xml:space="preserve"> + <value>connection refused</value> + <comment>why a dial did not complete, in a person's words</comment> + </data> + <data name="cause.tls" xml:space="preserve"> + <value>tls failed</value> + <comment>why a dial did not complete, in a person's words</comment> + </data> + <data name="cause.timeout" xml:space="preserve"> + <value>timed out</value> + <comment>why a dial did not complete, in a person's words</comment> + </data> + <data name="cause.handshakeStalled" xml:space="preserve"> + <value>handshake stalled</value> + <comment>why a dial did not complete, in a person's words</comment> + </data> + <data name="cause.none" xml:space="preserve"> + <value>no cause recorded</value> + <comment>why a dial did not complete, in a person's words</comment> + </data> + <data name="ansi.suppressed" xml:space="preserve"> + <value>The owner asked us not to republish this game's connect screen.</value> + <comment>the ANSI capture's frame</comment> + </data> + <data name="ansi.absent" xml:space="preserve"> + <value>No connect screen has been captured from this game.</value> + <comment>the ANSI capture's frame</comment> + </data> + <data name="ansi.tooSmall" xml:space="preserve"> + <value>{count, plural, one {Only # row came back — too little to show.} other {Only # rows came back — too little to show.}}</value> + <comment>the ANSI capture's frame</comment> + </data> + <data name="ansi.asSent" xml:space="preserve"> + <value>as sent by the server</value> + <comment>the ANSI capture's frame</comment> + </data> + <data name="ansi.size" xml:space="preserve"> + <value>{columns}×{rows}</value> + <comment>the ANSI capture's frame</comment> + </data> + <data name="ansi.size.doubleWidth" xml:space="preserve"> + <value>{columns}×{rows}, double-width</value> + <comment>the ANSI capture's frame</comment> + </data> + <data name="ansi.depth.colour" xml:space="preserve"> + <value>16-colour SGR</value> + <comment>the ANSI capture's frame</comment> + </data> + <data name="ansi.depth.plain" xml:space="preserve"> + <value>no colour</value> + <comment>the ANSI capture's frame</comment> + </data> + <data name="ansi.readAs" xml:space="preserve"> + <value>read as {charset}</value> + <comment>the ANSI capture's frame</comment> + </data> + <data name="ansi.captured" xml:space="preserve"> + <value>captured</value> + <comment>the ANSI capture's frame</comment> + </data> + <data name="ansi.frozen" xml:space="preserve"> + <value>frozen — the last screen we saw</value> + <comment>the ANSI capture's frame</comment> + </data> + <data name="ansi.alt.named" xml:space="preserve"> + <value>ASCII art: the connect screen of {game}. Its text is under "read as text", below.</value> + <comment>the ANSI capture's frame</comment> + </data> + <data name="ansi.alt" xml:space="preserve"> + <value>ASCII art: this game's connect screen. Its text is under "read as text", below.</value> + <comment>the ANSI capture's frame</comment> + </data> + <data name="ansi.plain.rows" xml:space="preserve"> + <value>{count, plural, one {connect screen: # line, text only} other {connect screen: # lines, text only}}</value> + <comment>the ANSI capture's frame</comment> + </data> + <data name="ansi.plain.rows.readAs" xml:space="preserve"> + <value>{count, plural, one {connect screen: # line, text only, read as {charset}} other {connect screen: # lines, text only, read as {charset}}}</value> + <comment>the ANSI capture's frame</comment> + </data> + <data name="capability.disagree.declaredNotOffered" xml:space="preserve"> + <value>the game declares it, and the server has never offered it in a handshake.</value> + <comment>the capability matrix's disagreements, said in prose</comment> + </data> + <data name="capability.disagree.offeredNotDeclared" xml:space="preserve"> + <value>the server offers it, and the game's own record says it does not.</value> + <comment>the capability matrix's disagreements, said in prose</comment> + </data> + <data name="capability.disagree.note" xml:space="preserve"> + <value>Usually a stale hand-typed field, not a lie. Shown because a client should not rely on what the two disagree about.</value> + <comment>the capability matrix's disagreements, said in prose</comment> + </data> + <data name="game.notFound" xml:space="preserve"> + <value>Not found</value> + <comment>the rest of the game page</comment> + </data> + <data name="game.notFound.hint" xml:space="preserve"> + <value>No game at this address. Check the spelling.</value> + <comment>the rest of the game page</comment> + </data> + <data name="game.endpoint.lastAnswered" xml:space="preserve"> + <value>last answered</value> + <comment>the rest of the game page</comment> + </data> + <data name="game.stale" xml:space="preserve"> + <value>{count, plural, one {# is past its refresh window. Old, not wrong.} other {# are past their refresh window. Old, not wrong.}}</value> + <comment>the rest of the game page</comment> + </data> + <data name="game.referrals.lists" xml:space="preserve"> + <value>This game's own referral list names:</value> + <comment>the rest of the game page</comment> + </data> + <data name="game.referrals.listedBy" xml:space="preserve"> + <value>Named by the referral list of:</value> + <comment>the rest of the game page</comment> + </data> + <data name="game.referral.since" xml:space="preserve"> + <value>since {date}</value> + <comment>the rest of the game page</comment> + </data> + <data name="game.referral.dropped" xml:space="preserve"> + <value>no longer listed, last seen</value> + <comment>the rest of the game page</comment> + </data> + <data name="game.archived.lastAnswered" xml:space="preserve"> + <value>Last answered {date}, {ago} ago.</value> + <comment>the rest of the game page</comment> + </data> + <data name="game.archived.stillProbed" xml:space="preserve"> + <value>Still probed weekly; this page updates the day it answers.</value> + <comment>the rest of the game page</comment> + </data> + <data name="game.archived.knownLive" xml:space="preserve"> + <value>{span} known live</value> + <comment>the rest of the game page</comment> + </data> + <data name="game.excluded" xml:space="preserve"> + <value>Not in the listing, the rankings or the daily figure: we do not think this address is a game somebody can play. Everything below is what it told us, unchanged.</value> + <comment>the rest of the game page</comment> + </data> + <data name="game.excluded.reason" xml:space="preserve"> + <value>Our reason: {why}</value> + <comment>the rest of the game page</comment> + </data> + <data name="game.unlisted" xml:space="preserve"> + <value>Not in the listing, the rankings or the daily figure, at the request of the people who run it. Everything below is preserved as it was, this page and every address it has ever had go on answering, and we are not dialling it.</value> + <comment>the rest of the game page</comment> + </data> + <data name="game.plain.playersNow" xml:space="preserve"> + <value>Players now: {count}</value> + <comment>the plain surface's own headings for this page</comment> + </data> + <data name="game.plain.capabilities" xml:space="preserve"> + <value>Capabilities ({disagreeing, plural, one {# of {total} disagrees} other {# of {total} disagree}})</value> + <comment>the plain surface's own headings for this page</comment> + </data> + <data name="game.plain.declared" xml:space="preserve"> + <value>Declared by the game</value> + <comment>the plain surface's own headings for this page</comment> + </data> + <data name="game.plain.connectScreen" xml:space="preserve"> + <value>Connect screen</value> + <comment>the plain surface's own headings for this page</comment> + </data> + <data name="game.plain.whatChanged" xml:space="preserve"> + <value>What changed</value> + <comment>the plain surface's own headings for this page</comment> + </data> + <data name="game.plain.measured" xml:space="preserve"> + <value>measured</value> + <comment>the plain surface's own headings for this page</comment> + </data> + <data name="game.plain.declared.column" xml:space="preserve"> + <value>declared</value> + <comment>the plain surface's own headings for this page</comment> + </data> + <data name="game.plain.disagree" xml:space="preserve"> + <value>** disagree</value> + <comment>the plain surface's own headings for this page</comment> + </data> + <data name="listing.row.connected" xml:space="preserve"> + <value>connected</value> + <comment>appended block: the listing row's own labels and the last three chips</comment> + </data> + <data name="listing.row.reached" xml:space="preserve"> + <value>reached</value> + <comment>appended block: the listing row's own labels and the last three chips</comment> + </data> + <data name="facet.group.search" xml:space="preserve"> + <value>search</value> + <comment>appended block: the listing row's own labels and the last three chips</comment> + </data> + <data name="facet.group.archived" xml:space="preserve"> + <value>archived</value> + <comment>appended block: the listing row's own labels and the last three chips</comment> + </data> + <data name="facet.group.adult" xml:space="preserve"> + <value>adult</value> + <comment>appended block: the listing row's own labels and the last three chips</comment> + </data> + <data name="facet.value.included" xml:space="preserve"> + <value>included</value> + <comment>appended block: the listing row's own labels and the last three chips</comment> + </data> + <data name="game.count.none" xml:space="preserve"> + <value>no count</value> + <comment>added by the accessibility review, second pass</comment> + </data> + <data name="game.count.none.why" xml:space="preserve"> + <value>no current count, and nothing here says why</value> + <comment>added by the accessibility review, second pass</comment> + </data> + <data name="game.plain.playersNoCount" xml:space="preserve"> + <value>Players now: no count (nothing here says why)</value> + <comment>added by the accessibility review, second pass</comment> + </data> + <data name="crawler.live" xml:space="preserve"> + <value>crawler live · last probe {age}</value> + <comment>the crawler strip, whose sentence was English around a localized age</comment> + </data> + <data name="crawler.quiet" xml:space="preserve"> + <value>crawler quiet · last probe {age}</value> + <comment>the crawler strip, whose sentence was English around a localized age</comment> + </data> + <data name="crawler.noProbe" xml:space="preserve"> + <value>no probe has finished here yet</value> + <comment>the crawler strip, whose sentence was English around a localized age</comment> + </data> + <data name="crawler.cycle.nothingDue" xml:space="preserve"> + <value>nothing due this cycle</value> + <comment>the crawler strip, whose sentence was English around a localized age</comment> + </data> + <data name="crawler.cycle" xml:space="preserve"> + <value>{considered, plural, one {# due} other {# due}} · {answered, plural, one {# answered} other {# answered}} · {failed, plural, one {# failed} other {# failed}}</value> + <comment>the crawler strip, whose sentence was English around a localized age</comment> + </data> + <data name="crawler.registry" xml:space="preserve"> + <value>{targets, plural, one {# address in the registry} other {# addresses in the registry}}, {due, plural, one {# due now} other {# due now}}</value> + <comment>the crawler strip, whose sentence was English around a localized age</comment> + </data> + <data name="preview.documentTitle" xml:space="preserve"> + <value>{page} — {site}</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.site" xml:space="preserve"> + <value>A directory of the MU* hobby — MUSHes, MUDs, MUCKs, MOOs — where every fact carries how it was obtained and how old it is.</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.demo" xml:space="preserve"> + <value>Demo data — nothing here was measured. {description}</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.cardAlt" xml:space="preserve"> + <value>{site} — measured, not asserted</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.cardAlt.named" xml:space="preserve"> + <value>{title} on {site}</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.title.games" xml:space="preserve"> + <value>Games</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.title.archive" xml:space="preserve"> + <value>The archive</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.title.rankings" xml:space="preserve"> + <value>Rankings</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.title.ecosystem" xml:space="preserve"> + <value>The ecosystem</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.title.reference" xml:space="preserve"> + <value>Reference</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.title.about" xml:space="preserve"> + <value>About</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.title.notFound" xml:space="preserve"> + <value>Not found</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.title.random" xml:space="preserve"> + <value>Random game</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.title.account" xml:space="preserve"> + <value>Your games</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.title.claim" xml:space="preserve"> + <value>Claim {game}</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.desc.games" xml:space="preserve"> + <value>Every MU* we have reached, faceted on what we measured: codebase, the protocols a server offered in the handshake, TLS, charset, language, and when we last got in.</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.desc.archive" xml:space="preserve"> + <value>The games that went dark, kept. Each keeps its page, history and URL, is still probed weekly, and returns to the listing on one successful connection.</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.desc.rankings" xml:space="preserve"> + <value>Busiest, most reachable, longest running — computed from measurements only. No votes, stars or ratings anywhere on this site.</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.desc.ecosystem" xml:space="preserve"> + <value>Codebase share and protocol adoption across the games we measure, with what servers offer set beside what they declare. Shares, never totals.</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.desc.reference" xml:space="preserve"> + <value>Hand-written pages on the codebases, clients and protocols of the MU* hobby, cross-linked to counts taken from the crawl.</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.desc.about" xml:space="preserve"> + <value>How this catalogue is built: what the crawler does, what it refuses to do, and how to make it stop.</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.desc.notFound" xml:space="preserve"> + <value>No game at this address. Nothing here is ever deleted, so a game that once lived at this URL still does — check the spelling.</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.desc.random" xml:space="preserve"> + <value>One game from the catalogue, chosen at random and never the same one twice.</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.desc.account" xml:space="preserve"> + <value>The listings you have claimed, and what a claim lets you change.</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.desc.claim" xml:space="preserve"> + <value>Prove you run this game by publishing a token where only its operator could put it.</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.game.archived" xml:space="preserve"> + <value>Archived — last reachable {age}, and still probed</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.game.archived.undated" xml:space="preserve"> + <value>Archived, and still probed</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.game.countUnknown" xml:space="preserve"> + <value>Player count unknown — the game answers, and publishes no number we can read</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.game.count" xml:space="preserve"> + <value>{count, plural, one {# player} other {# players}}, {how} {age}</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="feed.plain.newlyDiscovered" xml:space="preserve"> + <value>Newly discovered</value> + <comment>the plain mirror's feed headings and home counts</comment> + </data> + <data name="feed.plain.wentDark" xml:space="preserve"> + <value>Went dark</value> + <comment>the plain mirror's feed headings and home counts</comment> + </data> + <data name="feed.plain.cameBack" xml:space="preserve"> + <value>Came back</value> + <comment>the plain mirror's feed headings and home counts</comment> + </data> + <data name="home.plain.known" xml:space="preserve"> + <value>{count, plural, one {# game known} other {# games known}}</value> + <comment>the plain mirror's feed headings and home counts</comment> + </data> + <data name="home.plain.connectedNow" xml:space="preserve"> + <value>{count, plural, one {# connected now (measured)} other {# connected now (measured)}}</value> + <comment>the plain mirror's feed headings and home counts</comment> + </data> + <data name="home.plain.uncounted" xml:space="preserve"> + <value>{count, plural, one {# answering, uncounted} other {# answering, uncounted}}</value> + <comment>the plain mirror's feed headings and home counts</comment> + </data> + <data name="home.plain.archived" xml:space="preserve"> + <value>{count, plural, one {# archived, still probed} other {# archived, still probed}}</value> + <comment>the plain mirror's feed headings and home counts</comment> + </data> + <data name="reference.title" xml:space="preserve"> + <value>Reference</value> + <comment>THE REFERENCE SECTION'S CHROME</comment> + </data> + <data name="reference.lede" xml:space="preserve"> + <value>What the codebases are, what the clients do, and what the protocols mean. Written by hand and kept in the repository beside the crawler — not a wiki, and there is nothing on this page to edit. Every {number} here is a different thing: it comes from the catalogue and is recomputed each time you load the page.</value> + <comment>THE REFERENCE SECTION'S CHROME</comment> + </data> + <data name="reference.lede.number" xml:space="preserve"> + <value>number</value> + <comment>THE REFERENCE SECTION'S CHROME</comment> + </data> + <data name="reference.plain.lede" xml:space="preserve"> + <value>Hand-written, single-author, and versioned in git. The prose here is ours; every number beside it was measured by the crawler and is recomputed on each request. This is not a wiki, and there is no way to edit it from this page.</value> + <comment>THE REFERENCE SECTION'S CHROME</comment> + </data> + <data name="reference.section.orientation" xml:space="preserve"> + <value>Start here</value> + <comment>THE REFERENCE SECTION'S CHROME</comment> + </data> + <data name="reference.section.codebase" xml:space="preserve"> + <value>Codebases</value> + <comment>THE REFERENCE SECTION'S CHROME</comment> + </data> + <data name="reference.section.client" xml:space="preserve"> + <value>Clients</value> + <comment>THE REFERENCE SECTION'S CHROME</comment> + </data> + <data name="reference.section.protocol" xml:space="preserve"> + <value>Protocols</value> + <comment>THE REFERENCE SECTION'S CHROME</comment> + </data> + <data name="reference.kind.orientation" xml:space="preserve"> + <value>orientation</value> + <comment>THE REFERENCE SECTION'S CHROME</comment> + </data> + <data name="reference.kind.codebase" xml:space="preserve"> + <value>codebase</value> + <comment>THE REFERENCE SECTION'S CHROME</comment> + </data> + <data name="reference.kind.client" xml:space="preserve"> + <value>client</value> + <comment>THE REFERENCE SECTION'S CHROME</comment> + </data> + <data name="reference.kind.protocol" xml:space="preserve"> + <value>protocol</value> + <comment>THE REFERENCE SECTION'S CHROME</comment> + </data> + <data name="reference.notFound.title" xml:space="preserve"> + <value>Not found</value> + <comment>THE REFERENCE SECTION'S CHROME</comment> + </data> + <data name="reference.notFound.body" xml:space="preserve"> + <value>No reference page here. This section is hand-written, so a gap is work nobody has done rather than something that was removed — {index}.</value> + <comment>THE REFERENCE SECTION'S CHROME</comment> + </data> + <data name="reference.notFound.index" xml:space="preserve"> + <value>see what there is</value> + <comment>THE REFERENCE SECTION'S CHROME</comment> + </data> + <data name="reference.codebase.heading" xml:space="preserve"> + <value>Games running it</value> + <comment>a codebase page's measured half</comment> + </data> + <data name="reference.codebase.none" xml:space="preserve"> + <value>We have not identified any yet. That is a fact about what this crawler has measured, not about what exists — a game we have not reached, or whose codebase we could not read, is not counted here.</value> + <comment>a codebase page's measured half</comment> + </data> + <data name="reference.codebase.listed" xml:space="preserve"> + <value>{count, plural, one {# listed} other {# listed}}</value> + <comment>a codebase page's measured half</comment> + </data> + <data name="reference.codebase.archived" xml:space="preserve"> + <value>{count, plural, one {# archived} other {# archived}}</value> + <comment>a codebase page's measured half</comment> + </data> + <data name="reference.measuredNeverAsserted" xml:space="preserve"> + <value>measured, never asserted</value> + <comment>a codebase page's measured half</comment> + </data> + <data name="reference.codebase.note" xml:space="preserve"> + <value>Counted from the catalogue on this request, over the same filter the link above carries — so this number and that listing are one query and cannot drift apart.</value> + <comment>a codebase page's measured half</comment> + </data> + <data name="reference.codebase.offered" xml:space="preserve"> + <value>offered in their handshakes: {protocols}</value> + <comment>a codebase page's measured half</comment> + </data> + <data name="reference.protocol.heading" xml:space="preserve"> + <value>Measured adoption</value> + <comment>a protocol page's measured half</comment> + </data> + <data name="reference.protocol.none" xml:space="preserve"> + <value>Nothing measured yet.</value> + <comment>a protocol page's measured half</comment> + </data> + <data name="reference.protocol.share" xml:space="preserve"> + <value>of {listed, plural, one {# listed game} other {# listed games}} — {percent}</value> + <comment>a protocol page's measured half</comment> + </data> + <data name="reference.protocol.remainder" xml:space="preserve"> + <value>The games not counted here are not games without the protocol. A game is counted when we observed its server offering the option in a handshake; the rest are servers that did not offer it to us and servers whose handshake we have not read, and we cannot tell you which.</value> + <comment>a protocol page's measured half</comment> + </data> + <data name="reference.protocol.caption" xml:space="preserve"> + <value>Games observed offering {protocol} in a handshake, by the codebase we identified them as running.</value> + <comment>a protocol page's measured half</comment> + </data> + <data name="reference.protocol.column.codebase" xml:space="preserve"> + <value>codebase</value> + <comment>a protocol page's measured half</comment> + </data> + <data name="reference.protocol.column.offered" xml:space="preserve"> + <value>offered it</value> + <comment>a protocol page's measured half</comment> + </data> + <data name="reference.protocol.column.identified" xml:space="preserve"> + <value>identified</value> + <comment>a protocol page's measured half</comment> + </data> + <data name="reference.seeAlso" xml:space="preserve"> + <value>See also</value> + <comment>a protocol page's measured half</comment> + </data> + <data name="reference.capabilities.heading" xml:space="preserve"> + <value>Capabilities</value> + <comment>the client capability matrix, which is documentation rather than measurement</comment> + </data> + <data name="reference.capabilities.established" xml:space="preserve"> + <value>{count, plural, one {# of {total} established from the project's own documentation} other {# of {total} established from the project's own documentation}}</value> + <comment>the client capability matrix, which is documentation rather than measurement</comment> + </data> + <data name="reference.capabilities.caveat" xml:space="preserve"> + <value>Read off each project's own documentation, not measured by us — a client has no handshake for us to observe. "{unknown}" means we looked and did not establish it. It never means no.</value> + <comment>the client capability matrix, which is documentation rather than measurement</comment> + </data> + <data name="reference.capabilities.caption" xml:space="preserve"> + <value>Client capabilities, each read off the project's own documentation. Unknown means we did not establish it, and never that the client lacks it.</value> + <comment>the client capability matrix, which is documentation rather than measurement</comment> + </data> + <data name="reference.capabilities.column.documented" xml:space="preserve"> + <value>documented</value> + <comment>the client capability matrix, which is documentation rather than measurement</comment> + </data> + <data name="reference.capabilities.column.source" xml:space="preserve"> + <value>source</value> + <comment>the client capability matrix, which is documentation rather than measurement</comment> + </data> + <data name="reference.capabilities.noSource" xml:space="preserve"> + <value>we did not find one</value> + <comment>the client capability matrix, which is documentation rather than measurement</comment> + </data> + <data name="reference.capability.yes" xml:space="preserve"> + <value>yes</value> + <comment>the client capability matrix, which is documentation rather than measurement</comment> + </data> + <data name="reference.capability.no" xml:space="preserve"> + <value>no</value> + <comment>the client capability matrix, which is documentation rather than measurement</comment> + </data> + <data name="reference.capability.unknown" xml:space="preserve"> + <value>unknown</value> + <comment>the client capability matrix, which is documentation rather than measurement</comment> + </data> + <data name="reference.plain.runsOn" xml:space="preserve"> + <value>Runs on: {platforms}</value> + <comment>the plain mirror's own wording</comment> + </data> + <data name="reference.plain.codebase.heading" xml:space="preserve"> + <value>Games we have identified as running this codebase</value> + <comment>the plain mirror's own wording</comment> + </data> + <data name="reference.plain.codebase.none" xml:space="preserve"> + <value>None yet. That is a statement about what we have measured, not about what exists — a game we have not reached, or whose codebase we could not read, is not counted here.</value> + <comment>the plain mirror's own wording</comment> + </data> + <data name="reference.plain.codebase.counts" xml:space="preserve"> + <value>{listed, plural, one {# listed} other {# listed}}, {archived, plural, one {# archived} other {# archived}}</value> + <comment>the plain mirror's own wording</comment> + </data> + <data name="reference.plain.codebase.offered" xml:space="preserve"> + <value>Measured in their handshakes: {protocols}</value> + <comment>the plain mirror's own wording</comment> + </data> + <data name="reference.plain.codebase.nothingOffered" xml:space="preserve"> + <value>Nothing was offered in any handshake we have read from them.</value> + <comment>the plain mirror's own wording</comment> + </data> + <data name="reference.plain.protocol.share" xml:space="preserve"> + <value>{offering} of {listed, plural, one {# listed game} other {# listed games}} were observed offering it ({percent})</value> + <comment>the plain mirror's own wording</comment> + </data> + <data name="reference.plain.protocol.byCodebase" xml:space="preserve"> + <value>By codebase, of the games we identified</value> + <comment>the plain mirror's own wording</comment> + </data> + <data name="reference.plain.protocol.row" xml:space="preserve"> + <value>{offering} of {identified} offered it</value> + <comment>the plain mirror's own wording</comment> + </data> + <data name="reference.plain.capabilities.unknown" xml:space="preserve"> + <value>{count, plural, one {# of {total} rows is unknown} other {# of {total} rows are unknown}}: we did not find the project's own documentation saying either way. A short honest table beats a long guessed one.</value> + <comment>the plain mirror's own wording</comment> + </data> + <data name="account.title" xml:space="preserve"> + <value>Your games</value> + <comment>the dashboard's frame</comment> + </data> + <data name="account.noDatabase" xml:space="preserve"> + <value>Accounts need a database behind them, and this site is running on the demo fixture.</value> + <comment>the dashboard's frame</comment> + </data> + <data name="account.signInButton" xml:space="preserve"> + <value>Sign in</value> + <comment>the dashboard's frame</comment> + </data> + <data name="account.signedInAs" xml:space="preserve"> + <value>Signed in as {name}.</value> + <comment>the dashboard's frame</comment> + </data> + <data name="account.signOut" xml:space="preserve"> + <value>Sign out</value> + <comment>the dashboard's frame</comment> + </data> + <data name="account.empty.body" xml:space="preserve"> + <value>You have not claimed anything yet. Find your game in {listing} and press {claimControl} on its page.</value> + <comment>the dashboard's frame</comment> + </data> + <data name="account.empty.listing" xml:space="preserve"> + <value>the listing</value> + <comment>the dashboard's frame</comment> + </data> + <data name="account.empty.claimControl" xml:space="preserve"> + <value>claim this game</value> + <comment>the dashboard's frame</comment> + </data> + <data name="account.resigned.lead" xml:space="preserve"> + <value>Given up.</value> + <comment>the one banner a POST comes back with</comment> + </data> + <data name="account.resigned.body" xml:space="preserve"> + <value>The record of it is kept, and you can prove control again any time by publishing a fresh token.</value> + <comment>the one banner a POST comes back with</comment> + </data> + <data name="account.saved.lead" xml:space="preserve"> + <value>Saved.</value> + <comment>the one banner a POST comes back with</comment> + </data> + <data name="account.saved.thatGame" xml:space="preserve"> + <value>That game</value> + <comment>the one banner a POST comes back with</comment> + </data> + <data name="account.saved.fields" xml:space="preserve"> + <value>{game}'s page now shows it as owner-declared.</value> + <comment>the one banner a POST comes back with</comment> + </data> + <data name="account.saved.screenHidden" xml:space="preserve"> + <value>We have stopped republishing {game}'s connect screen. The page says so plainly rather than leaving a hole.</value> + <comment>the one banner a POST comes back with</comment> + </data> + <data name="account.saved.screenShown" xml:space="preserve"> + <value>{game}'s connect screen is on its page again.</value> + <comment>the one banner a POST comes back with</comment> + </data> + <data name="account.saved.crawlStopped" xml:space="preserve"> + <value>We have stopped dialling {game}, on every address we have for it. Its page keeps everything measured before you asked.</value> + <comment>the one banner a POST comes back with</comment> + </data> + <data name="account.saved.crawlResumed" xml:space="preserve"> + <value>We are dialling {game} again, from its next turn in the schedule.</value> + <comment>the one banner a POST comes back with</comment> + </data> + <data name="account.saved.unlisted" xml:space="preserve"> + <value>{game} is out of the listing, the rankings and the daily figure. Its page and every URL it has ever had go on answering.</value> + <comment>the one banner a POST comes back with</comment> + </data> + <data name="account.saved.relisted" xml:space="preserve"> + <value>{game} is back in the listing. One probe that answers is all it needs to be measured again.</value> + <comment>the one banner a POST comes back with</comment> + </data> + <data name="account.refused.lead" xml:space="preserve"> + <value>{field} was not changed.</value> + <comment>the one banner a POST comes back with</comment> + </data> + <data name="account.refused.tooLong" xml:space="preserve"> + <value>These are one-line answers; {max} characters is the most we store.</value> + <comment>the one banner a POST comes back with</comment> + </data> + <data name="account.refused.measured" xml:space="preserve"> + <value>That field is measured. A claim lets you add what MSSP has no room for; it never lets anybody edit what we observed, and that includes us.</value> + <comment>the one banner a POST comes back with</comment> + </data> + <data name="account.claimed.heading" xml:space="preserve"> + <value>Claimed</value> + <comment>a claimed game's block</comment> + </data> + <data name="account.claim.verified" xml:space="preserve"> + <value>verified {date}</value> + <comment>a claimed game's block</comment> + </data> + <data name="account.claim.verifiedAndSeen" xml:space="preserve"> + <value>verified {date}, token last seen {seen}</value> + <comment>a claimed game's block</comment> + </data> + <data name="account.claim.mssp" xml:space="preserve"> + <value>check your MSSP</value> + <comment>a claimed game's block</comment> + </data> + <data name="account.claim.coOwners" xml:space="preserve"> + <value>{count, plural, one {Also owned by {names} — who verified a token of their own.} other {Also owned by {names} — each having verified a token of their own.}}</value> + <comment>a claimed game's block</comment> + </data> + <data name="account.coOwner.unnamed" xml:space="preserve"> + <value>another account</value> + <comment>a claimed game's block</comment> + </data> + <data name="account.badge.summary" xml:space="preserve"> + <value>put your player count on your own site</value> + <comment>a claimed game's block</comment> + </data> + <data name="account.badge.carries" xml:space="preserve"> + <value>The badge carries the count and when we measured it, because a number with no age is the thing this site exists to replace.</value> + <comment>a claimed game's block</comment> + </data> + <data name="account.badge.states" xml:space="preserve"> + <value>It says {unknown} rather than nought when we could not count, and {archived} if the game stops answering.</value> + <comment>a claimed game's block</comment> + </data> + <data name="account.badge.json" xml:space="preserve"> + <value>There is {json} too, if you would rather draw your own.</value> + <comment>a claimed game's block</comment> + </data> + <data name="account.history.summary" xml:space="preserve"> + <value>history</value> + <comment>the audit log</comment> + </data> + <data name="account.event.issued" xml:space="preserve"> + <value>token issued</value> + <comment>the audit log</comment> + </data> + <data name="account.event.reissued" xml:space="preserve"> + <value>token issued again</value> + <comment>the audit log</comment> + </data> + <data name="account.event.verified" xml:space="preserve"> + <value>verified — we read your token</value> + <comment>the audit log</comment> + </data> + <data name="account.event.beaconSeen" xml:space="preserve"> + <value>token still published</value> + <comment>the audit log</comment> + </data> + <data name="account.event.beaconMissing" xml:space="preserve"> + <value>token not read this time</value> + <comment>the audit log</comment> + </data> + <data name="account.event.revoked" xml:space="preserve"> + <value>claim given up</value> + <comment>the audit log</comment> + </data> + <data name="account.event.expired" xml:space="preserve"> + <value>token expired unused</value> + <comment>the audit log</comment> + </data> + <data name="account.event.counterClaimed" xml:space="preserve"> + <value>another account proved control and took the game over</value> + <comment>the audit log</comment> + </data> + <data name="account.event.checkRequested" xml:space="preserve"> + <value>check requested</value> + <comment>the audit log</comment> + </data> + <data name="account.resign.summary" xml:space="preserve"> + <value>give up this claim</value> + <comment>the audit log</comment> + </data> + <data name="account.resign.confirm" xml:space="preserve"> + <value>Type {word} to confirm. Nothing is deleted and you can prove control again by publishing a fresh token; the game stays claimed if anybody else owns it.</value> + <comment>the audit log</comment> + </data> + <data name="account.resign.button" xml:space="preserve"> + <value>Give up {game}</value> + <comment>the audit log</comment> + </data> + <data name="account.pending.heading" xml:space="preserve"> + <value>Waiting on a token</value> + <comment>waiting on a token, and the passkeys</comment> + </data> + <data name="account.pending.dates" xml:space="preserve"> + <value>token issued {issued}, good until {expires}</value> + <comment>waiting on a token, and the passkeys</comment> + </data> + <data name="account.passkeys.heading" xml:space="preserve"> + <value>Passkeys</value> + <comment>waiting on a token, and the passkeys</comment> + </data> + <data name="account.passkey.unnamed" xml:space="preserve"> + <value>unnamed</value> + <comment>waiting on a token, and the passkeys</comment> + </data> + <data name="account.passkey.added" xml:space="preserve"> + <value>added {date}</value> + <comment>waiting on a token, and the passkeys</comment> + </data> + <data name="account.passkey.addedOneDevice" xml:space="preserve"> + <value>added {date} · on one device only</value> + <comment>waiting on a token, and the passkeys</comment> + </data> + <data name="account.passkey.single" xml:space="preserve"> + <value>This passkey lives on one device. If you lose it you can still get back in by publishing a fresh token on your game, but a second passkey is quicker.</value> + <comment>waiting on a token, and the passkeys</comment> + </data> + <data name="account.passkey.add" xml:space="preserve"> + <value>Add another passkey</value> + <comment>waiting on a token, and the passkeys</comment> + </data> + <data name="claim.noGame" xml:space="preserve"> + <value>No such game</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.title" xml:space="preserve"> + <value>Claim {game}</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.noDatabase" xml:space="preserve"> + <value>Claiming needs a database behind it, and this site is running on the demo fixture.</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.needAccount" xml:space="preserve"> + <value>You need an account first. It takes a passkey and a name.</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.signIn" xml:space="preserve"> + <value>Sign in or create an account</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.yourGames" xml:space="preserve"> + <value>Your games</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.hasOwners" xml:space="preserve"> + <value>{count, plural, one {This game already has an owner who proved control of the server.} other {This game already has # owners who proved control of the server.}} You can prove it too — the test is the same either way — but we need to know what you mean by it, because we cannot tell from the token.</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.join.button" xml:space="preserve"> + <value>I run it too — add me as an owner</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.join.note" xml:space="preserve"> + <value>Everyone keeps their claim. This is two people running one game.</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.assume.button" xml:space="preserve"> + <value>I have taken it over — transfer it to me</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.assume.note" xml:space="preserve"> + <value>{count, plural, one {When your token verifies, the existing claim is revoked and the game is yours.} other {When your token verifies, the existing claims are revoked and the game is yours.}} They will see why in their own history. Nothing is deleted, and they can prove control again the same way you are about to.</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.verified.lead" xml:space="preserve"> + <value>Verified.</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.verified.viaMssp" xml:space="preserve"> + <value>We read your token from the game's MSSP report on {date}.</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.verified.viaScreen" xml:space="preserve"> + <value>We read your token from the connect screen on {date}.</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.verified.leaveIt" xml:space="preserve"> + <value>Leave the token where it is. It doubles as an identity signal, so this game stays recognisable if it moves host or changes name. Removing it will not un-claim you.</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.publish" xml:space="preserve"> + <value>Publish this token anywhere the game shows it to an anonymous connection. The next probe picks it up, which proves you can write to that server.</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.transfer.lead" xml:space="preserve"> + <value>This is a transfer.</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.transfer.body" xml:space="preserve"> + <value>{count, plural, one {When we read this token, the current owner's claim on this game is revoked and it becomes yours.} other {When we read this token, the current owners' claims on this game are revoked and it becomes yours.}}</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.either.heading" xml:space="preserve"> + <value>Either of these will do</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.mssp.heading" xml:space="preserve"> + <value>An MSSP variable</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.mssp.note" xml:space="preserve"> + <value>In {codebase} that is a line in {file}; every codebase with MSSP has an equivalent.</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.mssp.aliases" xml:space="preserve"> + <value>{aliases} are accepted too.</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.screen.heading" xml:space="preserve"> + <value>A line on the connect screen</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.screen.note" xml:space="preserve"> + <value>Anywhere in the screen, and colour codes around it are fine.</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.then.heading" xml:space="preserve"> + <value>Then</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.then.body" xml:space="preserve"> + <value>We check on the ordinary crawl schedule. This token is good until {date}. Come back any time; nothing needs writing down.</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.check.button" xml:space="preserve"> + <value>Look sooner</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.check.can" xml:space="preserve"> + <value>Brings your game to the front of the queue. We dial on our own schedule, so this is sooner rather than now.</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.check.rationed" xml:space="preserve"> + <value>Just asked. Try again in a few minutes — it is rationed because it dials a real server sooner than we would have.</value> + <comment>claiming a game you run</comment> + </data> + <data name="owner.declare.heading" xml:space="preserve"> + <value>What only you can tell us about {game}</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.declare.lede" xml:space="preserve"> + <value>These are the things MSSP has no field for. They appear on your game's page as {declared}, with the date you last confirmed them, beside what we measured — never instead of it. Nothing measured can be edited from here, by you or by us.</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.field.declared" xml:space="preserve"> + <value>declared {age}. Empty this box to withdraw it — the record of what it said is kept either way.</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.save" xml:space="preserve"> + <value>Save what you declared</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.override.heading" xml:space="preserve"> + <value>What {game} reports, and what you would rather we showed</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.override.lede" xml:space="preserve"> + <value>Your MSSP is what every crawler reads, and we go on showing it beside anything you put here — an answer of yours does not hide one of your game's.</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.override.nothingMeasured" xml:space="preserve"> + <value>Nothing measured can be edited from here: not a player count, not a capability, not an hour of reachability.</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.override.fixItThere" xml:space="preserve"> + <value>If a line below is wrong in your {file}, fixing it there fixes it everywhere.</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.report.value" xml:space="preserve"> + <value>your game reports {value}, confirmed {age}</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.report.none" xml:space="preserve"> + <value>your game reports nothing here</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.rename.note" xml:space="preserve"> + <value>Changing the name changes what {game} is listed as and the address of its page. The old address goes on working for ever — every URL this game has ever had redirects to its current one — and clearing the box hands the name back to whatever your MSSP says.</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.screen.heading" xml:space="preserve"> + <value>Your connect screen</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.screen.suppressed" xml:space="preserve"> + <value>We are not republishing it. The page says so plainly rather than leaving a hole, and the crawler goes on reading it — it is how we recognise your game if it moves.</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.screen.show" xml:space="preserve"> + <value>Show it again</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.screen.shown" xml:space="preserve"> + <value>We show it because your server sends it to every anonymous connection. If you would rather we did not, say so and we stop. We will not ask why.</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.screen.stop" xml:space="preserve"> + <value>Stop showing our connect screen</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.crawl.heading" xml:space="preserve"> + <value>Being crawled</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.crawl.stopped" xml:space="preserve"> + <value>We have stopped. Nothing on {game} is dialled, and the page keeps everything measured before you asked — the empty hours name no cause, because {ourFact} is our fact and not a measurement of your game.</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.crawl.ourFact" xml:space="preserve"> + <value>you asked us to stop</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.crawl.resume" xml:space="preserve"> + <value>Start crawling us again</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.crawl.standing" xml:space="preserve"> + <value>This one came from your own server rather than from here — {routes}. To be crawled again, stop publishing it; we will hear that on the next cycle.</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.crawl.route.mssp" xml:space="preserve"> + <value>your MSSP report publishes {variable}</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.crawl.route.dns" xml:space="preserve"> + <value>a {label} TXT record asks us to stop</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.crawl.route.recorded" xml:space="preserve"> + <value>a request we recorded</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.crawl.partial" xml:space="preserve"> + <value>We have stopped on {stopped} and are still dialling {dialling}. That is usually a port added after the opt-out.</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.crawl.stopAll" xml:space="preserve"> + <value>Stop on every address too</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.crawl.dialling" xml:space="preserve"> + <value>We dial {game} on a schedule and read what any anonymous connection is shown. If you would rather we did not, say so and we stop — within one cycle, on every address we have for you, and we will not ask why.</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.crawl.selfService" xml:space="preserve"> + <value>Nothing already measured is deleted: your page keeps its history and its URL, and one probe after you take this back starts it again. You can also say it without us, in your own config — {mssp} in MSSP, or a {dns} TXT record — and we honour those whether or not anybody has ever claimed the game here.</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.crawl.stop" xml:space="preserve"> + <value>Stop crawling us</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.listing.heading" xml:space="preserve"> + <value>Being listed</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.listing.unlisted" xml:space="preserve"> + <value>{game} is out of the listing, out of the rankings and out of the daily figure. Its page and every URL it has ever had go on answering, and everything measured before you asked is still on it. Nothing was deleted; it is simply not somewhere a reader arrives by browsing.</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.listing.relist" xml:space="preserve"> + <value>Put us back in the listing</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.listing.probeRelists" xml:space="preserve"> + <value>One probe that answers does this too. While your opt-out stands we do not dial, so nothing will — but the day you take it back, the address comes up within a week and the probe that gets an answer puts you back. You do not have to ask us twice.</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.listing.mayUnlist" xml:space="preserve"> + <value>We have stopped dialling you, and your page is still in the listing with what we measured before that. If you would rather it were not, say so and it comes out — of the listing, the rankings and the daily figure.</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.listing.reversible" xml:space="preserve"> + <value>Nothing is deleted and nothing breaks: the page answers, every URL it has ever had still redirects to it, and anyone you send there sees it. It stops being somewhere a reader can arrive by browsing. Reversible from here, and by any probe that answers after you take your opt-out back.</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.listing.unlist" xml:space="preserve"> + <value>Take us out of the listing too</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="facet.group.measure" xml:space="preserve"> + <value>what we could measure</value> + <comment>what we could measure (the two measurement switches, spec §9)</comment> + </data> + <data name="facet.measure.note" xml:space="preserve"> + <value>Hiding these takes them out of your listing; it does not mean the game is empty.</value> + <comment>what we could measure (the two measurement switches, spec §9)</comment> + </data> + <data name="facet.group.uncounted" xml:space="preserve"> + <value>could not count</value> + <comment>what we could measure (the two measurement switches, spec §9)</comment> + </data> + <data name="facet.group.unreachable" xml:space="preserve"> + <value>could not reach</value> + <comment>what we could measure (the two measurement switches, spec §9)</comment> + </data> + <data name="facet.excluded.uncounted" xml:space="preserve"> + <value>hidden from this listing</value> + <comment>what we could measure (the two measurement switches, spec §9)</comment> + </data> + <data name="facet.excluded.unreachable" xml:space="preserve"> + <value>hidden from this listing</value> + <comment>what we could measure (the two measurement switches, spec §9)</comment> + </data> + <data name="facet.plain.marks" xml:space="preserve"> + <value>In the left column, * is a value this listing is filtered to and - is one it is filtered against. Both are choices in the query, not facts about a game.</value> + <comment>what we could measure (the two measurement switches, spec §9)</comment> + </data> +</root> diff --git a/src/MUI.Web/Resources/Messages.zh-Hans.resx b/src/MUI.Web/Resources/Messages.zh-Hans.resx new file mode 100644 index 0000000..a303b42 --- /dev/null +++ b/src/MUI.Web/Resources/Messages.zh-Hans.resx @@ -0,0 +1,2877 @@ +<?xml version="1.0" encoding="utf-8"?> +<root> + <!-- + 中文, machine-translated and not reviewed by a person. + + Every page served in this locale carries the ◆ notice saying so, and the locale is reachable but + never offered: nothing sends a reader here. Promotion to LocaleStatus.Shipped is a person reading + the locked strings against Glossary.cs, not an edit to a status enum. + + The values are ICU MessageFormat. Argument names in braces are code. + --> + <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata"> + <xsd:import namespace="http://www.w3.org/XML/1998/namespace" /> + <xsd:element name="root" msdata:IsDataSet="true"> + <xsd:complexType> + <xsd:choice maxOccurs="unbounded"> + <xsd:element name="data"> + <xsd:complexType> + <xsd:sequence> + <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" /> + <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" /> + </xsd:sequence> + <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" /> + <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" /> + <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" /> + <xsd:attribute ref="xml:space" /> + </xsd:complexType> + </xsd:element> + <xsd:element name="resheader"> + <xsd:complexType> + <xsd:sequence> + <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" /> + </xsd:sequence> + <xsd:attribute name="name" type="xsd:string" use="required" /> + </xsd:complexType> + </xsd:element> + </xsd:choice> + </xsd:complexType> + </xsd:element> + </xsd:schema> + <resheader name="resmimetype"><value>text/microsoft-resx</value></resheader> + <resheader name="version"><value>2.0</value></resheader> + <resheader name="reader"><value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader> + <resheader name="writer"><value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader> + <data name="facet.count" xml:space="preserve"> + <value>{count, plural, other {#个游戏}}</value> + </data> + <data name="facet.value.include" xml:space="preserve"> + <value>{value}，{count, plural, other {#个游戏}}，仅此项</value> + </data> + <data name="facet.value.exclude" xml:space="preserve"> + <value>{value}，{count, plural, other {#个游戏}}，已排除</value> + </data> + <data name="facet.value.choose" xml:space="preserve"> + <value>{value}，{count, plural, other {#个游戏}}</value> + </data> + <data name="facet.any" xml:space="preserve"> + <value>任意{facet}，{count, plural, other {#个游戏}}</value> + </data> + <data name="listing.total" xml:space="preserve"> + <value>{count, plural, =0 {此处未列出任何游戏。} other {#个游戏，每项事实都标明它的来源。}}</value> + </data> + <data name="chart.basis" xml:space="preserve"> + <value>{days, plural, other {#天}}实测 · {probes, plural, other {#次探测}}</value> + </data> + <data name="window.samples" xml:space="preserve"> + <value>{days, plural, other {#天}} · {count, plural, other {#次计数}}</value> + </data> + <data name="capabilities.agree" xml:space="preserve"> + <value>{disagreeing, plural, =0 {全部{total}项均一致。} other {在{total}项中，有#项与游戏自述不符。}}</value> + </data> + <data name="find.matching" xml:space="preserve"> + <value>{count, plural, =0 {没有游戏符合全部回答。} other {有#个游戏符合全部回答。}}</value> + </data> + <data name="find.basis" xml:space="preserve"> + <value>在{listed, plural, other {#个已列出的游戏}}中 · {answers, plural, =0 {未作回答} other {已回答#项}}</value> + </data> + <data name="find.show" xml:space="preserve"> + <value>{count, plural, other {显示这#个游戏}}</value> + </data> + <data name="find.drop" xml:space="preserve"> + <value>去掉“{answer}”——{count, plural, other {#个游戏}}</value> + </data> + <data name="find.clear" xml:space="preserve"> + <value>清除该问题的回答：{question}</value> + </data> + <data name="find.title" xml:space="preserve"> + <value>查找游戏</value> + </data> + <data name="find.kicker" xml:space="preserve"> + <value>符合全部回答</value> + </data> + <data name="find.noun" xml:space="preserve"> + <value>{count, plural, other {游戏}}</value> + </data> + <data name="find.clearAll" xml:space="preserve"> + <value>清除全部回答</value> + </data> + <data name="find.startAgain" xml:space="preserve"> + <value>重新开始</value> + </data> + <data name="find.more" xml:space="preserve"> + <value>{count, plural, other {另有#项}}</value> + </data> + <data name="find.answersGiven" xml:space="preserve"> + <value>已回答</value> + </data> + <data name="find.wholeListing" xml:space="preserve"> + <value>全部列表</value> + </data> + <data name="find.refused" xml:space="preserve"> + <value>该查询已被拒绝</value> + </data> + <data name="find.name.label" xml:space="preserve"> + <value>名称（若有）</value> + </data> + <data name="find.name.placeholder" xml:space="preserve"> + <value>名称或部分名称</value> + </data> + <data name="find.name.submit" xml:space="preserve"> + <value>按名称搜索</value> + </data> + <data name="find.q.band" xml:space="preserve"> + <value>现在有人在玩吗？</value> + </data> + <data name="find.q.genre" xml:space="preserve"> + <value>你想玩什么？</value> + </data> + <data name="find.q.lineage" xml:space="preserve"> + <value>哪种游戏？</value> + </data> + <data name="find.q.language" xml:space="preserve"> + <value>使用哪种语言？</value> + </data> + <data name="find.q.client" xml:space="preserve"> + <value>你的客户端有什么需求吗？</value> + </data> + <data name="find.q.dark" xml:space="preserve"> + <value>是否包含已失联的游戏？</value> + </data> + <data name="find.any.band" xml:space="preserve"> + <value>不限</value> + </data> + <data name="find.any.genre" xml:space="preserve"> + <value>任意题材</value> + </data> + <data name="find.any.lineage" xml:space="preserve"> + <value>任意类型</value> + </data> + <data name="find.any.language" xml:space="preserve"> + <value>任意语言</value> + </data> + <data name="find.any.client" xml:space="preserve"> + <value>不限</value> + </data> + <data name="find.dark.no" xml:space="preserve"> + <value>否，仅未失联的游戏</value> + </data> + <data name="find.dark.yes" xml:space="preserve"> + <value>是，也一并显示</value> + </data> + <data name="find.dark.chip" xml:space="preserve"> + <value>已失联的游戏</value> + </data> + <data name="find.protocol.tls" xml:space="preserve"> + <value>TLS——已加密，握手由我们完成</value> + </data> + <data name="find.protocol.mssp" xml:space="preserve"> + <value>MSSP——服务器自述</value> + </data> + <data name="find.protocol.mccp" xml:space="preserve"> + <value>MCCP——输出压缩</value> + </data> + <data name="find.protocol.mxp" xml:space="preserve"> + <value>MXP——可点击链接</value> + </data> + <data name="find.protocol.gmcp" xml:space="preserve"> + <value>GMCP——结构化客户端数据</value> + </data> + <data name="find.protocol.msdp" xml:space="preserve"> + <value>MSDP——结构化客户端数据</value> + </data> + <data name="find.protocol.charset" xml:space="preserve"> + <value>CHARSET——编码协商</value> + </data> + <data name="find.protocol.utf8" xml:space="preserve"> + <value>UTF-8——非拉丁文本可正常显示</value> + </data> + <data name="find.protocol.ttype" xml:space="preserve"> + <value>TTYPE——客户端自述类型</value> + </data> + <data name="find.protocol.atcp" xml:space="preserve"> + <value>ATCP——结构化客户端数据</value> + </data> + <data name="find.protocol.msp" xml:space="preserve"> + <value>MSP——声音触发</value> + </data> + <data name="find.protocol.eor" xml:space="preserve"> + <value>EOR——提示符标记</value> + </data> + <data name="find.protocol.other" xml:space="preserve"> + <value>{token}——握手中实测</value> + </data> + <data name="provenance.count.measured" xml:space="preserve"> + <value>实测</value> + </data> + <data name="provenance.game.measured" xml:space="preserve"> + <value>实测</value> + </data> + <data name="provenance.capability.measured" xml:space="preserve"> + <value>实测</value> + </data> + <data name="provenance.screen.measured" xml:space="preserve"> + <value>实测</value> + </data> + <data name="kicker.measured" xml:space="preserve"> + <value>实测</value> + </data> + <data name="provenance.count.declared" xml:space="preserve"> + <value>自述</value> + </data> + <data name="provenance.game.declared" xml:space="preserve"> + <value>自述</value> + </data> + <data name="provenance.capability.declared" xml:space="preserve"> + <value>自述</value> + </data> + <data name="kicker.declared" xml:space="preserve"> + <value>自述</value> + </data> + <data name="provenance.derived" xml:space="preserve"> + <value>推算</value> + </data> + <data name="kicker.derived" xml:space="preserve"> + <value>推算</value> + </data> + <data name="state.notMeasured" xml:space="preserve"> + <value>未实测</value> + </data> + <data name="state.uncounted" xml:space="preserve"> + <value>未能计数</value> + </data> + <data name="state.unreachable" xml:space="preserve"> + <value>无法连通</value> + </data> + <data name="state.notCounted" xml:space="preserve"> + <value>未计数</value> + </data> + <data name="listing.count.none" xml:space="preserve"> + <value>无计数</value> + </data> + <data name="listing.plain.fromHere" xml:space="preserve"> + <value>自本站</value> + </data> + <data name="listing.plain.archived" xml:space="preserve"> + <value>已归档</value> + </data> + <data name="listing.plain.claimed" xml:space="preserve"> + <value>已认领</value> + </data> + <data name="random.empty.title" xml:space="preserve"> + <value>没有可挑的游戏</value> + </data> + <data name="random.empty.body" xml:space="preserve"> + <value>没有游戏符合该筛选。试试{listing}，或者{archive}。</value> + </data> + <data name="random.empty.listing" xml:space="preserve"> + <value>全部列表</value> + </data> + <data name="random.empty.archive" xml:space="preserve"> + <value>把归档也算上</value> + </data> + <data name="term.connected" xml:space="preserve"> + <value>连接数</value> + </data> + <data name="term.unclaimed" xml:space="preserve"> + <value>无人认领</value> + </data> + <data name="term.claimedByOwner" xml:space="preserve"> + <value>已由所有者认领</value> + </data> + <data name="term.stillProbed" xml:space="preserve"> + <value>仍在探测</value> + </data> + <data name="term.typical" xml:space="preserve"> + <value>典型值</value> + </data> + <data name="term.peak" xml:space="preserve"> + <value>峰值</value> + </data> + <data name="a11y.readAsText" xml:space="preserve"> + <value>以文本形式阅读</value> + </data> + <data name="a11y.plainText" xml:space="preserve"> + <value>纯文本</value> + </data> + <data name="a11y.skipToContent" xml:space="preserve"> + <value>跳至主要内容</value> + </data> + <data name="a11y.asciiBanner" xml:space="preserve"> + <value>ASCII 横幅：{game} 的连接画面。</value> + </data> + <data name="nav.catalogues" xml:space="preserve"> + <value>目录</value> + </data> + <data name="nav.account" xml:space="preserve"> + <value>本站与账户</value> + </data> + <data name="nav.browse" xml:space="preserve"> + <value>浏览</value> + </data> + <data name="nav.learn" xml:space="preserve"> + <value>了解</value> + </data> + <data name="nav.thisSite" xml:space="preserve"> + <value>本站</value> + </data> + <data name="nav.menu" xml:space="preserve"> + <value>菜单</value> + </data> + <data name="nav.games" xml:space="preserve"> + <value>游戏</value> + </data> + <data name="nav.find" xml:space="preserve"> + <value>查找</value> + </data> + <data name="nav.random" xml:space="preserve"> + <value>随机</value> + </data> + <data name="nav.archive" xml:space="preserve"> + <value>归档</value> + </data> + <data name="nav.reference" xml:space="preserve"> + <value>参考</value> + </data> + <data name="nav.ecosystem" xml:space="preserve"> + <value>生态</value> + </data> + <data name="nav.rankings" xml:space="preserve"> + <value>排行</value> + </data> + <data name="nav.about" xml:space="preserve"> + <value>关于</value> + </data> + <data name="nav.submit" xml:space="preserve"> + <value>提交</value> + </data> + <data name="nav.submitGame" xml:space="preserve"> + <value>提交游戏</value> + </data> + <data name="nav.signIn" xml:space="preserve"> + <value>登录</value> + </data> + <data name="nav.yourGames" xml:space="preserve"> + <value>我的游戏</value> + </data> + <data name="theme.label" xml:space="preserve"> + <value>主题</value> + </data> + <data name="theme.auto" xml:space="preserve"> + <value>自动</value> + </data> + <data name="theme.light" xml:space="preserve"> + <value>浅色</value> + </data> + <data name="theme.dark" xml:space="preserve"> + <value>深色</value> + </data> + <data name="banner.demo.lead" xml:space="preserve"> + <value>演示数据。</value> + </data> + <data name="banner.demo" xml:space="preserve"> + <value>未配置数据库，因此这是一份样例。此处没有任何内容经过实测。</value> + </data> + <data name="footer.allGames" xml:space="preserve"> + <value>全部游戏</value> + </data> + <data name="footer.archive" xml:space="preserve"> + <value>归档</value> + </data> + <data name="footer.declaredByGame" xml:space="preserve"> + <value>游戏自述</value> + </data> + <data name="footer.whatChanged" xml:space="preserve"> + <value>变更记录</value> + </data> + <data name="home.title" xml:space="preserve"> + <value>MU* 爱好者的游戏目录</value> + </data> + <data name="home.lede" xml:space="preserve"> + <value>每一项事实都标明它的来源与时间：由我们的爬虫实测，或由游戏自述并明确标出。</value> + </data> + <data name="home.search.label" xml:space="preserve"> + <value>按名称、主题、代码库或主机搜索游戏</value> + </data> + <data name="home.search.placeholder" xml:space="preserve"> + <value>按名称、主题、代码库或主机搜索</value> + </data> + <data name="home.search.submit" xml:space="preserve"> + <value>搜索</value> + </data> + <data name="tile.gamesKnown" xml:space="preserve"> + <value>已知游戏</value> + </data> + <data name="tile.connectedNow" xml:space="preserve"> + <value>当前连接数</value> + </data> + <data name="tile.answeringUncounted" xml:space="preserve"> + <value>有应答，未能计数</value> + </data> + <data name="tile.archived" xml:space="preserve"> + <value>已归档</value> + </data> + <data name="feed.newlyDiscovered" xml:space="preserve"> + <value>新发现</value> + </data> + <data name="feed.wentDark" xml:space="preserve"> + <value>已失联——仍在探测</value> + </data> + <data name="feed.cameBack" xml:space="preserve"> + <value>已恢复</value> + </data> + <data name="feed.nothingNew" xml:space="preserve"> + <value>没有新发现。</value> + </data> + <data name="feed.nothingDark" xml:space="preserve"> + <value>没有游戏失联。</value> + </data> + <data name="feed.nothingBack" xml:space="preserve"> + <value>没有游戏恢复。我们仍会继续叩门。</value> + </data> + <data name="feed.live" xml:space="preserve"> + <value>实时</value> + </data> + <data name="games.title" xml:space="preserve"> + <value>游戏</value> + </data> + <data name="listing.sortedBy" xml:space="preserve"> + <value>按{order}排序</value> + </data> + <data name="listing.random" xml:space="preserve"> + <value>随机</value> + </data> + <data name="listing.columns" xml:space="preserve"> + <value>连接数 · 连通</value> + </data> + <data name="listing.fromHere" xml:space="preserve"> + <value>自本站</value> + </data> + <data name="listing.empty.head" xml:space="preserve"> + <value>没有匹配结果。</value> + </data> + <data name="listing.empty.hint" xml:space="preserve"> + <value>试试减少关键词，或去掉一个筛选条件。</value> + </data> + <data name="listing.clearFilters" xml:space="preserve"> + <value>清除筛选</value> + </data> + <data name="listing.aboutCodebase" xml:space="preserve"> + <value>关于 {codebase}</value> + </data> + <data name="listing.never" xml:space="preserve"> + <value>从未</value> + </data> + <data name="listing.claimed" xml:space="preserve"> + <value>已由所有者认领</value> + </data> + <data name="listing.unknownCodebase" xml:space="preserve"> + <value>未知代码库</value> + </data> + <data name="listing.unknownCodebase.title" xml:space="preserve"> + <value>我们无法识别该游戏运行的代码库</value> + </data> + <data name="listing.moreProtocols" xml:space="preserve"> + <value>另有{count, plural, other {#项}}：{names}</value> + </data> + <data name="switch.order" xml:space="preserve"> + <value>排序</value> + </data> + <data name="switch.window" xml:space="preserve"> + <value>时间窗</value> + </data> + <data name="switch.now" xml:space="preserve"> + <value>当前</value> + </data> + <data name="switch.typical" xml:space="preserve"> + <value>典型值</value> + </data> + <data name="switch.peak" xml:space="preserve"> + <value>峰值</value> + </data> + <data name="switch.name" xml:space="preserve"> + <value>名称</value> + </data> + <data name="switch.reached" xml:space="preserve"> + <value>连通</value> + </data> + <data name="window.7" xml:space="preserve"> + <value>7天</value> + </data> + <data name="window.30" xml:space="preserve"> + <value>30天</value> + </data> + <data name="window.90" xml:space="preserve"> + <value>90天</value> + </data> + <data name="filters.search.label" xml:space="preserve"> + <value>搜索游戏</value> + </data> + <data name="filters.search.placeholder" xml:space="preserve"> + <value>搜索游戏</value> + </data> + <data name="filters.summary" xml:space="preserve"> + <value>筛选</value> + </data> + <data name="filters.showing" xml:space="preserve"> + <value>当前显示</value> + </data> + <data name="filters.clearAll" xml:space="preserve"> + <value>全部清除</value> + </data> + <data name="filters.stopFiltering" xml:space="preserve"> + <value>——取消此项筛选</value> + </data> + <data name="facet.anyValue" xml:space="preserve"> + <value>任意</value> + </data> + <data name="facet.more" xml:space="preserve"> + <value>更多筛选（{count}）</value> + </data> + <data name="facet.moreValues" xml:space="preserve"> + <value>{count, plural, other {另有#项}}</value> + </data> + <data name="facet.alsoShow" xml:space="preserve"> + <value>同时显示</value> + </data> + <data name="facet.alsoShow.note" xml:space="preserve"> + <value>默认关闭。两者都不是对游戏的评判。</value> + </data> + <data name="facet.archived" xml:space="preserve"> + <value>已归档</value> + </data> + <data name="facet.adult" xml:space="preserve"> + <value>成人</value> + </data> + <data name="facet.archived.state" xml:space="preserve"> + <value>已归档游戏，{shown, select, true {显示} other {隐藏}}</value> + </data> + <data name="facet.adult.state" xml:space="preserve"> + <value>自述含成人内容的游戏，{shown, select, true {显示} other {隐藏}}</value> + </data> + <data name="facet.countsNote" xml:space="preserve"> + <value>计数均为我们实测到的游戏，绝非估算。</value> + </data> + <data name="facet.key.summary" xml:space="preserve"> + <value>徽标与留空的含义</value> + </data> + <data name="facet.key.blank" xml:space="preserve"> + <value>留空是我们测量中的缺口，而不是否定。每个分面各有说法：未识别、未自述、无协商结果。</value> + </data> + <data name="facet.key.zero" xml:space="preserve"> + <value>实测到的零是一个计数。未知的计数不是零，排序时也绝不按零处理。</value> + </data> + <data name="facet.key.openEnded" xml:space="preserve"> + <value>开放式分面只列出最常见的 {count} 个值。其余的可通过搜索和 URL 访问。</value> + </data> + <data name="facet.presence.note" xml:space="preserve"> + <value>未勾选表示未实测，而不是游戏不具备该项。</value> + </data> + <data name="facet.group.band" xml:space="preserve"> + <value>活跃度</value> + </data> + <data name="facet.group.seen" xml:space="preserve"> + <value>最近可见</value> + </data> + <data name="facet.group.protocol" xml:space="preserve"> + <value>提供的协议</value> + </data> + <data name="facet.group.tls" xml:space="preserve"> + <value>加密</value> + </data> + <data name="facet.group.charset" xml:space="preserve"> + <value>编码</value> + </data> + <data name="facet.group.codebase" xml:space="preserve"> + <value>代码库</value> + </data> + <data name="facet.group.version" xml:space="preserve"> + <value>版本</value> + </data> + <data name="facet.group.lineage" xml:space="preserve"> + <value>谱系</value> + </data> + <data name="facet.group.family" xml:space="preserve"> + <value>家族</value> + </data> + <data name="facet.group.genre" xml:space="preserve"> + <value>题材</value> + </data> + <data name="facet.group.language" xml:space="preserve"> + <value>语言</value> + </data> + <data name="facet.band.playersNow" xml:space="preserve"> + <value>当前有连接</value> + </data> + <data name="facet.band.activeThisWeek" xml:space="preserve"> + <value>本周活跃</value> + </data> + <data name="facet.band.quiet" xml:space="preserve"> + <value>冷清——没有高于 0 的计数</value> + </data> + <data name="facet.band.dark" xml:space="preserve"> + <value>失联——一个月未连通</value> + </data> + <data name="facet.band.archived" xml:space="preserve"> + <value>已归档</value> + </data> + <data name="facet.seen.day" xml:space="preserve"> + <value>24 小时内</value> + </data> + <data name="facet.seen.week" xml:space="preserve"> + <value>7 天内</value> + </data> + <data name="facet.seen.month" xml:space="preserve"> + <value>30 天内</value> + </data> + <data name="facet.seen.older" xml:space="preserve"> + <value>更早</value> + </data> + <data name="facet.seen.never" xml:space="preserve"> + <value>从未连通</value> + </data> + <data name="facet.unknown.charset" xml:space="preserve"> + <value>无协商结果</value> + </data> + <data name="facet.unknown.codebase" xml:space="preserve"> + <value>未识别</value> + </data> + <data name="facet.unknown.other" xml:space="preserve"> + <value>未自述</value> + </data> + <data name="facet.tls.yes" xml:space="preserve"> + <value>已通过 TLS 连接</value> + </data> + <data name="facet.excluded" xml:space="preserve"> + <value>非{value}</value> + </data> + <data name="facet.known.charset" xml:space="preserve"> + <value>有协商结果</value> + </data> + <data name="facet.known.codebase" xml:space="preserve"> + <value>已识别</value> + </data> + <data name="facet.known.other" xml:space="preserve"> + <value>有自述</value> + </data> + <data name="evidence.measured.meaning" xml:space="preserve"> + <value>我们亲眼观测到</value> + </data> + <data name="evidence.declared.meaning" xml:space="preserve"> + <value>游戏这样说，我们未加核实</value> + </data> + <data name="evidence.derived.meaning" xml:space="preserve"> + <value>我们对游戏所述内容做了归类</value> + </data> + <data name="sort.name" xml:space="preserve"> + <value>名称</value> + </data> + <data name="sort.players" xml:space="preserve"> + <value>当前连接数</value> + </data> + <data name="sort.reached" xml:space="preserve"> + <value>最近连通</value> + </data> + <data name="sort.medianWeek" xml:space="preserve"> + <value>典型连接数 · 7天</value> + </data> + <data name="sort.medianMonth" xml:space="preserve"> + <value>典型连接数 · 30天</value> + </data> + <data name="sort.medianQuarter" xml:space="preserve"> + <value>典型连接数 · 90天</value> + </data> + <data name="sort.peakWeek" xml:space="preserve"> + <value>同时最多连接 · 7天</value> + </data> + <data name="sort.peakMonth" xml:space="preserve"> + <value>同时最多连接 · 30天</value> + </data> + <data name="sort.peakQuarter" xml:space="preserve"> + <value>同时最多连接 · 90天</value> + </data> + <data name="sort.group.row" xml:space="preserve"> + <value>当前行内</value> + </data> + <data name="sort.group.typical" xml:space="preserve"> + <value>典型值</value> + </data> + <data name="sort.group.peak" xml:space="preserve"> + <value>峰值</value> + </data> + <data name="sort.unranked.players" xml:space="preserve"> + <value>未知计数</value> + </data> + <data name="sort.unranked.reached" xml:space="preserve"> + <value>从未连通过——并非只是很久未连通</value> + </data> + <data name="sort.unranked.median" xml:space="preserve"> + <value>窗口内计数少于 {minimum} 次，或完全没有——并非典型连接数为零</value> + </data> + <data name="sort.unranked.window" xml:space="preserve"> + <value>窗口内没有任何我们能计到的数——并非无人连接的游戏</value> + </data> + <data name="sort.window.median" xml:space="preserve"> + <value>中位 {value} · {days, plural, other {#天}} · {count, plural, other {#次计数}}</value> + </data> + <data name="sort.window.peak" xml:space="preserve"> + <value>同时最多 {value} · {days, plural, other {#天}} · {count, plural, other {#次计数}}</value> + </data> + <data name="game.connectScreen" xml:space="preserve"> + <value>连接画面</value> + </data> + <data name="game.connectionsByHour" xml:space="preserve"> + <value>按小时的连接数</value> + </data> + <data name="game.howMany" xml:space="preserve"> + <value>人数随时间变化</value> + </data> + <data name="game.reachable" xml:space="preserve"> + <value>可连通</value> + </data> + <data name="game.whatChanged" xml:space="preserve"> + <value>变更记录</value> + </data> + <data name="game.capabilities" xml:space="preserve"> + <value>能力</value> + </data> + <data name="game.declaredByGame" xml:space="preserve"> + <value>游戏自述</value> + </data> + <data name="game.referrals" xml:space="preserve"> + <value>转介</value> + </data> + <data name="game.unclaimed" xml:space="preserve"> + <value>无人认领——此处的一切均为实测。</value> + </data> + <data name="game.claimed" xml:space="preserve"> + <value>已由所有者认领——下方的实测事实仍出自我们。</value> + </data> + <data name="game.claim" xml:space="preserve"> + <value>认领此游戏</value> + </data> + <data name="game.answeringSince" xml:space="preserve"> + <value>自 {date} 起有应答</value> + </data> + <data name="game.readAsTextRows" xml:space="preserve"> + <value>以文本形式阅读——{count, plural, other {#行}}</value> + </data> + <data name="capability.column" xml:space="preserve"> + <value>能力</value> + </data> + <data name="capability.age" xml:space="preserve"> + <value>距今</value> + </data> + <data name="capability.offered" xml:space="preserve"> + <value>已提供</value> + </data> + <data name="capability.silent" xml:space="preserve"> + <value>静默</value> + </data> + <data name="capability.absent" xml:space="preserve"> + <value>缺失</value> + </data> + <data name="capability.denied" xml:space="preserve"> + <value>已拒绝</value> + </data> + <data name="capability.claimed" xml:space="preserve"> + <value>自述有</value> + </data> + <data name="capability.disagrees" xml:space="preserve"> + <value>不一致</value> + </data> + <data name="capability.whereTheyDisagree" xml:space="preserve"> + <value>不一致之处（{count}）</value> + </data> + <data name="activity.cell.counted" xml:space="preserve"> + <value>{day} {time}——{count, plural, =0 {0人连接，实测} other {平均#人连接}}</value> + </data> + <data name="activity.cell.notCounted" xml:space="preserve"> + <value>{day} {time}——已探测，未能读取计数</value> + </data> + <data name="activity.cell.notMeasured" xml:space="preserve"> + <value>{day} {time}——该小时未实测</value> + </data> + <data name="activity.none" xml:space="preserve"> + <value>我们尚未实测该游戏的活跃度。</value> + </data> + <data name="activity.noCount" xml:space="preserve"> + <value>一周中没有任何一个小时得出过连接人数。</value> + </data> + <data name="activity.allZero" xml:space="preserve"> + <value>每个小时都已实测，其中没有任何一个小时有人连接。</value> + </data> + <data name="activity.gap.day" xml:space="preserve"> + <value>{count, plural, other {{day}有#小时尚未实测。}}</value> + </data> + <data name="activity.gap.week" xml:space="preserve"> + <value>{count, plural, other {一周中有#小时尚未实测。}}</value> + </data> + <data name="activity.uncounted.day" xml:space="preserve"> + <value>{count, plural, other {{day}有#小时有应答，但未能计数。}}</value> + </data> + <data name="activity.uncounted.week" xml:space="preserve"> + <value>{count, plural, other {一周中有#小时有应答，但未能计数。}}</value> + </data> + <data name="activity.busiest.everyDay" xml:space="preserve"> + <value>每天最热闹，{window}。</value> + </data> + <data name="activity.busiest.everyDay.part" xml:space="preserve"> + <value>每天{part}最热闹，{window}。</value> + </data> + <data name="activity.busiest.days" xml:space="preserve"> + <value>{days}最热闹，{window}。</value> + </data> + <data name="activity.busiest.days.part" xml:space="preserve"> + <value>{days}{part}最热闹，{window}。</value> + </data> + <data name="activity.quiet" xml:space="preserve"> + <value>{who}一贯冷清，{window}。</value> + </data> + <data name="activity.quiet.part" xml:space="preserve"> + <value>{who}的{part}一贯冷清，{window}。</value> + </data> + <data name="activity.quiet.everyDay" xml:space="preserve"> + <value>每天</value> + </data> + <data name="activity.quiet.everyMeasuredDay" xml:space="preserve"> + <value>我们实测到的每一天</value> + </data> + <data name="activity.quiet.weekdays" xml:space="preserve"> + <value>工作日</value> + </data> + <data name="activity.quiet.onDays" xml:space="preserve"> + <value>{days}</value> + </data> + <data name="activity.part.morning" xml:space="preserve"> + <value>上午</value> + </data> + <data name="activity.part.afternoon" xml:space="preserve"> + <value>下午</value> + </data> + <data name="activity.part.evening" xml:space="preserve"> + <value>晚上</value> + </data> + <data name="activity.part.smallHours" xml:space="preserve"> + <value>凌晨</value> + </data> + <data name="activity.parts.morning" xml:space="preserve"> + <value>上午</value> + </data> + <data name="activity.parts.afternoon" xml:space="preserve"> + <value>下午</value> + </data> + <data name="activity.parts.evening" xml:space="preserve"> + <value>晚上</value> + </data> + <data name="activity.parts.smallHours" xml:space="preserve"> + <value>凌晨</value> + </data> + <data name="activity.days.list" xml:space="preserve"> + <value>{list}、{next}</value> + </data> + <data name="activity.days.pair" xml:space="preserve"> + <value>{first}和{second}</value> + </data> + <data name="activity.sparse.kicker" xml:space="preserve"> + <value>实测次数尚不足</value> + </data> + <data name="activity.sparse.none" xml:space="preserve"> + <value>一周中尚无任何一个小时有过实测。</value> + </data> + <data name="activity.sparse.uncounted" xml:space="preserve"> + <value>{count, plural, other {#小时有应答，但未能计数。}}</value> + </data> + <data name="activity.sparse.wait" xml:space="preserve"> + <value>待一周七天每天都有实测后，网格才会显示。</value> + </data> + <data name="activity.sparse.days" xml:space="preserve"> + <value>{days, plural, other {七天中已实测#天；待每天都有实测小时后，网格才会显示。}}</value> + </data> + <data name="activity.sample.zero" xml:space="preserve"> + <value>{count, plural, other {已实测#小时，其中始终无人连接。}}</value> + </data> + <data name="activity.sample.peak" xml:space="preserve"> + <value>{count, plural, other {已实测#小时，最热闹的是{day} {time} UTC，{peak}人连接。}}</value> + </data> + <data name="activity.sample.more" xml:space="preserve"> + <value>{count, plural, other {另有#小时有应答，但未能计数。}}</value> + </data> + <data name="activity.day.line" xml:space="preserve"> + <value>{day}——{facts}</value> + </data> + <data name="activity.day.facts" xml:space="preserve"> + <value>{first}，{second}</value> + </data> + <data name="activity.day.allZero" xml:space="preserve"> + <value>全天实测为零</value> + </data> + <data name="activity.day.peak" xml:space="preserve"> + <value>{time}峰值{count}人</value> + </data> + <data name="activity.day.nobodyOn" xml:space="preserve"> + <value>{window}无人连接</value> + </data> + <data name="activity.day.noCount" xml:space="preserve"> + <value>各小时均无计数</value> + </data> + <data name="activity.day.notMeasured" xml:space="preserve"> + <value>{count, plural, other {#小时未实测}}</value> + </data> + <data name="activity.day.notCounted" xml:space="preserve"> + <value>{count, plural, other {#小时已探测但未能计数}}</value> + </data> + <data name="activity.column.day" xml:space="preserve"> + <value>星期</value> + </data> + <data name="activity.column.quietest" xml:space="preserve"> + <value>最冷清</value> + </data> + <data name="activity.column.busiest" xml:space="preserve"> + <value>最热闹</value> + </data> + <data name="activity.column.at" xml:space="preserve"> + <value>时间</value> + </data> + <data name="activity.column.noCount" xml:space="preserve"> + <value>无计数</value> + </data> + <data name="activity.caption" xml:space="preserve"> + <value>按天显示的连接人数，时间为 UTC。{window}。</value> + </data> + <data name="activity.times" xml:space="preserve"> + <value>时间为 UTC · {window}</value> + </data> + <data name="activity.rollingAverage" xml:space="preserve"> + <value>{weeks, plural, other {#周滚动平均}}</value> + </data> + <data name="activity.legend.counted" xml:space="preserve"> + <value>已计数，含实测为零</value> + </data> + <data name="activity.legend.notCounted" xml:space="preserve"> + <value>已探测，未能读取计数</value> + </data> + <data name="activity.legend.notMeasured" xml:space="preserve"> + <value>该小时未实测</value> + </data> + <data name="activity.plain.heading" xml:space="preserve"> + <value>有人连接的时段（UTC）</value> + </data> + <data name="activity.key.counted" xml:space="preserve"> + <value>已计数</value> + </data> + <data name="activity.key.counted.meaning" xml:space="preserve"> + <value>我们连上了并读到了数字，包括实测为零</value> + </data> + <data name="activity.key.uncounted.meaning" xml:space="preserve"> + <value>我们连上了，但读不到数字</value> + </data> + <data name="activity.key.notMeasured.meaning" xml:space="preserve"> + <value>我们没有该小时的实测数据</value> + </data> + <data name="locale.label" xml:space="preserve"> + <value>语言</value> + </data> + <data name="locale.submit" xml:space="preserve"> + <value>切换语言</value> + </data> + <data name="about.title" xml:space="preserve"> + <value>关于 mu*index</value> + </data> + <data name="about.lede" xml:space="preserve"> + <value>这里的每一个游戏，都由一台连入其中的机器实测得出，每一项数值都标明它的来源与时间。本页说明这能证明什么、我们哪里会出错、我们读了谁的目录，以及如何让爬虫停下。</value> + </data> + <data name="about.measures.heading" xml:space="preserve"> + <value>本站所说的事实是什么</value> + </data> + <data name="about.measures.declared.lead" xml:space="preserve"> + <value>实测优先于自述，两者都会呈现。</value> + </data> + <data name="about.measures.declared.body" xml:space="preserve"> + <value>游戏的 MSSP 报告是它对自己的描述，telnet 握手则是我们亲眼看到它做了什么。两者都会出现在它的页面上，并标注来源与时间。两者不一致时，我们把这份不一致本身呈现出来。</value> + </data> + <data name="about.measures.count.lead" xml:space="preserve"> + <value>每一项人数计数都标明它从何而来。</value> + </data> + <data name="about.measures.count.body" xml:space="preserve"> + <value>要么是我们在连接画面上读到并数出的 WHO 或 DOING，要么是游戏自己发布的 MSSP PLAYERS 字段。二者从不合并。</value> + </data> + <data name="about.measures.unknown.lead" xml:space="preserve"> + <value>读不出来的回应是未知，绝不是零。</value> + </data> + <data name="about.measures.unknown.body" xml:space="preserve"> + <value>服务器可以随意定制自己的 WHO 表头，超过一定程度，我们的解析器就读不出来了。那是无法计数，自成一种状态。而实测到的零——我们连上了，里面没有人——是一个计数，也按计数显示。</value> + </data> + <data name="about.measures.reachable.lead" xml:space="preserve"> + <value>只说可连通，从不说在线率。</value> + </data> + <data name="about.measures.reachable.body" xml:space="preserve"> + <value>我们从一台主机上按间隔打开一个套接字。路由不到的游戏是无法连通，而它完全可能好好活着。本站不宣称任何游戏的在线率，因为本站没有测过它。</value> + </data> + <data name="about.measures.hour.lead" xml:space="preserve"> + <value>一个小时要么已计数，要么无法计数，要么未实测。</value> + </data> + <data name="about.measures.hour.body" xml:space="preserve"> + <value>活跃度网格有三种状态。第三种是空白，并且不指明原因：我们连不上的那个小时，和我们从未探测过的那个小时，是同一种缺失，两者都不是那台服务器的停机时间。</value> + </data> + <data name="about.limits.heading" xml:space="preserve"> + <value>我们知道自己哪里会出错</value> + </data> + <data name="about.limits.grace.lead" xml:space="preserve"> + <value>归档宽限期从我们发现你的那天算起。</value> + </data> + <data name="about.limits.grace.body" xml:space="preserve"> + <value>游戏停止应答后，会在宽限期结束时离开默认列表：宽限期是我们探测到的可连通时长的四分之一，下限 60 天，上限 365 天。一个从 1995 年就在运行的游戏，在我们发现它的那天也只从下限起算。我们不会导入任何数据，去填补我们到来之前的那些年。</value> + </data> + <data name="about.limits.created.lead" xml:space="preserve"> + <value>MSSP CREATED 不计入这段宽限期。</value> + </data> + <data name="about.limits.created.body" xml:space="preserve"> + <value>它只是配置文件里手打的一行，若予采信，归档门槛就会变得可以操纵。它以自述的身份显示，换不来任何东西。</value> + </data> + <data name="about.limits.claim.lead" xml:space="preserve"> + <value>认领游戏可以拿到上限。</value> + </data> + <data name="about.limits.claim.body" xml:space="preserve"> + <value>只要证明拥有服务器访问权，无论我们观察了多久，都值整整一年的宽限期。</value> + </data> + <data name="about.limits.oneHost.lead" xml:space="preserve"> + <value>本站的一切，都出自一台主机的间隔观测。</value> + </data> + <data name="about.limits.oneHost.body" xml:space="preserve"> + <value>可连通时间的百分比，是我们观测过的那段窗口内的比例，绝不是我们没观测过的窗口的比例。本站的任何图形都不会替其余部分补上数据。</value> + </data> + <data name="about.limits.deletion.lead" xml:space="preserve"> + <value>任何内容都不会被删除。</value> + </data> + <data name="about.limits.deletion.body" xml:space="preserve"> + <value>归档只是把游戏移出默认列表、排行和今日活跃数字，仅此而已。它的页面、URL、历史和地址都保留，我们仍会继续探测，一次成功的探测就能让它回来。</value> + </data> + <data name="about.never.heading" xml:space="preserve"> + <value>本站不会做的事</value> + </data> + <data name="about.never.votes.lead" xml:space="preserve"> + <value>没有投票、星级、评分或推荐。</value> + </data> + <data name="about.never.votes.body" xml:space="preserve"> + <value>排行仅由实测数据算出。一个按谁能动员最多点击来排名的目录，描述的是拉票活动，而不是这个爱好本身——前辈们正是这样倒下的。</value> + </data> + <data name="about.never.forums.lead" xml:space="preserve"> + <value>没有论坛、评测、维基、评论或玩家资料页。</value> + </data> + <data name="about.never.forums.body" xml:space="preserve"> + <value>入门资料——什么是 MUSH、哪种代码库适合协作扮演——和本站其余内容一样，由人撰写、署名，并纳入版本管理。</value> + </data> + <data name="about.never.names.lead" xml:space="preserve"> + <value>玩家名称从不留存。</value> + </data> + <data name="about.never.names.body" xml:space="preserve"> + <value>WHO 的回复只在内存中解析，取出一个计数和表头的形状。名称不会被记录下来；汇总使用加盐哈希，盐值会轮换。</value> + </data> + <data name="about.never.population.lead" xml:space="preserve"> + <value>不发布任何绝对人口数字。</value> + </data> + <data name="about.never.population.body" xml:space="preserve"> + <value>我们发布按代码库和按协议的占比：在实测集合上算出的比例，即使还有我们数不出来的游戏也依然成立。“有多少人在玩 MU*”则不然，因为那个数字一经引用就站不住脚。</value> + </data> + <data name="about.crawler.heading" xml:space="preserve"> + <value>爬虫，以及如何让它停下</value> + </data> + <data name="about.crawler.probe.lead" xml:space="preserve"> + <value>一次探测就是一个从不登录的连接。</value> + </data> + <data name="about.crawler.probe.body" xml:space="preserve"> + <value>它打开一个套接字，协商 telnet 选项，读取连接画面，通过协商选项 70 索取 MSSP，发送 {commands}，然后断开。不建角色，不登录，对端没有任何改动。会话有超时上限，卡住的探测不会一直占着一个连接位。</value> + </data> + <data name="about.crawler.delay.lead" xml:space="preserve"> + <value>CRAWL DELAY 说了算。</value> + </data> + <data name="about.crawler.delay.body" xml:space="preserve"> + <value>游戏若在 MSSP 报告中给出希望的最小间隔，我们就照办，并在两个方向上都优先于我们自己的排期：720 小时就是每月一次，而不是每周一次。失联的游戏仍会按这个更长的间隔被一直尝试下去，它恢复之后，正是这样重新回到列表的。</value> + </data> + <data name="about.crawler.referral.lead" xml:space="preserve"> + <value>转介来的地址只做核验，从不轻信。</value> + </data> + <data name="about.crawler.referral.body" xml:space="preserve"> + <value>MSSP 允许一个游戏点名其他游戏。任何拨号之前，每个名称都先做解析；除非它解析出的每一个地址都是全球可路由的，否则一律拒绝。解析结果混杂时，整个目标都被拒绝。这种拒绝记在我们自己名下，绝不会作为停机出现在某个游戏的记录里。</value> + </data> + <data name="about.crawler.screens.lead" xml:space="preserve"> + <value>展示连接画面，是因为它本来就发给所有人。</value> + </data> + <data name="about.crawler.screens.body" xml:space="preserve"> + <value>服务器会向每一个匿名连接、无需认证地绘出自己的连接画面。我们把它作为证据展示，并加以标注。你若开口，我们就撤下。</value> + </data> + <data name="about.crawler.stop.lead" xml:space="preserve"> + <value>说停我们就停——有三种方式。</value> + </data> + <data name="about.crawler.stop.body" xml:space="preserve"> + <value>在你的 MSSP 报告中发布 {variable} 1，读到它的那次探测就是最后一次。或者在 {label}.your.host 上发布一条内容为“{value}”的 TXT 记录，这既不需要支持 MSSP，也不需要在本站注册账户。再或者，写信给一个人。这三种方式都会在一个爬取周期之内生效，并连同日期和我们读到的内容一起记录，提交表单上同样照此执行。</value> + </data> + <data name="about.crawler.scope.lead" xml:space="preserve"> + <value>MSSP 字段停的是那个监听端口，TXT 记录停的是整台主机。</value> + </data> + <data name="about.crawler.scope.body" xml:space="preserve"> + <value>MSSP 由应答的那个端口发布，因此它只代表那个端口——MU* 托管商常常在同一个域名下运行互不相关的游戏，谁也不该替邻居闭嘴。TXT 记录默认覆盖所有端口，除非它指名某一个，写作“{value}=4201”。凡是我们读不出端口清单的写法，都按整台主机处理，所以“{value}=all”也是有效的。</value> + </data> + <data name="about.crawler.dns.lead" xml:space="preserve"> + <value>DNS 这条路，你不用问我们就能撤销。</value> + </data> + <data name="about.crawler.dns.body" xml:space="preserve"> + <value>读一条 TXT 记录，不必连上那台叫我们别来的服务器，所以我们在每次拨号前都会重新读它。你把它删掉，一周之内我们就会再次拨号。而 MSSP 字段不做你叫我们别做的那件事就无法重读，所以通过 MSSP 提出的退出和书面请求会一直有效，直到你另行告知。已退出的地址只会得到这一次 TXT 查询：它触及的是你的域名服务器，绝不会触及你的游戏。</value> + </data> + <data name="about.crawler.stopping.lead" xml:space="preserve"> + <value>停下不是删除，也不是停机。</value> + </data> + <data name="about.crawler.stopping.body" xml:space="preserve"> + <value>选择退出的游戏保留它的页面、它的地址，以及它开口之前我们实测到的一切。停下的只有新数据：活跃度网格不再增加小时，并且不指明原因，因为不再叩门是我们的决定，那是关于我们的事实。它记录在那次没有发生的爬取上，也记录在提出请求者的名册里。</value> + </data> + <data name="about.crawler.unlist.lead" xml:space="preserve"> + <value>如果只是停下还不够，列表条目也可以撤下。</value> + </data> + <data name="about.crawler.unlist.body" xml:space="preserve"> + <value>当我们在你游戏应答的每一个地址上都已停手之后，你的控制台会多出一项：把它移出列表、排行和每日数字。页面和它曾用过的每一个地址仍然照常应答，任何内容都不会被删除——它只是不再是读者靠浏览就能走到的地方。这需要一次经过验证的认领，因为这是关于你游戏的决定，我们会记录是谁做的。而一次探测就能撤销它：收回你的退出声明，下一次拨号只要得到应答，你就会重新回到列表，不必再来问我们第二次。</value> + </data> + <data name="about.identity.announced" xml:space="preserve"> + <value>服务器询问来者何人时，爬虫自报为 {name}。</value> + </data> + <data name="about.identity.unannounced" xml:space="preserve"> + <value>爬虫已配置为自称 {name}，但目前还说不出口。它使用的 telnet 库没有给客户端设置终端类型的途径，所以你的日志里看到的是那个库的默认值，而 NEW-ENVIRON 是用爬虫主机的环境作答的。这两处都是那个库的缺口，该由我们去那里修补。在此之前，请靠形态辨认一次探测：一个连接，不登录，一组简短的只读命令，然后就走。</value> + </data> + <data name="about.identity.crawler" xml:space="preserve"> + <value>爬虫</value> + </data> + <data name="about.identity.contact" xml:space="preserve"> + <value>联系方式</value> + </data> + <data name="about.identity.crawler.line" xml:space="preserve"> + <value>爬虫：{name}</value> + </data> + <data name="about.identity.contact.line" xml:space="preserve"> + <value>联系方式：{url}</value> + </data> + <data name="about.identity.placeholder" xml:space="preserve"> + <value>——占位值；本部署未设置联系地址</value> + </data> + <data name="about.identity.placeholder.plain" xml:space="preserve"> + <value>未配置联系地址，因此上面那个只是占位值，不会有人回应。</value> + </data> + <data name="about.sources.heading" xml:space="preserve"> + <value>游戏名单从何而来</value> + </data> + <data name="about.sources.addresses.lead" xml:space="preserve"> + <value>我们只取地址，别的都不取。</value> + </data> + <data name="about.sources.addresses.body" xml:space="preserve"> + <value>一次回填只取一个主机和一个端口。不取人数计数，不取连通历史，不取简介，不取字段，也不记录某个地址来自哪个站点。</value> + </data> + <data name="about.sources.less.lead" xml:space="preserve"> + <value>刻意少于那些站点能给的。</value> + </data> + <data name="about.sources.less.body" xml:space="preserve"> + <value>其中有几家存着多年的带日期人数计数。把它们导进来，会用别人早已在观测的游戏去填满热力图，也会把本站最核心的主张，架在别人的探测器上。</value> + </data> + <data name="about.sources.origin.lead" xml:space="preserve"> + <value>一个游戏的出处不是单一事实。</value> + </data> + <data name="about.sources.origin.body" xml:space="preserve"> + <value>凡是值得列出的游戏，都会同时出现在其中好几个目录里，所以“导入自”只会写上先跑完的那次抓取。某个游戏存在，这是公开信息；我们从哪里读到的，既不增添任何东西，也是别人劳动成果里最没理由算作我们的那一部分。</value> + </data> + <data name="about.sources.etiquette.lead" xml:space="preserve"> + <value>读别人的站点，终究是在读别人的站点。</value> + </data> + <data name="about.sources.etiquette.body" xml:space="preserve"> + <value>抓取之前，我们先索要批量导出或有文档的接口，先读 robots.txt，并对抓取严格限速。凡是需要维护者点头的来源，在有人能声明已经征询过之前，一律不抓。</value> + </data> + <data name="about.source.read" xml:space="preserve"> + <value>已读取——仅地址</value> + </data> + <data name="about.source.withheld" xml:space="preserve"> + <value>未读取——等待许可</value> + </data> + <data name="about.source.tintinMssp.note" xml:space="preserve"> + <value>一个页面，一次请求。由一个逐个连入游戏、并打印所读内容的爬虫发布。</value> + </data> + <data name="about.source.tintinMsdp.note" xml:space="preserve"> + <value>同一个爬虫的 MSDP 列表。几乎是其 MSSP 版本的子集，读取它只为那少数几个另一份没有覆盖到的地址。</value> + </data> + <data name="about.source.mudConnector.note" xml:space="preserve"> + <value>在一个页面上发布整份目录，因此读一次只花一个请求。它是我们最大的地址来源，而不是任何实测数据的来源。</value> + </data> + <data name="about.source.mudStats.note" xml:space="preserve"> + <value>一个索引页，外加每个世界一个页面，所以只能抓取，而不能导出。2026 年 7 月 30 日，我们以十五秒的间隔、遵守 robots.txt 抓取了他们的 143 个页面，但当时还没有人写信联系过他们。这本不该发生。现在这道闸门需要有人愿意声明已经征询过维护者才会打开。</value> + </data> + <data name="about.source.mudVerse.note" xml:space="preserve"> + <value>已实现，已测试，从未运行。除许可这一项之外，它在各方面都是这里最强的来源；在有人写信联系他们之前，我们不会抓取任何内容。</value> + </data> + <data name="about.licence.heading" xml:space="preserve"> + <value>许可协议</value> + </data> + <data name="about.licence.code.lead" xml:space="preserve"> + <value>代码采用 MIT 许可协议。</value> + </data> + <data name="about.licence.code.body" xml:space="preserve"> + <value>本站、爬虫和各个解析器，均在 MIT 许可协议下开源。</value> + </data> + <data name="about.licence.open.lead" xml:space="preserve"> + <value>数据的许可协议尚无定论。</value> + </data> + <data name="about.licence.open.body" xml:space="preserve"> + <value>这是与代码分开的一项决定，目前尚未作出。请把下面的条款当作本部署当前的答复，而不是本项目已定的立场。竞争的目录把整份名录拿走，在这里算作一项成功，所以无论最终如何定夺，都不会挡它的路。</value> + </data> + <data name="about.licence.codeLabel" xml:space="preserve"> + <value>代码</value> + </data> + <data name="about.licence.dataLabel" xml:space="preserve"> + <value>数据，按本部署提供的形式</value> + </data> + <data name="about.licence.creditLabel" xml:space="preserve"> + <value>署名为</value> + </data> + <data name="about.licence.code.line" xml:space="preserve"> + <value>代码：{licence}</value> + </data> + <data name="about.licence.data.line" xml:space="preserve"> + <value>数据：{licence}</value> + </data> + <data name="about.licence.credit.line" xml:space="preserve"> + <value>署名为：{credit}</value> + </data> + <data name="about.licence.deployment" xml:space="preserve"> + <value>（这是本部署提供的形式。本项目自己的答复仍未定。）</value> + </data> + <data name="submit.title" xml:space="preserve"> + <value>提交游戏</value> + </data> + <data name="submit.lede" xml:space="preserve"> + <value>告诉我们某个游戏在哪里。一个主机加一个端口就是整张表单；本站其余的一切，都由我们自己的爬虫实测得出。</value> + </data> + <data name="submit.host.label" xml:space="preserve"> + <value>主机</value> + </data> + <data name="submit.port.label" xml:space="preserve"> + <value>端口</value> + </data> + <data name="submit.host.hint" xml:space="preserve"> + <value>mud.example.org，或者粘贴 mud.example.org:4201 并把端口留空</value> + </data> + <data name="submit.button" xml:space="preserve"> + <value>提交</value> + </data> + <data name="submit.noCatalogue" xml:space="preserve"> + <value>提交需要数据库，而本站正运行在演示数据上。没有可写入的爬取登记表，所以这里干脆不放表单，而不是放一个悄悄什么也不做的表单。</value> + </data> + <data name="submit.notHere" xml:space="preserve"> + <value>此处没有</value> + </data> + <data name="submit.what.heading" xml:space="preserve"> + <value>一个地址会经历什么</value> + </data> + <data name="submit.what.resolve" xml:space="preserve"> + <value>拨号之前我们先解析地址，凡是解析到公网之外的一律拒绝。那是关于我们自己套接字的决定，绝不是关于某个游戏的事实。</value> + </data> + <data name="submit.what.optOut" xml:space="preserve"> + <value>如果运行那台主机的人已经要求我们不要爬取，那么无论谁提交，我们都不会接受这个地址。陌生人无法把你的游戏重新放上本站。</value> + </data> + <data name="submit.what.schedule" xml:space="preserve"> + <value>如果它有应答，我们就读取服务器对自己的说法，并按它自己的节奏一直读下去。一个地址只需要给我们一次。</value> + </data> + <data name="submit.what.claim" xml:space="preserve"> + <value>在有人证明自己是运营者之前，站上不会出现任何内容。认领需要一个通行密钥，以及在游戏本身上发布的一行文字。</value> + </data> + <data name="submit.what.duplicate" xml:space="preserve"> + <value>我们已经有的地址会并入现有条目。重复提交不会产生第二个条目，也不会让探测提前。</value> + </data> + <data name="submit.answer.thatAddress" xml:space="preserve"> + <value>那个地址</value> + </data> + <data name="submit.accepted.heading" xml:space="preserve"> + <value>已进入登记表。</value> + </data> + <data name="submit.accepted.sentence" xml:space="preserve"> + <value>{address} 会在下一个爬取周期被拨号，此后一直按它自己的节奏进行。等有人证明自己是运营者，它就会出现在这里——带着同一个地址回到这张表单，它会把链接交给你。</value> + </data> + <data name="submit.unclaimed.heading" xml:space="preserve"> + <value>我们有它，尚无人认领。</value> + </data> + <data name="submit.unclaimed.sentence" xml:space="preserve"> + <value>{address} 是我们已经在实测的地址。在有人证明自己是运营者之前，它不会出现在站上。如果那个人就是你，这里就是入口。</value> + </data> + <data name="submit.known.heading" xml:space="preserve"> + <value>这个我们已经有了。</value> + </data> + <data name="submit.known.sentence" xml:space="preserve"> + <value>{address} 是我们已经在实测的游戏。没有创建任何内容，也没有改动任何内容。</value> + </data> + <data name="submit.knownAddress.heading" xml:space="preserve"> + <value>这个地址我们已经有了。</value> + </data> + <data name="submit.knownAddress.sentence" xml:space="preserve"> + <value>{address} 我们已经知道了。没有创建任何内容，也没有改动任何内容。</value> + </data> + <data name="submit.queued.heading" xml:space="preserve"> + <value>已经在等了。</value> + </data> + <data name="submit.queued.sentence" xml:space="preserve"> + <value>{address} 已在爬取登记表中，尚未应答。再次提交不会让它提前：每个目标都按自己的节奏来，所以谁也不能借我们去催别人的服务器。</value> + </data> + <data name="submit.malformed.heading" xml:space="preserve"> + <value>这不是我们能拨号的地址。</value> + </data> + <data name="submit.malformed.sentence" xml:space="preserve"> + <value>主机名里需要有一个点或一个冒号，端口是 1 到 65535 之间的数字。请把两个框都填上，或者把 mud.example.org:4201 粘贴到第一个框里。</value> + </data> + <data name="submit.undialable.heading" xml:space="preserve"> + <value>我们无法拨号到那里。</value> + </data> + <data name="submit.undialable.sentence" xml:space="preserve"> + <value>对 {address} 给出这个答复有三种可能：名称可能解析不了，可能解析到公网之外，也可能运行那台主机的人已经要求我们别去。我们刻意不说是哪一种，因为向陌生人回答这个问题，等于从外部把一张网络画出来。关于该地址没有记录任何内容；这个决定是我们做的，也记在我们自己名下。</value> + </data> + <data name="submit.tooMany.heading" xml:space="preserve"> + <value>暂时够了。</value> + </data> + <data name="submit.tooMany.sentence" xml:space="preserve"> + <value>这张表单按提交者限速，你已经到上限了。请一小时后再来。没有丢失任何东西——我们收下的内容都已经在登记表里。</value> + </data> + <data name="submit.link.claim" xml:space="preserve"> + <value>认领此游戏</value> + </data> + <data name="account.signIn.title" xml:space="preserve"> + <value>登录</value> + </data> + <data name="account.signIn.preview" xml:space="preserve"> + <value>用通行密钥登录，即可认领你运营的游戏。没有密码可丢，也没有密码可偷。</value> + </data> + <data name="account.signIn.noDatabase" xml:space="preserve"> + <value>认领需要数据库，而本站正运行在演示数据上。这里没有可登录的东西。</value> + </data> + <data name="account.signIn.passkey.lead" xml:space="preserve"> + <value>登录就是一个通行密钥。</value> + </data> + <data name="account.signIn.passkey.body" xml:space="preserve"> + <value>私钥保存在你的设备或密码管理器里；我们只保存公钥那一半。没有密码，没有电子邮箱。</value> + </data> + <data name="account.signIn.button" xml:space="preserve"> + <value>用通行密钥登录</value> + </data> + <data name="account.signIn.script" xml:space="preserve"> + <value>本站唯一需要 JavaScript 的页面。没有它，通行密钥无法工作。</value> + </data> + <data name="account.register.heading" xml:space="preserve"> + <value>还没有账户？</value> + </data> + <data name="account.register.lede" xml:space="preserve"> + <value>只有在认领你运营的游戏时才需要账户。取一个对外显示的名字——它是认领旁边的一个标签，不是真名。</value> + </data> + <data name="account.register.name.label" xml:space="preserve"> + <value>名称</value> + </data> + <data name="account.register.name.placeholder" xml:space="preserve"> + <value>例如 corvid-admin</value> + </data> + <data name="account.register.button" xml:space="preserve"> + <value>用通行密钥创建账户</value> + </data> + <data name="account.store.heading" xml:space="preserve"> + <value>我们存什么</value> + </data> + <data name="account.store.name" xml:space="preserve"> + <value>你选择的名称。</value> + </data> + <data name="account.store.keys" xml:space="preserve"> + <value>你注册的每个通行密钥的公钥，以及你的设备给它取的名字。</value> + </data> + <data name="account.store.claims" xml:space="preserve"> + <value>你认领了哪些游戏，以及认领的时间。</value> + </data> + <data name="account.store.note" xml:space="preserve"> + <value>不存电子邮箱，不存密码，也不把 IP 日志与你的账户关联。即使丢失了全部通行密钥，你也可以在自己的游戏上发布一个新的认领令牌，重新来过：凭据是游戏，不是账户。</value> + </data> + <data name="date.absolute" xml:space="preserve"> + <value>{year}年{month}{day}日</value> + </data> + <data name="date.stamp" xml:space="preserve"> + <value>{date} {time} UTC</value> + </data> + <data name="age.short.now" xml:space="preserve"> + <value>刚刚</value> + </data> + <data name="age.short.minutes" xml:space="preserve"> + <value>{count, plural, other {#分钟}}</value> + </data> + <data name="age.short.hours" xml:space="preserve"> + <value>{count, plural, other {#小时}}</value> + </data> + <data name="age.short.days" xml:space="preserve"> + <value>{count, plural, other {#天}}</value> + </data> + <data name="age.short.weeks" xml:space="preserve"> + <value>{count, plural, other {#周}}</value> + </data> + <data name="age.short.months" xml:space="preserve"> + <value>{count, plural, other {#个月}}</value> + </data> + <data name="age.short.years" xml:space="preserve"> + <value>{count, plural, other {#年}}</value> + </data> + <data name="age.ago.now" xml:space="preserve"> + <value>刚刚</value> + </data> + <data name="age.ago.minutes" xml:space="preserve"> + <value>{count, plural, other {#分钟前}}</value> + </data> + <data name="age.ago.hours" xml:space="preserve"> + <value>{count, plural, other {#小时前}}</value> + </data> + <data name="age.ago.days" xml:space="preserve"> + <value>{count, plural, other {#天前}}</value> + </data> + <data name="age.ago.weeks" xml:space="preserve"> + <value>{count, plural, other {#周前}}</value> + </data> + <data name="age.ago.months" xml:space="preserve"> + <value>{count, plural, other {#个月前}}</value> + </data> + <data name="age.ago.years" xml:space="preserve"> + <value>{count, plural, other {#年前}}</value> + </data> + <data name="age.dark.now" xml:space="preserve"> + <value>刚刚</value> + </data> + <data name="age.dark.minutes" xml:space="preserve"> + <value>{count, plural, other {#分钟前}}</value> + </data> + <data name="age.dark.hours" xml:space="preserve"> + <value>{count, plural, other {#小时前}}</value> + </data> + <data name="age.dark.days" xml:space="preserve"> + <value>{count, plural, other {#天前}}</value> + </data> + <data name="age.dark.weeks" xml:space="preserve"> + <value>{count, plural, other {#周前}}</value> + </data> + <data name="age.dark.months" xml:space="preserve"> + <value>{count, plural, other {#个月前}}</value> + </data> + <data name="age.dark.years" xml:space="preserve"> + <value>{count, plural, other {#年前}}</value> + </data> + <data name="time.title" xml:space="preserve"> + <value>{age}，{stamp}</value> + </data> + <data name="time.spoken" xml:space="preserve"> + <value>，{stamp}</value> + </data> + <data name="chip.title" xml:space="preserve"> + <value>{value}——经{source}{how}，最近确认于 {date}</value> + </data> + <data name="chip.title.stale" xml:space="preserve"> + <value>{value}——经{source}{how}，最近确认于 {date}（已过预期刷新期）</value> + </data> + <data name="chip.plain" xml:space="preserve"> + <value>（{how}，{age}）</value> + </data> + <data name="chip.plain.stale" xml:space="preserve"> + <value>（{how}，{age}，已过刷新期）</value> + </data> + <data name="provenance.game.ownerDeclared" xml:space="preserve"> + <value>所有者自述</value> + </data> + <data name="source.staff" xml:space="preserve"> + <value>本站工作人员</value> + </data> + <data name="source.handshake" xml:space="preserve"> + <value>telnet 握手</value> + </data> + <data name="source.owner" xml:space="preserve"> + <value>游戏所有者</value> + </data> + <data name="source.who" xml:space="preserve"> + <value>WHO</value> + </data> + <data name="source.i3" xml:space="preserve"> + <value>I3</value> + </data> + <data name="source.mssp" xml:space="preserve"> + <value>MSSP</value> + </data> + <data name="source.info" xml:space="preserve"> + <value>INFO</value> + </data> + <data name="source.i3Mudlist" xml:space="preserve"> + <value>I3 的游戏列表</value> + </data> + <data name="source.banner" xml:space="preserve"> + <value>连接画面</value> + </data> + <data name="ecosystem.title" xml:space="preserve"> + <value>生态</value> + </data> + <data name="ecosystem.noTotals" xml:space="preserve"> + <value>只讲占比，绝不讲总量。我们不发布有多少人在玩 MU* 的数字：在我们实测过的游戏上算出的比例，即使还有连不上的游戏也依然成立，人头总数则不然。</value> + </data> + <data name="ecosystem.listed" xml:space="preserve"> + <value>{count, plural, other {已列出的游戏 {value} 个}}</value> + </data> + <data name="ecosystem.handshakes" xml:space="preserve"> + <value>{count, plural, other {已完成握手的游戏 {value} 个}}</value> + </data> + <data name="ecosystem.msspReports" xml:space="preserve"> + <value>{count, plural, other {已持有 MSSP 报告的游戏 {value} 个}}</value> + </data> + <data name="ecosystem.oldestHandshake" xml:space="preserve"> + <value>此处最早的握手：{age}前确认。</value> + </data> + <data name="ecosystem.share" xml:space="preserve"> + <value>{total, number} 个中的 {count, number}（{fraction, number, ::percent .0}）</value> + </data> + <data name="ecosystem.share.nothing" xml:space="preserve"> + <value>{total, number} 个中的 {count, number}——尚无实测</value> + </data> + <data name="ecosystem.share.percent" xml:space="preserve"> + <value>{fraction, number, ::percent .0}</value> + </data> + <data name="ecosystem.codebases.title" xml:space="preserve"> + <value>代码库</value> + </data> + <data name="ecosystem.codebases.basis" xml:space="preserve"> + <value>在已列出的{listed, plural, other {#个游戏}}中，有 {identified, number} 个告诉了我们它们运行的是什么，下面每一项占比都是相对这 {identified, number} 个算出来的。读不出代码库的游戏被排除在分母之外，绝不会被算作别的东西。</value> + </data> + <data name="ecosystem.codebases.none" xml:space="preserve"> + <value>还没有已列出的游戏告诉过我们它的代码库。</value> + </data> + <data name="ecosystem.soleUse" xml:space="preserve"> + <value>{share} 运行的代码库，没有任何其他已列出的游戏在用——每种各一个游戏，那是一个名字，而不是一份占比。它们计入上面的分母，只是从条形图中折叠起来，并没有被丢弃：</value> + </data> + <data name="ecosystem.lineages.title" xml:space="preserve"> + <value>谱系</value> + </data> + <data name="ecosystem.lineages.basis" xml:space="preserve"> + <value>还是这些游戏，按其服务器所承袭的传统分组——这是我们对代码库的判读，而不是任何游戏发布过的东西。没有游戏会报告“MUSH”：MSSP 里没有这个取值，而 MUSH 世界的大多数根本不发布 MSSP，所以只有这样，这个问题才问得出来。</value> + </data> + <data name="ecosystem.lineages.none" xml:space="preserve"> + <value>还没有已列出的游戏运行我们能归入某个谱系的代码库。</value> + </data> + <data name="ecosystem.lineages.notClassified" xml:space="preserve"> + <value>{count, plural, other {其中#个游戏运行的代码库}}我们没有归入任何谱系——有几个自己也这么说，它们发布的是 {family}。它们计入上面的分母，但不属于任何一份占比。</value> + </data> + <data name="ecosystem.protocols.title" xml:space="preserve"> + <value>协议</value> + </data> + <data name="ecosystem.protocols.floor" xml:space="preserve"> + <value>下面每一个实测数字都应读作下限。MSSP 是我们指名索取的，所以在这一项上，沉默本身就是一种回答。其余各项我们都不索取，服务器可能支持某个协议，却从不主动提供。</value> + </data> + <data name="ecosystem.mssp.instrument" xml:space="preserve"> + <value>{instrument} 是下面唯一不算下限的一行：我们向每台服务器指名索取它，所以没有提供它的游戏，是被问过之后拒绝的。它也是唯一没有自述数字的一项，因为凡是我们持有其报告的游戏，都已用行动证明支持它，再去数其中有多少同时把它列了出来，量到的只是一种习惯。</value> + </data> + <data name="ecosystem.mssp.gap" xml:space="preserve"> + <value>我们持有 {reports, number} 份报告，而今天提供 MSSP 的有{offered, plural, other {#个游戏}}：另外 {gap, number} 个在我们读过之后就不再发布了，一份报告不会因为不再重发而被丢弃。</value> + </data> + <data name="ecosystem.protocols.caption" xml:space="preserve"> + <value>协议采用情况。实测是服务器在一次完成的握手中提供的内容，自述是它的 MSSP 所声称的内容。两组不同的游戏，因此有两个分母。</value> + </data> + <data name="ecosystem.column.protocol" xml:space="preserve"> + <value>协议</value> + </data> + <data name="ecosystem.column.measured" xml:space="preserve"> + <value>实测——占 {basis}</value> + </data> + <data name="ecosystem.column.declared" xml:space="preserve"> + <value>自述——占 {basis}</value> + </data> + <data name="ecosystem.measured.never" xml:space="preserve"> + <value>未实测——从未观测到</value> + </data> + <data name="ecosystem.measured.declined" xml:space="preserve"> + <value>{share} · {declined, plural, other {#个游戏}}被问及时拒绝</value> + </data> + <data name="ecosystem.measured.unasked" xml:space="preserve"> + <value>{share} · {unobserved, plural, other {#个游戏}}既未提供也未被问及</value> + </data> + <data name="ecosystem.measured.declinedAndUnasked" xml:space="preserve"> + <value>{share} · {declined, plural, other {#个游戏}}被问及时拒绝 · {unobserved, plural, other {#个游戏}}既未提供也未被问及</value> + </data> + <data name="ecosystem.declared.none" xml:space="preserve"> + <value>未索取——这里的每一份报告本身就是回答</value> + </data> + <data name="ecosystem.curve.title" xml:space="preserve"> + <value>采用情况随时间的变化</value> + </data> + <data name="ecosystem.curve.caveat" xml:space="preserve"> + <value>每个点都是当天我们已实测的那些游戏上的占比，所以这条线会因两件事而移动：某个游戏改变了它提供的内容，以及我们能实测的游戏集合在它周围发生了变化。只有前者才是采用。下面的变更次数，才是纯粹由游戏改变主意构成的那一部分。</value> + </data> + <data name="ecosystem.curve.caption" xml:space="preserve"> + <value>各协议的实测占比，最早的读数在前</value> + </data> + <data name="ecosystem.curve.then" xml:space="preserve"> + <value>当时</value> + </data> + <data name="ecosystem.curve.now" xml:space="preserve"> + <value>现在</value> + </data> + <data name="ecosystem.curve.notMeasured" xml:space="preserve"> + <value>未实测</value> + </data> + <data name="ecosystem.snapshot.title" xml:space="preserve"> + <value>这是快照，不是曲线</value> + </data> + <data name="ecosystem.snapshot" xml:space="preserve"> + <value>这是我们现在能实测到的情况的一张快照。采用曲线画的是游戏改变主意，而我们在变化发生时才记录它，所以等记录得足够多，曲线才画得出来。若改用我们首次连通各个游戏的时间来作图，量到的将是这次爬取，而不是这个爱好。</value> + </data> + <data name="ecosystem.transitions" xml:space="preserve"> + <value>{count, plural, other {迄今已记录#次能力变更}}——曲线正是用这些材料画出来的。</value> + </data> + <data name="ecosystem.transitions.none" xml:space="preserve"> + <value>还没有任何实测能力发生过变化，因此无从作图。</value> + </data> + <data name="ecosystem.plain.denominators" xml:space="preserve"> + <value>实测的分母是 {measured}，自述的分母是 {declared}。两组不同的游戏，因此有两个分母。</value> + </data> + <data name="ecosystem.plain.counts" xml:space="preserve"> + <value>{listed} · {handshakes} · {mssp}。</value> + </data> + <data name="ecosystem.plain.oldestHandshake" xml:space="preserve"> + <value>这张图里最早的握手，最近一次确认是在 {age}前。</value> + </data> + <data name="ecosystem.plain.lineages" xml:space="preserve"> + <value>还是这些游戏，按其服务器所承袭的传统分组。这是{evidence}——{meaning}——而不是任何游戏发布过的东西：没有游戏会报告“MUSH”，因为 MSSP 里没有这个取值，而 MUSH 世界的大多数根本不发布 MSSP。</value> + </data> + <data name="ecosystem.plain.measured" xml:space="preserve"> + <value>实测：{value}</value> + </data> + <data name="ecosystem.plain.declared" xml:space="preserve"> + <value>自述：{value}</value> + </data> + <data name="rankings.title" xml:space="preserve"> + <value>排行</value> + </data> + <data name="rankings.noVote" xml:space="preserve"> + <value>仅由实测数据算出。永远没有投票、星级或评分。这里没有任何东西是对质量的排名。我们没有测过质量。</value> + </data> + <data name="rankings.busiest.title" xml:space="preserve"> + <value>最热闹——按实测的同时连接人数</value> + </data> + <data name="rankings.window.label" xml:space="preserve"> + <value>排行时间窗</value> + </data> + <data name="rankings.span" xml:space="preserve"> + <value>{days, plural, other {#天}}</value> + </data> + <data name="rankings.basis.median" xml:space="preserve"> + <value>最近{days, plural, other {#天}}内我们实测到的人数的中位数。</value> + </data> + <data name="rankings.basis.none" xml:space="preserve"> + <value>还没有游戏在{days, plural, other {#天}}内取得中位数所需的 {samples, number} 个样本。</value> + </data> + <data name="rankings.basis.eligible" xml:space="preserve"> + <value>{listed, number} 个已列出的游戏中，有{eligible, plural, other {#个}}在{days, plural, other {#天}}内取得了所需的 {samples, number} 个样本。</value> + </data> + <data name="rankings.basis.zero" xml:space="preserve"> + <value>实测到的零算数；读不出来的计数不算。</value> + </data> + <data name="rankings.spanChoice" xml:space="preserve"> + <value>一周说的是现在谁热闹，一个季度说的是一直以来谁热闹。这是两个不同的问题，一个游戏可能在其中一项领先，而在另一项不然。天数按整天计，时间为 UTC。</value> + </data> + <data name="rankings.busiest.empty" xml:space="preserve"> + <value>还没有已列出的游戏拥有足以参与排行的已计数样本——这说的是我们测了多久，而不是谁有多热闹。</value> + </data> + <data name="rankings.busiest.caption" xml:space="preserve"> + <value>按最近{days, plural, other {#天}}内我们实测到的人数的中位数为游戏排名。中位数相同的游戏并列同一名次，这里不做任何附加排序来分先后。</value> + </data> + <data name="rankings.column.place" xml:space="preserve"> + <value>#</value> + </data> + <data name="rankings.column.game" xml:space="preserve"> + <value>游戏</value> + </data> + <data name="rankings.column.median" xml:space="preserve"> + <value>中位数</value> + </data> + <data name="rankings.column.peak" xml:space="preserve"> + <value>峰值</value> + </data> + <data name="rankings.column.samples" xml:space="preserve"> + <value>已计数样本</value> + </data> + <data name="rankings.column.days" xml:space="preserve"> + <value>实测天数</value> + </data> + <data name="rankings.spells.title" xml:space="preserve"> + <value>连续可连通时间最长</value> + </data> + <data name="rankings.spells.basis" xml:space="preserve"> + <value>自所给日期起的每一次探测，都发现该游戏可连通。是可连通，不是在线：我们从一台主机上测一个套接字，路由不到的游戏完全可能好好活着。一段连续时长不可能超过我们观察的时长，所以日期才是事实，时长由它推出。</value> + </data> + <data name="rankings.spells.empty" xml:space="preserve"> + <value>目前没有已列出的游戏处在连续可连通的时段中。</value> + </data> + <data name="rankings.spells.caption" xml:space="preserve"> + <value>自所给日期起每一次探测都可连通的游戏。自同一日期起可连通的游戏并列同一名次，这里不做任何附加排序来分先后。</value> + </data> + <data name="rankings.column.since" xml:space="preserve"> + <value>可连通起始</value> + </data> + <data name="rankings.column.duration" xml:space="preserve"> + <value>即</value> + </data> + <data name="rankings.archivedNote" xml:space="preserve"> + <value>已归档的游戏只是不在这两张表里，仅此而已；一次成功的探测就能让它们回来。</value> + </data> + <data name="rankings.plain.busiest" xml:space="preserve"> + <value>最热闹——最近{days, plural, other {#天}}实测人数中位数</value> + </data> + <data name="rankings.plain.windows" xml:space="preserve"> + <value>时间窗：</value> + </data> + <data name="rankings.plain.thisOne" xml:space="preserve"> + <value>当前这个</value> + </data> + <data name="rankings.plain.row" xml:space="preserve"> + <value>中位数 {median, number} · 峰值 {peak, number} · {window, number} 天中的 {days, number} 天里共有{samples, plural, other {#个已计数样本}}</value> + </data> + <data name="rankings.plain.spellRow" xml:space="preserve"> + <value>自 {date} 起每次探测均可连通 · {duration}</value> + </data> + <data name="archive.title" xml:space="preserve"> + <value>归档</value> + </data> + <data name="archive.lede" xml:space="preserve"> + <value>已经停止应答的游戏。没有删除任何内容。我们仍每周探测，一次成功的探测当天就能把游戏放回列表。</value> + </data> + <data name="archive.search.legend" xml:space="preserve"> + <value>搜索归档</value> + </data> + <data name="archive.search.label" xml:space="preserve"> + <value>搜索已归档的游戏</value> + </data> + <data name="archive.search.placeholder" xml:space="preserve"> + <value>名称、代码库或简介</value> + </data> + <data name="archive.search.submit" xml:space="preserve"> + <value>显示</value> + </data> + <data name="archive.count" xml:space="preserve"> + <value>{count, plural, =0 {没有已归档的游戏} other {#个已归档的游戏}}</value> + </data> + <data name="archive.badge" xml:space="preserve"> + <value>已归档</value> + </data> + <data name="archive.lastReachable" xml:space="preserve"> + <value>最近连通</value> + </data> + <data name="archive.knownLive" xml:space="preserve"> + <value>已知存活</value> + </data> + <data name="archive.darkFor" xml:space="preserve"> + <value>（{age}前）</value> + </data> + <data name="archive.empty" xml:space="preserve"> + <value>没有匹配结果。</value> + </data> + <data name="archive.neverReachable" xml:space="preserve"> + <value>在我们实测过的范围内从未连通</value> + </data> + <data name="archive.noReachableTime" xml:space="preserve"> + <value>未实测到可连通时长</value> + </data> + <data name="archive.darkFor.unknown" xml:space="preserve"> + <value>未知</value> + </data> + <data name="archive.knownLive.years" xml:space="preserve"> + <value>{years, number, ::.#} 年</value> + </data> + <data name="archive.knownLive.days" xml:space="preserve"> + <value>{days, plural, other {#天}}</value> + </data> + <data name="archive.run" xml:space="preserve"> + <value>{from} – {to} · {span}</value> + </data> + <data name="archive.run.months" xml:space="preserve"> + <value>{count, plural, other {#个月}}</value> + </data> + <data name="archive.run.years" xml:space="preserve"> + <value>{count, plural, other {#年}}</value> + </data> + <data name="archive.plain.matching" xml:space="preserve"> + <value>{count, plural, other {有#个游戏}}匹配“{query}”</value> + </data> + <data name="archive.plain.count" xml:space="preserve"> + <value>{count, plural, other {#个游戏}}</value> + </data> + <data name="archive.plain.lastReachable" xml:space="preserve"> + <value>最近连通：</value> + </data> + <data name="archive.plain.knownLive" xml:space="preserve"> + <value>已知存活：</value> + </data> + <data name="archive.plain.knownLiveValue" xml:space="preserve"> + <value>实测可连通时长 {value}</value> + </data> + <data name="archive.plain.run" xml:space="preserve"> + <value>运行期：</value> + </data> + <data name="archive.plain.codebase" xml:space="preserve"> + <value>代码库：</value> + </data> + <data name="footer.randomGame" xml:space="preserve"> + <value>随机游戏</value> + </data> + <data name="trend.day.counted" xml:space="preserve"> + <value>{d, date, medium}——平均 {typical}，{probes, plural, other {#次探测}}中介于 {low}–{high}</value> + </data> + <data name="trend.day.flat" xml:space="preserve"> + <value>{d, date, medium}——{count, plural, =0 {0 人} other {#人}}，{probes, plural, other {#次探测}}次次如此</value> + </data> + <data name="trend.day.notCounted" xml:space="preserve"> + <value>{d, date, medium}——已探测，未能读取计数</value> + </data> + <data name="trend.day.notMeasured" xml:space="preserve"> + <value>{d, date, medium}——无实测</value> + </data> + <data name="trend.summary" xml:space="preserve"> + <value>在{days, plural, other {#天}}中的 {counted} 天里，典型有 {typical} 人在线，峰值 {peak}。</value> + </data> + <data name="trend.direction.steady" xml:space="preserve"> + <value>整个区间内保持平稳。</value> + </data> + <data name="trend.direction.up" xml:space="preserve"> + <value>从区间开始到结束，约上升 {change, number, percent}。</value> + </data> + <data name="trend.direction.down" xml:space="preserve"> + <value>从区间开始到结束，约下降 {change, number, percent}。</value> + </data> + <data name="trend.none.probed" xml:space="preserve"> + <value>本区间内有过探测，其中任何一次都未能读出在线人数。</value> + </data> + <data name="trend.none.notMeasured" xml:space="preserve"> + <value>本区间内没有实测。</value> + </data> + <data name="trend.empty" xml:space="preserve"> + <value>本区间内没有计到任何数。</value> + </data> + <data name="trend.week.span" xml:space="preserve"> + <value>{from, date, d MMM}–{to, date, d MMM}</value> + </data> + <data name="trend.week.oneDay" xml:space="preserve"> + <value>{d, date, d MMM}</value> + </data> + <data name="trend.week.counted" xml:space="preserve"> + <value>{span}：典型 {typical}，峰值 {peak}，已计数{days, plural, other {#天}}</value> + </data> + <data name="trend.week.notCounted" xml:space="preserve"> + <value>{span}：已探测，未能读取计数</value> + </data> + <data name="trend.week.notMeasured" xml:space="preserve"> + <value>{span}：未实测</value> + </data> + <data name="trend.week.uncounted" xml:space="preserve"> + <value>{count, plural, other {#天已探测但没有计数}}</value> + </data> + <data name="trend.week.unmeasured" xml:space="preserve"> + <value>{count, plural, other {#天未实测}}</value> + </data> + <data name="trend.week.and" xml:space="preserve"> + <value>{line}，{clause}</value> + </data> + <data name="trend.range" xml:space="preserve"> + <value>按 UTC 计日 · {from, date, medium} – {to, date, medium}</value> + </data> + <data name="trend.ceiling" xml:space="preserve"> + <value>顶端为 {value}</value> + </data> + <data name="trend.counted" xml:space="preserve"> + <value>{days, plural, other {#天}}中已计数 {counted} 天</value> + </data> + <data name="trend.axis.month" xml:space="preserve"> + <value>{d, date, MMM}</value> + </data> + <data name="trend.axis.monthYear" xml:space="preserve"> + <value>{d, date, MMM yyyy}</value> + </data> + <data name="trend.legend.mean" xml:space="preserve"> + <value>当天我们读到的各次计数的平均值</value> + </data> + <data name="trend.legend.peak" xml:space="preserve"> + <value>直到当天最热闹的那次计数</value> + </data> + <data name="trend.legend.band" xml:space="preserve"> + <value>当天最低到最高的计数</value> + </data> + <data name="trend.legend.notCounted" xml:space="preserve"> + <value>已探测，未能读取计数</value> + </data> + <data name="trend.legend.notMeasured.bar" xml:space="preserve"> + <value>未实测——完全没有条形</value> + </data> + <data name="trend.legend.notMeasured.line" xml:space="preserve"> + <value>未实测——线条断开一段</value> + </data> + <data name="trend.spans.label" xml:space="preserve"> + <value>趋势区间</value> + </data> + <data name="trend.shapes.label" xml:space="preserve"> + <value>趋势图形</value> + </data> + <data name="trend.preset" xml:space="preserve"> + <value>{days, plural, other {#天}}</value> + </data> + <data name="trend.earlier" xml:space="preserve"> + <value>← 更早</value> + </data> + <data name="trend.later" xml:space="preserve"> + <value>更近 →</value> + </data> + <data name="trend.shape.line" xml:space="preserve"> + <value>折线</value> + </data> + <data name="trend.shape.bar" xml:space="preserve"> + <value>条形</value> + </data> + <data name="trend.plain.heading" xml:space="preserve"> + <value>人数随时间变化</value> + </data> + <data name="trend.plain.range" xml:space="preserve"> + <value>{from, date, medium} – {to, date, medium}，UTC</value> + </data> + <data name="trend.plain.earlier" xml:space="preserve"> + <value>更早</value> + </data> + <data name="trend.plain.note" xml:space="preserve"> + <value>一周的概况按其中我们计到数的那些天汇总；一天也没有的那一周会明确说明</value> + </data> + <data name="reach.kicker" xml:space="preserve"> + <value>可连通 · 最近{days, plural, other {#天}}</value> + </data> + <data name="reach.stat.reachable" xml:space="preserve"> + <value>可连通</value> + </data> + <data name="reach.stat.longestOutage" xml:space="preserve"> + <value>最长中断</value> + </data> + <data name="reach.stat.lastCause" xml:space="preserve"> + <value>最近原因</value> + </data> + <data name="reach.noOutage" xml:space="preserve"> + <value>窗口内没有</value> + </data> + <data name="reach.noCause" xml:space="preserve"> + <value>未记录</value> + </data> + <data name="reach.scale.ago" xml:space="preserve"> + <value>{days, plural, other {#天前}}</value> + </data> + <data name="reach.scale.today" xml:space="preserve"> + <value>今天</value> + </data> + <data name="reach.legend.reachable" xml:space="preserve"> + <value>可连通</value> + </data> + <data name="reach.legend.degraded" xml:space="preserve"> + <value>降级——有应答，未能完成</value> + </data> + <data name="reach.legend.unreachable" xml:space="preserve"> + <value>无法连通</value> + </data> + <data name="reach.legend.notMeasured" xml:space="preserve"> + <value>未实测</value> + </data> + <data name="reach.word.reachable" xml:space="preserve"> + <value>可连通</value> + </data> + <data name="reach.word.degraded" xml:space="preserve"> + <value>降级</value> + </data> + <data name="reach.word.unreachable" xml:space="preserve"> + <value>无法连通</value> + </data> + <data name="reach.word.notMeasured" xml:space="preserve"> + <value>未实测</value> + </data> + <data name="reach.day.reachable" xml:space="preserve"> + <value>{d, date, d MMM}——全天可连通</value> + </data> + <data name="reach.day.degraded" xml:space="preserve"> + <value>{d, date, d MMM}——降级（{cause}）：有应答，未能完成</value> + </data> + <data name="reach.day.unreachable" xml:space="preserve"> + <value>{d, date, d MMM}——无法连通（{cause}）</value> + </data> + <data name="reach.day.notMeasured" xml:space="preserve"> + <value>{d, date, d MMM}——未实测；当时我们还没有开始观测这个游戏</value> + </data> + <data name="reach.none" xml:space="preserve"> + <value>{days, plural, other {最近#天尚未实测。}}</value> + </data> + <data name="reach.fraction.window" xml:space="preserve"> + <value>最近{days, plural, other {#天}}中，有 {percent} 的时间可连通。</value> + </data> + <data name="reach.fraction.measured" xml:space="preserve"> + <value>在我们已实测的{days, plural, other {#天}}中，有 {percent} 的时间可连通。</value> + </data> + <data name="reach.fraction.unknown" xml:space="preserve"> + <value>{days, plural, other {最近#天的可连通情况尚未实测。}}</value> + </data> + <data name="reach.unreachable.noneInWindow" xml:space="preserve"> + <value>窗口内没有哪一天是无法连通的。</value> + </data> + <data name="reach.unreachable.noneMeasured" xml:space="preserve"> + <value>我们实测过的日子里，没有哪一天是无法连通的。</value> + </data> + <data name="reach.unreachable.days" xml:space="preserve"> + <value>{count, plural, other {#天无法连通。}}</value> + </data> + <data name="reach.degraded.days" xml:space="preserve"> + <value>{count, plural, other {#天降级——我们连上了，但未能完成。}}</value> + </data> + <data name="reach.longestOutage" xml:space="preserve"> + <value>最长中断 {duration}。</value> + </data> + <data name="reach.longestOutage.cause" xml:space="preserve"> + <value>最长中断 {duration}（{cause}）。</value> + </data> + <data name="reach.predate" xml:space="preserve"> + <value>{count, plural, other {有#天早于我们的任何实测。}}</value> + </data> + <data name="reach.spell.range" xml:space="preserve"> + <value>{from, date, d MMM} – {to, date, d MMM}</value> + </data> + <data name="reach.spell.oneDay" xml:space="preserve"> + <value>{d, date, d MMM}</value> + </data> + <data name="reach.spell" xml:space="preserve"> + <value>{range}：{word}{count, plural, other {#天}}</value> + </data> + <data name="reach.spell.cause" xml:space="preserve"> + <value>{range}：{word}{count, plural, other {#天}}（{cause}）</value> + </data> + <data name="reach.plain.heading" xml:space="preserve"> + <value>可连通</value> + </data> + <data name="reach.plain.window" xml:space="preserve"> + <value>{days, plural, other {最近#天}}</value> + </data> + <data name="reach.plain.fraction" xml:space="preserve"> + <value>可连通：{days, plural, other {最近#天}}中的 {percent}</value> + </data> + <data name="reach.plain.longestOutage" xml:space="preserve"> + <value>最长中断：{duration}</value> + </data> + <data name="cause.dns" xml:space="preserve"> + <value>dns 未能解析</value> + </data> + <data name="cause.refused" xml:space="preserve"> + <value>连接被拒绝</value> + </data> + <data name="cause.tls" xml:space="preserve"> + <value>tls 失败</value> + </data> + <data name="cause.timeout" xml:space="preserve"> + <value>超时</value> + </data> + <data name="cause.handshakeStalled" xml:space="preserve"> + <value>握手停滞</value> + </data> + <data name="cause.none" xml:space="preserve"> + <value>未记录原因</value> + </data> + <data name="ansi.suppressed" xml:space="preserve"> + <value>所有者要求我们不要再发布这个游戏的连接画面。</value> + </data> + <data name="ansi.absent" xml:space="preserve"> + <value>尚未从这个游戏捕获到连接画面。</value> + </data> + <data name="ansi.tooSmall" xml:space="preserve"> + <value>{count, plural, other {只回来了#行——太少，无法显示。}}</value> + </data> + <data name="ansi.asSent" xml:space="preserve"> + <value>按服务器发送的原样</value> + </data> + <data name="ansi.size" xml:space="preserve"> + <value>{columns}×{rows}</value> + </data> + <data name="ansi.size.doubleWidth" xml:space="preserve"> + <value>{columns}×{rows}，双倍宽</value> + </data> + <data name="ansi.depth.colour" xml:space="preserve"> + <value>16 色 SGR</value> + </data> + <data name="ansi.depth.plain" xml:space="preserve"> + <value>无颜色</value> + </data> + <data name="ansi.readAs" xml:space="preserve"> + <value>按 {charset} 解读</value> + </data> + <data name="ansi.captured" xml:space="preserve"> + <value>已捕获</value> + </data> + <data name="ansi.frozen" xml:space="preserve"> + <value>已冻结——我们最后看到的画面</value> + </data> + <data name="ansi.alt.named" xml:space="preserve"> + <value>ASCII 图画：{game} 的连接画面。它的文本在下方的“以文本形式阅读”中。</value> + </data> + <data name="ansi.alt" xml:space="preserve"> + <value>ASCII 图画：这个游戏的连接画面。它的文本在下方的“以文本形式阅读”中。</value> + </data> + <data name="ansi.plain.rows" xml:space="preserve"> + <value>{count, plural, other {连接画面：#行，仅文本}}</value> + </data> + <data name="ansi.plain.rows.readAs" xml:space="preserve"> + <value>{count, plural, other {连接画面：#行，仅文本，按 {charset} 解读}}</value> + </data> + <data name="capability.disagree.declaredNotOffered" xml:space="preserve"> + <value>游戏自述具备该项，而服务器在握手中从未提供过它。</value> + </data> + <data name="capability.disagree.offeredNotDeclared" xml:space="preserve"> + <value>服务器提供该项，而游戏自己的记录说它没有。</value> + </data> + <data name="capability.disagree.note" xml:space="preserve"> + <value>通常只是一个久未更新的手打字段，而不是谎言。之所以显示出来，是因为客户端不该依赖两者不一致的部分。</value> + </data> + <data name="game.notFound" xml:space="preserve"> + <value>未找到</value> + </data> + <data name="game.notFound.hint" xml:space="preserve"> + <value>这个地址上没有游戏。请检查拼写。</value> + </data> + <data name="game.endpoint.lastAnswered" xml:space="preserve"> + <value>最近应答</value> + </data> + <data name="game.stale" xml:space="preserve"> + <value>{count, plural, other {有#项已超过刷新窗口。是旧，不是错。}}</value> + </data> + <data name="game.referrals.lists" xml:space="preserve"> + <value>这个游戏自己的转介列表点名了：</value> + </data> + <data name="game.referrals.listedBy" xml:space="preserve"> + <value>被以下游戏的转介列表点名：</value> + </data> + <data name="game.referral.since" xml:space="preserve"> + <value>自 {date} 起</value> + </data> + <data name="game.referral.dropped" xml:space="preserve"> + <value>已不再列出，最后一次见于</value> + </data> + <data name="game.archived.lastAnswered" xml:space="preserve"> + <value>最近一次应答是 {date}，距今 {ago}。</value> + </data> + <data name="game.archived.stillProbed" xml:space="preserve"> + <value>仍每周探测；它一应答，本页当天就会更新。</value> + </data> + <data name="game.archived.knownLive" xml:space="preserve"> + <value>已知存活 {span}</value> + </data> + <data name="game.excluded" xml:space="preserve"> + <value>不在列表、排行或每日数字中：我们认为这个地址不是一个可供人游玩的游戏。下面的一切都是它告诉我们的内容，原样未改。</value> + </data> + <data name="game.excluded.reason" xml:space="preserve"> + <value>我们的理由：{why}</value> + </data> + <data name="game.unlisted" xml:space="preserve"> + <value>应运营者的要求，不在列表、排行或每日数字中。下面的一切按原样保留，本页和它曾用过的每一个地址都继续应答，而我们不再向它拨号。</value> + </data> + <data name="game.plain.playersNow" xml:space="preserve"> + <value>当前人数：{count}</value> + </data> + <data name="game.plain.capabilities" xml:space="preserve"> + <value>能力（{total} 项中有 {disagreeing} 项不一致）</value> + </data> + <data name="game.plain.declared" xml:space="preserve"> + <value>游戏自述</value> + </data> + <data name="game.plain.connectScreen" xml:space="preserve"> + <value>连接画面</value> + </data> + <data name="game.plain.whatChanged" xml:space="preserve"> + <value>变更记录</value> + </data> + <data name="game.plain.measured" xml:space="preserve"> + <value>实测</value> + </data> + <data name="game.plain.declared.column" xml:space="preserve"> + <value>自述</value> + </data> + <data name="game.plain.disagree" xml:space="preserve"> + <value>** 不一致</value> + </data> + <data name="listing.row.connected" xml:space="preserve"> + <value>连接数</value> + </data> + <data name="listing.row.reached" xml:space="preserve"> + <value>连通</value> + </data> + <data name="facet.group.search" xml:space="preserve"> + <value>搜索</value> + </data> + <data name="facet.group.archived" xml:space="preserve"> + <value>已归档</value> + </data> + <data name="facet.group.adult" xml:space="preserve"> + <value>成人</value> + </data> + <data name="facet.value.included" xml:space="preserve"> + <value>已包含</value> + </data> + <data name="game.count.none" xml:space="preserve"> + <value>无计数</value> + </data> + <data name="game.count.none.why" xml:space="preserve"> + <value>当前无计数，此处也不指明原因</value> + </data> + <data name="game.plain.playersNoCount" xml:space="preserve"> + <value>当前人数：无计数（此处不指明原因）</value> + </data> + <data name="crawler.live" xml:space="preserve"> + <value>爬虫运行中 · 最近探测 {age}</value> + </data> + <data name="crawler.quiet" xml:space="preserve"> + <value>爬虫空闲 · 最近探测 {age}</value> + </data> + <data name="crawler.noProbe" xml:space="preserve"> + <value>此处尚未完成过任何探测</value> + </data> + <data name="crawler.cycle.nothingDue" xml:space="preserve"> + <value>本周期无到期目标</value> + </data> + <data name="crawler.cycle" xml:space="preserve"> + <value>{considered, plural, other {#个到期}} · {answered, plural, other {#个应答}} · {failed, plural, other {#个失败}}</value> + </data> + <data name="crawler.registry" xml:space="preserve"> + <value>登记表中有{targets, plural, other {#个地址}}，{due, plural, other {其中#个已到期}}</value> + </data> + <data name="preview.documentTitle" xml:space="preserve"> + <value>{page} — {site}</value> + </data> + <data name="preview.site" xml:space="preserve"> + <value>MU* 爱好的游戏目录——MUSH、MUD、MUCK、MOO——每一项事实都标明它的来源与时间。</value> + </data> + <data name="preview.demo" xml:space="preserve"> + <value>演示数据——此处没有任何内容经过实测。{description}</value> + </data> + <data name="preview.cardAlt" xml:space="preserve"> + <value>{site}——实测，而非自述</value> + </data> + <data name="preview.cardAlt.named" xml:space="preserve"> + <value>{site} 上的 {title}</value> + </data> + <data name="preview.title.games" xml:space="preserve"> + <value>游戏</value> + </data> + <data name="preview.title.archive" xml:space="preserve"> + <value>归档</value> + </data> + <data name="preview.title.rankings" xml:space="preserve"> + <value>排行</value> + </data> + <data name="preview.title.ecosystem" xml:space="preserve"> + <value>生态</value> + </data> + <data name="preview.title.reference" xml:space="preserve"> + <value>参考</value> + </data> + <data name="preview.title.about" xml:space="preserve"> + <value>关于</value> + </data> + <data name="preview.title.notFound" xml:space="preserve"> + <value>未找到</value> + </data> + <data name="preview.title.random" xml:space="preserve"> + <value>随机游戏</value> + </data> + <data name="preview.title.account" xml:space="preserve"> + <value>我的游戏</value> + </data> + <data name="preview.title.claim" xml:space="preserve"> + <value>认领 {game}</value> + </data> + <data name="preview.desc.games" xml:space="preserve"> + <value>我们连通过的每一个 MU*，按实测结果分面：代码库、服务器在握手中提供的协议、TLS、编码、语言，以及我们最近一次连入的时间。</value> + </data> + <data name="preview.desc.archive" xml:space="preserve"> + <value>已经失联的游戏，都保留下来。每个都保有自己的页面、历史和 URL，仍每周探测，一次成功连接即可回到列表。</value> + </data> + <data name="preview.desc.rankings" xml:space="preserve"> + <value>最热闹、最可连通、运行最久——仅由实测数据算出。本站任何地方都没有投票、星级或评分。</value> + </data> + <data name="preview.desc.ecosystem" xml:space="preserve"> + <value>我们实测的游戏中，代码库的占比与协议的采用情况，服务器提供的内容与它自述的内容并列呈现。只讲占比，绝不讲总量。</value> + </data> + <data name="preview.desc.reference" xml:space="preserve"> + <value>关于 MU* 爱好中的代码库、客户端与协议的手写页面，并与爬取所得的计数相互链接。</value> + </data> + <data name="preview.desc.about" xml:space="preserve"> + <value>这份目录是如何建成的：爬虫做什么、拒绝做什么，以及如何让它停下。</value> + </data> + <data name="preview.desc.notFound" xml:space="preserve"> + <value>这个地址上没有游戏。本站任何内容都不会被删除，所以曾经在这个 URL 上的游戏如今依然在——请检查拼写。</value> + </data> + <data name="preview.desc.random" xml:space="preserve"> + <value>从目录中随机挑出的一个游戏，绝不会连着两次相同。</value> + </data> + <data name="preview.desc.account" xml:space="preserve"> + <value>你已认领的条目，以及一次认领能让你改动什么。</value> + </data> + <data name="preview.desc.claim" xml:space="preserve"> + <value>在只有运营者才能放置的地方发布一个令牌，以此证明这个游戏由你运营。</value> + </data> + <data name="preview.game.archived" xml:space="preserve"> + <value>已归档——最近连通 {age}，仍在探测</value> + </data> + <data name="preview.game.archived.undated" xml:space="preserve"> + <value>已归档，仍在探测</value> + </data> + <data name="preview.game.countUnknown" xml:space="preserve"> + <value>人数未知——游戏有应答，但没有发布我们能读出的数字</value> + </data> + <data name="preview.game.count" xml:space="preserve"> + <value>{count, plural, other {#人连接}}，{age}{how}</value> + </data> + <data name="feed.plain.newlyDiscovered" xml:space="preserve"> + <value>新发现</value> + </data> + <data name="feed.plain.wentDark" xml:space="preserve"> + <value>已失联</value> + </data> + <data name="feed.plain.cameBack" xml:space="preserve"> + <value>已恢复</value> + </data> + <data name="home.plain.known" xml:space="preserve"> + <value>{count, plural, other {已知#个游戏}}</value> + </data> + <data name="home.plain.connectedNow" xml:space="preserve"> + <value>{count, plural, other {当前#人连接（实测）}}</value> + </data> + <data name="home.plain.uncounted" xml:space="preserve"> + <value>{count, plural, other {#个游戏有应答，未能计数}}</value> + </data> + <data name="home.plain.archived" xml:space="preserve"> + <value>{count, plural, other {#个已归档，仍在探测}}</value> + </data> + <data name="reference.title" xml:space="preserve"> + <value>参考</value> + </data> + <data name="reference.lede" xml:space="preserve"> + <value>代码库是什么，客户端做什么，协议又意味着什么。由人手写，与爬虫一同存放在代码仓库里——这不是维基，本页上也没有任何可编辑的东西。这里的每一个{number}都是另一回事：它取自目录，每次加载页面时都重新算出。</value> + </data> + <data name="reference.lede.number" xml:space="preserve"> + <value>数字</value> + </data> + <data name="reference.plain.lede" xml:space="preserve"> + <value>手写，单一作者，并用 git 做版本管理。这里的文字出自我们；旁边的每一个数字都由爬虫实测得出，并在每次请求时重新算出。这不是维基，本页也没有任何编辑它的途径。</value> + </data> + <data name="reference.section.orientation" xml:space="preserve"> + <value>从这里开始</value> + </data> + <data name="reference.section.codebase" xml:space="preserve"> + <value>代码库</value> + </data> + <data name="reference.section.client" xml:space="preserve"> + <value>客户端</value> + </data> + <data name="reference.section.protocol" xml:space="preserve"> + <value>协议</value> + </data> + <data name="reference.kind.orientation" xml:space="preserve"> + <value>入门</value> + </data> + <data name="reference.kind.codebase" xml:space="preserve"> + <value>代码库</value> + </data> + <data name="reference.kind.client" xml:space="preserve"> + <value>客户端</value> + </data> + <data name="reference.kind.protocol" xml:space="preserve"> + <value>协议</value> + </data> + <data name="reference.notFound.title" xml:space="preserve"> + <value>未找到</value> + </data> + <data name="reference.notFound.body" xml:space="preserve"> + <value>这里没有参考页面。本节由人手写，所以缺口是还没人做的工作，而不是被移除的内容——{index}。</value> + </data> + <data name="reference.notFound.index" xml:space="preserve"> + <value>看看现有的内容</value> + </data> + <data name="reference.codebase.heading" xml:space="preserve"> + <value>运行它的游戏</value> + </data> + <data name="reference.codebase.none" xml:space="preserve"> + <value>我们尚未识别到任何一个。这是关于这台爬虫实测到了什么的事实，而不是关于存在什么的事实——我们没有连通过的游戏，或者代码库读不出来的游戏，都不算进这里。</value> + </data> + <data name="reference.codebase.listed" xml:space="preserve"> + <value>{count, plural, other {已列出#个}}</value> + </data> + <data name="reference.codebase.archived" xml:space="preserve"> + <value>{count, plural, other {已归档#个}}</value> + </data> + <data name="reference.measuredNeverAsserted" xml:space="preserve"> + <value>实测，绝非断言</value> + </data> + <data name="reference.codebase.note" xml:space="preserve"> + <value>这是本次请求时从目录中数出的，用的正是上方链接所带的同一个筛选条件——所以这个数字和那份列表出自同一个查询，不可能对不上。</value> + </data> + <data name="reference.codebase.offered" xml:space="preserve"> + <value>在它们的握手中提供：{protocols}</value> + </data> + <data name="reference.protocol.heading" xml:space="preserve"> + <value>实测采用情况</value> + </data> + <data name="reference.protocol.none" xml:space="preserve"> + <value>尚无实测。</value> + </data> + <data name="reference.protocol.share" xml:space="preserve"> + <value>在{listed, plural, other {#个已列出的游戏}}中——{percent}</value> + </data> + <data name="reference.protocol.remainder" xml:space="preserve"> + <value>未算进这里的游戏，并不是没有这个协议的游戏。一个游戏被算进这里，条件是我们观测到它的服务器在一次握手中提供了这个选项；其余的既包括没有向我们提供它的服务器，也包括我们还没有读到过握手的服务器，而我们说不出是哪一种。</value> + </data> + <data name="reference.protocol.caption" xml:space="preserve"> + <value>在一次握手中被观测到提供 {protocol} 的游戏，按我们识别出的其运行代码库分组。</value> + </data> + <data name="reference.protocol.column.codebase" xml:space="preserve"> + <value>代码库</value> + </data> + <data name="reference.protocol.column.offered" xml:space="preserve"> + <value>已提供</value> + </data> + <data name="reference.protocol.column.identified" xml:space="preserve"> + <value>已识别</value> + </data> + <data name="reference.seeAlso" xml:space="preserve"> + <value>另见</value> + </data> + <data name="reference.capabilities.heading" xml:space="preserve"> + <value>能力</value> + </data> + <data name="reference.capabilities.established" xml:space="preserve"> + <value>{count, plural, other {在{total}项中，有#项依据项目自己的文档确定}}</value> + </data> + <data name="reference.capabilities.caveat" xml:space="preserve"> + <value>逐项读自各项目自己的文档，而非由我们实测——客户端没有握手可供我们观测。“{unknown}”表示我们查过，没能确定。它绝不表示“否”。</value> + </data> + <data name="reference.capabilities.caption" xml:space="preserve"> + <value>客户端能力，每一项都读自项目自己的文档。未知表示我们没能确定，而绝不表示这个客户端不具备该项。</value> + </data> + <data name="reference.capabilities.column.documented" xml:space="preserve"> + <value>有文档</value> + </data> + <data name="reference.capabilities.column.source" xml:space="preserve"> + <value>来源</value> + </data> + <data name="reference.capabilities.noSource" xml:space="preserve"> + <value>我们没有找到</value> + </data> + <data name="reference.capability.yes" xml:space="preserve"> + <value>有</value> + </data> + <data name="reference.capability.no" xml:space="preserve"> + <value>否</value> + </data> + <data name="reference.capability.unknown" xml:space="preserve"> + <value>未知</value> + </data> + <data name="reference.plain.runsOn" xml:space="preserve"> + <value>运行平台：{platforms}</value> + </data> + <data name="reference.plain.codebase.heading" xml:space="preserve"> + <value>我们识别为运行该代码库的游戏</value> + </data> + <data name="reference.plain.codebase.none" xml:space="preserve"> + <value>尚无。这是关于我们实测到了什么的说法，而不是关于存在什么的说法——我们没有连通过的游戏，或者代码库读不出来的游戏，都不算进这里。</value> + </data> + <data name="reference.plain.codebase.counts" xml:space="preserve"> + <value>{listed, plural, other {已列出#个}}，{archived, plural, other {已归档#个}}</value> + </data> + <data name="reference.plain.codebase.offered" xml:space="preserve"> + <value>在它们的握手中实测到：{protocols}</value> + </data> + <data name="reference.plain.codebase.nothingOffered" xml:space="preserve"> + <value>在我们读到过的它们的任何一次握手中，都没有提供过任何东西。</value> + </data> + <data name="reference.plain.protocol.share" xml:space="preserve"> + <value>在{listed, plural, other {#个已列出的游戏}}中，有 {offering} 个被观测到提供了它（{percent}）</value> + </data> + <data name="reference.plain.protocol.byCodebase" xml:space="preserve"> + <value>按代码库，在我们已识别的游戏中</value> + </data> + <data name="reference.plain.protocol.row" xml:space="preserve"> + <value>{identified} 个中有 {offering} 个提供了它</value> + </data> + <data name="reference.plain.capabilities.unknown" xml:space="preserve"> + <value>{count, plural, other {在{total}行中，有#行是未知}}：我们没有找到项目自己的文档给出任何一种说法。一张诚实的短表胜过一张靠猜的长表。</value> + </data> + <data name="account.title" xml:space="preserve"> + <value>我的游戏</value> + </data> + <data name="account.noDatabase" xml:space="preserve"> + <value>账户需要数据库支撑，而本站正运行在演示数据上。</value> + </data> + <data name="account.signInButton" xml:space="preserve"> + <value>登录</value> + </data> + <data name="account.signedInAs" xml:space="preserve"> + <value>已以 {name} 登录。</value> + </data> + <data name="account.signOut" xml:space="preserve"> + <value>退出登录</value> + </data> + <data name="account.empty.body" xml:space="preserve"> + <value>你还没有认领任何游戏。在{listing}中找到你的游戏，在它的页面上点击{claimControl}。</value> + </data> + <data name="account.empty.listing" xml:space="preserve"> + <value>列表</value> + </data> + <data name="account.empty.claimControl" xml:space="preserve"> + <value>认领此游戏</value> + </data> + <data name="account.resigned.lead" xml:space="preserve"> + <value>已放弃。</value> + </data> + <data name="account.resigned.body" xml:space="preserve"> + <value>相关记录会保留，你随时可以再发布一个新令牌，重新证明控制权。</value> + </data> + <data name="account.saved.lead" xml:space="preserve"> + <value>已保存。</value> + </data> + <data name="account.saved.thatGame" xml:space="preserve"> + <value>那个游戏</value> + </data> + <data name="account.saved.fields" xml:space="preserve"> + <value>{game} 的页面现在把它标为所有者自述。</value> + </data> + <data name="account.saved.screenHidden" xml:space="preserve"> + <value>我们已停止发布 {game} 的连接画面。页面会明确说明，而不是留一个空洞。</value> + </data> + <data name="account.saved.screenShown" xml:space="preserve"> + <value>{game} 的连接画面又回到了它的页面上。</value> + </data> + <data name="account.saved.crawlStopped" xml:space="preserve"> + <value>我们已停止向 {game} 拨号，我们掌握的它的每一个地址都停了。它的页面保留你开口之前实测到的一切。</value> + </data> + <data name="account.saved.crawlResumed" xml:space="preserve"> + <value>我们又开始向 {game} 拨号，从它在排期中的下一轮起。</value> + </data> + <data name="account.saved.unlisted" xml:space="preserve"> + <value>{game} 已不在列表、排行和每日数字中。它的页面和它曾用过的每一个 URL 仍然照常应答。</value> + </data> + <data name="account.saved.relisted" xml:space="preserve"> + <value>{game} 已回到列表中。一次得到应答的探测，就足以让它重新被实测。</value> + </data> + <data name="account.refused.lead" xml:space="preserve"> + <value>{field} 未作改动。</value> + </data> + <data name="account.refused.tooLong" xml:space="preserve"> + <value>这些是一行以内的回答；我们最多保存 {max} 个字符。</value> + </data> + <data name="account.refused.measured" xml:space="preserve"> + <value>该字段是实测的。认领让你补上 MSSP 放不下的内容；它绝不让任何人改动我们观测到的内容，我们自己也不例外。</value> + </data> + <data name="account.claimed.heading" xml:space="preserve"> + <value>已认领</value> + </data> + <data name="account.claim.verified" xml:space="preserve"> + <value>已于 {date} 验证</value> + </data> + <data name="account.claim.verifiedAndSeen" xml:space="preserve"> + <value>已于 {date} 验证，令牌最近一次见于 {seen}</value> + </data> + <data name="account.claim.mssp" xml:space="preserve"> + <value>检查你的 MSSP</value> + </data> + <data name="account.claim.coOwners" xml:space="preserve"> + <value>{count, plural, other {另有 {names} 共同拥有——各自验证过自己的令牌。}}</value> + </data> + <data name="account.coOwner.unnamed" xml:space="preserve"> + <value>另一个账户</value> + </data> + <data name="account.badge.summary" xml:space="preserve"> + <value>把你的在线人数放到自己的网站上</value> + </data> + <data name="account.badge.carries" xml:space="preserve"> + <value>这个徽标同时带上计数和我们实测它的时间，因为一个没有时间的数字，正是本站要取而代之的东西。</value> + </data> + <data name="account.badge.states" xml:space="preserve"> + <value>我们未能计数时，它显示{unknown}而不是零；游戏停止应答时，它显示{archived}。</value> + </data> + <data name="account.badge.json" xml:space="preserve"> + <value>还有{json}，如果你更愿意自己画。</value> + </data> + <data name="account.history.summary" xml:space="preserve"> + <value>历史</value> + </data> + <data name="account.event.issued" xml:space="preserve"> + <value>已签发令牌</value> + </data> + <data name="account.event.reissued" xml:space="preserve"> + <value>已再次签发令牌</value> + </data> + <data name="account.event.verified" xml:space="preserve"> + <value>已验证——我们读到了你的令牌</value> + </data> + <data name="account.event.beaconSeen" xml:space="preserve"> + <value>令牌仍在发布</value> + </data> + <data name="account.event.beaconMissing" xml:space="preserve"> + <value>本次未读到令牌</value> + </data> + <data name="account.event.revoked" xml:space="preserve"> + <value>已放弃认领</value> + </data> + <data name="account.event.expired" xml:space="preserve"> + <value>令牌未使用即过期</value> + </data> + <data name="account.event.counterClaimed" xml:space="preserve"> + <value>另一个账户证明了控制权，接管了这个游戏</value> + </data> + <data name="account.event.checkRequested" xml:space="preserve"> + <value>已请求提前查看</value> + </data> + <data name="account.resign.summary" xml:space="preserve"> + <value>放弃此认领</value> + </data> + <data name="account.resign.confirm" xml:space="preserve"> + <value>输入{word}以确认。任何内容都不会被删除，你可以再发布一个新令牌重新证明控制权；如果还有别人拥有它，这个游戏仍是已认领状态。</value> + </data> + <data name="account.resign.button" xml:space="preserve"> + <value>放弃 {game}</value> + </data> + <data name="account.pending.heading" xml:space="preserve"> + <value>等待令牌</value> + </data> + <data name="account.pending.dates" xml:space="preserve"> + <value>令牌签发于 {issued}，有效期至 {expires}</value> + </data> + <data name="account.passkeys.heading" xml:space="preserve"> + <value>通行密钥</value> + </data> + <data name="account.passkey.unnamed" xml:space="preserve"> + <value>未命名</value> + </data> + <data name="account.passkey.added" xml:space="preserve"> + <value>添加于 {date}</value> + </data> + <data name="account.passkey.addedOneDevice" xml:space="preserve"> + <value>添加于 {date} · 仅在一台设备上</value> + </data> + <data name="account.passkey.single" xml:space="preserve"> + <value>这个通行密钥只存在于一台设备上。万一丢了，你仍可以在自己的游戏上发布一个新令牌重新进来，但再加一个通行密钥更快。</value> + </data> + <data name="account.passkey.add" xml:space="preserve"> + <value>再添加一个通行密钥</value> + </data> + <data name="claim.noGame" xml:space="preserve"> + <value>没有这个游戏</value> + </data> + <data name="claim.title" xml:space="preserve"> + <value>认领 {game}</value> + </data> + <data name="claim.noDatabase" xml:space="preserve"> + <value>认领需要数据库，而本站正运行在演示数据上。</value> + </data> + <data name="claim.needAccount" xml:space="preserve"> + <value>你需要先有一个账户。只需一个通行密钥和一个名称。</value> + </data> + <data name="claim.signIn" xml:space="preserve"> + <value>登录或创建账户</value> + </data> + <data name="claim.yourGames" xml:space="preserve"> + <value>我的游戏</value> + </data> + <data name="claim.hasOwners" xml:space="preserve"> + <value>{count, plural, other {这个游戏已经有#位所有者证明了对该服务器的控制权。}}你也可以证明——两种情况下的检验方式相同——但我们需要知道你的意思是什么，因为从令牌上看不出来。</value> + </data> + <data name="claim.join.button" xml:space="preserve"> + <value>我也在运营它——把我加为所有者</value> + </data> + <data name="claim.join.note" xml:space="preserve"> + <value>每个人都保留自己的认领。这是两个人一起运营一个游戏。</value> + </data> + <data name="claim.assume.button" xml:space="preserve"> + <value>我已经接手了它——把它转给我</value> + </data> + <data name="claim.assume.note" xml:space="preserve"> + <value>{count, plural, other {你的令牌通过验证后，现有的认领会被撤销，这个游戏归你。}}他们会在自己的历史里看到原因。任何内容都不会被删除，他们也可以用你即将采用的同一种方式重新证明控制权。</value> + </data> + <data name="claim.verified.lead" xml:space="preserve"> + <value>已验证。</value> + </data> + <data name="claim.verified.viaMssp" xml:space="preserve"> + <value>我们在 {date} 从这个游戏的 MSSP 报告中读到了你的令牌。</value> + </data> + <data name="claim.verified.viaScreen" xml:space="preserve"> + <value>我们在 {date} 从连接画面上读到了你的令牌。</value> + </data> + <data name="claim.verified.leaveIt" xml:space="preserve"> + <value>把令牌留在原处。它同时也是一个身份标记，这样即使这个游戏换了主机或改了名字，我们仍认得出它。把它撤掉不会取消你的认领。</value> + </data> + <data name="claim.publish" xml:space="preserve"> + <value>把这个令牌发布在游戏会展示给匿名连接的任何地方。下一次探测就会读到它，这就证明了你能写入那台服务器。</value> + </data> + <data name="claim.transfer.lead" xml:space="preserve"> + <value>这是一次转移。</value> + </data> + <data name="claim.transfer.body" xml:space="preserve"> + <value>{count, plural, other {我们读到这个令牌时，当前所有者对这个游戏的认领会被撤销，它归你。}}</value> + </data> + <data name="claim.either.heading" xml:space="preserve"> + <value>两种方式都可以</value> + </data> + <data name="claim.mssp.heading" xml:space="preserve"> + <value>一个 MSSP 变量</value> + </data> + <data name="claim.mssp.note" xml:space="preserve"> + <value>在 {codebase} 中那是 {file} 里的一行；每个支持 MSSP 的代码库都有对应的做法。</value> + </data> + <data name="claim.mssp.aliases" xml:space="preserve"> + <value>{aliases} 同样可用。</value> + </data> + <data name="claim.screen.heading" xml:space="preserve"> + <value>连接画面上的一行</value> + </data> + <data name="claim.screen.note" xml:space="preserve"> + <value>画面中任何位置都行，周围有颜色代码也没关系。</value> + </data> + <data name="claim.then.heading" xml:space="preserve"> + <value>然后</value> + </data> + <data name="claim.then.body" xml:space="preserve"> + <value>我们按平常的爬取排期来查看。这个令牌有效期至 {date}。你随时可以再来；没有什么需要记下来。</value> + </data> + <data name="claim.check.button" xml:space="preserve"> + <value>提前查看</value> + </data> + <data name="claim.check.can" xml:space="preserve"> + <value>把你的游戏排到队列前面。我们按自己的排期拨号，所以这只是提前，而不是立刻。</value> + </data> + <data name="claim.check.rationed" xml:space="preserve"> + <value>刚刚请求过。请过几分钟再试——之所以限量，是因为它会让我们比原定更早去拨一台真实的服务器。</value> + </data> + <data name="owner.declare.heading" xml:space="preserve"> + <value>关于 {game}，只有你能告诉我们的事</value> + </data> + <data name="owner.declare.lede" xml:space="preserve"> + <value>这些是 MSSP 没有字段可放的东西。它们会以{declared}的身份出现在你游戏的页面上，带着你最后一次确认的日期，与我们实测到的内容并列——绝不取而代之。实测到的任何内容都无法从这里编辑，你不能，我们也不能。</value> + </data> + <data name="owner.field.declared" xml:space="preserve"> + <value>{age}自述。清空此框即可撤回——不论如何，它曾写过什么的记录都会保留。</value> + </data> + <data name="owner.save" xml:space="preserve"> + <value>保存你的自述</value> + </data> + <data name="owner.override.heading" xml:space="preserve"> + <value>{game} 报告了什么，以及你更希望我们显示什么</value> + </data> + <data name="owner.override.lede" xml:space="preserve"> + <value>你的 MSSP 是每个爬虫都会读到的内容，无论你在这里填了什么，我们都会把它并列显示出来——你给的答案不会遮住你游戏给的答案。</value> + </data> + <data name="owner.override.nothingMeasured" xml:space="preserve"> + <value>实测到的任何内容都无法从这里编辑：人数计数不行，能力不行，可连通的某个小时也不行。</value> + </data> + <data name="owner.override.fixItThere" xml:space="preserve"> + <value>如果下面某一行在你的 {file} 里就是错的，在那里改掉，处处都会跟着改。</value> + </data> + <data name="owner.report.value" xml:space="preserve"> + <value>你的游戏报告 {value}，{age}确认</value> + </data> + <data name="owner.report.none" xml:space="preserve"> + <value>你的游戏在这里什么也没有报告</value> + </data> + <data name="owner.rename.note" xml:space="preserve"> + <value>改名会同时改变 {game} 在列表中的名称和它页面的地址。旧地址永远继续有效——这个游戏曾用过的每一个 URL 都会重定向到它当前的地址——而清空此框，名称就交还给你的 MSSP 所说的内容。</value> + </data> + <data name="owner.screen.heading" xml:space="preserve"> + <value>你的连接画面</value> + </data> + <data name="owner.screen.suppressed" xml:space="preserve"> + <value>我们不再发布它。页面会明确说明，而不是留一个空洞；爬虫仍会继续读它——你的游戏搬了家，我们靠的就是它认出你。</value> + </data> + <data name="owner.screen.show" xml:space="preserve"> + <value>重新显示</value> + </data> + <data name="owner.screen.shown" xml:space="preserve"> + <value>我们展示它，是因为你的服务器本来就把它发给每一个匿名连接。你若不愿意，说一声我们就撤下。我们不会问为什么。</value> + </data> + <data name="owner.screen.stop" xml:space="preserve"> + <value>不要再展示我们的连接画面</value> + </data> + <data name="owner.crawl.heading" xml:space="preserve"> + <value>被爬取</value> + </data> + <data name="owner.crawl.stopped" xml:space="preserve"> + <value>我们已经停下。{game} 上没有任何地址还在被拨号，页面保留你开口之前实测到的一切——那些空白的小时不指明原因，因为{ourFact}是关于我们的事实，而不是对你游戏的实测。</value> + </data> + <data name="owner.crawl.ourFact" xml:space="preserve"> + <value>你要求我们停下</value> + </data> + <data name="owner.crawl.resume" xml:space="preserve"> + <value>重新开始爬取我们</value> + </data> + <data name="owner.crawl.standing" xml:space="preserve"> + <value>这一条来自你自己的服务器，而不是来自这里——{routes}。要重新被爬取，请停止发布它；下一个周期我们就会知道。</value> + </data> + <data name="owner.crawl.route.mssp" xml:space="preserve"> + <value>你的 MSSP 报告发布了 {variable}</value> + </data> + <data name="owner.crawl.route.dns" xml:space="preserve"> + <value>一条 {label} TXT 记录要求我们停下</value> + </data> + <data name="owner.crawl.route.recorded" xml:space="preserve"> + <value>一份我们记录在案的请求</value> + </data> + <data name="owner.crawl.partial" xml:space="preserve"> + <value>我们已在 {stopped} 上停下，仍在拨 {dialling}。这通常是在退出声明之后又新增的端口。</value> + </data> + <data name="owner.crawl.stopAll" xml:space="preserve"> + <value>在每一个地址上也都停下</value> + </data> + <data name="owner.crawl.dialling" xml:space="preserve"> + <value>我们按排期向 {game} 拨号，读取任何匿名连接都能看到的内容。你若不愿意，说一声我们就停——在一个爬取周期之内，在我们掌握的你的每一个地址上，而且我们不会问为什么。</value> + </data> + <data name="owner.crawl.selfService" xml:space="preserve"> + <value>已经实测到的内容不会被删除：你的页面保留它的历史和它的 URL，而你收回这项设置之后，一次探测就会让它重新开始。你也可以不经过我们，在自己的配置里说出来——MSSP 里的 {mssp}，或者一条 {dns} TXT 记录——无论有没有人在这里认领过这个游戏，我们都照办。</value> + </data> + <data name="owner.crawl.stop" xml:space="preserve"> + <value>不要再爬取我们</value> + </data> + <data name="owner.listing.heading" xml:space="preserve"> + <value>被列出</value> + </data> + <data name="owner.listing.unlisted" xml:space="preserve"> + <value>{game} 已不在列表中，不在排行中，也不在每日数字中。它的页面和它曾用过的每一个 URL 仍然照常应答，你开口之前实测到的一切也都还在上面。任何内容都没有被删除；它只是不再是读者靠浏览就能走到的地方。</value> + </data> + <data name="owner.listing.relist" xml:space="preserve"> + <value>把我们放回列表</value> + </data> + <data name="owner.listing.probeRelists" xml:space="preserve"> + <value>一次得到应答的探测同样能做到这件事。你的退出声明还立着的时候我们不会拨号，所以不会有这样的探测——但你收回它的那一天，这个地址会在一周之内轮到，得到应答的那次探测就会把你放回去。你不必再来问我们第二次。</value> + </data> + <data name="owner.listing.mayUnlist" xml:space="preserve"> + <value>我们已经不再向你拨号，而你的页面仍在列表中，带着在那之前我们实测到的内容。你若不愿意，说一声它就撤出来——从列表、排行和每日数字中撤出。</value> + </data> + <data name="owner.listing.reversible" xml:space="preserve"> + <value>任何内容都不会被删除，也不会有什么坏掉：页面照常应答，它曾用过的每一个 URL 仍然重定向到它，你指引过去的人都能看到它。它只是不再是读者靠浏览就能走到的地方。这可以从这里撤销，而你收回退出声明之后，任何一次得到应答的探测也能撤销它。</value> + </data> + <data name="owner.listing.unlist" xml:space="preserve"> + <value>把我们也移出列表</value> + </data> + <data name="facet.group.measure" xml:space="preserve"> + <value>实测到了什么</value> + </data> + <data name="facet.measure.note" xml:space="preserve"> + <value>隐藏这些会把它们从当前列表中移出；这并不表示该游戏里没有人。</value> + </data> + <data name="facet.group.uncounted" xml:space="preserve"> + <value>未能计数</value> + </data> + <data name="facet.group.unreachable" xml:space="preserve"> + <value>无法连通</value> + </data> + <data name="facet.excluded.uncounted" xml:space="preserve"> + <value>已从此列表中隐藏</value> + </data> + <data name="facet.excluded.unreachable" xml:space="preserve"> + <value>已从此列表中隐藏</value> + </data> + <data name="facet.plain.marks" xml:space="preserve"> + <value>左栏中，* 表示此列表已筛选为该值，- 表示此列表已把该值排除。两者都是查询中的选择，而不是关于某个游戏的事实。</value> + </data> +</root> diff --git a/src/MUI.Web/SiteComposition.cs b/src/MUI.Web/SiteComposition.cs index bc336b7..f502805 100644 --- a/src/MUI.Web/SiteComposition.cs +++ b/src/MUI.Web/SiteComposition.cs @@ -1,3 +1,5 @@ +using Microsoft.Extensions.Localization; + using MUI.Catalog; using MUI.Crawler; using MUI.Web.Accounts; @@ -6,6 +8,7 @@ using MUI.Web.Data; using MUI.Web.Fixtures; using MUI.Web.Icons; +using MUI.Web.Localization; using MUI.Web.Submissions; using MUI.Web.Theme; @@ -52,6 +55,9 @@ public static IServiceCollection AddMuiSite( services.AddRazorComponents(); + // The chrome's own words, before anything that renders them. + services.AddMuiLocalization(); + // The read API (spec §10) reads through the same IGameQueries the pages do, so the two // surfaces cannot disagree about a fact. What it adds of its own — the dataset licence, the // slug aliases and the attribution list — is configuration, because none of it is a @@ -112,6 +118,25 @@ public static IServiceCollection AddMuiSite( return services; } + /// <summary> + /// The resource set the chrome's strings are read from. + /// </summary> + /// <remarks> + /// The arrangement SharpMUSH's portal uses for its own chrome — <c>AddLocalization</c> over a + /// <c>Resources</c> folder, resolved through a marker class, with the SDK compiling one + /// satellite assembly per culture and no <c><EmbeddedResource></c> entries anywhere. What + /// differs is the values: theirs are composite-format strings and these are ICU patterns, + /// because <c>{0}</c> substitutes and cannot agree. See <see cref="Localization.Messages"/>. + /// </remarks> + public static IServiceCollection AddMuiLocalization(this IServiceCollection services) + { + ArgumentNullException.ThrowIfNull(services); + + services.AddLocalization(options => options.ResourcesPath = "Resources"); + + return services; + } + /// <summary> /// The middleware and the routes, in the order they have to be in. /// </summary> @@ -129,6 +154,18 @@ public static WebApplication UseMuiSite(this WebApplication app, string? connect // limit. app.UseSubmitterAddress(); + // Before anything routes, because the locale is a path segment and every @page directive is + // written without it: the middleware moves the prefix into PathBase so one route table + // serves every language. It is also before the not-found page, so a mistyped URL inside a + // locale is answered in that locale rather than in English. + app.UseMuiLocale(); + + // Explicit, and that is load-bearing rather than tidy: with no UseRouting call of its own an + // app gets one inserted at the very top of the pipeline, which resolved the endpoint before + // the middleware above had rewritten the path — so every localized URL 404'd while the + // unprefixed one worked. Naming it here is what puts routing after the rewrite. + app.UseRouting(); + // A reader who mistyped a URL, and a crawler indexing one, both got a 404 with an empty body: // the <NotFound> fragment inside <Router> is never rendered under static server rendering, so // the site's own "no game here" paragraph was dead copy. This answers those with the page — @@ -168,6 +205,10 @@ public static WebApplication UseMuiSite(this WebApplication app, string? connect // deployment has the same eyes as a reader of the real one. app.MapMuiTheme(); + // Beside the theme endpoint and for the same reason: it writes a cookie and redirects, and + // a reader of the demo deployment reads the same language as a reader of the real one. + app.MapMuiLocale(); + // §5.7, and before the route that would answer with "not found": a slug this game used to // have is a URL somebody is still holding, and it redirects to the page it has now — // permanently, and for an archived game exactly as for a live one. diff --git a/src/MUI.Web/Submissions/SubmissionEndpoint.cs b/src/MUI.Web/Submissions/SubmissionEndpoint.cs index e503b7d..53d60fc 100644 --- a/src/MUI.Web/Submissions/SubmissionEndpoint.cs +++ b/src/MUI.Web/Submissions/SubmissionEndpoint.cs @@ -3,6 +3,7 @@ using MUI.Catalog.Persistence; using MUI.Discovery; using MUI.Web.Components; +using MUI.Web.Localization; namespace MUI.Web.Submissions; @@ -56,7 +57,9 @@ await sources.OfAsync(SubmitterAddress.Of(context), context.RequestAborted), ? game.Slug : null; - return Results.Redirect(SubmitLinks.For(receipt.Outcome, receipt.Address, slug)); + return Results.Redirect(LocaleRouting.Link( + context.LocaleOf().Tag, + SubmitLinks.For(receipt.Outcome, receipt.Address, slug))); }); } } diff --git a/src/MUI.Web/Theme/ThemeEndpoint.cs b/src/MUI.Web/Theme/ThemeEndpoint.cs index 0904882..7b0b61b 100644 --- a/src/MUI.Web/Theme/ThemeEndpoint.cs +++ b/src/MUI.Web/Theme/ThemeEndpoint.cs @@ -1,4 +1,5 @@ using Microsoft.AspNetCore.Mvc; +using MUI.Web.Localization; namespace MUI.Web.Theme; @@ -42,7 +43,13 @@ public static IEndpointRouteBuilder MapMuiTheme(this IEndpointRouteBuilder endpo // 303 rather than 302: the reader posted a form and what they should now be holding is // the page they came from, fetched with GET. A 302 gets there by convention on every // browser written since 1996, and this says what was meant. - context.Response.Headers.Location = ReaderTheme.Back(returnTo); + // + // And back into the language they were reading, which the return field cannot carry: it + // holds Request.Path, from which the middleware has already taken the prefix. A reader + // who followed a shared /de/… link has no cookie either, so this redirect was the whole + // of what stood between them and an English page — for choosing a light background. + context.Response.Headers.Location = + LocaleRouting.Link(context.LocaleOf().Tag, ReaderTheme.Back(returnTo)); return Results.StatusCode(StatusCodes.Status303SeeOther); }).DisableAntiforgery(); diff --git a/src/MUI.Web/wwwroot/app.css b/src/MUI.Web/wwwroot/app.css index 09d448e..0e0ae29 100644 --- a/src/MUI.Web/wwwroot/app.css +++ b/src/MUI.Web/wwwroot/app.css @@ -12,23 +12,74 @@ */ :root { - --cpad: 14px; /* the density control writes this, and only this */ - --row-pad: 9px; + /* + Spacing, radii and motion, in the relationships the design handoff's own token files carry. + The values are theirs; the colours below are ours — the handoff's palette is a different + product's and its README says so. What transfers is the scale: content padding at 20px rather + than the 14 this site had, one radius for controls and a larger one for the surfaces that hold + them, and a single easing curve at an eighth of a second. + */ + --cpad: 24px; /* the density control writes this, and only this */ + --row-pad: 13px; /* a listing row: 13px 20px, over a 44px floor */ + + /* + The one horizontal inset the whole site shares — the bar, every content band, every listing + row. Fluid rather than fixed because the page is full-bleed now: at the width the handoff was + drawn to it lands on the 24px the drawing uses, and it grows a little rather than leaving a + wide monitor's chrome pinned to the very edge of the glass. + */ + --gutter: clamp(14px, 1.6vw, 28px); + + --radius: 9px; /* controls, chips, rows, nav items */ + --radius-lg: 14px; /* cards and panels — the things controls sit in */ + --radius-pill: 99px; /* pills and badges */ + + --ease: cubic-bezier(0.4, 0, 0.2, 1); + --dur: 0.14s; --bg: #0f1113; --surface: #16191c; --raised: #1d2125; --recessed: #0b0d0f; + + /* + Two hairline steps, as the handoff's tokens carry them: --line is a control's own edge and + --line-soft is the rule between two panels. One value did both, so a filter column's edge and + a button's border were the same weight — and the panel rules, which are ten times longer, + read as the loudest thing on the page. + */ --line: #262b30; + --line-soft: #1c2024; --text: #e8eaec; /* values and names */ --dim: #9aa2a9; /* prose and secondary */ --faint: #6b747c; /* provenance, ages, meta */ --accent: #35d29a; /* measured */ + + /* + The accent as *text on an accent tint* — the selected facet row, which paints a 12% wash of + the accent behind accent-coloured words. Every ratio beside a token here is measured against + the page, and a tinted row is not the page: in light, --accent is 5.0:1 on the background it + was tuned for and 3.9:1 on this one, which is the row a reader has just clicked. Dark clears + it either way, so there the two are the same colour. + */ + --accent-ink: var(--accent); --amber: #d8a13a; /* declared / ageing */ --derived: #a394f0; /* our own classification, and nobody else's */ + /* + Refusal, and only refusal. Not a provenance colour — nothing on this site is red because of + what we did or did not measure. It marks one thing: a facet value the reader has excluded, + where the handoff draws a danger tint, a danger ring and a struck-through label. A state the + reader put the control into, never a state of the data. + */ + --danger: #f4574c; + + /* The card's own elevation, and the one glow the accent is allowed. */ + --shadow: 0 1px 0 rgb(255 255 255 / 3%) inset, 0 4px 16px rgb(0 0 0 / 40%); + --glow: 0 0 8px color-mix(in srgb, var(--accent) 55%, transparent); + --sans: "Hanken Grotesk", ui-sans-serif, system-ui, -apple-system, sans-serif; --mono: "Cascadia Mono", ui-monospace, "SFMono-Regular", Consolas, monospace; --kick: "JetBrains Mono", var(--mono); @@ -60,38 +111,69 @@ data-theme wins over the system in both directions, so a toggle can be added without moving any of this. */ +/* + ── the light theme, and why none of it is white ─────────────────────────── + The page surface was #ffffff, and once the card went full-bleed that stopped being a panel and + became the whole window. A large field of pure white glares: the halation it produces around dark + text is worst for readers with astigmatism and is one of the things dyslexic readers most often + ask to be turned down, and 21:1 body contrast is past the point where more helps and into the + point where it tires. Nobody's guideline forbids it — WCAG has a floor and no ceiling — which is + why every design system that has thought about it lands in the same place by convention instead: + GitHub Primer's canvas.subtle #f6f8fa, IBM Carbon's #f4f4f4 background under white layers, + Material 3's tinted surfaces, Solarized Light's cream. All of them are off-white. + + So the ramp is a soft cool grey and the near-white is reserved for the things that are supposed to + sit *above* it — tiles, the hover plane. That also restores a distinction the light theme had lost + entirely: --surface and --raised were both #ffffff, so a card lifted off the page by a step in the + dark theme was lifted by nothing at all here, and its border was doing all the work. + + Text is a near-black with the ramp's own hue rather than #000, at ~15:1 — comfortably past the + 4.5:1 floor and short of the glare. Every step below was measured against the new surface, and + --faint moved because it did not clear 4.5:1 against the old one: it carries ages and provenance + at 12px, which is exactly the small low-contrast text the handoff asked to have checked. +*/ @media (prefers-color-scheme: light) { :root { - --bg: #f7f8f9; - --surface: #ffffff; - --raised: #ffffff; - --recessed: #eef0f2; - --line: #dfe3e6; - - --text: #14181b; - --dim: #4d565d; - --faint: #79838a; - - --accent: #04795b; /* same hue, dropped in value to clear 4.5:1 on white */ - --amber: #8a5d00; - --derived: #5b46c4; + --bg: #eef1f2; /* behind the page; barely visible now the shell is full-bleed */ + --surface: #f4f6f7; /* the page itself */ + --raised: #fbfcfc; /* tiles, hover planes — above the page, never below it */ + --recessed: #e9edee; /* the bar, the filter column */ + --line: #d3d9dc; + --line-soft: #e2e7e9; + + --text: #1a1f23; /* 15.3:1 — past the floor, short of the glare */ + --dim: #4d585f; /* 6.7:1 */ + --faint: #646f76; /* 4.8:1 — was 3.5:1 and carried 12px ages */ + + --accent: #04795b; /* same hue, dropped in value: 5.0:1 */ + --accent-ink: #036349; /* 5.3:1 on the accent's own 12% tint, where --accent is 3.9:1 */ + --amber: #7d5400; /* 6.2:1 */ + --derived: #5240b8; /* 7.0:1 */ + --danger: #a8261e; /* 6.5:1 */ + + --shadow: 0 1px 2px rgb(16 24 32 / 4%), 0 4px 16px rgb(16 24 32 / 5%); } } :root[data-theme="light"] { - --bg: #f7f8f9; - --surface: #ffffff; - --raised: #ffffff; - --recessed: #eef0f2; - --line: #dfe3e6; + --bg: #eef1f2; + --surface: #f4f6f7; + --raised: #fbfcfc; + --recessed: #e9edee; + --line: #d3d9dc; + --line-soft: #e2e7e9; - --text: #14181b; - --dim: #4d565d; - --faint: #79838a; + --text: #1a1f23; + --dim: #4d585f; + --faint: #646f76; --accent: #04795b; - --amber: #8a5d00; - --derived: #5b46c4; + --accent-ink: #036349; + --amber: #7d5400; + --derived: #5240b8; + --danger: #a8261e; + + --shadow: 0 1px 2px rgb(16 24 32 / 4%), 0 4px 16px rgb(16 24 32 / 5%); } :root[data-theme="dark"] { @@ -100,19 +182,29 @@ --raised: #1d2125; --recessed: #0b0d0f; --line: #262b30; + --line-soft: #1c2024; --text: #e8eaec; --dim: #9aa2a9; --faint: #6b747c; --accent: #35d29a; + + /* Reset with the rest of them. The light media block sets this unconditionally, so a reader who + pinned dark on a light-preferring system kept the light ink — a dark green on a dark tint, + 2.7:1, which is worse than the value it was added to fix. Every token this block redeclares + is redeclared for that reason; this one was missed. */ + --accent-ink: var(--accent); --amber: #d8a13a; --derived: #a394f0; + --danger: #f4574c; + + --shadow: 0 1px 0 rgb(255 255 255 / 3%) inset, 0 4px 16px rgb(0 0 0 / 40%); } :root[data-density="compact"] { - --cpad: 9px; - --row-pad: 5px; + --cpad: 13px; + --row-pad: 8px; } * { box-sizing: border-box; } @@ -125,16 +217,74 @@ body { text-wrap: pretty; } -main { max-width: 1080px; margin: 0 auto; padding: calc(var(--cpad) * 2) var(--cpad); } +/* + The shell: everything the handoff draws sits in one card — the bar along its top edge, the content + under it — rather than loose on the page. It is the difference between a document and an + instrument, and this site is the second: a directory whose bar, filters and rows are one panel. +*/ +/* + ── the shell ────────────────────────────────────────────────────────────── + Full-bleed. The handoff draws the site as one card floating on a ground, and that is a drawing + convention rather than a product decision — a directory is an instrument you fill the window with, + not a document you frame. So the card's border, radius, shadow and side margins are gone and the + page IS the surface; what the card was actually carrying — one bar along the top, bands separated + by hairlines, every block sharing one left edge — is unchanged and is the part that mattered. + + The radial that used to sit on the body moves here, because the body is no longer visible behind + anything. It is the one thing keeping a full-height dark page from reading as flat black. +*/ +.shell { + min-height: 100vh; + margin: 0; + background: var(--surface) radial-gradient(80% 90% at 78% -20%, + color-mix(in srgb, var(--raised) 45%, var(--surface)) 0%, var(--surface) 100%) fixed; + + /* + Clipped sideways and open downwards. `hidden` on both axes is what a card wants and it + swallowed the nav's own menu: at the width where both groups collapse into a disclosure, the + panel is positioned under the bar and every pixel of it was being clipped away, so the one + control that carries the whole catalogue on a narrow window opened onto nothing. `clip` pairs + with `visible` — `hidden` would coerce it to `auto` and hand the page a scrollbar. + */ + overflow-x: clip; + overflow-y: visible; +} + +/* + The content column's own padding, at the handoff's 30px/24px/26px. A page whose blocks bleed to + the card's edges — the listing's two columns, the game page's hairline-separated bands — cancels + it and pads each block itself, because a full-bleed rule cannot be drawn inside a padded box. +*/ +main { padding: 30px var(--gutter) 40px; } +main:has(> .card-page) { padding: 0; } + +/* + One vertical rhythm for the whole content column, as a gap rather than as margins on each block. + Margins collapse, disagree with each other and leave a dead band wherever a block renders nothing + — which is what the absent crawler strip did to the front page. +*/ +main > .card-page, +.hero { display: flex; flex-direction: column; gap: 22px; } h1 { font-size: 26px; font-weight: 600; letter-spacing: -0.01em; margin: 0 0 6px; } -h2 { font-size: 19px; font-weight: 600; margin: calc(var(--cpad) * 2) 0 var(--cpad); } +h2 { font-size: 20px; font-weight: 600; margin: calc(var(--cpad) * 1.4) 0 10px; } a { color: inherit; } .dim { color: var(--dim); } .faint { color: var(--faint); } .mono { font-family: var(--mono); font-variant-ligatures: none; } +/* Every count and every age, so the columns scan. */ +.mono, .tabular { font-variant-numeric: tabular-nums; } + +/* + ── the kicker, and why its typography is locale-gated ────────────────────── + Uppercase plus 0.16em tracking is this site's most recognisable label, and it is Latin-specific + twice over (i18n S1). Letter-spacing severs the cursive joins in Arabic, so connected words come + apart into unrelated shapes; Devanagari and Thai lose conjuncts and mark stacks the same way. + text-transform: uppercase is a no-op in CJK, turns ß into SS, and gets Turkish dotted/dotless i + wrong. The class is the semantics; :lang() decides the typography. +*/ .kicker { font: 10px/1 var(--kick); letter-spacing: 0.16em; @@ -142,18 +292,100 @@ a { color: inherit; } color: var(--faint); } -/* ── site chrome ───────────────────────────────────────────────────────── */ +/* Cursive and complex scripts: prominence from weight and size, never from tracking. */ +:is(.kicker, .nav-label, .bar-label, .facet-name, .evidence, .kick):is( + :lang(ar), :lang(he), :lang(fa), :lang(ur), :lang(th), :lang(hi), :lang(mr), :lang(ne)) { + text-transform: none; + letter-spacing: normal; + font-weight: 600; + font-size: 11.5px; + line-height: 1.5; +} + +/* CJK: uppercase does nothing, tracking looks like a fault, and 10px is unreadable. */ +:is(.kicker, .nav-label, .bar-label, .facet-name, .evidence, .kick):is( + :lang(zh), :lang(ja), :lang(ko)) { + text-transform: none; + letter-spacing: 0.02em; + font-size: 12px; +} + +/* ── site chrome ─────────────────────────────────────────────────────────── + A fixed 60px bar that never wraps. It stretches rather than centres, so a nav item is a + full-height box and its current-page marker can land on the bar's own bottom edge. */ header.site { + /* One row is 60px and stays 60px; a bar that has wrapped is as tall as what it holds. */ + min-height: 60px; + row-gap: 4px; + flex: none; border-bottom: 1px solid var(--line); - padding: var(--cpad); + background: var(--recessed); + padding: 0 var(--gutter); display: flex; - gap: var(--cpad); - align-items: baseline; + align-items: stretch; + justify-content: space-between; + gap: 20px; + + /* + A bar spanning the window is chrome, so it stays where chrome belongs. The game page runs to + three and a half thousand pixels and the catalogue is at the top of it; scrolling back up to + reach the nav is a cost the card layout hid by being short. + */ + position: sticky; + top: 0; + z-index: 30; + + /* + Sideways only. `overflow: hidden` is what a fixed-height bar wants — nothing may spill out of + it — but it clipped the nav's own dropdown to nothing at the width where that dropdown IS the + navigation. `clip` on one axis leaves `visible` legal on the other; `hidden` would coerce it. + */ + overflow-x: clip; + overflow-y: visible; } -header.site .mark { font-family: var(--mono); font-weight: 600; text-decoration: none; } -header.site .mark .star { color: var(--accent); } +/* + The bar is one line of chrome and the demo banner above it is a statement about the whole site, so + the banner scrolls away and the bar does not. Where there is no banner the bar is simply at the + top of the document. +*/ +.demo-banner { position: relative; z-index: 31; } + +/* + The bar measures itself. + + Every threshold in the ladder below used to be a pixel count, and every one of them was really a + measurement of *English*: the seven catalogue links are 430px in English and 517px in Japanese, so + 860 was the width at which the English bar stopped fitting and German, Dutch and Japanese spent the + whole 861–1100 band with links running out of their box. 1024 is one of the four widths this design + is reviewed at, and all three failed at it. + + `max-content` is the browser's own answer to "how wide is this text, in this language, in this + font" — so the nav asks for exactly what its links need and `flex-wrap` gives it its own row the + moment the bar cannot. No number to keep in step with a translation, nothing to re-tune when a + string changes, and a language nobody has measured yet is right on arrival. + + What the reader gets in that band is a two-row bar rather than a menu, which is the trade: every + destination stays visible and in the same order, and the row that moves is the one that was being + clipped. Below the collapse width it is still one disclosure, because a menu is the right shape on + a phone whatever the language. +*/ +header.site { flex-wrap: wrap; } +header.site .mark { flex: 0 0 auto; } +header.site .site-nav { flex: 1 1 auto; min-width: max-content; } +header.site nav.account { flex: 0 0 auto; } +header.site form.theme { flex: 0 0 auto; } + +header.site .mark { + display: flex; + align-items: center; + font: 700 17px/1 var(--sans); + letter-spacing: -0.01em; + text-decoration: none; + white-space: nowrap; +} +header.site .mark .star { color: var(--accent); text-shadow: var(--glow); } /* ── provenance chip ─────────────────────────────────────────────────────── Not a box. At rest it is the value, one state glyph and a relative age — no border, no fill, @@ -178,14 +410,43 @@ header.site .mark .star { color: var(--accent); } /* ── capability matrix ─────────────────────────────────────────────────── */ -table.matrix { border-collapse: collapse; width: 100%; } +/* + A framed table, as the handoff draws it: a header row on the recessed surface, hairlines between + the rows, and the caption as a foot band inside the same frame rather than a loose line under it. + A caption that sits outside the border reads as a note about the section; inside it, it reads as + what it is — the table's own summary, with the table still in view. +*/ +table.matrix { + border-collapse: collapse; + width: 100%; + border: 1px solid var(--line-soft); + border-radius: var(--radius); + overflow: hidden; +} table.matrix th, table.matrix td { text-align: left; - padding: var(--row-pad) var(--cpad); - border-bottom: 1px solid var(--line); + /* Its own padding rather than the row token: this table is six rows of two-word states, and a + listing row's 13px by 20px turns each of them into a paragraph. */ + padding: 11px 16px; + border-top: 1px solid var(--line-soft); + white-space: nowrap; +} +table.matrix thead th { + font: 10px/1 var(--kick); letter-spacing: 0.16em; text-transform: uppercase; color: var(--faint); + background: var(--recessed); + border-top: 0; + padding: 10px 16px; } -table.matrix thead th { font: 10px/1 var(--kick); letter-spacing: 0.16em; text-transform: uppercase; color: var(--faint); } +table.matrix tbody tr:first-child th, table.matrix tbody tr:first-child td { border-top: 1px solid var(--line-soft); } table.matrix tr.disagrees { background: color-mix(in srgb, var(--amber) 9%, transparent); } +/* At the foot and inside the frame, where a caption belongs on a table whose heading is directly + above it — and stated once, here, rather than in the heading as well. */ +table.matrix caption.count { + caption-side: bottom; text-align: left; font-size: 12.5px; + padding: 10px 16px; + background: var(--recessed); + border-top: 1px solid var(--line-soft); +} .state-present { color: var(--accent); } .state-absent { color: var(--dim); } .state-unknown { color: var(--faint); } @@ -210,15 +471,30 @@ td.gap { background: transparent; outline: 1px dashed var(--faint); out Foreign colour is quoted, not hosted. Its own fixed black ground and its own locked 16-colour table in both themes, so arbitrary SGR is expected inside and nothing bleeds either way. */ -figure.ansi { margin: 0; border: 1px solid var(--line); background: #000; } +/* + One panel holding the art, the words and the caption — rather than a black box with a kicker strip + welded under it and the words in a separate disclosure below. The frame is the site's own recessed + surface at the controls' radius; the art keeps its fixed black ground inside, because the SGR it + carries is somebody else's and has to sit on the terminal it was drawn for. +*/ +figure.ansi { + margin: 0; + border: 1px solid var(--line-soft); + border-radius: var(--radius); + background: var(--recessed); + padding: 16px 18px; + display: flex; + flex-direction: column; + gap: 12px; + overflow: hidden; +} figure.ansi figcaption { - font: 10px/1 var(--kick); - letter-spacing: 0.16em; - text-transform: uppercase; + font-family: var(--mono); + font-size: 11.5px; color: var(--faint); - padding: 8px var(--cpad); - border-top: 1px solid var(--line); - background: var(--surface); + padding: 0; + background: none; + border: 0; } /* @@ -258,22 +534,259 @@ figure.ansi figcaption { .skip:focus { left: 8px; top: 8px; } -:where(a, button, input, summary):focus-visible { +:where(a, button, input, select, summary):focus-visible { outline: 2px solid var(--accent); outline-offset: 2px; } /* ── chrome ────────────────────────────────────────────────────────────── */ -/* Wrapping, because seven catalogue links do not fit a 390px phone on one line and the alternative - is a page that scrolls sideways — which the whole layout is otherwise careful never to do. */ -header.site nav { display: flex; gap: var(--cpad); flex-wrap: wrap; } -header.site nav a { color: var(--dim); text-decoration: none; } +/* + Every item is a full-height flex box, and nothing wraps. The bar's job is to be one line of + chrome; when it stops fitting it degrades through the steps below rather than reflowing. +*/ +header.site nav { display: flex; align-items: stretch; min-width: 0; } +header.site nav a, header.site nav span.nav-item { + display: flex; align-items: center; white-space: nowrap; + color: var(--dim); text-decoration: none; font-size: 13.5px; +} header.site nav a:hover { color: var(--text); text-decoration: underline; text-underline-offset: 3px; } -/* The one link in this bar that leads somewhere only you can go, so it is not dimmed like the - catalogues beside it. */ +/* ── the two groups ──────────────────────────────────────────────────────── + Places to browse, and things to read about the hobby. The label is the kicker face the rest of + the site uses for column heads, and it is aria-hidden: the group carries the same word as its + accessible name, and a screen reader announcing "browse" as a text node and again as a label is + the duplication this pass exists to remove. */ + +header.site .site-nav { display: flex; align-items: stretch; justify-content: center; gap: 14px; } +header.site .nav-group { display: flex; align-items: stretch; gap: 11px; min-width: 0; } +header.site .nav-label { + display: flex; align-items: center; white-space: nowrap; + font: 9px/1 var(--kick); letter-spacing: 0.16em; text-transform: uppercase; color: var(--faint); +} + +/* A hairline between the groups rather than a wider gap: the bar is short and the gap that would + read as a separation is one that reads as a wrap. 18px, centred in the 60px bar. */ +header.site .nav-rule { flex: 0 0 auto; width: 1px; margin: 21px 0; background: var(--line); } + +/* + The page you are on, marked *inside* the item's own box. + + The marker is an inset shadow and NOTHING else — no border, no padding change. Either of those + adds a pixel to the current item's box, and because the bar is a flex line that grows to its + tallest child, the whole row moved down one pixel the moment a marked item was on it. A bar that + shifts when you arrive is a bar you cannot aim at, and it is the defect the handoff names by hand. +*/ +header.site nav a.on { color: var(--text); box-shadow: inset 0 -2px 0 0 var(--accent); } +header.site nav a.on:hover { text-decoration: none; } + +/* The far end of the bar: what to do, rather than where to go. Submit is an action and about is + site meta, so neither is a catalogue and neither sits in a group above. */ +header.site nav.account { display: flex; align-items: center; gap: 12px; } header.site nav.account a { color: var(--text); } +header.site nav.account a.action { + border: 1px solid var(--line); border-radius: var(--radius); padding: 6px 12px; + font-size: 13px; white-space: nowrap; +} +header.site nav.account a.action:hover { border-color: var(--dim); text-decoration: none; } + +/* The accent button: ring and tint together, as the handoff draws it — the fill is what tells it + apart from the bordered one beside it at a glance. */ +header.site nav.account a.action.primary { + border-color: color-mix(in srgb, var(--accent) 40%, transparent); + background: color-mix(in srgb, var(--accent) 12%, transparent); + color: var(--accent); +} + +/* + ── the nav's degradation order (i18n S2) ────────────────────────────────── + Width triggers the steps, never language: a German reader on a wide monitor never leaves step 0 + and an English reader in a narrow window reaches step 2. Each step loses DECORATION, never a + destination — which is the whole point, and why the collapse at the end is a disclosure holding + every link rather than a shorter bar. + + step 1 group labels drop; the divider keeps the grouping + step 2 submit loses its border, becoming a plain link + step 3 both groups collapse into one `menu` disclosure + + Budget every nav string at 1.4x the English width when reviewing a locale. +*/ + +/* + Step 0 to 2 the disclosure is not a disclosure: the summary is hidden and its content forced + visible, so the two groups sit in the bar exactly as if the <details> were not there. Guarded on + ::details-content, because a browser without it cannot be made to show a closed <details> — there + the summary stays and the nav is a menu button at every width, which is a worse bar and a working + one. +*/ +header.site .nav-menu { display: flex; position: relative; align-items: stretch; min-width: 0; } +header.site .nav-menu > summary { + display: flex; align-items: center; gap: 6px; cursor: pointer; + color: var(--dim); font-size: 13.5px; white-space: nowrap; list-style: none; +} +header.site .nav-menu > summary::-webkit-details-marker { display: none; } +header.site .nav-menu > summary:hover { color: var(--text); } +header.site .nav-menu[open] > summary { color: var(--text); } + +/* The panel, as a dropdown. Above the collapse width the same element is the bar's own centre row. */ +header.site .nav-menu .menu-panel { + position: absolute; top: 100%; left: 0; z-index: 20; min-width: 200px; + display: flex; flex-direction: column; gap: 2px; + padding: 8px; margin-top: 1px; + background: var(--raised); border: 1px solid var(--line); + border-radius: var(--radius); box-shadow: var(--shadow); +} +header.site .nav-menu .menu-panel > .nav-group { flex-direction: column; align-items: stretch; gap: 2px; } +header.site .nav-menu .menu-panel a { padding: 6px 10px; border-radius: 6px; } +header.site .nav-menu .menu-panel a:hover { background: var(--surface); text-decoration: none; } + +/* + The current page, marked for a list rather than for a bar — and only while the panel IS a list. + The inset shadow that lands on the bar's bottom edge becomes a full-width rule under one row of a + dropdown, which reads as a text field rather than as "you are here", so in the panel the marker + moves to the leading edge. Scoped to the collapsed width: unscoped it drew a vertical accent bar + and a tinted box down the side of the current item in the open bar. +*/ +@media (max-width: 880px) { + header.site .nav-menu .menu-panel a.on { + box-shadow: inset 2px 0 0 0 var(--accent); + background: color-mix(in srgb, var(--accent) 10%, transparent); + color: var(--accent); + } +} +header.site .nav-menu .menu-panel .nav-label { padding: 6px 8px 2px; } +header.site .nav-menu .menu-panel .nav-rule { display: none; } +header.site .menu-tail { display: flex; flex-direction: column; gap: 2px; } + +@supports selector(::details-content) { + @media (min-width: 881px) { + header.site .nav-menu > summary { display: none; } + + /* + The wrapper has to carry the bar's full height, not its content's. A nav item is a + full-height box so that the current-page marker — an inset shadow, drawn inside the box — + lands on the bar's own bottom edge; with the wrapper sized to its text the marker floated + eighteen pixels above it, which is the underline hanging in mid-bar rather than sitting on + it. `display: flex` is what makes the panel below a stretched flex item. + */ + header.site .nav-menu::details-content { + content-visibility: visible; + block-size: 100%; + display: flex; + align-items: stretch; + } + + /* The panel is the bar's middle row: a static flex line, not a dropdown. */ + header.site .nav-menu .menu-panel { + position: static; min-width: 0; height: 100%; + display: flex; flex-direction: row; align-items: stretch; gap: 14px; + padding: 0; margin: 0; background: none; border: 0; border-radius: 0; box-shadow: none; + } + header.site .nav-menu .menu-panel > .nav-group { flex-direction: row; align-items: stretch; gap: 11px; } + header.site .nav-menu .menu-panel a { padding: 0; border-radius: 0; } + header.site .nav-menu .menu-panel a:hover { background: none; } + header.site .nav-menu .menu-panel .nav-rule { display: block; } + header.site .nav-menu .menu-panel .nav-label { padding: 0; } + + /* Step 4's overflow home, which the bar itself still carries at these widths. */ + header.site .menu-tail { display: none; } + } + + /* + Step 1 — the labels go and the divider stays. The grouping is the fact; the words naming the + groups are a gloss on it, and the rule between them carries the same fact in one pixel. Losing + both at once would leave seven links in a row in no order anybody could name, which is the + state this bar was rebuilt out of. + */ + @media (min-width: 881px) and (max-width: 1180px) { + header.site .nav-label { display: none; } + header.site .nav-menu .menu-panel { gap: 14px; } + header.site .nav-menu .menu-panel > .nav-group { gap: 11px; } + } +} + +@media (max-width: 1000px) { /* step 2 — submit keeps the word, loses the box */ + header.site nav.account a.action:not(.primary) { + border-color: transparent; padding: 6px 0; color: var(--dim); + } + header.site nav.account a.action:not(.primary):hover { color: var(--text); } +} + +@media (max-width: 880px) { /* step 3 — one disclosure, every destination kept */ + header.site .site-nav { justify-content: flex-start; } + + /* + And it stops being the bar's shock absorber. Above this width the nav holds seven links and + `flex: 1 1 auto; min-width: 0` is what lets it give room back to the two ends; below it the + nav is one word and a chevron, and the same rule let flexbox squeeze that word to 33px — the + German bar rendered "Men" with the chevron cut off, on the only control that reaches the other + six pages. The ends are sized by their content and the middle was the only thing that could + yield, so a longer word at either end came out of the one item that must never shrink. + */ + header.site .site-nav { flex: 0 0 auto; } +} + +/* + Step 4 — the right cluster runs out too. `submit` joins the menu, which is where the markup + already carries it; `about` and `sign in` stay, the first because it is two words and the second + because it is the one item at that end that changes what the site will let a reader do. Still no + destination lost. +*/ +@media (max-width: 640px) { + header.site { padding: 0 14px; gap: 12px; } + header.site nav.account a.action:not(.primary) { display: none; } + header.site form.theme { gap: 6px; } +} + +/* + Step 5 — below a small phone the type gives way before anything else does. Nothing is dropped and + nothing moves; the two clusters at the ends are simply set a step smaller, which is the last + decoration the bar has left to spend. +*/ +@media (max-width: 460px) { + header.site { padding: 0 8px; gap: 6px; } + header.site .mark { font-size: 15px; } + header.site form.theme { gap: 4px; } + header.site form.theme button { font-size: 12px; } + header.site nav.account { gap: 6px; } + header.site nav.account a { font-size: 12.5px; } + header.site nav.account a.action { padding: 5px 8px; } +} + +/* + Step 6 — and the bar is measured in a language, not in English. + + Every step above was tuned against a bar reading "menu · about · submit · sign in · auto light + dark", which is the shortest this chrome is ever going to be. The same bar in German is "Menü · + über uns · anmelden · auto hell dunkel" and wanted seventeen more pixels than a 430px phone has; + Dutch was twelve pixels from the same wall. So the last step is a real one rather than a hedge, + and it spends the only thing left that is not a destination: the theme control's three words + become the row's tightest type, and the wordmark gives up a point with them. Nothing moves and + nothing is dropped — the German bar and the English bar hold the same seven pages either side of + it, which is the property the whole ladder exists to keep. +*/ +/* + Step 7 — and on the narrowest phone the bar stops being one line, for whichever language needs it. + + At 360px the German bar wants 412px: "mu*index · Menü ▾ · über uns · anmelden · auto hell dunkel". + Everything above this step spends decoration and the ladder has none left — and the item that fell + off the end was the theme control, clipped past `.shell`'s `overflow-x: clip` and so not merely + cramped but gone. A reader on a 360px phone in German could not change the theme at all. + + No width triggers this and no language is named in it: the bar already wraps on content, so the + theme control takes a second row exactly where it stops fitting. German and Dutch reach it at 360 + and English and Chinese do not, which is the ladder working rather than a rule about German. The + one thing set here is what happens *after* a wrap — the control keeps the trailing edge it has on + one line, so the bar does not appear to change its mind about which end it belongs to. +*/ +header.site form.theme { margin-inline-start: auto; } + +@media (max-width: 480px) { + header.site .mark { font-size: 14px; letter-spacing: 0; } + header.site form.theme { gap: 4px; } + header.site form.theme button { font-size: 11.5px; } + header.site nav.account a { font-size: 12px; } +} /* ── the reader's theme ──────────────────────────────────────────────────── Buttons drawn as the links beside them, because they belong to that row and a row of three real @@ -281,7 +794,10 @@ header.site nav.account a { color: var(--text); } brighter: a state carried by colour alone is a state a greyscale display does not carry, which is the same rule the heatmap's hatch exists for. */ -form.theme { display: flex; align-items: baseline; gap: 8px; margin: 0; } +/* Centred in the bar rather than baseline-aligned to it: the bar stretches its children to 60px, + and a baseline inside a stretched box lands wherever the box's first line happens to be — which + put this cluster sixteen pixels above the buttons beside it. */ +form.theme { display: flex; align-items: center; gap: 8px; margin: 0; } form.theme .kick { font: 10px/1 var(--kick); letter-spacing: 0.16em; @@ -312,19 +828,55 @@ pre.plain { white-space: pre-wrap; font-size: 13px; line-height: 1.6; color: var /* ── home ──────────────────────────────────────────────────────────────── */ -.hero h1 { font-size: 28px; max-width: 24ch; line-height: 1.2; } +.page-flow { display: flex; flex-direction: column; gap: 22px; } + +/* + The heading runs to whatever width it has. It carried a 24ch clamp, which broke "A directory of + the MU* hobby" across two lines at every width including 1440 — a measure is for paragraphs, and + this is one short line whose whole job is to be read at a glance. +*/ +.hero-head { display: flex; flex-direction: column; gap: 8px; } +.hero h1 { font-size: 26px; line-height: 1.2; letter-spacing: -0.01em; margin: 0; } -form.search { display: flex; gap: 8px; max-width: 560px; margin: var(--cpad) 0; } -form.search input { flex: 1; min-width: 0; } +/* The one sentence a stranger needs before they read a count. Dimmed a step so the heading above it + stays the first thing the eye takes, and measured so it never runs past a comfortable line. */ +.hero .lede { font-size: 14.5px; line-height: 1.6; color: var(--dim); max-width: 62ch; margin: 0; } +/* + One field with the search glyph inside it, and the submit beside it at the field's own height. + The two used to be separate boxes at two different sizes, which read as a form rather than as the + one control it is. +*/ +form.search { display: flex; gap: 8px; max-width: 520px; margin: 0; } +.search-field { + flex: 1 1 auto; min-width: 0; + display: flex; align-items: center; gap: 10px; + background: var(--recessed); + border: 1px solid var(--line); + border-radius: var(--radius); + padding: 0 14px; +} +.search-field:focus-within { border-color: color-mix(in srgb, var(--accent) 55%, var(--line)); } +.search-glyph { color: var(--accent); font-size: 15px; line-height: 1; } input[type="search"], input[type="text"] { background: var(--recessed); border: 1px solid var(--line); color: var(--text); font: 14px var(--sans); padding: 8px 11px; - border-radius: 6px; + border-radius: var(--radius); +} + +/* After the generic input rule, not before it: the field's own box is the bordered thing here and + the input inside it is only the caret. Ordered the other way round the generic rule won on equal + specificity and drew a second border inside the first. */ +.search-field input[type="search"] { + flex: 1; min-width: 0; + background: none; border: 0; padding: 11px 0; border-radius: 0; + color: var(--text); font: 14px var(--sans); } +.search-field input[type="search"]:focus { outline: none; } +.search-field input[type="search"]::placeholder { color: var(--faint); } button { background: var(--raised); @@ -332,95 +884,268 @@ button { color: var(--text); font: 14px var(--sans); padding: 8px 14px; - border-radius: 6px; + border-radius: var(--radius); cursor: pointer; } -ul.counts { +/* ── the four figures ────────────────────────────────────────────────────── + A label and a value, in a framed tile, at the size a front page's whole claim deserves. They were + one 12px mono line reading like a caption, which is what a count of the hobby is not. */ + +ul.tiles { list-style: none; margin: 0; padding: 0; - display: flex; flex-wrap: wrap; gap: 20px; font-size: 12px; color: var(--dim); + display: grid; grid-template-columns: repeat(auto-fit, minmax(170px, 1fr)); gap: 12px; +} +ul.tiles li { + border: 1px solid var(--line-soft); border-radius: var(--radius-lg); + background: var(--surface); box-shadow: var(--shadow); padding: 16px; + display: grid; gap: 8px; align-content: start; +} +ul.tiles a { text-decoration: none; display: grid; gap: 8px; } + +/* + The value stays in the machine face. The drawing sets it in the UI sans, and the handoff's own + token rules say the opposite two pages earlier — "mono for anything the machine said: counts, + versions, ages … the one typographic rule carrying meaning". A count of the hobby is the purest + case of a machine-said value on this site, so the prose wins over the component. The size is the + drawing's. +*/ +ul.tiles .kicker { color: var(--faint); } +ul.tiles .figure { + font-size: 28px; font-weight: 600; letter-spacing: -0.01em; color: var(--text); + line-height: 1; } -ul.counts strong { color: var(--text); font-weight: 400; } +ul.tiles .figure.state-present { color: var(--accent); } /* The crawler strip, under the counts it is the provenance of. A step smaller and dimmer than they are, because it is about the instrument rather than about the hobby — a reader who never notices it has lost nothing, and one who comes looking for it knows where to look. */ +/* Hairlines top and bottom, as the handoff frames it: the strip is a band of provenance under the + figures it qualifies, and a band reads as one thing where a loose line reads as a footnote. */ p.crawler { - margin: 10px 0 0; font-size: 11px; + margin: 0; padding: 12px 0; font-size: 12.5px; + display: flex; align-items: center; gap: 10px; + border-top: 1px solid var(--line-soft); border-bottom: 1px solid var(--line-soft); } +p.crawler .state-present { text-shadow: var(--glow); } .feeds { display: grid; grid-template-columns: repeat(auto-fit, minmax(280px, 1fr)); - gap: var(--cpad); - margin: calc(var(--cpad) * 2) 0; + gap: 22px; + margin: 0; } +/* A column: its heading, then rows. The heading carried a 33.6px top margin from the global h2 + rule, which put each of the three columns a block lower than the rhythm the page is set on. */ +.feeds .feed { display: flex; flex-direction: column; } +.feeds .feed h2 { margin: 0 0 10px; } +.feeds .feed-lit h2 { color: var(--accent); } +.feeds .feed-dark h2 { color: var(--amber); } + /* ── liveness feed cards ─────────────────────────────────────────────────── One shape, three registers. Neutral, unlit, and — for a return — the one place the site raises its voice, because a game dark for two years answering is what no incumbent can tell you. */ -.feed-card { - border: 1px solid var(--line); - background: var(--recessed); - border-radius: 8px; - padding: 12px 14px; - margin-bottom: 10px; +/* A row: name left, age right, a hairline between. Three columns of boxed cards gave a name and an + age the furniture of a section, and framed things on this site are supposed to mean something — + the connect screen is quoted in a frame because it is somebody else's. */ + +.feed-row { + display: flex; + justify-content: space-between; + align-items: baseline; + gap: 12px; + padding: 9px 0; + border-bottom: 1px solid var(--line-soft); } -.feed-card .feed-name { display: flex; align-items: baseline; gap: 8px; flex-wrap: wrap; margin-top: 6px; } -.feed-card .feed-name a { font-size: 15px; font-weight: 600; text-decoration: none; } -.feed-card .detail { font-size: 11.5px; color: var(--dim); margin: 4px 0 0; } -.feed-card.unlit { opacity: 0.78; } -.feed-card.unlit .feed-name a { color: var(--dim); } +/* The last row of a column closes on the column's own edge rather than on a rule to nothing. */ +.feeds .feed-row:last-child { border-bottom: 0; } -.feed-card.returned { - border-color: color-mix(in srgb, var(--accent) 34%, transparent); - background: color-mix(in srgb, var(--accent) 10%, transparent); - animation: return-glow 1.4s ease-out 1; +.feed-row .feed-name { + min-width: 0; font-size: 14px; color: var(--text); text-decoration: none; +} +.feed-row .feed-name:hover { text-decoration: underline; text-underline-offset: 3px; } +.feed-row .feed-state { + flex: none; display: inline-flex; align-items: baseline; gap: 5px; + font-size: 12.5px; color: var(--faint); +} +.feed-row .feed-state .sep { color: var(--faint); } +.feed-row.unlit .feed-name { color: var(--dim); } + +/* The return is the same row as the other two. The accent is on the word that says it is back and + nowhere else — a tinted card with a glow gave one column furniture the other two did not have, + and the eye cannot run down three lists that are drawn as different kinds of thing. */ +.feed-row.returned .feed-state .state-present { color: var(--accent); } + +/* ── the card's own footer ───────────────────────────────────────────────── + The same row on every page: where else to go, and the text mirror last. A rule above it, because + it is the end of the card and not another block in the column. */ + +.card-footer { + display: flex; flex-wrap: wrap; gap: 16px; + margin: 0; padding-top: 14px; + border-top: 1px solid var(--line-soft); + font-size: 13px; color: var(--dim); +} + +/* On a card page the footer is a band of the card rather than a block in a padded column, so it + pads itself to the same edge every other band uses. */ +.card-page > .card-footer { padding: 14px var(--gutter) 22px; } +.card-footer { align-items: baseline; } +.card-footer a { text-decoration: none; } +.card-footer a:hover { text-decoration: underline; text-underline-offset: 3px; } +.card-footer .sep { color: var(--faint); } + +/* + The language switcher, at the far end of the footer beside the plain-text link — the two controls + that change how the page is read rather than which page it is. Pushed there rather than placed, so + the destinations keep the left edge they had. +*/ +form.locale { display: flex; align-items: center; gap: 10px; margin: 0 0 0 auto; } + +/* The label is the theme control's kicker, because these two sit side by side and are the same kind + of thing: a small named control that changes how the page is read. */ +form.locale .kick { + font: 10px/1 var(--kick); + letter-spacing: 0.16em; + text-transform: uppercase; + color: var(--faint); } -/* Motion budget, one of three: once, on arrival, never repeating. */ -@keyframes return-glow { - from { box-shadow: 0 0 0 0 color-mix(in srgb, var(--accent) 55%, transparent); } - to { box-shadow: 0 0 0 14px transparent; } +/* + One box, drawn as the search field is: the control and its submit inside a single hairline rather + than a native dropdown and a wide button beside it. The footer is otherwise text, and two heavy + rectangles in it read as the loudest thing on the page — which a language switcher is not. +*/ +.locale-field { + display: flex; align-items: center; gap: 2px; + background: var(--recessed); + border: 1px solid var(--line); + border-radius: var(--radius); + padding: 0 4px 0 11px; +} +.locale-field:focus-within { border-color: color-mix(in srgb, var(--accent) 55%, var(--line)); } + +/* Stripped of the platform's own chrome so it matches the site rather than the OS — a native select + is a different shade, a different radius and a different caret on each of the three, and none of + them is this one. */ +form.locale select { + appearance: none; + background: none; border: 0; border-radius: 0; margin: 0; + padding: 7px 18px 7px 0; + color: var(--text); font: 13px var(--sans); + cursor: pointer; + + /* Sized to the option in force rather than to the longest one in the list. A select is as wide + as its widest child by default, so "English" sat in a box cut for "Русский (CI canary)" and + the caret ended up a hand's width from the word it belongs to. Where this is not supported the + box is merely the old width, which is the behaviour it replaces — nothing is lost by it. */ + field-sizing: content; +} +/* + The ring goes round the box, not round the flat control inside it. Stripping `appearance` takes the + platform's focus ring with it, and the border tint below is a mouse affordance rather than an + indicator a keyboard reader can rely on — 2.4.7 wants something that survives at any contrast. +*/ +form.locale select:focus { outline: none; } +.locale-field:has(select:focus-visible) { + outline: 2px solid var(--accent); + outline-offset: 2px; +} + +/* The nav's chevron, not a new glyph. Pulled back over the select's right padding and transparent to + the pointer, so the caret is part of the same click target rather than a dead spot beside it. */ +.locale-caret { + margin-left: -16px; + color: var(--faint); font-size: 11px; line-height: 1; + pointer-events: none; +} + +/* The search's own arrow. A submit is needed because this site runs no script, and this is the + smallest shape that says "commit" in a vocabulary the reader has already met. */ +.locale-go { + flex: none; display: flex; align-items: center; justify-content: center; + width: 22px; height: 22px; padding: 0; + background: none; border: 0; border-radius: 6px; + color: var(--faint); font-size: 13px; cursor: pointer; } +.locale-go:hover { color: var(--accent); background: var(--raised); } + -.feed-card.returned .return-line { font-size: 15px; line-height: 1.5; color: var(--text); margin: 6px 0 0; } /* ── game page ─────────────────────────────────────────────────────────── */ -.game-head { display: flex; gap: var(--cpad); flex-wrap: wrap; align-items: flex-start; } -.game-head .game-title { flex: 1; min-width: 260px; } +/* The header band: padded like every other band on a card page, with a rule under it running the + card's full width. */ +.game-head { + display: flex; gap: 20px; flex-wrap: wrap; + align-items: flex-start; justify-content: space-between; + padding: 24px var(--gutter); + border-bottom: 1px solid var(--line-soft); +} + +.game-identity { display: flex; gap: 16px; align-items: flex-start; min-width: 0; flex: 1 1 340px; } +.game-head .game-title { display: flex; flex-direction: column; gap: 6px; min-width: 0; } +.game-head .game-title h1 { margin: 0; } +.game-head .claim-line { margin: 0; font-size: 13.5px; } .game-head .plate { - width: 68px; height: 68px; flex: none; - border: 1px solid var(--line); border-radius: 8px; + width: 64px; height: 64px; flex: none; + border: 1px solid var(--line-soft); border-radius: 12px; background: var(--recessed); color: var(--dim); display: grid; place-items: center; font-size: 22px; + padding: 8px; box-sizing: border-box; +} + +/* + The count and the probe that produced it, as one block. It was a number and a provenance chip on + one line at body size, which set the fact most readers came for at the size of the metadata + qualifying it. +*/ +.game-figure { + flex: 0 0 auto; display: flex; flex-direction: column; align-items: flex-end; gap: 6px; + text-align: right; } +.game-figure .figure-count { + margin: 0; font-size: 20px; color: var(--accent); + text-shadow: var(--glow); font-variant-numeric: tabular-nums; +} +.game-figure .figure-count .unit { font-size: 15px; } + +/* A count the game states about itself rather than one we read: amber, which is what declared means + everywhere else here, and no glow — the glow is the accent's, and the accent means measured. */ +.game-figure .figure-count.declared { color: var(--amber); text-shadow: none; } +.game-figure .figure-count.unknown { + color: var(--faint); text-shadow: none; font-size: 15px; font-variant-numeric: normal; +} +.game-figure .figure-age { margin: 0; } + +/* One column, and the sections spaced by it rather than by margins that disagree. */ +.game-body { display: flex; flex-direction: column; gap: 28px; padding: 28px var(--gutter) 8px; } +.game-body > section { display: flex; flex-direction: column; gap: 10px; } +.game-body > section > h2 { margin: 0; font-size: 17px; } /* An icon sits in the monogram's place and at its size. `contain` rather than `cover`: a logo that is not square is letterboxed rather than cropped, because cropping somebody's artwork to fit our box is a small edit to a thing they published. The plate's own background shows through where the image does not reach, so a transparent PNG lands on the same recessed square as the monogram. */ .game-head img.plate { object-fit: contain; padding: 4px; } -.game-head .connect { flex: none; min-width: 240px; } -.game-head .lede { font-size: 15px; line-height: 1.65; max-width: 62ch; } -.game-head .tagline { font-size: 16px; } -.game-head .live { font-size: 14px; } +.game-head .lede { font-size: 14.5px; line-height: 1.6; max-width: 62ch; margin: 0; color: var(--dim); } +.game-head .tagline { font-size: 15px; margin: 0; } -/* The count's label, beside the count. Spaced in CSS rather than by a space in the markup, because - the renderer trims whitespace around a conditional — and sized to the line it qualifies. */ -.game-head .live .chip { margin-left: 6px; } -.game-head .live .chip .age { font-size: inherit; } +/* + An address is a line, not a card. Each was a bordered panel the full width of the title column, + which gave a hostname the furniture of the one framed thing on this page — somebody else's output, + quoted. +*/ .game-head .endpoint { - background: var(--raised); border: 1px solid var(--line); border-radius: 6px; - padding: 7px 10px; font-size: 12.5px; margin-bottom: 6px; + display: flex; flex-wrap: wrap; align-items: baseline; gap: 12px; + margin: 0; padding-top: 4px; + font-size: 13.5px; color: var(--text); } -/* Same reason as the chip above, and it shipped as "penultimatemush.com 9500answering here since - Jul 2026": the renderer trims the whitespace between the port and a conditional span, so the gap - has to be a margin rather than a space in the markup. */ -.game-head .endpoint > span { margin-left: 8px; } +.game-head .endpoint .faint { font-size: 12.5px; } +.game-head .endpoint.former .address { color: var(--dim); } .badges { margin: 4px 0 6px; } .badge.claimed { color: var(--accent); border-color: color-mix(in srgb, var(--accent) 34%, transparent); } @@ -433,6 +1158,7 @@ p.crawler { } .archive-plate strong { color: var(--text); font-weight: 500; } +/* Kept for any surface that still wants two columns; the game page is one column now. */ .two-up { display: grid; grid-template-columns: minmax(0, 1.15fr) minmax(0, 0.85fr); gap: calc(var(--cpad) * 2); } /* @@ -441,7 +1167,7 @@ p.crawler { on it was clipped, while .heat-wrap's own overflow-x sat there doing nothing. The only region allowed to scroll sideways is the ANSI frame. */ -.two-up > *, .feeds > *, .row-main > * { min-width: 0; } +.two-up > *, .feeds > *, .row-main > *, .game-body > * { min-width: 0; } .section-head { display: flex; align-items: baseline; justify-content: space-between; gap: var(--cpad); flex-wrap: wrap; } .section-head .count { font-size: 12px; margin: 0; } @@ -556,8 +1282,14 @@ nav.spans .span { padding: 6px 10px; border: 1px solid var(--line); border-radius: 999px; color: var(--dim); text-decoration: none; } -nav.spans .span:hover { border-color: var(--dim); color: var(--text); } -nav.spans .span.on { border-color: var(--accent); color: var(--accent); } +nav.spans a.span:hover { border-color: var(--dim); color: var(--text); } + +/* The pressed one, which is a span rather than a link to the page you are on. Tinted as well as + outlined, because with no hover to distinguish it the border alone was doing all the work. */ +nav.spans .span.on { + border-color: var(--accent); color: var(--accent); + background: color-mix(in srgb, var(--accent) 10%, transparent); +} /* The shape sits under the range and is the smaller question of the two, so it follows immediately rather than being spaced as a second block. */ nav.spans.shapes { margin-top: -4px; } @@ -569,11 +1301,37 @@ details.read-as-text[open] > *:not(summary) { animation: reveal 120ms ease-out; /* Motion budget, three of three. */ @keyframes reveal { from { opacity: 0; } to { opacity: 1; } } -ul.perday, ul.spells { +ul.spells { list-style: none; margin: 6px 0 0; padding: 0; font-family: var(--mono); font-size: 12px; color: var(--dim); } -ul.perday li, ul.spells li { padding: 2px 0; } +ul.spells li { padding: 2px 0; } + +/* The grid's text alternative: seven rows rather than a hundred and sixty-eight cells. Numbers are + tabular so the columns scan, and the caption sits under the table it describes. */ +table.perday { + width: 100%; margin: 6px 0 0; border-collapse: collapse; + font-family: var(--mono); font-size: 12px; color: var(--dim); + caption-side: bottom; +} +table.perday caption { padding: 8px 0 0; color: var(--faint); text-align: left; } +table.perday th, table.perday td { padding: 4px 8px 4px 0; text-align: left; } +table.perday thead th { + font: 10px/1 var(--kick); letter-spacing: 0.16em; text-transform: uppercase; color: var(--faint); + border-bottom: 1px solid var(--line); padding-bottom: 6px; +} +table.perday tbody th { color: var(--text); font-weight: 600; } +table.perday td.num { font-variant-numeric: tabular-nums; } + +/* Not enough measured days to draw a week. A panel rather than a bare line, so the section reads as + answered rather than as a graphic that failed to load. */ +.sparse { + margin: 10px 0 var(--cpad); padding: calc(var(--cpad) * 1.5) var(--cpad); + border: 1px dashed var(--line); border-radius: 8px; + background: var(--recessed); color: var(--dim); text-align: center; +} +.sparse p { margin: 0; } +.sparse .kicker { margin-bottom: 6px; } /* ── availability strip ──────────────────────────────────────────────────── Ninety bars, oldest left. Degraded is a *short* bar and not merely another colour; unreachable @@ -600,19 +1358,50 @@ dl.stats dd { margin: 3px 0 0; font-size: 17px; } /* ── the ANSI quotation frame ──────────────────────────────────────────── */ -figure.ansi .quote { position: relative; background: #000; } -figure.ansi .quote pre { - margin: 0; padding: var(--cpad); - font: 13px/1.5 var(--mono-cjk); font-variant-ligatures: none; - color: #aaaaaa; white-space: pre; overflow-x: auto; +/* Every row, once, in a region that scrolls — a screen twice the height of the frame is scrolled + rather than cropped and offered again below. The cap is about 26 rows, which is what a terminal + showed the player; past that the reader scrolls the same way they would have on connecting. + Focusable, because a scrolling region a keyboard cannot reach is one a keyboard cannot read. */ +figure.ansi .quote { + position: relative; background: #000; + border-radius: 6px; + max-height: 33em; overflow: auto; overscroll-behavior: contain; } -figure.ansi .crop-fade { - position: absolute; left: 0; right: 0; bottom: 0; height: 56px; - background: linear-gradient(to bottom, rgba(0, 0, 0, 0), #000); - pointer-events: none; +figure.ansi .quote:focus-visible { outline: 2px solid var(--accent); outline-offset: -2px; } +figure.ansi .quote pre { + margin: 0; padding: 14px 16px; + font: 12px/1.4 var(--mono-cjk); font-variant-ligatures: none; + color: #aaaaaa; white-space: pre; } figure.ansi figcaption { display: flex; gap: 8px; flex-wrap: wrap; } -details.read-as-text .ansi { border: 1px solid var(--line); } + +/* + ── the words, in the same figure ────────────────────────────────────────── + The prose lines are what a player actually needs — the address and the connect/create/QUIT + instructions — and they were behind a disclosure outside the frame, which made the block a picture + with a footnote rather than a quotation with a reading. Under a hairline, with the kicker the + handoff names, and open: this is the one text copy of the art, and a text alternative a reader has + to open is one most readers never see. +*/ +.screen-text { + border-top: 1px solid var(--line-soft); + padding-top: 12px; +} +.screen-text > summary { cursor: pointer; list-style: none; } +.screen-text > summary::-webkit-details-marker { display: none; } +.screen-text > summary::after { content: " ▾"; color: var(--faint); letter-spacing: normal; } +.screen-text[open] > summary::after { content: " ▴"; } +.screen-text .kicker { color: var(--accent); } +.screen-text > summary:hover .kicker { color: var(--text); } +.screen-text > pre { margin-top: 8px; } +.screen-text pre { + margin: 0; + font: 12.5px/1.7 var(--mono-cjk); font-variant-ligatures: none; + color: var(--text); + white-space: pre-wrap; + overflow-wrap: anywhere; +} + pre.plain-screen { background: var(--recessed); padding: var(--cpad); overflow-x: auto; font-size: 12px; } .ansi-plate { @@ -637,28 +1426,54 @@ pre.plain-screen { background: var(--recessed); padding: var(--cpad); overflow-x ul.games, ul.archive { list-style: none; margin: 0; padding: 0; } +/* + The row pads itself and the hairline runs the column's full width. It used to hang on a negative + margin so a hover plane could reach past the reading measure — the results column owns its own + padding now, so the row simply is the width it is drawn at. +*/ ul.games > li, ul.archive > li { - border-bottom: 1px solid var(--line); - padding: var(--row-pad) var(--cpad); - - /* Negative margin so the hover plane runs to the reading measure's own edge and the text does - not shift when it appears — a row that moves under the pointer is a row you mis-click. */ - margin: 0 calc(var(--cpad) * -1); + border-bottom: 1px solid var(--line-soft); + padding: var(--row-pad) var(--gutter); + margin: 0; } -ul.games > li.game-row:hover { background: var(--surface); } +ul.games > li.game-row:hover { background: var(--raised); } + +/* The row is a touch target before it is a layout: the game's name is the link, and on a phone a + list of five hundred of them is a list of five hundred things to hit. The handoff's geometry — + 13px by 20px over a 46px floor — is what puts a comfortable target under every name. */ +ul.games > li.game-row { min-height: 46px; padding: var(--row-pad) var(--gutter); } /* Three columns: the game's face, what it is, and what we measured. The plate is what gives a five-hundred-row list a left edge the eye can run down — before it, every row began with a different-length name and the only way to find a game was to read them. `start` rather than `baseline` because a 36px box has no baseline worth aligning a name to. */ +/* Two zones on the row and a third under them: identity on the left, measurement on the right, and + the meta line spanning beneath the name. The handoff's geometry exactly. */ +/* + Three columns and two lines: identity, measurement, freshness across the top, and the machine + facts spanning beneath. The count and the age are siblings on one baseline — they were a nested + two-row grid in the third column, which stacked the age under the count and left neither able to + line up down the page. +*/ .row-main { display: grid; - grid-template-columns: auto minmax(0, 1fr) auto; - gap: 2px var(--cpad); - align-items: start; + grid-template-columns: minmax(0, 1fr) auto auto; + gap: 3px 20px; + align-items: baseline; } +/* + `contents` so the name and the metadata are grid items of the row itself rather than of a box + inside column one — that is what lets the metadata span all three columns while the name occupies + only the first. +*/ +.row-main .row-text { display: contents; } +.row-main .row-head { grid-column: 1; grid-row: 1; min-width: 0; } +.row-main .row-count { grid-column: 2; grid-row: 1; } +.row-main .row-seen { grid-column: 3; grid-row: 1; } +.row-main .meta { grid-column: 1 / -1; grid-row: 2; min-width: 0; } + /* The row's own plate. Same recessed square, same border, same monogram treatment as the game page's — one vocabulary at two sizes, so a reader who has seen the page recognises the row. */ .row-main .plate { @@ -683,9 +1498,9 @@ ul.games .name, ul.archive .name { font-size: 15px; font-weight: 600; text-decor ul.games .name:hover { text-decoration: underline; text-underline-offset: 3px; } ul.archive .name { color: var(--dim); } -/* The majority state of the catalogue, so it is the quiet word rather than the third pill. A badge - every row wears distinguishes no row from any other, and at 700 rows it is chrome. */ -ul.games .unclaimed { font: 10px/1 var(--kick); letter-spacing: 0.14em; text-transform: uppercase; color: var(--faint); } +/* No rule for "unclaimed": it is not on a row any more. The majority state of the catalogue said on + every row is an administrative fact about our records, repeated once per game at a reader looking + for somewhere to play. It stays on the game page, where it arrives with the way to change it. */ .row-text .tagline { margin: 2px 0 0; @@ -699,70 +1514,75 @@ ul.games .unclaimed { font: 10px/1 var(--kick); letter-spacing: 0.14em; text-tra white-space: nowrap; } -ul.games .meta, ul.archive .meta { margin: 3px 0 0; font-size: 11.5px; color: var(--faint); } +ul.games .meta, ul.archive .meta { margin: 3px 0 0; font-size: 12.5px; color: var(--dim); } ul.games .meta .protocol { white-space: nowrap; } +/* The protocols this row did not print. A count rather than a name, and the names are in its title + for a pointer and on the game's page for everybody. */ +ul.games .meta .protocol.more { color: var(--dim); } + /* A provenance chip on a listing or archive row. The chip's own age size is set for body copy, and these contexts are already smaller than that — so the age rides the row's size rather than growing larger than the text it qualifies. Everything else about the chip is unchanged, deliberately: the row, the archive and the game page have to be one vocabulary and not three that resemble each other. `.meta` is the class both lists give that line, so both are covered by naming it once. */ -.meta .chip .age, .row-figure .chip .age { font-size: inherit; } +.meta .chip .age { font-size: inherit; } + +/* ── the two measured columns ────────────────────────────────────────────── + Tabular figures so the counts line up down the page without a table, and right-aligned so the + units place is the edge the eye runs down. + + The count carries no unit and no provenance glyph. "on" after every number was one English word + repeated 515 times — the column is named once, above, which is also one string per locale rather + than five hundred — and where a number came from is a fact you weigh when choosing between two + games rather than while scanning five hundred, so it lives on the game page and on the facet + badges instead. */ -/* The measured column. Tabular figures so the counts line up down the page without a table. */ -.row-figure { +.row-count { margin: 0; + grid-column: 2; text-align: right; - font-size: 12px; white-space: nowrap; + font-size: 15px; font-variant-numeric: tabular-nums; - display: grid; - gap: 2px; - justify-items: end; + color: var(--text); } -/* ── the count, which is the fact most readers came for ──────────────────── - Players on now is a fact like any other and is labelled like any other — the glyph beside it means - measured or declared exactly as it does in every other column, because a second meaning for the - accent dot would cost it the first one. What sets it apart is scale and position, which carry no - meaning to lose: the number is 17px and nothing else in a row is above 15, so it is what the eye - lands on, and it sits at the head of a column that lines up down the page. - - The number's own weight then does the rest of the work. A count with somebody in it is at full - text colour; a measured zero is dimmed one step — still a measurement, still glyphed, still above - the break, and visibly not somewhere to go tonight. An unknown says so in words and is dimmer - again. Three states, three weights, no new colours. */ +/* Somebody is on. The one place a live count is marked as such, and the glow follows the digits + rather than a pip beside them. */ +.row-count.live { color: var(--accent); } -.row-figure .players { color: var(--text); display: block; } -.row-figure .players .count { font-size: 17px; font-weight: 600; letter-spacing: -0.01em; } -.row-figure .players .pip { margin-right: 5px; } +/* A measured zero: dimmed one step, never faint. We got in and nobody was there is a result, and + it is not the same fact as a count we could not read. */ +.row-count.empty { color: var(--dim); } -/* A count of nobody, measured. Dimmed rather than hidden — we got in and nobody was there is a - result, and the row above the break is where it belongs. */ -.row-figure .players.empty .count { color: var(--dim); font-weight: 400; } +/* Not a number at all, so it is not set as one: smaller, faint, and in words. */ +.row-count.unknown { color: var(--faint); font-size: 13.5px; font-variant-numeric: normal; } -/* The one place a live count is marked as such: a soft glow on the pip where somebody is actually on - right now. A text-shadow rather than a ring, because a ring is drawn on the glyph's inline box — - which is a tall narrow rectangle, not the dot — and rendered as a lozenge round a circle. This - follows the glyph itself at any font and any size. - - Static. Five hundred of these animating is a page that cannot be read, and the motion budget is - spent on the "came back" card. It is a reinforcement and never the carrier: the count, the glyph - and the word behind it all say the same thing without it. */ -.row-figure .players.live .pip.state-present { - text-shadow: 0 0 7px color-mix(in srgb, var(--accent) 60%, transparent); +.row-seen { + margin: 0; + grid-column: 3; + text-align: right; + white-space: nowrap; + font-size: 12.5px; + color: var(--faint); + font-variant-numeric: tabular-nums; } -/* The count's own chip rides beside the figure. Spaced in CSS and not by a space in the markup, - because the renderer trims whitespace around a conditional and "219 on" ran into its own glyph. */ -.row-figure .players .chip { margin-left: 6px; } -.row-figure .players .unit { color: var(--faint); } -.row-figure .players.unknown { color: var(--faint); } -.row-figure .seen { color: var(--faint); font-size: 11.5px; } - -/* What a window sort ranked this row on, printed on the row it ranked. Faint and small: it is the - basis for the order rather than a fact the row is about, and the count above it stays the figure. */ -.row-figure .window { color: var(--faint); font-size: 11.5px; } +/* + Claimed: a ring with a tick in it and no visible word. It was a pill the width of "claimed" on the + handful of rows that carry it — furniture for a fact a browsing reader did not come for. The name + is on the element, where a screen reader and a tooltip both reach it. +*/ +.claim-ring { + display: inline-flex; align-items: center; justify-content: center; + width: 16px; height: 16px; flex: none; + border-radius: 99px; + border: 1px solid color-mix(in srgb, var(--accent) 40%, transparent); + background: color-mix(in srgb, var(--accent) 12%, transparent); + color: var(--accent); + font: 10px/1 var(--mono); +} /* Archived: dimmed one step, and that is the whole treatment. No red, no strikethrough, no "dead" — the entry is a library record for a periodical that ceased publication. */ @@ -788,26 +1608,84 @@ li.unranked-break { li.unranked-break:hover { background: var(--surface); } -dl.archive-facts { margin: 0; font-size: 12px; min-width: 220px; } +/* + The archive row is two zones, not the listing's three — it has no count column, and its facts + panel is a definition list rather than two cells. It shares .row-main with the listing for the + gap and the baseline, so it names its own columns rather than inheriting a third it has nothing + to put in. +*/ +ul.archive .row-main { grid-template-columns: minmax(0, 1fr) auto; } + +dl.archive-facts { margin: 0; font-size: 12px; min-width: 200px; } dl.archive-facts dd { margin: 0 0 6px; color: var(--dim); } +/* Below the width where a 200px facts panel and a game's metadata both fit, they stack — the panel + was holding its minimum and clipping the name and codebase beside it. */ +@media (max-width: 620px) { + ul.archive .row-main { grid-template-columns: minmax(0, 1fr); } + dl.archive-facts { min-width: 0; } +} + /* ── the listing's own header ────────────────────────────────────────────── */ -.listing-head { margin-bottom: var(--cpad); } -.listing-head p { margin: 0; max-width: 62ch; } +/* The card's own header band: padded like the drawing, with a rule under it running the full + width of the card rather than stopping at a content measure. */ +.listing-head { + margin: 0; + padding: 22px var(--gutter) 18px; + border-bottom: 1px solid var(--line-soft); + display: flex; flex-direction: column; gap: 7px; +} +.listing-head h1 { margin: 0; } +.listing-head p { margin: 0; max-width: 62ch; font-size: 14px; } + +/* ── the listing's toolbar ───────────────────────────────────────────────── + What order this is in on the left, the control that changes it and the two column names on the + right, over the columns they name. */ .listing-bar { display: flex; align-items: baseline; - gap: var(--cpad); + justify-content: space-between; + gap: 12px 20px; flex-wrap: wrap; - margin: calc(var(--cpad) * 1.5) 0 4px; + margin: 0; + padding: 11px var(--gutter); + border-bottom: 1px solid var(--line-soft); + font-size: 13px; + color: var(--dim); } -.listing-bar .result-count { margin: 0; font-size: 13px; } -.listing-bar .result-count strong { font-size: 19px; font-weight: 600; } .listing-bar .listing-order { margin: 0; } -.listing-bar .listing-order a { color: var(--faint); } +.listing-bar .listing-order .order-name { color: var(--text); } +.listing-bar .listing-order .sep { margin: 0 6px; color: var(--faint); } +.listing-bar .listing-order a { color: var(--dim); } + +.listing-tools { display: flex; align-items: baseline; gap: 20px; } +.listing-tools .column-head { margin: 0; } + +/* ── a pressed-state toggle group ────────────────────────────────────────── + Not links to the page you are already reading. The one in force is a <span> with aria-current, so + there is no keystroke that lands on a control whose only effect is to re-fetch this page — the + same fix the trend range and shape selectors already carry. */ + +.switch { display: flex; align-items: baseline; gap: 8px; font-size: 12.5px; } +.switch a { color: var(--dim); text-decoration: none; } +.switch a:hover { color: var(--text); text-decoration: underline; text-underline-offset: 3px; } +.switch .on { color: var(--accent); } +/* A rule, not a wider gap: the two halves of the switch are different kinds of order — three that + change which measurement the column shows, and two that only change the stacking. */ +.switch .switch-rule { + width: 1px; height: 13px; align-self: center; margin: 0 2px; background: var(--line); +} + +/* The window under the statistic it belongs to, quieter than the switch that produced it. */ +.switch.windows { + padding: 8px var(--gutter); + border-bottom: 1px solid var(--line-soft); + font-size: 12px; + justify-content: flex-end; +} /* Nothing matched. A plate rather than a paragraph, because an empty listing is a state and not an @@ -829,9 +1707,25 @@ dl.archive-facts dd { margin: 0 0 6px; color: var(--dim); } /* ── one column below 900px; no horizontal scroll except inside the frame ── */ @media (max-width: 900px) { - .two-up, .feeds { grid-template-columns: minmax(0, 1fr); } - .game-head { flex-direction: column; } - header.site { flex-wrap: wrap; } + .feeds { grid-template-columns: minmax(0, 1fr); } + + /* + The theme control is the one thing in the bar that goes nowhere, so it is what the bar gives + up its words for first: three buttons become their initials' worth of room. + + Taken out of the drawing and left in the accessibility tree, because the form names itself + with `aria-labelledby="theme-label"` and this is that label. `display: none` removed it from + both, so below 900px a screen reader met three buttons in a group with no name at all — the + one width where the surrounding words that would have explained them are gone too. + */ + header.site form.theme .kick { + position: absolute; + width: 1px; height: 1px; + padding: 0; margin: -1px; + overflow: hidden; + clip-path: inset(50%); + white-space: nowrap; + } /* All 168 cells at 12px rather than a scrolling grid — the whole week at a glance is the reason @@ -933,7 +1827,22 @@ ul.sole-use-names { ul.sole-use-names li { color: var(--dim); } /* Wide content scrolls inside its own box; the page body never scrolls sideways. */ -.table-wrap { overflow-x: auto; margin: var(--cpad) 0; } +/* + A scroller contains its own absolutely positioned descendants — and until it did, the game page + scrolled sideways. + + `.sr-only` is `position: absolute`, and with no positioned ancestor its containing block was the + initial one: the text a screen reader reads out of the capability matrix was laid out at the + matrix's own width, 463px in German, *outside* this box and outside `.shell`'s `overflow-x: clip`. + So five spans nobody can see pushed the document 59px wider than a 360px phone, and the whole page + scrolled to reveal nothing. Visually-hidden is not the same as out of the layout, and one + `position: relative` is what makes the difference invisible in both directions. +*/ +.table-wrap { position: relative; overflow-x: auto; margin: var(--cpad) 0; } + +/* Inside a section that already spaces its children, the wrapper carries no margin of its own — + and it keeps the table's rounded frame from being clipped square by the scroll box. */ +.game-body .table-wrap { margin: 0; border-radius: var(--radius); } table.protocols, table.ranking { border-collapse: collapse; width: 100%; } table.protocols th, table.protocols td, @@ -981,13 +1890,12 @@ table.ranking tbody th { font-weight: 400; } is the only reason they are there. ═══════════════════════════════════════════════════════════════════════════ */ -form.facet-form { - border: 1px solid var(--line); - border-radius: 10px; - background: var(--surface); - padding: var(--cpad); - margin: 0 0 var(--cpad); -} +/* + No box. It was a panel on a page — border, radius, its own surface — and inside the card it became + a box within a box, fighting the hairline that already separates it from the rows. The column's + own edge is the separation; the form is just its contents. +*/ +form.facet-form { border: 0; background: none; padding: 0; margin: 0; } /* ── the bar ─────────────────────────────────────────────────────────────── */ @@ -995,7 +1903,58 @@ form.facet-form { The archive's own search box is the same control with a legend on it, so it is styled here rather than growing a second look for one question asked on two pages. */ -.filter-bar, fieldset.facets { +/* ── the panel, as one disclosure below 900px ────────────────────────────── + Above that width the summary is hidden and the content is forced open, so the same markup is a + column on a laptop and a disclosure on a phone with no second rendering and no script. + + Guarded on ::details-content: where a browser does not have it, forcing a closed <details> open + from CSS is not possible, so the summary stays visible at every width — a "filters" disclosure at + the top of the column rather than an unreachable panel behind a hidden control. */ + +.facet-collapse { min-width: 0; } +.facet-collapse > summary { + display: flex; align-items: center; gap: 8px; + cursor: pointer; list-style: none; + padding: 9px 8px; margin-bottom: 4px; + border: 1px solid var(--line); border-radius: var(--radius); + font: 10px/1 var(--kick); letter-spacing: 0.16em; text-transform: uppercase; + color: var(--dim); +} +.facet-collapse > summary::-webkit-details-marker { display: none; } +.facet-collapse > summary:hover { color: var(--text); border-color: var(--dim); } +.facet-collapse > summary::after { + content: "▾"; margin-left: auto; font-size: 11px; letter-spacing: normal; +} +.facet-collapse[open] > summary::after { content: "▴"; } +.facet-collapse .summary-count { + font-family: var(--mono); font-size: 11px; letter-spacing: normal; color: var(--accent); +} +.facet-body { display: flex; flex-direction: column; gap: 24px; } + +@supports selector(::details-content) { + @media (min-width: 901px) { + .facet-collapse > summary { display: none; } + .facet-collapse::details-content { content-visibility: visible; block-size: auto; } + } +} + +/* One field, and nothing else — the sort and the two inclusion switches that used to share this row + are a toolbar switch and two facet rows now. */ +.filter-bar { display: block; margin: 0; } +.filter-bar .search-field { padding: 0 8px 0 12px; } +.filter-bar .search-field input[type="search"] { padding: 7px 0; font-size: 13px; } + +/* The submit, inside the field. A 268px column has no room for a second box on that row, and a + submit that exists only as the return key is one a pointer-only reader cannot press. */ +.search-go { + flex: none; display: flex; align-items: center; justify-content: center; + width: 22px; height: 22px; padding: 0; + background: none; border: 0; border-radius: 6px; + color: var(--faint); font-size: 13px; cursor: pointer; +} +.search-go:hover { color: var(--text); background: var(--raised); } + +fieldset.facets { display: flex; gap: 10px; align-items: center; @@ -1004,7 +1963,7 @@ form.facet-form { fieldset.facets { border: 1px solid var(--line); - border-radius: 10px; + border-radius: var(--radius-lg); background: var(--surface); padding: var(--cpad); margin: 0 0 var(--cpad); @@ -1017,7 +1976,8 @@ fieldset.facets legend { color: var(--faint); } -.filter-bar input[type="search"], fieldset.facets input[type="search"] { flex: 1 1 16rem; min-width: 0; } +.filter-bar input[type="search"] { min-width: 0; width: 100%; } +fieldset.facets input[type="search"] { flex: 1 1 16rem; min-width: 0; } .bar-field { display: inline-flex; align-items: center; gap: 6px; } .bar-label { font: 10px/1 var(--kick); letter-spacing: 0.16em; text-transform: uppercase; color: var(--faint); } @@ -1030,39 +1990,125 @@ fieldset.facets legend { auto-fit at a narrow floor, so eight facets pack four to a row on a laptop, two on a tablet and one on a phone without a breakpoint being written for any of them. */ -.facet-grid { +/* ── the listing's two columns ───────────────────────────────────────────── + What you are asking on the left, what came back on the right. `stretch` so the filter column's + own edge runs the full height of the card: aligned to its content it stops under a short panel + and leaves a well beside the rows. */ + +.listing-grid { display: grid; - grid-template-columns: repeat(auto-fit, minmax(178px, 1fr)); - gap: 10px var(--cpad); - margin-top: var(--cpad); + grid-template-columns: minmax(0, 268px) minmax(0, 1fr); + align-items: stretch; + gap: 0; + margin: 0; } -/* The control sits at the bottom of its cell, so a label that wraps grows upward and every select in - the row stays on one line. Left to itself the grid aligns the tops, and one long facet name puts - one control half a row below its neighbours. */ +/* + Placed explicitly, and that is load-bearing: the panel renders TWO siblings into this grid — the + form, and the row of active-filter chips that sits outside it because a chip is a link and not a + control. Left to auto-placement the chips took the second column and the listing dropped to the + first, under a filter column a thousand pixels tall — so applying a filter looked like a page that + had lost its results. +*/ +/* + The filter column is a surface a step below the card, so it reads as a column even where its rows + run out — the border alone left it as an unmarked area of the same fill as the results beside it. +*/ +.listing-grid > .facet-form { + grid-column: 1; + grid-row: 1 / span 99; + background: var(--recessed); + border-right: 1px solid var(--line-soft); + + /* Less 8px than the gutter, because every row inside pads itself by that — which is what puts + a facet label on exactly the same left edge as the wordmark above it. */ + padding: 20px max(6px, calc(var(--gutter) - 8px)); + display: flex; + flex-direction: column; + gap: 24px; +} +.listing-grid > * { grid-column: 2; min-width: 0; } +.listing-side { min-width: 0; } +.listing-grid > .active-filters { padding: 12px var(--gutter) 0; margin: 0; } + +/* + ── the filter column, narrow ────────────────────────────────────────────── + A disclosure above the listing rather than eleven hundred pixels of open panel to scroll past + before the first game. Closed by default and open whenever the reader has actually asked + something, because a filter in force that nothing shows is the defect this control replaces. +*/ +@media (max-width: 900px) { + .listing-grid { grid-template-columns: minmax(0, 1fr); } + .listing-grid > * { grid-column: 1; } + .listing-grid > .facet-form { + grid-column: 1; grid-row: auto; + border-right: 0; + border-bottom: 1px solid var(--line-soft); + } + .listing-grid > .active-filters { padding: 12px var(--gutter) 0; } + + /* Two columns of groups where there is room for them, so the opened panel is a band rather + than a column a reader has to scroll the length of. */ + .facet-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(240px, 1fr)); gap: 24px; } +} + +/* In a 268px column the facets stack, one group per row. Twenty-four pixels between groups, which + is the panel's own rhythm and twice the gap between a group's header and its rows. */ +.facet-grid { + display: flex; + flex-direction: column; + gap: 24px; + margin: 0; +} + +/* A facet is a heading, a note and a list of rows. */ .facet { min-width: 0; - display: grid; - grid-template-rows: 1fr auto; - align-content: end; + display: flex; + flex-direction: column; + gap: 9px; + border: 0; + padding: 0; + margin: 0; } +/* + The header block sits at the rows' own left padding, so the group name, the note and every row + label share one left edge — which is the whole reason the rows are padded rather than the panel. +*/ .facet > label, .facet > legend { display: flex; - gap: 6px; - align-items: baseline; - flex-wrap: wrap; - margin-bottom: 3px; - padding: 0; + flex-direction: column; + gap: 3px; + margin: 0; + padding: 0 8px; + width: 100%; + box-sizing: border-box; +} + +.facet .facet-head { + display: flex; align-items: center; justify-content: space-between; gap: 8px; } .facet .facet-name { font: 10px/1.4 var(--kick); - letter-spacing: 0.14em; + letter-spacing: 0.16em; text-transform: uppercase; color: var(--dim); } +/* + The one sentence a group needs at the moment somebody uses it, under its own heading rather than + once at the foot of the panel — the three groups say three different things and the line that + used to serve all of them contradicted the first. +*/ +.facet-note { + margin: 0; + font-size: 12px; + line-height: 1.5; + color: var(--faint); +} + select { background: var(--recessed); border: 1px solid var(--line); @@ -1074,9 +2120,139 @@ select { .facet select { width: 100%; max-width: 100%; } -/* A facet that is doing something says so at rest, and not only in colour — the chip row above the - results names it in words, and the select's own text is the value it is set to. */ -.facet select.chosen { border-color: color-mix(in srgb, var(--accent) 45%, var(--line)); } +/* ── the three-state facet row ───────────────────────────────────────────── + Off, only, anything but — one row per value, and the state legible without opening anything. The + two radios are hidden and the glyph is drawn, but they are real radios: the browser's own group + behaviour is what makes this work with no script, and every state is a word in the accessible + name as well as a shape and a tint. */ + +.facet .rows { display: grid; gap: 2px; margin: 0; } + +/* + The row's geometry, and it is a grid rather than a flex run for one reason: every column has to + land in the same place on every row of every group. As a flex run the widest label in a group + pushed that group's count and exclude columns ten pixels right of every other group's — and past + the panel's own edge, which is what the audit measured as a 253px row inside a 243px box. + + 15px the state glyph + 1fr the value, which is the one cell allowed to give up width + auto the count, right-aligned against the 1fr's slack so every count shares an edge + 18px the exclusion, where a "remove" belongs +*/ +.facet-row { + display: grid; + grid-template-columns: minmax(0, 1fr) 18px; + align-items: center; + gap: 9px; + min-height: 30px; + padding: 0 8px; + border-radius: 9px; + font-size: 13.5px; + color: var(--dim); + border: 1px solid transparent; +} + +/* One ordered scale: no exclusion, so no column for one. */ +.facet-row.single { grid-template-columns: minmax(0, 1fr); } + +.facet-row .pick { + display: grid; + grid-template-columns: 15px minmax(0, 1fr) auto; + align-items: center; + gap: 9px; + min-width: 0; + cursor: pointer; +} +.facet-row .tick { text-align: center; color: var(--faint); font-family: var(--mono); font-size: 12px; } +.facet-row .row-name { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; } +/* + `--dim` rather than `--faint`, because the panel is not the page. + + `--faint` was raised to 4.8:1 once already, measured against the page background — and the facet + panel is a more recessed surface than that, where the same token falls to 4.09:1 in dark and + 4.37:1 in light. Both are under the 4.5:1 this site holds itself to, and both are carried by a + 12px number, which is the smallest text in the panel and the one a reader most needs to read. + Raising the token instead would have moved every age and provenance line on the site to fix a + contrast the page itself does not have. +*/ +.facet-row .count { + font-family: var(--mono); font-size: 12px; font-variant-numeric: tabular-nums; color: var(--dim); +} + +/* The exclusion affordance, at the far edge where a "remove" belongs. Quiet until it is the state + the row is in. */ +.facet-row .drop { + display: block; text-align: center; cursor: pointer; + color: var(--faint); font-family: var(--mono); font-size: 12.5px; +} +.facet-row .drop:hover { color: var(--text); } +/* Links, so a click applies the filter rather than arming a control that waits for a button. */ +.facet-row a { text-decoration: none; color: inherit; border-radius: var(--radius); } + +.facet-row:hover { background: var(--raised); } + +/* + A rung of a scale that this filter leaves empty. It stays — a bounded facet is four named + thresholds a reader picks between, and deleting the empty ones meant narrowing the codebase + silently removed two of activity's four rows and shifted the panel under the reader's pointer. It + is dimmed rather than disabled, because 0 is an answer: "no Evennia game was active this week" is + a fact about the catalogue, and clicking it lands on the listing's own empty state. +*/ +.facet-row.empty { opacity: 0.55; } +.facet-row.empty:hover { opacity: 1; } + +/* Included: the accent as a tint and a ring, and the count goes accent with the label — the number + is the part of the row that says what the filter will return, so it is the part that has to look + chosen. */ +.facet-row.on { + color: var(--accent-ink); + background: color-mix(in srgb, var(--accent) 12%, transparent); + border-color: color-mix(in srgb, var(--accent) 40%, transparent); +} +.facet-row.on .tick, .facet-row.on .count { color: var(--accent-ink); } +.facet-row.on:hover { background: color-mix(in srgb, var(--accent) 16%, transparent); } + +/* + Excluded: the danger tint, ring and strikethrough the handoff draws. + + Red is not a provenance colour here and never becomes one — it marks a state the reader put the + control into, not a state of the data. That is why nothing else on the site is red: the accent + means measured, amber means declared, and this means refused. +*/ +.facet-row.excluded { + color: var(--danger); + background: color-mix(in srgb, var(--danger) 10%, transparent); + border-color: color-mix(in srgb, var(--danger) 35%, transparent); +} +.facet-row.excluded .tick, .facet-row.excluded .count { color: var(--danger); } +.facet-row.excluded .row-name { + text-decoration: line-through; + text-decoration-color: color-mix(in srgb, var(--danger) 50%, transparent); +} +.facet-row.excluded .drop { color: var(--danger); } +.facet-row.excluded:hover { background: color-mix(in srgb, var(--danger) 14%, transparent); } + +/* The radios are hidden, so the focus ring belongs to the row that holds them. */ +.facet-row a:focus-visible { outline: 2px solid var(--accent); outline-offset: 2px; } + +/* The tail. A summary is a control, so it gets the row's own height and hit area. */ +.facet .facet-tail { margin-top: 2px; } +.facet .facet-tail summary { + cursor: pointer; padding: 4px 8px; font-size: 12px; color: var(--faint); border-radius: 9px; +} +.facet .facet-tail summary:hover { color: var(--text); background: var(--raised); } + +/* Said once, under the groups it applies to. */ +.facet-hint { margin: 12px 0 0; font-size: 11.5px; color: var(--dim); } + +/* The facets a reader goes looking for, rather than the three they arrive with. */ +.facet-more-groups { margin: 0; border-top: 1px solid var(--line-soft); padding-top: 14px; } +.facet-more-groups > summary { + cursor: pointer; font: 10px/1 var(--kick); letter-spacing: 0.16em; text-transform: uppercase; + color: var(--faint); padding: 4px 8px; border-radius: var(--radius); +} +.facet-more-groups > summary:hover { color: var(--text); background: var(--raised); } +.facet-more-groups .facet-grid { margin-top: 14px; } /* ── the presence facet ──────────────────────────────────────────────────── */ @@ -1088,11 +2264,15 @@ select { fieldset.facet.presence { border: 0; padding: 0; - margin: var(--cpad) 0 0; + margin: 0; min-width: 0; } -fieldset.facet.presence .checks { display: flex; flex-wrap: wrap; gap: 6px; } +fieldset.facet.presence .checks { + display: flex; flex-wrap: wrap; gap: 6px; min-width: 0; padding: 0 8px; +} +fieldset.facet.presence .check { max-width: 100%; } +fieldset.facet.presence .check .check-name { overflow-wrap: anywhere; min-width: 0; } fieldset.facet.presence .check { display: inline-flex; @@ -1110,9 +2290,6 @@ fieldset.facet.presence .check:hover { border-color: var(--dim); } fieldset.facet.presence .check:has(:checked) { border-color: color-mix(in srgb, var(--accent) 45%, var(--line)); } fieldset.facet.presence .check .count { color: var(--faint); font-variant-numeric: tabular-nums; } -/* Where the unticked-is-not-a-no sentence lives: inside the fieldset it is about, at the moment of - ticking, rather than in a key at the bottom of the panel. */ -fieldset.facet.presence .hint { margin: 6px 0 0; font-size: 11.5px; color: var(--faint); max-width: 62ch; } /* Measured, declared, and the one thing we concluded ourselves — three registers, never the only carrier of the difference, because the chip spells each out in words as well and colour is not a @@ -1137,25 +2314,28 @@ fieldset.facet.presence .hint { margin: 6px 0 0; font-size: 11.5px; color: var(- a title attribute: this is the difference the whole site exists to publish, and it stays in the document whether or not a pointer ever hovers anything. */ +/* + One line and one disclosure. The three-row provenance legend that used to stand here is behind the + disclosure now: every group wears its own evidence badge, which is where the word is actually + needed — before a filter is applied rather than after the panel has been read to the bottom. It + also wrapped its descriptions right-aligned, which is what a flex row does to a text node it did + not expect to break. +*/ .facet-key { display: flex; - flex-wrap: wrap; - gap: 4px 18px; - align-items: baseline; - margin-top: var(--cpad); - padding-top: 10px; - border-top: 1px solid var(--line); - font-size: 11.5px; + flex-direction: column; + gap: 8px; + margin: 0 8px; + padding-top: 14px; + border-top: 1px solid var(--line-soft); + font-size: 12px; color: var(--faint); + text-align: left; } -.facet-key .key-item { display: inline-flex; gap: 5px; align-items: baseline; } -.facet-key .facet-more { margin-left: auto; } -.facet-key summary { cursor: pointer; color: var(--dim); } - -.facet-key .facet-more[open] { flex: 1 0 100%; margin-left: 0; margin-top: 6px; } -.facet-key .facet-more ul { margin: 6px 0 0; padding-left: 1.2em; max-width: 72ch; } -.facet-key .facet-more li { margin-bottom: 5px; color: var(--dim); } +.facet-key summary { cursor: pointer; color: var(--dim); font-size: 11.5px; } +.facet-key .facet-more ul { margin: 8px 0 0; padding-left: 1.2em; } +.facet-key .facet-more li { margin-bottom: 6px; color: var(--dim); line-height: 1.5; } /* ── what the query is currently asking for ──────────────────────────────── */ @@ -1202,18 +2382,16 @@ fieldset.facet.presence .hint { margin: 6px 0 0; font-size: 11.5px; color: var(- /* ── the panel and the rows, narrow ──────────────────────────────────────── */ +/* + Narrow rows keep all three columns and all three stay aligned. They used to collapse into a flex + run under the name, which put the age beside the count on some rows and under it on others — the + same list drawn two ways down one screen. The name gives up width first, which is the one cell + that can spare it, and the two right-hand columns hold their edge. +*/ @media (max-width: 620px) { - /* The bar stacks: a search box sharing a row with a sort and a toggle has room for none of them. */ - .filter-bar input[type="search"] { flex: 1 0 100%; } - .filter-bar button { margin-left: auto; } - - /* The measured column goes under the name rather than fighting it for a width neither has — - under the name and not under the plate, so the row keeps the left edge the plate gives it and - the figure lines up with the text it belongs to. */ - .row-main { grid-template-columns: auto minmax(0, 1fr); } - .row-main .plate { grid-row: span 2; } - .row-figure { text-align: left; justify-items: start; margin-top: 4px; } - .row-figure { display: flex; gap: 12px; flex-wrap: wrap; align-items: baseline; } + .row-main { gap: 3px 12px; } + .row-count { font-size: 14px; } + .row-count.unknown { font-size: 12.5px; } } /* ── reference and orientation pages ─────────────────────────────────────── The hand-written section (spec §9). Two things it has to communicate that no @@ -1375,3 +2553,283 @@ ol.events .faint { margin-right: 8px; } details.resign form { margin-top: 6px; } details.resign input[type="text"] { display: block; margin: 6px 0; max-width: 16ch; } + +/* ── find a game ─────────────────────────────────────────────────────────── + The questions on the left, the count on the right, and the count still on + screen when the last question is answered — which is the whole premise of + this page. Until this block existed the page had no rule of its own at all: + it was the one surface left on user-agent form styling, drawn full-bleed + with 2px groove borders and 5px of padding. */ + +.find-grid { + display: grid; + grid-template-columns: minmax(0, 1fr) minmax(0, 310px); + align-items: stretch; + gap: 0; + margin: 0; + + /* + `clip`, never `hidden`. An ancestor with overflow: hidden is a scroll + container, and a sticky element can only travel inside its own — so the + panel would pin for a few hundred pixels and then scroll away for the + rest, leaving the count invisible while questions four to six were + answered. That is the exact failure this page was redrawn to fix, and + `clip` clips without establishing the container. + */ + overflow: clip; +} + +.find-questions { min-width: 0; grid-column: 1; } + +/* ── one question ───────────────────────────────────────────────────────── + 24 above the heading, 14 under it, 24 to the next rule. Symmetric outside, + tighter inside, so the heading binds to the options it labels and the + questions separate from each other. The numbers are on the elements + themselves rather than on a container: a <legend> renders on the border + edge and outside the padding box, which is why the drawing's own first + attempt produced 13px above the heading and 2px below it. */ + +.find-q { + padding: 24px var(--gutter); + border-top: 1px solid var(--line-soft); +} + +.find-q-head { + display: flex; + align-items: baseline; + justify-content: space-between; + gap: 12px; + margin: 0 0 14px; +} + +/* The question is a heading, so a screen reader can jump between the six and + the page has an outline. h2's own rhythm belongs to prose sections and + would fight the 24/14 above. */ +.find-q-head h2 { font-size: 16px; font-weight: 600; margin: 0; color: var(--text); } + +.find-opts { display: flex; flex-wrap: wrap; gap: 10px 8px; } + +/* + An option chip. 40px is the floor, not the height: a long gloss wraps and + the chip grows rather than clipping it. The row gap is deliberately larger + than the column gap — equal gaps make wrapped rows read as a grid instead of + as rows. +*/ +.find-opt { + display: inline-flex; + align-items: center; + gap: 9px; + min-height: 40px; + padding: 8px 14px; + border: 1px solid var(--line); + border-radius: var(--radius); + background: var(--raised); + color: var(--dim); + font-size: 13.5px; + text-decoration: none; + transition: background var(--dur) var(--ease), border-color var(--dur) var(--ease); +} + +.find-opt .tick { font-family: var(--mono); font-size: 12px; color: var(--faint); } +.find-opt .count { font-size: 12px; color: var(--faint); } +.find-opt:hover { background: color-mix(in srgb, var(--accent) 8%, var(--raised)); } +.find-opt:focus-visible { outline: 2px solid var(--accent); outline-offset: 2px; } + +/* Chosen: the tint, the ring and the count in the accent, because the number + is the part of the chip that says what answering will return. */ +.find-opt.on { + color: var(--accent); + background: color-mix(in srgb, var(--accent) 12%, transparent); + border-color: color-mix(in srgb, var(--accent) 45%, transparent); +} +.find-opt.on .tick, .find-opt.on .count { color: var(--accent); } + +/* The long tail. A summary is a control, so it gets a control's hit area. */ +.find-tail { margin-top: 10px; } +.find-tail > summary { + cursor: pointer; + display: inline-block; + padding: 6px 10px; + font-size: 12px; + color: var(--faint); + border-radius: var(--radius); +} +.find-tail > summary:hover { color: var(--text); background: var(--raised); } +.find-tail .find-opts { margin-top: 10px; } + +/* ── the name field ─────────────────────────────────────────────────────── + Label above the field, not beside it: beside it the field lost half the + column and a typed name could not be read back. */ + +.find-name { padding: 0 var(--gutter); margin: 0; } +.find-name label { display: block; margin-bottom: 8px; } +.find-name .search-field { max-width: 460px; } + +/* ── the count ──────────────────────────────────────────────────────────── + The outer cell carries the fill and the edge at full row height; the inner + wrapper is what sticks. Splitting the two is what lets the column read as a + column even where the panel is short. */ + +.find-panel { + grid-column: 2; + background: var(--recessed); + border-left: 1px solid var(--line-soft); + min-width: 0; +} + +.find-panel-inner { + position: sticky; + top: 20px; + display: flex; + flex-direction: column; + gap: 14px; + /* 24 at the top so the first line lands on the first question's heading. */ + padding: 24px 22px; +} + +.find-count { display: flex; align-items: baseline; gap: 8px; margin: 0; } + +.find-n { + font-size: 40px; + font-weight: 600; + line-height: 1; + color: var(--accent); + font-variant-numeric: tabular-nums; +} + +.find-noun { font-size: 13.5px; color: var(--dim); } +.find-basis { margin: 0; font-size: 12px; color: var(--faint); } + +.find-chips { display: flex; flex-wrap: wrap; gap: 6px; } + +.find-chip { + display: inline-flex; + align-items: center; + gap: 7px; + padding: 5px 11px; + border: 1px solid var(--line); + border-radius: var(--radius-pill); + background: var(--raised); + color: var(--dim); + font-size: 12px; + text-decoration: none; + max-width: 100%; +} +.find-chip .chip-value { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; } +.find-chip .chip-x { color: var(--faint); } +.find-chip:hover { color: var(--text); border-color: var(--dim); } + +/* + The way out of a combination that returned almost nothing. Quiet on purpose: + no amber, no warning box, no sentence about the result being narrow. The + reader can see the count; this is the one thing they cannot work out. +*/ +.find-loosen { + display: inline-flex; + align-items: center; + gap: 7px; + padding: 8px 12px; + border: 1px dashed var(--line); + border-radius: var(--radius); + color: var(--dim); + font-size: 12.5px; + text-decoration: none; +} +.find-loosen:hover { color: var(--text); border-color: var(--dim); background: var(--raised); } + +/* The one accented control on the page, and it is a link: it navigates to the + listing with this question asked, and nothing here is a form to fire. */ +.find-go { + display: block; + padding: 11px 16px; + border-radius: var(--radius); + border: 1px solid color-mix(in srgb, var(--accent) 55%, transparent); + background: color-mix(in srgb, var(--accent) 14%, transparent); + box-shadow: var(--glow); + color: var(--accent); + font-size: 14px; + font-weight: 600; + text-align: center; + text-decoration: none; +} +.find-go:hover { background: color-mix(in srgb, var(--accent) 22%, transparent); } +.find-go:focus-visible { outline: 2px solid var(--accent); outline-offset: 2px; } + +.find-clear { margin: 0; font-size: 12px; } +.find-clear a { color: var(--faint); } +.find-clear a:hover { color: var(--text); } + +/* + ── the panel, narrow ───────────────────────────────────────────────────── + The drawing has no responsive treatment and cannot be followed here: at + 430px its own grid crushes the question column to 139px while the panel + keeps all 310. So the panel stacks — above the questions, because the count + is the thing the page exists to show and putting it under six questions + would mean scrolling past every one of them to find out what they returned. + It stays sticky at the top of the viewport, which is the same promise the + side column makes at a width that has room for one. +*/ +@media (max-width: 860px) { + .find-grid { grid-template-columns: minmax(0, 1fr); } + .find-questions, .find-panel { grid-column: 1; } + + /* + Below the questions in the visual order because it is below them in the + DOM, and a column that disagrees with the tab order is a worse answer + than a long page. It sticks to the *bottom* instead of the top, which + keeps the same promise from the other end: the count and the submit are + on screen while the last question is being answered, without a reader + having to find them again afterwards. + */ + .find-panel { + border-left: 0; + border-top: 1px solid var(--line-soft); + position: sticky; + bottom: 0; + } + + /* + Laid across rather than down, because a bar pinned to the bottom of a + phone spends every pixel it takes: short controls share a line, so the + whole panel costs four rows with two answers given rather than seven. + + A wrapping row *in document order*, and that part is not cosmetic. This + was a two-column bar with the call to action pinned right and spanning + three rows, which put it first to the eye and fourth to the keyboard: + tabbing ran chips, loosen, then 114px back up the screen to the button. + Flex-wrap packs the same controls in the order they are written, so the + focus ring only ever travels forwards. + */ + .find-panel-inner { + position: static; + display: flex; + /* The base rule stacks; this is the one place the direction changes, and + leaving it out gives a centred column that reads as a broken card. */ + flex-direction: row; + flex-wrap: wrap; + align-items: center; + gap: 8px 12px; + padding: 12px var(--gutter); + } + + /* + The kicker labels a column, and this is a bar. The sub-line beside the + count says the same thing in more words, and the sentence a screen reader + is given — "2 games match every answer" — is untouched, so nothing is + lost that was only being carried here. + */ + .find-panel-inner > .kicker { display: none; } + + .find-chips { flex: 0 1 auto; } + .find-go { padding: 9px 14px; } + .find-n { font-size: 28px; } + + /* + The bar is pinned over the foot of the viewport, and a browser scrolling a + newly focused option into view does not know it is there — so tabbing down + the last question lands the focus ring behind the panel. `scroll-padding` + is the scriptless way to tell it, and `:has` is what keeps the rule on the + one page that has a bar rather than on every scroll on the site. + */ + html:has(.find-page) { scroll-padding-bottom: 200px; } +} diff --git a/tests/MUI.Catalog.Tests/AdultListingTests.cs b/tests/MUI.Catalog.Tests/AdultListingTests.cs index d8b76a0..0a0ed14 100644 --- a/tests/MUI.Catalog.Tests/AdultListingTests.cs +++ b/tests/MUI.Catalog.Tests/AdultListingTests.cs @@ -33,7 +33,13 @@ private static GameFacetRow Row(string slug, string? genre = null, bool adult = Codebase: "Evennia", Family: null, Genre: genre, - IsAdult: adult); + IsAdult: adult, + + // Every game here answered and was counted. The adult switch is what this suite is + // about, and a row that was also uncounted would put a second reason in front of the + // one being asserted. + Uncounted: false, + Unreachable: false); private static readonly GameFacetRow[] Catalogue = [ diff --git a/tests/MUI.Catalog.Tests/FacetPolarityTests.cs b/tests/MUI.Catalog.Tests/FacetPolarityTests.cs index d1988ce..fe6c4a3 100644 --- a/tests/MUI.Catalog.Tests/FacetPolarityTests.cs +++ b/tests/MUI.Catalog.Tests/FacetPolarityTests.cs @@ -173,7 +173,9 @@ private static GameListing Search(GameFilter filter) => Codebase: game.Codebase, Family: null, Genre: null, - IsAdult: false); + IsAdult: false, + Uncounted: false, + Unreachable: false); private static GameSummary Game(string slug, string? codebase) => new( Guid.NewGuid(), slug, slug, null, LifecycleState.Active, IsClaimed: false, diff --git a/tests/MUI.Catalog.Tests/FacetedSearchTests.cs b/tests/MUI.Catalog.Tests/FacetedSearchTests.cs index ea5e2ed..5a26de2 100644 --- a/tests/MUI.Catalog.Tests/FacetedSearchTests.cs +++ b/tests/MUI.Catalog.Tests/FacetedSearchTests.cs @@ -24,7 +24,9 @@ private static GameFacetRow Row( string? charset = null, bool tls = false, DateTimeOffset? lastReachableAt = null, - string[]? protocols = null) + string[]? protocols = null, + bool uncounted = false, + bool unreachable = false) { var summary = new GameSummary( Guid.NewGuid(), slug, slug, Tagline: null, LifecycleState.Active, IsClaimed: false, @@ -43,7 +45,12 @@ private static GameFacetRow Row( // Adult content has its own suite (AdultListingTests). Every row here declares none, so // these counts are taken over the whole set and are not quietly shaped by that default. - IsAdult: false); + IsAdult: false, + + // Both default to false, so a row is a game we reached and counted unless a test says + // otherwise — the ordinary case, and the one every count in this file is taken over. + uncounted, + unreachable); } private static FacetGroup Group(GameListing listing, string key) => @@ -213,7 +220,12 @@ public async Task NeverReachedIsItsOwnBandAndNotTheOldestOne() null), ActivityBand.Dark, FacetedSearch.LastSeenOf(null, Now), - false, null, null, null, null, null, false), + false, null, null, null, null, null, false, + + // Never once reached, so unreachable — and NOT uncounted, because we hold no + // presence row for it at all. Naming a cause for that is what rule 2 forbids. + Uncounted: false, + Unreachable: true), ]; await Assert.That(FacetedSearch.LastSeenOf(null, Now)).IsEqualTo(LastSeenBand.Never); @@ -371,10 +383,145 @@ public async Task OneGamesCapitalisationDoesNotNameAValue() await Assert.That(codebase.Count).IsEqualTo(3); } + // ── what we could measure ──────────────────────────────────────────────────────────────── + + /// <summary> + /// The set these four rows describe, once, so every assertion below is about the same catalogue. + /// </summary> + /// <remarks> + /// <b>The first two are the whole point.</b> <c>zero</c> is a game we got into and counted + /// nobody in, and <c>unreadable</c> is a game we got into and could not count at all. Both sit in + /// <see cref="ActivityBand.Quiet"/> — the band cannot tell them apart, which is why these facets + /// exist — and only the second is uncounted. <c>gone</c> is the third state twice over: never + /// reached, and with nothing measured to be uncounted about. + /// </remarks> + private static GameFacetRow[] Measured() => + [ + Row("zero", band: ActivityBand.Quiet, genre: "Fantasy"), + Row("unreadable", band: ActivityBand.Quiet, genre: "Fantasy", uncounted: true), + Row("busy", genre: "Historical"), + Row("gone", band: ActivityBand.Dark, genre: "Fantasy", + lastReachableAt: Now.AddDays(-90), unreachable: true), + ]; + + [Test] + public async Task AGameMeasuredAtZeroIsNotUncounted() + { + // The failure this facet was written to make impossible. A measured nought is a count — we + // got in and nobody was there (rule 2) — and it shares an activity band with a game whose + // every WHO was past our parser. A filter that returned both under a word meaning the second + // would publish our own parser's limits as somebody's empty game. + var rows = Measured(); + + var uncounted = FacetedSearch.Search(rows, new GameFilter { Uncounted = FacetChoice.Of(FacetTokens.Yes) }); + + await Assert.That(uncounted.Games.Select(g => g.Slug)).IsEquivalentTo(new[] { "unreadable" }); + + // And both are still in the band, which is the band being right rather than the facet being + // redundant with it. + var quiet = FacetedSearch.Search(rows, new GameFilter { Band = ActivityBand.Quiet }); + + await Assert.That(quiet.Games.Select(g => g.Slug)).IsEquivalentTo(new[] { "zero", "unreadable" }); + } + + [Test] + public async Task AGameWeHaveNotMeasuredIsNeitherUncountedNorCounted() + { + // §5.4's third state, which names no cause. `gone` has no presence rows at all, so it is not + // uncounted — the facet says "we tried and could not read", and claiming that of a game we + // never got into would be the same fabrication in the other direction. + var rows = Measured(); + + var uncounted = FacetedSearch.Search(rows, new GameFilter { Uncounted = FacetChoice.Of(FacetTokens.Yes) }); + var unreachable = FacetedSearch.Search(rows, new GameFilter { Unreachable = FacetChoice.Of(FacetTokens.Yes) }); + + await Assert.That(uncounted.Games.Any(g => g.Slug == "gone")).IsFalse(); + await Assert.That(unreachable.Games.Select(g => g.Slug)).IsEquivalentTo(new[] { "gone" }); + } + + [Test] + public async Task TheTwoSwitchesComposeWithEachOtherAndWithAnUnrelatedFacet() + { + // The reason they are two FacetChoices rather than two values of `band`: a reader narrowing + // by genre has to be able to drop both kinds of unmeasured game without spending the one + // selection `band` has. Three questions at once, and all three applied. + var rows = Measured(); + + var listing = FacetedSearch.Search(rows, new GameFilter + { + Genre = FacetChoice.Of("Fantasy"), + Uncounted = FacetChoice.Not(FacetTokens.Yes), + Unreachable = FacetChoice.Not(FacetTokens.Yes), + }); + + // Fantasy, minus the one we could not read and the one we could not reach — leaving the + // measured nought, which is a game we counted and must survive both exclusions. + await Assert.That(listing.Games.Select(g => g.Slug)).IsEquivalentTo(new[] { "zero" }); + } + + [Test] + public async Task ExcludingBothStillLeavesAListingThatExplainsItself() + { + // Hiding is a decision about the listing, so the controls that made it have to stay + // reachable — a selection whose only affordance has vanished is the defect the whole panel + // was rebuilt to remove. Both rows survive at the count their own selection returns. + var rows = Measured(); + + var listing = FacetedSearch.Search(rows, new GameFilter + { + Uncounted = FacetChoice.Not(FacetTokens.Yes), + Unreachable = FacetChoice.Not(FacetTokens.Yes), + }); + + await Assert.That(listing.Games.Select(g => g.Slug)).IsEquivalentTo(new[] { "zero", "busy" }); + + foreach (var key in new[] { FacetKeys.Uncounted, FacetKeys.Unreachable }) + { + var value = Value(listing, key, FacetTokens.Yes); + + await Assert.That(value.State).IsEqualTo(FacetState.Excluded); + await Assert.That(value.Count).IsEqualTo(1); + } + } + + [Test] + public async Task TheCountBesideEachSwitchIsWhatChoosingItReturns() + { + // The panel's own promise, made over the set that has both hard states in it. The generic + // walk above covers this too; this one names the facets, so a change that made the counts + // fall out of a wider denominator fails here with the right words on it. + var rows = Measured(); + var listing = FacetedSearch.Search(rows, new GameFilter()); + + foreach (var key in new[] { FacetKeys.Uncounted, FacetKeys.Unreachable }) + { + var value = Value(listing, key, FacetTokens.Yes); + + await Assert.That(value.Count).IsEqualTo(1); + await Assert.That(FacetedSearch.Search(rows, Choose(key, value.Token)).Games.Count) + .IsEqualTo(value.Count); + } + } + + [Test] + public async Task ASwitchNothingMatchesIsNotDrawnAtAll() + { + // A bounded facet keeps every rung of a scale, because a scale with a rung missing is not + // the same scale. This is not a scale — it is one fact, held or not — so a catalogue we + // could count and reach in full offers no control, which is the honest rendering of a + // measurement with nothing in it. + var listing = FacetedSearch.Search([Row("busy"), Row("also")], new GameFilter()); + + await Assert.That(listing.Facets.Any(f => f.Key == FacetKeys.Uncounted)).IsFalse(); + await Assert.That(listing.Facets.Any(f => f.Key == FacetKeys.Unreachable)).IsFalse(); + } + private static GameFilter Choose(string key, string token) => key switch { FacetKeys.Band => new GameFilter { Band = Band(token) }, FacetKeys.LastSeen => new GameFilter { LastSeen = Seen(token) }, + FacetKeys.Uncounted => new GameFilter { Uncounted = FacetChoice.Parse(token) }, + FacetKeys.Unreachable => new GameFilter { Unreachable = FacetChoice.Parse(token) }, FacetKeys.Protocol => new GameFilter { MeasuredProtocols = [token] }, FacetKeys.Tls => new GameFilter { Tls = true }, FacetKeys.Charset => new GameFilter { Charset = FacetChoice.Parse(token) }, diff --git a/tests/MUI.Catalog.Tests/Persistence/FacetQueriesPostgresTests.cs b/tests/MUI.Catalog.Tests/Persistence/FacetQueriesPostgresTests.cs index 3ebf947..53ea769 100644 --- a/tests/MUI.Catalog.Tests/Persistence/FacetQueriesPostgresTests.cs +++ b/tests/MUI.Catalog.Tests/Persistence/FacetQueriesPostgresTests.cs @@ -280,10 +280,116 @@ await Assert.That(games.Count) } } + [Test] + public async Task AMeasuredZeroIsNotUncountedAndTheBandCannotTellThemApart() + { + // The one this facet exists for, against the reader that actually computes it. + // + // Both games are reachable, both have no count above nought this week, and both therefore + // land in `quiet` — the band is one threshold and cannot say why. `empty` was probed and + // answered nought, which is a measurement of theirs; `unreadable` was probed and produced no + // number, which is a limit of ours. Returning the first under a word meaning the second is + // rules 2, 4 and 5 in one control, and the digest threw the distinction away until now. + await using var db = await PostgresFixture.MigratedAsync(); + var empty = await Seed.GameAsync(db, "empty", "Measured empty", lastReachableAt: Now); + var unreadable = await Seed.GameAsync(db, "unreadable", "Unreadable", lastReachableAt: Now); + var writer = new PresenceWriter(new NpgsqlPresenceStore(db.DataSource)); + + // Three probes each, over the same hours, differing only in what came back. + foreach (var hours in new[] { 1, 20, 60 }) + { + await writer.WriteAsync( + empty, PresenceReading.Counted(0, FieldSource.Who), Now.AddHours(-hours)); + await writer.WriteAsync( + unreadable, + PresenceReading.Unmeasurable(UnmeasurableReason.WhoUnparseable), + Now.AddHours(-hours)); + } + + var queries = QueriesOn(db); + + var quiet = await queries.ListAsync(new GameFilter { Band = ActivityBand.Quiet }); + await Assert.That(quiet.Select(g => g.Slug)).IsEquivalentTo(new[] { "empty", "unreadable" }); + + var uncounted = await queries.ListAsync( + new GameFilter { Uncounted = FacetChoice.Of(FacetTokens.Yes) }); + await Assert.That(uncounted.Select(g => g.Slug)).IsEquivalentTo(new[] { "unreadable" }); + + // And the count each game's row carries agrees: nought is a number, and the other is null. + var listed = await queries.ListAsync(new GameFilter()); + await Assert.That(listed.Single(g => g.Id == empty).PlayersNow).IsEqualTo(0); + await Assert.That(listed.Single(g => g.Id == unreadable).PlayersNow).IsNull(); + } + + [Test] + public async Task AGameWithNoPresenceRowsAtAllIsNotUncounted() + { + // §5.4's third state. A probe that failed writes no presence row (`PresenceWriter`), so a + // game with nothing stored is one we did not measure — and "we tried and could not read it" + // is a cause, which that state may not be given. It is unreachable instead, from the + // availability series, which can tell the two apart. + await using var db = await PostgresFixture.MigratedAsync(); + await Seed.GameAsync(db, "never", "Never answered", lastReachableAt: null); + var probed = await Seed.GameAsync(db, "probed", "Probed", lastReachableAt: Now); + var writer = new PresenceWriter(new NpgsqlPresenceStore(db.DataSource)); + + await writer.WriteAsync( + probed, PresenceReading.Unmeasurable(UnmeasurableReason.WhoLoginPrompt), Now.AddHours(-2)); + + var queries = QueriesOn(db); + + await Assert.That( + (await queries.ListAsync(new GameFilter { Uncounted = FacetChoice.Of(FacetTokens.Yes) })) + .Select(g => g.Slug)) + .IsEquivalentTo(new[] { "probed" }); + + await Assert.That( + (await queries.ListAsync(new GameFilter { Unreachable = FacetChoice.Of(FacetTokens.Yes) })) + .Select(g => g.Slug)) + .IsEquivalentTo(new[] { "never" }); + } + + [Test] + public async Task TheTwoSwitchesNarrowTogetherAndTheCountsSayWhatTheyReturn() + { + // Orthogonal, and orthogonal to the rest of the panel: excluding both leaves the games we + // measured, with the two controls still drawn so the reader can undo what they did. + await using var db = await PostgresFixture.MigratedAsync(); + var counted = await Seed.GameAsync(db, "counted", "Counted", lastReachableAt: Now); + var unreadable = await Seed.GameAsync(db, "unreadable", "Unreadable", lastReachableAt: Now); + await Seed.GameAsync(db, "gone", "Gone", lastReachableAt: Now.AddDays(-90)); + var writer = new PresenceWriter(new NpgsqlPresenceStore(db.DataSource)); + + await writer.WriteAsync(counted, PresenceReading.Counted(4, FieldSource.Who), Now.AddHours(-1)); + await writer.WriteAsync( + unreadable, PresenceReading.Unmeasurable(UnmeasurableReason.I3NoReply), Now.AddHours(-1)); + + var queries = QueriesOn(db); + + var kept = await queries.SearchAsync(new GameFilter + { + Uncounted = FacetChoice.Not(FacetTokens.Yes), + Unreachable = FacetChoice.Not(FacetTokens.Yes), + }); + + await Assert.That(kept.Games.Select(g => g.Slug)).IsEquivalentTo(new[] { "counted" }); + + foreach (var key in new[] { FacetKeys.Uncounted, FacetKeys.Unreachable }) + { + var value = Group(kept, key)!.Values.Single(v => v.Token == FacetTokens.Yes); + + await Assert.That(value.State).IsEqualTo(FacetState.Excluded); + await Assert.That((await queries.ListAsync(Choose(key, value.Token))).Count) + .IsEqualTo(value.Count); + } + } + private static GameFilter Choose(string key, string token) => key switch { FacetKeys.Band => new GameFilter { Band = Band(token) }, FacetKeys.LastSeen => new GameFilter { LastSeen = Seen(token) }, + FacetKeys.Uncounted => new GameFilter { Uncounted = FacetChoice.Parse(token) }, + FacetKeys.Unreachable => new GameFilter { Unreachable = FacetChoice.Parse(token) }, FacetKeys.Protocol => new GameFilter { MeasuredProtocols = [token] }, FacetKeys.Tls => new GameFilter { Tls = true }, FacetKeys.Charset => new GameFilter { Charset = FacetChoice.Parse(token) }, diff --git a/tests/MUI.Web.Tests/AboutPageTests.cs b/tests/MUI.Web.Tests/AboutPageTests.cs index 2f6d462..9e8b1b2 100644 --- a/tests/MUI.Web.Tests/AboutPageTests.cs +++ b/tests/MUI.Web.Tests/AboutPageTests.cs @@ -10,6 +10,7 @@ using MUI.Discovery; using MUI.Web.Api; using MUI.Web.Components; +using MUI.Web.Localization; namespace MUI.Web.Tests; @@ -34,6 +35,21 @@ public class AboutPageTests private static string Plain => PlainText.RenderAbout(Page); + /// <summary> + /// The English a message id carries, which is what this page is asserted against. + /// </summary> + /// <remarks> + /// The copy lives in <see cref="Messages"/> now, so a sentence pasted into a test would be a + /// third copy of it — and the one nothing checks. Asking the bundle asserts the fact this page + /// makes a claim about ("the archive-grace limitation is stated") rather than the spelling of + /// it, and still fails if the id stops reaching the page. Where a claim is a <em>rule</em> + /// rather than a sentence — the refusal to say "no automated opt-out" — the literal stays, + /// because there the wording is the rule. A rule about the site's <em>vocabulary</em> is the one + /// case where a literal on this page is wrong: it belongs over the whole bundle in every locale, + /// which is where <see cref="NoMessageOutsideTheseTwoRefusalsUsesTheWordUptime"/> puts it. + /// </remarks> + private static string Says(string id) => Messages.For(Locales.SourceTag, id); + [Test] public async Task EveryDirectoryTheBackfillReadIsCreditedByNameAndByAddress() { @@ -59,13 +75,17 @@ public async Task ASourceWeChoseNotToFetchIsCreditedAndSaidToBeUnread() var mudverse = Page.Sources.Single(s => s.Name == "MudVerse"); await Assert.That(mudverse.State).IsEqualTo(ImportSourceState.Withheld); - await Assert.That(Plain).Contains("not read — awaiting permission"); + await Assert.That(Plain).Contains(Says("about.source.withheld")); + + // And the badge for one we did read is a different string, not a negation of this one: a + // reader meets the difference between "we chose not to" and "we could not" only here. + await Assert.That(Says("about.source.read")).IsNotEqualTo(Says("about.source.withheld")); } [Test] public async Task TheAttributionSaysAddressesOnlyAndSaysWhy() { - await Assert.That(Render.Words(Plain)).Contains("We take addresses. Nothing else."); + await Assert.That(Render.Words(Plain)).Contains(Says("about.sources.addresses.lead")); await Assert.That(Render.Words(Plain)).Contains("No player counts"); await Assert.That(Render.Words(Plain)).Contains("no reachability history"); } @@ -131,12 +151,13 @@ public async Task AnUnconfiguredContactAddressIsMarkedAsThePlaceholderItIs() { // The built-in URL is on a domain nobody has chosen. Printed unmarked it would read as the // way to reach us, which is the one thing this section exists to provide. - await Assert.That(Render.Words(Plain)).Contains("is a placeholder and answers nobody"); + await Assert.That(Render.Words(Plain)).Contains(Says("about.identity.placeholder.plain")); var configured = PlainText.RenderAbout(AboutPage.Build( new ProbeOptions { InfoUrl = "https://example.test/crawler" }, new DatasetLicenceOptions())); - await Assert.That(Render.Words(configured)).DoesNotContain("is a placeholder and answers nobody"); + await Assert.That(Render.Words(configured)) + .DoesNotContain(Says("about.identity.placeholder.plain")); } [Test] @@ -182,7 +203,7 @@ public async Task ThePoliteAndSecurityFactsAboutAProbeSurvive() { var text = Render.Words(Plain); - await Assert.That(text).Contains("CRAWL DELAY wins."); + await Assert.That(text).Contains(Says("about.crawler.delay.lead")); await Assert.That(text).Contains("resolved before anything is dialled"); await Assert.That(text).Contains("globally routable"); } @@ -203,27 +224,87 @@ public async Task TheMeasuredSpineSurvivesInWords() { var text = Render.Words(Plain); - await Assert.That(text).Contains("Measured beats declared, and both are shown."); + await Assert.That(text).Contains(Says("about.measures.declared.lead")); await Assert.That(text).Contains("MSSP PLAYERS field"); await Assert.That(text).Contains("WHO or DOING read at the connect screen"); await Assert.That(text).Contains("unknown, never zero"); } + /// <summary> + /// The page explains what reachability is, in whatever language it is being read in. + /// </summary> + /// <remarks> + /// <para> + /// <b>This used to count the English word "uptime" and require exactly two of it.</b> That was a + /// reasonable guard while the page was a C# string and an unreasonable one the moment it became + /// a translation: a Japanese or Chinese rendering of the same two refusals contains the token + /// zero times and would fail, and a German one contains it twice by a coincidence of loanwords + /// rather than because the rule held. Worse, the assertion made the *presence* of the forbidden + /// word the thing under test, so the page's vocabulary rule was guarded by requiring the + /// vocabulary to be broken. + /// </para> + /// <para> + /// The rule survives, split from the spelling. Here: the two refusal ids reach the page, asked + /// of the bundle, so this holds in every locale. And in + /// <see cref="NoMessageOutsideTheseTwoRefusalsUsesTheWordUptime"/>: the word appears in no other + /// message, in no locale — which is the rule itself ("reachable, never uptime", in copy), + /// checked over the whole bundle rather than inferred from one page's word count. + /// </para> + /// </remarks> [Test] - public async Task ReachableIsExplainedAndNeverCalledUptimeExceptToRefuseTheWord() + public async Task ReachableIsExplainedInWhateverLanguageThePageIsRead() { var text = Render.Words(Plain); - await Assert.That(text).Contains("Reachable, never uptime."); + await Assert.That(text).Contains(Says("about.measures.reachable.lead")); + await Assert.That(text).Contains(Says("about.measures.reachable.body")); - // The word appears twice and both are refusals. Anything else would be the site's own - // vocabulary rule broken on the page that states it. - var uses = Regex.Matches(text, "uptime", RegexOptions.IgnoreCase).Count; - await Assert.That(uses).IsEqualTo(2); + // The substance of the refusal, which is what the rule is for: the measurement is of our + // socket from our host, and an unreachable game may be perfectly alive. await Assert.That(text).Contains("unreachable and perfectly alive"); await Assert.That(text).Contains("nothing here measured it"); } + /// <summary> + /// "Reachable, never uptime" — over the bundle, in every locale, rather than over one page. + /// </summary> + /// <remarks> + /// The two about-page ids are the whole exemption: they are the sentences that name the word in + /// order to refuse it, and they are the only place on the site allowed to. Every other id is + /// checked in every bundle a reader can be served, so a translator who reaches for the loanword + /// in a reachability string fails this rather than shipping it — which a rendered-English word + /// count could never have caught. + /// </remarks> + [Test] + public async Task NoMessageOutsideTheseTwoRefusalsUsesTheWordUptime() + { + string[] refusals = ["about.measures.reachable.lead", "about.measures.reachable.body"]; + + var tags = Locales.All + .Select(locale => locale.Tag) + .Append(Locales.SourceTag) + .Distinct(StringComparer.OrdinalIgnoreCase) + .ToArray(); + + await Assert.That(tags).IsNotEmpty(); + + foreach (var tag in tags) + { + foreach (var id in Messages.Ids.Except(refusals, StringComparer.Ordinal)) + { + var pattern = Messages.Pattern(tag, id) ?? string.Empty; + + await Assert.That(pattern.Contains("uptime", StringComparison.OrdinalIgnoreCase)) + .IsFalse() + .Because($"{id} says \"uptime\" in {tag}; the word here is reachable"); + } + } + + // And the exemption is real rather than vacuous: the English refusals do use the word, which + // is what makes them refusals and not silence. + await Assert.That(Says("about.measures.reachable.lead").ToLowerInvariant()).Contains("uptime"); + } + [Test] public async Task TheThingsThisSiteWillNotDoAreStatedRatherThanImplied() { @@ -231,10 +312,10 @@ public async Task TheThingsThisSiteWillNotDoAreStatedRatherThanImplied() // they are absent. PlainParityTests asserts the opposite about every other surface. var text = Render.Words(Plain); - await Assert.That(text).Contains("No votes, stars, ratings or recommendations"); - await Assert.That(text).Contains("No forums, reviews, wikis, comments or player profiles"); - await Assert.That(text).Contains("Player names are never persisted."); - await Assert.That(text).Contains("No absolute population figure is published."); + await Assert.That(text).Contains(Says("about.never.votes.lead")); + await Assert.That(text).Contains(Says("about.never.forums.lead")); + await Assert.That(text).Contains(Says("about.never.names.lead")); + await Assert.That(text).Contains(Says("about.never.population.lead")); } [Test] @@ -242,7 +323,7 @@ public async Task TheDataLicenceIsPresentedAsUndecidedRatherThanAsSettled() { var text = Render.Words(Plain); - await Assert.That(text).Contains("The code is MIT."); + await Assert.That(text).Contains(Says("about.licence.code.lead")); await Assert.That(text).Contains("licence for the data is an open question"); await Assert.That(text).Contains("not yet taken"); @@ -295,6 +376,58 @@ public async Task TheGraphicalPageCarriesEverySentenceThePlainOneDoes() } } + /// <summary> + /// Every sentence on this page comes out of the bundle, and the machine voice does not. + /// </summary> + /// <remarks> + /// <para> + /// The pseudolocale accents and brackets every string that reached a reader through + /// <see cref="Messages"/>, so anything still legible as English here is a sentence typed into a + /// page — which is what the whole of this page was until it was moved. This was the largest + /// untranslated surface on the site, and the one it would be worst to leave: it is where the + /// site explains what a measurement here proves, to a reader who by definition does not yet + /// trust it. + /// </para> + /// <para> + /// The directories' names and addresses go the other way. They are somebody else's name and + /// somebody else's URL, they are the credit §7.6 owes, and translating either would destroy the + /// acknowledgement rather than localize it — so they are asserted to be <em>unchanged</em>. + /// </para> + /// </remarks> + [Test] + public async Task EverySentenceComesFromTheBundleAndTheDirectoriesOwnNamesDoNot() + { + var page = AboutPage.Build(new ProbeOptions(), new DatasetLicenceOptions(), "qps-ploc"); + var pseudo = PlainText.RenderAbout(page, "qps-ploc"); + + await Assert.That(pseudo).Contains("⟦"); + + foreach (var section in Page.Sections) + { + await Assert.That(pseudo) + .DoesNotContain(section.Heading) + .Because($"the {section.Id} heading never went through the message pipeline"); + + foreach (var point in section.Points) + { + await Assert.That(pseudo) + .DoesNotContain(point.Lead) + .Because($"a point in {section.Id} is hard-coded English"); + } + } + + // The crawler's own name and the licence a deployment configured are machine voice too, and + // are read off the objects that own them rather than out of the bundle. + await Assert.That(pseudo).Contains(page.Sections.Single(s => s.Id == "crawler").Identity!.Name); + await Assert.That(pseudo).Contains(new DatasetLicenceOptions().LicenceName); + + foreach (var source in Page.Sources) + { + await Assert.That(pseudo).Contains(source.Name); + await Assert.That(pseudo).Contains(source.Url); + } + } + [Test] public async Task TheGraphicalPageIsReachableWithoutScriptingAndSaysHowToReadItPlainly() { diff --git a/tests/MUI.Web.Tests/AccountSurfaceTests.cs b/tests/MUI.Web.Tests/AccountSurfaceTests.cs index 173d0b8..c8df4ef 100644 --- a/tests/MUI.Web.Tests/AccountSurfaceTests.cs +++ b/tests/MUI.Web.Tests/AccountSurfaceTests.cs @@ -1,3 +1,4 @@ +using System.Globalization; using System.Security.Claims; using System.Text.RegularExpressions; @@ -15,8 +16,10 @@ using MUI.Catalog.Persistence; using MUI.Web; using MUI.Web.Accounts; +using MUI.Web.Components; using MUI.Web.Components.Pages; using MUI.Web.Fixtures; +using MUI.Web.Localization; namespace MUI.Web.Tests; @@ -64,11 +67,123 @@ public async Task WithNoDatabaseThePageSaysAccountsNeedOne() var body = Render.Words(await host.Client.GetStringAsync("/account")); - await Assert.That(body).Contains("Accounts need a database"); - await Assert.That(body).DoesNotContain("Sign in"); - await Assert.That(body).DoesNotContain("give up this claim"); + // The fact, through the bundle, rather than a pasted sentence: the claim is that this page + // says the one thing and offers neither the way in nor a write surface, and it goes on + // being that claim when somebody rewords the copy. + await Assert.That(body).Contains(En("account.noDatabase")); + await Assert.That(body).DoesNotContain(En("account.signInButton")); + await Assert.That(body).DoesNotContain(En("account.resign.summary")); } + /// <summary>One message in the source language, as it reads once rendered.</summary> + private static string En(string id) => Render.Words(Messages.For(Locales.SourceTag, id)); + + /// <summary> + /// A placed sentence in the source language, with its slots filled as the page fills them. + /// </summary> + /// <remarks> + /// <see cref="Sentence.Place"/> hands back runs and markers so the markup can choose an element + /// per slot; a test wants the sentence a reader ends up with. Reassembling it here means these + /// assertions read the same bundle the page does — the alternative is a pasted English string, + /// which is exactly what this pass exists to remove. + /// </remarks> + private static string EnPlaced( + string id, + IReadOnlyDictionary<string, string> fills, + params (string Key, object? Value)[] args) => + Render.Words(string.Concat(Sentence + .Place(Locales.SourceTag, id, [.. fills.Keys], args) + .Select(part => part.Slot is null ? part.Text : fills[part.Slot]))); + + /// <summary> + /// Every word of the sign-in page comes out of the message bundle. + /// </summary> + /// <remarks> + /// <para> + /// Both branches, because they are two different pages: over the demo fixture it is one sentence + /// saying there is nothing to sign in to, and behind a database it is the whole passkey + /// explanation — and the second was never rendered by any test at all, so it could have drifted + /// into English without anything noticing. + /// </para> + /// <para> + /// The pseudolocale is the instrument: it accents and brackets anything that reached a reader + /// through <see cref="Messages"/>, so an English sentence surviving here is one typed into the + /// markup. Asserted against the English render rather than against pasted strings, so this keeps + /// holding when the copy is edited. + /// </para> + /// </remarks> + [Test] + [Arguments(true)] + [Arguments(false)] + public async Task EveryWordOfSigningInComesFromTheBundle(bool withDatabase) + { + var english = Render.Words(await SignInAsync(Locales.SourceTag, withDatabase)); + var pseudo = Render.Words(await SignInAsync("qps-ploc", withDatabase)); + + await Assert.That(pseudo).Contains("⟦"); + + // Which page this is, asserted rather than assumed: a harness that failed to register + // identity would render the one-sentence branch twice and the loop below would pass on a + // page nobody had looked at. + await Assert.That(english.Contains( + Messages.For(Locales.SourceTag, "account.store.heading"), StringComparison.Ordinal)) + .IsEqualTo(withDatabase); + + await Assert.That(english.Contains( + Messages.For(Locales.SourceTag, "account.signIn.noDatabase"), StringComparison.Ordinal)) + .IsEqualTo(!withDatabase); + + // Every sentence of the English page, absent from the same page in another language. + // + // Argument-free ids only, and that costs this sweep nothing: the sign-in page says no + // message that takes one. The `account.` prefix now also covers the owner dashboard, whose + // sentences name a game, a date or a count — and a pattern cannot be rendered at all + // without its arguments, so including them here would throw rather than assert. + foreach (var id in Sayable("account.")) + { + var sentence = Render.Words(Messages.For(Locales.SourceTag, id)); + + if (!english.Contains(sentence, StringComparison.Ordinal)) + { + continue; + } + + await Assert.That(pseudo) + .DoesNotContain(sentence) + .Because($"{id} is rendered as English whatever language the page was asked for"); + } + } + + /// <summary> + /// The sign-in page, in one locale, with or without a database behind it. + /// </summary> + /// <remarks> + /// The locale arrives the way the middleware leaves it — in <c>HttpContext.Items</c> — because + /// that is what the page reads. Identity is registered only for the second case, which is + /// exactly the condition the page itself branches on. + /// </remarks> + private static Task<string> SignInAsync(string tag, bool withDatabase) => + Render.ComponentAsync<MUI.Web.Components.Pages.SignIn>([], services => + { + services.AddLogging(); + services.AddSingleton(new MUI.Web.Data.CatalogueSource(IsMeasured: withDatabase)); + + var context = new DefaultHttpContext(); + context.Items[LocaleRouting.ItemKey] = + new LocaleContext(Locales.Find(tag)!, FromPath: tag != Locales.SourceTag); + services.AddCascadingValue(_ => context); + + if (!withDatabase) + { + return; + } + + services.AddHttpContextAccessor(); + services.AddAuthentication(); + services.AddSingleton<IUserStore<MuiUser>>(new Accounts([], FixtureGameQueries.Now)); + services.AddIdentityCore<MuiUser>().AddSignInManager(); + }); + /// <summary>A signed-out visitor is offered the way in and nothing else.</summary> [Test] public async Task ASignedOutVisitorIsOfferedSignInAndNoWriteSurface() @@ -77,7 +192,7 @@ public async Task ASignedOutVisitorIsOfferedSignInAndNoWriteSurface() await Assert.That(markup).Contains("/account/sign-in"); await Assert.That(markup).DoesNotContain("<form"); - await Assert.That(Render.Words(markup)).DoesNotContain("Claimed"); + await Assert.That(Render.Words(markup)).DoesNotContain(En("account.claimed.heading")); } /// <summary>An account with nothing claimed is told where to start.</summary> @@ -87,9 +202,20 @@ public async Task AnAccountWithNoClaimsIsPointedAtTheListing() var markup = await World.New().SignedIn().RenderAsync(); var words = Render.Words(markup); - await Assert.That(words).Contains("You have not claimed anything yet"); + // The whole sentence, reassembled from the bundle including the two runs the markup turns + // into a link and an emphasis — so this holds on the words a reader gets rather than on + // the fragments the markup happens to be split into. Read off the visible text, because a + // placed sentence has elements inside it. + await Assert.That(Render.Text(markup)).Contains(EnPlaced( + "account.empty.body", + new Dictionary<string, string>(StringComparer.Ordinal) + { + ["listing"] = En("account.empty.listing"), + ["claimControl"] = En("account.empty.claimControl"), + })); + await Assert.That(words).Contains("/games"); - await Assert.That(words).DoesNotContain("Waiting on a token"); + await Assert.That(words).DoesNotContain(En("account.pending.heading")); await Assert.That(markup).DoesNotContain("resign"); } @@ -100,11 +226,11 @@ public async Task APendingClaimLinksToItsToken() var markup = await World.New().SignedIn().Pending(Mush).RenderAsync(); var words = Render.Words(markup); - await Assert.That(words).Contains("Waiting on a token"); + await Assert.That(words).Contains(En("account.pending.heading")); await Assert.That(markup).Contains("/g/m-u-s-h/claim"); // Pending is not owning: none of the owner surfaces appear for it. - await Assert.That(words).DoesNotContain("Claimed"); + await Assert.That(words).DoesNotContain(En("account.claimed.heading")); await Assert.That(markup).DoesNotContain("badge.svg"); } @@ -122,7 +248,7 @@ public async Task AVerifiedClaimShowsEverythingAClaimGrants() var markup = await World.New().SignedIn().Verified(Ashen).RenderAsync(); var words = Render.Words(markup); - await Assert.That(words).Contains("Claimed"); + await Assert.That(words).Contains(En("account.claimed.heading")); await Assert.That(markup).Contains("/g/ashen-court"); // §8.5's enrichment, through OwnerPanel. @@ -136,7 +262,7 @@ public async Task AVerifiedClaimShowsEverythingAClaimGrants() await Assert.That(markup).Contains("/g/ashen-court/mssp"); await Assert.That(markup).Contains("/g/ashen-court/badge.svg"); await Assert.That(markup).Contains("/g/ashen-court/badge.json"); - await Assert.That(words).Contains("history"); + await Assert.That(words).Contains(En("account.history.summary")); await Assert.That(markup).Contains("/resign"); } @@ -185,11 +311,19 @@ public async Task ACoOwnedGameNamesTheOtherOwners() var markup = await World.New().SignedIn().Verified(Ashen).CoOwnedBy("thistle").RenderAsync(); var words = Render.Words(markup); - await Assert.That(words).Contains("Also owned by thistle"); - await Assert.That(words).Contains("verified a token of their own"); + // One co-owner, so the message's `one` branch — which is a different sentence from the + // plural in English and in most languages, and naming the branch is the point. + await Assert.That(words).Contains( + Render.Words(Messages.Say( + Locales.SourceTag, "account.claim.coOwners", ("count", 1), ("names", "thistle")))); // The resign copy is the one that differs when somebody else holds the game too. - await Assert.That(words).Contains("the game stays claimed if anybody else owns it"); + await Assert.That(Render.Text(markup)).Contains(EnPlaced( + "account.resign.confirm", + new Dictionary<string, string>(StringComparer.Ordinal) + { + ["word"] = OwnershipWrites.ResignConfirmation, + })); } /// <summary>A sole owner sees no co-owner line at all.</summary> @@ -198,7 +332,10 @@ public async Task ASoleOwnerIsNotToldAboutOwnersWhoDoNotExist() { var words = Render.Words(await World.New().SignedIn().Verified(Ashen).RenderAsync()); - await Assert.That(words).DoesNotContain("Also owned by"); + // The whole rendered line for one co-owner, which cannot appear when there are none. + await Assert.That(words).DoesNotContain( + Render.Words(Messages.Say( + Locales.SourceTag, "account.claim.coOwners", ("count", 1), ("names", "thistle")))); } // ── the status banner ───────────────────────────────────────────────────── @@ -213,11 +350,15 @@ public async Task ASoleOwnerIsNotToldAboutOwnersWhoDoNotExist() /// branch — so every arm is driven here, by the querystring the redirect actually carries. /// </remarks> [Test] - [Arguments("?saved={game}&did=fields", "now shows it as owner-declared")] - [Arguments("?saved={game}&did=screen-hidden", "stopped republishing")] - [Arguments("?saved={game}&did=screen-shown", "connect screen is on its page again")] - [Arguments("?resigned=1", "Given up.")] - [Arguments("?refused=CODEBASE&because=NotEnrichable", "CODEBASE was not changed")] + [Arguments("?saved={game}&did=fields", "account.saved.fields")] + [Arguments("?saved={game}&did=screen-hidden", "account.saved.screenHidden")] + [Arguments("?saved={game}&did=screen-shown", "account.saved.screenShown")] + [Arguments("?saved={game}&did=crawl-stopped", "account.saved.crawlStopped")] + [Arguments("?saved={game}&did=crawl-resumed", "account.saved.crawlResumed")] + [Arguments("?saved={game}&did=unlisted", "account.saved.unlisted")] + [Arguments("?saved={game}&did=relisted", "account.saved.relisted")] + [Arguments("?resigned=1", "account.resigned.lead")] + [Arguments("?refused=CODEBASE&because=NotEnrichable", "account.refused.lead")] public async Task EveryOutcomeReportsTheActionThatHappened(string query, string expected) { var words = Render.Words(await World.New() @@ -225,9 +366,19 @@ public async Task EveryOutcomeReportsTheActionThatHappened(string query, string .Verified(Ashen) .RenderAsync(query.Replace("{game}", Ashen.ToString(), StringComparison.Ordinal))); - await Assert.That(words).Contains(expected); + // The id rather than a pasted fragment, so a reworded banner still has to be the banner for + // the action that happened. The four §11 and listing arms were added to OwnerWrites and + // never to this table, which is the exact omission the remark above describes — the switch + // had already reported the wrong branch once for the same reason. + // + // Both arguments are supplied to every arm; a pattern that names neither ignores them. + await Assert.That(words).Contains(Render.Words(Messages.Say( + Locales.SourceTag, expected, ("game", AshenName), ("field", "CODEBASE")))); } + /// <summary>The fixture game's own name, which the banner quotes and never translates.</summary> + private const string AshenName = "Ashen Court"; + /// <summary> /// Two outcomes at once is one banner, and it is the one the chain says it is. /// </summary> @@ -244,12 +395,154 @@ public async Task ACraftedUrlCarryingTwoOutcomesStillReportsOnlyOne() .Verified(Ashen) .RenderAsync($"?resigned=1&saved={Ashen}&did=fields&refused=CODEBASE")); - await Assert.That(words).Contains("Given up."); - await Assert.That(words).DoesNotContain("now shows it as owner-declared"); - await Assert.That(words).DoesNotContain("was not changed"); + await Assert.That(words).Contains(En("account.resigned.lead")); + await Assert.That(words).DoesNotContain(Render.Words( + Messages.Say(Locales.SourceTag, "account.saved.fields", ("game", AshenName)))); + await Assert.That(words).DoesNotContain(Render.Words( + Messages.Say(Locales.SourceTag, "account.refused.lead", ("field", "CODEBASE")))); + } + + // ── the language the dashboard is answered in ───────────────────────────── + + /// <summary> + /// Every word of the dashboard comes out of the bundle, on the fullest page it has. + /// </summary> + /// <remarks> + /// <para> + /// The pseudolocale is the instrument, as it is for the sign-in page: it accents and brackets + /// anything that reached a reader through <see cref="Messages"/>, so an English sentence + /// surviving here is one somebody typed into the markup. Driven on a verified claim with a + /// co-owner and a banner, because that is the state that renders the owner panel, the badge + /// block, the audit log and the resignation form — most of this page's words are in there. + /// </para> + /// <para> + /// What stays English is named rather than tolerated: a game's name, an operator's chosen + /// display name, a field name out of the registry, the confirmation word the form compares + /// against, the badge's own text and an ISO stamp. Every one of those is machine voice, and + /// translating any of them would break the thing it names. + /// </para> + /// </remarks> + [Test] + public async Task EveryWordOfTheDashboardComesFromTheBundle() + { + var english = Render.Text(await Full(Locales.SourceTag)); + var pseudo = Render.Text(await Full("qps-ploc")); + + await Assert.That(pseudo).Contains("⟦"); + + // The page really is the full one, rather than a guard branch rendered twice. + await Assert.That(english).Contains(En("account.claimed.heading")); + await Assert.That(english).Contains(En("owner.crawl.heading")); + + foreach (var id in Sayable("account.", "owner.")) + { + var sentence = Render.Words(Messages.For(Locales.SourceTag, id)); + + if (!english.Contains(sentence, StringComparison.Ordinal)) + { + continue; + } + + await Assert.That(pseudo) + .DoesNotContain(sentence) + .Because($"{id} is rendered as English whatever language the page was asked for"); + } } + /// <summary> + /// A German request gets German wherever German exists, and the machine voice survives it. + /// </summary> + /// <remarks> + /// <para> + /// <b>Gated on <see cref="Messages.HasOwn"/> rather than on a list of ids, and that is the + /// point.</b> This page's own ids are new and the four satellites are translated in one round + /// afterwards, so today most of them fall back to English — which is the designed behaviour and + /// not a failure. Naming ids here would either freeze that state in or fail the moment the + /// translations land. Asking the bundle instead means the assertion is "German where there is + /// German", which is true now and stays true as each id is translated. + /// </para> + /// <para> + /// The counter proves it is not vacuous: the owner panel already renders the provenance word, + /// which is translated, so this has real German to find today. + /// </para> + /// </remarks> + [Test] + public async Task AGermanRequestGetsGermanOnTheDashboard() + { + var english = Render.Text(await Full(Locales.SourceTag)); + var german = Render.Text(await Full("de")); + + var translated = 0; + + // The provenance family joins by the one id these pages render, not by prefix: the others + // carry the bare word "measured", which occurs inside half the sentences on this page and + // would match as a substring rather than as the chip the panel promises. + foreach (var id in Sayable("account.", "owner.").Append("provenance.game.ownerDeclared")) + { + var en = Render.Words(Messages.For(Locales.SourceTag, id)); + var de = Render.Words(Messages.For("de", id)); + + // An id that fell back has nothing to assert, and a word German spells the same way + // proves nothing either way. + if (!Messages.HasOwn("de", id) + || string.Equals(en, de, StringComparison.Ordinal) + || !english.Contains(en, StringComparison.Ordinal)) + { + continue; + } + + await Assert.That(german).Contains(de).Because($"{id} is not answered in German"); + + translated++; + } + + await Assert.That(translated) + .IsGreaterThan(0) + .Because("no id on this page has German yet, so this test asserted nothing"); + + // The page is answered in German rather than merely served under a German tag. + await Assert.That(german).IsNotEqualTo(english); + + // A fallback shows the English and never the id. That is the one failure mode a reader + // cannot recover from — English inside a German sentence tells them something true, and + // `account.title` on the page tells them the site is broken. + foreach (var id in Sayable("account.", "owner.").Where(i => !Messages.HasOwn("de", i))) + { + await Assert.That(german).DoesNotContain(id).Because($"{id} reached a reader as its id"); + } + + // Machine voice is untouched: the game's name and the confirmation word are not translated. + await Assert.That(german).Contains(AshenName); + await Assert.That(german).Contains(OwnershipWrites.ResignConfirmation); + } + + /// <summary>Ids under these prefixes that can be rendered without arguments.</summary> + /// <remarks> + /// A pattern cannot be formatted at all without the arguments it names, so a sweep that walks + /// whole sentences has to leave those out. It costs little: the parameterised ids on these + /// pages are the ones carrying a game's name, a date or a count, and each has its own test. + /// </remarks> + private static IEnumerable<string> Sayable(params string[] prefixes) => + Messages.Ids + .Where(i => prefixes.Any(p => i.StartsWith(p, StringComparison.Ordinal))) + .Where(i => !IcuMessage.Compile(Messages.Pattern(Locales.SourceTag, i)!).Arguments().Any()); + + /// <summary>The dashboard in one locale, in the state that renders the most of it.</summary> + private static Task<string> Full(string tag) => + World.New() + .In(tag) + .SignedIn() + .Verified(Ashen) + .CoOwnedBy("thistle") + .RenderAsync($"?saved={Ashen}&did=fields"); + /// <summary>An enrichment refusal names the field and says which rule refused it.</summary> + /// <remarks> + /// The two reasons are different sentences and must not be swapped: one says an answer was too + /// long, the other says the field is measured and that nobody edits a measurement, us included. + /// A refusal that gave the second reason for the first cause would be the site claiming a rule + /// it does not have. + /// </remarks> [Test] public async Task ARefusalOverLengthSaysSoRatherThanBlamingTheField() { @@ -258,9 +551,15 @@ public async Task ARefusalOverLengthSaysSoRatherThanBlamingTheField() .Verified(Ashen) .RenderAsync("?refused=FANDOM&because=TooLong")); - await Assert.That(words).Contains("FANDOM was not changed"); - await Assert.That(words).Contains($"{OwnerEnrichment.MaxValueLength} characters"); - await Assert.That(words).DoesNotContain("That field is measured"); + await Assert.That(words).Contains(Render.Words( + Messages.Say(Locales.SourceTag, "account.refused.lead", ("field", "FANDOM")))); + + await Assert.That(words).Contains(Render.Words(Messages.Say( + Locales.SourceTag, + "account.refused.tooLong", + ("max", OwnerEnrichment.MaxValueLength.ToString(CultureInfo.InvariantCulture))))); + + await Assert.That(words).DoesNotContain(En("account.refused.measured")); } // ── the routes the page posts to ────────────────────────────────────────── @@ -363,9 +662,23 @@ private sealed class World private readonly List<GameClaim> _claims = []; private bool _signedIn; + private string _tag = Locales.SourceTag; public static World New() => new(); + /// <summary> + /// The locale the request was answered in, as the middleware leaves it. + /// </summary> + /// <remarks> + /// In <c>HttpContext.Items</c> rather than on a thread's culture, because that is where the + /// page reads it from — every surface here is handed its locale rather than inferring one. + /// </remarks> + public World In(string tag) + { + _tag = tag; + return this; + } + public World SignedIn() { _signedIn = true; @@ -442,7 +755,7 @@ public Task<string> RenderAsync(string query = "") => services.AddSingleton(new OwnerEnrichment( claims, fields, new FieldReconciler(fields), FieldRegistry.Instance, new Frozen(Now))); - services.AddSingleton<IUserStore<MuiUser>>(new Accounts(_accounts)); + services.AddSingleton<IUserStore<MuiUser>>(new Accounts(_accounts, Now)); services.AddIdentityCore<MuiUser>(); }); @@ -456,10 +769,13 @@ public Task<string> RenderAsync(string query = "") => ExpiresAt = Now.AddDays(20), }; - private static HttpContext Context(MuiUser? user) + private HttpContext Context(MuiUser? user) { var context = new DefaultHttpContext(); + context.Items[LocaleRouting.ItemKey] = + new LocaleContext(Locales.Find(_tag)!, FromPath: _tag != Locales.SourceTag); + if (user is not null) { context.User = new ClaimsPrincipal(new ClaimsIdentity( @@ -600,78 +916,4 @@ public Task<IReadOnlyList<GameRecord>> UnarchivedAsync(CancellationToken ct = de CancellationToken ct = default) => Task.FromResult<string?>(null); } - - /// <summary> - /// Enough of a user store to find an account and list its passkeys. - /// </summary> - /// <remarks> - /// Identity's <c>UserManager</c> is a concrete type over a store interface, so a page that calls - /// it needs one. This is persistence rather than authorisation: which account the page is for - /// comes from the cascaded principal, and what that account may see comes from the claim store. - /// </remarks> - private sealed class Accounts(List<MuiUser> users) : IUserStore<MuiUser>, IUserPasskeyStore<MuiUser> - { - public Task<MuiUser?> FindByIdAsync(string id, CancellationToken ct) => - Task.FromResult(users.FirstOrDefault(u => u.Id.ToString() == id)); - - public Task<string> GetUserIdAsync(MuiUser user, CancellationToken ct) => - Task.FromResult(user.Id.ToString()); - - public Task<string?> GetUserNameAsync(MuiUser user, CancellationToken ct) => - Task.FromResult<string?>(user.DisplayName); - - public Task<string?> GetNormalizedUserNameAsync(MuiUser user, CancellationToken ct) => - Task.FromResult<string?>(user.NormalisedName); - - public Task<MuiUser?> FindByNameAsync(string name, CancellationToken ct) => - Task.FromResult(users.FirstOrDefault(u => u.NormalisedName == name)); - - public Task SetUserNameAsync(MuiUser user, string? name, CancellationToken ct) => Task.CompletedTask; - - public Task SetNormalizedUserNameAsync(MuiUser user, string? name, CancellationToken ct) => - Task.CompletedTask; - - public Task<IdentityResult> CreateAsync(MuiUser user, CancellationToken ct) => - Task.FromResult(IdentityResult.Success); - - public Task<IdentityResult> UpdateAsync(MuiUser user, CancellationToken ct) => - Task.FromResult(IdentityResult.Success); - - public Task<IdentityResult> DeleteAsync(MuiUser user, CancellationToken ct) => - Task.FromResult(IdentityResult.Success); - - public Task AddOrUpdatePasskeyAsync(MuiUser user, UserPasskeyInfo passkey, CancellationToken ct) => - Task.CompletedTask; - - public Task<IList<UserPasskeyInfo>> GetPasskeysAsync(MuiUser user, CancellationToken ct) => - Task.FromResult<IList<UserPasskeyInfo>>( - [ - new UserPasskeyInfo( - [1, 2, 3], - [4, 5, 6], - Now.AddYears(-1), - 0u, - ["internal"], - true, - true, - true, - [], - []) - { - Name = "the yubikey in the drawer", - }, - ]); - - public Task<MuiUser?> FindByPasskeyIdAsync(byte[] id, CancellationToken ct) => - Task.FromResult<MuiUser?>(null); - - public Task<UserPasskeyInfo?> FindPasskeyAsync(MuiUser user, byte[] id, CancellationToken ct) => - Task.FromResult<UserPasskeyInfo?>(null); - - public Task RemovePasskeyAsync(MuiUser user, byte[] id, CancellationToken ct) => Task.CompletedTask; - - public void Dispose() - { - } - } } diff --git a/tests/MUI.Web.Tests/Accounts.cs b/tests/MUI.Web.Tests/Accounts.cs new file mode 100644 index 0000000..08bf9f8 --- /dev/null +++ b/tests/MUI.Web.Tests/Accounts.cs @@ -0,0 +1,88 @@ +using Microsoft.AspNetCore.Identity; + +using MUI.Web.Accounts; + +namespace MUI.Web.Tests; + +/// <summary> +/// Enough of a user store to find an account and list its passkeys. +/// </summary> +/// <remarks> +/// <para> +/// Identity's <c>UserManager</c> is a concrete type over a store interface, so a page that calls it +/// needs one. This is persistence rather than authorisation: which account a page is for comes from +/// the cascaded principal, and what that account may see comes from the claim store. +/// </para> +/// <para> +/// Its own file because two surfaces need it. The dashboard and the claim page both go through +/// <c>UserManager.GetUserAsync</c> before they render anything an owner can act on, and the second +/// one could not be rendered at all while this was private to the first — so the claim page's +/// signed-in states had no test, which is the same gap the dashboard was in before it got one. +/// </para> +/// </remarks> +internal sealed class Accounts(List<MuiUser> users, DateTimeOffset now) + : IUserStore<MuiUser>, IUserPasskeyStore<MuiUser> +{ + public Task<MuiUser?> FindByIdAsync(string id, CancellationToken ct) => + Task.FromResult(users.FirstOrDefault(u => u.Id.ToString() == id)); + + public Task<string> GetUserIdAsync(MuiUser user, CancellationToken ct) => + Task.FromResult(user.Id.ToString()); + + public Task<string?> GetUserNameAsync(MuiUser user, CancellationToken ct) => + Task.FromResult<string?>(user.DisplayName); + + public Task<string?> GetNormalizedUserNameAsync(MuiUser user, CancellationToken ct) => + Task.FromResult<string?>(user.NormalisedName); + + public Task<MuiUser?> FindByNameAsync(string name, CancellationToken ct) => + Task.FromResult(users.FirstOrDefault(u => u.NormalisedName == name)); + + public Task SetUserNameAsync(MuiUser user, string? name, CancellationToken ct) => Task.CompletedTask; + + public Task SetNormalizedUserNameAsync(MuiUser user, string? name, CancellationToken ct) => + Task.CompletedTask; + + public Task<IdentityResult> CreateAsync(MuiUser user, CancellationToken ct) => + Task.FromResult(IdentityResult.Success); + + public Task<IdentityResult> UpdateAsync(MuiUser user, CancellationToken ct) => + Task.FromResult(IdentityResult.Success); + + public Task<IdentityResult> DeleteAsync(MuiUser user, CancellationToken ct) => + Task.FromResult(IdentityResult.Success); + + public Task AddOrUpdatePasskeyAsync(MuiUser user, UserPasskeyInfo passkey, CancellationToken ct) => + Task.CompletedTask; + + public Task<IList<UserPasskeyInfo>> GetPasskeysAsync(MuiUser user, CancellationToken ct) => + Task.FromResult<IList<UserPasskeyInfo>>( + [ + new UserPasskeyInfo( + [1, 2, 3], + [4, 5, 6], + now.AddYears(-1), + 0u, + ["internal"], + true, + true, + true, + [], + []) + { + Name = "the yubikey in the drawer", + }, + ]); + + public Task<MuiUser?> FindByPasskeyIdAsync(byte[] id, CancellationToken ct) => + Task.FromResult<MuiUser?>(null); + + public Task<UserPasskeyInfo?> FindPasskeyAsync(MuiUser user, byte[] id, CancellationToken ct) => + Task.FromResult<UserPasskeyInfo?>(null); + + public Task RemovePasskeyAsync(MuiUser user, byte[] id, CancellationToken ct) => Task.CompletedTask; + + public void Dispose() + { + } +} diff --git a/tests/MUI.Web.Tests/AdultSurfaceTests.cs b/tests/MUI.Web.Tests/AdultSurfaceTests.cs index 4042fb5..b3b4124 100644 --- a/tests/MUI.Web.Tests/AdultSurfaceTests.cs +++ b/tests/MUI.Web.Tests/AdultSurfaceTests.cs @@ -1,3 +1,4 @@ +using MUI.Web.Localization; using MUI.Catalog; using MUI.Web.Api; using MUI.Web.Components; @@ -70,23 +71,37 @@ public async Task TheBarCarriesTheControlWhetherOrNotItIsTicked() { // Drawn on every request, ticked or not. A default whose only undo appears once you have // already undone it is a default a reader cannot find, and this one hides games silently. + // + // A link now rather than a checkbox waiting on a submit button: the panel's "show" button + // is gone, so a control that only armed itself would be one nothing could fire. foreach (var filter in new[] { Listing(), Listing($"?{FacetKeys.Adult}=true") }) { var html = await PanelAsync(filter); - await Assert.That(html).Contains($"name=\"{FacetKeys.Adult}\""); - await Assert.That(Render.Words(html)).Contains("include adult"); + // The control, whichever way it is set. Its href is the *other* position, so asserting + // on a fixed URL would only ever find one of the two states — which is how a control + // that vanished once it had been used would pass a test. + await Assert.That(html).Contains("adult content,"); + await Assert.That(Render.Words(html)).Contains("adult"); } } [Test] - public async Task TheTickedBoxIsCheckedWhenTheUrlAsksForThem() + public async Task TheSwitchSaysWhichWayItIsSetAndLinksToTheOther() { - // The URL is the whole of this page's state, so a shared link has to come back with the box - // in the position that produced it. - await Assert.That(await PanelAsync(Listing())).DoesNotContain($"name=\"{FacetKeys.Adult}\" value=\"true\" checked"); - await Assert.That(await PanelAsync(Listing($"?{FacetKeys.Adult}=1"))) - .Contains($"name=\"{FacetKeys.Adult}\" value=\"true\" checked"); + // The URL is the whole of this page's state, so a shared link has to come back with the + // switch in the position that produced it — and the way out has to be the other position. + var off = await PanelAsync(Listing()); + var on = await PanelAsync(Listing($"?{FacetKeys.Adult}=1")); + + // Off: says so, and its link turns them on. + await Assert.That(off).Contains("adult content, hidden"); + await Assert.That(off).Contains($"href=\"/games?{FacetKeys.Adult}=true\""); + + // On: says so, and its link is the one that clears the key rather than setting it false — + // the address a reader copies says only what they asked for. + await Assert.That(on).Contains("adult content, shown"); + await Assert.That(on).DoesNotContain($"href=\"/games?{FacetKeys.Adult}=true\""); } [Test] @@ -96,9 +111,16 @@ public async Task IncludingThemIsAChipThatCanBeTakenBackOff() var filter = Listing(Query); var listing = await Queries.SearchAsync(filter); - var chip = ActiveFilters.For(listing.Facets, filter, Query).Single(c => c.Facet is "adult"); - await Assert.That(chip.Value).IsEqualTo("included"); + // Both halves of the chip come out of the bundle now, so this asks the bundle what they say + // rather than repeating the English. The fact under test is unchanged and is not wording: + // the chip for this key exists, it says the key is included, and its link takes it back off. + var chips = ActiveFilters.For(Locales.SourceTag, listing.Facets, filter, Query); + var chip = chips.Single( + c => c.Facet == FacetWords.Group(Locales.SourceTag, FacetKeys.Adult)); + + await Assert.That(chip.Value) + .IsEqualTo(Messages.For(Locales.SourceTag, "facet.value.included")); await Assert.That(chip.RemoveHref).DoesNotContain(FacetKeys.Adult); } diff --git a/tests/MUI.Web.Tests/AnsiTests.cs b/tests/MUI.Web.Tests/AnsiTests.cs index 6531733..324d8e3 100644 --- a/tests/MUI.Web.Tests/AnsiTests.cs +++ b/tests/MUI.Web.Tests/AnsiTests.cs @@ -92,23 +92,135 @@ public async Task NothingCapturedIsDistinctFromTooSmall() } [Test] - public async Task AScreenPastTwentyFourRowsIsCroppedAndSaysHowManyThereAre() + public async Task ALongScreenIsParsedWholeRatherThanCropped() { - var screen = Ansi.Parse(Screen(47), suppressedByOwner: false); + // There is no crop any more. The frame used to hold the first twenty-four rows, offer the + // whole screen again under "show all N rows" and its text a third time under "read as text" + // — three copies of one piece of box-drawing, and three passes through it for anybody + // listening. One region, every row, and it scrolls. + var screen = Ansi.Parse(Screen(214), suppressedByOwner: false); - await Assert.That(screen.RowCount).IsEqualTo(47); - await Assert.That(screen.IsCropped).IsTrue(); - await Assert.That(screen.IsOversized).IsFalse(); - await Assert.That(screen.Visible.Count()).IsEqualTo(Ansi.CropRows); + await Assert.That(screen.RowCount).IsEqualTo(214); + await Assert.That(screen.Rows.Count).IsEqualTo(214); } [Test] - public async Task AScreenPastTwoHundredRowsIsFlaggedAsOversizedAndStillCropsAtTwentyFour() + public async Task AWidthIsCountedInTerminalCellsAndPerRowRatherThanPerScreen() { - var screen = Ansi.Parse(Screen(214), suppressedByOwner: false); + // The row that made a screen-wide flag wrong: seventy-eight ASCII characters and one Han + // glyph. Seventy-nine characters, eighty cells — and the caption used to halve the whole + // screen the moment any wide rune appeared anywhere, and report forty for this. + var mixed = new string('x', 78) + "漢"; + var screen = Ansi.Parse($"{mixed}\nplain\nplain", suppressedByOwner: false); + + await Assert.That(screen.Rows[0].Text.Length).IsEqualTo(79); + await Assert.That(screen.Rows[0].Cells).IsEqualTo(80); + await Assert.That(screen.CellColumns).IsEqualTo(80); + await Assert.That(screen.HasWideRunes).IsTrue(); + + // And eighty-one cells cannot be one row of an eighty-column terminal. A double-width glyph + // that would straddle the right margin is moved whole to the next line rather than split + // across it, which is what a terminal does — so seventy-nine ASCII plus one Han glyph is two + // rows, not one over-wide one. The layout counts cells and the caption reads them; before + // this the layout counted UTF-16 units, so a screen of wide glyphs wrapped after eighty + // runes, which is a hundred and sixty cells. + var straddling = Ansi.Parse(new string('x', 79) + "漢\nplain", suppressedByOwner: false); + + await Assert.That(straddling.Rows[0].Cells).IsEqualTo(79); + await Assert.That(straddling.Rows[1].Text).IsEqualTo("漢"); + + // And a screen drawn entirely out of wide glyphs is twice its character count, which is the + // case the halving was written for and the only one it got right. + var wide = Ansi.Parse($"{new string('漢', 40)}\n{new string('漢', 40)}\n{new string('漢', 40)}", + suppressedByOwner: false); + + await Assert.That(wide.CellColumns).IsEqualTo(80); + } + + [Test] + public async Task AWideRuneOnOneRowDoesNotWidenTheRowsAroundIt() + { + // The width reported is the widest row, not the widest row's arithmetic applied to all of + // them. A banner with one Japanese line in it is as wide as that line and no wider. + var screen = Ansi.Parse("ascii\n漢字\nascii", suppressedByOwner: false); + + await Assert.That(screen.Rows[0].Cells).IsEqualTo(5); + await Assert.That(screen.Rows[1].Cells).IsEqualTo(4); + await Assert.That(screen.CellColumns).IsEqualTo(5); + } + + [Test] + public async Task ACombiningMarkCostsNoCellOfItsOwn() + { + // It is drawn onto the cell before it. Counted as a character, an accented Greek or + // Devanagari banner would be reported wider than it is drawn. + // + // Composed here rather than written as a literal, so the decomposition is this test's and + // not whatever normalisation the file was saved under: three letters, each carrying a + // combining acute of its own. + var acute = (char)0x0301; + var decomposed = string.Concat(Enumerable.Repeat($"e{acute}", 3)); + var screen = Ansi.Parse($"{decomposed}\nplain\nplain", suppressedByOwner: false); + + await Assert.That(screen.Rows[0].Text.Length).IsEqualTo(6); + await Assert.That(screen.Rows[0].Cells).IsEqualTo(3); + await Assert.That(screen.HasWideRunes).IsFalse(); + } + + [Test] + public async Task AnEmptyScreenHasNoWidthRatherThanTheGridsWidth() + { + await Assert.That(Ansi.Parse(null, false).CellColumns).IsEqualTo(0); + } - await Assert.That(screen.IsOversized).IsTrue(); - await Assert.That(screen.Visible.Count()).IsEqualTo(Ansi.CropRows); + /// <summary> + /// The whole accessible alternative to the picture is outside the picture. + /// </summary> + /// <remarks> + /// <c>role="img"</c> makes every descendant presentational, so a disclosure inside + /// <c>div.quote</c> is announced as nothing at all and the one-line <c>aria-label</c> becomes + /// the only alternative there is — a label saying the screen exists, in place of the screen. + /// The disclosure therefore sits beside the quoted region and inside the figure. + /// </remarks> + [Test] + public async Task TheReadAsTextDisclosureIsOutsideTheRoleImgSubtree() + { + var html = await Render.ComponentAsync<AnsiQuote>(new() + { + ["Screen"] = Ansi.Parse(Screen(6), suppressedByOwner: false), + }); + + await Assert.That(html).Contains("role=\"img\""); + await Assert.That(html).Contains("aria-label="); + await Assert.That(html).Contains("class=\"screen-text\""); + + // The quoted region holds one <pre> and no other element that closes with </div>, so the + // first </div> after it is its own — and the disclosure has to come after that. + var quote = html.IndexOf("class=\"quote\"", StringComparison.Ordinal); + var closes = html.IndexOf("</div>", quote, StringComparison.Ordinal); + var disclosure = html.IndexOf("class=\"screen-text\"", StringComparison.Ordinal); + + await Assert.That(quote).IsGreaterThanOrEqualTo(0); + await Assert.That(disclosure).IsGreaterThan(closes); + + // And it is still inside the figure, which is what makes the two one block. + var figure = html.IndexOf("</figure>", StringComparison.Ordinal); + await Assert.That(disclosure).IsLessThan(figure); + } + + [Test] + public async Task TheCaptionStatesTheWidestRowInCellsRatherThanAHalvedGrid() + { + // Seventy-eight ASCII characters and one Han glyph: eighty cells, the widest a row of an + // eighty-column terminal can be. The caption said forty, because one wide rune anywhere + // halved the whole screen. + var html = Render.Words(await Render.ComponentAsync<AnsiQuote>(new() + { + ["Screen"] = Ansi.Parse(new string('x', 78) + "漢\nplain\nplain", suppressedByOwner: false), + })); + + await Assert.That(html).Contains("80×"); + await Assert.That(html).DoesNotContain("40×"); } [Test] diff --git a/tests/MUI.Web.Tests/CapabilityMatrixTests.cs b/tests/MUI.Web.Tests/CapabilityMatrixTests.cs index 6a9180f..3b36606 100644 --- a/tests/MUI.Web.Tests/CapabilityMatrixTests.cs +++ b/tests/MUI.Web.Tests/CapabilityMatrixTests.cs @@ -42,13 +42,29 @@ public async Task ADisagreementIsMarkedInTheRowAndNotOnlyByATint() } [Test] - public async Task TheCountIsInTheSectionHeadSoItSurvivesCollapse() + public async Task TheTallyIsTheTablesCaptionAndIsSaidExactlyOnce() { + // It used to be the section's heading text and, verbatim, the table's sr-only caption — so a + // screen reader heard the same sentence twice on the way to the first row. As the caption it + // is the table's own description, it is on screen for everybody, and it is there once. + // The wording is the short form the handoff's copy table asks for. "capabilities" was the + // word the heading directly above already says, so the caption no longer repeats it. var html = await MatrixAsync(); var head = html[..html.IndexOf("<table", StringComparison.Ordinal)]; - await Assert.That(head).Contains("1 of 4 capabilities"); - await Assert.That(head).Contains("disagrees with what the game declares"); + await Assert.That(html).Contains("<caption class=\"count"); + + // "disagrees" and not "disagree": the caption is an ICU message with a real plural clause, + // so one disagreement agrees with its verb. It read "1 of 4 disagree" for as long as the + // sentence was assembled by hand. + await Assert.That(Render.Words(html)).Contains("1 of 4 disagrees with what the game declares."); + await Assert.That(head).DoesNotContain("1 of 4"); + + var occurrences = Render.Words(html).Split("1 of 4").Length - 1; + await Assert.That(occurrences).IsEqualTo(1); + + // The heading is just the noun, which is the other half of saying it once. + await Assert.That(Render.Words(head)).Contains("Capabilities"); } [Test] diff --git a/tests/MUI.Web.Tests/ClaimSurfaceTests.cs b/tests/MUI.Web.Tests/ClaimSurfaceTests.cs index 89e46a4..390c04a 100644 --- a/tests/MUI.Web.Tests/ClaimSurfaceTests.cs +++ b/tests/MUI.Web.Tests/ClaimSurfaceTests.cs @@ -1,8 +1,17 @@ +using System.Security.Claims; + +using Microsoft.AspNetCore.Components.Forms; +using Microsoft.AspNetCore.Http; +using Microsoft.AspNetCore.Identity; +using Microsoft.Extensions.DependencyInjection; + using MUI.Catalog; using MUI.Catalog.Persistence; +using MUI.Discovery; using MUI.Web.Accounts; using MUI.Web.Components.Pages; using MUI.Web.Fixtures; +using MUI.Web.Localization; namespace MUI.Web.Tests; @@ -30,7 +39,9 @@ public async Task AGamePageOverTheFixtureDoesNotOfferToBeClaimed() { var page = await Render.PageAsync<Game>(new() { ["Slug"] = "m-u-s-h" }); - await Assert.That(page).Contains("Everything here was measured, not entered by an owner"); + // One sentence, where the badge and a paragraph three blocks below used to say the same + // thing twice. The invitation is the half that depends on there being anywhere to sign in. + await Assert.That(Render.Words(page)).Contains("Unclaimed — everything here was measured."); await Assert.That(page).DoesNotContain("Claim this game"); } @@ -95,4 +106,311 @@ public async Task OnlyChannelsAProbeCanReadAreClaimChannels() { await Assert.That(Enum.GetNames<ClaimChannel>()).IsEquivalentTo(new[] { "Mssp", "ConnectScreen" }); } + + // ── the language the claim page is answered in ──────────────────────────── + + /// <summary> + /// Every word of the claim page comes out of the message bundle. + /// </summary> + /// <remarks> + /// <para> + /// Driven on the state that renders the most of it: a signed-in operator with a pending token, + /// which is the page an owner actually works from — the instructions, both channels, the + /// expiry and the recheck button. The degraded states are covered below, because those are the + /// ones a reader of the demo site meets. + /// </para> + /// <para> + /// The pseudolocale is the instrument: it brackets anything that reached a reader through + /// <see cref="Messages"/>, so an English sentence surviving here is one typed into the markup. + /// </para> + /// </remarks> + [Test] + public async Task EveryWordOfClaimingComesFromTheBundle() + { + var english = Render.Text(await ClaimWorld.Pending(Locales.SourceTag)); + var pseudo = Render.Text(await ClaimWorld.Pending("qps-ploc")); + + await Assert.That(pseudo).Contains("⟦"); + + // The page really is the token-bearing one rather than a guard branch rendered twice. + await Assert.That(english).Contains(Render.Words( + Messages.For(Locales.SourceTag, "claim.either.heading"))); + + foreach (var id in Sayable("claim.")) + { + var sentence = Render.Words(Messages.For(Locales.SourceTag, id)); + + if (!english.Contains(sentence, StringComparison.Ordinal)) + { + continue; + } + + await Assert.That(pseudo) + .DoesNotContain(sentence) + .Because($"{id} is rendered as English whatever language the page was asked for"); + } + } + + /// <summary> + /// A German request gets German wherever German exists, and the token survives it. + /// </summary> + /// <remarks> + /// Gated on <see cref="Messages.HasOwn"/> rather than on a list of ids: this page's own ids are + /// new and the satellites are translated in one round afterwards, so most of them fall back to + /// English today — the designed behaviour. The parts that must never move are asserted + /// directly, because every one of them is something an operator pastes into a config file. + /// </remarks> + [Test] + public async Task AGermanRequestGetsGermanOnTheClaimPage() + { + var english = Render.Text(await ClaimWorld.Pending(Locales.SourceTag)); + var german = Render.Text(await ClaimWorld.Pending("de")); + + foreach (var id in Sayable("claim.").Where(i => Messages.HasOwn("de", i))) + { + var de = Render.Words(Messages.For("de", id)); + var en = Render.Words(Messages.For(Locales.SourceTag, id)); + + if (string.Equals(de, en, StringComparison.Ordinal) + || !english.Contains(en, StringComparison.Ordinal)) + { + continue; + } + + await Assert.That(german).Contains(de).Because($"{id} is not answered in German"); + } + + // A fallback shows the English and never the id. + foreach (var id in Sayable("claim.").Where(i => !Messages.HasOwn("de", i))) + { + await Assert.That(german).DoesNotContain(id).Because($"{id} reached a reader as its id"); + } + + // The machine voice, which is the half of this page that must be byte-identical in every + // language: the token itself, the MSSP variable and the connect-screen prefix are what a + // probe looks for, and a translated one is a claim that could never verify. + await Assert.That(german).Contains(ClaimWorld.Token); + await Assert.That(german).Contains(ClaimTokenBeacon.MsspVariable); + await Assert.That(german).Contains(ClaimTokenBeacon.ConnectScreenPrefix); + + // And the accepted spellings are read from the parser rather than retyped into the page. + foreach (var accepted in ClaimTokenBeacon.AcceptedMsspVariables) + { + await Assert.That(german).Contains(accepted); + } + } + + /// <summary> + /// The states a reader of the demo site can actually reach, in the language they asked for. + /// </summary> + /// <remarks> + /// There is no database behind the fixture, so claiming is absent rather than present and + /// broken — and "absent" is itself a sentence, which has to be in the reader's language like + /// any other. Both branches, because a slug that names nothing and a slug that names a game we + /// cannot claim are different answers. + /// </remarks> + [Test] + [Arguments(Locales.SourceTag)] + [Arguments("qps-ploc")] + [Arguments("de")] + public async Task TheDegradedClaimPageAnswersInTheReadersLanguage(string tag) + { + var missing = Render.Text(await ClaimWorld.NoGame(tag)); + + await Assert.That(missing).Contains(Render.Words(Messages.For(tag, "claim.noGame"))); + + var unclaimable = Render.Text(await ClaimWorld.NoDatabase(tag)); + + await Assert.That(unclaimable).Contains(Render.Words(Messages.For(tag, "claim.noDatabase"))); + + // The heading names the game, and the game's name is its own bytes in every language. + await Assert.That(unclaimable).Contains(Render.Words( + Messages.Say(tag, "claim.title", ("game", ClaimWorld.GameName)))); + } + + /// <summary>Ids under a prefix that can be rendered without arguments.</summary> + private static IEnumerable<string> Sayable(string prefix) => + Messages.Ids + .Where(i => i.StartsWith(prefix, StringComparison.Ordinal)) + .Where(i => !IcuMessage.Compile(Messages.Pattern(Locales.SourceTag, i)!).Arguments().Any()); + + /// <summary> + /// The claim page, in one locale, in each state it can be reached in. + /// </summary> + /// <remarks> + /// At component level with an <see cref="HttpContext"/> cascaded in, for the reason the + /// dashboard's harness is: §8.2 makes passkeys the only way in, so a loopback host cannot + /// produce an authenticated session without an authenticator. The page's own guards still run — + /// which game, which account, and whether there is a claim — against a real + /// <see cref="ClaimService"/> over in-memory stores. + /// </remarks> + private static class ClaimWorld + { + public const string Slug = "ashen-court"; + + public const string GameName = "Ashen Court"; + + /// <summary>A token of the right shape. Machine voice, and identical in every language.</summary> + public const string Token = "muidx-t3kn2wxy7q4m8dgh6prs"; + + private static readonly DateTimeOffset Now = FixtureGameQueries.Now; + + private static readonly Guid GameId = Guid.Parse("aaaaaaaa-0000-0000-0000-000000000007"); + + /// <summary>A signed-in operator with a token outstanding: the page an owner works from.</summary> + public static Task<string> Pending(string tag) => RenderAsync(tag, withGame: true, withClaims: true); + + /// <summary>A slug that names nothing.</summary> + public static Task<string> NoGame(string tag) => RenderAsync(tag, withGame: false, withClaims: true); + + /// <summary>A real game on a site with no database behind it — the demo fixture's state.</summary> + public static Task<string> NoDatabase(string tag) => + RenderAsync(tag, withGame: true, withClaims: false); + + private static Task<string> RenderAsync(string tag, bool withGame, bool withClaims) + { + var user = new MuiUser { DisplayName = "corvid-admin", CreatedAt = Now }; + + var claim = new GameClaim + { + Id = Guid.CreateVersion7(), + GameId = GameId, + UserId = user.Id, + Token = Token, + IssuedAt = Now.AddDays(-2), + ExpiresAt = Now.AddDays(12), + }; + + return Render.ComponentAsync<MUI.Web.Components.Pages.Claim>( + new Dictionary<string, object?> { ["Slug"] = Slug }, + services => + { + var games = new Games(withGame + ? new GameRecord(GameId, Slug, GameName, null, LifecycleState.Active, false, Now) + : null); + + var claims = new Claims([claim]); + + services.AddLogging(); + services.AddSingleton<TimeProvider>(new Frozen(Now)); + services.AddSingleton(new MUI.Web.Data.CatalogueSource(IsMeasured: withClaims)); + services.AddSingleton<AntiforgeryStateProvider, NoAntiforgery>(); + services.AddSingleton<IGameStore>(games); + + // Registered together, because that is how the site registers them: claiming + // exists only when a connection string does, and the page's "no database" + // branch is exactly the absence of this service. + if (withClaims) + { + services.AddSingleton<IClaimStore>(claims); + services.AddSingleton(new ClaimService(claims, games, new Frozen(Now))); + } + + services.AddSingleton<IUserStore<MuiUser>>(new Accounts([user], Now)); + services.AddIdentityCore<MuiUser>(); + + var context = new DefaultHttpContext + { + User = new ClaimsPrincipal(new ClaimsIdentity( + [new System.Security.Claims.Claim( + ClaimTypes.NameIdentifier, user.Id.ToString())], + "Test")), + }; + + context.Items[LocaleRouting.ItemKey] = + new LocaleContext(Locales.Find(tag)!, FromPath: tag != Locales.SourceTag); + + services.AddCascadingValue(_ => context); + }); + } + + private sealed class Games(GameRecord? game) : IGameStore + { + public Task<GameRecord?> ByIdAsync(Guid id, CancellationToken ct = default) => + Task.FromResult(game?.Id == id ? game : null); + + public Task<GameRecord?> BySlugAsync(string slug, CancellationToken ct = default) => + Task.FromResult(game?.Slug == slug ? game : null); + + public Task InsertAsync(GameRecord g, CancellationToken ct = default) => + throw new NotSupportedException(); + + public Task ExcludeAsync(Guid id, string reason, DateTimeOffset at, CancellationToken ct = default) => + throw new NotSupportedException(); + + public Task IncludeAsync(Guid id, DateTimeOffset at, CancellationToken ct = default) => + throw new NotSupportedException(); + + public Task UnlistAsync(Guid id, Guid by, DateTimeOffset at, CancellationToken ct = default) => + throw new NotSupportedException(); + + public Task RelistAsync(Guid id, DateTimeOffset at, CancellationToken ct = default) => + throw new NotSupportedException(); + + public Task SetStateAsync(Guid id, LifecycleState s, DateTimeOffset at, CancellationToken ct = default) => + throw new NotSupportedException(); + + public Task MarkReachableAsync(Guid id, DateTimeOffset at, CancellationToken ct = default) => + throw new NotSupportedException(); + + public Task<string?> RenameAsync( + Guid id, + string name, + string slug, + DateTimeOffset at, + CancellationToken ct = default) => + throw new NotSupportedException(); + + public Task SetClaimedAsync(Guid id, bool isClaimed, CancellationToken ct = default) => + throw new NotSupportedException(); + + public Task CorroborateAsync( + Guid id, + DateTimeOffset at, + IReadOnlyList<string> signals, + CancellationToken ct = default) => + throw new NotSupportedException(); + + public Task<IReadOnlyList<GameRecord>> UnarchivedAsync(CancellationToken ct = default) => + throw new NotSupportedException(); + } + + private sealed class Claims(List<GameClaim> claims) : IClaimStore + { + public Task<GameClaim?> FindAsync(Guid id, CancellationToken ct = default) => + Task.FromResult(claims.FirstOrDefault(c => c.Id == id)); + + public Task<IReadOnlyList<GameClaim>> ForGameAsync(Guid game, CancellationToken ct = default) => + Task.FromResult<IReadOnlyList<GameClaim>>([.. claims.Where(c => c.GameId == game)]); + + public Task<IReadOnlyList<GameClaim>> ForUserAsync(Guid user, CancellationToken ct = default) => + Task.FromResult<IReadOnlyList<GameClaim>>([.. claims.Where(c => c.UserId == user)]); + + public Task<GameClaim?> FindPendingByTokenAsync(Guid g, string t, CancellationToken ct = default) => + Task.FromResult<GameClaim?>(null); + + public Task InsertAsync(GameClaim claim, CancellationToken ct = default) + { + claims.Add(claim); + return Task.CompletedTask; + } + + public Task UpdateAsync(GameClaim claim, CancellationToken ct = default) => Task.CompletedTask; + + public Task RecordEventAsync(ClaimEvent e, CancellationToken ct = default) => Task.CompletedTask; + + public Task<IReadOnlyList<ClaimEvent>> EventsAsync(Guid claim, CancellationToken ct = default) => + Task.FromResult<IReadOnlyList<ClaimEvent>>([]); + } + + private sealed class Frozen(DateTimeOffset at) : TimeProvider + { + public override DateTimeOffset GetUtcNow() => at; + } + + private sealed class NoAntiforgery : AntiforgeryStateProvider + { + public override AntiforgeryRequestToken? GetAntiforgeryToken() => null; + } + } } diff --git a/tests/MUI.Web.Tests/CrawlerStripTests.cs b/tests/MUI.Web.Tests/CrawlerStripTests.cs index 2d8a571..5337a44 100644 --- a/tests/MUI.Web.Tests/CrawlerStripTests.cs +++ b/tests/MUI.Web.Tests/CrawlerStripTests.cs @@ -1,3 +1,5 @@ +using MUI.Web.Localization; + using MUI.Catalog; using MUI.Web.Components; @@ -29,7 +31,8 @@ public async Task ARecentProbeReadsAsWorking() var pulse = Pulse(TimeSpan.FromSeconds(40)); await Assert.That(pulse.State(Now)).IsEqualTo(CrawlState.Working); - await Assert.That(CrawlerCopy.State(pulse, Now)).IsEqualTo("crawler working — last probe just now"); + await Assert.That(CrawlerCopy.State(Locales.SourceTag, pulse, Now)) + .IsEqualTo("crawler live · last probe " + Messages.For(Locales.SourceTag, "age.ago.now")); } /// <summary> @@ -46,10 +49,11 @@ public async Task ARecentProbeReadsAsWorking() public async Task AStalePulseIsQuietAndNamesNoCause() { var pulse = Pulse(TimeSpan.FromHours(4)); - var copy = CrawlerCopy.State(pulse, Now); + var copy = CrawlerCopy.State(Locales.SourceTag, pulse, Now); await Assert.That(pulse.State(Now)).IsEqualTo(CrawlState.Quiet); - await Assert.That(copy).IsEqualTo("crawler quiet — last probe 4h ago"); + await Assert.That(copy).IsEqualTo( + "crawler quiet · last probe " + Relative.Ago(Locales.SourceTag, TimeSpan.FromHours(4))); foreach (var diagnosis in new[] { "stopped", "down", "crashed", "stalled", "failed", "error", "offline" }) { @@ -65,10 +69,10 @@ public async Task TheStripNeverSaysUptimeAndNeverDescribesAGame() { var rendered = string.Join( "\n", - CrawlerCopy.State(Pulse(TimeSpan.FromSeconds(10)), Now), - CrawlerCopy.State(Pulse(TimeSpan.FromDays(2)), Now), - CrawlerCopy.LastCycle(Pulse(TimeSpan.Zero, Cycle(8, 6, 2))) ?? string.Empty, - CrawlerCopy.Registry(Pulse(TimeSpan.Zero))); + CrawlerCopy.State(Locales.SourceTag, Pulse(TimeSpan.FromSeconds(10)), Now), + CrawlerCopy.State(Locales.SourceTag, Pulse(TimeSpan.FromDays(2)), Now), + CrawlerCopy.LastCycle(Locales.SourceTag, Pulse(TimeSpan.Zero, Cycle(8, 6, 2))) ?? string.Empty, + CrawlerCopy.Registry(Locales.SourceTag, Pulse(TimeSpan.Zero))); foreach (var word in new[] { "uptime", "unreachable", "reachable" }) { @@ -85,10 +89,10 @@ public async Task TheStripNeverSaysUptimeAndNeverDescribesAGame() public async Task AnUnmeasuredPulseRendersNothing() { await Assert.That(CrawlerPulse.Unknown.State(Now)).IsEqualTo(CrawlState.NotYet); - await Assert.That(CrawlerCopy.LastCycle(CrawlerPulse.Unknown)).IsNull(); + await Assert.That(CrawlerCopy.LastCycle(Locales.SourceTag, CrawlerPulse.Unknown)).IsNull(); var html = await Render.PageAsync<Components.Pages.Home>([]); - await Assert.That(html).DoesNotContain("crawler working"); + await Assert.That(html).DoesNotContain("crawler live"); await Assert.That(html).DoesNotContain("crawler quiet"); } @@ -103,11 +107,11 @@ public async Task AnUnmeasuredPulseRendersNothing() [Test] public async Task ACycleWithNothingDueSaysSoRatherThanPrintingZeroes() { - await Assert.That(CrawlerCopy.LastCycle(Pulse(TimeSpan.Zero, Cycle(0, 0, 0)))) - .IsEqualTo("last cycle: nothing was due"); + await Assert.That(CrawlerCopy.LastCycle(Locales.SourceTag, Pulse(TimeSpan.Zero, Cycle(0, 0, 0)))) + .IsEqualTo("nothing due this cycle"); - await Assert.That(CrawlerCopy.LastCycle(Pulse(TimeSpan.Zero, Cycle(8, 6, 2)))) - .IsEqualTo("last cycle: 8 due · 6 answered · 2 failed"); + await Assert.That(CrawlerCopy.LastCycle(Locales.SourceTag, Pulse(TimeSpan.Zero, Cycle(8, 6, 2)))) + .IsEqualTo("8 due · 6 answered · 2 failed"); } /// <summary> diff --git a/tests/MUI.Web.Tests/EcosystemSurfaceTests.cs b/tests/MUI.Web.Tests/EcosystemSurfaceTests.cs index 7790ef9..ab610f6 100644 --- a/tests/MUI.Web.Tests/EcosystemSurfaceTests.cs +++ b/tests/MUI.Web.Tests/EcosystemSurfaceTests.cs @@ -1,6 +1,7 @@ using MUI.Catalog; using MUI.Web.Components; using MUI.Web.Fixtures; +using MUI.Web.Localization; namespace MUI.Web.Tests; @@ -24,6 +25,18 @@ private static async Task<string> EcosystemAsync() => private static async Task<string> RankingsAsync() => PlainText.RenderRankings(await Queries.RankingsAsync(), Now); + /// <summary> + /// One message, as the source locale renders it. + /// </summary> + /// <remarks> + /// These assertions are about what the two surfaces <em>claim</em>, not about the English they + /// happen to claim it in. Reading the claim out of the bundle keeps the guard exactly as strong + /// — a page that stopped saying it fails here — while leaving the wording free to be translated, + /// which is the whole reason it moved into the bundle. + /// </remarks> + private static string Say(string id, params (string Key, object? Value)[] args) => + Messages.For("en", id, args.ToDictionary(a => a.Key, a => a.Value, StringComparer.Ordinal)); + [Test] public async Task NoAbsolutePlayerFigureIsEmittedByEitherSurface() { @@ -43,7 +56,7 @@ public async Task NoAbsolutePlayerFigureIsEmittedByEitherSurface() await Assert.That(text).DoesNotContain("across all games"); // And it says out loud that the omission is deliberate rather than an oversight. - await Assert.That(Render.Words(text)).Contains("Shares, never totals"); + await Assert.That(Render.Words(text)).Contains(Say("ecosystem.noTotals")); } [Test] @@ -73,9 +86,14 @@ public async Task BothDenominatorsAreNamedRatherThanImplied() // talkative and calling the difference adoption. var text = Render.Words(await EcosystemAsync()); - await Assert.That(text).Contains("whose handshake we completed"); - await Assert.That(text).Contains("whose MSSP report we hold"); - await Assert.That(text).Contains("Two sets of games, so two denominators"); + var dashboard = await Queries.EcosystemAsync(); + + await Assert.That(text).Contains(EcosystemCopy.Handshakes("en", dashboard.Handshakes)); + await Assert.That(text).Contains(EcosystemCopy.MsspReports("en", dashboard.MsspReports)); + await Assert.That(text).Contains(Say( + "ecosystem.plain.denominators", + ("measured", EcosystemCopy.Handshakes("en", dashboard.Handshakes)), + ("declared", EcosystemCopy.MsspReports("en", dashboard.MsspReports)))); } [Test] @@ -85,12 +103,15 @@ public async Task AProtocolWithNoMeasurementSaysSoRatherThanShowingNoughtPerCent // this, which is a fact about our reach; "0.0%" is a claim about everybody else's servers. var never = new ProtocolAdoption("TLS", Offered: null, Declined: 0, Handshakes: 400, Declared: 12, MsspReports: 300); - await Assert.That(EcosystemCopy.Measured(never)).Contains("not measured"); - await Assert.That(EcosystemCopy.Measured(never)).DoesNotContain("0.0%"); - await Assert.That(EcosystemCopy.Measured(never)).DoesNotContain("0 of 400"); + await Assert.That(EcosystemCopy.Measured("en", never)) + .IsEqualTo(Say("ecosystem.measured.never")); + await Assert.That(EcosystemCopy.Measured("en", never)).DoesNotContain("0.0%"); + await Assert.That(EcosystemCopy.Measured("en", never)).DoesNotContain("0 of 400"); // The declared side is unaffected and still carries its own set. - await Assert.That(EcosystemCopy.Declared(never)).IsEqualTo("12 of 300 (4.0%)"); + await Assert.That(EcosystemCopy.Declared("en", never)).IsEqualTo( + Say("ecosystem.share", ("count", 12), ("total", 300), ("fraction", 12d / 300))); + await Assert.That(EcosystemCopy.Declared("en", never)).IsEqualTo("12 of 300 (4.0%)"); } [Test] @@ -100,8 +121,9 @@ public async Task AnEmptyDenominatorIsNothingMeasuredAndNotNoughtPerCent() var nothing = new MeasuredShare("GMCP", 0, 0); await Assert.That(nothing.Fraction).IsNull(); - await Assert.That(EcosystemCopy.Share(nothing)).Contains("nothing measured yet"); - await Assert.That(EcosystemCopy.Share(nothing)).DoesNotContain("%"); + await Assert.That(EcosystemCopy.Share("en", nothing)) + .IsEqualTo(Say("ecosystem.share.nothing", ("count", 0), ("total", 0))); + await Assert.That(EcosystemCopy.Share("en", nothing)).DoesNotContain("%"); } [Test] @@ -112,8 +134,7 @@ public async Task TheMeasuredColumnIsSaidToBeAFloor() // saying so publishes our own instrumentation as a fact about somebody's game. var text = Render.Words(await EcosystemAsync()); - await Assert.That(text).Contains("may support a protocol without ever offering it"); - await Assert.That(text).Contains("as a floor"); + await Assert.That(text).Contains(Say("ecosystem.protocols.floor")); } [Test] @@ -124,8 +145,8 @@ public async Task TheDashboardCallsItselfASnapshotAndNotATrend() // crawl reaching more games and nothing about anybody adopting anything. var text = Render.Words(await EcosystemAsync()); - await Assert.That(text).Contains("A snapshot of what we can measure now"); - await Assert.That(text).Contains("nothing to plot"); + await Assert.That(text).Contains(Say("ecosystem.snapshot")); + await Assert.That(text).Contains(Say("ecosystem.transitions.none")); await Assert.That(text).DoesNotContain("growth"); } @@ -138,7 +159,10 @@ public async Task AGameWithNoCodebaseIsOutsideTheDenominatorAndSaidToBe() await Assert.That(dashboard.Codebases.NotIdentified).IsGreaterThan(0); await Assert.That(dashboard.Codebases.Families.Sum(f => f.Count)) .IsEqualTo(dashboard.Codebases.Identified); - await Assert.That(text).Contains("left out of the denominator, never counted as something else"); + await Assert.That(text).Contains(Say( + "ecosystem.codebases.basis", + ("listed", dashboard.Codebases.Identified + dashboard.Codebases.NotIdentified), + ("identified", dashboard.Codebases.Identified))); } [Test] @@ -155,8 +179,13 @@ public async Task TheCodebasePanelNamesTheListingBesideTheGamesThatAnswered() await Assert.That(listed).IsEqualTo(dashboard.ListedGames); await Assert.That(dashboard.Codebases.Identified).IsNotEqualTo(listed); - await Assert.That(text).Contains($"Of the {listed} games listed, {dashboard.Codebases.Identified} told us what they run"); - await Assert.That(text).Contains($"every share below is over those {dashboard.Codebases.Identified}"); + // Both numbers in one sentence, and each unmistakable for the other. + await Assert.That(text).Contains(Say( + "ecosystem.codebases.basis", + ("listed", listed), + ("identified", dashboard.Codebases.Identified))); + await Assert.That(text).Contains($"{listed} games listed"); + await Assert.That(text).Contains($"over those {dashboard.Codebases.Identified}"); } /// <summary>The one-game codebases are folded out of the chart and listed under it.</summary> @@ -177,7 +206,8 @@ public async Task ACodebaseOnlyOneGameRunsIsFoldedOutOfTheChartAndStillPrinted() await Assert.That(text).Contains( $"{codebases.SoleUseTotal.Count} of {codebases.Identified}"); - await Assert.That(text).Contains("no other listed game runs"); + await Assert.That(text).Contains( + Say("ecosystem.soleUse", ("share", EcosystemCopy.Share("en", codebases.SoleUseTotal)))); foreach (var alone in codebases.SoleUse) { @@ -201,7 +231,8 @@ public async Task TheMsspRowStaysBecauseItIsTheOnlyMeasurementThatIsNotAFloor() await Assert.That(mssp.Measured).IsNotNull(); await Assert.That(mssp.Declined).IsGreaterThan(0); await Assert.That(text).Contains("MSSP"); - await Assert.That(text).Contains("is the one row below that is not a floor"); + await Assert.That(text).Contains( + Say("ecosystem.mssp.instrument", ("instrument", EcosystemProtocols.Instrument))); } [Test] @@ -218,9 +249,9 @@ public async Task OnlyMsspHasNoDeclaredFigureAndTheReasonIsItsDenominator() var blank = dashboard.Protocols.Where(p => p.DeclaredShare is null).Select(p => p.Protocol); await Assert.That(blank).IsEquivalentTo(new[] { "MSSP" }); - await Assert.That(EcosystemCopy.Declared(dashboard.Protocols.Single(p => p.Protocol == "MSSP"))) + await Assert.That(EcosystemCopy.Declared("en", dashboard.Protocols.Single(p => p.Protocol == "MSSP"))) .DoesNotContain("%"); - await Assert.That(text).Contains("every report here is the answer"); + await Assert.That(text).Contains(Say("ecosystem.declared.none")); } [Test] @@ -236,13 +267,14 @@ public async Task TwoCountsOfMsspAreReconciledRatherThanLeftToSubtract() var withGap = new ProtocolAdoption("MSSP", Offered: 123, Declined: 295, Handshakes: 418, Declared: 1, MsspReports: 131); - await Assert.That(EcosystemCopy.MsspBasis(withGap, 131)).Contains("We hold 131 reports"); - await Assert.That(EcosystemCopy.MsspBasis(withGap, 131)).Contains("the other 8"); + await Assert.That(EcosystemCopy.MsspBasis("en", withGap, 131)).Contains( + Say("ecosystem.mssp.gap", ("reports", 131), ("offered", 123), ("gap", 8))); // And no gap means no sentence about one, rather than "the other 0". var level = withGap with { Offered = 131 }; - await Assert.That(EcosystemCopy.MsspBasis(level, 131)).DoesNotContain("the other"); + await Assert.That(EcosystemCopy.MsspBasis("en", level, 131)) + .IsEqualTo(Say("ecosystem.mssp.instrument", ("instrument", EcosystemProtocols.Instrument))); } [Test] @@ -250,9 +282,15 @@ public async Task TheRankingsStateWhatTheyRankOnAndOverWhatWindow() { var text = Render.Words(await RankingsAsync()); - await Assert.That(text).Contains("Median of the player counts we measured over the last 7 days"); - await Assert.That(text).Contains("counted samples a median needs"); - await Assert.That(text).Contains("A measured zero counts; an unreadable count does not"); + await Assert.That(text).Contains(Say("rankings.basis.median", ("days", 7))); + + // The threshold, as a sentence rather than as arithmetic. Where nothing qualifies the page + // said "0 of 519 games listed produced the 24 counted samples a median needs, on at least 4 + // days of the window", which is a subtraction the reader was left to do. + await Assert.That(text).Contains("24 samples across 4 days"); + + // Rule 4 on the surface that most invites a zero to be read as an absence. + await Assert.That(text).Contains(Say("rankings.basis.zero")); } [Test] @@ -261,7 +299,7 @@ public async Task TheRankingsOfferNoVoteAndClaimNoBest() // §2's permanent non-goal, said on the surface a reader would look for it on. var text = Render.Words(await RankingsAsync()); - await Assert.That(text).Contains("No votes, stars or ratings, ever"); + await Assert.That(text).Contains(Say("rankings.noVote")); await Assert.That(text.ToLowerInvariant()).DoesNotContain("rate this"); await Assert.That(text.ToLowerInvariant()).DoesNotContain("top rated"); } diff --git a/tests/MUI.Web.Tests/FacetSurfaceTests.cs b/tests/MUI.Web.Tests/FacetSurfaceTests.cs index 6cf11d6..1f6e01c 100644 --- a/tests/MUI.Web.Tests/FacetSurfaceTests.cs +++ b/tests/MUI.Web.Tests/FacetSurfaceTests.cs @@ -1,3 +1,4 @@ +using MUI.Web.Localization; using System.Reflection; using MUI.Catalog; @@ -39,6 +40,12 @@ .. typeof(FacetKeys) FacetKeys.Tls => "true", FacetKeys.Band => "quiet", FacetKeys.LastSeen => "week", + + // One word each, like the two bands above and unlike the open-ended facets: their + // vocabularies are a single value, so the binding refuses anything else rather than + // narrowing a listing to nothing on a typo. + FacetKeys.Uncounted => "yes", + FacetKeys.Unreachable => "yes", FacetKeys.Protocol => "GMCP", // Not the default. The point of the check below is that the parameter changed something, // and asking for the order the filter already arrives in changes nothing by construction. @@ -216,9 +223,16 @@ public async Task ThePanelIsAPlainGetFormWithAControlPerFacet() await Assert.That(html).Contains("action=\"/games\""); await Assert.That(html).DoesNotContain("<script"); + // Every facet reaches the same querystring, whichever shape its control has: the presence + // facets are checkboxes the form submits, and the choice facets are links that carry the + // key themselves — a control that waited for a "show" button was a filter that did nothing + // when a reader clicked it. foreach (var group in (await Queries.SearchAsync(new GameFilter())).Facets) { - await Assert.That(html).Contains($"name=\"{group.Key}\""); + var named = html.Contains($"name=\"{group.Key}\"", StringComparison.Ordinal) + || html.Contains($"/games?{group.Key}=", StringComparison.Ordinal); + + await Assert.That(named).IsTrue().Because($"{group.Key} reaches no querystring"); } } @@ -228,12 +242,72 @@ public async Task EveryValueOnThePanelCarriesTheCountChoosingItReturns() var listing = await Queries.SearchAsync(new GameFilter()); var html = Render.Words(await PanelAsync(new GameFilter())); + // A row per value now, rather than an option per value twice over: the count is its own cell + // beside the name, and it is also in both radios' accessible names — the one that includes + // the value carries what including it returns, the one that excludes it carries what + // excluding it returns. A control offering a number the listing would not produce is the + // failure this guards against, in either direction. foreach (var group in listing.Facets.Where(g => g.Kind is FacetKind.Choice)) { + var single = FacetWords.IsSingleChoice(group.Key); + foreach (var value in group.Values) { - await Assert.That(html) - .Contains($"{FacetWords.Value(group.Key, value)} ({value.Count})"); + var name = FacetWords.Value(Locales.SourceTag, group.Key, value); + + // "only" is on the tri-state groups alone. Activity and last-seen are one ordered + // scale — a radio group — so their rows say what choosing returns and nothing about + // a second state they do not have. + await Assert.That(html).Contains(single + ? $"{name}, {Plural(value.Count)}" + : $"{name}, {Plural(value.Count)}, only"); + + if (!single) + { + await Assert.That(html) + .Contains($"{name}, {Plural(group.Total - value.Count)}, excluded"); + } + } + } + } + + /// <summary> + /// A count and its noun, agreeing — because the panel says it that way. + /// </summary> + /// <remarks> + /// Every accessible name on the panel read "1 games" and "0 games" until this pass. English has + /// two forms and this is the one place the panel says a number out loud, so it says it + /// correctly; the test spells the rule out rather than accepting whatever the panel produced. + /// </remarks> + private static string Plural(int count) => count == 1 ? "1 game" : $"{count} games"; + + [Test] + public async Task ExclusionIsOfferedOnlyWhereExcludingMeansSomething() + { + // Activity and last-seen are nested thresholds on one ordered scale: a game reached an hour + // ago is also in the last seven days and the last thirty, and "connected now" is a narrower + // window than "active this week" rather than a different kind of thing. "Everything but + // games with somebody connected" is not a question anybody has — so those groups are radios + // with no exclude affordance at all, which is one control and one tab stop per value instead + // of two. + var listing = await Queries.SearchAsync(new GameFilter()); + var html = await PanelAsync(new GameFilter()); + + foreach (var group in listing.Facets.Where(g => g.Kind is FacetKind.Choice)) + { + foreach (var value in group.Values) + { + var excluded = $"{FacetWords.Value(Locales.SourceTag, group.Key, value)}, {Plural(group.Total - value.Count)}, excluded"; + + if (FacetWords.IsSingleChoice(group.Key)) + { + await Assert.That(html).DoesNotContain(excluded) + .Because($"{group.Key} is one ordered scale and cannot be excluded from"); + } + else + { + await Assert.That(html).Contains(excluded); + } } } } @@ -241,19 +315,19 @@ await Assert.That(html) [Test] public async Task ThePanelSaysInWordsThatAnUnknownIsNotANo() { - // Said in the markup, not only in a comment. A reader ticking boxes is exactly the person who - // would otherwise read an unticked box as the game declining a protocol. + // Said in the markup, not only in a comment. A reader who reads an unticked box as the game + // declining a protocol has been told something the site never measured. // - // The prose these used to sit in is gone — the panel explained itself at more length than it - // took to operate — so each of them now has a place of its own: the tick-box reading is a - // line inside the fieldset it is about, and the rest is one disclosure. What may not change - // is that they are all still in the document, which is what this asserts. + // The three lines that used to sit under each group header are gone at the user's direction, + // so the reading now has one home rather than several: the disclosure at the foot of the + // panel. What may not change is that it is still in the document — a <details> keeps its + // contents in the accessibility tree and in what a text browser is served, which is what + // makes it a fair place to put the long form of a rule and not a place to hide one. var words = Render.Words(await PanelAsync(new GameFilter())); - await Assert.That(words).Contains("Unticked is not a no"); await Assert.That(words).Contains("A blank is a gap in our measurement, not a no"); await Assert.That(words).Contains("not identified"); - await Assert.That(words).Contains("from the same query as the list below"); + await Assert.That(words).Contains("Counts are games we measured, never estimates"); await Assert.That(words).Contains("An unknown count is not a zero"); } @@ -267,7 +341,7 @@ public async Task TheDisclosureIsAnAffordanceRatherThanAPlaceToHideThings() var html = await PanelAsync(new GameFilter()); await Assert.That(html).Contains("<summary>"); - await Assert.That(Render.Words(html)).Contains("what a blank means"); + await Assert.That(Render.Words(html)).Contains("what the badges and the blanks mean"); } [Test] @@ -282,9 +356,9 @@ public async Task AFacetWithNoValueForAGameSpellsThatOutInItsOwnWords() await Assert.That(words).Contains("not declared"); await Assert.That(words).Contains("nothing negotiated"); - await Assert.That(FacetWords.Unknown(FacetKeys.Codebase)).IsNotEqualTo("no"); - await Assert.That(FacetWords.Unknown(FacetKeys.Genre)) - .IsNotEqualTo(FacetWords.Unknown(FacetKeys.Charset)); + await Assert.That(FacetWords.Unknown(Locales.SourceTag, FacetKeys.Codebase)).IsNotEqualTo("no"); + await Assert.That(FacetWords.Unknown(Locales.SourceTag, FacetKeys.Genre)) + .IsNotEqualTo(FacetWords.Unknown(Locales.SourceTag, FacetKeys.Charset)); } [Test] @@ -303,16 +377,16 @@ public async Task EachFacetSaysWhetherItIsAMeasurementOrTheGamesOwnClaim() // likely to guess at and the one it would matter most to leave unexplained. foreach (var evidence in Enum.GetValues<FacetEvidence>()) { - await Assert.That(words).Contains(FacetWords.Evidence(evidence)); - await Assert.That(words).Contains(FacetWords.EvidenceMeaning(evidence)); + await Assert.That(words).Contains(FacetWords.Evidence(Locales.SourceTag, evidence)); + await Assert.That(words).Contains(FacetWords.EvidenceMeaning(Locales.SourceTag, evidence)); } // And no two of them say the same thing, or the panel has a distinction it cannot draw. var registers = Enum.GetValues<FacetEvidence>().Length; - await Assert.That(Enum.GetValues<FacetEvidence>().Select(FacetWords.Evidence).Distinct().Count()) + await Assert.That(Enum.GetValues<FacetEvidence>().Select(e => FacetWords.Evidence(Locales.SourceTag, e)).Distinct().Count()) .IsEqualTo(registers); await Assert.That( - Enum.GetValues<FacetEvidence>().Select(FacetWords.EvidenceMeaning).Distinct().Count()) + Enum.GetValues<FacetEvidence>().Select(e => FacetWords.EvidenceMeaning(Locales.SourceTag, e)).Distinct().Count()) .IsEqualTo(registers); } @@ -330,7 +404,7 @@ public async Task AGroupsEvidenceIsSaidOnTheGroupAndNotOnlyInTheKey() // Read off the label element itself rather than off an offset into the page: the facet // names are ordinary English words and several of them occur in the option text of other // facets, so anything positional here measures the wrong thing. - var marker = $"<span class=\"facet-name\">{FacetWords.Group(group.Key)}</span>"; + var marker = $"<span class=\"facet-name\">{DrawnUnder(group.Key)}</span>"; var at = html.IndexOf(marker, StringComparison.Ordinal); await Assert.That(at).IsGreaterThanOrEqualTo(0).Because($"{group.Key} has no name of its own"); @@ -345,19 +419,39 @@ public async Task AGroupsEvidenceIsSaidOnTheGroupAndNotOnlyInTheKey() // The class and the word are the same string on purpose: a second copy of the mapping // here is a place for the test and the panel to drift apart, and it did — a register // added to the enum arrived in this helper as "declared". - await Assert.That(label).Contains($"evidence {FacetWords.Evidence(group.Evidence)}") + await Assert.That(label).Contains($"evidence {FacetWords.Evidence(Locales.SourceTag, group.Evidence)}") .Because($"{group.Key} has no evidence chip beside its own name"); } } + /// <summary> + /// The heading a facet's rows are actually drawn under, which is its own name for all but two. + /// </summary> + /// <remarks> + /// <c>uncounted</c> and <c>unreachable</c> share one legend, because they are one question with + /// two independent answers rather than two facets that happen to be adjacent — see the panel. + /// The guarantee this test exists for is unweakened by that: the evidence chip is on the legend + /// both rows sit under, so a reader still cannot reach either count without having been told + /// what kind of statement it is. What would weaken it is a group drawn with no heading at all, + /// and that is still what this fails on. + /// </remarks> + private static string DrawnUnder(string key) => + key is FacetKeys.Uncounted or FacetKeys.Unreachable + ? Messages.For(Locales.SourceTag, "facet.group.measure") + : FacetWords.Group(Locales.SourceTag, key); + [Test] public async Task AChosenValueIsMarkedSoTheFormShowsWhatTheUrlAsked() { + // No <select> and no checkbox left on this panel: the state is the row's own class and its + // aria-current, and the way out is the row's own link. A control that showed nothing at rest + // until it was opened is the defect the rows replace. var filter = new GameFilter { Band = ActivityBand.Archived, IncludeArchived = true }; var html = await PanelAsync(filter); - await Assert.That(html).Contains("selected"); - await Assert.That(html).Contains("checked"); + await Assert.That(html).Contains("aria-current=\"true\""); + await Assert.That(html).Contains("facet-row on"); + await Assert.That(html).DoesNotContain("<select"); } [Test] @@ -409,7 +503,7 @@ public async Task WhatTheQueryIsAskingForIsRepeatedAsChipsThatRemoveThemselves() await Assert.That(GameFilterBinding.TryRead(Url, out var query, out _)).IsTrue(); var listing = await Queries.SearchAsync(query.Filter); - var chips = ActiveFilters.For(listing.Facets, query.Filter, Url); + var chips = ActiveFilters.For(Locales.SourceTag, listing.Facets, query.Filter, Url); await Assert.That(chips.Select(c => c.Value)).Contains("not Evennia"); await Assert.That(chips.Select(c => c.Value)).Contains("sun"); @@ -421,6 +515,50 @@ public async Task WhatTheQueryIsAskingForIsRepeatedAsChipsThatRemoveThemselves() await Assert.That(gmcp.RemoveHref).DoesNotContain("GMCP"); } + /// <summary>Every chip is a translated word, including the four the panel does not supply.</summary> + /// <remarks> + /// Three chips are built by <see cref="ActiveFilters"/> itself rather than read off a facet + /// group — a typed name, and the two widenings — and all three, plus the word "included", were + /// still literal English after the rest of the site was localized. A translated listing rendered + /// them beside translated chips, so one row mixed two languages. Asserted by asking the bundle + /// what each says rather than by repeating the English, which is the whole point of the fix. + /// </remarks> + [Test] + public async Task EveryChipIsAWordFromTheBundleAndNotALiteral() + { + const string Url = $"?q=sun&{FacetKeys.Archived}=true&{FacetKeys.Adult}=true"; + var en = Locales.SourceTag; + + await Assert.That(GameFilterBinding.TryRead(Url, out var query, out _)).IsTrue(); + + var listing = await Queries.SearchAsync(query.Filter); + var chips = ActiveFilters.For(en, listing.Facets, query.Filter, Url); + var facets = chips.Select(c => c.Facet).ToList(); + + foreach (var key in (string[])[FacetKeys.Text, FacetKeys.Archived, FacetKeys.Adult]) + { + await Assert.That(facets) + .Contains(FacetWords.Group(en, key)) + .Because($"the {key} chip names itself from the bundle"); + } + + // "included" is the only chip value that is a state of ours rather than a token a game gave + // us, so it is the only one that has to be translated rather than passed through. + var included = Messages.For(en, "facet.value.included"); + + await Assert.That(chips.Count(c => c.Value == included)).IsEqualTo(2); + + // And none of the four is a bare key leaking through FacetWords.Group's fallback, which + // cannot be told from the English by comparing strings — "archived" is both the facet key + // and the word. So the bundle is asked whether it owns the id at all: an id the bundle has + // is an id a translator can reach, and that is the thing being asserted. + foreach (var id in (string[]) + ["facet.group.search", "facet.group.archived", "facet.group.adult", "facet.value.included"]) + { + await Assert.That(Messages.Ids).Contains(id); + } + } + [Test] public async Task NothingSelectedIsNoChipsAtAll() { @@ -433,7 +571,7 @@ public async Task NothingSelectedIsNoChipsAtAll() var listing = await Queries.SearchAsync(query.Filter); - await Assert.That(ActiveFilters.For(listing.Facets, query.Filter, string.Empty)).IsEmpty(); + await Assert.That(ActiveFilters.For(Locales.SourceTag, listing.Facets, query.Filter, string.Empty)).IsEmpty(); } [Test] @@ -448,13 +586,20 @@ public async Task AnUnreadableSortIsRefusedRatherThanQuietlyIgnored() [Test] public async Task TheSortIsAControlOnThePanelAndAParameterInTheUrl() { + // The order moved off this panel and into the listing's own toolbar, over the column whose + // numbers it changes — a pressed-state switch of links rather than a <select> that armed + // itself and waited for a "show" button. What the panel may not do is keep a second, stale + // copy of the control. var html = await PanelAsync(new GameFilter { Sort = GameSort.Players }); - await Assert.That(html).Contains($"name=\"{FacetKeys.Sort}\""); + await Assert.That(html).DoesNotContain($"name=\"{FacetKeys.Sort}\""); + await Assert.That(html).DoesNotContain("<select"); + // Every order is still a parameter, and still named, wherever it is drawn. foreach (var sort in Enum.GetValues<GameSort>()) { - await Assert.That(Render.Words(html)).Contains(FacetWords.Sort(sort)); + await Assert.That(FacetWords.Sort(Locales.SourceTag, sort)).IsNotEmpty(); + await Assert.That(FacetTokens.Of(sort)).IsNotEmpty(); } } @@ -466,11 +611,241 @@ public async Task NoSortCallsItselfBusiestBecauseTheRankingsPageAlreadyMeansSome // answering to one name on one site is how a reader ends up comparing them. foreach (var sort in Enum.GetValues<GameSort>()) { - await Assert.That(FacetWords.Sort(sort)).DoesNotContain("busiest"); - await Assert.That(FacetWords.Sort(sort)).DoesNotContain("popular"); + await Assert.That(FacetWords.Sort(Locales.SourceTag, sort)).DoesNotContain("busiest"); + await Assert.That(FacetWords.Sort(Locales.SourceTag, sort)).DoesNotContain("popular"); } } + [Test] + public async Task AValueIsOneRowWithThreeStatesRatherThanTwoOptionsInTwoLists() + { + // Finding B3. Every value used to appear twice in one select — once under "only", once under + // "anything but" — so thirteen codebases were twenty-seven options, read out as near-identical + // pairs, and the state showed nothing at rest: a select sitting in its second group looks + // exactly like one sitting on "any" until it is opened. + // + // Two radios per row now, sharing the facet's key. No script: the browser's own group + // behaviour is what clears the other rows, and the querystring is the one the binding and the + // read API already parse. + var html = await PanelAsync(new GameFilter()); + + var grid = html[html.IndexOf("facet-grid", StringComparison.Ordinal)..]; + + // The sort control keeps its optgroups — grouping nine orders by what each one reads is a + // different job from listing one facet's values twice. + await Assert.That(grid).DoesNotContain("<optgroup"); + // Links, not controls: a filter that needs a second click on a "show" button before it does + // anything is a filter panel that does not work, which is what radios made these. + await Assert.That(html).Contains("href=\"/games?codebase=Evennia\""); + await Assert.That(html).Contains("href=\"/games?codebase=%21Evennia\""); + + // And the whole facet is still one tab stop, as the select was: one radio group, arrow keys + // within it. + // And no prose under the group headers. The three notes that lived there — "tick to + // include", "pick one", "unticked means not measured" — are gone at the user's direction: + // the control's shape says what it does, and a panel explaining itself once per group is a + // panel nobody reads once. + await Assert.That(Render.Words(html)).DoesNotContain("Tick to include"); + await Assert.That(Render.Words(html)).DoesNotContain("Pick one."); + await Assert.That(Render.Words(html)).DoesNotContain("Unticked means not measured"); + } + + [Test] + public async Task AnExcludedValueSaysSoInTheRowAndInTheControlsName() + { + // "PennMUSH, 23 games, excluded" — the value, the count excluding it returns, and the state, + // in the accessible name, because a reader arrowing through a radio group hears the control + // and not the row around it. The strike-through and the × are the drawing of the same fact, + // and neither of them is a colour. + var html = await PanelAsync(new GameFilter { Codebase = FacetChoice.Not("Evennia") }); + + await Assert.That(html).Contains("class=\"facet-row excluded\""); + await Assert.That(Render.Words(html)).Contains("games, excluded\""); + // And the applied one links to clearing itself, so a row unticks where it was ticked. + await Assert.That(html).Contains("aria-current=\"true\""); + await Assert.That(html).Contains("href=\"/games\""); + } + + // ── what we could measure ──────────────────────────────────────────────────────────────── + + [Test] + public async Task TheDemoTellsAMeasuredZeroFromAnUnreadableCountFromAGameWeNeverReached() + { + // The fixture's own three-way split, asserted before anything renders. All three of these + // games are on the listing and none of them is "a game with players on"; Eldertale was + // counted and found empty, Midnight Sun answered and could not be counted, and Hollow Bell + // did not answer. A demo that could not tell them apart would be a demo of the wrong site. + var listing = await Queries.SearchAsync(new GameFilter()); + + var uncounted = await Queries.ListAsync( + new GameFilter { Uncounted = FacetChoice.Of(FacetTokens.Yes) }); + var unreachable = await Queries.ListAsync( + new GameFilter { Unreachable = FacetChoice.Of(FacetTokens.Yes) }); + + await Assert.That(uncounted.Select(g => g.Slug)).IsEquivalentTo(new[] { "midnight-sun" }); + await Assert.That(unreachable.Select(g => g.Slug)).IsEquivalentTo(new[] { "hollow-bell" }); + + // Eldertale is the trap: a measured nought, in the same activity band as Midnight Sun. + var eldertale = listing.Games.Single(g => g.Slug == "eldertale"); + + await Assert.That(eldertale.PlayersNow).IsEqualTo(0); + await Assert.That(uncounted.Any(g => g.Slug == "eldertale")).IsFalse(); + + // And Hollow Bell is the other one: no number, and not because we failed to read one. + await Assert.That(uncounted.Any(g => g.Slug == "hollow-bell")).IsFalse(); + } + + [Test] + public async Task TheGroupDrawsBothSwitchesUnderOneHeadingWithTheirRealCounts() + { + var html = Render.Words(await PanelAsync(new GameFilter())); + var listing = await Queries.SearchAsync(new GameFilter()); + + await Assert.That(html).Contains(Messages.For(Locales.SourceTag, "facet.group.measure")); + + foreach (var key in new[] { FacetKeys.Uncounted, FacetKeys.Unreachable }) + { + var group = listing.Facets.Single(f => f.Key == key); + var value = group.Values.Single(); + + await Assert.That(value.Count).IsGreaterThan(0); + await Assert.That(html) + .Contains(FacetWords.Value(Locales.SourceTag, key, value)) + .Because($"{key} has no row on the panel"); + + // The count beside it is the one the listing keeps, which is the panel's whole promise. + await Assert.That((await Queries.ListAsync(Choose(key))).Count).IsEqualTo(value.Count); + } + } + + [Test] + public async Task HidingThemIsSaidToBeOurFilterAndNotAClaimAboutTheGames() + { + // Rule 5 on the one control most likely to be read the other way. A reader who unticks these + // has changed their listing, and the panel has to say that in words rather than leave a + // shorter listing to be read as a shorter hobby. + var html = Render.Words(await PanelAsync(new GameFilter())); + + await Assert.That(html).Contains(Messages.For(Locales.SourceTag, "facet.measure.note")); + + // And the same sentence survives on the surface that has no styling to carry a tone. Read + // with the whitespace collapsed, because the plain renderer wraps at 80 columns and the + // sentence is longer than that — a literal comparison here would be asserting where the line + // breaks fall rather than that the words are present. + var listing = await Queries.SearchAsync(new GameFilter()); + var text = PlainText.RenderListing(listing, new GameFilter(), FixtureGameQueries.Now); + + await Assert.That(Flowed(text)) + .Contains(Flowed(Messages.For(Locales.SourceTag, "facet.measure.note"))); + } + + /// <summary>One line of text, whatever column the renderer broke it at.</summary> + private static string Flowed(string text) => + string.Join(' ', text.Split((char[]?)null, StringSplitOptions.RemoveEmptyEntries)); + + [Test] + public async Task ThePlainSurfaceDrawsIncludedAndExcludedDifferently() + { + // "Only these" and "anything but these" are opposite filters, and one star for both drew + // them identically on the surface where a reader has nothing else to go on. It matters most + // here, because excluding is what these two switches are mostly for. + var included = new GameFilter { Uncounted = FacetChoice.Of(FacetTokens.Yes) }; + var excluded = new GameFilter { Uncounted = FacetChoice.Not(FacetTokens.Yes) }; + + var onText = PlainText.RenderListing( + await Queries.SearchAsync(included), included, FixtureGameQueries.Now); + var offText = PlainText.RenderListing( + await Queries.SearchAsync(excluded), excluded, FixtureGameQueries.Now); + + await Assert.That(onText).Contains($"* {FacetTokens.Yes}"); + await Assert.That(offText).Contains($"- {FacetTokens.Yes}"); + await Assert.That(offText).DoesNotContain($"* {FacetTokens.Yes}"); + + // And the column has a key, because a mark nobody explains is a mark nobody reads. + await Assert.That(Flowed(offText)) + .Contains(Flowed(Messages.For(Locales.SourceTag, "facet.plain.marks"))); + } + + [Test] + [Arguments(FacetKeys.Uncounted)] + [Arguments(FacetKeys.Unreachable)] + public async Task EachSwitchRoundTripsThroughTheQuerystringInBothPolarities(string key) + { + // Three states and a URL for each, read back by the one parser /games and /api/games share. + foreach (var token in new[] { FacetTokens.Yes, FacetChoice.ExcludeToken + FacetTokens.Yes }) + { + var read = GameFilterBinding.TryRead($"?{key}={token}", out var query, out var error); + + await Assert.That(read).IsTrue().Because($"?{key}={token}: {error}"); + + var choice = key == FacetKeys.Uncounted ? query.Filter.Uncounted : query.Filter.Unreachable; + + await Assert.That(choice).IsNotNull(); + await Assert.That(choice!.Token).IsEqualTo(token); + + // The panel's own link for that state is in the markup, so the round trip is a click and + // not only a hand-typed URL. + var html = await PanelAsync(query.Filter); + await Assert.That(html).Contains("aria-current=\"true\""); + } + + // And absent is the third state: not asked, and so not narrowed. + GameFilterBinding.TryRead(string.Empty, out var bare, out _); + await Assert.That(key == FacetKeys.Uncounted ? bare.Filter.Uncounted : bare.Filter.Unreachable) + .IsNull(); + } + + [Test] + [Arguments(FacetKeys.Uncounted)] + [Arguments(FacetKeys.Unreachable)] + public async Task AValueTheseSwitchesDoNotHaveIsRefusedRatherThanQuietlyEmptying(string key) + { + // Their vocabulary is one word, so anything else is a typo — and a typo that narrowed the + // listing to nothing would hand a reader an empty page to read as "no game is like that", + // which is our own parser published as a measurement of the hobby. + var read = GameFilterBinding.TryRead($"?{key}=maybe", out _, out var error); + + await Assert.That(read).IsFalse(); + await Assert.That(error).IsNotNull(); + await Assert.That(error!).Contains(FacetTokens.Yes); + } + + [Test] + public async Task ExcludingBothLeavesAListingThatStillOffersTheWayBack() + { + // The listing shrinks and the two controls that shrank it stay drawn, at the count that + // undoing them returns. A selection whose only affordance has gone is the defect the rows + // replaced. + var filter = new GameFilter + { + Uncounted = FacetChoice.Not(FacetTokens.Yes), + Unreachable = FacetChoice.Not(FacetTokens.Yes), + }; + + var listing = await Queries.SearchAsync(filter); + var html = await PanelAsync(filter); + + await Assert.That(listing.Games.Any(g => g.Slug == "midnight-sun")).IsFalse(); + await Assert.That(listing.Games.Any(g => g.Slug == "hollow-bell")).IsFalse(); + + // Eldertale is a measured nought and survives both exclusions, which is the point of them + // being two facets rather than one word for "no number". + await Assert.That(listing.Games.Any(g => g.Slug == "eldertale")).IsTrue(); + + foreach (var key in new[] { FacetKeys.Uncounted, FacetKeys.Unreachable }) + { + await Assert.That(listing.Facets.Single(f => f.Key == key).Values.Single().State) + .IsEqualTo(FacetState.Excluded); + } + + await Assert.That(Render.Words(html)) + .Contains(Messages.For(Locales.SourceTag, "facet.excluded.uncounted")); + } + + private static GameFilter Choose(string key) => key == FacetKeys.Uncounted + ? new GameFilter { Uncounted = FacetChoice.Of(FacetTokens.Yes) } + : new GameFilter { Unreachable = FacetChoice.Of(FacetTokens.Yes) }; + private static async Task<string> PanelAsync(GameFilter filter) { var listing = await Queries.SearchAsync(filter); @@ -483,28 +858,28 @@ private static async Task<string> PanelAsync(GameFilter filter) } /// <summary> - /// A filter as one comparable string. + /// A filter as one comparable string, so two of them can be compared for having read anything. /// </summary> /// <remarks> + /// <para> /// Record equality would compare <see cref="GameFilter.MeasuredProtocols"/> by reference and so /// call every parsed filter different from every other — which would make the test above pass /// whatever the parser did with a key. + /// </para> + /// <para> + /// <b>Read off the type rather than listed here, and that is the fix rather than tidying.</b> + /// This was a hand-written roll-call of sixteen members, in a test whose entire job is to catch a + /// facet that was added in one place and forgotten in another — so a new member reached it as + /// silence: the binding read the parameter correctly, the fingerprint could not see it, and the + /// failure said "nothing reads it" about the one thing that did. A list maintained by hand + /// cannot be the check on a list maintained by hand. + /// </para> /// </remarks> private static string Describe(GameFilter f) => string.Join( '|', - f.Text, - f.IncludeArchived, - f.IncludeAdult, - f.Tls, - f.Band, - f.LastSeen, - f.Charset?.Token, - f.Codebase?.Token, - f.CodebaseVersion?.Token, - f.Lineage?.Token, - f.Family?.Token, - f.Genre?.Token, - f.Language?.Token, - f.Sort, - string.Join(',', f.MeasuredProtocols)); + typeof(GameFilter) + .GetProperties(BindingFlags.Public | BindingFlags.Instance) + .OrderBy(p => p.Name, StringComparer.Ordinal) + .Select(p => p.GetValue(f)) + .Select(v => v is IEnumerable<string> many ? string.Join(',', many) : v?.ToString())); } diff --git a/tests/MUI.Web.Tests/FeedAndArchiveTests.cs b/tests/MUI.Web.Tests/FeedAndArchiveTests.cs index 96f2027..e82dd8e 100644 --- a/tests/MUI.Web.Tests/FeedAndArchiveTests.cs +++ b/tests/MUI.Web.Tests/FeedAndArchiveTests.cs @@ -1,3 +1,5 @@ +using MUI.Web.Localization; + using MUI.Catalog; using MUI.Web.Components; using MUI.Web.Fixtures; @@ -35,25 +37,43 @@ public async Task TheThreeRegistersAreOneShapeWithThreeHeadings() foreach (var html in new[] { discovered, dark, back }) { - await Assert.That(html).Contains("<article class=\"feed-card"); + // A row rather than a card: three columns of boxes gave a name and an age the furniture + // of a section, on a page whose only other framed thing is somebody else's connect + // screen. The three registers are still three, and still one shape. + await Assert.That(html).Contains("<article class=\"feed-row"); await Assert.That(html).Contains("href=\"/g/x\""); } } [Test] - public async Task TheReturnCardGetsTheFullSentenceAtBodySizeAndTheOthersDoNot() + public async Task ARowSaysWhatHappenedAndWhenAndNothingTheHeadingAlreadySaid() { - // The one place the site raises its voice, and it earns it: a game dark for two years - // answering is the thing nobody else can tell you. - var entry = new FeedEntry(Guid.NewGuid(), "x", "The Long Sleep", Now, "Answered again after 26 months dark."); + // Three lists of five rows, and every row used to carry a prose line under it — "first + // seen", "answered again", "we keep knocking", and on the discovery feed the referral that + // found the game and the codebase it answered with. The column heading above says which + // register this is, so each of those was the same fact announced twice: twenty extra lines + // on the front page for a screen reader to wade through. + // + // What survives is a *cause*, which is not a repetition of the heading — the socket was + // refused, or the name did not resolve. It rides in the one right-hand cell beside the age + // rather than on a second line: "refused · 16h". + var entry = new FeedEntry(Guid.NewGuid(), "x", "The Long Sleep", Now, "connection refused"); var back = await CardAsync(entry, FeedKind.CameBack); var dark = await CardAsync(entry, FeedKind.WentDark); + var found = await CardAsync(entry, FeedKind.NewlyDiscovered); - await Assert.That(back).Contains("class=\"return-line\""); - await Assert.That(back).Contains("● live"); - await Assert.That(dark).Contains("class=\"mono detail\""); - await Assert.That(dark).DoesNotContain("class=\"return-line\""); + // No second line on any of the three. + foreach (var html in new[] { back, dark, found }) + { + await Assert.That(html).DoesNotContain("class=\"return-line\""); + await Assert.That(html).DoesNotContain("class=\"mono detail\""); + } + + // A return says it is back; a cause appears only where there is one to give. + await Assert.That(Render.Words(back)).Contains("live"); + await Assert.That(Render.Words(dark)).Contains("connection refused"); + await Assert.That(Render.Words(found)).DoesNotContain("connection refused"); } [Test] @@ -110,20 +130,28 @@ public async Task AnArchiveEntryCarriesWhenItWasLastReachableAndHowLongItWasKnow await Assert.That(entry.LastReachableAt).IsNotNull(); await Assert.That(entry.KnownLive).IsGreaterThan(TimeSpan.FromDays(365 * 10)); - await Assert.That(entry.LastAnswered).Contains("2023"); - await Assert.That(entry.Run).IsNotNull(); + await Assert.That(entry.LastAnswered("en")).Contains("2023"); + await Assert.That(entry.Run("en")).IsNotNull(); } [Test] public async Task AGameWeCouldNeverReachHasNoRunToState() { // Inventing a run from the dates we happen to hold would be asserting rather than measuring. + // Asserted through the message rather than against its English, because the claim is that + // the entry says *this* — never reached at all, and no reachable time measured — rather than + // that it says it in these words. A locale that dropped either would fail here too. var game = (await Queries.ListAsync(new GameFilter { IncludeArchived = true })).First(); var entry = ArchiveEntry.For(game, [], Now); - await Assert.That(entry.Run).IsNull(); - await Assert.That(entry.LastAnswered).Contains("never"); - await Assert.That(entry.KnownLiveWording).IsEqualTo("no reachable time measured"); + await Assert.That(entry.Run("en")).IsNull(); + await Assert.That(entry.LastAnswered("en")) + .IsEqualTo(Messages.For("en", "archive.neverReachable")); + await Assert.That(entry.KnownLiveWording("en")) + .IsEqualTo(Messages.For("en", "archive.noReachableTime")); + + // And a zero here is an absence of measurement, never a measured zero. + await Assert.That(entry.KnownLiveWording("en")).DoesNotContain("0"); } [Test] diff --git a/tests/MUI.Web.Tests/FindAGameTests.cs b/tests/MUI.Web.Tests/FindAGameTests.cs index ad58347..f5ce246 100644 --- a/tests/MUI.Web.Tests/FindAGameTests.cs +++ b/tests/MUI.Web.Tests/FindAGameTests.cs @@ -1,31 +1,180 @@ using System.Text.RegularExpressions; using MUI.Catalog; +using MUI.Web.Api; +using MUI.Web.Components; using MUI.Web.Components.Pages; +using MUI.Web.Fixtures; +using MUI.Web.Localization; namespace MUI.Web.Tests; /// <summary> -/// §9's find-a-game wizard, and the one property that makes it safe to have. +/// §9's find-a-game wizard, and the properties that make a page of counts safe to have. /// </summary> /// <remarks> -/// The wizard's whole design is that it does not translate. It is a GET form aimed at the listing, -/// so the querystring it produces is parsed by the listing's own binding — which means the failure -/// mode to guard is a control whose name or value the binding would refuse. A wizard offering a -/// choice that comes back as a 400, or worse as a silently ignored filter, teaches a reader that -/// the site does not work. +/// <para> +/// Two things are being guarded. The first is the old one: the page does not translate, so a control +/// whose name or value the listing's binding would refuse teaches a reader that the site does not +/// work. The second is new and larger — this page now publishes a number for a combination of +/// answers, and the whole product is that a number here came from a query rather than from +/// arithmetic. The prototype it was drawn from multiplied marginal ratios; these tests are what +/// stops that arriving by any route. +/// </para> /// </remarks> public class FindAGameTests { + private static Task<string> FindAsync(string query = "") => + Render.PageAsync<FindAGame>([], query); + + private static Task<FindScreen> ScreenAsync(string query = "") => + FindScreen.BuildAsync(new FixtureGameQueries(), query); + + /// <summary>The querystring an address on this page carries, which is empty on "ask nothing".</summary> + private static string QueryOf(string href) + { + var mark = href.IndexOf('?', StringComparison.Ordinal); + + return mark < 0 ? string.Empty : href[mark..]; + } + + /// <summary> + /// The unlock: an answered Find page is a page, not a moment between two form submissions. + /// </summary> + /// <remarks> + /// It rendered every option unselected whatever the URL said, because it read no querystring at + /// all — so an answered page could not be linked, did not survive reload, and, the reason it had + /// to change, could not be counted: there was no server-side instant at which a set of answers + /// existed. + /// </remarks> + [Test] + public async Task AnAnsweredPageIsLinkable() + { + var html = await FindAsync("?genre=Fantasy"); + + await Assert.That(html).Contains("aria-current=\"true\""); + await Assert.That(Render.Words(html)).Contains("Fantasy"); + + var screen = await ScreenAsync("?genre=Fantasy"); + var genre = screen.Questions.Single(q => q.Key == FacetKeys.Genre); + + await Assert.That(genre.Answer).IsNotNull(); + await Assert.That(genre.Answer!.Label).IsEqualTo("Fantasy"); + } + + /// <summary> + /// The count is a count of games, not a product of the numbers beside the options. + /// </summary> + /// <remarks> + /// Asserted against the listing the same answers produce, because that is the only definition of + /// "right" that matters: the button says "show these N games" and the page it opens has to hold + /// N of them. Multiplying marginal ratios — what the handoff's prototype does — gives 2 here and + /// would give a plausible wrong number on every combination where two answers correlate. + /// </remarks> + [Test] + public async Task TheCountIsTheListingTheAnswersProduce() + { + foreach (var query in (string[])["", "?genre=Fantasy", "?band=playersNow&language=English", "?genre=~unknown"]) + { + GameFilterBinding.TryRead(query, out var bound, out _); + + var listing = await new FixtureGameQueries().SearchAsync(bound.Filter); + var screen = await ScreenAsync(query); + + await Assert.That(screen.Matching) + .IsEqualTo(listing.Games.Count) + .Because($"{query} must count the games it would list"); + } + } + + /// <summary> + /// Every option's number is what choosing it returns, with the other answers still applied. + /// </summary> + /// <remarks> + /// <para> + /// The failure this prevents is the page's original one in a subtler dress: a marginal count + /// beside an option in a form that already has three other answers is a promise about a listing + /// nobody will ever see. Checked by following the option's own link and counting what comes + /// back — the same route a reader takes. + /// </para> + /// <para> + /// A chosen option is the one case where the number and the link point different ways, and + /// deliberately: its link <em>clears</em> the answer, because a control a reader cannot undo is + /// a trap, while its number is still what the answer returns — which is the count in the panel. + /// </para> + /// </remarks> + [Test] + public async Task AnOptionPromisesWhatItsOwnLinkReturns() + { + foreach (var query in (string[])["?band=playersNow", "?genre=Fantasy&protocol=MSSP", ""]) + { + var screen = await ScreenAsync(query); + + foreach (var question in screen.Questions) + { + var options = question.Options.Concat(question.Tail); + + foreach (var option in question.Any is null ? options : options.Append(question.Any)) + { + if (option.IsChosen) + { + await Assert.That(option.Count) + .IsEqualTo(screen.Matching) + .Because($"{question.Text} / {option.Label} is the answer in force"); + continue; + } + + GameFilterBinding.TryRead(QueryOf(option.Href), out var bound, out _); + + var listing = await new FixtureGameQueries().SearchAsync(bound.Filter); + + await Assert.That(option.Count) + .IsEqualTo(listing.Games.Count) + .Because($"{question.Text} / {option.Label} promises {option.Count} at {option.Href}"); + } + } + } + } + + /// <summary>The figure on the loosen button is the listing that dropping the answer returns.</summary> + /// <remarks> + /// The handoff picks the answer with the smallest marginal count and shows what it thinks + /// dropping it returns. Both halves are estimates; both are replaced here by a set the query + /// already counted, and this is what proves it. + /// </remarks> [Test] - public async Task TheWizardAsksTheListingForItsAnswer() + public async Task TheLoosenButtonCarriesACountedNumber() { - var html = await Render.PageAsync<FindAGame>([]); + var screen = await ScreenAsync("?genre=Historical&language=English"); + + await Assert.That(screen.Loosen).IsNotNull(); + + GameFilterBinding.TryRead(QueryOf(screen.Loosen!.Href), out var bound, out _); + + var listing = await new FixtureGameQueries().SearchAsync(bound.Filter); - // A GET at the listing, so the answer is a bookmarkable listing URL and not a page of its - // own that would have to re-render the rows. - await Assert.That(html).Contains("method=\"get\""); - await Assert.That(html).Contains("action=\"/games\""); + await Assert.That(screen.Loosen.Count).IsEqualTo(listing.Games.Count); + await Assert.That(screen.Loosen.Count).IsGreaterThan(screen.Matching); + } + + /// <summary>Nothing offers a way to see nothing.</summary> + /// <remarks> + /// A control that cannot do what it offers is worse than one that is not there, and at zero the + /// affordance the reader needs is the answer responsible rather than a button onto an empty + /// listing. + /// </remarks> + [Test] + public async Task AtZeroThePageOffersTheWayOutAndNotTheEmptyListing() + { + var screen = await ScreenAsync("?genre=Historical&language=Swedish"); + + await Assert.That(screen.Matching).IsEqualTo(0); + await Assert.That(screen.Loosen).IsNotNull(); + + var html = await FindAsync("?genre=Historical&language=Swedish"); + + await Assert.That(html).DoesNotContain("find-go"); + await Assert.That(Render.Words(html)).Contains("clear all answers"); } /// <summary> @@ -35,12 +184,20 @@ public async Task TheWizardAsksTheListingForItsAnswer() /// Read off the rendered markup rather than off the source, because what matters is the name /// that reaches the browser. A control named for a key <see cref="FacetKeys"/> does not define /// would be dropped on the floor by the listing, and the reader would see a filter they set - /// having no effect at all — the silent no-op this codebase refuses everywhere else. + /// having no effect at all — the silent no-op this codebase refuses everywhere else. The one + /// form left on this page is the name field, and the answers already given ride with it as + /// hidden inputs, so this is also what stops a typed name silently discarding the other five. /// </remarks> [Test] public async Task EveryControlIsNamedForAFacetTheListingReads() { - var html = await Render.PageAsync<FindAGame>([]); + var html = await FindAsync("?genre=Fantasy&band=playersNow"); + + var start = html.IndexOf("<form class=\"find-name\"", StringComparison.Ordinal); + + await Assert.That(start).IsGreaterThan(-1); + + var form = html[start..html.IndexOf("</form>", start, StringComparison.Ordinal)]; var known = typeof(FacetKeys) .GetFields() @@ -48,45 +205,181 @@ public async Task EveryControlIsNamedForAFacetTheListingReads() .Select(f => (string)f.GetRawConstantValue()!) .ToHashSet(StringComparer.Ordinal); - var named = Regex.Matches(html, @"name=""(?<name>[^""]+)""") + var named = Regex.Matches(form, @"name=""(?<name>[^""]+)""") .Select(m => m.Groups["name"].Value) .Distinct() .ToList(); - await Assert.That(named).IsNotEmpty(); + await Assert.That(named).Contains(FacetKeys.Text); + await Assert.That(named).Contains(FacetKeys.Genre); + await Assert.That(named).Contains(FacetKeys.Band); foreach (var name in named) { - await Assert.That(known.Contains(name)).IsTrue(); + await Assert.That(known.Contains(name)).IsTrue().Because($"{name} is not a facet"); } } /// <summary> - /// The activity bands it offers are spelled by the enum, so none can be unaskable. + /// No answer is offered that the listing cannot apply. /// </summary> /// <remarks> - /// The first draft of this page wrote the three tokens out by hand, which is exactly the drift - /// its own design comment says it avoids: a band renamed in the enum would leave the wizard - /// offering a value the binding refuses, and nothing would have failed to say so. + /// Every link on the page is walked through the listing's own binding. A refused querystring is + /// what a reader would meet as a 400 or, worse, as a filter that silently did nothing — and the + /// long tail's disclosure makes this bigger than it looks, because a folded option that could + /// not be applied would be invisible until somebody opened it. /// </remarks> [Test] - public async Task TheBandsItOffersAreTheOnesTheBindingAccepts() + public async Task NoAnswerIsOfferedThatTheListingCannotApply() { - var html = await Render.PageAsync<FindAGame>([]); + var screen = await ScreenAsync("?band=quiet"); - var offered = Regex.Matches(html, @"name=""band"" value=""(?<token>[^""]*)""") - .Select(m => m.Groups["token"].Value) - .Where(t => t.Length > 0) - .ToList(); + foreach (var question in screen.Questions) + { + foreach (var option in question.Options.Concat(question.Tail)) + { + await Assert.That(GameFilterBinding.TryRead(QueryOf(option.Href), out _, out var error)) + .IsTrue() + .Because($"{option.Label} produces {option.Href}: {error}"); + } + } + } - await Assert.That(offered).IsNotEmpty(); + /// <summary> + /// The silent bucket is an option, and it keeps the word its own facet spells absence with. + /// </summary> + /// <remarks> + /// The page filtered it out while the query layer answered it and the plain surface offered it, + /// so two surfaces of one page disagreed about what could be asked. The handoff wants every one + /// of them labelled <em>unknown</em>; they stay three sentences, because a genre nobody declared + /// and a codebase we could not identify are a fact about the game and a fact about our reach, and + /// that difference is the thing the site is for. + /// </remarks> + [Test] + public async Task SilenceIsSelectableAndKeepsItsOwnWord() + { + var screen = await ScreenAsync(); + var genre = screen.Questions.Single(q => q.Key == FacetKeys.Genre); + + var silent = genre.Options.Single(o => o.Href.Contains(FacetChoice.UnknownToken, StringComparison.Ordinal)); + + await Assert.That(silent.Label).IsEqualTo("not declared"); + await Assert.That(silent.Count).IsGreaterThan(0); + await Assert.That(Render.Words(await FindAsync())).Contains("not declared"); + } + + /// <summary> + /// Archiving removes a game from the default listing and from nothing else — including here. + /// </summary> + /// <remarks> + /// The handoff asks for this question to default to <em>include them</em> so that "none of these + /// questions are required" becomes true. Inverting it would give one reader two different result + /// sets from two doors into one query. What was taken instead is the branch the handoff offers + /// itself: keep the default, delete the claim, and say what is applied — which this page does by + /// putting the number each answer returns on both of them. + /// </remarks> + [Test] + public async Task TheDarkQuestionDefaultsTheSameWayTheListingDoes() + { + var screen = await ScreenAsync(); + var dark = screen.Questions.Single(q => q.Key == FacetKeys.Archived); + + var live = dark.Options[0]; + var all = dark.Options[1]; + + await Assert.That(live.IsChosen).IsTrue(); + await Assert.That(all.IsChosen).IsFalse(); + + // Both answers carry the number they return, which is how the page says a filter is applied + // without a sentence that can go stale. + await Assert.That(all.Count).IsGreaterThan(live.Count); - foreach (var token in offered) + var listing = await new FixtureGameQueries().SearchAsync( + new GameFilter { IncludeArchived = true, IncludeAdult = false }); + + await Assert.That(all.Count).IsEqualTo(listing.Games.Count); + } + + /// <summary>TLS is one row, and the acronyms all read the same shape.</summary> + /// <remarks> + /// It reached the page twice — the dedicated <c>tls</c> facet and a <c>protocol=TLS</c> value + /// falling through to the generic gloss — so one acronym named two controls with two meanings. + /// And Razor ate the space after the conditional that wrote the name, which shipped + /// <c>MSSP— server self-description</c> to a screen reader as one word. + /// </remarks> + [Test] + public async Task TheClientQuestionNamesTlsOnceAndGlossesEveryAcronym() + { + var screen = await ScreenAsync(); + var client = screen.Questions.Single(q => q.Key == FacetKeys.Protocol); + + var labels = client.Options.Concat(client.Tail).Select(o => o.Label).ToList(); + + await Assert.That(labels.Count(l => l.StartsWith("TLS", StringComparison.Ordinal))).IsEqualTo(1); + + foreach (var label in labels) { - await Assert.That(FacetTokens.Bands.Contains(token)).IsTrue(); + await Assert.That(label).Contains(" — ").Because($"{label} has no gloss"); + await Assert.That(label).DoesNotContain("measured in the handshake"); } } + /// <summary>Six questions, one answer at a time, and each one a labelled group with a heading.</summary> + /// <remarks> + /// The drawing asks for six <c>fieldset</c>/<c>legend</c> pairs. Our options are links, and a + /// legend is announced when focus enters a form control in its group — with no controls to + /// enter it would name the group for nobody. A heading is announced, is navigable by a screen + /// reader's own heading key, and is the substitution the handoff explicitly allows. + /// </remarks> + [Test] + public async Task EveryQuestionIsALabelledGroupWithAHeading() + { + var screen = await ScreenAsync(); + + await Assert.That(screen.Questions.Count).IsEqualTo(6); + + foreach (var question in screen.Questions) + { + var chosen = question.Options.Concat(question.Tail).Count(o => o.IsChosen); + + await Assert.That(chosen).IsLessThanOrEqualTo(1).Because($"{question.Text} is a single choice"); + } + + var html = await FindAsync(); + + await Assert.That(Regex.Matches(html, @"role=""group""").Count).IsEqualTo(6); + await Assert.That(Regex.Matches(html, @"aria-labelledby=""find-q\d""").Count).IsEqualTo(6); + await Assert.That(Regex.Matches(html, @"<h2 id=""find-q\d""").Count).IsEqualTo(6); + } + + /// <summary>Every question says what kind of statement its answers are.</summary> + /// <remarks> + /// "What kind of game?" is the load-bearing one: it asks the derived lineage facet rather than + /// the declared <c>family</c> string, so the option a reader picks is a grouping of ours — and + /// rule 5 is what the badge exists to satisfy, not decoration. The alternative the handoff + /// proposes is a raw-string-to-group map authored in the web layer, which would be a second copy + /// of a vocabulary the catalogue owns. + /// </remarks> + [Test] + public async Task TheGroupedQuestionSaysTheGroupingIsOurs() + { + var screen = await ScreenAsync(); + + // Selected by the facet key, not by its English. The question is identified by the facet it + // asks — that is the fact this test is about — so an edit to the copy or a translated locale + // must not make it fail, and must not make it fail pointing at lineage evidence. + var kind = screen.Questions.Single(q => q.Key == FacetKeys.Lineage); + + await Assert.That(kind.Text).IsEqualTo(Messages.For(Locales.SourceTag, "find.q.lineage")); + await Assert.That(kind.Evidence).IsEqualTo(FacetEvidence.Derived); + + var html = await FindAsync(); + + await Assert.That(html).Contains("evidence derived"); + await Assert.That(html).Contains("evidence measured"); + await Assert.That(html).Contains("evidence declared"); + } + /// <summary>No rating, no score, no recommendation — here least of all.</summary> /// <remarks> /// A page that asks somebody what they want is the most natural place on this site for a @@ -97,11 +390,480 @@ public async Task TheBandsItOffersAreTheOnesTheBindingAccepts() [Test] public async Task TheWizardRecommendsNothing() { - var words = Render.Words(await Render.PageAsync<FindAGame>([])); + var words = Render.Words(await FindAsync("?genre=Fantasy")); foreach (var forbidden in (string[])["recommend", "best match", "top pick", "rating", "score"]) { await Assert.That(words.Contains(forbidden, StringComparison.OrdinalIgnoreCase)).IsFalse(); } } + + /// <summary>A querystring we cannot read is refused, on both surfaces.</summary> + /// <remarks> + /// The listing already refuses one. This page used to ignore its URL entirely, so it could not + /// refuse anything — and now that it reads one, answering <c>?band=nonsense</c> with the + /// unfiltered catalogue would present our own parse failure as somebody's answer. + /// </remarks> + [Test] + public async Task AQueryWeCannotReadIsRefusedRatherThanIgnored() + { + var screen = await ScreenAsync("?band=nonsense"); + + await Assert.That(screen.Error).IsNotNull(); + await Assert.That(screen.Questions).IsEmpty(); + + await Assert.That(Render.Words(await FindAsync("?band=nonsense"))) + .Contains("is not an activity band"); + await Assert.That(PlainText.RenderFind(screen)).Contains("REFUSED"); + } + + /// <summary> + /// The plain surface is the same page: same questions, same options, same counts, same words. + /// </summary> + /// <remarks> + /// It was a different page. Plain dumped ten facet groups as querystring recipes while the + /// rendered page asked six questions, and the two disagreed about what could be asked at all — + /// plain offered the silent bucket the rendered page hid. Both are now one construction with two + /// renderers, and this walks the model to prove the text carries every option and every number. + /// </remarks> + [Test] + public async Task ThePlainSurfaceCarriesEveryQuestionEveryOptionAndTheCount() + { + var screen = await ScreenAsync("?genre=Fantasy&plain=1"); + var plain = PlainText.RenderFind(screen); + + await Assert.That(plain).Contains("FIND A GAME"); + await Assert.That(plain).Contains("MATCHING ALL ANSWERS"); + await Assert.That(plain).Contains("/games?plain=1"); + + foreach (var question in screen.Questions) + { + await Assert.That(plain).Contains(question.Text.ToUpperInvariant()); + + foreach (var option in question.Options.Concat(question.Tail)) + { + await Assert.That(plain).Contains($"{option.Label} ({option.Count})"); + await Assert.That(plain).Contains(option.Href); + } + } + + // Nothing here is wider than a text browser. + foreach (var line in plain.Split('\n')) + { + await Assert.That(line.TrimEnd().Length) + .IsLessThanOrEqualTo(PlainText.Columns) + .Because($"'{line}' is wider than {PlainText.Columns} columns"); + } + } + + /// <summary>Following a link on the plain surface stays on the plain surface.</summary> + /// <remarks> + /// It falls out of the construction rather than being arranged — every address on both surfaces + /// is this page's own URL with one parameter changed — and it is worth asserting because a + /// reader who lands back on the rendered page after answering one question has lost the surface + /// they chose. + /// </remarks> + [Test] + public async Task ThePlainSurfaceLinksStayPlain() + { + var screen = await ScreenAsync("?plain=1"); + + foreach (var question in screen.Questions) + { + foreach (var option in question.Options.Concat(question.Tail)) + { + await Assert.That(option.Href).Contains("plain=1"); + } + } + + await Assert.That(screen.ShowHref).Contains("plain=1"); + + // Including the one control that clears everything: emptying the form is about the answers, + // and throwing a reader out of the surface they chose is not something they asked for. + var answered = await ScreenAsync("?genre=Fantasy&plain=1"); + + await Assert.That(answered.ClearHref).IsEqualTo("/find?plain=1"); + await Assert.That(answered.Answers[0].ClearHref).Contains("plain=1"); + } + + /// <summary> + /// The long tail folds, and every option in it is still a real answer. + /// </summary> + /// <remarks> + /// <para> + /// The catalogue this is drawn from has nine of twelve genres matching two games or fewer, and an + /// option that returns one result is a piece of trivia in a list somebody has to read. The + /// fixture is six games and cannot produce that shape, so the tail is exercised over a catalogue + /// made for it — which is also the only way to prove the thing that matters: what is behind the + /// disclosure is the values themselves, never a "3 more genres" bucket of its own. A submittable + /// bucket would be Find offering a choice the listing cannot express. + /// </para> + /// <para> + /// The reader's own answer is never in the tail. A selection folded out of sight is the defect + /// the disclosure would introduce, and it is the one option they need to be able to undo. + /// </para> + /// </remarks> + [Test] + public async Task TheLongTailFoldsAndHoldsRealAnswers() + { + var wide = new WideCatalogue(); + + var screen = await FindScreen.BuildAsync(wide, string.Empty); + var genre = screen.Questions.Single(q => q.Key == FacetKeys.Genre); + + await Assert.That(genre.Options.Count).IsLessThan(WideCatalogue.Genres.Length); + await Assert.That(genre.Tail).IsNotEmpty(); + + foreach (var option in genre.Tail) + { + GameFilterBinding.TryRead(QueryOf(option.Href), out var bound, out _); + + var listing = await wide.SearchAsync(bound.Filter); + + await Assert.That(option.Count).IsEqualTo(listing.Games.Count); + await Assert.That(option.Count).IsGreaterThan(0); + } + + // The silent bucket stays in the open however little it weighs: it is the option that makes + // "show me the games nobody has classified" askable at all. + await Assert.That(genre.Options.Any(o => o.Label == "not declared")).IsTrue(); + + var chosen = genre.Tail[^1]; + + var answered = await FindScreen.BuildAsync(wide, QueryOf(chosen.Href)); + + await Assert.That(answered.Questions.Single(q => q.Key == FacetKeys.Genre).Options + .Any(o => o.IsChosen)).IsTrue(); + } + + /// <summary> + /// A chosen capability outside the commonest six is still on the page, and can still be undone. + /// </summary> + /// <remarks> + /// <para> + /// The client question does not go through <see cref="FindScreen"/>'s <c>Split</c> — its options + /// are two facets welded into one control — so the rule that a reader's own answer is never + /// folded away had to be carried across by hand, and was not. The shown list was the first six + /// by popularity and the tail was the remainder with every chosen option filtered out, so a + /// capability ranking seventh or lower was in neither: the answer in force was invisible and the + /// only affordance that clears it went with it. A single-choice control that can enter a state + /// it cannot leave is the worst shape a question on this page can have. + /// </para> + /// <para> + /// Exercised over a catalogue built to rank the chosen capability last, because the six-game + /// fixture measures one protocol and cannot produce a seventh option at all. + /// </para> + /// </remarks> + [Test] + public async Task AChosenCapabilityOutsideTheCommonestSixIsStillShownAndStillClearable() + { + var many = new ManyCapabilities(); + + // The rarest, which is what the popularity cut pushes furthest out of sight. + var rare = ManyCapabilities.Protocols[^1]; + + var before = await FindScreen.BuildAsync(many, string.Empty); + var offered = before.Questions.Single(q => q.Key == FacetKeys.Protocol); + + // The premise: it really is in the tail before anybody chooses it. + await Assert.That(offered.Options.Any(o => o.Label.StartsWith(rare, StringComparison.Ordinal))) + .IsFalse(); + await Assert.That(offered.Tail.Any(o => o.Label.StartsWith(rare, StringComparison.Ordinal))) + .IsTrue(); + + var screen = await FindScreen.BuildAsync(many, $"?{FacetKeys.Protocol}={rare}"); + var client = screen.Questions.Single(q => q.Key == FacetKeys.Protocol); + + // Shown, not folded: promoted into the open list exactly as Split promotes one elsewhere. + var chosen = client.Options.Single(o => o.IsChosen); + + await Assert.That(chosen.Label).StartsWith(rare); + await Assert.That(client.Tail.Any(o => o.IsChosen)).IsFalse(); + + // And clearable: its own link drops the answer rather than setting it again, so the control + // is reachable in both directions with no second affordance. + await Assert.That(chosen.Href).DoesNotContain($"{FacetKeys.Protocol}={rare}"); + + GameFilterBinding.TryRead(QueryOf(chosen.Href), out var cleared, out _); + + await Assert.That(cleared.Filter.MeasuredProtocols).IsEmpty(); + + // The plain surface carries it too, or the graphical fix is half a fix (§9). + await Assert.That(PlainText.RenderFind(screen)).Contains($"[x] {rare}"); + } + + /// <summary> + /// A catalogue measuring more capabilities than the client question shows, ranked so the last is + /// well outside the cut. + /// </summary> + private sealed class ManyCapabilities : IGameQueries + { + internal static readonly string[] Protocols = + [ + "MSSP", "MCCP", "GMCP", "MXP", "MSDP", "TTYPE", "ATCP", "MSP", "EOR", + ]; + + // Nine games offer the first, one offers the last: a strict popularity order with no ties, + // so which options fall outside the shown six is a fact rather than a sort artefact. + private static readonly IReadOnlyList<GameFacetRow> Rows = + [ + .. Protocols.SelectMany((protocol, rank) => Enumerable + .Range(0, Protocols.Length - rank) + .Select(n => Row($"{protocol}-{n}", protocol))), + ]; + + public Task<GameListing> SearchAsync(GameFilter filter, CancellationToken ct = default) => + Task.FromResult(FacetedSearch.Search(Rows, filter)); + + public Task<IReadOnlyList<GameSummary>> ListAsync(GameFilter filter, CancellationToken ct = default) => + throw new NotSupportedException(); + + public Task<GamePage?> FindAsync(string slug, CancellationToken ct = default) => + throw new NotSupportedException(); + + public Task<GamePage?> FindAsync(Guid id, CancellationToken ct = default) => + throw new NotSupportedException(); + + public Task<GameSummary?> FindByIdAsync(Guid id, CancellationToken ct = default) => + throw new NotSupportedException(); + + public Task<LivenessFeeds> FeedsAsync(CancellationToken ct = default) => + throw new NotSupportedException(); + + public Task<EcosystemDashboard> EcosystemAsync(CancellationToken ct = default) => + throw new NotSupportedException(); + + public Task<Rankings> RankingsAsync(RankingSpan span, CancellationToken ct = default) => + throw new NotSupportedException(); + + private static GameFacetRow Row(string slug, string protocol) => new( + new GameSummary( + Guid.NewGuid(), slug, slug, null, LifecycleState.Active, IsClaimed: false, + PlayersNow: 1, Codebase: "PennMUSH", MeasuredProtocols: [protocol]), + ActivityBand.PlayersNow, + LastSeenBand.Day, + TlsMeasured: false, + Charset: "UTF-8", + Language: "English", + Codebase: "PennMUSH", + Family: "TinyMUD", + Genre: "Fantasy", + IsAdult: false, + Uncounted: false, + Unreachable: false); + } + + /// <summary> + /// A catalogue with a long tail, which the six-game fixture has no way to have. + /// </summary> + /// <remarks> + /// Built out of <see cref="GameFacetRow"/> and answered through <see cref="FacetedSearch"/> — + /// the same arithmetic the database and the fixture both go through — so this exercises the real + /// counting rather than a hand-written listing that could agree with nothing. + /// </remarks> + private sealed class WideCatalogue : IGameQueries + { + internal static readonly string[] Genres = + [ + "Fantasy", "Science Fiction", "Adventure", "Horror", "Historical", + "Social", "Multitheme", "Cyberpunk", "Western", "Noir", + ]; + + private static readonly IReadOnlyList<GameFacetRow> Rows = + [ + .. Genres.SelectMany((genre, rank) => Enumerable + .Range(0, Genres.Length - rank) + .Select(n => Row($"{genre}-{n}", genre))), + + // One game nobody classified, so the silent bucket has something in it. + Row("silent", null), + ]; + + public Task<GameListing> SearchAsync(GameFilter filter, CancellationToken ct = default) => + Task.FromResult(FacetedSearch.Search(Rows, filter)); + + public Task<IReadOnlyList<GameSummary>> ListAsync(GameFilter filter, CancellationToken ct = default) => + throw new NotSupportedException(); + + public Task<GamePage?> FindAsync(string slug, CancellationToken ct = default) => + throw new NotSupportedException(); + + public Task<GamePage?> FindAsync(Guid id, CancellationToken ct = default) => + throw new NotSupportedException(); + + public Task<GameSummary?> FindByIdAsync(Guid id, CancellationToken ct = default) => + throw new NotSupportedException(); + + public Task<LivenessFeeds> FeedsAsync(CancellationToken ct = default) => + throw new NotSupportedException(); + + public Task<EcosystemDashboard> EcosystemAsync(CancellationToken ct = default) => + throw new NotSupportedException(); + + public Task<Rankings> RankingsAsync(RankingSpan span, CancellationToken ct = default) => + throw new NotSupportedException(); + + private static GameFacetRow Row(string slug, string? genre) => new( + new GameSummary( + Guid.NewGuid(), slug, slug, null, LifecycleState.Active, IsClaimed: false, + PlayersNow: 1, Codebase: "PennMUSH", MeasuredProtocols: ["MSSP"]), + ActivityBand.PlayersNow, + LastSeenBand.Day, + TlsMeasured: false, + Charset: "UTF-8", + Language: "English", + Codebase: "PennMUSH", + Family: "TinyMUD", + Genre: genre, + IsAdult: false, + Uncounted: false, + Unreachable: false); + } + + /// <summary>The count and the noun it agrees with are one message, never two strings.</summary> + /// <remarks> + /// The page these replace read "1 games" in the client question, on every protocol whose count + /// happened to be one. English is nearly the only language that would have survived even that, + /// and a number glued to an English fragment in English word order is exactly what the i18n + /// review named. "0 games" is not the same fault and is correct English — zero takes the plural + /// here and the singular in French — which is the reason the branch is a message and not an + /// <c>if</c>. + /// </remarks> + [Test] + public async Task NoCountIsGluedToAnEnglishNoun() + { + foreach (var query in (string[])["", "?genre=Historical", "?protocol=MSDP"]) + { + var words = Render.Words(await FindAsync(query)); + + await Assert.That(words).DoesNotContain("1 games"); + await Assert.That(words).DoesNotContain("1 listed games"); + await Assert.That(words).DoesNotContain("1 answers given"); + } + } + + /// <summary> + /// Nothing here needs script, which is the constraint the whole design bends around. + /// </summary> + /// <remarks> + /// The drawing this page comes from is a debounced <c>aria-live</c> region recomputing a count + /// as answers change. There is no script on this site, so the count is computed on the server + /// and every answer is an address: a link applies on click with nothing listening, and the one + /// form left is the name field, which a browser submits as a GET on its own. Asserted rather + /// than assumed because "it happens to work without JS today" and "it cannot stop working + /// without JS" are different properties, and only the second one is the design. + /// </remarks> + [Test] + public async Task NothingOnThisPageNeedsScript() + { + foreach (var query in (string[])["?genre=Fantasy&band=playersNow", "?plain=1"]) + { + var html = await FindAsync(query); + + await Assert.That(html).DoesNotContain("<script"); + await Assert.That(html).DoesNotContain("onclick"); + await Assert.That(html).DoesNotContain("javascript:"); + } + + var rendered = await FindAsync("?genre=Fantasy"); + + // Every form this page owns is a GET, and every answer is an anchor: a POST would be a + // change of state with no address, which is the one thing this page has never had. The + // shared language switcher is deliberately not one of them — choosing a language writes a + // cookie rather than asking the catalogue a question, and it belongs to the chrome. + var forms = Regex.Matches(rendered, "<form[^>]*>") + .Select(m => m.Value) + .Where(f => !f.Contains("class=\"locale\"", StringComparison.Ordinal)) + .ToList(); + + await Assert.That(forms).IsNotEmpty(); + + foreach (var form in forms) + { + await Assert.That(form).Contains("method=\"get\"").Because($"{form} is not a GET"); + await Assert.That(form).Contains("action=\"/find\"").Because($"{form} leaves the page"); + } + } + + /// <summary>Every word this page owns is in the bundle, questions included.</summary> + /// <remarks> + /// <para> + /// This is the one surface written in a reader's language rather than in the catalogue's — six + /// questions, the answer that un-asks each one, and a three-word gloss per capability — so it is + /// the page with the most prose and the least of it reachable by a translator if it is spelled + /// in C#. The facet <em>values</em> are deliberately not checked here: those come from + /// <see cref="FacetWords"/>, which the listing shares, and a second vocabulary for them on this + /// page is the drift the page's own header comment warns about. + /// </para> + /// <para> + /// Asserted by identity against the bundle rather than against English text, so the test says + /// "this string came from that id" and keeps saying it after somebody edits the English. + /// </para> + /// </remarks> + [Test] + public async Task EveryWordThisPageOwnsComesFromTheMessageBundle() + { + var screen = await ScreenAsync(); + var en = Locales.SourceTag; + + string[] questions = + [ + "find.q.band", "find.q.genre", "find.q.lineage", + "find.q.language", "find.q.client", "find.q.dark", + ]; + + await Assert.That(screen.Questions.Select(q => q.Text)) + .IsEquivalentTo(questions.Select(id => Messages.For(en, id)).ToArray()); + + string[] anys = ["find.any.band", "find.any.genre", "find.any.lineage", "find.any.language"]; + + await Assert.That(screen.Questions.Where(q => q.Any is not null).Select(q => q.Any!.Label)) + .Contains(Messages.For(en, "find.any.client")); + + foreach (var id in anys) + { + await Assert.That(screen.Questions.Select(q => q.Any?.Label)) + .Contains(Messages.For(en, id)) + .Because($"{id} is what un-asks its question"); + } + + // The acronym and its gloss are one message and not a name with three words glued to it: + // "MSSP— server self-description" shipped from exactly that concatenation, and a language + // that puts the gloss first has nowhere to say so if the two are joined in C#. + var client = screen.Questions.Single(q => q.Key == FacetKeys.Protocol); + + await Assert.That(client.Options.Concat(client.Tail).Select(o => o.Label)) + .Contains(Messages.For(en, "find.protocol.mssp")); + + await Assert.That(client.Options.Concat(client.Tail).Select(o => o.Label)) + .Contains(Messages.For(en, "find.protocol.tls")); + } + + /// <summary> + /// One locale reaches the words and the mirror alike, because it is built into the screen. + /// </summary> + /// <remarks> + /// The locale is a parameter of the construction rather than something applied to the result: + /// the plain surface reads its question texts and its option labels straight off the screen, so + /// a translation applied after the fact would reach the rendered page and not this one — the + /// same split, in the same place, that this page was rebuilt to close. + /// </remarks> + [Test] + public async Task TheTextMirrorSpeaksTheLocaleTheScreenWasBuiltIn() + { + foreach (var tag in (string[])[Locales.SourceTag, "de", "ja"]) + { + var screen = await FindScreen.BuildAsync(new FixtureGameQueries(), "?plain=1", tag); + var plain = PlainText.RenderFind(screen, tag); + + await Assert.That(plain).Contains(Messages.For(tag, "find.title").ToUpperInvariant()); + + foreach (var question in screen.Questions) + { + await Assert.That(plain) + .Contains(question.Text.ToUpperInvariant()) + .Because($"{tag} asks its questions in one language on both surfaces"); + } + } + } } diff --git a/tests/MUI.Web.Tests/GameAnchorsTests.cs b/tests/MUI.Web.Tests/GameAnchorsTests.cs new file mode 100644 index 0000000..a86d07e --- /dev/null +++ b/tests/MUI.Web.Tests/GameAnchorsTests.cs @@ -0,0 +1,135 @@ +using MUI.Catalog; +using MUI.Catalog.Persistence; +using MUI.Web.Components.Pages; +using MUI.Web.Data; +using MUI.Web.Fixtures; + +using Microsoft.AspNetCore.Components; +using Microsoft.Extensions.DependencyInjection; + +namespace MUI.Web.Tests; + +/// <summary> +/// The game page's own in-page links, and the sections they are supposed to land on. +/// </summary> +/// <remarks> +/// A footer link to <c>#changed</c> is not a broken link a browser reports: it scrolls nowhere and +/// says nothing, and to a screen reader following it the page simply does not move. The change list +/// renders only for a game with a recorded change, so the link has to be conditioned on the same +/// thing the heading is — the fixture gives every game two changes, which is why nothing had ever +/// rendered this page without one. +/// </remarks> +public class GameAnchorsTests +{ + [Test] + public async Task TheFooterLinksToTheChangeListOnlyWhereThereIsOne() + { + var withChanges = await RenderAsync(strip: false); + + await Assert.That(withChanges).Contains("id=\"changed\""); + await Assert.That(withChanges).Contains("href=\"#changed\""); + + var without = await RenderAsync(strip: true); + + await Assert.That(without).DoesNotContain("id=\"changed\""); + await Assert.That(without).DoesNotContain("href=\"#changed\""); + + // The rest of the footer is untouched, so what went is the link and not the row it sat in. + await Assert.That(without).Contains("href=\"#declared\""); + await Assert.That(without).Contains("id=\"declared\""); + await Assert.That(without).Contains("?plain=1"); + } + + /// <summary> + /// Every anchor the page links to is an id the page rendered. + /// </summary> + /// <remarks> + /// Stated as the general rule rather than about <c>#changed</c> alone, so a section that becomes + /// conditional later is caught by the test that already exists. + /// </remarks> + [Test] + [Arguments(false)] + [Arguments(true)] + public async Task EveryInPageLinkLandsOnSomething(bool strip) + { + var html = await RenderAsync(strip); + + var targets = System.Text.RegularExpressions.Regex + .Matches(html, "href=\"#([^\"]+)\"") + .Select(m => m.Groups[1].Value) + .Distinct(StringComparer.Ordinal) + .ToList(); + + // A sweep over "every in-page link" asserts nothing when the page renders none, and passes + // anyway. The page under test has them; if it stops having them this should fail rather + // than quietly become a test of nothing. + await Assert.That(targets).IsNotEmpty() + .Because("the game page carries in-page links, and a sweep over none proves none of them"); + + foreach (var target in targets) + { + await Assert.That(html) + .Contains($"id=\"{target}\"") + .Because($"the page links to #{target} and renders no such id"); + } + } + + private static Task<string> RenderAsync(bool strip) => + Render.ComponentAsync<Game>( + new() { ["Slug"] = "m-u-s-h" }, + services => + { + var fixture = new FixtureGameQueries(); + + services.AddSingleton<IGameQueries>(strip ? new WithoutChanges(fixture) : fixture); + services.AddSingleton<IAvailabilityHistory>(fixture); + services.AddSingleton(TimeProvider.System); + services.AddSingleton<NavigationManager>(new Nowhere()); + services.AddSingleton(new CatalogueSource(IsMeasured: false)); + }); + + /// <summary>The fixture, with the change history taken off the page it answers with.</summary> + /// <remarks> + /// Every fixture game carries two changes, so this is the only way to see the page a game with a + /// quiet record actually gets. It delegates rather than reimplements: what is under test is one + /// conditional in the markup, and a second fixture would drift from the first. + /// </remarks> + private sealed class WithoutChanges(IGameQueries inner) : IGameQueries + { + public Task<GameListing> SearchAsync(GameFilter filter, CancellationToken cancellationToken = default) => + inner.SearchAsync(filter, cancellationToken); + + public Task<IReadOnlyList<GameSummary>> ListAsync(GameFilter filter, CancellationToken cancellationToken = default) => + inner.ListAsync(filter, cancellationToken); + + public async Task<GamePage?> FindAsync(string slug, CancellationToken cancellationToken = default) => + await inner.FindAsync(slug, cancellationToken) is { } page ? page with { Changes = [] } : null; + + public async Task<GamePage?> FindAsync(Guid id, CancellationToken cancellationToken = default) => + await inner.FindAsync(id, cancellationToken) is { } page ? page with { Changes = [] } : null; + + public Task<GameSummary?> FindByIdAsync(Guid id, CancellationToken cancellationToken = default) => + inner.FindByIdAsync(id, cancellationToken); + + public Task<LivenessFeeds> FeedsAsync(CancellationToken cancellationToken = default) => + inner.FeedsAsync(cancellationToken); + + public Task<EcosystemDashboard> EcosystemAsync(CancellationToken cancellationToken = default) => + inner.EcosystemAsync(cancellationToken); + + public Task<Rankings> RankingsAsync( + RankingSpan span = RankingSpan.Week, + CancellationToken cancellationToken = default) => + inner.RankingsAsync(span, cancellationToken); + } + + /// <summary>A navigation manager for a component rendered outside a request.</summary> + private sealed class Nowhere : NavigationManager + { + public Nowhere() => Initialize("http://localhost/", "http://localhost/g/m-u-s-h"); + + protected override void NavigateToCore(string uri, bool forceLoad) + { + } + } +} diff --git a/tests/MUI.Web.Tests/GamePlateTests.cs b/tests/MUI.Web.Tests/GamePlateTests.cs index bbfbf56..d083367 100644 --- a/tests/MUI.Web.Tests/GamePlateTests.cs +++ b/tests/MUI.Web.Tests/GamePlateTests.cs @@ -37,16 +37,18 @@ public async Task APlateIsNeverEmpty() } [Test] - public async Task EveryRowHasAPlateAndNoneOfThemPointsOffThisOrigin() + public async Task NoRowDrawsAPlateAndNoIconPointsOffThisOrigin() { - // The fixture holds no icon bytes, so every row is the monogram — which is exactly the state - // a deployment with an empty cache renders, and it has to be a plate rather than a hole. + // The handoff's listing row is identity, measurement and freshness and nothing else: a 36px + // square per row is a fourth column of furniture down a list five hundred long, and the face + // a game published is on its own page at a size that shows it. The component is unchanged + // and the game page still draws it. var html = await Render.PageAsync<Games>([]); var rows = html.Split("class=\"game-row").Length - 1; var plates = html.Split("class=\"plate").Length - 1; await Assert.That(rows).IsGreaterThan(0); - await Assert.That(plates).IsEqualTo(rows); + await Assert.That(plates).IsEqualTo(0); // §11. An icon is served from this origin or not at all: every src is the site's own route. foreach (var src in html.Split("<img").Skip(1)) @@ -61,13 +63,16 @@ public async Task AMissingIconAndAnUnreachableOneAreDrawnIdentically() // The one thing the plate may not do. A placeholder, a broken image or a "logo unavailable" // would publish our failed fetch as a fact about somebody's game (rule 5) — and the second // and third of those states are indistinguishable from the first anywhere in the markup. - var html = await Render.PageAsync<Games>([]); + var html = await Render.PageAsync<Game>(new() { ["Slug"] = "m-u-s-h" }); await Assert.That(html).DoesNotContain("no icon"); await Assert.That(html).DoesNotContain("icon unavailable"); - // The name is beside it either way, so the picture is never the thing announced. - await Assert.That(html).Contains("class=\"plate mono\" aria-hidden=\"true\""); + // And no element at all where there is no icon. "When absent, render no element: no + // monogram, no grey square, no initial in a circle" — an empty frame on five hundred pages + // is noise, and a generated monogram invents a brand the game never supplied, which on a + // site that publishes only what it measured is the one decoration that costs something. + await Assert.That(html).DoesNotContain("class=\"plate"); } [Test] @@ -98,15 +103,29 @@ public async Task AnIconIsServedFromThisOriginAndReservesItsSpaceBeforeItArrives } [Test] - public async Task TheGamePageAndTheListingDrawOneVocabularyAtTwoSizes() + public async Task NoSurfaceInventsAFaceForAGameThatPublishedNone() { - // Two spellings of "the first letters of the name" is how a game comes to be MU on one page - // and M* on the next. Both surfaces render the same component. + // Neither the listing nor the game page draws a monogram now. The component still knows how + // — a surface that needs a fixed left edge down a list of rows is a different argument — but + // nothing passes Fallback, so a game with no icon gets no element on either surface and the + // title simply starts at the left edge. var page = await Render.PageAsync<Game>(new() { ["Slug"] = "m-u-s-h" }); var listing = await Render.PageAsync<Games>([]); - await Assert.That(page).Contains("class=\"plate mono\""); - await Assert.That(Render.Words(page)).Contains(Monogram.Of("M*U*S*H")); - await Assert.That(listing).Contains("class=\"plate mono\""); + await Assert.That(page).DoesNotContain("class=\"plate"); + await Assert.That(listing).DoesNotContain("class=\"plate"); + + // And the one implementation is still there, behind the parameter, so the two surfaces + // cannot grow two spellings of "the first letters of the name". + var withFallback = await Render.ComponentAsync<GamePlate>(new() + { + ["Slug"] = "m-u-s-h", + ["Name"] = "M*U*S*H", + ["HasIcon"] = false, + ["Fallback"] = true, + }); + + await Assert.That(withFallback).Contains("class=\"plate mono\" aria-hidden=\"true\""); + await Assert.That(Render.Words(withFallback)).Contains(Monogram.Of("M*U*S*H")); } } diff --git a/tests/MUI.Web.Tests/IcuMessageTests.cs b/tests/MUI.Web.Tests/IcuMessageTests.cs new file mode 100644 index 0000000..bdf3291 --- /dev/null +++ b/tests/MUI.Web.Tests/IcuMessageTests.cs @@ -0,0 +1,372 @@ +using MUI.Web.Localization; + +namespace MUI.Web.Tests; + +/// <summary> +/// MessageFormat 1.0, against the cases that catch the usual mistakes. +/// </summary> +/// <remarks> +/// Most of these are the examples ICU's own documentation uses, because they are the ones chosen to +/// break a naive implementation: the apostrophe that is not a quote, the plural offset that changes +/// <c>#</c> but not <c>=0</c>, the ordinal categories English has and its cardinal rule does not, +/// and the fraction that makes 1 and 1.0 different words. +/// </remarks> +public class IcuMessageTests +{ + private static string Format(string pattern, string tag = "en", params (string Key, object? Value)[] args) => + IcuMessage.Format(pattern, tag, args.ToDictionary(a => a.Key, a => a.Value, StringComparer.Ordinal)); + + // ── quoting ────────────────────────────────────────────────────────────────────────────── + + [Test] + [Arguments("doesn't", "doesn't")] // a lone apostrophe is an apostrophe + [Arguments("it''s", "it's")] // doubled is always one + [Arguments("'{'literal'}'", "{literal}")] // quotes a brace + [Arguments("'{0}'", "{0}")] // and everything up to the closing quote + [Arguments("O'Brien's MUSH", "O'Brien's MUSH")] + [Arguments("5 o''clock", "5 o'clock")] + public async Task ApostrophesFollowIcusDefaultMode(string pattern, string expected) + { + // DOUBLE_OPTIONAL: an apostrophe only starts a quote when it immediately precedes { } | or, + // inside a plural, #. Anywhere else it is a literal — which is what makes English possessives + // and contractions safe to type without thinking about it. + await Assert.That(Format(pattern)).IsEqualTo(expected); + } + + [Test] + public async Task AQuotedHashInsideAPluralIsALiteral() + { + // And an unquoted one is the number. Both matter: a game called "#1 MUSH" would otherwise + // print its own count in the middle of its name. + await Assert.That(Format("{n, plural, other {'#' is # }}", "en", ("n", 3))).IsEqualTo("# is 3 "); + await Assert.That(Format("channel #general")).IsEqualTo("channel #general"); + } + + [Test] + public async Task ABraceInsideABranchIsQuotedTheSameWay() + { + // The doubled-brace escape an earlier version carried could not do this: a branch ending + // "...}}" is indistinguishable from a literal brace followed by the argument's own close. + await Assert.That(Format("{n, plural, other {'{'#'}'}}", "en", ("n", 2))).IsEqualTo("{2}"); + } + + // ── plural ─────────────────────────────────────────────────────────────────────────────── + + [Test] + [Arguments(0, "0 games")] + [Arguments(1, "1 game")] + [Arguments(2, "2 games")] + public async Task EnglishCardinalHasTwoForms(int count, string expected) + { + await Assert.That(Format("{n, plural, one {# game} other {# games}}", "en", ("n", count))) + .IsEqualTo(expected); + } + + [Test] + public async Task AVisibleFractionIsNotOneEvenWhenTheValueIsOne() + { + // "1.0 stars", never "1.0 star" — and the two quantities are equal, so nothing but the + // operands can tell them apart. This is the case an integer-only implementation cannot get + // right, and the reason PluralOperands exists. + const string Pattern = "{n, plural, one {# star} other {# stars}}"; + + await Assert.That(Format(Pattern, "en", ("n", 1))).IsEqualTo("1 star"); + await Assert.That(Format(Pattern, "en", ("n", 1.0m))).IsEqualTo("1.0 stars"); + } + + [Test] + [Arguments(1, "1 игра")] + [Arguments(2, "2 игры")] + [Arguments(5, "5 игр")] + [Arguments(11, "11 игр")] // ends in 1 and is not `one` + [Arguments(12, "12 игр")] // ends in 2 and is not `few` + [Arguments(21, "21 игра")] + [Arguments(22, "22 игры")] + public async Task RussianCardinalHasThreeFormsAndTheTeensAreTheTrap(int count, string expected) + { + // A rule written from the first three examples anybody tries is wrong for 11 and 12, and + // wrong in a way no English-speaking reviewer notices. + await Assert.That(Format( + "{n, plural, one {# игра} few {# игры} many {# игр} other {# игры}}", "ru", ("n", count))) + .IsEqualTo(expected); + } + + [Test] + [Arguments(1, "1st")] + [Arguments(2, "2nd")] + [Arguments(3, "3rd")] + [Arguments(4, "4th")] + [Arguments(11, "11th")] + [Arguments(12, "12th")] + [Arguments(13, "13th")] + [Arguments(21, "21st")] + [Arguments(102, "102nd")] + public async Task EnglishOrdinalHasFourFormsAndTheCardinalRuleCannotProduceThem(int n, string expected) + { + // selectordinal is a different rule set, not a different spelling of plural. English's + // cardinal rule has two categories and this needs four. + await Assert.That(Format( + "{n, selectordinal, one {#st} two {#nd} few {#rd} other {#th}}", "en", ("n", n))) + .IsEqualTo(expected); + } + + [Test] + public async Task AnExactMatchBeatsACategory() + { + const string Pattern = "{n, plural, =0 {nobody} one {# person} other {# people}}"; + + await Assert.That(Format(Pattern, "en", ("n", 0))).IsEqualTo("nobody"); + await Assert.That(Format(Pattern, "en", ("n", 1))).IsEqualTo("1 person"); + await Assert.That(Format(Pattern, "en", ("n", 4))).IsEqualTo("4 people"); + } + + [Test] + public async Task OffsetChangesTheHashAndTheCategoryButNotTheExactMatch() + { + // ICU's own example. `=` matches the number as written; `#` and the category are both taken + // after the offset is subtracted — which is what makes "Bob and 2 others" come out of a + // party of three. + const string Pattern = + "{n, plural, offset:1 =0 {nobody} =1 {just them} one {them and # other} other {them and # others}}"; + + await Assert.That(Format(Pattern, "en", ("n", 0))).IsEqualTo("nobody"); + await Assert.That(Format(Pattern, "en", ("n", 1))).IsEqualTo("just them"); + await Assert.That(Format(Pattern, "en", ("n", 2))).IsEqualTo("them and 1 other"); + await Assert.That(Format(Pattern, "en", ("n", 3))).IsEqualTo("them and 2 others"); + } + + [Test] + public async Task AHashPrintsANumberTheWayANumberArgumentPrintsIt() + { + // One bundle may not print one quantity two ways. `#` was the raw integer digits and + // `{n, number}` was the culture's grouped form, so a listing past a thousand said "1234 + // games" in a sentence and "1,234" in the column beside it. The separator is the culture's: + // en groups with a comma and de with a full stop. + await Assert.That(Format("{n, plural, other {# games}}", "en", ("n", 1234))).IsEqualTo("1,234 games"); + await Assert.That(Format("{n, plural, other {# Spiele}}", "de", ("n", 1234))).IsEqualTo("1.234 Spiele"); + + await Assert.That(Format("{n, plural, other {#}}", "en", ("n", 1_234_567))) + .IsEqualTo(Format("{n, number, integer}", "en", ("n", 1_234_567))); + } + + [Test] + public async Task ANegativeCountKeepsItsSign() + { + // CLDR takes the absolute value to choose a category and never to print the number. The + // operands are absolute because the chart says so; the rendering is not, and printing "3 + // games" for minus three is a measurement stated backwards. + const string Pattern = "{n, plural, one {# game} other {# games}}"; + + await Assert.That(Format(Pattern, "en", ("n", -1))).IsEqualTo("-1 game"); + await Assert.That(Format(Pattern, "en", ("n", -3))).IsEqualTo("-3 games"); + await Assert.That(Format(Pattern, "en", ("n", -1234))).IsEqualTo("-1,234 games"); + } + + [Test] + public async Task ChineseHasOneFormAndSoAgreesWithAnyShape() + { + // Which is exactly why it cannot be the locale a string architecture is validated against. + foreach (var count in new[] { 0, 1, 2, 5, 11 }) + { + await Assert.That(Format("{n, plural, other {#个游戏}}", "zh-Hans", ("n", count))) + .IsEqualTo($"{count}个游戏"); + } + } + + // ── select and nesting ─────────────────────────────────────────────────────────────────── + + [Test] + public async Task SelectMatchesAKeywordAndFallsBackToOther() + { + const string Pattern = "{state, select, measured {we watched it} declared {they said so} other {unknown}}"; + + await Assert.That(Format(Pattern, "en", ("state", "measured"))).IsEqualTo("we watched it"); + await Assert.That(Format(Pattern, "en", ("state", "declared"))).IsEqualTo("they said so"); + await Assert.That(Format(Pattern, "en", ("state", "derived"))).IsEqualTo("unknown"); + } + + [Test] + public async Task ASelectorMayHoldAnotherSelector() + { + // The case that breaks a parser which stops at the first closing brace: a branch containing + // an argument ends with two of them, and only a counted scan gets the boundary right. + const string Pattern = + "{kind, select, game {{n, plural, one {# game} other {# games}}} other {{n} things}}"; + + await Assert.That(Format(Pattern, "en", ("kind", "game"), ("n", 1))).IsEqualTo("1 game"); + await Assert.That(Format(Pattern, "en", ("kind", "game"), ("n", 7))).IsEqualTo("7 games"); + await Assert.That(Format(Pattern, "en", ("kind", "other"), ("n", 7))).IsEqualTo("7 things"); + } + + [Test] + public async Task AHashIsNotSpecialInsideANestedArgumentsSubMessage() + { + // ICU's rule, and a genuinely surprising one: # is a placeholder in the plural argument's + // own sub-messages and nowhere else. Inside a select nested in that plural it is a literal + // hash, and a message that wants the number there has to name the argument. + await Assert.That(Format( + "{n, plural, other {{k, select, a {# apples} other {# other}}}}", + "en", ("n", 4), ("k", "a"))) + .IsEqualTo("# apples"); + + await Assert.That(Format( + "{n, plural, other {{k, select, a {{n} apples} other {other}}}}", + "en", ("n", 4), ("k", "a"))) + .IsEqualTo("4 apples"); + } + + // ── number, date and time ──────────────────────────────────────────────────────────────── + + [Test] + public async Task NumberCarriesItsStyles() + { + await Assert.That(Format("{n, number}", "en", ("n", 1234.5m))).IsEqualTo("1,234.5"); + await Assert.That(Format("{n, number, integer}", "en", ("n", 1234.6m))).IsEqualTo("1,235"); + await Assert.That(Format("{n, number, percent}", "en", ("n", 0.42m))).IsEqualTo("42%"); + await Assert.That(Format("{n, number, ::.00}", "en", ("n", 3.14159m))).IsEqualTo("3.14"); + } + + [Test] + public async Task DateAndTimeAreAcceptedRatherThanRefused() + { + // Nothing on this site calls them — every date goes through Dates, which states UTC and + // never prints a numeric month. They are here so the grammar is supported rather than the + // half of it we happen to use. + var when = new DateTimeOffset(2026, 8, 17, 14, 2, 0, TimeSpan.Zero); + + await Assert.That(Format("{d, date}", "en", ("d", when))).IsEqualTo("17 Aug 2026"); + await Assert.That(Format("{d, date, short}", "en-GB", ("d", when))).Contains("2026"); + await Assert.That(Format("{d, time}", "en", ("d", when))).IsEqualTo("14:02:00"); + } + + // ── refusals ───────────────────────────────────────────────────────────────────────────── + + [Test] + public async Task ASelectorWithNoOtherBranchIsRefusedWhenItIsParsed() + { + // Not when a reader's count happens to reach the gap. Every bundle is parsed by a test, so + // this fails a build. + await Assert.That(() => MessagePattern.Parse("{n, plural, one {# game}}")) + .Throws<FormatException>(); + + await Assert.That(() => MessagePattern.Parse("{x, select, a {A}}")) + .Throws<FormatException>(); + } + + [Test] + public async Task ABranchKeywordNoCategoryUsesIsRefused() + { + // "much" is not a CLDR category, so nothing would ever select it. It is almost always a typo + // for "many", and silently rendering `other` instead is how that typo survives review. + await Assert.That(() => MessagePattern.Parse("{n, plural, much {#} other {#}}")) + .Throws<FormatException>(); + } + + [Test] + public async Task DeprecatedAndUnknownTypesAreRefusedRatherThanGuessed() + { + await Assert.That(() => MessagePattern.Parse("{n, choice, 0#none|1#one}")) + .Throws<FormatException>(); + + await Assert.That(() => MessagePattern.Parse("{n, spellout}")) + .Throws<FormatException>(); + } + + [Test] + public async Task AMissingArgumentIsAnErrorAndNotAnEmptyString() + { + // A message that silently rendered nothing for a value nobody passed would be a fact + // quietly missing from a page whose whole claim is that its facts are there. + await Assert.That(() => Format("{missing}")).Throws<FormatException>(); + await Assert.That(() => Format("{n, plural, other {#}}", "en", ("n", "not a number"))) + .Throws<FormatException>(); + } + + [Test] + public async Task AnUnmatchedBraceIsRefused() + { + await Assert.That(() => MessagePattern.Parse("a } b")).Throws<FormatException>(); + await Assert.That(() => MessagePattern.Parse("{n, plural, other {#}")).Throws<FormatException>(); + } + + [Test] + [Arguments("{n, plural, = {none} other {#}}")] // a bare '=' matched nothing at all + [Arguments("{n, plural, =x {none} other {#}}")] // and neither does a word after it + [Arguments("{n, plural, =- {none} other {#}}")] + [Arguments("{n, plural, =. {none} other {#}}")] + public async Task AnExplicitMatchWithNoNumberAfterItIsRefused(string pattern) + { + // An `=` selector is stored under a key compared against the number as written, so `=` on + // its own is a branch nothing can ever select. The category check at the line above skips + // anything starting with `=`, so this was the one dead branch the parser let through — and + // a dead branch is precisely what this parser refuses rather than guesses at. + await Assert.That(() => MessagePattern.Parse(pattern)).Throws<FormatException>(); + } + + [Test] + public async Task AnExplicitMatchStillTakesEveryNumberIcuWritesOneWith() + { + // Refusing the empty case must not also refuse the legal ones: ICU parses an explicit value + // as a number, which may carry a sign and a fraction. + await Assert.That(Format("{n, plural, =0 {none} other {#}}", "en", ("n", 0))).IsEqualTo("none"); + await Assert.That(Format("{n, plural, =-1 {owed} other {#}}", "en", ("n", -1))).IsEqualTo("owed"); + await Assert.That(Format("{n, plural, =1.5 {half} other {#}}", "en", ("n", 1.5m))).IsEqualTo("half"); + } + + [Test] + public async Task ADateWithNoZoneIsReadAsUtcAndNotAsTheServersOwnClock() + { + // This site states UTC on every date it prints, and `new DateTimeOffset(dt)` applies the + // machine's local offset to an Unspecified kind — so the same message rendered on two + // hosts said two different times, and neither said which. + var unspecified = new DateTime(2026, 8, 17, 14, 2, 0, DateTimeKind.Unspecified); + + await Assert.That(Format("{d, time, medium}", "en", ("d", unspecified))).IsEqualTo("14:02:00"); + await Assert.That(Format("{d, date, zzz}", "en", ("d", unspecified))).IsEqualTo("+00:00"); + } + + [Test] + public async Task ANumberArgumentThatIsNotANumberNamesItselfInTheRefusal() + { + // The documented contract is FormatException. Convert.ToDecimal raises InvalidCastException + // for a value with no conversion and OverflowException for one out of range, and neither + // says which argument in a forty-message page was the one that failed. + await Assert.That(() => Format("{n, number}", "en", ("n", new object()))) + .Throws<FormatException>(); + + await Assert.That(() => Format("{n, number, integer}", "en", ("n", double.MaxValue))) + .Throws<FormatException>(); + } + + // ── the parse, as a thing callers can read ─────────────────────────────────────────────── + + [Test] + public async Task APatternCanBeAskedWhatArgumentsItReads() + { + // Which is what lets a test check a bundle against the values the site actually supplies, + // without rendering every message against every plausible count. + var parsed = MessagePattern.Parse( + "{value}, {count, plural, one {# game} other {# games}}, {state, select, a {A} other {B}}"); + + var names = parsed.Arguments().Select(a => a.Name).ToList(); + + await Assert.That(names).Contains("value"); + await Assert.That(names).Contains("count"); + await Assert.That(names).Contains("state"); + + var plural = parsed.Arguments().Single(a => a.Kind is ArgumentKind.Plural); + + await Assert.That(plural.Branches.Keys).Contains("one"); + await Assert.That(plural.Branches.Keys).Contains("other"); + } + + [Test] + public async Task ThePatternCacheReturnsTheSameParseForTheSameText() + { + // Forty messages render per facet panel, and re-parsing a string that has not changed since + // startup is work nobody asked for. + const string Pattern = "{n, plural, one {#} other {#}}"; + + await Assert.That(IcuMessage.Compile(Pattern)).IsSameReferenceAs(IcuMessage.Compile(Pattern)); + } +} diff --git a/tests/MUI.Web.Tests/LocalizationTests.cs b/tests/MUI.Web.Tests/LocalizationTests.cs new file mode 100644 index 0000000..a2d1daa --- /dev/null +++ b/tests/MUI.Web.Tests/LocalizationTests.cs @@ -0,0 +1,1350 @@ +using Microsoft.AspNetCore.Http; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.FileProviders; +using Microsoft.Extensions.Hosting; +using MUI.Web.Localization; + +namespace MUI.Web.Tests; + +/// <summary> +/// The localization pipeline: plural rules, ICU messages, the locked glossary, and the routing. +/// </summary> +/// <remarks> +/// Nothing here asserts that a translation is <em>good</em> — no test can, and the handoff is +/// explicit that Han glyph correctness and register both need review by somebody who reads the +/// language. What these hold is the part a machine can: that a message reaches every form its locale +/// needs, that a locked string cannot quietly become a paraphrase, and that a locale nobody has +/// translated is never offered to a reader. +/// </remarks> +public class LocalizationTests +{ + // ── plural rules ───────────────────────────────────────────────────────────────────────── + + [Test] + [Arguments(0, "other")] + [Arguments(1, "one")] + [Arguments(2, "other")] + [Arguments(21, "other")] + public async Task EnglishHasTwoForms(int count, string expected) + { + await Assert.That(PluralRules.Keyword(PluralRules.Of("en", count))).IsEqualTo(expected); + } + + [Test] + [Arguments(1, "one")] + [Arguments(21, "one")] + [Arguments(2, "few")] + [Arguments(23, "few")] + [Arguments(5, "many")] + [Arguments(11, "many")] // the exception that catches a naive n % 10 rule + [Arguments(12, "many")] + [Arguments(0, "many")] + public async Task RussianHasThreeAndTheyAreNotObvious(int count, string expected) + { + // 11 and 12 end in 1 and 2 and take neither `one` nor `few`. A rule written from the first + // three examples anybody tries is wrong for both, which is why the canary exists. + await Assert.That(PluralRules.Keyword(PluralRules.Of("ru", count))).IsEqualTo(expected); + } + + [Test] + [Arguments(0)] + [Arguments(1)] + [Arguments(5)] + public async Task ChineseHasOneFormAndSoCannotFailAnAgreementBug(int count) + { + // The reason Chinese ships first and Russian goes in CI. Chinese agrees with any string + // architecture, including one that is wrong for every inflected language. + await Assert.That(PluralRules.Of("zh-Hans", count)).IsEqualTo(PluralCategory.Other); + await Assert.That(PluralRules.CategoriesOf("zh-Hans").Count).IsEqualTo(1); + } + + [Test] + public async Task AScriptOrPrivateSubtagDoesNotChangeHowANumberAgrees() + { + // zh-Hans and zh-Hant draw different glyphs; ru and the canary's ru-x-canary read different + // bundles. Neither changes the arithmetic. + await Assert.That(PluralRules.Of("zh-Hant", 5)).IsEqualTo(PluralRules.Of("zh", 5)); + await Assert.That(PluralRules.Of("ru-x-canary", 2)).IsEqualTo(PluralRules.Of("ru", 2)); + } + + // ── plural rules, checked against the CLDR 46 chart rather than against memory ──────────── + + [Test] + public async Task TurkishSaysOneForOneAndForNothingElse() + { + // CLDR 46 tr — one: n = 1. The table said `n = 0..1`, which is a real rule in CLDR and + // belongs to Akan and Punjabi, not to Turkish. It put zero in the form Turkish reserves + // for exactly one thing. + await Assert.That(PluralRules.Keyword(PluralRules.Of("tr", 0))).IsEqualTo("other"); + await Assert.That(PluralRules.Keyword(PluralRules.Of("tr", 1))).IsEqualTo("one"); + await Assert.That(PluralRules.Keyword(PluralRules.Of("tr", 2))).IsEqualTo("other"); + } + + [Test] + [Arguments("el", "one")] // one: n = 1 + [Arguments("no", "one")] // one: n = 1 + [Arguments("es", "one")] // one: n = 1 + [Arguments("tr", "one")] // one: n = 1 + [Arguments("da", "one")] // one: n = 1 or t != 0 and i = 0,1 + [Arguments("be", "one")] // one: n % 10 = 1 and n % 100 != 11 — stated on n, no v guard + [Arguments("en", "other")] // one: i = 1 and v = 0 + [Arguments("de", "other")] // one: i = 1 and v = 0 + [Arguments("it", "other")] // one: i = 1 and v = 0 + [Arguments("ru", "other")] // one: v = 0 and i % 10 = 1 and i % 100 != 11 + public async Task OnePointZeroIsWhatSeparatesARuleStatedOnNFromOneStatedOnI(string tag, string expected) + { + // 1.0 is the only value that tells the two shapes apart, and transcribing every language + // into `i = 1 and v = 0` because English is written that way is wrong for six of the + // thirty-one here. It is also the exact error the operands in this file exist to catch. + var oneDotZero = PluralOperands.Of(1.0m, visibleFractionDigits: 1); + + await Assert.That(PluralRules.Keyword(PluralRules.Of(tag, oneDotZero))).IsEqualTo(expected); + } + + [Test] + public async Task DanishSaysOneForAFractionBelowTwo() + { + // CLDR 46 da — one: n = 1 or t != 0 and i = 0,1. Danish is the only language in this table + // whose `one` reaches a value that is not 1, and a rule copied from Swedish loses it. + await Assert.That(PluralRules.Keyword(PluralRules.Of("da", PluralOperands.Of(0.5m)))).IsEqualTo("one"); + await Assert.That(PluralRules.Keyword(PluralRules.Of("da", PluralOperands.Of(1.5m)))).IsEqualTo("one"); + await Assert.That(PluralRules.Keyword(PluralRules.Of("da", PluralOperands.Of(2.5m)))).IsEqualTo("other"); + await Assert.That(PluralRules.Keyword(PluralRules.Of("da", 0))).IsEqualTo("other"); + } + + [Test] + [Arguments("fr")] + [Arguments("pt")] + [Arguments("es")] + [Arguments("it")] + public async Task AMillionTakesItsOwnFormInEveryRomanceLanguageCldrStatesOneFor(string tag) + { + // many: e = 0 and i != 0 and i % 1000000 = 0 and v = 0 — "un millón de juegos" takes a + // preposition the other forms do not. fr and pt had it; es and it were given English's + // rule and so had no `many` at all. + await Assert.That(PluralRules.Keyword(PluralRules.Of(tag, 1_000_000))).IsEqualTo("many"); + await Assert.That(PluralRules.Keyword(PluralRules.Of(tag, 2_000_000))).IsEqualTo("many"); + await Assert.That(PluralRules.Keyword(PluralRules.Of(tag, 1_000_001))).IsEqualTo("other"); + } + + [Test] + public async Task HebrewLostItsManyFormAndAllOfItsOrdinalsBeforeCldr46() + { + // Both were removed upstream, and a table still carrying them selects a branch no + // translator was asked to write — the failure this file's `other` fallback cannot catch, + // because the branch exists and is simply wrong. + await Assert.That(PluralRules.Keyword(PluralRules.Of("he", 20))).IsEqualTo("other"); + await Assert.That(PluralRules.Keyword(PluralRules.Of("he", 100))).IsEqualTo("other"); + + await Assert.That(PluralRules.CategoriesOf("he", PluralKind.Ordinal)) + .IsEquivalentTo(new[] { PluralCategory.Other }); + + // one: i = 1 and v = 0 or i = 0 and v != 0 — the second clause was missing entirely. + await Assert.That(PluralRules.Keyword(PluralRules.Of("he", PluralOperands.Of(0.5m)))).IsEqualTo("one"); + } + + [Test] + [Arguments("sv", 1, "one")] // one: n % 10 = 1,2 and n % 100 != 11,12 + [Arguments("sv", 2, "one")] + [Arguments("sv", 3, "other")] + [Arguments("sv", 11, "other")] + [Arguments("sv", 12, "other")] + [Arguments("sv", 21, "one")] + [Arguments("be", 2, "few")] // few: n % 10 = 2,3 and n % 100 != 12,13 + [Arguments("be", 3, "few")] + [Arguments("be", 12, "other")] + [Arguments("be", 13, "other")] + [Arguments("vi", 1, "one")] // one: n = 1 + [Arguments("vi", 2, "other")] + [Arguments("ms", 1, "one")] // one: n = 1 + public async Task TheOrdinalTableStatesARuleForEveryLanguageCldrStatesOneFor(string tag, int n, string expected) + { + // An ordinal rule missing from the table is not a missing translation — it is every rank + // rendered in the `other` form, silently, in a language that inflects them. + await Assert.That(PluralRules.Keyword(PluralRules.Of(tag, n, PluralKind.Ordinal))).IsEqualTo(expected); + } + + [Test] + public async Task ACldrRangeMatchesAWholeNumberAndNothingElse() + { + // `n % 100 = 3..10` is a range over integers: 3.5 is not in it. Reading it as `i % 100` + // makes every fraction take the category of its integer part. + await Assert.That(PluralRules.Keyword(PluralRules.Of("ar", PluralOperands.Of(3.5m)))).IsEqualTo("other"); + await Assert.That(PluralRules.Keyword(PluralRules.Of("ar", 3))).IsEqualTo("few"); + await Assert.That(PluralRules.Keyword(PluralRules.Of("ar", 11))).IsEqualTo("many"); + } + + // ── ICU messages ───────────────────────────────────────────────────────────────────────── + + [Test] + [Arguments(0, "0 games")] + [Arguments(1, "1 game")] + [Arguments(2, "2 games")] + public async Task ACountAndItsNounAgree(int count, string expected) + { + // The panel shipped "1 games" and "0 games" on every accessible name until this existed. + await Assert.That(Messages.Count("en", count)).IsEqualTo(expected); + } + + [Test] + public async Task TheSameMessageReachesADifferentFormInADifferentLocale() + { + // One message, one argument, three answers — which is the whole point of the message being + // a message rather than a number glued to a word. + await Assert.That(Messages.Count("ru-x-canary", 1)).IsEqualTo("1 игра"); + await Assert.That(Messages.Count("ru-x-canary", 2)).IsEqualTo("2 игры"); + await Assert.That(Messages.Count("ru-x-canary", 5)).IsEqualTo("5 игр"); + } + + [Test] + public async Task AnExactMatchWinsOverACategory() + { + // `=0` is how a message says "no games" rather than "0 games" without inventing a plural + // category that CLDR does not give English. + var listing = Messages.For("en", "listing.total", new Dictionary<string, object?> { ["count"] = 0 }); + + await Assert.That(listing).StartsWith("No games"); + } + + [Test] + public async Task ABranchMayHoldAnotherArgument() + { + // "1 of 6 disagree" nests {total} inside a plural branch. A parser that stopped at the first + // closing brace would cut the branch in half and read the rest as a key. + var args = new Dictionary<string, object?> { ["disagreeing"] = 1, ["total"] = 6 }; + + await Assert.That(Messages.For("en", "capabilities.agree", args)) + .IsEqualTo("1 of 6 disagrees with what the game declares."); + + args["disagreeing"] = 0; + + await Assert.That(Messages.For("en", "capabilities.agree", args)) + .IsEqualTo("None of the 6 disagree."); + } + + [Test] + public async Task SyntaxThisFormatterDoesNotImplementIsRefusedRatherThanGuessed() + { + // A formatter that accepts what it cannot do fails as a wrong string rather than as a build + // error, and a wrong string on this site is a wrong claim. + await Assert.That(() => IcuMessage.Format("{n, date, short}", "en", new Dictionary<string, object?> { ["n"] = 1 })) + .Throws<FormatException>(); + + await Assert.That(() => IcuMessage.Format("{missing}", "en")) + .Throws<FormatException>(); + } + + [Test] + public async Task AHashOutsideAPluralBranchIsALiteral() + { + // ICU says so, and a game called "#1 MUSH" would otherwise render its own count. + await Assert.That(IcuMessage.Format("channel #general", "en")).IsEqualTo("channel #general"); + } + + // ── the locked glossary ────────────────────────────────────────────────────────────────── + + [Test] + public async Task EveryLockedIdIsAMessageTheSiteActuallySays() + { + // A glossary entry with no message behind it is a promise to translators about a string + // that does not exist, and it would go on being translated for ever. + foreach (var locked in Glossary.Locked) + { + await Assert.That(Messages.Pattern(Locales.SourceTag, locked.Id)) + .IsEqualTo(locked.English) + .Because($"{locked.Id} is locked but the English bundle disagrees"); + } + } + + [Test] + public async Task TheFourKindsOfAbsenceAreFourDifferentStrings() + { + // The finding this whole file exists for. "not measured", "uncounted", "unreachable" and + // "not counted" are four claims, and a translation engine treats them as stylistic variants + // of *unavailable* — after which a reader cannot tell a game that answered from one that did + // not, which is the one thing this site is for. + string[] ids = ["state.notMeasured", "state.uncounted", "state.unreachable", "state.notCounted"]; + + var english = ids.Select(id => Messages.For("en", id)).ToList(); + + await Assert.That(english.Distinct().Count()).IsEqualTo(ids.Length); + + foreach (var id in ids) + { + await Assert.That(Glossary.IsLocked(id)).IsTrue().Because($"{id} must not be paraphrasable"); + } + } + + [Test] + public async Task OneEnglishWordWithSeveralSubjectsIsSeveralIds() + { + // "measured" is one string in English and four in Russian, chosen by what it describes. The + // ids have to be granular enough for a translator to reach each case at all — collapsing + // them because the source language cannot tell them apart is how three cases out of four end + // up ungrammatical. + var measured = Glossary.Locked.Where(l => l.English == "measured").ToList(); + + await Assert.That(measured.Count).IsGreaterThanOrEqualTo(4); + await Assert.That(measured.Select(m => m.Id).Distinct().Count()).IsEqualTo(measured.Count); + await Assert.That(measured.Select(m => m.Subject).Distinct().Count()).IsGreaterThanOrEqualTo(4); + + // And the bare column header is one of them, because it modifies nothing and so takes a form + // none of the others do. + await Assert.That(Glossary.Of("kicker.measured")!.Subject).IsEqualTo(Subject.Standalone); + } + + [Test] + public async Task EveryLockedStringShipsWithTheReasonItIsLocked() + { + // The lock reads as distrust without it, and a well-meaning "improvement" arrives as a pull + // request nobody knows how to refuse. + foreach (var locked in Glossary.Locked) + { + await Assert.That(string.IsNullOrWhiteSpace(locked.Rationale)).IsFalse(); + await Assert.That(locked.Rationale.Length).IsGreaterThan(40); + } + + await Assert.That(Glossary.Brief()).Contains("provenance.count.measured"); + await Assert.That(Glossary.Brief()).Contains("the English will show"); + } + + // ── completeness, and the canary ───────────────────────────────────────────────────────── + + [Test] + public async Task AnUntranslatedStringFallsBackToTheEnglishRatherThanToNothing() + { + // A reader meeting one English phrase inside another language learns something true. A + // smoothed-over approximation of a locked string teaches them something false and gives them + // no way to tell. + await Assert.That(Messages.HasOwn("ru-x-canary", "term.connected")).IsFalse(); + await Assert.That(Messages.For("ru-x-canary", "term.connected")).IsEqualTo("connected"); + + // And where it has been translated, the translation wins. + await Assert.That(Messages.For("ru-x-canary", "kicker.measured")).IsEqualTo("ИЗМЕРЕНО"); + } + + [Test] + public async Task TheCanaryFailsOnAMissingPluralFormRatherThanRenderingOne() + { + // The whole reason Russian is wired into CI while Chinese ships first. `listing.total` in + // the canary bundle declares `one` and `other` — complete in English, and silently missing + // the `few` form that a count of two takes in Russian. + var incomplete = Missing("ru-x-canary", "listing.total"); + + // Reported per argument, because a message with two counts in it can be complete for one + // and not the other. + await Assert.That(incomplete).Contains("count:few"); + await Assert.That(incomplete).Contains("count:many"); + + // Where the message is complete, nothing is reported. + await Assert.That(Missing("ru-x-canary", "facet.count")).IsEmpty(); + } + + [Test] + public async Task EveryOfferedLocaleIsCompleteInEveryPluralFormItNeeds() + { + // The gate. A locale reaches LocaleStatus.Shipped only when this holds for it — which is why + // the canary above is TestOnly and is not walked here. + foreach (var locale in Locales.Offered) + { + foreach (var id in Messages.Ids) + { + await Assert.That(Missing(locale.Tag, id)) + .IsEmpty() + .Because($"{locale.Tag} / {id} is missing a plural form it needs"); + } + } + } + + [Test] + public async Task NoLocaleIsOfferedBeforeItsLockedStringsAreTranslated() + { + // Nothing ships to a reader before the glossary exists. Today that means English alone, and + // this test is what stops somebody moving a status enum and shipping a mostly-English page + // under a Chinese flag. + foreach (var locale in Locales.Offered.Where(l => l.Tag != Locales.SourceTag)) + { + foreach (var locked in Glossary.Locked) + { + await Assert.That(Messages.HasOwn(locale.Tag, locked.Id)) + .IsTrue() + .Because($"{locale.Tag} is offered without a translation for {locked.Id}"); + } + } + } + + [Test] + public async Task ThePseudolocaleExercisesTheMachineryAndTheWidthBudget() + { + // Accented and expanded, so a string that never went through the pipeline is visible at a + // glance and every string is reviewed at the 1.4x width German and Russian actually need. + var pseudo = Messages.Count("qps-ploc", 3); + + await Assert.That(pseudo).Contains("⟦"); + await Assert.That(pseudo).Contains("3"); + await Assert.That(pseudo.Length).IsGreaterThan(Messages.Count("en", 3).Length); + + // And the ICU syntax survived: a pseudolocale that mangled a branch keyword would prove + // nothing, because the message would not parse. + await Assert.That(Messages.Count("qps-ploc", 1)).Contains("1"); + } + + // ── routing ────────────────────────────────────────────────────────────────────────────── + + [Test] + [Arguments("de", "de")] + [Arguments("de-AT,de;q=0.9,en;q=0.8", "de")] + [Arguments("zh-CN,zh;q=0.9", "zh-Hans")] + [Arguments("en-GB,en;q=0.9", null)] // already where they are + [Arguments("de;q=0", null)] // explicitly refused + [Arguments("*", null)] + [Arguments("", null)] + [Arguments("kl,fo", null)] // nothing offered answers + public async Task AcceptLanguageIsReadForTheFirstVisitOnly(string header, string? expected) + { + // A header is a standing preference about content in general, not a choice about this site — + // worth one redirect and no more. The parse honours q-values because a browser sends them + // meaning something, and matches on the language subtag so zh-CN reaches zh-Hans. + // + // Note every case answers null today, because English is the only offered locale and English + // is where the reader already is. The rule is asserted against the offered set rather than + // against a hard-coded answer, so this starts biting the day a locale ships. + var chosen = LocaleRouting.Preferred(header); + + if (expected is null || Locales.Find(expected) is not { IsOffered: true }) + { + await Assert.That(chosen).IsNull(); + return; + } + + await Assert.That(chosen!.Tag).IsEqualTo(expected); + } + + [Test] + [Arguments("/games", "/games")] + [Arguments("/de/games", "/games")] + [Arguments("//elsewhere.example", "/")] + [Arguments("/\\elsewhere.example", "/")] + [Arguments("/games\nLocation: /evil", "/")] + [Arguments("", "/")] + public async Task TheReturnPathIsAPathOnThisSiteAndNothingElse(string posted, string expected) + { + // It arrives in a form field and is written into a Location header. A protocol-relative URL + // is a different host wearing a path's clothes and walks straight through a StartsWith('/') + // check; several browsers read /\host the same way; a CR here is response splitting. + // Any locale prefix comes off, because the endpoint decides which language the page is in. + await Assert.That(LocaleRouting.Back(posted)).IsEqualTo(expected); + } + + /// <summary> + /// The document states the language it is written in, and it is the one the reader asked for. + /// </summary> + /// <remarks> + /// <para> + /// <c>lang</c> was the constant <c>"en"</c> while the whole page below it came back translated, + /// so a reader on <c>/ja/games</c> was handed a fully Japanese document that told the browser it + /// was English. That is not a tidiness point on the two locales this site shipped first: Unicode + /// unified thousands of Han characters across Chinese and Japanese, the correct drawn form + /// differs, and <c>lang</c> is the only thing that selects between the two font families. The + /// wrong one renders at exactly the same width, so nothing in the overflow audit could see it. + /// </para> + /// <para> + /// It is also what a screen reader switches voice on, and what the <c>hreflang</c> links in the + /// head are claiming about this document — three separate promises that were all being made in + /// the wrong language. + /// </para> + /// </remarks> + [Test] + [Arguments("/games", "en")] + [Arguments("/de/games", "de")] + [Arguments("/nl/games", "nl")] + [Arguments("/ja/games", "ja")] + [Arguments("/zh-Hans/games", "zh-Hans")] + public async Task TheDocumentDeclaresTheLanguageItIsAnsweredIn(string path, string expected) + { + await using var site = await SiteHost.StartAsync(); + + var markup = await site.Client.GetStringAsync(path); + + await Assert.That(markup).Contains($"<html lang=\"{expected}\""); + } + + /// <summary> + /// A locale is a property of a document, so nothing else is ever moved to reach one. + /// </summary> + /// <remarks> + /// <para> + /// <b>The locale was a one-way door, and the switcher out of it was the thing it shut.</b> The + /// middleware answered any unprefixed request from a reader with <c>mui_locale=de</c> with a + /// redirect to <c>/de/...</c> — including a POST. A browser follows a 302 as a GET and drops the + /// body, and <c>/de/theme</c> is served by nothing, so a German reader could not change the + /// theme; <c>POST /locale</c> went the same way, so they could not change the language back + /// either. Every control on this site is a form, which is what made one redirect reach all of + /// them. + /// </para> + /// <para> + /// The API and the crawler's own files are excluded for a different reason: they are not + /// documents in a language. <c>/api/…</c> answers the same JSON to everybody and + /// <c>robots.txt</c> has one canonical address, which is where a crawler looks for it. + /// </para> + /// </remarks> + [Test] + public async Task AChoiceOfLocaleNeverMovesARequestThatIsNotADocument() + { + await using var site = await SiteHost.StartAsync(); + + // The theme is written, rather than the request being bounced to a URL nothing serves. + var theme = new HttpRequestMessage(HttpMethod.Post, "/theme") + { + Content = new FormUrlEncodedContent([ + new KeyValuePair<string, string>("theme", "light"), + new KeyValuePair<string, string>("return", "/games"), + ]), + }; + theme.Headers.Add("Cookie", $"{Locales.CookieName}=de"); + + var themed = await site.Client.SendAsync(theme); + + await Assert.That(themed.Headers.TryGetValues("Set-Cookie", out var themeCookies)).IsTrue(); + await Assert.That(string.Join(' ', themeCookies!)).Contains("mui_theme=light"); + + // And the way out of German is still open from inside German. + var switched = new HttpRequestMessage(HttpMethod.Post, Locales.Path) + { + Content = new FormUrlEncodedContent([ + new KeyValuePair<string, string>(Locales.Field, "nl"), + new KeyValuePair<string, string>(Locales.ReturnField, "/games"), + ]), + }; + switched.Headers.Add("Cookie", $"{Locales.CookieName}=de"); + + var moved = await site.Client.SendAsync(switched); + + await Assert.That(moved.Headers.TryGetValues("Set-Cookie", out var localeCookies)).IsTrue(); + await Assert.That(string.Join(' ', localeCookies!)).Contains($"{Locales.CookieName}=nl"); + await Assert.That(moved.Headers.Location?.OriginalString).IsEqualTo("/nl/games"); + } + + /// <summary>A document still follows the reader's choice, which is the rule the guard protects.</summary> + [Test] + public async Task AChoiceOfLocaleStillMovesADocument() + { + await using var site = await SiteHost.StartAsync(); + + var asked = new HttpRequestMessage(HttpMethod.Get, "/games"); + asked.Headers.Add("Cookie", $"{Locales.CookieName}=de"); + + var answered = await site.Client.SendAsync(asked); + + await Assert.That((int)answered.StatusCode).IsEqualTo(302); + await Assert.That(answered.Headers.Location?.OriginalString).IsEqualTo("/de/games"); + } + + /// <summary> + /// A redirect re-emits the address that was asked for, and not a decoded reading of it. + /// </summary> + /// <remarks> + /// <c>Request.Path.Value</c> is decoded, so writing it back into a <c>Location</c> header + /// changes what the URL means: <c>%2F</c> comes back as a separator and makes one segment into + /// two, <c>%23</c> comes back as a <c>#</c> and truncates everything after it, and a non-ASCII + /// character comes back raw into a header field that cannot carry one. A game whose slug + /// contains any of them is a game a reader cannot reach in any language but English. + /// </remarks> + [Test] + [Arguments("/g/a%2Fb")] + [Arguments("/g/caf%C3%A9")] + [Arguments("/g/one%23two")] + [Arguments("/g/what%3Fnow")] + public async Task AnEscapedPathSurvivesTheRedirectItIsSentThrough(string path) + { + await using var site = await SiteHost.StartAsync(); + + var asked = new HttpRequestMessage(HttpMethod.Get, path); + asked.Headers.Add("Cookie", $"{Locales.CookieName}=de"); + + var answered = await site.Client.SendAsync(asked); + + await Assert.That((int)answered.StatusCode).IsEqualTo(302); + await Assert.That(answered.Headers.Location?.OriginalString).IsEqualTo("/de" + path); + } + + /// <summary>And the same going the other way, off the /en prefix that redirects to no prefix.</summary> + [Test] + [Arguments("/en/g/a%2Fb", "/g/a%2Fb")] + [Arguments("/en/g/caf%C3%A9", "/g/caf%C3%A9")] + public async Task AnEscapedPathSurvivesTheRedirectOffTheEnglishPrefix(string asked, string expected) + { + await using var site = await SiteHost.StartAsync(); + + var answered = await site.Client.GetAsync(asked); + + await Assert.That((int)answered.StatusCode).IsEqualTo(301); + await Assert.That(answered.Headers.Location?.OriginalString).IsEqualTo(expected); + } + + /// <summary> + /// A file is the same file in every language, including the ones whose names we cannot know. + /// </summary> + /// <remarks> + /// The stylesheet carries a content fingerprint, so no list of paths can name it — and a reader + /// with a locale cookie was paying a redirect for the stylesheet, the script and the touch icon + /// on every page load. Recognised by extension rather than by "the last segment has a dot", + /// because <c>{Slug}</c> is a route parameter and a game's slug is not this rule's to constrain. + /// </remarks> + [Test] + [Arguments("/app.gt0hup1p9v.css")] + [Arguments("/passkey.js")] + [Arguments("/apple-touch-icon.png")] + [Arguments("/favicon.svg")] + [Arguments("/site.webmanifest")] + [Arguments("/robots.txt")] + [Arguments("/sitemap.xml")] + public async Task AFingerprintedFileIsNeverGivenALocalePrefix(string path) + { + await Assert.That(LocaleRouting.IsUnlocalized(path)).IsTrue(); + } + + /// <summary>And a document is still a document, whatever is in its slug.</summary> + [Test] + [Arguments("/games")] + [Arguments("/g/m-u-s-h")] + [Arguments("/reference/protocols/mssp")] + [Arguments("/g/a-game-with.no-extension")] + public async Task ADocumentIsNeverMistakenForAFile(string path) + { + await Assert.That(LocaleRouting.IsUnlocalized(path)).IsFalse(); + } + + /// <summary>The read API and the crawler's files have one address each, in every language.</summary> + [Test] + [Arguments("/api/games")] + [Arguments("/robots.txt")] + [Arguments("/sitemap.xml")] + public async Task AFileThatIsTheSameInEveryLanguageIsNotGivenALocalePrefix(string path) + { + await using var site = await SiteHost.StartAsync(); + + var asked = new HttpRequestMessage(HttpMethod.Get, path); + asked.Headers.Add("Cookie", $"{Locales.CookieName}=de"); + + var answered = await site.Client.SendAsync(asked); + + await Assert.That((int)answered.StatusCode).IsNotEqualTo(302); + } + + // ── links out of a locale ──────────────────────────────────────────────────────────────── + + /// <summary> + /// One address, in the locale the page carrying it is read in. + /// </summary> + /// <remarks> + /// The table is the whole rule: an app path takes the prefix, the source locale takes none, and + /// four shapes are left exactly as they arrived — a query-only address, which means <em>this + /// page, asked differently</em>; a file that has one canonical address in every language; an + /// absolute URL; and a protocol-relative one, which is another host wearing a path's clothes. + /// </remarks> + [Test] + [Arguments("en", "/games", "/games")] + [Arguments("de", "/games", "/de/games")] + [Arguments("de", "/", "/de/")] + [Arguments("de", "/g/ashen-court", "/de/g/ashen-court")] + [Arguments("de", "/games?sort=busiest", "/de/games?sort=busiest")] + [Arguments("zh-Hans", "/rankings", "/zh-Hans/rankings")] + [Arguments("de", "?plain=1", "?plain=1")] + [Arguments("de", "?window=30d&plain=1", "?window=30d&plain=1")] + [Arguments("de", "#content", "#content")] + [Arguments("de", "/api/games", "/api/games")] + [Arguments("de", "/robots.txt", "/robots.txt")] + [Arguments("de", "/sitemap.xml", "/sitemap.xml")] + [Arguments("de", "/favicon.svg", "/favicon.svg")] + [Arguments("de", "/site.webmanifest", "/site.webmanifest")] + [Arguments("de", "/api/games?limit=5", "/api/games?limit=5")] + [Arguments("de", "https://example.com/games", "https://example.com/games")] + [Arguments("de", "mailto:someone@example.com", "mailto:someone@example.com")] + [Arguments("de", "//elsewhere.example/games", "//elsewhere.example/games")] + [Arguments("de", "", "")] + public async Task AnAddressIsWrittenInTheLocaleThePageIsReadIn(string tag, string given, string expected) + { + await Assert.That(LocaleRouting.Link(tag, given)).IsEqualTo(expected); + } + + /// <summary> + /// Every link on a localized page stays inside that locale. + /// </summary> + /// <remarks> + /// <para> + /// <b>Every internal link was an absolute path emitted verbatim, so a German page's links all + /// pointed out of German.</b> <c>/de/games</c> rendered <c>href="/games"</c>, + /// <c>href="/about"</c> and <c>href="/find"</c>, and a reader who followed a shared + /// <c>/de/…</c> link carries no cookie — so nothing could send them back and their first click + /// landed in English. Putting the locale in the path is what makes it linkable, shareable, + /// cacheable and indexable, and a page that discards it on every link has the property in its + /// own address and nowhere else. + /// </para> + /// <para> + /// Swept rather than spot-checked, over every anchor and every form on the page, because the + /// bug was fifty separate link sites and any one of them left behind is the same bug for + /// whichever reader clicks it. Nothing here is asked with a cookie: this is the reader who was + /// sent a link. + /// </para> + /// </remarks> + [Test] + [Arguments("/de/")] + [Arguments("/de/games")] + [Arguments("/de/games?sort=busiest")] + [Arguments("/de/archive")] + [Arguments("/de/find")] + [Arguments("/de/rankings")] + [Arguments("/de/ecosystem")] + [Arguments("/de/about")] + [Arguments("/de/reference")] + [Arguments("/de/reference/codebases/pennmush")] + [Arguments("/de/submit")] + [Arguments("/de/g/ashen-court")] + public async Task EveryLinkOnALocalizedPageStaysInThatLocale(string path) + { + await using var site = await SiteHost.StartAsync(); + + var markup = await site.Client.GetStringAsync(path); + var addresses = Addresses(markup); + + // The page was read, rather than a 404 body with nothing on it being swept clean. + await Assert.That(addresses.Count).IsGreaterThan(3); + + foreach (var address in addresses) + { + if (LeavesThisSite(address) || LocaleRouting.IsUnlocalized(PathOf(address))) + { + continue; + } + + await Assert.That(address) + .StartsWith("/de/") + .Because($"{path} offers {address}, which leads out of German"); + } + } + + /// <summary>And the source locale is the absence of a prefix, on the same pages.</summary> + /// <remarks> + /// <c>/games</c> is the canonical English address and <c>/en/games</c> redirects to it, so a + /// prefix written here would be a second URL for a document that already has one — and every + /// bookmark and inbound link already spells the unprefixed one. + /// </remarks> + [Test] + [Arguments("/")] + [Arguments("/games")] + [Arguments("/archive")] + [Arguments("/find")] + [Arguments("/rankings")] + [Arguments("/g/ashen-court")] + public async Task TheSourceLocaleIsTheAbsenceOfAPrefix(string path) + { + await using var site = await SiteHost.StartAsync(); + + var markup = await site.Client.GetStringAsync(path); + + foreach (var address in Addresses(markup)) + { + foreach (var locale in Locales.All) + { + await Assert.That(address.StartsWith($"/{locale.Tag}/", StringComparison.Ordinal)) + .IsFalse() + .Because($"{path} offers {address}, a second address for a page that has one"); + } + } + } + + /// <summary> + /// A query-only address means <em>this page, asked differently</em>, in every language. + /// </summary> + /// <remarks> + /// The plain-text link and all five trend range links are written as a bare querystring so they + /// resolve against the page they are on — which is what removing <c><base href="/"></c> + /// from <c>App.razor</c> made true, and which giving one a prefix would undo just as + /// thoroughly: <c>/de/?plain=1</c> is the home page, not the listing the reader was reading. + /// </remarks> + [Test] + [Arguments("/de/games")] + [Arguments("/de/g/ashen-court")] + [Arguments("/de/rankings")] + public async Task AQueryOnlyAddressIsLeftExactlyAsItWasWritten(string path) + { + await using var site = await SiteHost.StartAsync(); + + var markup = await site.Client.GetStringAsync(path); + var queries = Addresses(markup).Where(a => a.StartsWith('?')).ToList(); + + await Assert.That(queries.Count).IsGreaterThan(0); + + foreach (var query in queries) + { + await Assert.That(query).DoesNotContain("/de"); + } + } + + /// <summary> + /// A file with one canonical address never gets a prefix, whatever language the page is in. + /// </summary> + /// <remarks> + /// The head's own links are not swept above — a stylesheet is not a document in a language — + /// so the list the middleware refuses to redirect is asserted here directly against the markup + /// that carries it. + /// </remarks> + [Test] + public async Task AFileWithOneAddressIsNeverPrefixedInTheMarkupEither() + { + await using var site = await SiteHost.StartAsync(); + + var markup = await site.Client.GetStringAsync("/de/games"); + + foreach (var file in new[] { "/favicon.svg", "/favicon.ico", "/site.webmanifest" }) + { + await Assert.That(markup).Contains($"href=\"{file}\""); + await Assert.That(markup).DoesNotContain($"href=\"/de{file}\""); + } + } + + /// <summary> + /// A control that answers with a <c>Location</c> header keeps the reader's language too. + /// </summary> + /// <remarks> + /// <para> + /// <b>These are the links a sweep of the markup cannot see</b>, and the walk found them where + /// the sweep could not: "surprise me" is in the nav of every page, and from <c>/de/games</c> it + /// answered with <c>Location: /g/eldertale</c> — a reader two clicks into German, put back into + /// English by the one destination that is a header rather than an attribute. The theme control + /// did the same for the reader who preferred a light background. + /// </para> + /// <para> + /// No cookie on any of these, deliberately. A reader who followed a shared <c>/de/…</c> link has + /// none, so the path is the only thing that knows what language they are reading in — which is + /// the whole reason the locale is in the path. + /// </para> + /// </remarks> + [Test] + public async Task AControlThatAnswersWithARedirectKeepsTheReadersLanguage() + { + await using var site = await SiteHost.StartAsync(); + + var random = await site.Client.GetAsync("/de/games/random"); + + await Assert.That((int)random.StatusCode).IsEqualTo(302); + await Assert.That(Where(random)).StartsWith("/de/g/"); + + var theme = new HttpRequestMessage(HttpMethod.Post, "/de/theme") + { + Content = new FormUrlEncodedContent([ + new KeyValuePair<string, string>("theme", "light"), + new KeyValuePair<string, string>("return", "/games"), + ]), + }; + + var themed = await site.Client.SendAsync(theme); + + await Assert.That((int)themed.StatusCode).IsEqualTo(303); + await Assert.That(themed.Headers.Location?.OriginalString).IsEqualTo("/de/games"); + + // And the crawler's own short URL, which lands on a page and so is a document in a language. + var crawler = await site.Client.GetAsync("/de/crawler"); + + await Assert.That(Where(crawler)).StartsWith("/de/about"); + + // The source locale keeps the address it always had. + var english = await site.Client.GetAsync("/games/random"); + + await Assert.That(Where(english)).StartsWith("/g/"); + await Assert.That(Where(english)).DoesNotContain("/de/"); + } + + /// <summary> + /// The plain surface prints its addresses in the locale it is printing. + /// </summary> + /// <remarks> + /// <para> + /// <b>They are links, whatever they look like.</b> There are no anchors on this surface, so a + /// path is printed for a reader to type, to follow in a text browser, or to paste to somebody — + /// and a German reader who copies <c>/g/ashen-court</c> off <c>/de/games?plain=1</c> arriving in + /// English is the same defect as the fifty in the markup, on the surface whose whole promise is + /// that it mirrors the page. + /// </para> + /// <para> + /// The trend's seek link stays a bare querystring here for the reason it does in the markup: it + /// means <em>this page, asked differently</em>, and the page it is on is already the German one. + /// </para> + /// </remarks> + [Test] + public async Task ThePlainSurfacePrintsItsAddressesInTheLocaleItIsPrintingIn() + { + await using var site = await SiteHost.StartAsync(); + + var listing = await site.Client.GetStringAsync("/de/games?plain=1"); + var game = await site.Client.GetStringAsync("/de/g/ashen-court?plain=1"); + var english = await site.Client.GetStringAsync("/games?plain=1"); + + await Assert.That(listing).Contains("/de/g/ashen-court"); + await Assert.That(english).Contains("/g/ashen-court"); + await Assert.That(english).DoesNotContain("/de/g/ashen-court"); + + // The seek link is relative to the page and is not given a prefix it would break under. + await Assert.That(game).Contains("?from="); + await Assert.That(game).DoesNotContain("/de?from="); + } + + /// <summary> + /// A reference article is the article in every locale, and not the section's empty state. + /// </summary> + /// <remarks> + /// The page looked itself up by <c>NavigationManager.Uri</c>, whose local path still carries + /// the prefix the middleware moved into <c>PathBase</c> — so <c>/de/reference/codebases/pennmush</c> + /// asked the library for a document filed under <c>/reference/codebases/pennmush</c>, was told + /// there is none, and answered every non-English reader with "no reference page here" for all + /// thirty-odd articles. It is the request's own path that names the document, in every language. + /// </remarks> + [Test] + [Arguments("/reference/codebases/pennmush")] + [Arguments("/de/reference/codebases/pennmush")] + [Arguments("/ja/reference/codebases/pennmush")] + public async Task AReferenceArticleIsFoundInEveryLocale(string path) + { + await using var site = await SiteHost.StartAsync(); + + var markup = await site.Client.GetStringAsync(path); + + await Assert.That(markup).Contains("PennMUSH"); + await Assert.That(Render.Words(markup)).DoesNotContain("No reference page here"); + } + + /// <summary>Every anchor and every form on a rendered page, as the browser receives them.</summary> + /// <remarks> + /// Read off the frame rather than the source, because that is where the bug was: the components + /// held the right paths all along and the markup is what pointed out of the locale. + /// </remarks> + private static IReadOnlyList<string> Addresses(string markup) => + [ + .. System.Text.RegularExpressions.Regex + .Matches(markup, "<a\\s[^>]*?href=\"([^\"]*)\"|<form\\s[^>]*?action=\"([^\"]*)\"") + .Select(m => m.Groups[1].Success ? m.Groups[1].Value : m.Groups[2].Value) + .Select(a => System.Net.WebUtility.HtmlDecode(a) ?? string.Empty) + .Where(a => a.Length > 0), + ]; + + /// <summary> + /// Where a redirect sends the reader, as a path. + /// </summary> + /// <remarks> + /// The two shapes are both correct and both shipped: an endpoint writes a relative + /// <c>Location</c>, and a page redirecting through <c>NavigationManager</c> gets an absolute one + /// built off the request's own base. What a test is asking about is where the reader lands. + /// </remarks> + private static string Where(HttpResponseMessage response) => + response.Headers.Location is not { } location ? string.Empty + : location.IsAbsoluteUri ? location.AbsolutePath + : location.OriginalString; + + /// <summary>Whether an address names somewhere that is not a page of this site.</summary> + private static bool LeavesThisSite(string address) => + address[0] != '/' || (address.Length > 1 && address[1] is '/' or '\\'); + + private static string PathOf(string address) + { + var cut = address.AsSpan().IndexOfAny('?', '#'); + + return cut < 0 ? address : address[..cut]; + } + + /// <summary> + /// A sentence with links in it is one message, and what a translator writes is never markup. + /// </summary> + /// <remarks> + /// The random-game empty state is "No game matches that filter. Try {listing}, or {archive}." — + /// two anchors inside one sentence. Gluing English round the anchors would give a language that + /// wants the archive named first, or a different preposition before each, nowhere to say so; but + /// formatting the anchors *into* the string and trusting the result through a + /// <c>MarkupString</c> would make every bundle a place a tag could be put. The message places + /// two private-use markers and the page walks them, so the bundle holds text either way. + /// </remarks> + [Test] + public async Task ASentenceWithLinksInItPlacesThemWithoutCarryingMarkup() + { + foreach (var id in new[] { "random.empty.title", "random.empty.body", "random.empty.listing", "random.empty.archive" }) + { + await Assert.That(Messages.Ids).Contains(id); + } + + // The body places both links and holds no markup of its own, in every locale. + foreach (var locale in Locales.All.Where(l => l.IsChoosable)) + { + var body = Messages.Pattern(locale.Tag, "random.empty.body"); + + await Assert.That(body).Contains("{listing}").Because($"{locale.Tag} must place the listing link"); + await Assert.That(body).Contains("{archive}").Because($"{locale.Tag} must place the archive link"); + await Assert.That(body).DoesNotContain("<").Because($"{locale.Tag} must carry no markup"); + } + } + + [Test] + public async Task TheAlternatesNameEveryOfferedLocaleAndAnXDefault() + { + var alternates = LocaleRouting.Alternates("/games").ToList(); + + await Assert.That(alternates.Select(a => a.HrefLang)).Contains("x-default"); + + // x-default is the unprefixed address: the one to show a reader whose language nothing here + // matches, rather than leaving a crawler to pick among them. + await Assert.That(alternates.Single(a => a.HrefLang == "x-default").Path).IsEqualTo("/games"); + + foreach (var locale in Locales.Offered) + { + var mine = alternates.Single(a => a.HrefLang == locale.Tag); + + await Assert.That(mine.Path).IsEqualTo( + locale.Tag == Locales.SourceTag ? "/games" : $"/{locale.Tag}/games"); + } + } + + [Test] + public async Task ARenderOnlyScriptIsNeverAnInterfaceLanguage() + { + // An Arabic game name inside an English page is correct permanently — that is <bdi> and a + // per-element lang, and it needs nothing further. An entire Arabic interface still flowing + // left-to-right is not, so it is not offered. The boundary is data rather than a comment, so + // it is publishable and so this can hold it. + foreach (var script in Locales.RenderOnlyScripts) + { + await Assert.That(Locales.Offered.Any(l => l.Tag.StartsWith(script, StringComparison.Ordinal))) + .IsFalse() + .Because($"{script} is render-only and must not be an interface language"); + } + } + + /// <summary> + /// The plural forms a locale needs for a message and does not declare. + /// </summary> + /// <remarks> + /// <para> + /// Read off the parsed message rather than off the string, so a branch inside a nested selector + /// counts exactly as one at the top level does. + /// </para> + /// <para> + /// An <c>other</c> branch does not excuse a missing form, and that is the point: ICU will + /// happily route a Russian 2 through <c>other</c> and render a word no native speaker would + /// write, silently. A form the language distinguishes has to be declared rather than fallen + /// into. + /// </para> + /// <para> + /// Only what the locale itself carries is checked. A locale that has translated nothing reports + /// nothing missing here, which is correct: an untranslated string is a fallback and a + /// half-translated plural is a bug, and only the second is this test's business. + /// </para> + /// </remarks> + private static IReadOnlyList<string> Missing(string tag, string id) + { + if (!Messages.HasOwn(tag, id)) + { + return []; + } + + var pattern = IcuMessage.Compile(Messages.Pattern(tag, id)!); + + return + [ + .. pattern.Arguments() + .Where(a => a.Kind is ArgumentKind.Plural or ArgumentKind.SelectOrdinal) + .SelectMany(a => PluralRules + .CategoriesOf(tag, a.Kind is ArgumentKind.SelectOrdinal + ? PluralKind.Ordinal + : PluralKind.Cardinal) + .Select(PluralRules.Keyword) + .Where(form => form != "other" && !a.Branches.ContainsKey(form)) + .Select(form => $"{a.Name}:{form}")), + ]; + } + + [Test] + public async Task EveryPatternInEveryBundleParses() + { + // The whole reason the pattern is parsed rather than interpreted: a message with a missing + // `other`, an unbalanced brace or a branch keyword no category uses is broken for exactly + // one reader — whichever one's count reaches it. Parsing every bundle here turns all three + // into a build failure. + foreach (var locale in Locales.All) + { + foreach (var id in Messages.Ids) + { + if (!Messages.HasOwn(locale.Tag, id)) + { + continue; + } + + var pattern = Messages.Pattern(locale.Tag, id)!; + + await Assert.That(() => IcuMessage.Compile(pattern)) + .ThrowsNothing() + .Because($"{locale.Tag} / {id} does not parse: {pattern}"); + } + } + } + + [Test] + public async Task EveryTranslationReadsTheSameArgumentsTheEnglishDoes() + { + // A translator who drops {total} from a sentence leaves a fact off the page, and one who + // invents {name} writes a message the site will refuse to render at all. Both are caught + // here rather than by whoever opens that page in that language. + foreach (var locale in Locales.All.Where(l => l.Tag != Locales.SourceTag)) + { + foreach (var id in Messages.Ids.Where(i => Messages.HasOwn(locale.Tag, i))) + { + var source = Names(Messages.Pattern(Locales.SourceTag, id)!); + var mine = Names(Messages.Pattern(locale.Tag, id)!); + + await Assert.That(mine.Except(source)) + .IsEmpty() + .Because($"{locale.Tag} / {id} names an argument the English does not supply"); + } + } + + static IReadOnlyList<string> Names(string pattern) => + [.. IcuMessage.Compile(pattern).Arguments().Select(a => a.Name).Distinct()]; + } + + [Test] + public async Task EveryLocaleTheSiteNamesHasAPluralRuleWrittenForIt() + { + // An unlisted language answers `other` for every count — right for Chinese, wrong for + // German, and silent either way. This is the gate on adding one. + foreach (var locale in Locales.All) + { + await Assert.That(PluralRules.Covers(locale.Tag)) + .IsTrue() + .Because($"{locale.Tag} has no plural rule transcribed from CLDR {PluralRules.CldrVersion}"); + } + } + + [Test] + public async Task TheResxAndTheCompiledInSourceSayTheSameThing() + { + // Two copies of the English exist on purpose — resx is where a translation lives and where + // every translation tool looks, and the compiled-in bundle is the fallback that must not + // depend on a satellite assembly having loaded. Two copies with no test between them is how + // a message gets fixed in one and not the other, and the reader who finds out is whichever + // one is served by the copy nobody updated. + var resx = ResxMessages(); + + await Assert.That(resx).IsNotEmpty(); + + foreach (var id in Messages.Ids) + { + await Assert.That(resx.ContainsKey(id)) + .IsTrue() + .Because($"{id} is in the source bundle and not in Messages.resx"); + + await Assert.That(resx[id]) + .IsEqualTo(Messages.Source(id)) + .Because($"{id} differs between Messages.resx and the compiled-in source"); + } + + foreach (var id in resx.Keys) + { + await Assert.That(Messages.Ids) + .Contains(id) + .Because($"{id} is in Messages.resx and nothing on the site says it"); + } + } + + /// <summary> + /// The English resx, read as XML rather than through the resource manager. + /// </summary> + /// <remarks> + /// Deliberately not through <see cref="Microsoft.Extensions.Localization.IStringLocalizer"/>: + /// that would read whatever the build embedded, which is the thing being checked. Reading the + /// file compares what a translator would edit against what the site compiles. + /// <para> + /// The file is copied beside the test binary by the project — see the comment on that item for + /// why, which is that counting <c>..</c> segments up from <see cref="AppContext.BaseDirectory"/> + /// only reaches the repository root at one exact output depth, and failed as a missing file in + /// a test whose subject is message content. + /// </para> + /// </remarks> + private static IReadOnlyDictionary<string, string> ResxMessages() + { + var path = System.IO.Path.Combine(System.AppContext.BaseDirectory, "Messages.resx"); + + var document = System.Xml.Linq.XDocument.Load(path); + + return document.Root! + .Elements("data") + .Where(e => e.Attribute("name") is not null) + .ToDictionary( + e => e.Attribute("name")!.Value, + e => e.Element("value")?.Value ?? string.Empty, + StringComparer.Ordinal); + } + + [Test] + public async Task ALocaleIsOfferedWhenItHasTheWordsAndNotBefore() + { + // The gate, and now the only one. `Offered` is what a default may reach — Accept-Language, a + // remembered cookie, an hreflang alternate — and what opens it is the bundle carrying the + // locked glossary, not somebody's claim to have read it. There used to be a second tier that + // was translated and deliberately unreachable; it made four languages undiscoverable in + // exchange for a promise the site made only to itself. + foreach (var locale in Locales.Offered.Where(l => l.Tag != Locales.SourceTag)) + { + foreach (var locked in Glossary.Locked) + { + await Assert.That(Messages.HasOwn(locale.Tag, locked.Id)) + .IsTrue() + .Because($"{locale.Tag} is offered without a translation for {locked.Id}"); + } + } + + // A locale with nothing translated is never offered, whatever else changes. + foreach (var locale in Locales.All.Where(l => l.Status is LocaleStatus.Planned)) + { + await Assert.That(locale.IsOffered) + .IsFalse() + .Because($"{locale.Tag} is planned and has no words yet"); + } + + // And a review locale is reachable by choice and never by default: it exists to be tested + // against, and a reader must not be sent to a pseudolocale by their browser's settings. + foreach (var locale in Locales.All.Where(l => l.Status is LocaleStatus.TestOnly)) + { + await Assert.That(locale.IsOffered) + .IsFalse() + .Because($"{locale.Tag} is a review locale and must not be offered"); + } + + // And no default reaches a review locale, whatever a browser asks for. + await Assert.That(LocaleRouting.Preferred("qps-ploc,ru;q=0.9")).IsNull(); + + // The alternates name only what is offered: an hreflang pointing at a pseudolocale would + // invite a search engine to index accented English as a language. + var alternates = LocaleRouting.Alternates("/games").Select(a => a.HrefLang).ToList(); + + await Assert.That(alternates).DoesNotContain("qps-ploc"); + await Assert.That(alternates).DoesNotContain("ru-x-canary"); + } + + [Test] + public async Task AReviewBuildListsTheLocalesThatAreNotLanguages() + { + // Without this the switcher has one option, draws nothing, and cannot be reviewed at all — + // which is how it shipped invisible. + var production = Locales.Switchable(preview: false); + var review = Locales.Switchable(preview: true); + + // A machine-translated locale is in both — it has real words and it says on every page that + // a machine wrote them. The pseudolocale and the canary are in neither, because they are not + // languages and nothing but a review build should list them. + await Assert.That(production.Select(l => l.Tag)).Contains("de"); + await Assert.That(production.Select(l => l.Tag)).DoesNotContain("qps-ploc"); + await Assert.That(review.Select(l => l.Tag)).Contains("qps-ploc"); + await Assert.That(review.Count).IsGreaterThan(production.Count); + + // A planned locale is in neither: nothing is translated, so listing it would offer a page + // that is still English under a name saying it is not. + await Assert.That(review.Select(l => l.Tag)).DoesNotContain("ru"); + } + + [Test] + public async Task WhetherTheReviewLocalesAreListedIsAskedOfTheRequestAndNotOfTheProcess() + { + // It was a static flag that every host start wrote, and this suite starts hosts in both + // Development and Production inside one process — so the switcher listed whatever the last + // host to start had decided, on every request served by any of them. Two requests, two + // answers, and no dependency on which host began first. + var review = Request(Environments.Development); + var production = Request(Environments.Production); + + await Assert.That(review.IsReviewBuild()).IsTrue(); + await Assert.That(production.IsReviewBuild()).IsFalse(); + + await Assert.That(Locales.Switchable(review.IsReviewBuild()).Select(l => l.Tag)).Contains("qps-ploc"); + await Assert.That(Locales.Switchable(production.IsReviewBuild()).Select(l => l.Tag)).DoesNotContain("qps-ploc"); + + // And a component rendered with no request behind it at all — which is every headless + // component test in this suite — is not a review build. That is the case that made taking + // IWebHostEnvironment as a dependency impossible, and it is why this is asked of the + // request rather than injected. + await Assert.That(((HttpContext?)null).IsReviewBuild()).IsFalse(); + } + + /// <summary>A request served by a host running in one named environment.</summary> + private static HttpContext Request(string environment) + { + var services = new ServiceCollection(); + + services.AddSingleton<IHostEnvironment>(new StubEnvironment { EnvironmentName = environment }); + + return new DefaultHttpContext { RequestServices = services.BuildServiceProvider() }; + } + + private sealed class StubEnvironment : IHostEnvironment + { + public string EnvironmentName { get; set; } = string.Empty; + + public string ApplicationName { get; set; } = "MUI.Web.Tests"; + + public string ContentRootPath { get; set; } = AppContext.BaseDirectory; + + public IFileProvider ContentRootFileProvider { get; set; } = new NullFileProvider(); + } + + [Test] + public async Task AChosenReviewLocaleIsHonouredEvenThoughItIsNeverOffered() + { + // The difference between offering a locale and honouring a choice. Nothing sends a reader to + // the pseudolocale; having picked it, they stay in it across an unprefixed URL, or the + // switcher would appear to do nothing on the next page. + await Assert.That(Locales.Find("qps-ploc")!.IsOffered).IsFalse(); + await Assert.That(Locales.Find("qps-ploc")!.IsChoosable).IsTrue(); + + // A translated locale is both: it can be chosen, and a browser asking for it is answered. + // That is the tier collapse — there is no longer a state that has the words and withholds + // them. + await Assert.That(Locales.Find("de")!.IsOffered).IsTrue(); + await Assert.That(Locales.Find("de")!.IsChoosable).IsTrue(); + + // A planned locale is neither. There is nothing to choose. + await Assert.That(Locales.Find("ru")!.IsChoosable).IsFalse(); + await Assert.That(Locales.Find("ru")!.IsOffered).IsFalse(); + } + + [Test] + public async Task EveryOfferedLocaleTranslatedTheWholeGlossary() + { + // Not the review gate — that is a person reading them. This is the weaker thing worth + // asserting: a bundle that stopped halfway would leave a page in two languages, with the + // English half being exactly the provenance words a reader most needs to trust. + foreach (var locale in Locales.All.Where(l => l.IsOffered && l.Tag != Locales.SourceTag)) + { + foreach (var locked in Glossary.Locked) + { + await Assert.That(Messages.HasOwn(locale.Tag, locked.Id)) + .IsTrue() + .Because($"{locale.Tag} has no {locked.Id}"); + } + } + } + + [Test] + public async Task TheFourKindsOfAbsenceStayFourInEveryTranslation() + { + // The finding the glossary exists for, checked against what the translators actually wrote. + // A machine translating "not measured", "uncounted", "unreachable" and "not counted" will + // reach for the same target phrase for at least two of them if nothing stops it — and a + // reader then cannot tell a game that answered from one that did not. + string[] ids = ["state.notMeasured", "state.uncounted", "state.unreachable", "state.notCounted"]; + + foreach (var locale in Locales.All.Where(l => l.IsOffered && l.Tag != Locales.SourceTag)) + { + var rendered = ids.Select(id => Messages.For(locale.Tag, id)).ToList(); + + await Assert.That(rendered.Distinct().Count()) + .IsEqualTo(ids.Length) + .Because($"{locale.Tag} collapsed two of the four kinds of absence: {string.Join(" / ", rendered)}"); + } + } +} diff --git a/tests/MUI.Web.Tests/MUI.Web.Tests.csproj b/tests/MUI.Web.Tests/MUI.Web.Tests.csproj index 0bc31d4..f9a612a 100644 --- a/tests/MUI.Web.Tests/MUI.Web.Tests.csproj +++ b/tests/MUI.Web.Tests/MUI.Web.Tests.csproj @@ -27,4 +27,25 @@ <ProjectReference Include="..\..\src\MUI.Web\MUI.Web.csproj" /> </ItemGroup> + <!-- + The English bundle as a translator edits it, copied beside the test binary. + + A test here compares Messages.resx against the compiled-in source dictionary, and it has to read + the *file* to do it: going through the resource manager would read whatever the build embedded, + which is the thing under test. It used to find the file by counting five ".." segments up from + AppContext.BaseDirectory, which is only the repository root when the output sits at exactly + bin/<config>/<tfm> — so a redirected output path, an artifacts layout, a second target framework + or a different configuration nesting each turned a message-content test into a + FileNotFoundException naming a path nobody recognised. + + MSBuild resolves this relative to the project file, which is a fixed relationship rather than a + guess about where the output landed, and the copy is the same bytes. Searching upward for the + repository root would have worked too and still assumes the output is inside the repository. + --> + <ItemGroup> + <None Include="..\..\src\MUI.Web\Resources\Messages.resx" + Link="Messages.resx" + CopyToOutputDirectory="PreserveNewest" /> + </ItemGroup> + </Project> diff --git a/tests/MUI.Web.Tests/PlainParityTests.cs b/tests/MUI.Web.Tests/PlainParityTests.cs index 488c54e..15188c9 100644 --- a/tests/MUI.Web.Tests/PlainParityTests.cs +++ b/tests/MUI.Web.Tests/PlainParityTests.cs @@ -2,6 +2,7 @@ using MUI.Web.Components; using MUI.Web.Components.Pages; using MUI.Web.Fixtures; +using MUI.Web.Localization; namespace MUI.Web.Tests; @@ -15,6 +16,65 @@ namespace MUI.Web.Tests; /// </remarks> public class PlainParityTests { + /// <summary> + /// The longest unbroken spell is first, on the page as well as in its text mirror. + /// </summary> + /// <remarks> + /// <b>The page and its own <c>?plain=1</c> alternative disagreed about a ranking.</b> The table + /// ranked by <c>Since.Ticks</c> and the place goes to the greatest value, but an earlier date is + /// a *smaller* number of ticks — so the longest spell on the site was printed as last of seven + /// under a heading that says longest, while the mirror numbered the same rows from a counter and + /// got them right. Ranking by the span the section is named for is what makes the two agree, and + /// this asserts the property rather than the arithmetic: whoever the plain renderer prints first + /// is whoever the table gives place 1. + /// </remarks> + [Test] + public async Task TheLongestSpellIsFirstOnThePageAndInTheMirror() + { + var rankings = await Queries.RankingsAsync(RankingSpan.Week); + var spells = rankings.LongestUnbroken; + + await Assert.That(spells.Count).IsGreaterThan(1); + + // The one the section is about: the longest span, not the earliest start. + var longest = spells.MaxBy(s => s.LengthAt(Now))!; + + // The plain mirror numbers the rows from a counter, in the order the query returned them, + // so its first row is the first spell. Asserted against the list rather than by searching + // the rendered text: a game's name appears in the busiest table higher up the same page, + // and an index search finds that one instead. + await Assert.That(spells[0].Slug).IsEqualTo(longest.Slug); + + // The mirror does print it first, which is the half of the parity that was already right. + var text = PlainText.RenderRankings(rankings, Now, Locales.SourceTag); + var section = text[text.LastIndexOf(spells[0].Name, StringComparison.Ordinal)..]; + + await Assert.That(section).StartsWith(spells[0].Name); + + // And a shorter spell never outranks a longer one. The page's rule, on the page's value: + // the start date, which is the measurement, rather than the duration, which is that date + // read against a clock that moves between one comparison and the next. + var places = spells.Select(s => s.Since).ToList(); + + await Assert.That(PlaceEarliest(places, longest.Since)).IsEqualTo(1); + + foreach (var spell in spells.Where(s => s.Since > longest.Since)) + { + await Assert.That(PlaceEarliest(places, spell.Since)).IsGreaterThan(1); + } + + // Ties share a place, which is the rule the column exists for: no row is numbered past the + // number of rows. + foreach (var spell in spells) + { + await Assert.That(PlaceEarliest(places, spell.Since)).IsLessThanOrEqualTo(spells.Count); + } + } + + /// <summary>The page's own rule for a place where the earliest value wins.</summary> + private static int PlaceEarliest<T>(IEnumerable<T> values, T value) where T : IComparable<T> => + 1 + values.Count(v => v.CompareTo(value) < 0); + private static readonly DateTimeOffset Now = FixtureGameQueries.Now; private static readonly FixtureGameQueries Queries = new(); @@ -53,6 +113,33 @@ public async Task TheHeatmapSurvivesAsASentenceAndALinePerDay() await Assert.That(text).Contains("Wed —"); } + /// <summary> + /// The mirror answers in the language the reader asked in, day names included. + /// </summary> + /// <remarks> + /// Over HTTP rather than through the renderer, because the thing being checked is that the + /// locale reaches this surface at all: the plain page is composed by a different code path from + /// the rendered one, and the heatmap's words were the last on the site to be answered in English + /// whatever the address said. A German reader's per-day lines start "Mo", not "Mon". + /// </remarks> + [Test] + public async Task ThePlainMirrorIsAnsweredInTheLanguageTheAddressAsksFor() + { + await using var site = await SiteHost.StartAsync(); + + var english = Render.Words(await site.Client.GetStringAsync("/g/m-u-s-h?plain=1")); + var german = Render.Words(await site.Client.GetStringAsync("/de/g/m-u-s-h?plain=1")); + + await Assert.That(english).Contains("Mon —"); + await Assert.That(german).Contains("Mo —"); + await Assert.That(german).DoesNotContain("Mon —"); + + // The same three states, and still three. The words for two of them are the glossary's, so + // in German they are German — and they are still two different words. + await Assert.That(german).Contains(Messages.For("de", "state.notMeasured")); + await Assert.That(german).Contains(Messages.For("de", "state.uncounted")); + } + [Test] public async Task TheTrendSurvivesAsASentenceALinePerWeekAndAWayToSeek() { @@ -62,10 +149,14 @@ public async Task TheTrendSurvivesAsASentenceALinePerWeekAndAWayToSeek() // change it would have the navigation and none of its function. var text = await GameAsync("m-u-s-h"); - await Assert.That(text).Contains("HOW MANY, OVER TIME"); + // The heading through the bundle rather than shouted in English. It used to be upper-cased + // here with ToUpperInvariant, which is an English typographic habit applied to a string a + // translator writes — and one that mangles ß and Turkish i on the way past. + await Assert.That(text).Contains(Messages.For(Locales.SourceTag, "trend.plain.heading")); await Assert.That(text).Contains("typically"); await Assert.That(text).Contains("peak"); - await Assert.That(text).Contains("earlier: ?from="); + await Assert.That(text) + .Contains($"{Messages.For(Locales.SourceTag, "trend.plain.earlier")}: ?from="); } [Test] @@ -83,10 +174,13 @@ public async Task TheTrendSaysWhichKindOfNothingAQuietWeekWas() // And no cause is named for either: a failed probe writes no presence row, so silence // cannot tell an outage of theirs from a gap of ours. - var trend = text[text.IndexOf("HOW MANY, OVER TIME", StringComparison.Ordinal)..]; - var reachable = trend.IndexOf("Reachable (", StringComparison.Ordinal); + var trend = text[text.IndexOf( + Messages.For(Locales.SourceTag, "trend.plain.heading"), StringComparison.Ordinal)..]; + var reachable = trend.IndexOf( + Messages.For(Locales.SourceTag, "reach.plain.heading") + " (", StringComparison.Ordinal); - await Assert.That(reachable > 0 ? trend[..reachable] : trend).DoesNotContain("unreachable"); + await Assert.That(reachable > 0 ? trend[..reachable] : trend) + .DoesNotContain(Messages.For(Locales.SourceTag, "state.unreachable")); } [Test] @@ -122,7 +216,9 @@ public async Task TheCapabilityMatrixSurvivesWithBothColumnsAndTheCount() { var text = await GameAsync("m-u-s-h"); - await Assert.That(text).Contains("Capabilities (1 of 6 disagree)"); + // One disagreement takes a singular verb here exactly as it does in the caption over the + // graphical matrix. The two surfaces are one fact and had two grammars. + await Assert.That(text).Contains("Capabilities (1 of 6 disagrees)"); await Assert.That(text).Contains("measured: NO declared: yes ** disagree"); } @@ -140,16 +236,25 @@ public async Task AScreenTooSmallToFrameSaysHowSmallItWas() { var text = await GameAsync("midnight-sun"); - await Assert.That(text).Contains("Only 2 row(s) came back"); + // Through the bundle, which is also how it stopped saying "row(s)": a parenthesised s is a + // fact about English written where a plural rule belongs, and the graphical frame and this + // surface now render the one ICU message rather than two spellings of it. + await Assert.That(text).Contains(Messages.For( + Locales.SourceTag, + "ansi.tooSmall", + new Dictionary<string, object?>(StringComparer.Ordinal) { ["count"] = 2 })); } [Test] - public async Task AnOversizedScreenSaysHowLongItIs() + public async Task ALongScreenSaysHowLongItIsAndPrintsAllOfIt() { + // No crop on either surface any more, so no note about one. The graphical page scrolls the + // whole screen in one frame rather than showing the first twenty-four rows and offering the + // rest twice more; this surface prints every row, as it always did. var text = await GameAsync("batmud"); await Assert.That(text).Contains("connect screen: 214 lines"); - await Assert.That(text).Contains("Unusually long"); + await Assert.That(text).DoesNotContain("Unusually long"); } [Test] @@ -167,7 +272,7 @@ public async Task TheThreeFeedsAreThreeNamedSectionsInWords() { // The register the cards carry is a tone, and a tone is not a fact. In text the words do // all of the work. - var text = PlainText.RenderFeeds(await Queries.FeedsAsync(), Now); + var text = PlainText.RenderFeeds(Locales.SourceTag, await Queries.FeedsAsync(), Now); await Assert.That(text).Contains("NEWLY DISCOVERED"); await Assert.That(text).Contains("WENT DARK"); @@ -175,6 +280,57 @@ public async Task TheThreeFeedsAreThreeNamedSectionsInWords() await Assert.That(text).Contains("Aardwolf MUD"); } + /// <summary> + /// The three feeds are three sections in the reader's language, not three English headings. + /// </summary> + /// <remarks> + /// <para> + /// <b>They were literals in the renderer, and a <c>tag</c> that reached only the ages.</b> + /// Passing a locale to <c>RenderFeeds</c> and asserting the result therefore proved nothing: + /// every locale printed "NEWLY DISCOVERED" and "Nothing new." and the test that passed + /// <c>Locales.SourceTag</c> was asserting English against English. + /// </para> + /// <para> + /// So this asks in two languages at once. The pseudolocale is the discriminating half — it is + /// generated from the source bundle, so a string that reaches it came through <c>Messages</c> + /// and a string that did not is still plain English on the page. German is the half that proves + /// the tag threads all the way down to a real satellite: the empty states are translated there + /// already, so a German render has to print German sentences and not the fallback. + /// </para> + /// </remarks> + [Test] + public async Task TheFeedHeadingsAndEmptyStatesComeFromTheBundleAndNotFromTheRenderer() + { + var feeds = await Queries.FeedsAsync(); + var empty = new LivenessFeeds([], [], []); + + // Through the bundle: the pseudolocale accents and brackets every source string, and only a + // string that went through Messages can come back accented. + var pseudo = PlainText.RenderFeeds("qps-ploc", empty, Now); + + await Assert.That(pseudo).DoesNotContain("NEWLY DISCOVERED"); + await Assert.That(pseudo).Contains( + Messages.For("qps-ploc", "feed.plain.newlyDiscovered").ToUpperInvariant()); + await Assert.That(pseudo).Contains(Messages.For("qps-ploc", "feed.nothingNew")); + + // And in German, where the empty states are translated: the sentences the satellite carries, + // not the English they fall back from. + var german = PlainText.RenderFeeds("de", empty, Now); + + await Assert.That(german).Contains("Nichts Neues."); + await Assert.That(german).Contains("Nichts ist verstummt."); + await Assert.That(german).Contains("Nichts ist zurückgekehrt. Wir klopfen weiter."); + await Assert.That(german).DoesNotContain("Nothing new."); + + // The headings are asked of the bundle rather than spelled here, so this keeps holding on + // the day feed.plain.* is translated and stops being the English fallback. + foreach (var id in new[] { "feed.plain.newlyDiscovered", "feed.plain.wentDark", "feed.plain.cameBack" }) + { + await Assert.That(PlainText.RenderFeeds("de", feeds, Now)) + .Contains(Messages.For("de", id).ToUpperInvariant()); + } + } + [Test] public async Task TheArchiveSaysWhenEachGameWasLastReachableAndHowLongItWasKnownLive() { @@ -185,10 +341,12 @@ public async Task TheArchiveSaysWhenEachGameWasLastReachableAndHowLongItWasKnown entries.Add(ArchiveEntry.For(game, await Queries.ForGameAsync(game.Id), Now)); } - var text = PlainText.RenderArchive(entries, null, Now); + var text = PlainText.RenderArchive(entries, null, Now, Locales.SourceTag); - await Assert.That(text).Contains("Last reachable:"); - await Assert.That(text).Contains("Known live:"); + // The labels, asked of the bundle rather than spelled again here: the mirror has to carry + // the same two facts as the page, and which words say them is the bundle's business. + await Assert.That(text).Contains(Messages.For(Locales.SourceTag, "archive.plain.lastReachable")); + await Assert.That(text).Contains(Messages.For(Locales.SourceTag, "archive.plain.knownLive")); await Assert.That(text).Contains("Gaslight Row"); } @@ -203,7 +361,7 @@ public async Task TheArchiveUsesTheWordArchivedAndNeverDead() entries.Add(ArchiveEntry.For(game, await Queries.ForGameAsync(game.Id), Now)); } - var text = PlainText.RenderArchive(entries, null, Now).ToLowerInvariant(); + var text = PlainText.RenderArchive(entries, null, Now, Locales.SourceTag).ToLowerInvariant(); await Assert.That(text).Contains("[archived]"); await Assert.That(text).DoesNotContain("dead"); @@ -218,18 +376,48 @@ public async Task NoPlainLineIsWiderThanEightyColumns() { await GameAsync("m-u-s-h"), await GameAsync("midnight-sun"), - PlainText.RenderFeeds(await Queries.FeedsAsync(), Now), + PlainText.RenderFeeds(Locales.SourceTag, await Queries.FeedsAsync(), Now), PlainText.RenderListing(await Queries.SearchAsync(new GameFilter()), new GameFilter(), Now), // The archive too, because its lines are the ones a label lengthens most: an archived // game's codebase carries the oldest age on the site. - PlainText.RenderArchive(await ArchiveAsync(), query: null, Now), + PlainText.RenderArchive(await ArchiveAsync(), query: null, Now, Locales.SourceTag), }; + // These five hold to the cap on every line, addresses included, and that is not relaxed: + // the exemption below belongs to one surface and must not spread to the others by being + // written as a blanket rule. foreach (var line in surfaces.SelectMany(s => s.Split('\n'))) { await Assert.That(line.TrimEnd().Length).IsLessThanOrEqualTo(PlainText.Columns); } + + // Find was the one surface the cap was never checked on. It is checked on the prose only, + // because its addresses genuinely cannot hold to it — a query carrying six answers is past + // eighty columns before any wrapping decision is made, and a wrapped address is not + // clickable in the browsers this surface exists for. See the note on PlainText.Columns. + // German as well as English: a translated option label is the longest thing this renderer + // writes and the one no fixed vocabulary bounds. And loaded rather than empty, so the long + // addresses are actually present and the prose is measured beside them. + const string Loaded = "?plain=1&genre=Fantasy&language=English&lineage=MUSH&archived=true"; + + string[] find = + [ + PlainText.RenderFind(await FindScreen.BuildAsync(Queries, "?plain=1")), + PlainText.RenderFind(await FindScreen.BuildAsync(Queries, "?plain=1", "de"), "de"), + PlainText.RenderFind(await FindScreen.BuildAsync(Queries, Loaded)), + PlainText.RenderFind(await FindScreen.BuildAsync(Queries, Loaded, "de"), "de"), + ]; + + foreach (var line in find.SelectMany(s => s.Split('\n'))) + { + if (line.TrimStart().StartsWith('/')) + { + continue; + } + + await Assert.That(line.TrimEnd().Length).IsLessThanOrEqualTo(PlainText.Columns); + } } [Test] @@ -282,39 +470,72 @@ await Queries.SearchAsync(new GameFilter { IncludeArchived = true }), await Assert.That(text).Contains("Players now: 9 (declared, 9m)"); // And a value nobody has confirmed in years says so in the word, not in an amber colour. - await Assert.That(text).Contains("PennMUSH 1.8.5 (declared, 3y, stale)"); + // Asserted through the bundle rather than as a literal: the label is four messages now + // — the shape, the word, the rung and its plural — and a literal here would pass while the + // German page said something else entirely. + var label = Messages.For( + Locales.SourceTag, + "chip.plain.stale", + new Dictionary<string, object?>(StringComparer.Ordinal) + { + ["how"] = Messages.For(Locales.SourceTag, "provenance.game.declared"), + ["age"] = Relative.Format(Locales.SourceTag, TimeSpan.FromDays(365 * 3)), + }); + + await Assert.That(text).Contains($"PennMUSH 1.8.5 {label}"); } [Test] public async Task TheRenderedListingRowCarriesTheSameLabelThePlainOneSpells() { - // The rendered row and the plain row have to be two renderings of one fact. The chip is the - // vocabulary the game page already uses — glyph, relative age, amber when it has aged out — - // and the row reuses it rather than inventing a second way of saying "we read this off a - // banner forty minutes ago". + // The rendered row and the plain row have to be two renderings of one fact. The fields on + // the meta line keep the chip the game page uses — glyph, relative age, amber when it has + // aged out — rather than inventing a second way of saying "nobody has confirmed this since + // 2023". var html = await Render.PageAsync<Games>([]); - await Assert.That(html).Contains("class=\"chip measured"); await Assert.That(html).Contains("class=\"chip declared"); - // Never colour or glyph alone: the word is in the accessibility tree either as the chip's - // own title or as text only a screen reader reads. - await Assert.That(Render.Words(html)).Contains("declared"); - await Assert.That(Render.Words(html)).Contains("measured"); + // The count is the exception, and finding S1 took it all the way: no glyph and no word + // beside a number on a listing row at all. Where a number came from is what a reader weighs + // when choosing between two games, not while scanning five hundred, so it lives on the game + // page and on the facet groups' own badges — which is where it tells them whether a filter + // is trustworthy *before* they apply it. Rule 1 is intact one surface along. + await Assert.That(html).DoesNotContain("class=\"declared-note\""); + await Assert.That(html).DoesNotContain("class=\"pip"); + + // And the chip that stays — the codebase — prints no age, because the row has a freshness + // column of its own and every row used to state one age twice, four characters apart. + var meta = html[html.IndexOf("class=\"meta", StringComparison.Ordinal)..]; + await Assert.That(meta[..meta.IndexOf("</p>", StringComparison.Ordinal)]) + .DoesNotContain("<time"); } [Test] - public async Task TheRowsGlyphAgreesWithTheChipBesideIt() + public async Task TheCountColumnCarriesANumberAndNothingElse() { - // The chip was added to the row and the glyph in front of it was left hard-coded measured, - // so a declared count rendered a green ● beside a ◇ chip — one number described two ways in - // the same breath, which is the disagreement the chip exists to end. The game page was fixed - // and the listing that points at it was not. + // Finding S1, and the localization win with it. The cell used to read "●545 on" — a + // provenance glyph whose legend lived elsewhere on the page, then the number, then one + // English word repeated on all 515 rows. The column is named once, above the rows, and the + // cells hold the bare figure. var html = await Render.PageAsync<Games>([]); + var counts = html.Split("class=\"row-count").Skip(1).ToList(); + + await Assert.That(counts).IsNotEmpty(); + + foreach (var cell in counts) + { + var text = Render.Words(cell[..cell.IndexOf("</p>", StringComparison.Ordinal)]); - // Razor encodes both glyphs, so the assertion reads them as the markup carries them. - await Assert.That(html).Contains("class=\"pip state-declared\" aria-hidden=\"true\">◇"); - await Assert.That(html).Contains("class=\"pip state-present\" aria-hidden=\"true\">●"); + // Either a bare number, or the words that say there is no number. Never a zero standing + // in for an unknown, and never a unit. + await Assert.That(text).DoesNotContain(" on"); + await Assert.That(text).DoesNotContain("●"); + await Assert.That(text).DoesNotContain("◇"); + } + + // The column head is where the noun went, once. + await Assert.That(Render.Words(html)).Contains("connected · reached"); } [Test] @@ -356,13 +577,25 @@ public async Task TheGamePagesLiveCountWearsTheSameChipTheListingRowDoes() var declared = await Render.PageAsync<Game>(new() { ["Slug"] = "ashen-court" }); var measured = await Render.PageAsync<Game>(new() { ["Slug"] = "m-u-s-h" }); - await Assert.That(declared).Contains("class=\"chip declared"); + // The chip became the figure's own kicker: the count over the word and the age that + // produced it, which is one fact read as one block rather than a number with a label + // trailing it at metadata size. await Assert.That(Render.Words(declared)).Contains("declared"); - await Assert.That(measured).Contains("class=\"chip measured"); - - // A count nobody could take gets no chip, because there is nothing to label. + await Assert.That(declared).Contains("figure-count mono declared"); + await Assert.That(Render.Words(measured)).Contains("measured"); + await Assert.That(measured).Contains("figure-count mono"); + await Assert.That(measured).DoesNotContain("figure-count mono declared"); + + // A count the page does not have says so in words, and never as a zero. Read off the id, + // and off the figure rather than the whole document: what the hero may not do is pick one of + // rule 2's three states when the null it was handed covers all of them, so the word here is + // the absence itself and the assertion is that it is present and legible. var none = await Render.PageAsync<Game>(new() { ["Slug"] = "midnight-sun" }); - await Assert.That(none).Contains("count unknown"); + var figure = none[none.IndexOf("class=\"game-figure\"", StringComparison.Ordinal)..]; + var words = Render.Words(figure[..figure.IndexOf("</div>", StringComparison.Ordinal)]); + + await Assert.That(words).Contains(Messages.For(Locales.SourceTag, "game.count.none")); + await Assert.That(words).DoesNotContain("0"); } [Test] @@ -372,9 +605,21 @@ public async Task TheArchiveLabelsACodebaseExactlyAsTheListingDoes() // "Codebase: PennMUSH 1.8.5" on /archive — the same value, one surface saying nobody has // confirmed it since 2023 and the other not. The archive is where a value is oldest and // where the label matters most. - var text = PlainText.RenderArchive(await ArchiveAsync(), query: null, Now); + var text = PlainText.RenderArchive(await ArchiveAsync(), query: null, now: Now, tag: Locales.SourceTag); + + // Asserted through the bundle rather than as a literal: the label is four messages now + // — the shape, the word, the rung and its plural — and a literal here would pass while the + // German page said something else entirely. + var label = Messages.For( + Locales.SourceTag, + "chip.plain.stale", + new Dictionary<string, object?>(StringComparer.Ordinal) + { + ["how"] = Messages.For(Locales.SourceTag, "provenance.game.declared"), + ["age"] = Relative.Format(Locales.SourceTag, TimeSpan.FromDays(365 * 3)), + }); - await Assert.That(text).Contains("PennMUSH 1.8.5 (declared, 3y, stale)"); + await Assert.That(text).Contains($"PennMUSH 1.8.5 {label}"); // And the rendered page wears the same chip the listing row does. var html = await Render.PageAsync<Archive>([]); @@ -385,11 +630,87 @@ public async Task TheArchiveLabelsACodebaseExactlyAsTheListingDoes() public async Task TheHomePageCountsOnlyWhatWasMeasured() { var counts = SiteCounts.From(await Queries.ListAsync(new GameFilter { IncludeArchived = true })); - var text = PlainText.RenderHome(counts, await Queries.FeedsAsync(), CrawlerPulse.Unknown, Now); + var text = PlainText.RenderHome(Locales.SourceTag, counts, await Queries.FeedsAsync(), CrawlerPulse.Unknown, Now); await Assert.That(text).Contains("games known"); - await Assert.That(text).Contains("with players on now (measured)"); - await Assert.That(text).Contains("answering, count unknown"); + await Assert.That(text).Contains("connected now (measured)"); + await Assert.That(text).Contains("answering, uncounted"); + } + + /// <summary> + /// The four front-page figures, and the crawler's own line, in the reader's language. + /// </summary> + /// <remarks> + /// <b>The count labels and the crawler strip were the last English on a localized page.</b> + /// The strip is the worst of the two: it is the provenance of the four figures above it, so a + /// reader who cannot read it is a reader with no way to discount them — and it printed + /// "crawler live · last probe" in English around an age that had been carefully localized. + /// The wordmark is exempt and stays: a site's name is machine voice, like a hostname. + /// </remarks> + [Test] + public async Task TheHomeCountsAndTheCrawlerLineComeFromTheBundle() + { + var counts = SiteCounts.From(await Queries.ListAsync(new GameFilter { IncludeArchived = true })); + var cycle = new CrawlCycleRecord( + Now.AddMinutes(-2), Now.AddMinutes(-1), 8, 8, 6, 2, 0, 0, 0, 0, 0, 6, 0, 0, 0); + var pulse = new CrawlerPulse(Now.AddMinutes(-1), Now.AddMinutes(3), 4, 710, cycle); + + var pseudo = PlainText.RenderHome("qps-ploc", counts, await Queries.FeedsAsync(), pulse, Now); + + // The wordmark is the one line that must not have gone through the bundle. + await Assert.That(pseudo).Contains("MU*INDEX"); + + // Everything else did. "crawler live" carries no plural branch, so the pseudolocale accents + // it end to end and its English spelling cannot survive a trip through the bundle. + await Assert.That(pseudo).DoesNotContain("crawler live"); + + // The counts do carry plural branches, and the pseudolocale steps over anything inside + // braces — accenting a branch keyword would make the message unparseable. So the signal + // there is the ⟦⟧ the transform wraps the whole message in, which is what asking the bundle + // for the expected string tests: a renderer that interpolated its own line would print the + // same words with no brackets round them. + await Assert.That(pseudo) + .Contains(Messages.For("qps-ploc", "home.plain.known", Count(counts.Known))); + await Assert.That(pseudo) + .Contains(Messages.For("qps-ploc", "home.plain.archived", Count(counts.Archived))); + await Assert.That(pseudo).DoesNotContain($"\n{counts.Known} games known"); + await Assert.That(pseudo) + .Contains(CrawlerCopy.Registry("qps-ploc", pulse)) + .And.DoesNotContain($"\n{pulse.TargetsKnown} addresses in the registry"); + + // And the whole surface threads one tag: the German render says what the German bundle says + // for every id, whether that is a translation or the English it still falls back to. + var german = PlainText.RenderHome("de", counts, await Queries.FeedsAsync(), pulse, Now); + + foreach (var id in new[] + { + "home.plain.known", "home.plain.connectedNow", + "home.plain.uncounted", "home.plain.archived", + }) + { + await Assert.That(german).Contains(Messages.For("de", id, Count(CountFor(id, counts)))); + } + + await Assert.That(german).Contains(CrawlerCopy.State("de", pulse, Now)); + await Assert.That(german).Contains(CrawlerCopy.LastCycle("de", pulse)!); + await Assert.That(german).Contains(CrawlerCopy.Registry("de", pulse)); + + // The feeds it appends carry German ages, which is the one part of a feed row that was + // already localized and so the one that proves the tag survived the call into RenderFeeds. + var first = (await Queries.FeedsAsync()).NewlyDiscovered[0]; + + await Assert.That(german).Contains(Relative.Ago("de", Now - first.At)); + + static Dictionary<string, object?> Count(int count) => + new(StringComparer.Ordinal) { ["count"] = count }; + + static int CountFor(string id, SiteCounts counts) => id switch + { + "home.plain.known" => counts.Known, + "home.plain.connectedNow" => counts.WithPlayersOn, + "home.plain.uncounted" => counts.CountUnknown, + _ => counts.Archived, + }; } [Test] @@ -401,7 +722,7 @@ public async Task NoSurfaceOffersAVoteStarRatingOrRecommendation() var surfaces = new[] { await GameAsync("m-u-s-h"), - PlainText.RenderHome(counts, await Queries.FeedsAsync(), CrawlerPulse.Unknown, Now), + PlainText.RenderHome(Locales.SourceTag, counts, await Queries.FeedsAsync(), CrawlerPulse.Unknown, Now), PlainText.RenderListing(await Queries.SearchAsync(new GameFilter()), new GameFilter(), Now), }; diff --git a/tests/MUI.Web.Tests/PlainSurfaceTests.cs b/tests/MUI.Web.Tests/PlainSurfaceTests.cs index 137b860..9835190 100644 --- a/tests/MUI.Web.Tests/PlainSurfaceTests.cs +++ b/tests/MUI.Web.Tests/PlainSurfaceTests.cs @@ -1,6 +1,7 @@ using MUI.Catalog; using MUI.Web.Components; using MUI.Web.Fixtures; +using MUI.Web.Localization; namespace MUI.Web.Tests; @@ -56,25 +57,28 @@ public async Task EachWayOutOfTheListingIsMarkedAsItself(LifecycleState state, s } [Test] - public async Task AnUnknownCountSaysSoInWordsRatherThanBeingBlank() + public async Task AMissingCountSaysSoInWordsRatherThanBeingBlank() { // A blank reads as zero to a human exactly as it does to a parser. Midnight Sun answers, // offers no MSSP and no pre-login WHO, so there is genuinely nothing to count. + // + // Read off the id rather than the English: what this guards is that the absence is written + // out at all, not that it is written out in any particular words. var text = await RenderAsync("midnight-sun"); - await Assert.That(text).Contains("Players now: unknown"); + await Assert.That(text).Contains(Messages.For(Locales.SourceTag, "game.plain.playersNoCount")); await Assert.That(text).DoesNotContain("Players now: 0"); } [Test] - public async Task AMeasuredZeroIsPrintedAsZeroAndNotAsUnknown() + public async Task AMeasuredZeroIsPrintedAsZeroAndNotAsAnAbsence() { // Eldertale really has nobody on. That is a measurement and must not be softened into a // shrug — the two are different facts and the plain surface has to keep them apart. var text = await RenderAsync("eldertale"); await Assert.That(text).Contains("Players now: 0"); - await Assert.That(text).DoesNotContain("unknown"); + await Assert.That(text).DoesNotContain(Messages.For(Locales.SourceTag, "game.plain.playersNoCount")); } [Test] @@ -89,18 +93,30 @@ public async Task TheGamePagesOwnCountSaysHowItWasObtainedJustAsTheListingDoes() await Assert.That(declared).Contains("Players now: 9 (declared, 9m)"); await Assert.That(measured).Contains("Players now: 15 (measured, 4m)"); - // A count nobody could take keeps its sentence and gains no label. + // A count that does not exist keeps its sentence and gains no label — a provenance chip over + // nothing would attest to a measurement nobody took. await Assert.That(await RenderAsync("midnight-sun")) - .Contains("Players now: unknown (no count could be measured)"); + .Contains(Messages.For(Locales.SourceTag, "game.plain.playersNoCount")); } [Test] public async Task ADisagreementIsFlaggedInWordsNotByColour() { var text = await RenderAsync("m-u-s-h"); + var page = await Queries.FindAsync("m-u-s-h"); + // The mark on the row, and the tally in the heading — the latter read off the id, so the + // assertion is that the count reached the heading rather than that English inflects the + // verb one particular way. await Assert.That(text).Contains("** disagree"); - await Assert.That(text).Contains("disagree)"); + await Assert.That(text).Contains(Messages.For( + Locales.SourceTag, + "game.plain.capabilities", + new Dictionary<string, object?>(StringComparer.Ordinal) + { + ["disagreeing"] = page!.DisagreementCount, + ["total"] = page.Capabilities.Count, + })); } [Test] diff --git a/tests/MUI.Web.Tests/PresenceTrendTests.cs b/tests/MUI.Web.Tests/PresenceTrendTests.cs index bf3c0ac..bde58f2 100644 --- a/tests/MUI.Web.Tests/PresenceTrendTests.cs +++ b/tests/MUI.Web.Tests/PresenceTrendTests.cs @@ -1,5 +1,6 @@ using MUI.Catalog; using MUI.Web.Components; +using MUI.Web.Localization; namespace MUI.Web.Tests; @@ -17,6 +18,9 @@ public class PresenceTrendTests { private static readonly DateOnly Start = new(2026, 5, 1); + /// <summary>The locale these assertions read in. The source bundle is what they are written against.</summary> + private const string English = Locales.SourceTag; + [Test] public async Task ADayNobodyMeasuredGetsNoInkAtAll() { @@ -54,7 +58,7 @@ public async Task ASingleMeasuredDayIsAWholeBarRatherThanASpeck() var bars = TrendGeometry.Bars(series); await Assert.That(bars).Count().IsEqualTo(1); - await Assert.That(bars[0].Day.Label).Contains("14"); + await Assert.That(bars[0].Day.Label(English)).Contains("14"); await Assert.That(TrendGeometry.Zero - bars[0].MeanTop) .IsGreaterThan(100d) .Because("the only measurement in the range is also the ceiling, so its bar is the plot"); @@ -71,10 +75,16 @@ public async Task AnUncountableDayIsNotDrawnOnTheZeroLine() Uncountable(2), Counted(3, 5), Counted(4, 4)); - var ticks = TrendGeometry.Ticks(series); + var ticks = TrendGeometry.Ticks(English, series); await Assert.That(ticks).Count().IsEqualTo(1); - await Assert.That(ticks[0].Label).Contains("no count could be read"); + // The gutter mark carries the "probed, no count could be read" sentence and never the + // "no measurement" one — the middle state of §5.4 said as itself, in whatever language the + // reader asked for. + var uncountableDay = Start.AddDays(2); + + await Assert.That(ticks[0].Label).IsEqualTo(Say("trend.day.notCounted", uncountableDay)); + await Assert.That(ticks[0].Label).IsNotEqualTo(Say("trend.day.notMeasured", uncountableDay)); await Assert.That(TrendGeometry.Bars(series)).Count().IsEqualTo(4); await Assert.That(TrendGeometry.Bars(series).Any(b => b.Day.IsUncountable)).IsFalse(); @@ -92,8 +102,8 @@ public async Task AMeasuredZeroIsAMeasurementAndKeepsItsInk() await Assert.That(TrendGeometry.Zero - zero.MeanTop) .IsGreaterThanOrEqualTo(TrendGeometry.MinimumInk); - await Assert.That(TrendGeometry.Ticks(series)).IsEmpty(); - await Assert.That(series.Days[1].Label).Contains("0 players"); + await Assert.That(TrendGeometry.Ticks(English, series)).IsEmpty(); + await Assert.That(series.Days[1].Label(English)).Contains("0 players"); } [Test] @@ -158,11 +168,11 @@ public async Task TheCalendarIsLabelledWhereAMonthStartsAndIsNeverCrowded() // an axis, so they thin instead of overprinting. var quarter = TrendSeries.Over(new DateOnly(2026, 5, 19), new DateOnly(2026, 8, 16), []); - await Assert.That(TrendGeometry.Months(quarter).Select(m => m.Label)) + await Assert.That(TrendGeometry.Months(English, quarter).Select(m => m.Label)) .IsEquivalentTo(new[] { "Jun", "Jul", "Aug" }); var years = TrendSeries.Over(new DateOnly(2021, 1, 1), new DateOnly(2025, 12, 31), []); - var months = TrendGeometry.Months(years); + var months = TrendGeometry.Months(English, years); await Assert.That(months.Count).IsLessThanOrEqualTo(9); await Assert.That(months.Zip(months.Skip(1)).All(p => p.Second.X > p.First.X)).IsTrue(); @@ -197,12 +207,12 @@ public async Task APlayerCountIsNeverReportedWithADecimal() // rather than nearest, so the figure is one we are sure of. var series = Series(Counted(0, 601, 731, 666.1m), Counted(1, 590, 640, 620.4m)); - await Assert.That(series.Sentence).Contains("Typically 666 on"); - await Assert.That(series.Sentence).DoesNotContain("666.1"); - await Assert.That(series.Days[0].Label).Contains("666 on average"); - await Assert.That(series.Days[0].Label).DoesNotContain("666.1"); - await Assert.That(series.PerWeek().Single()).Contains("typically 666"); - await Assert.That(series.PerWeek().Single()).DoesNotContain("666.1"); + await Assert.That(series.Sentence(English)).Contains("Typically 666 on"); + await Assert.That(series.Sentence(English)).DoesNotContain("666.1"); + await Assert.That(series.Days[0].Label(English)).Contains("666 on average"); + await Assert.That(series.Days[0].Label(English)).DoesNotContain("666.1"); + await Assert.That(series.PerWeek(English).Single()).Contains("typically 666"); + await Assert.That(series.PerWeek(English).Single()).DoesNotContain("666.1"); // The wording is floored; the geometry is not, or the bar would be shortened by a sentence. await Assert.That(series.Days[0].Average).IsEqualTo(666.1d); @@ -218,14 +228,20 @@ public async Task TheSentenceNamesTheThreeStatesApart() var probed = Series(Uncountable(0), Uncountable(1)); var measured = Series(Counted(0, 6), Counted(1, 6), Counted(2, 8)); - await Assert.That(nothing.Sentence).IsEqualTo("No measurement in this range."); - await Assert.That(probed.Sentence).Contains("no player count could be read"); - await Assert.That(measured.Sentence).Contains("Typically 6"); - await Assert.That(measured.Sentence).Contains("peaking at 8"); + // The fact, through the bundle: a range with nothing in it says exactly the "no measurement" + // message and never the "probed and uncountable" one. Written this way the assertion still + // holds after a translation, which is the point — the two must stay two in every locale. + await Assert.That(nothing.Sentence(English)) + .IsEqualTo(Messages.For(English, "trend.none.notMeasured")); + await Assert.That(nothing.Sentence(English)) + .IsNotEqualTo(Messages.For(English, "trend.none.probed")); + await Assert.That(probed.Sentence(English)).Contains("no player count could be read"); + await Assert.That(measured.Sentence(English)).Contains("Typically 6"); + await Assert.That(measured.Sentence(English)).Contains("peaking at 8"); // And none of them names a cause: a failed probe writes no presence row, so silence here // cannot tell an outage of theirs from a gap of ours. - foreach (var sentence in new[] { nothing.Sentence, probed.Sentence }) + foreach (var sentence in new[] { nothing.Sentence(English), probed.Sentence(English) }) { await Assert.That(sentence).DoesNotContain("unreachable"); await Assert.That(sentence).DoesNotContain("down"); @@ -241,14 +257,18 @@ public async Task ADirectionIsOnlyClaimedWhenBothEndsWereMeasured() Counted(0, 20), Counted(1, 20), Counted(2, 20), Gap(3), Gap(4), Gap(5), Gap(6), Gap(7)); - await Assert.That(lopsided.Sentence).DoesNotContain("Down"); - await Assert.That(lopsided.Sentence).DoesNotContain("Up about"); + await Assert.That(lopsided.Sentence(English)).DoesNotContain("Down"); + await Assert.That(lopsided.Sentence(English)).DoesNotContain("Up about"); var falling = Series( Counted(0, 30), Counted(1, 30), Counted(2, 28), Counted(3, 20), Counted(4, 12), Counted(5, 10)); - await Assert.That(falling.Sentence).Contains("Down about"); + // And the change is a percentage a person reads, not the fraction behind it: the sign and + // its spacing come off the locale's number format rather than being a literal in a template. + await Assert.That(falling.Sentence(English)).Contains("Down about"); + await Assert.That(falling.Sentence(English)).Contains("63%"); + await Assert.That(falling.Sentence(English)).DoesNotContain("0.63"); } [Test] @@ -265,12 +285,25 @@ public async Task PerWeekSaysWhichOfTheThreeStatesAWeekWas() }) .ToArray()); - var lines = series.PerWeek().ToList(); + var lines = series.PerWeek(English).ToList(); await Assert.That(lines).Count().IsEqualTo(3); await Assert.That(lines[0]).Contains("typically 5"); await Assert.That(lines[0]).Contains("7 days counted"); - await Assert.That(lines[1]).IsEqualTo($"{Start.AddDays(7):d MMM}–{Start.AddDays(13):d MMM}: not measured"); + await Assert.That(lines[1]).IsEqualTo(Messages.For( + English, + "trend.week.notMeasured", + new Dictionary<string, object?>(StringComparer.Ordinal) + { + ["span"] = Messages.For( + English, + "trend.week.span", + new Dictionary<string, object?>(StringComparer.Ordinal) + { + ["from"] = Start.AddDays(7), + ["to"] = Start.AddDays(13), + }), + })); await Assert.That(lines[2]).Contains("probed, no count could be read"); } @@ -285,13 +318,86 @@ public async Task AWeekWithAllThreeStatesInItKeepsThemApart() Uncountable(4), Uncountable(5), Gap(6)); - var line = series.PerWeek().Single(); + var line = series.PerWeek(English).Single(); await Assert.That(line).Contains("4 days counted"); await Assert.That(line).Contains("2 days probed without a count"); await Assert.That(line).Contains("1 day not measured"); } + /// <summary> + /// A German request gets German month names, from CLDR rather than from an array in a component. + /// </summary> + /// <remarks> + /// This is the whole reason the date became a <c>{d, date}</c> argument instead of a + /// <c>ToString("d MMM yyyy")</c> at the call site. The old spelling read the month name off + /// whatever culture the thread happened to carry — the request's in one place and the invariant + /// one in the headless renderer — so a German page said "21 May 2026" in the middle of a German + /// sentence, and no translator could have fixed it because the word was not in a file they are + /// ever sent. + /// </remarks> + [Test] + public async Task ADateIsNamedInTheLanguageThePageWasAskedFor() + { + var day = Counted(20, 12); // 21 May 2026 + var may = new System.Globalization.CultureInfo("de") + .DateTimeFormat.AbbreviatedMonthNames[4]; + + await Assert.That(day.Label("de")).Contains(may); + await Assert.That(day.Label(English)) + .Contains(System.Globalization.CultureInfo + .GetCultureInfo("en").DateTimeFormat.AbbreviatedMonthNames[4]); + + // And the axis label under the chart, which is the same data through a different message. + var year = TrendSeries.Over(new DateOnly(2026, 4, 20), new DateOnly(2026, 6, 10), []); + + await Assert.That(TrendGeometry.Months("de", year).Select(m => m.Label)) + .Contains(may); + } + + /// <summary> + /// The two absences stay two, in every locale this site offers. + /// </summary> + /// <remarks> + /// A day probed all through that produced no count is a measurement of a game that was + /// answering; a day with no measurement is a statement about our crawl. Collapsing them is the + /// worst bug §5.4 can carry, and it is a collapse a translator makes silently — both English + /// sentences begin with a date and end in a negative — so it is asserted per locale rather than + /// once against the source bundle. Neither may reach for a cause: a failed probe writes no + /// presence row at all, so an empty day cannot tell an outage of theirs from a gap of ours. + /// </remarks> + [Test] + public async Task NoMeasurementAndNoReadableCountStayTwoDifferentStringsInEveryLocale() + { + var gap = Gap(0); + var uncountable = Uncountable(1); + + foreach (var locale in Locales.All) + { + await Assert.That(gap.Label(locale.Tag)) + .IsNotEqualTo(uncountable.Label(locale.Tag)) + .Because($"{locale.Tag} renders both absences as one sentence"); + + await Assert.That(Messages.Pattern(locale.Tag, "trend.day.notMeasured")) + .IsNotEqualTo(Messages.Pattern(locale.Tag, "trend.day.notCounted")) + .Because($"{locale.Tag} translated the two absences to one pattern"); + + // And neither names a cause, in any of them. "unreachable" is a locked id with its own + // translation in every bundle, and a day with no presence row is not one. + foreach (var absence in new[] { gap.Label(locale.Tag), uncountable.Label(locale.Tag) }) + { + await Assert.That(absence) + .DoesNotContain(Messages.For(locale.Tag, "state.unreachable")); + } + } + } + + private static string Say(string id, DateOnly date) => + Messages.For( + English, + id, + new Dictionary<string, object?>(StringComparer.Ordinal) { ["d"] = date }); + private static TrendSeries Series(params TrendDay[] days) => new(days[0].Date, days[^1].Date, days); diff --git a/tests/MUI.Web.Tests/ReachSeriesTests.cs b/tests/MUI.Web.Tests/ReachSeriesTests.cs index 4f8bcee..f790f82 100644 --- a/tests/MUI.Web.Tests/ReachSeriesTests.cs +++ b/tests/MUI.Web.Tests/ReachSeriesTests.cs @@ -1,5 +1,6 @@ using MUI.Catalog; using MUI.Web.Components; +using MUI.Web.Localization; namespace MUI.Web.Tests; @@ -11,6 +12,9 @@ public class ReachSeriesTests { private static readonly DateTimeOffset Now = new(2026, 7, 30, 20, 0, 0, TimeSpan.Zero); + /// <summary>The locale these assertions read in — the source bundle they are written against.</summary> + private const string English = Locales.SourceTag; + private static AvailabilityInterval Span(double from, double? to, AvailabilityState state, FailureCause cause) => new() { @@ -39,7 +43,7 @@ public async Task ADayWeWereNotWatchingIsItsOwnStateAndNotAnOutage() await Assert.That(summary.Days.Count(d => d.State is ReachState.Unmeasured)).IsGreaterThan(70); await Assert.That(summary.Days.Any(d => d.State is ReachState.Unreachable)).IsFalse(); - await Assert.That(summary.Sentence).Contains("predate anything we measured"); + await Assert.That(summary.Sentence(English)).Contains("predate anything we measured"); } [Test] @@ -55,8 +59,8 @@ public async Task DegradedIsItsOwnStateBetweenReachableAndUnreachable() ], Now); await Assert.That(summary.Days.Any(d => d.State is ReachState.Degraded)).IsTrue(); - await Assert.That(summary.Sentence).Contains("degraded"); - await Assert.That(summary.Sentence).Contains("could not finish"); + await Assert.That(summary.Sentence(English)).Contains("degraded"); + await Assert.That(summary.Sentence(English)).Contains("could not finish"); } [Test] @@ -89,7 +93,12 @@ public async Task TheLongestOutageCarriesItsOwnCauseAndNotTheMostRecentOne() await Assert.That(summary.LongestOutageCause).IsEqualTo(FailureCause.Refused); await Assert.That(summary.LastCause).IsEqualTo(FailureCause.Timeout); - await Assert.That(summary.Sentence).Contains("connection refused"); + // The cause named through the bundle rather than spelled here, so the assertion is about + // which FailureCause reached the sentence and survives its being translated. + await Assert.That(summary.Sentence(English)) + .Contains(Wording.Cause(English, FailureCause.Refused)); + await Assert.That(summary.Sentence(English)) + .DoesNotContain(Wording.Cause(English, FailureCause.Timeout)); } [Test] @@ -104,9 +113,11 @@ public async Task EverySpellThatWasNotReachableIsAvailableAsWords() Span(37, null, AvailabilityState.Reachable, FailureCause.None), ], Now); - await Assert.That(summary.Spells.Count()).IsEqualTo(1); - await Assert.That(summary.Spells[0]).Contains("unreachable"); - await Assert.That(summary.Spells[0]).Contains("dns did not resolve"); + await Assert.That(summary.Spells(English).Count).IsEqualTo(1); + await Assert.That(summary.Spells(English)[0]) + .Contains(Messages.For(English, "reach.word.unreachable")); + await Assert.That(summary.Spells(English)[0]) + .Contains(Wording.Cause(English, FailureCause.Dns)); } [Test] diff --git a/tests/MUI.Web.Tests/ReferenceContentTests.cs b/tests/MUI.Web.Tests/ReferenceContentTests.cs index 88f3c44..ae8bd75 100644 --- a/tests/MUI.Web.Tests/ReferenceContentTests.cs +++ b/tests/MUI.Web.Tests/ReferenceContentTests.cs @@ -1,5 +1,6 @@ using MUI.Catalog; using MUI.Web.Components; +using MUI.Web.Localization; using MUI.Web.Reference; namespace MUI.Web.Tests; @@ -194,16 +195,27 @@ public async Task ABodyHeadingNeverCompetesWithThePageTitle() /// The plain rendering of every reference page, which is the test of whether the section is /// communicating anything at all. /// </summary> +/// <remarks> +/// Rendered in the source locale here and asserted through <see cref="Messages"/> rather than +/// against English literals: what these guard is that the state survives as a word at all, and a +/// test spelling the word itself would have to be edited every time a translator is allowed to +/// choose a better one. <see cref="ReferenceLocalizationTests"/> is where the language is the +/// subject. +/// </remarks> public class ReferencePlainTests { private static readonly ReferenceLibrary Library = ReferenceLibrary.Shipped; + private const string Tag = Locales.SourceTag; + + private static string Word(CapabilityState state) => ClientCapabilities.Word(Tag, state); + [Test] public async Task EveryReferencePageHasAPlainRendering() { foreach (var document in Library.Documents) { - var text = ReferencePlainText.Render(document, related: Library.Related(document)); + var text = ReferencePlainText.Render(Tag, document, related: Library.Related(document)); await Assert.That(text).Contains(document.Title.ToUpperInvariant()); await Assert.That(text.Length).IsGreaterThan(document.Summary.Length); @@ -214,11 +226,14 @@ public async Task EveryReferencePageHasAPlainRendering() public async Task AClientMatrixSurvivesInWordsWithUnknownSpelledOut() { var mudlet = Library.Find(ReferenceKind.Client, "mudlet")!; - var text = ReferencePlainText.Render(mudlet); + var text = ReferencePlainText.Render(Tag, mudlet); - await Assert.That(text).Contains("screen reader yes"); - await Assert.That(text).Contains("MCCP unknown"); - await Assert.That(text).Contains("It never means no."); + await Assert.That(text).Contains($"screen reader {Word(CapabilityState.Present)}"); + await Assert.That(text).Contains($"MCCP {Word(CapabilityState.Unknown)}"); + + // The caveat quotes the same word the cells use, and says what it does not mean. + await Assert.That(Render.Words(text)) + .Contains(Render.Words(ReferencePlainText.ClientMatrixCaveat(Tag))); } [Test] @@ -228,11 +243,11 @@ public async Task ThePlainClientMatrixNeverLeavesAnUnknownCellBlank() // reason this surface exists. foreach (var document in Library.OfKind(ReferenceKind.Client)) { - var text = ReferencePlainText.Render(document); + var text = ReferencePlainText.Render(Tag, document); foreach (var claim in ClientCapabilities.For(document).Where(c => c.State is CapabilityState.Unknown)) { - await Assert.That(text).Contains($"{claim.Name,-16} unknown"); + await Assert.That(text).Contains($"{claim.Name,-16} {Word(CapabilityState.Unknown)}"); } } } @@ -241,23 +256,32 @@ public async Task ThePlainClientMatrixNeverLeavesAnUnknownCellBlank() public async Task ThePlainProtocolPageSaysWhatTheRemainderIsNot() { var gmcp = Library.Find(ReferenceKind.Protocol, "gmcp")!; - var text = ReferencePlainText.Render(gmcp, protocol: new ProtocolFigures(3, 10, [])); - - await Assert.That(text).Contains("3 of 10 listed games were observed offering it"); - await Assert.That(Render.Words(text)).Contains("not games without the protocol"); + var text = ReferencePlainText.Render(Tag, gmcp, protocol: new ProtocolFigures(3, 10, [])); + + await Assert.That(Render.Words(text)).Contains(Render.Words(Messages.Say( + Tag, + "reference.plain.protocol.share", + ("offering", 3), + ("listed", 10), + ("percent", Wording.Percent(0.3))))); + + // Rule 5: the games not counted are not games without the protocol. + await Assert.That(Render.Words(text)) + .Contains(Render.Words(ReferencePlainText.ProtocolRemainderCaveat(Tag))); } [Test] public async Task ThePlainIndexListsEverySectionItHas() { - var text = ReferencePlainText.RenderIndex(Library); + var text = ReferencePlainText.RenderIndex(Tag, Library); - foreach (var heading in new[] { "START HERE", "CODEBASES", "CLIENTS", "PROTOCOLS" }) + foreach (var kind in Enum.GetValues<ReferenceKind>()) { - await Assert.That(text).Contains(heading); + await Assert.That(text).Contains(ReferencePlainText.Heading(Tag, kind).ToUpperInvariant()); } - await Assert.That(Render.Words(text)).Contains("This is not a wiki"); + await Assert.That(Render.Words(text)) + .Contains(Render.Words(Messages.For(Tag, "reference.plain.lede"))); } [Test] @@ -268,7 +292,7 @@ public async Task NoPlainReferenceLineIsWiderThanEightyColumnsUnlessItIsOneUnbre // has to fit. foreach (var document in Library.Documents) { - var text = ReferencePlainText.Render(document, related: Library.Related(document)); + var text = ReferencePlainText.Render(Tag, document, related: Library.Related(document)); foreach (var line in text.Split('\n').Select(l => l.TrimEnd())) { diff --git a/tests/MUI.Web.Tests/ReferenceFiguresTests.cs b/tests/MUI.Web.Tests/ReferenceFiguresTests.cs index ce2f0cf..1e1f7a2 100644 --- a/tests/MUI.Web.Tests/ReferenceFiguresTests.cs +++ b/tests/MUI.Web.Tests/ReferenceFiguresTests.cs @@ -68,10 +68,12 @@ public async Task AFamilyWithNothingIdentifiedIsNotAZeroLeftToSpeakForItself() await Assert.That(figures.Known).IsEqualTo(0); var page = Library.Find(ReferenceKind.Codebase, "pennmush")!; - var text = MUI.Web.Components.ReferencePlainText.Render(page, codebase: figures); + var text = MUI.Web.Components.ReferencePlainText.Render( + MUI.Web.Localization.Locales.SourceTag, page, codebase: figures); - await Assert.That(Render.Words(text)).Contains("None yet"); - await Assert.That(Render.Words(text)).Contains("not about what exists"); + await Assert.That(Render.Words(text)).Contains(Render.Words( + MUI.Web.Localization.Messages.For( + MUI.Web.Localization.Locales.SourceTag, "reference.plain.codebase.none"))); } [Test] diff --git a/tests/MUI.Web.Tests/ReferenceLocalizationTests.cs b/tests/MUI.Web.Tests/ReferenceLocalizationTests.cs new file mode 100644 index 0000000..cfa6b79 --- /dev/null +++ b/tests/MUI.Web.Tests/ReferenceLocalizationTests.cs @@ -0,0 +1,357 @@ +using MUI.Catalog; +using MUI.Web.Components; +using MUI.Web.Localization; +using MUI.Web.Reference; + +namespace MUI.Web.Tests; + +/// <summary> +/// The reference section's chrome, answered in the language the reader asked for. +/// </summary> +/// <remarks> +/// <para> +/// <b>The chrome and the articles are localized by two different routes, and this is about the +/// first.</b> An article is a document, translated as a document by the content layer; the furniture +/// round it is strings in a bundle. So the boundary is the subject in both directions: every word +/// the site writes has to come from the bundle, and no word an article owns — nor any machine voice +/// inside one — may pass through it. +/// </para> +/// <para> +/// The pseudo-locale is what proves the first half. A string rendered through the bundle comes back +/// wrapped in <c>⟦ ⟧</c> and with its vowels accented, so a heading that is still bare came from a +/// template rather than from a message — which is a claim no German render can make today, because +/// a locale that has not translated an id yet falls back to the English and is byte-identical to a +/// hard-coded one. +/// </para> +/// </remarks> +public class ReferenceLocalizationTests +{ + private const string Pseudo = "qps-ploc"; + + private static readonly ReferenceLibrary Library = ReferenceLibrary.Shipped; + + /// <summary>Every id the section's chrome says, whichever surface says it.</summary> + private static IReadOnlyList<string> ChromeIds => + [.. Messages.Ids.Where(id => id.StartsWith("reference.", StringComparison.Ordinal))]; + + [Test] + public async Task AGermanRequestIsAnsweredWithGermanChrome() + { + // "Textfassung" is the German for the plain-text link, and it is on the reference pages + // because they ask the bundle for it now. Before this change both pages spelled the link + // "plain text" in every language on the site. + await using var site = await SiteHost.StartAsync(); + + foreach (var path in new[] { "/de/reference", "/de/reference/protocols/mssp" }) + { + var markup = await site.Client.GetStringAsync(path); + + await Assert.That(markup).Contains(Messages.For("de", "a11y.plainText")); + await Assert.That(Render.Words(markup)) + .DoesNotContain("plain text") + .Because($"{path} still writes an English link into a German page"); + } + } + + [Test] + public async Task EveryWordTheSectionWritesComesFromTheBundle() + { + // The pseudo-locale's brackets are the proof. Each of these is a different kind of chrome — + // the heading, the lede, a section label, a measured panel's heading, a table's column, the + // plain-text link — and a bare one is a string that never met a translator. + await using var site = await SiteHost.StartAsync(); + + var index = await site.Client.GetStringAsync($"/{Pseudo}/reference"); + + foreach (var id in new[] + { + "reference.title", "reference.plain.lede", "reference.section.codebase", + "reference.section.protocol", + }) + { + var expected = id == "reference.plain.lede" + ? Messages.For(Pseudo, "reference.lede.number") + : Messages.For(Pseudo, id); + + await Assert.That(Render.Words(index)) + .Contains(Render.Words(expected)) + .Because($"{id} did not reach the page through the bundle"); + } + + var entry = await site.Client.GetStringAsync($"/{Pseudo}/reference/protocols/mssp"); + + foreach (var id in new[] + { + "reference.kind.protocol", "reference.protocol.heading", "reference.protocol.remainder", + "reference.seeAlso", + }) + { + await Assert.That(Render.Words(entry)) + .Contains(Render.Words(Messages.For(Pseudo, id))) + .Because($"{id} did not reach the page through the bundle"); + } + } + + [Test] + public async Task AnArticlesOwnTextNeverPassesThroughTheBundle() + { + // The boundary, from the other side, and asked of the one locale that can answer it. The + // pseudo-locale accents and brackets everything the message pipeline touches, so an article + // body coming back plain is the evidence that it is a document rather than a string. What + // language that document is in is the content layer's business and not asserted here. + await using var site = await SiteHost.StartAsync(); + + var words = Render.Words( + await site.Client.GetStringAsync($"/{Pseudo}/reference/protocols/mssp")); + + await Assert.That(words).Contains("MSSP is telnet option 70"); + } + + [Test] + public async Task AProtocolAcronymIsNeverATranslatableString() + { + // A locale that translated TTYPE would be destroying evidence rather than localizing a + // string, so no acronym is in the bundle to be translated: they reach a message as an + // argument or sit in the markup. Checked against the source text of every id this section + // owns, in every bundle a reader can be answered from. + string[] machineVoice = + [ + "MSSP", "GMCP", "MSDP", "ATCP", "MCCP", "MXP", "MSP", "TTYPE", "CHARSET", "EOR", + "PennMUSH", "Evennia", "TinyMUX", "Mudlet", "telnet", + ]; + + foreach (var id in ChromeIds) + { + foreach (var locale in Locales.All.Where(l => l.IsChoosable)) + { + var pattern = Messages.Pattern(locale.Tag, id)!; + + foreach (var token in machineVoice) + { + await Assert.That(pattern.Contains(token, StringComparison.OrdinalIgnoreCase)) + .IsFalse() + .Because($"{locale.Tag}/{id} carries {token}, which is machine voice"); + } + } + } + } + + [Test] + public async Task AnAcronymOnTheRenderedPageIsUntouchedByTheLocale() + { + // And the same claim about the frame rather than about the bundle. The pseudo-locale accents + // every vowel it is given, so TTYPE coming back as TTYPE is the evidence that no locale is + // between the catalogue and the page. MSSP has no vowel to accent and would prove nothing. + await using var site = await SiteHost.StartAsync(); + + var markup = await site.Client.GetStringAsync($"/{Pseudo}/reference/protocols/ttype"); + + await Assert.That(markup).Contains("TTYPE"); + await Assert.That(markup).DoesNotContain("TTYPÉ"); + } + + [Test] + public async Task ThePlainMirrorIsWrittenInThePagesLanguage() + { + // Same rule as the rest of the plain surface: it says what the page says, in the language + // the page was asked for. Its own wording, because it has no panel round the sentences — + // but its own wording out of the same bundle. + var plain = ReferencePlainText.RenderIndex(Pseudo, Library); + + await Assert.That(Render.Words(plain)) + .Contains(Render.Words(Messages.For(Pseudo, "reference.plain.lede"))); + + foreach (var kind in Enum.GetValues<ReferenceKind>()) + { + await Assert.That(plain).Contains(ReferencePlainText.Heading(Pseudo, kind).ToUpperInvariant()); + } + } + + [Test] + public async Task TheThreeCapabilityWordsStayThreeWordsInEveryLocale() + { + // The finding the whole localization file exists for, in this table's own vocabulary. An + // unknown is what we looked for and did not establish; a locale that let it collapse into + // the no beside it would publish our own failure to find a page as the client lacking the + // feature. + foreach (var locale in Locales.All.Where(l => l.IsChoosable)) + { + var words = new[] + { + CapabilityState.Present, CapabilityState.Absent, CapabilityState.Unknown, + }.Select(s => ClientCapabilities.Word(locale.Tag, s)).ToList(); + + await Assert.That(words.Distinct().Count()) + .IsEqualTo(3) + .Because($"{locale.Tag} says the same word for two different states"); + } + } + + [Test] + public async Task TheCaveatQuotesTheWordTheCellsUse() + { + // One sentence explaining one word, and they cannot drift apart: the word is an argument to + // the sentence rather than written into it a second time. + foreach (var locale in Locales.All.Where(l => l.IsChoosable)) + { + await Assert.That(ReferencePlainText.ClientMatrixCaveat(locale.Tag)) + .Contains(ClientCapabilities.Word(locale.Tag, CapabilityState.Unknown)); + } + } + + /// <summary> + /// A translated article is the same article: same slug, same kind, same related pages. + /// </summary> + /// <remarks> + /// <para> + /// <b>Enforced by the loader and asserted here anyway.</b> <c>ReferenceLibrary.For</c> hands out + /// the English record with only the prose replaced, so a translator cannot move a slug even by + /// writing a different one — but the file on disk is what a person edits next, and a front + /// matter that disagrees with the English is a trap set for whoever reads it later. This walks + /// the files rather than the loaded documents, which is the only place the difference shows. + /// </para> + /// <para> + /// The structural keys are the routing and the see-also graph: <c>kind</c> and <c>slug</c> make + /// the URL, <c>see-also</c> makes the related-pages links, and <c>codebase</c>, <c>protocol</c>, + /// <c>home</c>, <c>platform</c> and <c>capability</c> are read as machine voice. Only + /// <c>title</c> and <c>summary</c> are prose. + /// </para> + /// </remarks> + [Test] + public async Task ATranslatedArticleKeepsTheEnglishStructure() + { + var root = ArticleRoot(); + var english = root.GetFiles("*.md").ToDictionary(f => f.Name, StringComparer.Ordinal); + + await Assert.That(english).IsNotEmpty().Because("the English articles are the source"); + + var checkedFiles = 0; + + foreach (var directory in root.GetDirectories()) + { + foreach (var translated in directory.GetFiles("*.md")) + { + await Assert.That(english.ContainsKey(translated.Name)) + .IsTrue() + .Because($"{directory.Name}/{translated.Name} translates an article that does not exist"); + + var source = Structure(File.ReadAllText(english[translated.Name].FullName)); + var target = Structure(File.ReadAllText(translated.FullName)); + + await Assert.That(target) + .IsEquivalentTo(source) + .Because($"{directory.Name}/{translated.Name} changed a structural front-matter key"); + + checkedFiles++; + } + } + + await Assert.That(checkedFiles) + .IsGreaterThan(0) + .Because("a sweep over no translations proves nothing about translations"); + } + + /// <summary>Every front-matter line that is not prose, in the order the file gives them.</summary> + private static List<string> Structure(string document) + { + var parts = document.Split("---", 3); + var front = parts.Length > 1 ? parts[1] : string.Empty; + + return + [ + .. front.Split('\n') + .Select(l => l.TrimEnd('\r')) + .Where(l => l.Length > 0 && !l.StartsWith("title:", StringComparison.Ordinal) + && !l.StartsWith("summary:", StringComparison.Ordinal)), + ]; + } + + /// <summary> + /// The articles on disk, which is where a front matter can disagree with the English. + /// </summary> + /// <remarks> + /// Walked up from the test binary to the repository root rather than assumed at a fixed depth: + /// the output layout moves with the configuration, the framework and any <c>--output</c>, and a + /// content test that fails as a missing directory says nothing about content. + /// </remarks> + private static DirectoryInfo ArticleRoot() + { + var directory = new DirectoryInfo(AppContext.BaseDirectory); + + while (directory is not null) + { + var articles = new DirectoryInfo(Path.Combine(directory.FullName, "content", "reference")); + + if (articles.Exists) + { + return articles; + } + + directory = directory.Parent; + } + + throw new InvalidOperationException("content/reference was not found above the test binary."); + } + + /// <summary> + /// Every offered locale gets its own articles, including the one whose tag carries a dash. + /// </summary> + /// <remarks> + /// <b>Chinese was the locale that silently did not work.</b> MSBuild builds a manifest resource + /// name out of the file's path and replaces what cannot appear in an identifier, so + /// <c>content/reference/zh-Hans/</c> is embedded as <c>…reference.zh_Hans.…</c> and a lookup + /// spelled with the dash matched nothing. German, Dutch and Japanese all worked, which is + /// exactly the evidence that hides it — so this names <c>zh-Hans</c> rather than iterating and + /// hoping the interesting case is in the list. + /// </remarks> + [Test] + [Arguments("de")] + [Arguments("nl")] + [Arguments("ja")] + [Arguments("zh-Hans")] + public async Task ALocaleWithArticlesServesItsOwnProse(string tag) + { + var english = ReferenceLibrary.Shipped.Find("/reference/protocols/mssp"); + var translated = ReferenceLibrary.For(tag).Find("/reference/protocols/mssp"); + + await Assert.That(english).IsNotNull(); + await Assert.That(translated).IsNotNull(); + + await Assert.That(translated!.Body) + .IsNotEqualTo(english!.Body) + .Because($"{tag} has a translation of this article and should be reading it"); + + // The prose changed and nothing else did: a translation supplies words, not structure. + await Assert.That(translated.Slug).IsEqualTo(english.Slug); + await Assert.That(translated.Kind).IsEqualTo(english.Kind); + await Assert.That(translated.SeeAlso).IsEquivalentTo(english.SeeAlso); + await Assert.That(translated.Home).IsEqualTo(english.Home); + } + + /// <summary>And every article is translated in every offered locale, not merely most of them.</summary> + /// <remarks> + /// The loader falls back per article so a gap is invisible on the page, which is right for a + /// reader and wrong for us: without this, one file failing to be written would look exactly like + /// a file that was never meant to exist. + /// </remarks> + [Test] + [Arguments("de")] + [Arguments("nl")] + [Arguments("ja")] + [Arguments("zh-Hans")] + public async Task NoArticleQuietlyFallsBackToEnglish(string tag) + { + var english = ReferenceLibrary.Shipped; + var localized = ReferenceLibrary.For(tag); + + foreach (var article in english.Documents) + { + var translated = localized.Find(article.Path); + + await Assert.That(translated).IsNotNull(); + await Assert.That(translated!.Body) + .IsNotEqualTo(article.Body) + .Because($"{tag}{article.Path} is being served in English"); + } + } +} diff --git a/tests/MUI.Web.Tests/Render.cs b/tests/MUI.Web.Tests/Render.cs index d165cab..0c8a121 100644 --- a/tests/MUI.Web.Tests/Render.cs +++ b/tests/MUI.Web.Tests/Render.cs @@ -1,3 +1,5 @@ +using System.Text.RegularExpressions; + using MUI.Catalog; using MUI.Catalog.Persistence; using MUI.Web.Data; @@ -192,4 +194,24 @@ public static async Task<string> ComponentAsync<TComponent>( public static string Words(string markupOrText) => string.Join(' ', System.Net.WebUtility.HtmlDecode(markupOrText) .Split((char[]?)null, StringSplitOptions.RemoveEmptyEntries)); + + /// <summary> + /// What a reader actually sees: the elements removed, then decoded and collapsed. + /// </summary> + /// <remarks> + /// <para> + /// <see cref="Words"/> keeps the tags, which is right for most assertions here and wrong for one + /// kind: a sentence that places its own link or code span is broken up by elements, so asserting + /// it against <c>Words</c> asserts the markup as well as the sentence. It is also why a + /// class name — <c><details class="history"></c> — reads as the word "history" and can + /// satisfy a check that was about the copy. + /// </para> + /// <para> + /// Tags are stripped <em>before</em> decoding, on purpose. The owner dashboard prints a badge + /// snippet as escaped markup for an operator to copy; decoding first would turn it into + /// something this regex then ate, and the snippet is text a reader is meant to see. + /// </para> + /// </remarks> + public static string Text(string markup) => + Words(Regex.Replace(markup, "<[^>]*>", " ", RegexOptions.None, TimeSpan.FromSeconds(5))); } diff --git a/tests/MUI.Web.Tests/ScriptAndDirectionTests.cs b/tests/MUI.Web.Tests/ScriptAndDirectionTests.cs new file mode 100644 index 0000000..68314a9 --- /dev/null +++ b/tests/MUI.Web.Tests/ScriptAndDirectionTests.cs @@ -0,0 +1,136 @@ +using MUI.Web.Components; +using MUI.Web.Components.Pages; + +namespace MUI.Web.Tests; + +/// <summary> +/// Game-supplied names, tagged with the script they are actually in. +/// </summary> +/// <remarks> +/// <para> +/// The listing has always contained 北大侠客行 inside a page declared <c>lang="en"</c>. A screen +/// reader picks its voice and its pronunciation rules from that attribute, so it attempts Chinese +/// characters with English phonetics — which is not an accent, it is noise. The same attribute is +/// what selects between the regional Han forms a font draws. +/// </para> +/// <para> +/// The rule these tests exist to hold is the site's own: <b>say what you measured and nothing +/// else.</b> A script settles a language only where it is used for essentially one, and where it is +/// shared the tag is left off rather than filled in with whichever language is commonest. +/// </para> +/// </remarks> +public class ScriptAndDirectionTests +{ + [Test] + [Arguments("Shangrila", null)] + [Arguments("Tapestries MUCK", null)] + [Arguments("3Kingdoms", null)] + public async Task PlainAsciiGetsNoAttributesAtAll(string name, string? expected) + { + // Most of the catalogue, and the page's own lang already describes it. Five hundred rows + // repeating that is the duplication this whole pass exists to remove. + await Assert.That(NameScript.IsPlainAscii(name)).IsTrue(); + await Assert.That(NameScript.LanguageOf(name)).IsEqualTo(expected); + } + + [Test] + [Arguments("ドラゴンクエスト", "ja")] // katakana + [Arguments("剣と魔法の世界", "ja")] // Han with one hiragana particle + [Arguments("바람의나라", "ko")] // Hangul + [Arguments("เมืองแห่งเงา", "th")] // Thai + [Arguments("Δίκτυο", "el")] // Greek + [Arguments("Ἑλλάς", "el")] // opens in Greek Extended, continues in Greek + [Arguments("מבוך", "he")] // Hebrew + [Arguments("مدينة الأحلام", "ar")] // Arabic + public async Task AScriptUsedForOneLanguageSettlesIt(string name, string expected) + { + // Kana settle Japanese wherever they appear, and one is enough: a Japanese title is + // routinely mostly Han with a single particle in it. + await Assert.That(NameScript.LanguageOf(name)).IsEqualTo(expected); + } + + /// <summary> + /// Greek Extended is Greek, and the widening stops at its edges. + /// </summary> + /// <remarks> + /// Polytonic Greek lives at U+1F00–U+1FFF and nothing else is written there, so the block + /// settles a language exactly as the basic Greek block does. Unlisted, it fell to + /// <c>Script.Other</c> — which meant whether a Greek name was tagged at all depended on which of + /// its letters happened to carry a breathing mark. Asserted from the codepoints rather than from + /// a word, because no natural Greek word is written entirely out of this block. + /// </remarks> + [Test] + [Arguments(0x1f00, "el")] // the first letter in the block + [Arguments(0x1ffe, "el")] // the last assigned character in it + [Arguments(0x1efd, null)] // Latin Extended Additional, one below — shared by many languages + [Arguments(0x2010, null)] // general punctuation, above — a script at all only by courtesy + public async Task GreekExtendedSettlesGreekAndTheBlocksAroundItStillSettleNothing( + int codepoint, string? expected) + { + await Assert.That(NameScript.LanguageOf(char.ConvertFromUtf32(codepoint))).IsEqualTo(expected); + } + + [Test] + [Arguments("北大侠客行")] // Han, no kana — Chinese or Japanese, nothing says which + [Arguments("Сумеречная Империя")] // Cyrillic — Russian, Ukrainian, Bulgarian, a dozen more + [Arguments("मापा गया")] // Devanagari — Hindi, Marathi, Nepali + public async Task AScriptSharedByManyLanguagesSettlesNothing(string name) + { + // The important half. Unicode unified Han across Chinese and Japanese, and the correct drawn + // form differs between them — so guessing "zh" for a Japanese game's name is not a harmless + // default, it is the site asserting something about somebody's game that no probe measured. + // An absent lang costs a glyph variant; a wrong one costs the claim the site is built on. + await Assert.That(NameScript.IsPlainAscii(name)).IsFalse(); + await Assert.That(NameScript.LanguageOf(name)).IsNull(); + } + + [Test] + [Arguments("مدينة الأحلام", "rtl")] + [Arguments("מבוך", "rtl")] + [Arguments("北大侠客行", null)] + [Arguments("Shangrila", null)] + public async Task DirectionIsAnsweredFromTheFirstStrongCharacter(string name, string? expected) + { + // Which is what the Unicode bidirectional algorithm itself uses to type a paragraph, so a + // name opening with a Latin bracket around Arabic text is still an Arabic run. + await Assert.That(NameScript.DirectionOf(name)).IsEqualTo(expected); + } + + [Test] + public async Task ANonLatinNameIsIsolatedFromTheRowAroundIt() + { + // Without <bdi> the name, the neutral characters beside it and the count in the next cell + // renegotiate order as one bidirectional run, and the number lands on the wrong side of the + // row. With it, the name reads right-to-left inside its own box while the row stays + // left-to-right — which is the whole of "RTL text, LTR layout" and needs no mirrored + // stylesheet. + var arabic = await Render.ComponentAsync<GameName>(new() { ["Name"] = "مدينة الأحلام" }); + var chinese = await Render.ComponentAsync<GameName>(new() { ["Name"] = "北大侠客行" }); + var latin = await Render.ComponentAsync<GameName>(new() { ["Name"] = "Shangrila" }); + + await Assert.That(arabic).Contains("<bdi"); + await Assert.That(arabic).Contains("dir=\"rtl\""); + await Assert.That(arabic).Contains("lang=\"ar\""); + + // Isolated, but not tagged: nothing in the codepoints says which language this Han is. + await Assert.That(chinese).Contains("<bdi"); + await Assert.That(chinese).DoesNotContain("lang="); + + // And no element at all where the page's own lang already describes the name. + await Assert.That(latin).DoesNotContain("<bdi"); + } + + [Test] + public async Task TheListingWrapsEveryGameNameAndLeavesTheMachineVoiceAlone() + { + // Two halves of tier three. A game's name is isolated so the layout survives it; the + // machine voice — codebase strings, versions, protocol acronyms, hostnames — carries + // translate="no", because translating `PennMUSH 1.8.8p0` destroys evidence rather than + // localizing anything. + var listing = await Render.PageAsync<Games>([]); + var game = await Render.PageAsync<Game>(new() { ["Slug"] = "m-u-s-h" }); + + await Assert.That(listing).Contains("class=\"meta mono\" translate=\"no\""); + await Assert.That(game).Contains("translate=\"no\""); + } +} diff --git a/tests/MUI.Web.Tests/SilenceIsNotEvidenceTests.cs b/tests/MUI.Web.Tests/SilenceIsNotEvidenceTests.cs index 81741cf..e3a33a3 100644 --- a/tests/MUI.Web.Tests/SilenceIsNotEvidenceTests.cs +++ b/tests/MUI.Web.Tests/SilenceIsNotEvidenceTests.cs @@ -1,6 +1,9 @@ using MUI.Catalog; using MUI.Catalog.Persistence; using MUI.Web.Components; +using MUI.Web.Components.Pages; +using MUI.Web.Fixtures; +using MUI.Web.Localization; namespace MUI.Web.Tests; @@ -36,9 +39,14 @@ public async Task AFractionOverAPartlyMeasuredWindowNamesTheMeasuredDenominator( // The number itself was always right — FractionReachable divides by observed time. It was // the sentence that widened it to the window. - await Assert.That(summary.Sentence).Contains("we have measured"); - await Assert.That(summary.Sentence).DoesNotContain("of the last 90 days"); - await Assert.That(summary.Sentence).Contains("89 days predate anything we measured"); + // + // Asserted through the bundle rather than against the English, so the rule holds in every + // locale: the two denominators are two different ids and a translation cannot merge them. + var sentence = summary.Sentence(Locales.SourceTag); + + await Assert.That(sentence).Contains(Say("reach.fraction.measured", ("percent", "100.0%"), ("days", 1))); + await Assert.That(sentence).DoesNotContain(Say("reach.fraction.window", ("percent", "100.0%"), ("days", 90))); + await Assert.That(sentence).Contains(Say("reach.predate", ("count", 89))); } /// <summary>A window we watched all of may say so, and says it the short way.</summary> @@ -49,10 +57,19 @@ public async Task AFractionOverAFullyMeasuredWindowStillNamesTheWindow() [Reachable(from: Now.AddDays(-120), to: null)], Now); - await Assert.That(summary.Sentence).Contains("Reachable 100.0% of the last 90 days."); - await Assert.That(summary.Sentence).DoesNotContain("predate"); + // The whole sentence, assembled from the ids it is supposed to use and no others: the window + // phrasing because the window was fully observed, and nothing about days that predate us. + await Assert.That(summary.Sentence(Locales.SourceTag)).IsEqualTo( + Say("reach.fraction.window", ("percent", "100.0%"), ("days", 90)) + + " " + Messages.For(Locales.SourceTag, "reach.unreachable.noneInWindow")); } + private static string Say(string id, params (string Key, object? Value)[] args) => + Messages.For( + Locales.SourceTag, + id, + args.ToDictionary(a => a.Key, a => a.Value, StringComparer.Ordinal)); + /// <summary> /// An hour with no presence row is not an hour the game was down. /// </summary> @@ -77,16 +94,30 @@ public async Task AnHourWithNoSampleIsNotReportedAsUnreachable() } } - var sentence = ActivitySummary.Sentence(week); + var sentence = ActivitySummary.Sentence(Locales.SourceTag, week); await Assert.That(sentence).Contains("have no measurement yet"); await Assert.That(sentence).DoesNotContain("not reachable"); await Assert.That(sentence).DoesNotContain("unreachable"); var cell = new ActivityCell(3, 4, null, Probed: false); - await Assert.That(ActivitySummary.CellLabel(cell)).DoesNotContain("reachable"); - await Assert.That(ActivitySummary.CellValue(cell)).IsEqualTo("not measured"); - await Assert.That(ActivitySummary.PerDay(week).First()).Contains("not measured"); + await Assert.That(ActivitySummary.CellLabel(Locales.SourceTag, cell)).DoesNotContain("reachable"); + + // The locked id, not the English spelling of it: what this test guards is that the hour is + // called not-measured rather than given a cause, in whatever language the reader asked for. + await Assert.That(ActivitySummary.CellValue(Locales.SourceTag, cell)) + .IsEqualTo(Messages.For(Locales.SourceTag, "state.notMeasured")); + + await Assert.That(ActivitySummary.PerDay(Locales.SourceTag, week).First()).Contains("not measured"); + + // And no locale names a cause for it either. "unreachable" is a different locked id with a + // different translation in every bundle, and an hour with no presence row is not one. + foreach (var locale in Locales.All) + { + await Assert.That(ActivitySummary.CellValue(locale.Tag, cell)) + .IsNotEqualTo(Messages.For(locale.Tag, "state.unreachable")) + .Because($"{locale.Tag} calls an unmeasured hour unreachable"); + } } /// <summary> @@ -111,6 +142,61 @@ public async Task InternalFieldsAreNotThingsAGameSaidAboutItself() await Assert.That(FieldRegistry.Instance.Find(InternalFields.BannerHash)).IsNull(); } + /// <summary> + /// A missing count is not a count somebody failed to read. + /// </summary> + /// <remarks> + /// <para> + /// The game page's hero said <c>state.notCounted</c> whenever <c>PlayersNow</c> was null, and the + /// glossary reserves that string for the middle of rule 2's three states: an hour we reached and + /// could not read a number out of. A null count is not that state. It is that state, an hour + /// nobody measured, and a count older than the window this figure covers, and nothing on the page + /// separates them — so Gaslight Row, archived and unreached since 2018, was described as a game + /// we had probed and failed to count. + /// </para> + /// <para> + /// Asserted through the locked ids rather than the English, and on both surfaces, because + /// <c>?plain=1</c> carried the same claim in its own words ("no count could be measured"). + /// </para> + /// </remarks> + [Test] + public async Task AGamePageWithNoCountNamesNoCauseForNotHavingOne() + { + var page = await new FixtureGameQueries().FindAsync("gaslight-row"); + + await Assert.That(page!.Summary.PlayersNow).IsNull(); + + // The hero itself, sliced out: the strip and the grid below it are entitled to the words + // "unreachable" and "uncounted", because they are derived from intervals and from presence + // rows and can tell those states apart. This figure cannot, so this figure may not say them. + var raw = await Render.PageAsync<Game>(new() { ["Slug"] = "gaslight-row" }); + var opens = raw.IndexOf("class=\"game-figure\"", StringComparison.Ordinal); + + await Assert.That(opens).IsGreaterThanOrEqualTo(0); + + var figure = Render.Words(raw[opens..raw.IndexOf("</div>", opens, StringComparison.Ordinal)]); + + var count = PlainText.Render(page, Now) + .ReplaceLineEndings("\n") + .Split('\n') + .First(line => line.StartsWith("Players now:", StringComparison.Ordinal)); + + foreach (var text in new[] { figure, count }) + { + // The three locked words that would each name a cause nobody measured. + await Assert.That(text).DoesNotContain(Messages.For(Locales.SourceTag, "state.notCounted")); + await Assert.That(text).DoesNotContain(Messages.For(Locales.SourceTag, "state.uncounted")); + await Assert.That(text).DoesNotContain(Messages.For(Locales.SourceTag, "state.unreachable")); + + // And never a nought, which is the other direction of the same mistake. + await Assert.That(text).DoesNotContain("0"); + } + + await Assert.That(figure).Contains(Messages.For(Locales.SourceTag, "game.count.none")); + await Assert.That(figure).Contains(Messages.For(Locales.SourceTag, "game.count.none.why")); + await Assert.That(count).IsEqualTo(Messages.For(Locales.SourceTag, "game.plain.playersNoCount")); + } + private static AvailabilityInterval Reachable(DateTimeOffset from, DateTimeOffset? to) => new() { GameId = Guid.NewGuid(), diff --git a/tests/MUI.Web.Tests/SiteHeaderTests.cs b/tests/MUI.Web.Tests/SiteHeaderTests.cs index fb17e21..77234d4 100644 --- a/tests/MUI.Web.Tests/SiteHeaderTests.cs +++ b/tests/MUI.Web.Tests/SiteHeaderTests.cs @@ -64,11 +64,76 @@ public async Task TheHeaderReadsNothingButWhetherThereIsAPrincipal() await Assert.That(await HeaderAsync(signedIn: true)).IsNotNull(); } - private static Task<string> HeaderAsync(bool signedIn) => + [Test] + public async Task TheCatalogueLinksAreTwoLabelledGroupsAndTheActionsAreNotInThem() + { + // Nine links in one flat row, in no order anybody could name. They are two ideas — places to + // browse, and things to read about the hobby — and two odd ones out: submit is an action + // rather than a category, and about is site meta. Both moved to the far end, beside sign in. + var markup = await HeaderAsync(signedIn: false); + + await Assert.That(markup).Contains("aria-label=\"browse\""); + await Assert.That(markup).Contains("aria-label=\"learn\""); + + var catalogues = markup[markup.IndexOf("site-nav", StringComparison.Ordinal).. + markup.IndexOf("nav class=\"account", StringComparison.Ordinal)]; + + await Assert.That(catalogues).Contains("/games"); + await Assert.That(catalogues).Contains("/rankings"); + await Assert.That(catalogues).DoesNotContain("/about"); + + // Submit is in the nav's markup, and it is not in either group: it lives in `menu-tail`, + // which the bar shows only at the width where the right-hand cluster has run out of room + // for it. A destination the bar cannot fit moves; it is never dropped. + var groups = catalogues[..catalogues.IndexOf("menu-tail", StringComparison.Ordinal)]; + + await Assert.That(groups).DoesNotContain("/submit"); + await Assert.That(catalogues).Contains("/submit"); + } + + [Test] + public async Task EveryCatalogueLinkIsInTheDocumentExactlyOnce() + { + // The bar collapses into a disclosure on a narrow window, and the obvious way to build that + // is a second copy of the links inside the menu. It is also wrong: two copies put two + // `aria-current="page"` markers in one document and hand a screen reader the catalogue + // twice. The disclosure wraps the same two groups instead, and CSS decides whether it is a + // menu or a row. + var markup = await HeaderAsync(signedIn: false, path: "/games"); + + foreach (var href in new[] { "/games", "/find", "/games/random", "/archive", "/reference", "/ecosystem", "/rankings" }) + { + await Assert.That(markup.Split($"href=\"{href}\"").Length - 1).IsEqualTo(1); + } + } + + [Test] + public async Task TheCurrentPageIsMarkedAndTheMarkerIsDrawnInsideTheItem() + { + // aria-current is the fact. The drawing of it is an inset box-shadow in the stylesheet, not + // a border or a padding change: either of those adds a pixel to the current item's box and + // shifts every link beside it on arrival, which is the reported defect. + var markup = await HeaderAsync(signedIn: false, path: "/reference/protocols/mssp"); + + await Assert.That(markup).Contains("href=\"/reference\" class=\"on\" aria-current=\"page\""); + await Assert.That(markup.Split("aria-current").Length - 1).IsEqualTo(1); + } + + [Test] + public async Task TheHomePageDoesNotMarkEverySectionAsCurrent() + { + // "/" is a prefix of every path on the site, so a section match that reached it would mark + // the whole bar on the one page that has no item in it. + var markup = await HeaderAsync(signedIn: false, path: "/"); + + await Assert.That(markup).DoesNotContain("aria-current"); + } + + private static Task<string> HeaderAsync(bool signedIn, string path = "/games") => Render.ComponentAsync<MainLayout>(new Dictionary<string, object?>(), services => { services.AddSingleton(new CatalogueSource(IsMeasured: true)); - services.AddCascadingValue(_ => Context(signedIn)); + services.AddCascadingValue(_ => Context(signedIn, path)); }); /// <summary> @@ -80,10 +145,14 @@ private static Task<string> HeaderAsync(bool signedIn) => /// has no way to produce a real session without an authenticator. The guard under test is the /// layout's own read of <c>Identity.IsAuthenticated</c>, and that runs either way. /// </remarks> - private static HttpContext Context(bool signedIn) + private static HttpContext Context(bool signedIn, string path = "/games") { var context = new DefaultHttpContext(); + // The header asks it one other thing now: which page this is, so the item for it can be + // marked. A path and nothing else — no route data, no endpoint. + context.Request.Path = path; + if (signedIn) { context.User = new ClaimsPrincipal(new ClaimsIdentity( @@ -93,4 +162,30 @@ [new Claim(ClaimTypes.NameIdentifier, Guid.CreateVersion7().ToString())], return context; } + + /// <summary> + /// One page is current, so one item is marked — even where two destinations nest. + /// </summary> + /// <remarks> + /// A section matches its own root and everything under it, which is what makes a reference + /// article mark "reference". But <c>/games/random</c> is its own destination in the same bar, so + /// standing on it matched <c>/games</c> as well and a screen reader was handed two + /// <c>aria-current="page"</c> markers in one document. The most specific match wins now. + /// </remarks> + [Test] + [Arguments("/games/random", "/games/random")] + [Arguments("/games", "/games")] + [Arguments("/reference/protocols/mssp", "/reference")] + [Arguments("/archive", "/archive")] + public async Task ExactlyOneNavigationItemIsMarkedCurrent(string path, string expected) + { + var markup = await HeaderAsync(signedIn: false, path: path); + + var marked = System.Text.RegularExpressions.Regex + .Matches(markup, "<a href=\"([^\"]+)\"[^>]*aria-current=\"page\"") + .Select(m => m.Groups[1].Value) + .ToList(); + + await Assert.That(marked).IsEquivalentTo(new[] { expected }); + } } diff --git a/tests/MUI.Web.Tests/SortingTests.cs b/tests/MUI.Web.Tests/SortingTests.cs index b8e0468..ce4ba00 100644 --- a/tests/MUI.Web.Tests/SortingTests.cs +++ b/tests/MUI.Web.Tests/SortingTests.cs @@ -1,3 +1,4 @@ +using MUI.Web.Localization; using MUI.Catalog; using MUI.Web.Api; using MUI.Web.Components; @@ -115,8 +116,12 @@ await Assert.That(await Render.PageAsync<Games>([], "?sort=name")) await Assert.That(sorted).Contains("unranked-break"); await Assert.That(Render.Words(sorted)).Contains("from here"); - await Assert.That(Render.Words(sorted)).Contains(FacetWords.Unranked(GameSort.Players)); - await Assert.That(FacetWords.Unranked(GameSort.Players)).Contains("not zero"); + await Assert.That(Render.Words(sorted)).Contains(FacetWords.Unranked(Locales.SourceTag, GameSort.Players)); + // The break names the state rather than arguing with a reading of it. It said "reachable, + // count unreadable — not zero", which spends most of its words denying something nobody had + // thought yet; the state has a name, the site uses that name everywhere else, and the rows + // under the break say "not counted" in their own cells. + await Assert.That(FacetWords.Unranked(Locales.SourceTag, GameSort.Players)).IsEqualTo("Unknown count"); } [Test] @@ -128,8 +133,8 @@ public async Task ARowNeverPrintsAnAgeAsNowAgo() var html = Render.Words(await Render.PageAsync<Games>([])); await Assert.That(html).DoesNotContain("now ago"); - await Assert.That(Relative.Ago(TimeSpan.FromSeconds(10))).IsEqualTo("just now"); - await Assert.That(Relative.Ago(TimeSpan.FromMinutes(20))).IsEqualTo("20m ago"); + await Assert.That(Relative.Ago(Locales.SourceTag, TimeSpan.FromSeconds(10))).IsEqualTo("just now"); + await Assert.That(Relative.Ago(Locales.SourceTag, TimeSpan.FromMinutes(20))).IsEqualTo("20m ago"); } [Test] @@ -143,8 +148,8 @@ public async Task ThePlainSurfaceSaysWhatOrderItIsInAndWhereTheBreakFell() var text = PlainText.RenderListing( await Queries.SearchAsync(query.Filter), query.Filter, FixtureGameQueries.Now); - await Assert.That(Render.Words(text)).Contains($"Sorted by {FacetWords.Sort(GameSort.Players)}"); - await Assert.That(Render.Words(text)).Contains(FacetWords.Unranked(GameSort.Players)); + await Assert.That(Render.Words(text)).Contains($"Sorted by {FacetWords.Sort(Locales.SourceTag, GameSort.Players)}"); + await Assert.That(Render.Words(text)).Contains(FacetWords.Unranked(Locales.SourceTag, GameSort.Players)); // And the parameter that changes it, because a text browser cannot operate a <select>. await Assert.That(text).Contains($"?{FacetKeys.Sort}="); @@ -220,8 +225,8 @@ public async Task AGameWithNoWindowSortsBelowTheBreakAndNeverAsAZero() await Assert.That(order[0].Name).IsEqualTo("counted"); await Assert.That(GameSorting.IsUnranked(uncountable, GameSort.MedianMonth)).IsTrue(); - await Assert.That(FacetWords.Unranked(GameSort.MedianMonth)).Contains("not a typical count of zero"); - await Assert.That(FacetWords.Unranked(GameSort.PeakMonth)).Contains("not a game nobody was on"); + await Assert.That(FacetWords.Unranked(Locales.SourceTag, GameSort.MedianMonth)).Contains("not a typical count of zero"); + await Assert.That(FacetWords.Unranked(Locales.SourceTag, GameSort.PeakMonth)).Contains("not a game nobody was on"); } [Test] @@ -255,19 +260,19 @@ public async Task EverySortHasWordsAndAGroupToBeOfferedUnder() // "name" — which is an order the reader did not choose, silently. foreach (var sort in Enum.GetValues<GameSort>()) { - await Assert.That(FacetWords.Sort(sort)).IsNotEmpty(); - await Assert.That(FacetWords.SortGroup(sort)).IsNotEmpty(); + await Assert.That(FacetWords.Sort(Locales.SourceTag, sort)).IsNotEmpty(); + await Assert.That(FacetWords.SortGroup(Locales.SourceTag, sort)).IsNotEmpty(); if (sort is not GameSort.Name) { - await Assert.That(FacetWords.Unranked(sort)) + await Assert.That(FacetWords.Unranked(Locales.SourceTag, sort)) .IsNotEmpty() .Because($"{sort} can leave games unranked and has to say what they have in common"); } } // Distinct labels, or two options in the control are one choice wearing two rows. - await Assert.That(Enum.GetValues<GameSort>().Select(FacetWords.Sort).Distinct().Count()) + await Assert.That(Enum.GetValues<GameSort>().Select(s => FacetWords.Sort(Locales.SourceTag, s)).Distinct().Count()) .IsEqualTo(Enum.GetValues<GameSort>().Length); } diff --git a/tests/MUI.Web.Tests/SubmitSurfaceTests.cs b/tests/MUI.Web.Tests/SubmitSurfaceTests.cs index cd2c019..fc73c0e 100644 --- a/tests/MUI.Web.Tests/SubmitSurfaceTests.cs +++ b/tests/MUI.Web.Tests/SubmitSurfaceTests.cs @@ -3,6 +3,7 @@ using MUI.Discovery; using MUI.Web.Components; using MUI.Web.Components.Pages; +using MUI.Web.Localization; namespace MUI.Web.Tests; @@ -77,6 +78,48 @@ public async Task TheFormSaysASubmissionIsNotAListing() await Assert.That(page).Contains("Nothing appears on the site until somebody proves they run it"); } + /// <summary> + /// Every word this form says comes out of the message bundle. + /// </summary> + /// <remarks> + /// The pseudolocale brackets and accents anything that reached a reader through + /// <see cref="Messages"/>, so an English sentence surviving here is one typed into the page or + /// into <see cref="SubmitCopy"/>. The address is the exception and is asserted to survive + /// intact: it is what a stranger typed, it is machine voice, and a form that handed back a + /// translated version of somebody's hostname would be answering about a different address. + /// </remarks> + [Test] + public async Task EveryAnswerComesFromTheBundleAndTheAddressComesBackUntouched() + { + foreach (var outcome in Enum.GetValues<SubmissionOutcome>()) + { + var english = SubmitCopy.Answer(outcome, "mud.example.org 4201")!; + var pseudo = PlainText.RenderSubmit( + SubmitCopy.Answer(outcome, "mud.example.org 4201", null, "qps-ploc"), + hasCatalogue: true, + "qps-ploc"); + + await Assert.That(pseudo).Contains("⟦"); + await Assert.That(Render.Words(pseudo)) + .DoesNotContain(Render.Words(english.Heading)) + .Because($"the {outcome} heading never went through the message pipeline"); + } + + // The lede, the five points and the address, in one render. + var form = Render.Words(PlainText.RenderSubmit( + SubmitCopy.Answer(SubmissionOutcome.Accepted, "mud.example.org 4201", null, "qps-ploc"), + hasCatalogue: true, + "qps-ploc")); + + await Assert.That(form).Contains("mud.example.org 4201"); + await Assert.That(form).DoesNotContain(Render.Words(SubmitCopy.Lede())); + + foreach (var point in SubmitCopy.Points()) + { + await Assert.That(form).DoesNotContain(Render.Words(point)); + } + } + /// <summary>Over the demo fixture the form is absent rather than present and doing nothing.</summary> [Test] public async Task OverTheFixtureThereIsNoFormAtAll() diff --git a/tests/MUI.Web.Tests/ThreeStatesTests.cs b/tests/MUI.Web.Tests/ThreeStatesTests.cs index 6fd1df7..89286ff 100644 --- a/tests/MUI.Web.Tests/ThreeStatesTests.cs +++ b/tests/MUI.Web.Tests/ThreeStatesTests.cs @@ -1,6 +1,7 @@ using MUI.Catalog; using MUI.Web.Components; using MUI.Web.Fixtures; +using MUI.Web.Localization; namespace MUI.Web.Tests; @@ -17,32 +18,179 @@ namespace MUI.Web.Tests; /// </remarks> public class ThreeStatesTests { + /// <summary> + /// The listing's absent count says the count is absent, and does not name a cause. + /// </summary> + /// <remarks> + /// <b>Three cases were wearing one word, and the word named a cause.</b> The count column + /// printed <c>state.notCounted</c> — the glossary's phrase for a probe that answered without a + /// number — whenever the window had no measurement, which also covers a window we never probed + /// in and a game with no rows at all. Two of the three are our crawl schedule, and rule 5 says + /// our schedule is never published as a fact about somebody's game. The same conflation was + /// found and fixed on the game page's hero; this is the listing's half of it. + /// </remarks> + [Test] + public async Task TheListingSaysACountIsAbsentWithoutSayingWhy() + { + var absent = Messages.For(Locales.SourceTag, "listing.count.none"); + var probed = Messages.For(Locales.SourceTag, "state.notCounted"); + + // Two different facts, so two different strings — in every language, not just this one. + // + // Walked over every locale the site has a bundle for, not the choosable ones. The filtered + // set can shrink to English alone — a locale that is not yet complete is not offered — and + // then this loop proves nothing while still passing, which is the failure mode a + // cross-locale claim is most prone to. The count is asserted so it cannot go quiet. + var locales = Locales.All.Where(l => l.Tag != Locales.SourceTag).ToList(); + + await Assert.That(locales.Count).IsGreaterThan(1) + .Because("a claim about every language needs more than one language to be a claim"); + + foreach (var locale in locales.Append(Locales.Source)) + { + await Assert.That(Messages.For(locale.Tag, "listing.count.none")) + .IsNotEqualTo(Messages.For(locale.Tag, "state.notCounted")) + .Because($"{locale.Tag} must not print a probed-but-unreadable count for an unmeasured window"); + } + + // And it names nothing: no cause, no zero. + await Assert.That(absent).DoesNotContain("0"); + await Assert.That(absent).IsNotEqualTo(probed); + } + + /// <summary>The plain listing marks and its break line are the bundle's words, not English.</summary> + /// <remarks> + /// The rendered listing was localized and its <c>?plain=1</c> mirror was not: "-- from here:", + /// "[archived]" and "[claimed]" were literals, so a German reader's text alternative carried + /// three English words the page beside it does not. A mirror that answers in a different + /// language from the page is not a mirror. + /// </remarks> + [Test] + public async Task ThePlainListingMarksAreTranslatedLikeTheRestOfIt() + { + foreach (var id in new[] + { + "listing.plain.fromHere", "listing.plain.archived", "listing.plain.claimed", + }) + { + await Assert.That(Messages.Ids).Contains(id); + await Assert.That(Messages.For(Locales.SourceTag, id)).IsNotEmpty(); + } + } + private static readonly DateTimeOffset Now = FixtureGameQueries.Now; + /// <summary>The language these assertions are written in, named rather than assumed.</summary> + private const string English = Locales.SourceTag; + + /// <summary> + /// The four states on one day — and, because the grid is only drawn once every day of the week + /// carries a measurement, a measured hour on each of the other six so there is a grid to look at. + /// </summary> private static ActivityCell[] OneOfEach() => [ new(0, 0, 4, Probed: true), new(0, 1, 0, Probed: true), new(0, 2, null, Probed: true), new(0, 3, null, Probed: false), + .. Enumerable.Range(1, 6).Select(day => new ActivityCell(day, 20, 3, Probed: true)), ]; private static Task<string> GridAsync(IReadOnlyList<ActivityCell> cells) => Render.ComponentAsync<ActivityHeatmap>(new() { ["Cells"] = cells }); [Test] - public async Task TheGridIsARealTableWithRowAndColumnHeaders() + public async Task TheGridIsDrawnWithHeadersAndIsNotWhatAScreenReaderIsGiven() { - // Not a compromise for accessibility — a real table is what makes arrow-key navigation work - // at all, and it costs the visual design nothing. + // The drawing keeps its row and column headers — they are what make the picture legible and + // what the mouse tooltips hang off — but it is hidden from assistive tech, because announced + // cell by cell it is 168 utterances that deliver one shape. The seven rows below it are the + // text alternative, and they are a real table with a caption and headers of their own. var html = await GridAsync(OneOfEach()); + await Assert.That(html).Contains("<div class=\"heat-wrap\" aria-hidden=\"true\""); await Assert.That(html).Contains("<table class=\"heat\""); + await Assert.That(html).Contains("<table class=\"perday\""); await Assert.That(html).Contains("scope=\"col\""); await Assert.That(html).Contains("scope=\"row\""); await Assert.That(html).Contains("<caption"); } + [Test] + public async Task ACellCarriesNoAnnouncedTextOfItsOwn() + { + // 168 cells with a word in each is the whole of finding B2: on a sparsely measured game a + // screen reader was made to hear "not measured" 167 times before reaching the one number + // that existed. The words stay in the tooltip, where a mouse reader gets them, and the facts + // stay in the table below, where a listener gets them in seven rows. + var html = Render.Words(await GridAsync(OneOfEach())); + + await Assert.That(html).Contains("title=\"Mon 03:00 — no measurement in this hour\"></td>"); + + // Nothing announced anywhere in the grid's body — no cell text, and no sr-only span smuggling + // one back in. The words are in the table below, seven rows of them. + var body = html[html.IndexOf("<tbody", StringComparison.Ordinal)..]; + var grid = body[..body.IndexOf("</table>", StringComparison.Ordinal)]; + + await Assert.That(grid).DoesNotContain("sr-only"); + await Assert.That(grid).DoesNotContain("</td>not"); + } + + [Test] + public async Task BelowSevenMeasuredDaysThereIsNoGridAtAll() + { + // A 7×24 grid holding one probe is 167 empty cells, and it reads as a broken page to a + // sighted reader and as a wall to a listening one. What we have, and what has to arrive + // before there is a week to draw. + var html = Render.Words(await GridAsync( + [ + new(0, 0, 42, Probed: true), + ])); + + await Assert.That(html).Contains("not enough measurements yet"); + await Assert.That(html).Contains("the busiest 42 on Monday at 00:00 UTC"); + await Assert.That(html).DoesNotContain("<table"); + + // And no sentence about a week: "busiest Monday, small hours" off one Monday morning is a + // claim about a shape one measurement cannot have. + await Assert.That(html).DoesNotContain("Busiest"); + } + + /// <summary> + /// The threshold itself, from both sides. + /// </summary> + /// <remarks> + /// The test above uses one measured day, which passes whether the comparison is <c>>=</c>, + /// <c>></c> or off by one. Six against seven is the only pair that pins + /// <see cref="ActivitySummary.MeasuredDaysForGrid"/> down, and two surfaces read it — the grid's + /// own gate and the plain surface's. + /// </remarks> + [Test] + public async Task SixMeasuredDaysIsNotAWeekAndTheSeventhIsWhatDrawsTheGrid() + { + var six = Enumerable.Range(0, ActivitySummary.MeasuredDaysForGrid - 1) + .Select(day => new ActivityCell(day, 20, 3, Probed: true)) + .ToList(); + + var withoutGrid = Render.Words(await GridAsync(six)); + + await Assert.That(withoutGrid).Contains("not enough measurements yet"); + await Assert.That(withoutGrid).DoesNotContain("<table"); + + var seven = six + .Append(new ActivityCell(ActivitySummary.MeasuredDaysForGrid - 1, 20, 3, Probed: true)) + .ToList(); + + await Assert.That(Render.Words(await GridAsync(seven))).Contains("<table class=\"perday\""); + + // And the plain surface turns on the same day, or the two disagree about how much was + // measured — which is the failure mode a shared constant with one caller invites. + await Assert.That(ActivitySummary.MeasuredDays(six)) + .IsLessThan(ActivitySummary.MeasuredDaysForGrid); + await Assert.That(ActivitySummary.MeasuredDays(seven)) + .IsEqualTo(ActivitySummary.MeasuredDaysForGrid); + } + [Test] public async Task TheThreeStatesAreThreeDifferentCellsInTheMarkup() { @@ -57,16 +205,16 @@ public async Task TheThreeStatesAreThreeDifferentCellsInTheMarkup() [Test] public async Task AMeasuredZeroSaysMeasuredAndAnUnmeasuredHourSaysSo() { - // The distinction has to survive with no cell shape and no colour at all, so it is in the - // cell's own text as well as its class — the value a reader arrows onto, and the whole - // sentence in the tooltip. + // The distinction has to survive with no cell shape and no colour at all, so it is in words + // as well as in the cell's class: the whole sentence in the tooltip, and a column each in + // the table below, where "not measured" and "no count" are two headings and never one. var html = await GridAsync(OneOfEach()); await Assert.That(html).Contains("0 players, measured"); await Assert.That(html).Contains("no measurement in this hour"); await Assert.That(html).Contains("probed, no count could be read"); - await Assert.That(html).Contains(">not measured<"); - await Assert.That(html).Contains(">not counted<"); + await Assert.That(html).Contains(">not measured</th>"); + await Assert.That(html).Contains(">no count</th>"); } [Test] @@ -75,10 +223,194 @@ public async Task AnAnnouncedCellIsAValueRatherThanARepeatedSentence() // The headers already say which hour of which day a cell is. Repeating that in every cell // turns 168 cells into 168 paragraphs, which is what the summary and the disclosure exist // to prevent. - await Assert.That(ActivitySummary.CellValue(new ActivityCell(0, 0, 4, true))).IsEqualTo("4"); - await Assert.That(ActivitySummary.CellValue(new ActivityCell(0, 1, 0, true))).IsEqualTo("0"); - await Assert.That(ActivitySummary.CellValue(new ActivityCell(0, 2, null, true))).IsEqualTo("not counted"); - await Assert.That(ActivitySummary.CellValue(new ActivityCell(0, 3, null, false))).IsEqualTo("not measured"); + // + // The two words are read from the glossary rather than written out here: they are locked ids + // and this test's business is that the cell says the right *state*, not that English spells + // it a particular way. A number is a number in every locale and stays written out. + await Assert.That(ActivitySummary.CellValue(English, new ActivityCell(0, 0, 4, true))).IsEqualTo("4"); + await Assert.That(ActivitySummary.CellValue(English, new ActivityCell(0, 1, 0, true))).IsEqualTo("0"); + + await Assert.That(ActivitySummary.CellValue(English, new ActivityCell(0, 2, null, true))) + .IsEqualTo(Messages.For(English, "state.notCounted")); + + await Assert.That(ActivitySummary.CellValue(English, new ActivityCell(0, 3, null, false))) + .IsEqualTo(Messages.For(English, "state.notMeasured")); + } + + /// <summary> + /// The worst bug this codebase can ship, checked in every language the site answers in. + /// </summary> + /// <remarks> + /// An hour that answered and could not be counted and an hour nobody has a measurement for are + /// two facts, and a translation engine reaches for one phrase — <em>nicht verfügbar</em> — for + /// both. A reader who cannot tell them apart cannot tell a game that answered from one that did + /// not, which is the single thing this site exists to say. Asserted through the cell rather than + /// through the glossary, because the cell is where a reader meets them. + /// </remarks> + [Test] + public async Task NotMeasuredAndNotCountedAreTwoDifferentWordsInEveryLocale() + { + var gap = new ActivityCell(0, 3, null, Probed: false); + var uncountable = new ActivityCell(0, 2, null, Probed: true); + + foreach (var locale in Locales.All) + { + var notMeasured = ActivitySummary.CellValue(locale.Tag, gap); + var notCounted = ActivitySummary.CellValue(locale.Tag, uncountable); + + await Assert.That(notMeasured) + .IsNotEqualTo(notCounted) + .Because($"{locale.Tag} says the same thing about two different hours"); + + // And neither is a nought. A zero is a count we took, and both of these are the absence + // of one — in every language, including the ones that have not been translated yet. + await Assert.That(notMeasured).IsNotEqualTo("0"); + await Assert.That(notCounted).IsNotEqualTo("0"); + } + } + + /// <summary> + /// A German page names the days in German, and it does not get them from us. + /// </summary> + /// <remarks> + /// Seven weekday strings compiled into a component are seven strings no translator is ever sent, + /// and the symptom was a fully German sentence with "Monday" in the middle of it. They come from + /// CLDR now, so the mapping is what can break: Monday is 0 in this codebase because that is how + /// the store keys a week, and .NET's arrays start at Sunday. + /// </remarks> + [Test] + [Arguments("en", 0, "Monday", "Mon")] + [Arguments("en", 6, "Sunday", "Sun")] + [Arguments("de", 0, "Montag", "Mo")] + [Arguments("de", 4, "Freitag", "Fr")] + [Arguments("de", 6, "Sonntag", "So")] + [Arguments("nl", 0, "maandag", "ma")] + public async Task ADayIsNamedInTheReadersLanguageAndTheWeekStartsOnMonday( + string tag, int day, string expected, string expectedShort) + { + await Assert.That(ActivitySummary.DayName(tag, day)).IsEqualTo(expected); + await Assert.That(ActivitySummary.ShortDayName(tag, day)).IsEqualTo(expectedShort); + } + + /// <summary> + /// The sentence about a week reaches a reader in their own language, day names and all. + /// </summary> + [Test] + public async Task TheSummarySentenceIsAnsweredInTheLocaleItWasAskedIn() + { + var cells = FixtureActivity(); + + var english = ActivitySummary.Sentence(English, cells); + var german = ActivitySummary.Sentence("de", cells); + + // Every id here is untranslated today, so the German sentence is the English one — with the + // day names, which are CLDR's rather than ours, already in German. That is the fallback + // behaving: an English phrase in a German page says truthfully that this claim has not been + // translated, and a day name has no excuse, because nobody had to translate it. + await Assert.That(german).IsNotEqualTo(english); + + var named = 0; + + foreach (var day in Enumerable.Range(0, 7)) + { + if (!english.Contains(ActivitySummary.DayName(English, day), StringComparison.Ordinal)) + { + continue; + } + + named++; + + await Assert.That(german).Contains(ActivitySummary.DayName("de", day)); + await Assert.That(german).DoesNotContain(ActivitySummary.DayName(English, day)); + } + + await Assert.That(named).IsGreaterThan(0).Because("the sentence named no day at all"); + } + + /// <summary> + /// No count is ever said in a plural form the reader's language does not have. + /// </summary> + /// <remarks> + /// <para> + /// The whole reason the counts are ICU arguments rather than numbers glued to English nouns. + /// English distinguishes one hour from two and Chinese distinguishes nothing, so an English + /// message with a <c>one</c> branch must not hand that branch to a Chinese reader merely because + /// it is there — which is precisely what a fallback does if the formatter picks branches by the + /// source language rather than by the target. + /// </para> + /// <para> + /// Counted as shapes rather than compared to expected strings: with the number blanked out, the + /// number of distinct renderings a message can produce is the number of forms it emits, and that + /// may never exceed the count of categories CLDR gives the language. + /// </para> + /// </remarks> + [Test] + public async Task ACountIsSaidInAFormItsOwnLanguageHas() + { + string[] counted = ["activity.gap.week", "activity.day.notMeasured", "activity.sparse.uncounted"]; + + foreach (var locale in Locales.All) + { + var forms = PluralRules.CategoriesOf(locale.Tag).Count; + + foreach (var id in counted) + { + var shapes = Enumerable.Range(1, 25) + .Select(n => Messages + .For(locale.Tag, id, new Dictionary<string, object?> { ["count"] = n }) + .Replace(n.ToString(), "#", StringComparison.Ordinal)) + .Distinct(StringComparer.Ordinal) + .ToList(); + + await Assert.That(shapes.Count) + .IsLessThanOrEqualTo(forms) + .Because($"{locale.Tag} / {id} says {shapes.Count} things and the language has " + + $"{forms} plural {(forms == 1 ? "form" : "forms")}"); + } + } + + // And English, where a bug of this kind is invisible, still says both of its two. + await Assert.That(Messages.For(English, "activity.gap.week", new Dictionary<string, object?> { ["count"] = 1 })) + .Contains("1 hour across"); + await Assert.That(Messages.For(English, "activity.gap.week", new Dictionary<string, object?> { ["count"] = 2 })) + .Contains("2 hours across"); + } + + /// <summary> + /// Every sentence the panel can write renders in every locale, with no argument left unsupplied. + /// </summary> + /// <remarks> + /// A message that names <c>{day}</c> where the caller passes none is a <c>FormatException</c> on + /// somebody's page rather than a wrong word, and the branch it hides in is the one that only a + /// particular week reaches. This walks the shapes: a week measured at zero, a week nobody + /// counted, a week of gaps, and a week with one hour in it. + /// </remarks> + [Test] + public async Task EverySentenceShapeRendersInEveryLocale() + { + IReadOnlyList<ActivityCell>[] weeks = + [ + FixtureActivity(), + OneOfEach(), + [.. Week((d, h) => new ActivityCell(d, h, 0, Probed: true))], + [.. Week((d, h) => new ActivityCell(d, h, null, Probed: true))], + [.. Week((d, h) => new ActivityCell(d, h, null, Probed: false))], + [new ActivityCell(0, 0, 42, Probed: true)], + [], + ]; + + foreach (var locale in Locales.All) + { + foreach (var week in weeks) + { + await Assert.That(() => ActivitySummary.Sentence(locale.Tag, week)).ThrowsNothing(); + await Assert.That(() => ActivitySummary.Sparse(locale.Tag, week)).ThrowsNothing(); + await Assert.That(() => ActivitySummary.PerDay(locale.Tag, week)).ThrowsNothing(); + } + } + + static IEnumerable<ActivityCell> Week(Func<int, int, ActivityCell> cell) => + Enumerable.Range(0, 7).SelectMany(d => Enumerable.Range(0, 24).Select(h => cell(d, h))); } [Test] @@ -94,9 +426,9 @@ public async Task AnArchivedGamesGridIsEmptyRatherThanHatched() var page = await new FixtureGameQueries().FindAsync("gaslight-row"); await Assert.That(page!.Activity.All(c => c.IsGap)).IsTrue(); - await Assert.That(ActivitySummary.Sentence(page.Activity)).Contains("no measurement yet"); - await Assert.That(ActivitySummary.Sentence(page.Activity)).DoesNotContain("reachable"); - await Assert.That(ActivitySummary.Sentence(page.Activity)).DoesNotContain("answered but produced"); + await Assert.That(ActivitySummary.Sentence(English, page.Activity)).Contains("no measurement yet"); + await Assert.That(ActivitySummary.Sentence(English, page.Activity)).DoesNotContain("reachable"); + await Assert.That(ActivitySummary.Sentence(English, page.Activity)).DoesNotContain("answered but produced"); } [Test] @@ -114,13 +446,28 @@ public async Task TheSummarySentenceArrivesBeforeTheGrid() } [Test] - public async Task AReadAsTextDisclosureGivesOneLinePerDayRatherThanAHundredAndSixtyEightCells() + public async Task AReadAsTextDisclosureGivesOneRowPerDayRatherThanAHundredAndSixtyEightCells() { + // Seven rows — day, quietest, busiest, the hour the peak was in, and the two kinds of hour + // that produced no number — behind one keystroke rather than a wall to scroll past. var html = Render.Words(await GridAsync(FixtureActivity())); - await Assert.That(html).Contains("read as text"); - await Assert.That(html).Contains("Mon —"); - await Assert.That(html).Contains("Sun —"); + await Assert.That(html).Contains("read as text — 7 rows"); + await Assert.That(html).Contains("<th scope=\"row\">Mon</th>"); + await Assert.That(html).Contains("<th scope=\"row\">Sun</th>"); + await Assert.That(html).Contains("Players on by day, in UTC."); + } + + [Test] + public async Task ThePlainSurfaceSaysTheSameThingAboutASparselyMeasuredGame() + { + // Plain mode is the mirror people actually rely on, so a change that removes a graphic has + // to reach it too — otherwise the two surfaces disagree about how much was measured. + var page = await new FixtureGameQueries().FindAsync("gaslight-row"); + var text = Render.Words(PlainText.Render(page!, Now)); + + await Assert.That(text).Contains("The grid appears once every day of the week has one."); + await Assert.That(text).DoesNotContain("Mon —"); } [Test] @@ -129,7 +476,7 @@ public async Task TheSentenceNamesUnmeasuredAndUncountableHoursSeparately() // The design's own specimen sentence says only "could not be measured", which covers both. // They are different facts about a game and the summary keeps them apart — an hour nobody // has a measurement for, and an hour we reached and could not count. - var sentence = ActivitySummary.Sentence(FixtureActivity()); + var sentence = ActivitySummary.Sentence(English, FixtureActivity()); await Assert.That(sentence).Contains("have no measurement yet"); await Assert.That(sentence).Contains("answered but produced no count"); @@ -143,7 +490,7 @@ public async Task AGameCountedAtZeroAllWeekIsNotDescribedAsUnmeasured() .SelectMany(d => Enumerable.Range(0, 24).Select(h => new ActivityCell(d, h, 0, Probed: true))) .ToList(); - var sentence = ActivitySummary.Sentence(cells); + var sentence = ActivitySummary.Sentence(English, cells); await Assert.That(sentence).Contains("Measured every hour"); await Assert.That(sentence).DoesNotContain("not reachable"); diff --git a/tests/MUI.Web.Tests/TimeSurfaceTests.cs b/tests/MUI.Web.Tests/TimeSurfaceTests.cs new file mode 100644 index 0000000..32c7407 --- /dev/null +++ b/tests/MUI.Web.Tests/TimeSurfaceTests.cs @@ -0,0 +1,436 @@ +using System.Globalization; + +using MUI.Catalog; +using MUI.Web.Components; +using WebProvenance = MUI.Web.Components.Provenance; +using MUI.Web.Localization; + +namespace MUI.Web.Tests; + +/// <summary> +/// One date format, one age ladder, and an age a reader can resolve to a time — in any language. +/// </summary> +/// <remarks> +/// <para> +/// The site printed three absolute formats — <c>2026-08-17</c> on a game page, <c>31 July 2026</c> +/// in the rankings, <c>Aug 2026</c> beside an address — and its relative ages carried no absolute +/// value at all, so a reader arriving from a cached page or a search result could not tell what +/// "19m ago" was 19 minutes before. +/// </para> +/// <para> +/// Then it printed the one format under <see cref="CultureInfo.InvariantCulture"/>, which is the +/// same defect wearing a different hat: a German page said <c>30 Jul 2026</c>, and the month name +/// was not in any file a translator is ever sent. These now assert the fact through the bundle +/// rather than the English literal, because a literal passes on the day the German is wrong. +/// </para> +/// </remarks> +public class TimeSurfaceTests +{ + private static readonly DateTimeOffset Now = new(2026, 8, 17, 14, 21, 0, TimeSpan.Zero); + + private const string English = Locales.SourceTag; + private const string German = "de"; + + /// <summary> + /// The locales that claim to be languages. + /// </summary> + /// <remarks> + /// The pseudolocale accents every letter it is handed, so it renders UTC as ÚTÇ and MSSP inside + /// brackets. That is the pseudolocale doing its one job — proving a string came through the + /// pipeline — and it is never offered to a reader, so it is not the thing these two assert on. + /// </remarks> + private static IEnumerable<Locale> Languages => + Locales.All.Where(l => l.Status is not LocaleStatus.TestOnly); + + [Test] + public async Task ThereIsOneAbsoluteFormatAndItNamesItsZone() + { + var at = new DateTimeOffset(2026, 8, 17, 14, 2, 0, TimeSpan.Zero); + + await Assert.That(Dates.Absolute(English, at)).IsEqualTo("17 Aug 2026"); + await Assert.That(Dates.Stamp(English, at)).IsEqualTo("17 Aug 2026 14:02 UTC"); + await Assert.That(Dates.Machine(at)).IsEqualTo("2026-08-17T14:02:00Z"); + } + + /// <summary> + /// The month is CLDR's, not an array here and not the invariant culture's. + /// </summary> + /// <remarks> + /// The same finding as the heatmap's seven English day names, one file over: no translator could + /// have fixed <c>Jul</c> on a German page, because the word was never in a file they are sent. + /// July is the case worth pinning — German writes <c>Juli</c> in a date and .NET's *standalone* + /// abbreviation is the legacy <c>Jul</c>, so a plausible-looking call to + /// <c>GetAbbreviatedMonthName</c> would leave this passing in English and wrong in German. + /// </remarks> + [Test] + public async Task AGermanPageNamesTheMonthInGerman() + { + var july = new DateTimeOffset(2026, 7, 30, 18, 0, 0, TimeSpan.Zero); + + // The word, not the whole string: the order of the three parts is `date.absolute`'s to + // decide, and German's translation of it supplies the ordinal point that English has no use + // for — "30. Juli 2026". Pinning the assembled sentence here would have made a correct + // translation fail, which is the test asserting its own English word order as if it were a + // fact about dates. + await Assert.That(Dates.Absolute(German, july)).Contains("Juli"); + await Assert.That(Dates.Absolute(German, july)).Contains("30"); + await Assert.That(Dates.Absolute(German, july)).Contains("2026"); + await Assert.That(Dates.Absolute(German, july)).DoesNotContain("Jul "); + + // The stamp is the date with the clock on it, in whatever order that locale puts them. + await Assert.That(Dates.Stamp(German, july)).Contains(Dates.Absolute(German, july)); + await Assert.That(Dates.Stamp(German, july)).Contains("18:00"); + await Assert.That(Dates.Stamp(German, july)).Contains("UTC"); + + await Assert.That(Dates.Absolute(German, july)).IsNotEqualTo(Dates.Absolute(English, july)); + } + + /// <summary>Every month of the year, and not one of them still in English.</summary> + /// <remarks> + /// One month passing is a coincidence — <c>Feb</c>, <c>Aug</c> and <c>Sep</c> are nearly the + /// same word in both languages, and the sweep that found this was run against a fixture whose + /// dates are all in July. Walking twelve is what proves the name came out of CLDR rather than + /// out of a lucky abbreviation. + /// </remarks> + [Test] + public async Task NoMonthOfTheGermanYearComesBackInEnglish() + { + for (var month = 1; month <= 12; month++) + { + var at = new DateTimeOffset(2026, month, 15, 9, 0, 0, TimeSpan.Zero); + + await Assert.That(Dates.Absolute(German, at)) + .IsNotEqualTo(Dates.Absolute(English, at)) + .Because($"month {month} reads the same in German as in English"); + } + } + + /// <summary> + /// UTC is a zone and not a word, and the clock is the site's rather than the locale's. + /// </summary> + /// <remarks> + /// Every time here is UTC because a crawler's clock is the only one it has. A locale that + /// rendered <c>2:02 PM</c>, or one that translated the suffix, would be describing a different + /// instant to a reader who has no way to tell. + /// </remarks> + [Test] + public async Task TheZoneIsNamedInEveryLanguageAndTheClockDoesNotMove() + { + var at = new DateTimeOffset(2026, 8, 17, 14, 2, 0, TimeSpan.Zero); + + foreach (var locale in Languages) + { + var stamp = Dates.Stamp(locale.Tag, at); + + await Assert.That(stamp).Contains("14:02").Because($"{locale.Tag} moved the clock"); + await Assert.That(stamp).Contains("UTC").Because($"{locale.Tag} lost the zone"); + } + } + + [Test] + public async Task TheAgeLadderRunsMinutesToNinetyThenHoursToFortyEight() + { + await Assert.That(Relative.Format(English, TimeSpan.FromSeconds(30))).IsEqualTo("now"); + await Assert.That(Relative.Format(English, TimeSpan.FromMinutes(84))).IsEqualTo("84m"); + await Assert.That(Relative.Format(English, TimeSpan.FromMinutes(95))).IsEqualTo("1h"); + await Assert.That(Relative.Format(English, TimeSpan.FromHours(47))).IsEqualTo("47h"); + await Assert.That(Relative.Format(English, TimeSpan.FromHours(49))).IsEqualTo("2d"); + } + + /// <summary> + /// Every rung of every family is a real ICU plural, with the branches its language has. + /// </summary> + /// <remarks> + /// <para> + /// <c>n + "w ago"</c> is a sentence assembled in English word order with nowhere for a + /// translator to stand. The rungs are patterns instead, so a language selects its own category + /// — and this walks every locale the site names against the CLDR rules it transcribes, because + /// a pattern that parses in English can still be missing the branch Russian needs. + /// </para> + /// <para> + /// <c>other</c> is mandatory everywhere, including in Japanese and Chinese, which have nothing + /// else. A branch keyword a language does not have is rejected rather than ignored. + /// </para> + /// </remarks> + [Test] + public async Task EveryRungIsAPluralWithTheCategoriesItsLanguageActuallyHas() + { + string[] families = ["age.short", "age.ago", "age.dark"]; + string[] rungs = ["now", "minutes", "hours", "days", "weeks", "months", "years"]; + + foreach (var family in families) + { + foreach (var rung in rungs) + { + var id = family + "." + rung; + + await Assert.That(Messages.Source(id)) + .IsNotNull() + .Because($"{id} is not in the English bundle"); + + foreach (var locale in Locales.All) + { + foreach (var count in new[] { 0, 1, 2, 5, 11, 21, 101 }) + { + var said = Messages.For( + locale.Tag, + id, + new Dictionary<string, object?>(StringComparer.Ordinal) { ["count"] = count }); + + await Assert.That(string.IsNullOrWhiteSpace(said)) + .IsFalse() + .Because($"{locale.Tag} said nothing for {id} at {count}"); + } + } + } + } + } + + /// <summary> + /// The number reaches the pattern, so a language can put it where it belongs. + /// </summary> + [Test] + public async Task ThePluralPrintsTheNumberItWasGiven() + { + await Assert.That(Relative.Format(English, TimeSpan.FromDays(21))).IsEqualTo("3w"); + await Assert.That(Relative.Ago(English, TimeSpan.FromDays(21))).IsEqualTo("3w ago"); + await Assert.That(Relative.Format(English, TimeSpan.FromDays(400))).IsEqualTo("13mo"); + await Assert.That(Relative.Ago(English, TimeSpan.FromDays(1200))).IsEqualTo("3y ago"); + } + + /// <summary> + /// "How fresh is this measurement" and "how long has this game been dark" are two questions. + /// </summary> + /// <remarks> + /// English answers both with "2w ago" and several languages will not. The ids are separate so a + /// translator can reach each one at all — collapsing them because the source language cannot + /// tell them apart is how three cases in four end up ungrammatical. + /// </remarks> + [Test] + public async Task AFreshMeasurementAndADarkGameAreTwoIdsEvenWhereTheEnglishIsOne() + { + var age = TimeSpan.FromDays(14); + + await Assert.That(Relative.Ago(English, age, AgeSense.Confirmed)) + .IsEqualTo(Relative.Ago(English, age, AgeSense.Reached)); + + string[] rungs = ["now", "minutes", "hours", "days", "weeks", "months", "years"]; + + foreach (var rung in rungs) + { + await Assert.That(Messages.Source("age.ago." + rung)).IsNotNull(); + await Assert.That(Messages.Source("age.dark." + rung)).IsNotNull(); + } + } + + /// <summary> + /// The dark register never names a cause, in any language. + /// </summary> + /// <remarks> + /// We measured a socket from one vantage point at intervals. A game with a routing problem to + /// our host is unreachable and perfectly alive, and "offline" would file our vantage point as a + /// fact about their game (rule 5). + /// </remarks> + [Test] + public async Task ADarkGameIsNeverCalledOfflineOrDown() + { + foreach (var locale in Locales.All) + { + foreach (var rung in new[] { "now", "hours", "weeks", "years" }) + { + var said = Messages.For( + locale.Tag, + "age.dark." + rung, + new Dictionary<string, object?>(StringComparer.Ordinal) { ["count"] = 3 }) + .ToLowerInvariant(); + + foreach (var cause in new[] { "offline", "down", "uptime", "crashed", "dead" }) + { + await Assert.That(said).DoesNotContain(cause); + } + } + } + } + + [Test] + public async Task AnAgeCarriesTheInstantItIsRelativeTo() + { + var html = await Render.ComponentAsync<Moment>(new() + { + ["At"] = new DateTimeOffset(2026, 8, 17, 14, 2, 0, TimeSpan.Zero), + ["Now"] = Now, + }); + + await Assert.That(html).Contains("<time datetime=\"2026-08-17T14:02:00Z\""); + await Assert.That(html).Contains("title=\"19m ago, 17 Aug 2026 14:02 UTC\""); + await Assert.That(Render.Words(html)).Contains(">19m</time>"); + } + + [Test] + public async Task TheAbsoluteTimeIsSpokenWhereAReaderIsWeighingOneFactAndNotWhereTheyAreScanning() + { + // A listing row that announced the absolute time of every age would be the wall of + // repetition this whole pass exists to remove; a game page's field, where the age is the + // fact being weighed, is exactly where it belongs. + var parameters = new Dictionary<string, object?> + { + ["At"] = new DateTimeOffset(2026, 8, 17, 14, 2, 0, TimeSpan.Zero), + ["Now"] = Now, + }; + + var scanning = await Render.ComponentAsync<Moment>(parameters); + var weighing = await Render.ComponentAsync<Moment>( + new(parameters) { ["Spoken"] = true }); + + await Assert.That(scanning).DoesNotContain("sr-only"); + await Assert.That(Render.Words(weighing)).Contains("17 Aug 2026 14:02 UTC"); + } + + /// <summary> + /// Which of the age and the instant comes first is a language's decision. + /// </summary> + /// <remarks> + /// It was a comma in an interpolated string, which is a word order chosen for English and + /// offered to nobody else. + /// </remarks> + [Test] + public async Task TheTitleIsAMessageAndNotAComma() + { + await Assert.That(Messages.Source("time.title")).IsEqualTo("{age}, {stamp}"); + + var said = Messages.For( + English, + "time.title", + new Dictionary<string, object?>(StringComparer.Ordinal) + { + ["age"] = Relative.Ago(English, TimeSpan.FromMinutes(19)), + ["stamp"] = Dates.Stamp(English, new DateTimeOffset(2026, 8, 17, 14, 2, 0, TimeSpan.Zero)), + }); + + await Assert.That(said).IsEqualTo("19m ago, 17 Aug 2026 14:02 UTC"); + } + + /// <summary> + /// <b>MSSP, not <c>Mssp</c>.</b> + /// </summary> + /// <remarks> + /// The chip's tooltip interpolated <see cref="FieldSource"/> straight into a sentence and told + /// readers a value arrived "via Mssp" — an acronym mis-cased by C#'s naming convention, in a + /// string no translator could reach. Upper-casing at the call site would have fixed four letters + /// and left the next member to leak the same way, which is what the exhaustive map prevents. + /// </remarks> + [Test] + public async Task AProtocolAcronymIsSpeltAsTheProtocolSpellsIt() + { + await Assert.That(WebProvenance.Via(English, FieldSource.Mssp)).IsEqualTo("MSSP"); + await Assert.That(WebProvenance.Via(English, FieldSource.Who)).IsEqualTo("WHO"); + await Assert.That(WebProvenance.Via(English, FieldSource.Info)).IsEqualTo("INFO"); + await Assert.That(WebProvenance.Via(English, FieldSource.I3)).IsEqualTo("I3"); + + // And an acronym is the same acronym in every language: it is evidence, not a word. + foreach (var locale in Languages) + { + await Assert.That(WebProvenance.Via(locale.Tag, FieldSource.Mssp)) + .IsEqualTo("MSSP") + .Because($"{locale.Tag} translated a protocol name"); + } + } + + /// <summary>Every source has a display name, and none of them is the enum member.</summary> + [Test] + public async Task NoFieldSourceReachesAReaderAsItsEnumMember() + { + foreach (var source in Enum.GetValues<FieldSource>()) + { + var shown = WebProvenance.Via(English, source); + + await Assert.That(string.IsNullOrWhiteSpace(shown)) + .IsFalse() + .Because($"{source} has no display name"); + + // I3 is the one member whose C# spelling is already the reader's — an initial and a + // digit, with no casing for PascalCase to get wrong. Every other member's ToString + // would be a defect on the page: Mssp for an acronym, Who for a command, I3Mudlist for + // two words and a missing space. + if (source is FieldSource.I3) + { + continue; + } + + await Assert.That(shown) + .IsNotEqualTo(source.ToString()) + .Because($"{source} is reaching the page as its own C# spelling"); + } + } + + /// <summary> + /// The chip's tooltip, whole: machine voice through, our words from the bundle. + /// </summary> + /// <remarks> + /// "last confirmed" is the load-bearing phrase and it is a fact about our crawl. It is the day + /// <em>we</em> last saw the value, and it must never be read as a day the game did anything. + /// </remarks> + [Test] + public async Task TheChipTooltipSaysTheSourceTheDateAndWhoseFactTheDateIs() + { + var confirmed = new DateTimeOffset(2026, 7, 30, 18, 0, 0, TimeSpan.Zero); + + var english = Messages.For( + English, + "chip.title", + new Dictionary<string, object?>(StringComparer.Ordinal) + { + ["value"] = "PennMUSH 1.8.8p0", + ["how"] = Messages.For(English, "provenance.game.declared"), + ["source"] = WebProvenance.Via(English, FieldSource.Mssp), + ["date"] = Dates.Stamp(English, confirmed), + }); + + await Assert.That(english) + .IsEqualTo("PennMUSH 1.8.8p0 — declared via MSSP, last confirmed 30 Jul 2026 18:00 UTC"); + + // The same tooltip asked for in German is not the same string. It was, and that is the + // defect this pass exists to close. + var german = Messages.For( + German, + "chip.title", + new Dictionary<string, object?>(StringComparer.Ordinal) + { + ["value"] = "PennMUSH 1.8.8p0", + ["how"] = Messages.For(German, "provenance.game.declared"), + ["source"] = WebProvenance.Via(German, FieldSource.Mssp), + ["date"] = Dates.Stamp(German, confirmed), + }); + + await Assert.That(german).IsNotEqualTo(english); + await Assert.That(german).Contains("MSSP"); + await Assert.That(german).Contains("PennMUSH 1.8.8p0"); + } + + /// <summary> + /// Measured, declared and owner-declared stay three words in every locale. + /// </summary> + /// <remarks> + /// The provenance tooltip is the string that says which of the two a reader is looking at, so + /// collapsing them into one word is the one failure that makes this site say something false. + /// </remarks> + [Test] + public async Task TheChipNeverCollapsesMeasuredAndDeclaredIntoOneWord() + { + string[] ids = + [ + "provenance.game.measured", + "provenance.game.declared", + "provenance.game.ownerDeclared", + ]; + + foreach (var locale in Locales.All) + { + var said = ids.Select(id => Messages.For(locale.Tag, id)).ToList(); + + await Assert.That(said.Distinct(StringComparer.Ordinal).Count()) + .IsEqualTo(ids.Length) + .Because($"{locale.Tag} said the same word for two different claims"); + } + } +}
mirror. + // + // ── the crawler strip, whose sentence was English around a localized age ────────────── + // The age used to be the only localized part, so a German reader met "crawler live · last + // probe 4m" — one German fragment inside an English line, on the one strip whose whole job + // is to let a reader discount every number above it. The age comes in as an argument + // because the ladder that builds it already localizes, and because a language that puts + // the age first has nowhere to say so if the two are concatenated. + ["crawler.live"] = "crawler live · last probe {age}", + ["crawler.quiet"] = "crawler quiet · last probe {age}", + ["crawler.noProbe"] = "no probe has finished here yet", + + // Three counters, each agreeing with its own number. English inflects none of them and + // several languages inflect all three, which is exactly the case a concatenation cannot be + // translated out of. + ["crawler.cycle.nothingDue"] = "nothing due this cycle", + ["crawler.cycle"] = "{considered, plural, one {# due} other {# due}}" + + " · {answered, plural, one {# answered} other {# answered}}" + + " · {failed, plural, one {# failed} other {# failed}}", + ["crawler.registry"] = "{targets, plural, one {# address in the registry} other {# addresses in the registry}}" + + ", {due, plural, one {# due now} other {# due now}}", + + // ── what this site says about itself where it is not this site ──────────────────────── + // The , the meta description and the Open Graph tags. A German page advertised + // itself in English to a reader, a search engine and every link preview — the three places + // a reader has least ability to check what they were told, and the one surface the demo + // banner cannot follow a link into. + // + // The wordmark is not here. "mu*index" is the site's name, machine voice like a hostname or + // a codebase string, so it arrives as {site} rather than as text a translator could edit. + ["preview.documentTitle"] = "{page} — {site}", + ["preview.site"] = "A directory of the MU* hobby — MUSHes, MUDs, MUCKs, MOOs — where every " + + "fact carries how it was obtained and how old it is.", + ["preview.demo"] = "Demo data — nothing here was measured. {description}", + ["preview.cardAlt"] = "{site} — measured, not asserted", + ["preview.cardAlt.named"] = "{title} on {site}", + + // One id per page, title and description apart: a title is a noun phrase and a description + // is a sentence, and a language that declines the first differently from the second has + // nowhere to stand if they share an id. + ["preview.title.games"] = "Games", + ["preview.title.archive"] = "The archive", + ["preview.title.rankings"] = "Rankings", + ["preview.title.ecosystem"] = "The ecosystem", + ["preview.title.reference"] = "Reference", + ["preview.title.about"] = "About", + ["preview.title.notFound"] = "Not found", + ["preview.title.random"] = "Random game", + ["preview.title.account"] = "Your games", + ["preview.title.claim"] = "Claim {game}", + + ["preview.desc.games"] = "Every MU* we have reached, faceted on what we measured: codebase, " + + "the protocols a server offered in the handshake, TLS, charset, language, and when we " + + "last got in.", + ["preview.desc.archive"] = "The games that went dark, kept. Each keeps its page, history and " + + "URL, is still probed weekly, and returns to the listing on one successful connection.", + ["preview.desc.rankings"] = "Busiest, most reachable, longest running — computed from " + + "measurements only. No votes, stars or ratings anywhere on this site.", + ["preview.desc.ecosystem"] = "Codebase share and protocol adoption across the games we " + + "measure, with what servers offer set beside what they declare. Shares, never totals.", + ["preview.desc.reference"] = "Hand-written pages on the codebases, clients and protocols of " + + "the MU* hobby, cross-linked to counts taken from the crawl.", + ["preview.desc.about"] = "How this catalogue is built: what the crawler does, what it refuses " + + "to do, and how to make it stop.", + ["preview.desc.notFound"] = "No game at this address. Nothing here is ever deleted, so a game " + + "that once lived at this URL still does — check the spelling.", + ["preview.desc.random"] = "One game from the catalogue, chosen at random and never the same " + + "one twice.", + ["preview.desc.account"] = "The listings you have claimed, and what a claim lets you change.", + ["preview.desc.claim"] = "Prove you run this game by publishing a token where only its " + + "operator could put it.", + + // A game's own preview. The name, the host and the port stay machine voice; everything the + // site says *about* them is here. The unknown count is a sentence and never a zero (rule 4), + // and the archived plate says "still probed" because that is §7.5's promise. + ["preview.game.archived"] = "Archived — last reachable {age}, and still probed", + ["preview.game.archived.undated"] = "Archived, and still probed", + ["preview.game.countUnknown"] = "Player count unknown — the game answers, and publishes no " + + "number we can read", + ["preview.game.count"] = "{count, plural, one {# player} other {# players}}, {how} {age}", + + // ── the plain mirror's feed headings and home counts ────────────────────────────────── + // Uppercased at the call site like every other plain heading, so the id carries the words + // and not the casing — a locale whose script has no case gets the words unharmed. + // The empty states are not here: feed.nothingNew and its two siblings already exist and are + // already translated, and the graphical cards and this mirror say the same sentence. + ["feed.plain.newlyDiscovered"] = "Newly discovered", + ["feed.plain.wentDark"] = "Went dark", + ["feed.plain.cameBack"] = "Came back", + + // The four figures the front page tiles carry, as whole sentences rather than a number + // glued to a tile label — the mirror has no tiles to put a label beside. English inflects + // only the first; the other three carry both branches anyway, because a language that + // inflects them has nowhere else to say so. + ["home.plain.known"] = "{count, plural, one {# game known} other {# games known}}", + ["home.plain.connectedNow"] = "{count, plural, one {# connected now (measured)} other {# connected now (measured)}}", + ["home.plain.uncounted"] = "{count, plural, one {# answering, uncounted} other {# answering, uncounted}}", + ["home.plain.archived"] = "{count, plural, one {# archived, still probed} other {# archived, still probed}}", + + // ── THE REFERENCE SECTION'S CHROME ──────────────────────────────────────────────────── + // ═════════════════════════════════════════════════════════════════════════════════════ + // + // Appended as one marked block on purpose: another surface is appending to this file at the + // same time, and a block at the end is a merge that adds rather than one that collides. + // + // **The articles are not here.** The Markdown under content/reference is a set of documents + // somebody owns, translated as documents and by their own route; a bundle holds strings the + // site says, and an article is not one. What is here is the furniture round them — and it + // says nothing about what language an article is in, because that is the content layer's + // fact to state and it is changing. + // + // **Every acronym stays out of the bundle.** MSSP, GMCP, TTYPE, CHARSET and the codebase and + // client names arrive as arguments or sit in the markup. This is the surface most *about* + // machine voice and so the one where a locale is likeliest to reach for a word — and a + // translated TTYPE is destroyed evidence rather than a localized string. + ["reference.title"] = "Reference", + ["reference.lede"] = "What the codebases are, what the clients do, and what the protocols " + + "mean. Written by hand and kept in the repository beside the crawler — not a wiki, and " + + "there is nothing on this page to edit. Every {number} here is a different thing: it " + + "comes from the catalogue and is recomputed each time you load the page.", + + // The emphasised word, placed by the message rather than wrapped round a fragment of it: a + // language that stresses a different word in that clause has somewhere to move the emphasis + // to, and the bundle still holds no markup. Sentences.Place walks it. + ["reference.lede.number"] = "number", + ["reference.plain.lede"] = "Hand-written, single-author, and versioned in git. The prose here " + + "is ours; every number beside it was measured by the crawler and is recomputed on each " + + "request. This is not a wiki, and there is no way to edit it from this page.", + + // The four section headings, and the four kind words beside a page's title. One English word + // does both jobs for three of them — a heading over a list, and a label naming what one page + // is — and inflected languages routinely need different forms, so they are eight ids. + ["reference.section.orientation"] = "Start here", + ["reference.section.codebase"] = "Codebases", + ["reference.section.client"] = "Clients", + ["reference.section.protocol"] = "Protocols", + ["reference.kind.orientation"] = "orientation", + ["reference.kind.codebase"] = "codebase", + ["reference.kind.client"] = "client", + ["reference.kind.protocol"] = "protocol", + + // A gap in a hand-written section is work nobody has done, and the page says so rather than + // implying something was taken away — §7.5 in the one place a reader could reasonably read a + // deletion into a 404. + ["reference.notFound.title"] = "Not found", + ["reference.notFound.body"] = "No reference page here. This section is hand-written, so a gap " + + "is work nobody has done rather than something that was removed — {index}.", + ["reference.notFound.index"] = "see what there is", + + // ── a codebase page's measured half ─────────────────────────────────────────────────── + // The zero is a sentence and never a bare 0 (rule 4): none identified is a statement about + // this crawler's reach, and reads as a statement about the codebase unless it is spelled out. + ["reference.codebase.heading"] = "Games running it", + ["reference.codebase.none"] = "We have not identified any yet. That is a fact about what this " + + "crawler has measured, not about what exists — a game we have not reached, or whose " + + "codebase we could not read, is not counted here.", + ["reference.codebase.listed"] = "{count, plural, one {# listed} other {# listed}}", + ["reference.codebase.archived"] = "{count, plural, one {# archived} other {# archived}}", + + // Rule 1, in three words, and its own id in every register it appears in. It must not soften + // into "verified" or "from our data": what it says is that nothing on this line was taken + // from anybody's self-description. + ["reference.measuredNeverAsserted"] = "measured, never asserted", + ["reference.codebase.note"] = "Counted from the catalogue on this request, over the same " + + "filter the link above carries — so this number and that listing are one query and " + + "cannot drift apart.", + + // The protocol list is machine voice and arrives whole, joined by the markup. A locale + // orders the sentence round it and never touches what is inside. + ["reference.codebase.offered"] = "offered in their handshakes: {protocols}", + + // ── a protocol page's measured half ─────────────────────────────────────────────────── + ["reference.protocol.heading"] = "Measured adoption", + ["reference.protocol.none"] = "Nothing measured yet.", + ["reference.protocol.share"] = "of {listed, plural, one {# listed game} other {# listed games}} — {percent}", + + // **The remainder is not a measurement and the page has to say so.** A locale that shortened + // this to "the rest do not support it" would file our own unread handshakes as a fact about + // somebody's game, which is rule 5 exactly. The sentence names both halves of what the + // remainder mixes, and a translation has to keep them two. + ["reference.protocol.remainder"] = "The games not counted here are not games without the " + + "protocol. A game is counted when we observed its server offering the option in a " + + "handshake; the rest are servers that did not offer it to us and servers whose " + + "handshake we have not read, and we cannot tell you which.", + ["reference.protocol.caption"] = "Games observed offering {protocol} in a handshake, by the " + + "codebase we identified them as running.", + ["reference.protocol.column.codebase"] = "codebase", + ["reference.protocol.column.offered"] = "offered it", + ["reference.protocol.column.identified"] = "identified", + ["reference.seeAlso"] = "See also", + + // ── the client capability matrix, which is documentation rather than measurement ─────── + // Every cell here is somebody's documentation read by us, and the table is a sibling of the + // game pages' measured matrix rather than a copy of it. The caveat carries that difference + // and takes the unknown word as an argument, so the sentence and the cells cannot disagree + // about which word they are quoting. + ["reference.capabilities.heading"] = "Capabilities", + ["reference.capabilities.established"] = "{count, plural, one {# of {total} established from the project's own documentation} other {# of {total} established from the project's own documentation}}", + ["reference.capabilities.caveat"] = "Read off each project's own documentation, not measured " + + "by us — a client has no handshake for us to observe. \"{unknown}\" means we looked and " + + "did not establish it. It never means no.", + ["reference.capabilities.caption"] = "Client capabilities, each read off the project's own " + + "documentation. Unknown means we did not establish it, and never that the client lacks " + + "it.", + ["reference.capabilities.column.documented"] = "documented", + ["reference.capabilities.column.source"] = "source", + ["reference.capabilities.noSource"] = "we did not find one", + + // Three words for three states, and the third is the one that matters. An unknown is what we + // looked for and did not establish; a locale that rendered it as the no beside it would turn + // our reading into the project's absence. They are ids of their own rather than the game + // pages' capability words, which answer a different question — offered on a wire. + ["reference.capability.yes"] = "yes", + ["reference.capability.no"] = "no", + ["reference.capability.unknown"] = "unknown", + + // ── the plain mirror's own wording ──────────────────────────────────────────────────── + // Where the plain surface says the same sentence as the page it mirrors it shares the id + // above; these are the lines it words differently because it has no panel round them. + ["reference.plain.runsOn"] = "Runs on: {platforms}", + ["reference.plain.codebase.heading"] = "Games we have identified as running this codebase", + ["reference.plain.codebase.none"] = "None yet. That is a statement about what we have " + + "measured, not about what exists — a game we have not reached, or whose codebase we " + + "could not read, is not counted here.", + ["reference.plain.codebase.counts"] = "{listed, plural, one {# listed} other {# listed}}, {archived, plural, one {# archived} other {# archived}}", + ["reference.plain.codebase.offered"] = "Measured in their handshakes: {protocols}", + ["reference.plain.codebase.nothingOffered"] = "Nothing was offered in any handshake we have " + + "read from them.", + ["reference.plain.protocol.share"] = "{offering} of {listed, plural, one {# listed game} other {# listed games}} were observed offering it ({percent})", + ["reference.plain.protocol.byCodebase"] = "By codebase, of the games we identified", + ["reference.plain.protocol.row"] = "{offering} of {identified} offered it", + ["reference.plain.capabilities.unknown"] = "{count, plural, one {# of {total} rows is unknown} other {# of {total} rows are unknown}}: we did not find the project's own documentation saying either way. A short honest table beats a long guessed one.", + + // ══ APPENDED BLOCK: the owner dashboard and the claim flow ════════════════════════════ + // The last two page surfaces that were still English whatever language they were asked + // for. Kept as one block at the end of the dictionary so that a parallel append merges + // additively rather than interleaving. + // + // These surfaces address a game's operator in the second person — "your games", "a game + // you run" — and the English says "you" deliberately. A translator should render them in + // whatever second person their language uses for one person being addressed directly; the + // catalogue surfaces are impersonal and these are not. Do not neutralise them. + // + // Nothing here may blur the two provenances. An owner's answer is a DECLARATION stored + // beside what the crawler measured; a claim is a fact about our records and never a + // measurement of the game; an opt-out is honoured and is never a deletion. Where a + // sentence carries that distinction it is called out on the id. + + // ── the dashboard's frame ───────────────────────────────────────────────────────────── + // account.title is its own id rather than preview.title.account's: a heading is the first + // line of a document and a title is a noun phrase in a browser tab, and the languages that + // decline the two differently have nowhere to stand if they share one. + ["account.title"] = "Your games", + ["account.noDatabase"] = "Accounts need a database behind them, and this site is running on " + + "the demo fixture.", + ["account.signInButton"] = "Sign in", + ["account.signedInAs"] = "Signed in as {name}.", + ["account.signOut"] = "Sign out", + + // The empty state's sentence places its own link and its own quoted control, so the word + // order belongs to the language rather than to the markup. {claimControl} names the button + // on a game's page; it is a separate id from game.claim because that one is the control's + // own label and this one is prose quoting it — a language that capitalises or declines a + // quoted control differently has nowhere else to say so. + ["account.empty.body"] = "You have not claimed anything yet. Find your game in {listing} " + + "and press {claimControl} on its page.", + ["account.empty.listing"] = "the listing", + ["account.empty.claimControl"] = "claim this game", + + // ── the one banner a POST comes back with ───────────────────────────────────────────── + // Resigning is not deleting: §7.5 keeps the record, and §8.4 lets the same person prove + // control again. A translation that renders this as "removed" or "deleted" contradicts the + // rule the sentence exists to state. + ["account.resigned.lead"] = "Given up.", + ["account.resigned.body"] = "The record of it is kept, and you can prove control again any " + + "time by publishing a fresh token.", + ["account.saved.lead"] = "Saved.", + + // One sentence per write. The game's name is its own bytes and arrives as an argument, so + // a language that puts the subject elsewhere can move it; {game} is never translated. + // These say what WE did — stopped republishing, stopped dialling, took out of the listing — + // and never that anything about the game was measured or removed. + ["account.saved.thatGame"] = "That game", + ["account.saved.fields"] = "{game}'s page now shows it as owner-declared.", + ["account.saved.screenHidden"] = "We have stopped republishing {game}'s connect screen. The " + + "page says so plainly rather than leaving a hole.", + ["account.saved.screenShown"] = "{game}'s connect screen is on its page again.", + ["account.saved.crawlStopped"] = "We have stopped dialling {game}, on every address we have " + + "for it. Its page keeps everything measured before you asked.", + ["account.saved.crawlResumed"] = "We are dialling {game} again, from its next turn in the " + + "schedule.", + ["account.saved.unlisted"] = "{game} is out of the listing, the rankings and the daily " + + "figure. Its page and every URL it has ever had go on answering.", + ["account.saved.relisted"] = "{game} is back in the listing. One probe that answers is all " + + "it needs to be measured again.", + + // Refused out loud (§8.5). {field} is a registry field name — machine voice, an argument. + // The second sentence is the site's whole claim and may not soften: nobody edits a + // measurement, and that includes us. + ["account.refused.lead"] = "{field} was not changed.", + ["account.refused.tooLong"] = "These are one-line answers; {max} characters is the most we " + + "store.", + ["account.refused.measured"] = "That field is measured. A claim lets you add what MSSP has " + + "no room for; it never lets anybody edit what we observed, and that includes us.", + + // ── a claimed game's block ──────────────────────────────────────────────────────────── + // "verified {date}" is a fact about OUR record — the date we read this owner's token — and + // not a measurement of the game. Two ids rather than a suffix glued on, because the beacon + // note lands in a different place in most languages. + ["account.claimed.heading"] = "Claimed", + ["account.claim.verified"] = "verified {date}", + ["account.claim.verifiedAndSeen"] = "verified {date}, token last seen {seen}", + ["account.claim.mssp"] = "check your MSSP", + ["account.claim.coOwners"] = "{count, plural," + + " one {Also owned by {names} — who verified a token of their own.}" + + " other {Also owned by {names} — each having verified a token of their own.}}", + ["account.coOwner.unnamed"] = "another account", + + // The badge snippet. {unknown} and {archived} are the badge's own bytes rather than words + // to translate: a badge answers one address to everybody, so a German page promising a + // German word would be promising something the image never says. {json} is an acronym and + // machine voice for the same reason every protocol name here is. + ["account.badge.summary"] = "put your player count on your own site", + ["account.badge.carries"] = "The badge carries the count and when we measured it, because a " + + "number with no age is the thing this site exists to replace.", + ["account.badge.states"] = "It says {unknown} rather than nought when we could not count, " + + "and {archived} if the game stops answering.", + ["account.badge.json"] = "There is {json} too, if you would rather draw your own.", + + // ── the audit log ───────────────────────────────────────────────────────────────────── + // The vocabulary is ClaimEventKind's, spelled for a person. beaconMissing reads as an + // observation and never as a warning: a probe not reading the token happens for reasons + // that have nothing to do with the owner, and absence never revokes (§8.4). + ["account.history.summary"] = "history", + ["account.event.issued"] = "token issued", + ["account.event.reissued"] = "token issued again", + ["account.event.verified"] = "verified — we read your token", + ["account.event.beaconSeen"] = "token still published", + ["account.event.beaconMissing"] = "token not read this time", + ["account.event.revoked"] = "claim given up", + ["account.event.expired"] = "token expired unused", + ["account.event.counterClaimed"] = "another account proved control and took the game over", + ["account.event.checkRequested"] = "check requested", + + // Giving up a claim. {word} is the literal an operator types into the box and is never + // translated — a translated confirmation word would be one the form does not accept. + ["account.resign.summary"] = "give up this claim", + ["account.resign.confirm"] = "Type {word} to confirm. Nothing is deleted and you can prove " + + "control again by publishing a fresh token; the game stays claimed if anybody else " + + "owns it.", + ["account.resign.button"] = "Give up {game}", + + // ── waiting on a token, and the passkeys ────────────────────────────────────────────── + ["account.pending.heading"] = "Waiting on a token", + ["account.pending.dates"] = "token issued {issued}, good until {expires}", + ["account.passkeys.heading"] = "Passkeys", + ["account.passkey.unnamed"] = "unnamed", + ["account.passkey.added"] = "added {date}", + ["account.passkey.addedOneDevice"] = "added {date} · on one device only", + ["account.passkey.single"] = "This passkey lives on one device. If you lose it you can " + + "still get back in by publishing a fresh token on your game, but a second passkey is " + + "quicker.", + ["account.passkey.add"] = "Add another passkey", + + // ── claiming a game you run ─────────────────────────────────────────────────────────── + // claim.title is its own id rather than preview.title.claim's, for the reason account.title + // is: a heading and a browser-tab title are not the same noun phrase. + ["claim.noGame"] = "No such game", + ["claim.title"] = "Claim {game}", + ["claim.noDatabase"] = "Claiming needs a database behind it, and this site is running on " + + "the demo fixture.", + ["claim.needAccount"] = "You need an account first. It takes a passkey and a name.", + ["claim.signIn"] = "Sign in or create an account", + ["claim.yourGames"] = "Your games", + + // The game already has owners, and nothing in a probe can tell joining from taking over — + // both publish the identical line. So the choice is made here, in words, before the token + // exists. The owner count agrees inside the message rather than being chosen in C#. + ["claim.hasOwners"] = "{count, plural," + + " one {This game already has an owner who proved control of the server.}" + + " other {This game already has # owners who proved control of the server.}}" + + " You can prove it too — the test is the same either way — but we need to know what " + + "you mean by it, because we cannot tell from the token.", + ["claim.join.button"] = "I run it too — add me as an owner", + ["claim.join.note"] = "Everyone keeps their claim. This is two people running one game.", + ["claim.assume.button"] = "I have taken it over — transfer it to me", + ["claim.assume.note"] = "{count, plural," + + " one {When your token verifies, the existing claim is revoked and the game is yours.}" + + " other {When your token verifies, the existing claims are revoked and the game is yours.}}" + + " They will see why in their own history. Nothing is deleted, and they can prove " + + "control again the same way you are about to.", + + // Verified. Two ids and not one with the channel slotted in: "from the game's MSSP report" + // and "from the connect screen" take different prepositions and different cases in the + // languages that have them, and a single sentence with a {channel} hole has nowhere to + // say so. Both state what WE read, which is a fact about our records. + ["claim.verified.lead"] = "Verified.", + ["claim.verified.viaMssp"] = "We read your token from the game's MSSP report on {date}.", + ["claim.verified.viaScreen"] = "We read your token from the connect screen on {date}.", + ["claim.verified.leaveIt"] = "Leave the token where it is. It doubles as an identity " + + "signal, so this game stays recognisable if it moves host or changes name. Removing " + + "it will not un-claim you.", + + // Publishing the token. Every variable name, file name and prefix below is machine voice + // and arrives as an argument: a translated MSSP variable is one no crawler reads. + ["claim.publish"] = "Publish this token anywhere the game shows it to an anonymous " + + "connection. The next probe picks it up, which proves you can write to that server.", + ["claim.transfer.lead"] = "This is a transfer.", + ["claim.transfer.body"] = "{count, plural," + + " one {When we read this token, the current owner's claim on this game is revoked and it becomes yours.}" + + " other {When we read this token, the current owners' claims on this game are revoked and it becomes yours.}}", + ["claim.either.heading"] = "Either of these will do", + ["claim.mssp.heading"] = "An MSSP variable", + ["claim.mssp.note"] = "In {codebase} that is a line in {file}; every codebase with MSSP has " + + "an equivalent.", + ["claim.mssp.aliases"] = "{aliases} are accepted too.", + ["claim.screen.heading"] = "A line on the connect screen", + ["claim.screen.note"] = "Anywhere in the screen, and colour codes around it are fine.", + ["claim.then.heading"] = "Then", + ["claim.then.body"] = "We check on the ordinary crawl schedule. This token is good until " + + "{date}. Come back any time; nothing needs writing down.", + + // Asking us to look sooner moves the game to the front of the queue; the crawler still + // does the dialling on its own schedule and under CRAWL DELAY. Neither sentence may + // promise a probe, because pressing a button here is our decision and not a measurement. + ["claim.check.button"] = "Look sooner", + ["claim.check.can"] = "Brings your game to the front of the queue. We dial on our own " + + "schedule, so this is sooner rather than now.", + ["claim.check.rationed"] = "Just asked. Try again in a few minutes — it is rationed because " + + "it dials a real server sooner than we would have.", + + // ── what a claim actually grants (the owner panel, §8.5 and §11) ────────────────────── + // Everything on this panel is enrichment. An owner's answer is DECLARED: stored under its + // own field source beside whatever the crawler measured, shown with its age, and it never + // replaces, hides or silences a measurement. A translation that lets "you told us" read as + // "we measured" breaks the one rule the whole site rests on. + ["owner.declare.heading"] = "What only you can tell us about {game}", + ["owner.declare.lede"] = "These are the things MSSP has no field for. They appear on your " + + "game's page as {declared}, with the date you last confirmed them, beside what we " + + "measured — never instead of it. Nothing measured can be edited from here, by you or " + + "by us.", + ["owner.field.declared"] = "declared {age}. Empty this box to withdraw it — the record of " + + "what it said is kept either way.", + ["owner.save"] = "Save what you declared", + + ["owner.override.heading"] = "What {game} reports, and what you would rather we showed", + ["owner.override.lede"] = "Your MSSP is what every crawler reads, and we go on showing it " + + "beside anything you put here — an answer of yours does not hide one of your game's.", + ["owner.override.nothingMeasured"] = "Nothing measured can be edited from here: not a " + + "player count, not a capability, not an hour of reachability.", + ["owner.override.fixItThere"] = "If a line below is wrong in your {file}, fixing it there " + + "fixes it everywhere.", + ["owner.report.value"] = "your game reports {value}, confirmed {age}", + ["owner.report.none"] = "your game reports nothing here", + ["owner.rename.note"] = "Changing the name changes what {game} is listed as and the " + + "address of its page. The old address goes on working for ever — every URL this game " + + "has ever had redirects to its current one — and clearing the box hands the name back " + + "to whatever your MSSP says.", + + ["owner.screen.heading"] = "Your connect screen", + ["owner.screen.suppressed"] = "We are not republishing it. The page says so plainly rather " + + "than leaving a hole, and the crawler goes on reading it — it is how we recognise " + + "your game if it moves.", + ["owner.screen.show"] = "Show it again", + ["owner.screen.shown"] = "We show it because your server sends it to every anonymous " + + "connection. If you would rather we did not, say so and we stop. We will not ask why.", + ["owner.screen.stop"] = "Stop showing our connect screen", + + // §11. An opt-out is honoured, never a deletion — and the empty hours it leaves may not be + // given a cause, because "you asked us to stop" is OUR fact and not a measurement of the + // game (rule 5, rule 2). {ourFact} is placed by the message so a language can put the + // emphasised clause where it belongs. + ["owner.crawl.heading"] = "Being crawled", + ["owner.crawl.stopped"] = "We have stopped. Nothing on {game} is dialled, and the page " + + "keeps everything measured before you asked — the empty hours name no cause, because " + + "{ourFact} is our fact and not a measurement of your game.", + ["owner.crawl.ourFact"] = "you asked us to stop", + ["owner.crawl.resume"] = "Start crawling us again", + ["owner.crawl.standing"] = "This one came from your own server rather than from here — " + + "{routes}. To be crawled again, stop publishing it; we will hear that on the next " + + "cycle.", + ["owner.crawl.route.mssp"] = "your MSSP report publishes {variable}", + ["owner.crawl.route.dns"] = "a {label} TXT record asks us to stop", + ["owner.crawl.route.recorded"] = "a request we recorded", + // Neither state, and shown as neither: rounding this to "stopped" would tell an owner we + // had left them alone while we went on dialling the port that is still open. + ["owner.crawl.partial"] = "We have stopped on {stopped} and are still dialling {dialling}. " + + "That is usually a port added after the opt-out.", + ["owner.crawl.stopAll"] = "Stop on every address too", + ["owner.crawl.dialling"] = "We dial {game} on a schedule and read what any anonymous " + + "connection is shown. If you would rather we did not, say so and we stop — within " + + "one cycle, on every address we have for you, and we will not ask why.", + ["owner.crawl.selfService"] = "Nothing already measured is deleted: your page keeps its " + + "history and its URL, and one probe after you take this back starts it again. You " + + "can also say it without us, in your own config — {mssp} in MSSP, or a {dns} TXT " + + "record — and we honour those whether or not anybody has ever claimed the game here.", + ["owner.crawl.stop"] = "Stop crawling us", + + // Migration 0025's second decision, and a second one rather than a stronger version of the + // first. Nothing is deleted here either: the page answers, every URL it ever had still + // redirects to it, and it stops being somewhere a reader arrives by browsing. + ["owner.listing.heading"] = "Being listed", + ["owner.listing.unlisted"] = "{game} is out of the listing, out of the rankings and out of " + + "the daily figure. Its page and every URL it has ever had go on answering, and " + + "everything measured before you asked is still on it. Nothing was deleted; it is " + + "simply not somewhere a reader arrives by browsing.", + ["owner.listing.relist"] = "Put us back in the listing", + ["owner.listing.probeRelists"] = "One probe that answers does this too. While your opt-out " + + "stands we do not dial, so nothing will — but the day you take it back, the address " + + "comes up within a week and the probe that gets an answer puts you back. You do not " + + "have to ask us twice.", + ["owner.listing.mayUnlist"] = "We have stopped dialling you, and your page is still in the " + + "listing with what we measured before that. If you would rather it were not, say so " + + "and it comes out — of the listing, the rankings and the daily figure.", + ["owner.listing.reversible"] = "Nothing is deleted and nothing breaks: the page answers, " + + "every URL it has ever had still redirects to it, and anyone you send there sees it. " + + "It stops being somewhere a reader can arrive by browsing. Reversible from here, and " + + "by any probe that answers after you take your opt-out back.", + ["owner.listing.unlist"] = "Take us out of the listing too", + // ══ END APPENDED BLOCK ════════════════════════════════════════════════════════════════ + + // ══ WHAT WE COULD MEASURE ═════════════════════════════════════════════════════════════ + // The handoff's last panel group: two independent switches over the two reasons a listing + // row carries no number. Every string here describes *our* reach and none of them describes + // a game, which is rule 5 — the note exists because the gesture these controls offer is the + // one most likely to be read as a claim about the games it removes. + ["facet.group.measure"] = "what we could measure", + + // The design's own sentence, with its first clause made true of the control that shipped: + // the panel's rows are tri-state, so hiding is the "−" rather than an untick. The second + // clause is the load-bearing one and is carried verbatim. + ["facet.measure.note"] = "Hiding these takes them out of your listing; it does not mean the " + + "game is empty.", + + // Named for what we did and never for what the game is. "could not count" is a fact about + // our parsers meeting a dialect; "no players" would be that same fact filed in somebody + // else's public record. + ["facet.group.uncounted"] = "could not count", + ["facet.group.unreachable"] = "could not reach", + + // What the chip says when a reader has dropped one of the two. Deliberately not "not + // uncounted": a double negative reads as an assertion about the games, and this is an + // assertion about the listing. Two ids carrying one English sentence, because they are two + // different facts and a language that inflects will not spell them the same way. + ["facet.excluded.uncounted"] = "hidden from this listing", + ["facet.excluded.unreachable"] = "hidden from this listing", + + // The plain surface's own key to its left column. It drew "only these" and "anything but + // these" with one star until these two switches arrived, whose ordinary gesture is the + // second — so the surface with the least else to go on was the one that could not show the + // third state at all. + ["facet.plain.marks"] = "In the left column, * is a value this listing is filtered to and - " + + "is one it is filtered against. Both are choices in the query, not facts about a game.", + // ══ END WHAT WE COULD MEASURE ═════════════════════════════════════════════════════════ + }; + + /// <summary> + /// The bundles, by tag. + /// </summary> + /// <remarks> + /// <para> + /// <b>Only English is complete, and that is the honest state of this work rather than a gap in + /// it.</b> The order of work is explicit: the glossary is written and human-translated before a + /// reader is sent anywhere, and no locale is offered until it is. What ships here is the + /// machinery, exercised end to end by the two test-only bundles below. + /// </para> + /// <para> + /// <c>qps-ploc</c> is a pseudolocale — accented and expanded English. It is not a language and + /// nobody claims it is one; it exists so routing, fallback, plural selection and the nav's 1.4x + /// width budget are all exercised by something real. <c>ru-x-canary</c> is machine-translated, + /// never shipped, and deliberately incomplete: it is what makes a missing plural form fail a + /// build instead of reaching a reader. + /// </para> + /// </remarks> + private static readonly Dictionary<string, Dictionary<string, string>> TestBundles = + new(StringComparer.OrdinalIgnoreCase) + { + // Every message, mechanically transformed. Generated rather than typed so it cannot + // fall behind the source bundle it is derived from. + ["qps-ploc"] = English.ToDictionary(e => e.Key, e => Pseudo(e.Value), StringComparer.Ordinal), + + // Three plural categories, and one message that is missing its `few` and `many` branches + // on purpose. That omission is what the completeness test turns into a build failure. + ["ru-x-canary"] = new(StringComparer.Ordinal) + { + ["facet.count"] = "{count, plural, one {# игра} few {# игры} many {# игр} other {# игры}}", + ["listing.total"] = "{count, plural, one {# игра} other {# игр}}, каждый факт измерен.", + ["provenance.count.measured"] = "измерена", + ["provenance.game.measured"] = "измерено", + ["provenance.capability.measured"] = "измерены", + ["kicker.measured"] = "ИЗМЕРЕНО", + }, + }; + + /// <summary> + /// One message, rendered for a locale — or the English, where that locale has no approved one. + /// </summary> + /// <remarks> + /// The fallback is silent to the reader and loud to the build. A reader meeting one English + /// phrase inside a German sentence learns something true: this particular claim has not been + /// translated yet. What must never happen is the other thing — a smoothed-over approximation of + /// a locked string, which teaches them something false and gives them no way to tell. + /// </remarks> + public static string For(string tag, string id, IReadOnlyDictionary<string, object?>? args = null) + { + ArgumentNullException.ThrowIfNull(tag); + ArgumentNullException.ThrowIfNull(id); + + var pattern = Pattern(tag, id) + ?? throw new KeyNotFoundException($"No message '{id}' in any bundle, including English."); + + return IcuMessage.Format(pattern, tag, args); + } + + /// <summary> + /// The same, with the arguments named inline rather than built into a dictionary first. + /// </summary> + /// <remarks> + /// <b>One helper, because there were eleven.</b> Every component that renders more than one + /// message had grown its own private wrapper turning a tuple array into an ordinal dictionary + /// and calling <see cref="For"/> — the same six lines, copied, and twice inside one file. + /// <c>StringComparer.Ordinal</c> is the part that mattered and the part a twelfth copy would + /// eventually get wrong: an argument name is a token in a pattern, matched exactly, and a + /// dictionary that folded case would answer a lookup the parser never asked for. + /// </remarks> + public static string Say(string tag, string id, params (string Key, object? Value)[] args) + { + ArgumentNullException.ThrowIfNull(args); + + return For(tag, id, args.ToDictionary(a => a.Key, a => a.Value, StringComparer.Ordinal)); + } + + /// <summary>A count and its noun, agreeing — the commonest call by a long way.</summary> + public static string Count(string tag, int count) => + For(tag, "facet.count", new Dictionary<string, object?> { ["count"] = count }); + + /// <summary>The raw pattern a locale would use, English included, or null.</summary> + public static string? Pattern(string tag, string id) + { + ArgumentNullException.ThrowIfNull(tag); + ArgumentNullException.ThrowIfNull(id); + + return Own(tag, id) ?? English.GetValueOrDefault(id); + } + + /// <summary>Whether a locale carries its own text for an id, rather than falling back.</summary> + public static bool HasOwn(string tag, string id) => Own(tag, id) is not null; + + /// <summary> + /// What a locale itself says for an id — from its resx, or from a test bundle — or null. + /// </summary> + /// <remarks> + /// <c>ResourceNotFound</c> is the load-bearing check. <see cref="IStringLocalizer"/> answers a + /// missing key with the key itself rather than with null, so a lookup that trusted the string it + /// got back would render <c>facet.count</c> to a reader and call it a translation. + /// </remarks> + private static string? Own(string tag, string id) + { + if (TestBundles.TryGetValue(tag, out var bundle)) + { + return bundle.GetValueOrDefault(id); + } + + // The source language reads its own compiled-in copy: it is the fallback for every other + // locale, and a fallback that depends on a satellite assembly having loaded is not one. + if (string.Equals(tag, Locales.SourceTag, StringComparison.OrdinalIgnoreCase)) + { + return English.GetValueOrDefault(id); + } + + if (Culture(tag) is not { } culture) + { + return null; + } + + // The resource set for this culture *alone*, with tryParents off — which is the whole point. + // GetString walks up to the neutral resources, so it answers the English for a locale that + // has translated nothing, and a caller asking "does this locale carry its own words for this + // id" would be told yes for every id in the site. The fallback is deliberate elsewhere and + // wrong here. + // + // A ResourceManager rather than IStringLocalizer, and that is not a rejection of the pattern + // — IStringLocalizer *is* a ResourceManager with the culture read off the ambient thread. + // This lookup is static and is called from Razor markup, from the plain-text renderer and + // from headless component tests alike, and it is handed the locale rather than inferring + // one; the DI wrapper would mean it could not answer at all without a host behind it, which + // is most of where it is called from. AddMuiLocalization still registers the injected form + // for anything that wants it. + try + { + return Resources.GetResourceSet(culture, createIfNotExists: true, tryParents: false) + ?.GetString(id); + } + catch (MissingManifestResourceException) + { + return null; + } + } + + /// <summary> + /// The satellite assemblies, keyed off the marker type so the base name cannot drift. + /// </summary> + /// <remarks> + /// One per culture, compiled by the SDK from <c>Resources/Messages.<culture>.resx</c> with + /// no <c><EmbeddedResource></c> entries in the project file. A culture with no satellite + /// answers null here rather than throwing, which is the fallback path. + /// </remarks> + private static readonly ResourceManager Resources = new(typeof(Web.Resources.Messages)); + + private static CultureInfo? Culture(string tag) + { + try + { + return CultureInfo.GetCultureInfo(tag); + } + catch (CultureNotFoundException) + { + return null; + } + } + + /// <summary>The source text for an id, which is what a resx has to agree with.</summary> + public static string? Source(string id) => English.GetValueOrDefault(id); + + + + /// <summary>Every id the site says, in the order the source bundle declares them.</summary> + public static IReadOnlyList<string> Ids { get; } = [.. English.Keys]; + + /// <summary>The ids a locale has not translated yet.</summary> + /// <remarks> + /// The release checklist's own question, answerable from code rather than from a spreadsheet. + /// A locale may not be moved to <see cref="LocaleStatus.Shipped"/> while any <em>locked</em> id + /// is in this list — which is the rule the completeness test enforces. + /// </remarks> + public static IReadOnlyList<string> MissingFor(string tag) => + [.. Ids.Where(id => !HasOwn(tag, id))]; + + /// <summary> + /// Accented, expanded English — a language nobody speaks, which is the point. + /// </summary> + /// <remarks> + /// Two jobs. The accents prove a string came through the pipeline rather than being hard-coded + /// in a template, and the padding gives every string the 1.4x width the handoff says to review + /// a locale at — German and Russian run 30–40% longer on short UI nouns, and the nav bar was + /// tightened to fit English exactly. The ICU syntax is stepped over rather than transformed: + /// mangling a branch keyword would make the message unparseable and prove nothing. + /// </remarks> + private static string Pseudo(string pattern) + { + var b = new System.Text.StringBuilder(pattern.Length * 2); + var depth = 0; + + foreach (var c in pattern) + { + if (c == '{') { depth++; b.Append(c); continue; } + if (c == '}') { depth--; b.Append(c); continue; } + + // Inside braces the text is syntax — argument names and branch keywords — and accenting + // it would make the message unparseable, which proves nothing. + b.Append(depth > 0 ? c : Accent(c)); + } + + // The padding goes outside the braces so no argument name is touched. + return "⟦" + b + "⟧"; + } + + private static char Accent(char c) => c switch + { + 'a' => 'á', 'e' => 'é', 'i' => 'í', 'o' => 'ó', 'u' => 'ú', 'n' => 'ñ', 'c' => 'ç', + 'A' => 'Á', 'E' => 'É', 'I' => 'Í', 'O' => 'Ó', 'U' => 'Ú', 'N' => 'Ñ', 'C' => 'Ç', + _ => c, + }; +} diff --git a/src/MUI.Web/Localization/PluralOperands.cs b/src/MUI.Web/Localization/PluralOperands.cs new file mode 100644 index 0000000..ebaf00c --- /dev/null +++ b/src/MUI.Web/Localization/PluralOperands.cs @@ -0,0 +1,106 @@ +using System.Globalization; + +namespace MUI.Web.Localization; + +/// <summary> +/// The six values a CLDR plural rule is written in terms of. +/// </summary> +/// <param name="N">The absolute value of the number.</param> +/// <param name="I">Its integer digits.</param> +/// <param name="V">How many fraction digits are <em>visible</em>, trailing zeros included.</param> +/// <param name="W">How many are visible with trailing zeros removed.</param> +/// <param name="F">The visible fraction digits as an integer, trailing zeros included.</param> +/// <param name="T">The same with trailing zeros removed.</param> +/// <param name="E">The compact-decimal exponent, which is zero for everything this site formats.</param> +/// <remarks> +/// <para> +/// <b>Visible is the load-bearing word, and it is why this type exists rather than an <c>int</c>.</b> +/// In English <c>1</c> is <c>one</c> and <c>1.0</c> is <c>other</c> — "1.0 stars" is correct and +/// "1.0 star" is not — and the two are the same quantity. A rule cannot tell them apart from the +/// value alone; it needs to know how the number was <em>written</em>. That is what <c>v</c> and +/// <c>f</c> carry, and it is the single most commonly missed thing in a hand-rolled plural +/// implementation. +/// </para> +/// <para> +/// Every count this site pluralises is an integer, so <c>v</c> is zero throughout and none of this +/// changes an answer today. It is here because a plural implementation that only works for integers +/// is one that silently gives the wrong form the first time somebody formats a rate or an average, +/// and because the rules below are transcribed from CLDR in the operands CLDR states them in — a +/// transcription into a different vocabulary is a transcription that cannot be checked. +/// </para> +/// <para> +/// <b>These are absolute values and this type cannot print a number.</b> CLDR takes the absolute +/// value to choose a category, never to display one, so a <c>Format</c> here would drop the sign of +/// every number it was handed — and it did, along with the group separator, which put "1234 games" +/// in a sentence beside "1,234" in the column. Rendering belongs to <see cref="IcuMessage"/>, which +/// still holds the signed value the caller passed. +/// </para> +/// </remarks> +public readonly record struct PluralOperands( + decimal N, + long I, + int V, + int W, + long F, + long T, + int E) +{ + /// <summary>The operands of an integer, where every fractional one is zero.</summary> + public static PluralOperands Of(long value) + { + var n = Math.Abs(value); + + return new PluralOperands(n, n, 0, 0, 0, 0, 0); + } + + /// <summary> + /// The operands of a number as it will actually be written. + /// </summary> + /// <param name="value">The quantity.</param> + /// <param name="visibleFractionDigits"> + /// How many fraction digits the rendered string shows, or null to read them off the value. + /// </param> + /// <remarks> + /// The parameter is what makes <c>1</c> and <c>1.0</c> different: a caller formatting to two + /// decimal places has to say so, because by the time the number reaches here as a + /// <see cref="decimal"/> the trailing zeros it will be printed with are a fact about the format + /// string and not about the value. + /// </remarks> + public static PluralOperands Of(decimal value, int? visibleFractionDigits = null) + { + var n = Math.Abs(value); + var i = (long)decimal.Truncate(n); + + // decimal keeps its own scale, so 1.50m already knows it has two fraction digits. That is + // the right default: a caller who did not say otherwise gets the digits the value carries. + var scale = (byte)((decimal.GetBits(n)[3] >> 16) & 0x7f); + var v = visibleFractionDigits ?? scale; + + var fractional = n - i; + var f = v == 0 ? 0L : (long)decimal.Round(fractional * Pow10(v), 0, MidpointRounding.AwayFromZero); + + // w and t are v and f with trailing zeros taken off: 1.50 has v=2, f=50, w=1, t=5. + var w = v; + var t = f; + + while (w > 0 && t % 10 == 0) + { + t /= 10; + w--; + } + + return new PluralOperands(n, i, v, w, f, t, E: 0); + } + + private static decimal Pow10(int power) + { + var result = 1m; + + for (var at = 0; at < power; at++) + { + result *= 10m; + } + + return result; + } +} diff --git a/src/MUI.Web/Localization/PluralRules.cs b/src/MUI.Web/Localization/PluralRules.cs new file mode 100644 index 0000000..be62fe8 --- /dev/null +++ b/src/MUI.Web/Localization/PluralRules.cs @@ -0,0 +1,402 @@ +namespace MUI.Web.Localization; + +/// <summary>The CLDR plural categories.</summary> +/// <remarks> +/// Six of them exist across all languages; no single language uses more than five, and most use one +/// or two. <see cref="Other"/> is the one every language has and the only one a message must +/// declare. +/// </remarks> +public enum PluralCategory +{ + Zero, + One, + Two, + Few, + Many, + Other, +} + +/// <summary>Cardinal counts one thing; ordinal ranks it.</summary> +/// <remarks> +/// They are different rule sets and getting them from one table is a bug rather than a shortcut. In +/// English the cardinal rule has two forms — <em>1 game, 2 games</em> — and the ordinal rule has +/// four — <em>1st, 2nd, 3rd, 4th</em> — and neither can produce the other's answers. +/// </remarks> +public enum PluralKind +{ + Cardinal, + Ordinal, +} + +/// <summary> +/// Which plural form a number takes, per locale, per kind. +/// </summary> +/// <remarks> +/// <para> +/// <b>Transcribed from CLDR 46's plural charts, in the operands CLDR states them in.</b> Each rule +/// below is written the way the chart writes it — <c>i = 1 and v = 0</c> rather than +/// <c>count == 1</c> — so it can be checked against the source line by line. A transcription into a +/// different vocabulary is a transcription nobody can verify. +/// </para> +/// <para> +/// <b>Hand-written rather than taken from a library, and that is a judgement rather than a +/// preference.</b> The .NET options are thin: ICU4N is an alpha pinned to ICU 60, whose CLDR data +/// predates several of the rules below, and the MessageFormat ports are 0.1.x forks of an abandoned +/// project. Neither is a dependency worth the credibility of a site whose entire product is being +/// right about what it knows. The cost is that this table has to be maintained against CLDR when a +/// locale is added, which is why <see cref="LocalesCovered"/> exists and is asserted against the +/// locales the site actually commits to. +/// </para> +/// <para> +/// <b>An unlisted language answers <see cref="PluralCategory.Other"/>.</b> That is correct for a +/// language with one form and safe for one whose rule is not written here — the message still +/// renders, in the form every language has. What stops that being a silent wrong answer is the test +/// that walks every offered locale and refuses one this table does not cover. +/// </para> +/// </remarks> +public static class PluralRules +{ + /// <summary>The CLDR release these rules were transcribed from.</summary> + public const string CldrVersion = "46"; + + /// <summary> + /// The languages this table states a rule for, cardinal or ordinal. + /// </summary> + /// <remarks> + /// The gate on adding a locale: a tag whose language is not here falls back to <c>other</c> for + /// every count, which is right for Chinese and wrong for German. Asserted in the tests against + /// <see cref="Locales.All"/>. + /// </remarks> + public static IReadOnlyList<string> LocalesCovered { get; } = + [ + "en", "de", "nl", "sv", "da", "no", "fi", "et", "el", "it", "es", "fr", "pt", + "ru", "uk", "be", "pl", "cs", "sk", "hi", "th", "vi", "id", "ms", "ja", "ko", "zh", + "tr", "he", "ar", "qps", + ]; + + /// <summary>The category <paramref name="count"/> takes.</summary> + public static PluralCategory Of(string tag, long count, PluralKind kind = PluralKind.Cardinal) => + Of(tag, PluralOperands.Of(count), kind); + + /// <summary>The category a number written a particular way takes.</summary> + public static PluralCategory Of(string tag, PluralOperands o, PluralKind kind = PluralKind.Cardinal) + { + ArgumentNullException.ThrowIfNull(tag); + + var language = Language(tag); + + return kind is PluralKind.Ordinal ? Ordinal(language, o) : Cardinal(language, o); + } + + private static PluralCategory Cardinal(string language, PluralOperands o) => language switch + { + // one: i = 1 and v = 0 + // + // The v = 0 is why this file carries operands at all: "1.0 stars" is other, not one, and + // the two quantities are equal. `qps` is the pseudolocale and is English underneath, so it + // has to select exactly what English selects or it exercises the wrong branch. + "en" or "de" or "nl" or "sv" or "fi" or "et" or "qps" => + o is { I: 1, V: 0 } ? PluralCategory.One : PluralCategory.Other, + + // one: n = 1 + // + // <b>Not the line above, and 1.0 is the whole of the difference.</b> Greek, Norwegian, + // Spanish and Turkish say `one` for it where English says `other`. All four had been given + // English's rule, because on the integers the two agree — and the integers are all anybody + // checks. Turkish had `n = 0..1` besides, which is a real CLDR rule belonging to Akan and + // Punjabi and puts zero in the form Turkish keeps for exactly one thing. + "el" or "no" or "tr" => o.N == 1m ? PluralCategory.One : PluralCategory.Other, + + // one: n = 1 or t != 0 and i = 0,1 + // + // Danish alone, and the only `one` in this table that reaches a quantity which is not 1: + // "0,5 stjerne" rather than "0,5 stjerner". Copied from Swedish, it loses that clause + // silently — the integers, again, agree. + "da" => o.N == 1m || (o.T != 0 && o.I is 0 or 1) + ? PluralCategory.One + : PluralCategory.Other, + + // one: i = 1 and v = 0 (it) + // n = 1 (es) + // i = 0,1 (fr, pt) + // many: e = 0 and i != 0 and i % 1000000 = 0 and v = 0 (all four) + // + // The Romance millions rule — "un millón de juegos", with the preposition the other forms + // do not take. fr and pt carried it; it and es were folded into English's rule above and so + // had no `many` at all, which is a form a translator would have been asked to write and + // never given anywhere to put. + "it" => Millions(o) ? PluralCategory.Many + : o is { I: 1, V: 0 } ? PluralCategory.One + : PluralCategory.Other, + + "es" => Millions(o) ? PluralCategory.Many + : o.N == 1m ? PluralCategory.One + : PluralCategory.Other, + + "fr" or "pt" => Millions(o) ? PluralCategory.Many + : o.I is 0 or 1 ? PluralCategory.One + : PluralCategory.Other, + + // one: v = 0 and i % 10 = 1 and i % 100 != 11 + // few: v = 0 and i % 10 = 2..4 and i % 100 != 12..14 + // many: v = 0 and (i % 10 = 0 or i % 10 = 5..9 or i % 100 = 11..14) + // other: everything with a visible fraction + // + // 11 and 12 end in 1 and 2 and take neither `one` nor `few`. A rule written from the first + // three examples anybody tries is wrong for both. + "ru" or "uk" => o.V != 0 ? PluralCategory.Other + : (o.I % 10, o.I % 100) switch + { + (1, not 11) => PluralCategory.One, + (2 or 3 or 4, not (12 or 13 or 14)) => PluralCategory.Few, + _ => PluralCategory.Many, + }, + + // one: n % 10 = 1 and n % 100 != 11 + // few: n % 10 = 2..4 and n % 100 != 12..14 + // many: n % 10 = 0 or n % 10 = 5..9 or n % 100 = 11..14 + // + // Belarusian states Russian's shape on `n` rather than on `i` with `v = 0`, so 1.0 is + // `one` here and `other` there. It had been folded in with Russian above: right for every + // integer, wrong for every number written with a decimal place. + "be" => !Whole(o) ? PluralCategory.Other + : (o.I % 10, o.I % 100) switch + { + (1, not 11) => PluralCategory.One, + (2 or 3 or 4, not (12 or 13 or 14)) => PluralCategory.Few, + _ => PluralCategory.Many, + }, + + // one: i = 1 and v = 0 + // few: v = 0 and i % 10 = 2..4 and i % 100 != 12..14 + // many: v = 0 and i != 1 and (i % 10 = 0..1 or i % 10 = 5..9 or i % 100 = 12..14) + "pl" => o.V != 0 ? PluralCategory.Other + : o.I == 1 ? PluralCategory.One + : (o.I % 10, o.I % 100) switch + { + (2 or 3 or 4, not (12 or 13 or 14)) => PluralCategory.Few, + _ => PluralCategory.Many, + }, + + // one: i = 1 and v = 0 + // few: i = 2..4 and v = 0 + // many: v != 0 + "cs" or "sk" => o.V != 0 ? PluralCategory.Many + : o.I switch + { + 1 => PluralCategory.One, + 2 or 3 or 4 => PluralCategory.Few, + _ => PluralCategory.Other, + }, + + // one: i = 0 or n = 1 + "hi" => o.I == 0 || o.N == 1m ? PluralCategory.One : PluralCategory.Other, + + // one: i = 1 and v = 0 or i = 0 and v != 0 + // two: i = 2 and v = 0 + // + // The `many` this rule used to carry for multiples of ten was withdrawn from CLDR before + // 46, and so was every one of Hebrew's ordinals. A table still stating them selects a + // branch nobody was ever asked to translate — which the `other` fallback cannot catch, + // because the branch is present and simply wrong. + "he" => o switch + { + { I: 1, V: 0 } or { I: 0, V: not 0 } => PluralCategory.One, + { I: 2, V: 0 } => PluralCategory.Two, + _ => PluralCategory.Other, + }, + + // zero: n = 0 one: n = 1 two: n = 2 + // few: n % 100 = 3..10 many: n % 100 = 11..99 + // + // Six categories, which is the count the review cites — and Arabic is render-only here, so + // this rule exists for correctness of the table rather than for a locale that ships. + "ar" => o.N switch + { + 0 => PluralCategory.Zero, + 1 => PluralCategory.One, + 2 => PluralCategory.Two, + _ when !Whole(o) => PluralCategory.Other, + _ => (o.I % 100) switch + { + >= 3 and <= 10 => PluralCategory.Few, + >= 11 and <= 99 => PluralCategory.Many, + _ => PluralCategory.Other, + }, + }, + + // No plural inflection at all. This is exactly why Chinese cannot be the locale a string + // architecture is validated against: it agrees with any shape, including a wrong one. + "zh" or "ja" or "ko" or "th" or "vi" or "id" or "ms" => PluralCategory.Other, + + _ => PluralCategory.Other, + }; + + private static PluralCategory Ordinal(string language, PluralOperands o) => language switch + { + // one: n % 10 = 1 and n % 100 != 11 (1st, 21st, but 11th) + // two: n % 10 = 2 and n % 100 != 12 (2nd, 22nd, but 12th) + // few: n % 10 = 3 and n % 100 != 13 (3rd, 23rd, but 13th) + "en" or "qps" => !Whole(o) ? PluralCategory.Other + : (o.I % 10, o.I % 100) switch + { + (1, not 11) => PluralCategory.One, + (2, not 12) => PluralCategory.Two, + (3, not 13) => PluralCategory.Few, + _ => PluralCategory.Other, + }, + + // one: n % 10 = 1,2 and n % 100 != 11,12 (1:a and 2:a, then 3:e — and 11:e, 12:e) + "sv" => !Whole(o) ? PluralCategory.Other + : (o.I % 10, o.I % 100) switch + { + (1 or 2, not (11 or 12)) => PluralCategory.One, + _ => PluralCategory.Other, + }, + + // one: n = 1 (1er / 1re, then 2e, 3e …) + "fr" => o.N == 1m ? PluralCategory.One : PluralCategory.Other, + + // few: n % 10 = 3 and n % 100 != 13 + "uk" => !Whole(o) ? PluralCategory.Other + : (o.I % 10, o.I % 100) switch + { + (3, not 13) => PluralCategory.Few, + _ => PluralCategory.Other, + }, + + // few: n % 10 = 2,3 and n % 100 != 12,13 + "be" => !Whole(o) ? PluralCategory.Other + : (o.I % 10, o.I % 100) switch + { + (2 or 3, not (12 or 13)) => PluralCategory.Few, + _ => PluralCategory.Other, + }, + + // many: n = 11,8,80,800 + "it" => Whole(o) && o.I is 11 or 8 or 80 or 800 ? PluralCategory.Many : PluralCategory.Other, + + // one: n = 1 two: n = 2,3 few: n = 4 many: n = 6 + "hi" => !Whole(o) ? PluralCategory.Other + : o.I switch + { + 1 => PluralCategory.One, + 2 or 3 => PluralCategory.Two, + 4 => PluralCategory.Few, + 6 => PluralCategory.Many, + _ => PluralCategory.Other, + }, + + // one: n = 1 + "vi" or "ms" => o.N == 1m ? PluralCategory.One : PluralCategory.Other, + + // Every other language this site knows about has one ordinal form: German, Spanish, Danish, + // Norwegian, Greek, Dutch, Finnish, Estonian, Polish, Czech, Slovak, Russian, Portuguese, + // Thai, Indonesian, Chinese, Japanese, Korean, Turkish, Arabic — and Hebrew, whose six-way + // ordinal table CLDR withdrew before 46. + _ => PluralCategory.Other, + }; + + /// <summary>The Romance millions rule, which CLDR states identically for all four languages.</summary> + /// <remarks> + /// <c>many: e = 0 and i != 0 and i % 1000000 = 0 and v = 0</c>. <c>e</c> is the compact-decimal + /// exponent and is zero for everything this site formats, so the clause CLDR adds for compact + /// notation cannot be reached from here. + /// </remarks> + private static bool Millions(PluralOperands o) => + o is { E: 0, V: 0, I: not 0 } && o.I % 1_000_000 == 0; + + /// <summary>Whether the number is a whole one, which is all a CLDR range can ever match.</summary> + /// <remarks> + /// <c>n % 100 = 3..10</c> is a range over integers: 3.5 is not in it, however its integer part + /// reads. Testing <c>i</c> in its place gives every fraction the category of the whole number + /// below it — the wrong form for a rate and for an average alike, and invisible in a table + /// exercised only with counts. + /// </remarks> + private static bool Whole(PluralOperands o) => o.N == o.I; + + /// <summary> + /// Every category a locale can produce, which is what a message has to cover. + /// </summary> + /// <remarks> + /// The assertion the Russian canary is for. A message declaring only <c>one</c> and <c>other</c> + /// is complete in English and silently wrong in Russian, where a count of two takes a form + /// neither branch supplies — and a wrong plural does not read as a typo to a native speaker, it + /// reads as illiterate. + /// </remarks> + public static IReadOnlyList<PluralCategory> CategoriesOf( + string tag, PluralKind kind = PluralKind.Cardinal) + { + ArgumentNullException.ThrowIfNull(tag); + + // Derived by exercising the rule rather than by keeping a second table beside it, so the + // two cannot disagree. The probes cover every boundary the rules above test — the teens, + // the tens, the millions, and a fraction, which is the case that separates `one` from + // `other` in English. + var seen = new List<PluralCategory>(); + + foreach (var probe in Probes) + { + var category = Of(tag, probe, kind); + + if (!seen.Contains(category)) + { + seen.Add(category); + } + } + + return seen; + } + + /// <summary>Numbers that between them reach every branch of every rule above.</summary> + private static IReadOnlyList<PluralOperands> Probes { get; } = + [ + .. new long[] + { + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 20, 21, 22, 23, 24, 25, + 80, 100, 101, 102, 103, 111, 112, 113, 800, 1000, 1_000_000, 2_000_000, + }.Select(n => PluralOperands.Of(n)), + + // A visible fraction, which is `other` in English and in Russian and `many` in Czech. + PluralOperands.Of(1.0m, visibleFractionDigits: 1), + PluralOperands.Of(1.5m, visibleFractionDigits: 1), + ]; + + /// <summary>The keyword a message branch is spelled with.</summary> + public static string Keyword(PluralCategory category) => category switch + { + PluralCategory.Zero => "zero", + PluralCategory.One => "one", + PluralCategory.Two => "two", + PluralCategory.Few => "few", + PluralCategory.Many => "many", + _ => "other", + }; + + /// <summary>Whether a word is one of the six category keywords.</summary> + public static bool IsCategory(string word) => + word is "zero" or "one" or "two" or "few" or "many" or "other"; + + /// <summary>Whether this table states a rule for a tag's language at all.</summary> + public static bool Covers(string tag) + { + ArgumentNullException.ThrowIfNull(tag); + + return LocalesCovered.Contains(Language(tag), StringComparer.Ordinal); + } + + /// <summary> + /// The language subtag, which is what a plural rule is keyed on. + /// </summary> + /// <remarks> + /// <c>zh-Hans</c> and <c>zh-Hant</c> pluralise identically, and so do <c>ru</c> and the CI + /// canary's <c>ru-x-canary</c> — the script and the private-use subtag change which glyphs are + /// drawn and which bundle is read, never how a number agrees. + /// </remarks> + private static string Language(string tag) + { + var dash = tag.IndexOf('-', StringComparison.Ordinal); + + return (dash < 0 ? tag : tag[..dash]).ToLowerInvariant(); + } +} diff --git a/src/MUI.Web/Localization/Sentences.cs b/src/MUI.Web/Localization/Sentences.cs new file mode 100644 index 0000000..a55cf20 --- /dev/null +++ b/src/MUI.Web/Localization/Sentences.cs @@ -0,0 +1,100 @@ +namespace MUI.Web.Localization; + +/// <summary> +/// A sentence whose word order belongs to the locale and whose markup belongs to the site. +/// </summary> +/// <remarks> +/// <para> +/// Some sentences have a link or an emphasised word inside them. Gluing English round an anchor +/// gives a language that wants the link first, or a different preposition before it, nowhere to say +/// so; formatting the anchor <em>into</em> the string and trusting the result through a +/// <c>MarkupString</c> would make every bundle a place a tag could be put. So the message places a +/// marker, this walks it, and what a translator writes is text either way. +/// </para> +/// <para> +/// The markers are private-use code points, which no translation contains by accident and no script +/// the site offers uses. They are assigned in the order the slots are passed and never appear in +/// what a reader is shown: a marker that survives into the output is a slot the message did not +/// place, and the run for it is simply absent — which is visible rather than silent. +/// </para> +/// <para> +/// This was two copies before it was one file. The random-game empty state placed two links this +/// way and the reference section needed the same thing for its own two sentences, at which point the +/// marker constant, the walk and the "translator writes no markup" argument were about to exist +/// twice. +/// </para> +/// </remarks> +public static class Sentences +{ + /// <summary>The first marker. One code point per slot, upwards from here.</summary> + private const char Marker = '\uE000'; + + /// <summary> + /// The most slots one sentence may place. Well past anything readable, and a bound rather than + /// an open range so a stray private-use character in a translation cannot be read as a slot. + /// </summary> + private const int MaxSlots = 8; + + /// <summary>One piece of a sentence: plain text, or the text of a named slot.</summary> + /// <param name="Text">What the reader sees, already in their language.</param> + /// <param name="Slot"> + /// The argument name the message placed, or null for the prose between the slots. The caller + /// switches on this to decide what markup goes round the run. + /// </param> + public sealed record Run(string Text, string? Slot); + + /// <summary> + /// A message, split into the runs its markup renders — the slots in the order the + /// <em>message</em> puts them, which is the locale's order and not this call's. + /// </summary> + public static IReadOnlyList<Run> Place(string tag, string id, params (string Name, string Text)[] slots) + { + ArgumentNullException.ThrowIfNull(slots); + ArgumentOutOfRangeException.ThrowIfGreaterThan(slots.Length, MaxSlots); + + var sentence = Messages.For(tag, id, slots + .Select((slot, i) => (slot.Name, Value: (object?)((char)(Marker + i)).ToString())) + .ToDictionary(s => s.Name, s => s.Value, StringComparer.Ordinal)); + + var runs = new List<Run>(); + var run = new System.Text.StringBuilder(); + + foreach (var c in sentence) + { + var slot = c - Marker; + + if (slot < 0 || slot >= slots.Length) + { + run.Append(c); + continue; + } + + if (run.Length > 0) + { + runs.Add(new Run(run.ToString(), null)); + run.Clear(); + } + + runs.Add(new Run(slots[slot].Text, slots[slot].Name)); + } + + if (run.Length > 0) + { + runs.Add(new Run(run.ToString(), null)); + } + + return runs; + } + + /// <summary> + /// The same sentence with the slots substituted rather than marked — for the plain surface, + /// which has no markup to put round them and must still say every word the page does. + /// </summary> + public static string Flat(string tag, string id, params (string Name, string Text)[] slots) + { + ArgumentNullException.ThrowIfNull(slots); + + return Messages.For(tag, id, slots.ToDictionary( + s => s.Name, s => (object?)s.Text, StringComparer.Ordinal)); + } +} diff --git a/src/MUI.Web/MUI.Web.csproj b/src/MUI.Web/MUI.Web.csproj index 2da38cb..4320d0f 100644 --- a/src/MUI.Web/MUI.Web.csproj +++ b/src/MUI.Web/MUI.Web.csproj @@ -30,6 +30,15 @@ <ItemGroup> <EmbeddedResource Include="..\..\content\reference\*.md" Link="Content\reference\%(Filename)%(Extension)" /> + + <!-- + And one directory per locale beside it. The English is the source and stays at the top level; + a translation is the same article with the same slug in another language, so it is named the + same and filed under its tag. The resource name that results carries the tag as a segment, + which is what the library keys on. + --> + <EmbeddedResource Include="..\..\content\reference\*\*.md" + Link="Content\reference\%(RecursiveDir)%(Filename)%(Extension)" /> </ItemGroup> <!-- diff --git a/src/MUI.Web/Reference/ClientCapabilities.cs b/src/MUI.Web/Reference/ClientCapabilities.cs index 3552ffa..9f666ac 100644 --- a/src/MUI.Web/Reference/ClientCapabilities.cs +++ b/src/MUI.Web/Reference/ClientCapabilities.cs @@ -1,4 +1,5 @@ using MUI.Catalog; +using MUI.Web.Localization; namespace MUI.Web.Reference; @@ -65,13 +66,20 @@ .. Rows.Select(row => document.Capabilities } /// <summary> - /// The word for a state. Never a glyph on its own, and <em>unknown</em> is spelled out rather - /// than left blank: a blank cell reads as a no to a human exactly as it does to a parser. + /// The word for a state, in the reader's language. Never a glyph on its own, and + /// <em>unknown</em> is spelled out rather than left blank: a blank cell reads as a no to a human + /// exactly as it does to a parser. /// </summary> - public static string Word(CapabilityState state) => state switch + /// <remarks> + /// Three ids rather than three literals, and they are this table's own rather than the game + /// pages' capability words: those answer <em>was it offered on a wire</em> and these answer + /// <em>does the project's documentation say so</em>. A locale that let the third collapse into + /// the second would publish our own failure to find a page as the client lacking the feature. + /// </remarks> + public static string Word(string tag, CapabilityState state) => Messages.For(tag, state switch { - CapabilityState.Present => "yes", - CapabilityState.Absent => "no", - _ => "unknown", - }; + CapabilityState.Present => "reference.capability.yes", + CapabilityState.Absent => "reference.capability.no", + _ => "reference.capability.unknown", + }); } diff --git a/src/MUI.Web/Reference/ReferenceLibrary.cs b/src/MUI.Web/Reference/ReferenceLibrary.cs index 9d99183..8f878b0 100644 --- a/src/MUI.Web/Reference/ReferenceLibrary.cs +++ b/src/MUI.Web/Reference/ReferenceLibrary.cs @@ -1,6 +1,8 @@ using System.Collections.Frozen; using System.Reflection; +using MUI.Web.Localization; + namespace MUI.Web.Reference; /// <summary> @@ -54,15 +56,81 @@ private ReferenceLibrary(IReadOnlyList<ReferenceDocument> documents) /// </summary> public static ReferenceLibrary Shipped { get; } = Load(typeof(ReferenceLibrary).Assembly); - public static ReferenceLibrary Load(Assembly assembly) + /// <summary> + /// The library a reader in this locale gets: their language where we have it, English where we + /// do not. + /// </summary> + /// <remarks> + /// <para> + /// <b>A translation supplies prose and nothing else.</b> The document handed out is the English + /// record with its title, summary and body replaced — so the slug, the kind, the + /// <c>see-also</c> graph, the protocol name and the upstream link come from one file in one + /// language, whatever a translator does to their copy. A slug is a URL and a URL has one page; + /// this makes that true by construction rather than by asking forty files to agree. + /// </para> + /// <para> + /// An article with no translation is served in English rather than withheld. The alternative is + /// a reference section that is missing pages in four languages, and a missing page is worse + /// than a page in the wrong language: one of them still answers the question. + /// </para> + /// </remarks> + public static ReferenceLibrary For(string tag) + { + ArgumentNullException.ThrowIfNull(tag); + + return Localized.GetOrAdd(tag, static t => + { + if (string.Equals(t, Locales.SourceTag, StringComparison.OrdinalIgnoreCase)) + { + return Shipped; + } + + var translated = Load(typeof(ReferenceLibrary).Assembly, t) + .Documents.ToDictionary(d => d.Path, StringComparer.OrdinalIgnoreCase); + + return new ReferenceLibrary( + [ + .. Shipped.Documents.Select(english => + translated.TryGetValue(english.Path, out var localized) + ? english with + { + Title = localized.Title, + Summary = localized.Summary, + Body = localized.Body, + } + : english), + ]); + }); + } + + private static readonly System.Collections.Concurrent.ConcurrentDictionary<string, ReferenceLibrary> Localized = + new(StringComparer.OrdinalIgnoreCase); + + public static ReferenceLibrary Load(Assembly assembly) => Load(assembly, tag: null); + + /// <param name="tag"> + /// The locale directory to read, or null for the English articles at the top level. The two are + /// told apart by the resource name: a translation carries its tag as a segment before the file + /// name, so <c>…reference.de.protocol-mssp.md</c> is German and <c>…reference.protocol-mssp.md</c> + /// is the source. + /// </param> + public static ReferenceLibrary Load(Assembly assembly, string? tag) { ArgumentNullException.ThrowIfNull(assembly); + // MSBuild builds a manifest name out of the file's path and replaces what cannot appear in + // an identifier, so `content/reference/zh-Hans/` is embedded as `…reference.zh_Hans.…`. The + // tag is BCP-47 and its only such character is the dash. Without this, Chinese was the one + // locale whose articles loaded and were never found — three locales working is exactly the + // evidence that hides it, which is why the test below names zh-Hans rather than "a locale". + var prefix = tag is null ? ".reference." : $".reference.{tag.Replace('-', '_')}."; + var documents = new List<ReferenceDocument>(); foreach (var resource in assembly.GetManifestResourceNames() - .Where(n => n.Contains(".reference.", StringComparison.Ordinal) - && n.EndsWith(".md", StringComparison.Ordinal)) + .Where(n => n.Contains(prefix, StringComparison.OrdinalIgnoreCase) + && n.EndsWith(".md", StringComparison.Ordinal) + && (tag is not null || !IsLocalized(n))) .Order(StringComparer.Ordinal)) { using var stream = assembly.GetManifestResourceStream(resource) @@ -85,6 +153,24 @@ public static ReferenceLibrary Load(Assembly assembly) return new ReferenceLibrary([.. documents.OrderBy(d => d.Kind).ThenBy(d => d.Title, StringComparer.OrdinalIgnoreCase)]); } + /// <summary> + /// Whether a resource name names a translation rather than a source article. + /// </summary> + /// <remarks> + /// The file names carry dashes and never dots, so everything between <c>.reference.</c> and + /// <c>.md</c> is one segment for a source article and two for a translation — and the extra + /// segment is the tag. <c>zh-Hans</c> survives that because its dash is not a separator here. + /// </remarks> + private static bool IsLocalized(string resource) + { + const string Marker = ".reference."; + + var start = resource.IndexOf(Marker, StringComparison.Ordinal) + Marker.Length; + var rest = resource[start..^".md".Length]; + + return rest.Contains('.', StringComparison.Ordinal); + } + public IReadOnlyList<ReferenceDocument> OfKind(ReferenceKind kind) => [.. Documents.Where(d => d.Kind == kind)]; diff --git a/src/MUI.Web/Reference/ReferenceMarkdown.cs b/src/MUI.Web/Reference/ReferenceMarkdown.cs index 7ae0ba2..ac07394 100644 --- a/src/MUI.Web/Reference/ReferenceMarkdown.cs +++ b/src/MUI.Web/Reference/ReferenceMarkdown.cs @@ -5,6 +5,7 @@ using Markdig.Syntax.Inlines; using MUI.Web.Components; +using MUI.Web.Localization; namespace MUI.Web.Reference; @@ -34,7 +35,19 @@ public static class ReferenceMarkdown .UsePipeTables() .Build(); - public static string ToHtml(string markdown) + /// <param name="tag"> + /// The locale this article is being read in, which its own cross-references are written in. + /// </param> + /// <remarks> + /// <b>The links inside the prose are localized here and not in the page.</b> The body reaches + /// the markup as one <c>MarkupString</c>, so nothing downstream can see the anchors inside it — + /// and every article in this section cites two or three others. A German reader following "see + /// MSSP" from a German page was put back into English by a link nobody had written on a page, + /// which is the same defect as the fifty in the components and invisible to the same sweep. + /// It is done on the parsed document rather than on the rendered HTML, because a rewrite over + /// markup is a second, worse HTML parser. + /// </remarks> + public static string ToHtml(string markdown, string tag = Locales.SourceTag) { var document = Markdown.Parse(markdown ?? string.Empty, Pipeline); @@ -45,6 +58,11 @@ public static string ToHtml(string markdown) image.IsImage = false; } + foreach (var link in document.Descendants<LinkInline>()) + { + link.Url = LocaleRouting.Link(tag, link.Url); + } + foreach (var heading in document.Descendants<HeadingBlock>()) { heading.Level = Math.Min(heading.Level + 1, 6); diff --git a/src/MUI.Web/Resources/Messages.cs b/src/MUI.Web/Resources/Messages.cs new file mode 100644 index 0000000..1b134ae --- /dev/null +++ b/src/MUI.Web/Resources/Messages.cs @@ -0,0 +1,22 @@ +namespace MUI.Web.Resources; + +/// <summary> +/// The marker <see cref="Microsoft.Extensions.Localization.IStringLocalizer{T}"/> resolves against. +/// </summary> +/// <remarks> +/// <para> +/// A type with no members, whose only job is to name a resource set: <c>Messages.resx</c> and every +/// <c>Messages.<culture>.resx</c> beside it are discovered from this class's namespace and +/// compiled into satellite assemblies by the SDK, with no <c><EmbeddedResource></c> entries in +/// the project file. The same shape SharpMUSH's portal uses for its own chrome. +/// </para> +/// <para> +/// <b>The values are ICU patterns, not composite-format strings.</b> That is where this parts +/// company with the usual .NET arrangement: <c>string.Format</c> and <c>CompositeFormat</c> take +/// <c>{0}</c> and can only substitute, so "23 games" has to be assembled from a number and a noun +/// somewhere in C# — which is the concatenation the whole pipeline exists to remove. resx supplies +/// the storage, the tooling and the satellite assemblies; <see cref="Localization.IcuMessage"/> +/// supplies the grammar. +/// </para> +/// </remarks> +public sealed class Messages; diff --git a/src/MUI.Web/Resources/Messages.de.resx b/src/MUI.Web/Resources/Messages.de.resx new file mode 100644 index 0000000..0d3a0e0 --- /dev/null +++ b/src/MUI.Web/Resources/Messages.de.resx @@ -0,0 +1,2877 @@ +<?xml version="1.0" encoding="utf-8"?> +<root> + <!-- + Deutsch, machine-translated and not reviewed by a person. + + Every page served in this locale carries the ◆ notice saying so, and the locale is reachable but + never offered: nothing sends a reader here. Promotion to LocaleStatus.Shipped is a person reading + the locked strings against Glossary.cs, not an edit to a status enum. + + The values are ICU MessageFormat. Argument names in braces are code. + --> + <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata"> + <xsd:import namespace="http://www.w3.org/XML/1998/namespace" /> + <xsd:element name="root" msdata:IsDataSet="true"> + <xsd:complexType> + <xsd:choice maxOccurs="unbounded"> + <xsd:element name="data"> + <xsd:complexType> + <xsd:sequence> + <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" /> + <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" /> + </xsd:sequence> + <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" /> + <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" /> + <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" /> + <xsd:attribute ref="xml:space" /> + </xsd:complexType> + </xsd:element> + <xsd:element name="resheader"> + <xsd:complexType> + <xsd:sequence> + <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" /> + </xsd:sequence> + <xsd:attribute name="name" type="xsd:string" use="required" /> + </xsd:complexType> + </xsd:element> + </xsd:choice> + </xsd:complexType> + </xsd:element> + </xsd:schema> + <resheader name="resmimetype"><value>text/microsoft-resx</value></resheader> + <resheader name="version"><value>2.0</value></resheader> + <resheader name="reader"><value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader> + <resheader name="writer"><value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader> + <data name="facet.count" xml:space="preserve"> + <value>{count, plural, one {# Spiel} other {# Spiele}}</value> + </data> + <data name="facet.value.include" xml:space="preserve"> + <value>{value}, {count, plural, one {# Spiel} other {# Spiele}}, nur</value> + </data> + <data name="facet.value.exclude" xml:space="preserve"> + <value>{value}, {count, plural, one {# Spiel} other {# Spiele}}, ausgeschlossen</value> + </data> + <data name="facet.value.choose" xml:space="preserve"> + <value>{value}, {count, plural, one {# Spiel} other {# Spiele}}</value> + </data> + <data name="facet.any" xml:space="preserve"> + <value>{facet}: beliebig, {count, plural, one {# Spiel} other {# Spiele}}</value> + </data> + <data name="listing.total" xml:space="preserve"> + <value>{count, plural, =0 {Keine Spiele eingetragen.} one {# Spiel, jede Tatsache nennt ihre Herkunft.} other {# Spiele, jede Tatsache nennt ihre Herkunft.}}</value> + </data> + <data name="chart.basis" xml:space="preserve"> + <value>{days, plural, one {# Tag} other {# Tage}} gemessen · {probes, plural, one {# Abfrage} other {# Abfragen}}</value> + </data> + <data name="window.samples" xml:space="preserve"> + <value>{days, plural, one {# Tag} other {# Tage}} · {count, plural, one {# Zählung} other {# Zählungen}}</value> + </data> + <data name="capabilities.agree" xml:space="preserve"> + <value>{disagreeing, plural, =0 {Keine der {total} widerspricht.} one {# von {total} widerspricht dem, was das Spiel angibt.} other {# von {total} widersprechen dem, was das Spiel angibt.}}</value> + </data> + <data name="find.matching" xml:space="preserve"> + <value>{count, plural, =0 {Keine Spiele passen zu allen Antworten.} one {# Spiel passt zu allen Antworten.} other {# Spiele passen zu allen Antworten.}}</value> + </data> + <data name="find.basis" xml:space="preserve"> + <value>von {listed, plural, one {# eingetragenem Spiel} other {# eingetragenen Spielen}} · {answers, plural, =0 {keine Antworten gegeben} one {# Antwort gegeben} other {# Antworten gegeben}}</value> + </data> + <data name="find.show" xml:space="preserve"> + <value>{count, plural, one {Das eine Spiel zeigen} other {Diese # Spiele zeigen}}</value> + </data> + <data name="find.drop" xml:space="preserve"> + <value>„{answer}“ entfernen — {count, plural, one {# Spiel} other {# Spiele}}</value> + </data> + <data name="find.clear" xml:space="preserve"> + <value>Antwort zurücksetzen: {question}</value> + </data> + <data name="find.title" xml:space="preserve"> + <value>Ein Spiel finden</value> + </data> + <data name="find.kicker" xml:space="preserve"> + <value>passend zu allen Antworten</value> + </data> + <data name="find.noun" xml:space="preserve"> + <value>{count, plural, one {Spiel} other {Spiele}}</value> + </data> + <data name="find.clearAll" xml:space="preserve"> + <value>alle Antworten zurücksetzen</value> + </data> + <data name="find.startAgain" xml:space="preserve"> + <value>neu beginnen</value> + </data> + <data name="find.more" xml:space="preserve"> + <value>{count, plural, one {# weiteres} other {# weitere}}</value> + </data> + <data name="find.answersGiven" xml:space="preserve"> + <value>gegebene Antworten</value> + </data> + <data name="find.wholeListing" xml:space="preserve"> + <value>das gesamte Verzeichnis</value> + </data> + <data name="find.refused" xml:space="preserve"> + <value>diese Anfrage wurde abgelehnt</value> + </data> + <data name="find.name.label" xml:space="preserve"> + <value>ein Name, falls Sie einen haben</value> + </data> + <data name="find.name.placeholder" xml:space="preserve"> + <value>Name oder Namensteil</value> + </data> + <data name="find.name.submit" xml:space="preserve"> + <value>Nach Namen suchen</value> + </data> + <data name="find.q.band" xml:space="preserve"> + <value>Spielt gerade jemand?</value> + </data> + <data name="find.q.genre" xml:space="preserve"> + <value>Was möchten Sie spielen?</value> + </data> + <data name="find.q.lineage" xml:space="preserve"> + <value>Welche Art von Spiel?</value> + </data> + <data name="find.q.language" xml:space="preserve"> + <value>In welcher Sprache?</value> + </data> + <data name="find.q.client" xml:space="preserve"> + <value>Braucht Ihr Client etwas?</value> + </data> + <data name="find.q.dark" xml:space="preserve"> + <value>Verstummte Spiele einbeziehen?</value> + </data> + <data name="find.any.band" xml:space="preserve"> + <value>egal</value> + </data> + <data name="find.any.genre" xml:space="preserve"> + <value>beliebiges Genre</value> + </data> + <data name="find.any.lineage" xml:space="preserve"> + <value>beliebige Art</value> + </data> + <data name="find.any.language" xml:space="preserve"> + <value>beliebige Sprache</value> + </data> + <data name="find.any.client" xml:space="preserve"> + <value>egal</value> + </data> + <data name="find.dark.no" xml:space="preserve"> + <value>nein, nur aktive Spiele</value> + </data> + <data name="find.dark.yes" xml:space="preserve"> + <value>ja, auch diese zeigen</value> + </data> + <data name="find.dark.chip" xml:space="preserve"> + <value>verstummte Spiele</value> + </data> + <data name="find.protocol.tls" xml:space="preserve"> + <value>TLS — verschlüsselt, Handshake von uns abgeschlossen</value> + </data> + <data name="find.protocol.mssp" xml:space="preserve"> + <value>MSSP — Selbstauskunft des Servers</value> + </data> + <data name="find.protocol.mccp" xml:space="preserve"> + <value>MCCP — komprimierte Ausgabe</value> + </data> + <data name="find.protocol.mxp" xml:space="preserve"> + <value>MXP — anklickbare Links</value> + </data> + <data name="find.protocol.gmcp" xml:space="preserve"> + <value>GMCP — strukturierte Client-Daten</value> + </data> + <data name="find.protocol.msdp" xml:space="preserve"> + <value>MSDP — strukturierte Client-Daten</value> + </data> + <data name="find.protocol.charset" xml:space="preserve"> + <value>CHARSET — Aushandlung der Kodierung</value> + </data> + <data name="find.protocol.utf8" xml:space="preserve"> + <value>UTF-8 — nichtlateinischer Text wird dargestellt</value> + </data> + <data name="find.protocol.ttype" xml:space="preserve"> + <value>TTYPE — Client nennt seinen Typ</value> + </data> + <data name="find.protocol.atcp" xml:space="preserve"> + <value>ATCP — strukturierte Client-Daten</value> + </data> + <data name="find.protocol.msp" xml:space="preserve"> + <value>MSP — Sound-Auslöser</value> + </data> + <data name="find.protocol.eor" xml:space="preserve"> + <value>EOR — Prompt-Markierung</value> + </data> + <data name="find.protocol.other" xml:space="preserve"> + <value>{token} — im Handshake gemessen</value> + </data> + <data name="provenance.count.measured" xml:space="preserve"> + <value>gemessen</value> + </data> + <data name="provenance.game.measured" xml:space="preserve"> + <value>gemessen</value> + </data> + <data name="provenance.capability.measured" xml:space="preserve"> + <value>gemessen</value> + </data> + <data name="provenance.screen.measured" xml:space="preserve"> + <value>gemessen</value> + </data> + <data name="kicker.measured" xml:space="preserve"> + <value>gemessen</value> + </data> + <data name="provenance.count.declared" xml:space="preserve"> + <value>angegeben</value> + </data> + <data name="provenance.game.declared" xml:space="preserve"> + <value>angegeben</value> + </data> + <data name="provenance.capability.declared" xml:space="preserve"> + <value>angegeben</value> + </data> + <data name="kicker.declared" xml:space="preserve"> + <value>angegeben</value> + </data> + <data name="provenance.derived" xml:space="preserve"> + <value>abgeleitet</value> + </data> + <data name="kicker.derived" xml:space="preserve"> + <value>abgeleitet</value> + </data> + <data name="state.notMeasured" xml:space="preserve"> + <value>nicht gemessen</value> + </data> + <data name="state.uncounted" xml:space="preserve"> + <value>ungezählt</value> + </data> + <data name="state.unreachable" xml:space="preserve"> + <value>nicht erreichbar</value> + </data> + <data name="state.notCounted" xml:space="preserve"> + <value>nicht gezählt</value> + </data> + <data name="listing.count.none" xml:space="preserve"> + <value>keine Zählung</value> + </data> + <data name="listing.plain.fromHere" xml:space="preserve"> + <value>von hier aus</value> + </data> + <data name="listing.plain.archived" xml:space="preserve"> + <value>archiviert</value> + </data> + <data name="listing.plain.claimed" xml:space="preserve"> + <value>beansprucht</value> + </data> + <data name="random.empty.title" xml:space="preserve"> + <value>Nichts zur Auswahl</value> + </data> + <data name="random.empty.body" xml:space="preserve"> + <value>Kein Spiel passt zu diesem Filter. {listing} versuchen oder {archive}.</value> + </data> + <data name="random.empty.listing" xml:space="preserve"> + <value>das gesamte Verzeichnis</value> + </data> + <data name="random.empty.archive" xml:space="preserve"> + <value>das Archiv einbeziehen</value> + </data> + <data name="term.connected" xml:space="preserve"> + <value>Verbindungen</value> + </data> + <data name="term.unclaimed" xml:space="preserve"> + <value>nicht beansprucht</value> + </data> + <data name="term.claimedByOwner" xml:space="preserve"> + <value>vom Betreiber beansprucht</value> + </data> + <data name="term.stillProbed" xml:space="preserve"> + <value>wird weiter abgefragt</value> + </data> + <data name="term.typical" xml:space="preserve"> + <value>typisch</value> + </data> + <data name="term.peak" xml:space="preserve"> + <value>Spitze</value> + </data> + <data name="a11y.readAsText" xml:space="preserve"> + <value>als Text lesen</value> + </data> + <data name="a11y.plainText" xml:space="preserve"> + <value>Textfassung</value> + </data> + <data name="a11y.skipToContent" xml:space="preserve"> + <value>zum Inhalt springen</value> + </data> + <data name="a11y.asciiBanner" xml:space="preserve"> + <value>ASCII-Banner: der Verbindungsbildschirm von {game}.</value> + </data> + <data name="nav.catalogues" xml:space="preserve"> + <value>Kataloge</value> + </data> + <data name="nav.account" xml:space="preserve"> + <value>Diese Website und Ihr Konto</value> + </data> + <data name="nav.browse" xml:space="preserve"> + <value>stöbern</value> + </data> + <data name="nav.learn" xml:space="preserve"> + <value>lernen</value> + </data> + <data name="nav.thisSite" xml:space="preserve"> + <value>diese Website</value> + </data> + <data name="nav.menu" xml:space="preserve"> + <value>Menü</value> + </data> + <data name="nav.games" xml:space="preserve"> + <value>Spiele</value> + </data> + <data name="nav.find" xml:space="preserve"> + <value>finden</value> + </data> + <data name="nav.random" xml:space="preserve"> + <value>zufällig</value> + </data> + <data name="nav.archive" xml:space="preserve"> + <value>Archiv</value> + </data> + <data name="nav.reference" xml:space="preserve"> + <value>Referenz</value> + </data> + <data name="nav.ecosystem" xml:space="preserve"> + <value>Ökosystem</value> + </data> + <data name="nav.rankings" xml:space="preserve"> + <value>Ranglisten</value> + </data> + <data name="nav.about" xml:space="preserve"> + <value>über uns</value> + </data> + <data name="nav.submit" xml:space="preserve"> + <value>eintragen</value> + </data> + <data name="nav.submitGame" xml:space="preserve"> + <value>Spiel eintragen</value> + </data> + <data name="nav.signIn" xml:space="preserve"> + <value>anmelden</value> + </data> + <data name="nav.yourGames" xml:space="preserve"> + <value>Ihre Spiele</value> + </data> + <data name="theme.label" xml:space="preserve"> + <value>Design</value> + </data> + <data name="theme.auto" xml:space="preserve"> + <value>automatisch</value> + </data> + <data name="theme.light" xml:space="preserve"> + <value>hell</value> + </data> + <data name="theme.dark" xml:space="preserve"> + <value>dunkel</value> + </data> + <data name="banner.demo.lead" xml:space="preserve"> + <value>Demodaten.</value> + </data> + <data name="banner.demo" xml:space="preserve"> + <value>Es ist keine Datenbank konfiguriert, daher sind dies Beispieldaten. Nichts davon wurde gemessen.</value> + </data> + <data name="footer.allGames" xml:space="preserve"> + <value>alle Spiele</value> + </data> + <data name="footer.archive" xml:space="preserve"> + <value>Archiv</value> + </data> + <data name="footer.declaredByGame" xml:space="preserve"> + <value>vom Spiel angegeben</value> + </data> + <data name="footer.whatChanged" xml:space="preserve"> + <value>was sich geändert hat</value> + </data> + <data name="home.title" xml:space="preserve"> + <value>Ein Verzeichnis des MU*-Hobbys</value> + </data> + <data name="home.lede" xml:space="preserve"> + <value>Jede Tatsache nennt ihre Herkunft und ihr Alter: von unserem Crawler gemessen oder vom Spiel angegeben und als solche gekennzeichnet.</value> + </data> + <data name="home.search.label" xml:space="preserve"> + <value>Spiele nach Name, Thema, Codebase oder Host suchen</value> + </data> + <data name="home.search.placeholder" xml:space="preserve"> + <value>nach Name, Thema, Codebase oder Host suchen</value> + </data> + <data name="home.search.submit" xml:space="preserve"> + <value>suchen</value> + </data> + <data name="tile.gamesKnown" xml:space="preserve"> + <value>bekannte Spiele</value> + </data> + <data name="tile.connectedNow" xml:space="preserve"> + <value>jetzt verbunden</value> + </data> + <data name="tile.answeringUncounted" xml:space="preserve"> + <value>antwortend, ungezählt</value> + </data> + <data name="tile.archived" xml:space="preserve"> + <value>archiviert</value> + </data> + <data name="feed.newlyDiscovered" xml:space="preserve"> + <value>neu entdeckt</value> + </data> + <data name="feed.wentDark" xml:space="preserve"> + <value>verstummt — wird weiter abgefragt</value> + </data> + <data name="feed.cameBack" xml:space="preserve"> + <value>wieder da</value> + </data> + <data name="feed.nothingNew" xml:space="preserve"> + <value>Nichts Neues.</value> + </data> + <data name="feed.nothingDark" xml:space="preserve"> + <value>Nichts ist verstummt.</value> + </data> + <data name="feed.nothingBack" xml:space="preserve"> + <value>Nichts ist zurückgekehrt. Wir klopfen weiter.</value> + </data> + <data name="feed.live" xml:space="preserve"> + <value>live</value> + </data> + <data name="games.title" xml:space="preserve"> + <value>Spiele</value> + </data> + <data name="listing.sortedBy" xml:space="preserve"> + <value>sortiert nach {order}</value> + </data> + <data name="listing.random" xml:space="preserve"> + <value>zufällig</value> + </data> + <data name="listing.columns" xml:space="preserve"> + <value>Verbindungen · erreicht</value> + </data> + <data name="listing.fromHere" xml:space="preserve"> + <value>von hier aus</value> + </data> + <data name="listing.empty.head" xml:space="preserve"> + <value>Keine Treffer.</value> + </data> + <data name="listing.empty.hint" xml:space="preserve"> + <value>Weniger Wörter versuchen oder einen Filter entfernen.</value> + </data> + <data name="listing.clearFilters" xml:space="preserve"> + <value>Filter zurücksetzen</value> + </data> + <data name="listing.aboutCodebase" xml:space="preserve"> + <value>über {codebase}</value> + </data> + <data name="listing.never" xml:space="preserve"> + <value>nie</value> + </data> + <data name="listing.claimed" xml:space="preserve"> + <value>vom Betreiber beansprucht</value> + </data> + <data name="listing.unknownCodebase" xml:space="preserve"> + <value>Unbekannte Codebase</value> + </data> + <data name="listing.unknownCodebase.title" xml:space="preserve"> + <value>wir konnten die Codebase dieses Spiels nicht identifizieren</value> + </data> + <data name="listing.moreProtocols" xml:space="preserve"> + <value>und {count, plural, one {# weiteres} other {# weitere}}: {names}</value> + </data> + <data name="switch.order" xml:space="preserve"> + <value>Sortierung</value> + </data> + <data name="switch.window" xml:space="preserve"> + <value>Zeitraum</value> + </data> + <data name="switch.now" xml:space="preserve"> + <value>jetzt</value> + </data> + <data name="switch.typical" xml:space="preserve"> + <value>typisch</value> + </data> + <data name="switch.peak" xml:space="preserve"> + <value>Spitze</value> + </data> + <data name="switch.name" xml:space="preserve"> + <value>Name</value> + </data> + <data name="switch.reached" xml:space="preserve"> + <value>erreicht</value> + </data> + <data name="window.7" xml:space="preserve"> + <value>7 Tage</value> + </data> + <data name="window.30" xml:space="preserve"> + <value>30 Tage</value> + </data> + <data name="window.90" xml:space="preserve"> + <value>90 Tage</value> + </data> + <data name="filters.search.label" xml:space="preserve"> + <value>Spiele suchen</value> + </data> + <data name="filters.search.placeholder" xml:space="preserve"> + <value>Spiele suchen</value> + </data> + <data name="filters.summary" xml:space="preserve"> + <value>Filter</value> + </data> + <data name="filters.showing" xml:space="preserve"> + <value>angezeigt</value> + </data> + <data name="filters.clearAll" xml:space="preserve"> + <value>alle zurücksetzen</value> + </data> + <data name="filters.stopFiltering" xml:space="preserve"> + <value>— nicht mehr danach filtern</value> + </data> + <data name="facet.anyValue" xml:space="preserve"> + <value>beliebig</value> + </data> + <data name="facet.more" xml:space="preserve"> + <value>weitere Filter ({count})</value> + </data> + <data name="facet.moreValues" xml:space="preserve"> + <value>{count, plural, one {# weiterer} other {# weitere}}</value> + </data> + <data name="facet.alsoShow" xml:space="preserve"> + <value>zusätzlich zeigen</value> + </data> + <data name="facet.alsoShow.note" xml:space="preserve"> + <value>Standardmäßig aus. Keines von beiden ist ein Urteil über das Spiel.</value> + </data> + <data name="facet.archived" xml:space="preserve"> + <value>archiviert</value> + </data> + <data name="facet.adult" xml:space="preserve"> + <value>Erwachseneninhalte</value> + </data> + <data name="facet.archived.state" xml:space="preserve"> + <value>archivierte Spiele, {shown, select, true {angezeigt} other {verborgen}}</value> + </data> + <data name="facet.adult.state" xml:space="preserve"> + <value>Spiele, die Erwachseneninhalte angeben, {shown, select, true {angezeigt} other {verborgen}}</value> + </data> + <data name="facet.countsNote" xml:space="preserve"> + <value>Zahlen sind gemessene Spiele, nie Schätzungen.</value> + </data> + <data name="facet.key.summary" xml:space="preserve"> + <value>was die Kennzeichen und die Leerstellen bedeuten</value> + </data> + <data name="facet.key.blank" xml:space="preserve"> + <value>Eine Leerstelle ist eine Lücke in unserer Messung, kein Nein. Jede Facette benennt ihre eigene: nicht identifiziert, nicht angegeben, nichts ausgehandelt.</value> + </data> + <data name="facet.key.zero" xml:space="preserve"> + <value>Eine gemessene Null ist eine Zählung. Eine unbekannte Zählung ist keine Null und wird nie als solche sortiert.</value> + </data> + <data name="facet.key.openEnded" xml:space="preserve"> + <value>Offene Facetten listen ihre {count} häufigsten Werte. Der Rest ist über die Suche und über die URL erreichbar.</value> + </data> + <data name="facet.presence.note" xml:space="preserve"> + <value>Nicht angehakt heißt nicht gemessen — nicht, dass es dem Spiel fehlt.</value> + </data> + <data name="facet.group.band" xml:space="preserve"> + <value>Aktivität</value> + </data> + <data name="facet.group.seen" xml:space="preserve"> + <value>zuletzt gesehen</value> + </data> + <data name="facet.group.protocol" xml:space="preserve"> + <value>angebotene Protokolle</value> + </data> + <data name="facet.group.tls" xml:space="preserve"> + <value>verschlüsselt</value> + </data> + <data name="facet.group.charset" xml:space="preserve"> + <value>Kodierung</value> + </data> + <data name="facet.group.codebase" xml:space="preserve"> + <value>Codebase</value> + </data> + <data name="facet.group.version" xml:space="preserve"> + <value>Version</value> + </data> + <data name="facet.group.lineage" xml:space="preserve"> + <value>Abstammung</value> + </data> + <data name="facet.group.family" xml:space="preserve"> + <value>Familie</value> + </data> + <data name="facet.group.genre" xml:space="preserve"> + <value>Genre</value> + </data> + <data name="facet.group.language" xml:space="preserve"> + <value>Sprache</value> + </data> + <data name="facet.band.playersNow" xml:space="preserve"> + <value>jetzt verbunden</value> + </data> + <data name="facet.band.activeThisWeek" xml:space="preserve"> + <value>diese Woche aktiv</value> + </data> + <data name="facet.band.quiet" xml:space="preserve"> + <value>ruhig — nie mehr als 0 gezählt</value> + </data> + <data name="facet.band.dark" xml:space="preserve"> + <value>verstummt — seit einem Monat nicht erreicht</value> + </data> + <data name="facet.band.archived" xml:space="preserve"> + <value>archiviert</value> + </data> + <data name="facet.seen.day" xml:space="preserve"> + <value>in den letzten 24 Stunden</value> + </data> + <data name="facet.seen.week" xml:space="preserve"> + <value>in den letzten 7 Tagen</value> + </data> + <data name="facet.seen.month" xml:space="preserve"> + <value>in den letzten 30 Tagen</value> + </data> + <data name="facet.seen.older" xml:space="preserve"> + <value>länger her</value> + </data> + <data name="facet.seen.never" xml:space="preserve"> + <value>nie erreicht</value> + </data> + <data name="facet.unknown.charset" xml:space="preserve"> + <value>nichts ausgehandelt</value> + </data> + <data name="facet.unknown.codebase" xml:space="preserve"> + <value>nicht identifiziert</value> + </data> + <data name="facet.unknown.other" xml:space="preserve"> + <value>nicht angegeben</value> + </data> + <data name="facet.tls.yes" xml:space="preserve"> + <value>über TLS verbunden</value> + </data> + <data name="facet.excluded" xml:space="preserve"> + <value>nicht {value}</value> + </data> + <data name="facet.known.charset" xml:space="preserve"> + <value>etwas ausgehandelt</value> + </data> + <data name="facet.known.codebase" xml:space="preserve"> + <value>überhaupt identifiziert</value> + </data> + <data name="facet.known.other" xml:space="preserve"> + <value>überhaupt angegeben</value> + </data> + <data name="evidence.measured.meaning" xml:space="preserve"> + <value>wir haben das selbst beobachtet</value> + </data> + <data name="evidence.declared.meaning" xml:space="preserve"> + <value>das Spiel sagt es, und wir haben es nicht geprüft</value> + </data> + <data name="evidence.derived.meaning" xml:space="preserve"> + <value>wir haben gruppiert, was das Spiel uns mitgeteilt hat</value> + </data> + <data name="sort.name" xml:space="preserve"> + <value>Name</value> + </data> + <data name="sort.players" xml:space="preserve"> + <value>jetzt verbunden</value> + </data> + <data name="sort.reached" xml:space="preserve"> + <value>zuletzt erreicht</value> + </data> + <data name="sort.medianWeek" xml:space="preserve"> + <value>typisch verbunden · 7 Tage</value> + </data> + <data name="sort.medianMonth" xml:space="preserve"> + <value>typisch verbunden · 30 Tage</value> + </data> + <data name="sort.medianQuarter" xml:space="preserve"> + <value>typisch verbunden · 90 Tage</value> + </data> + <data name="sort.peakWeek" xml:space="preserve"> + <value>meiste gleichzeitig · 7 Tage</value> + </data> + <data name="sort.peakMonth" xml:space="preserve"> + <value>meiste gleichzeitig · 30 Tage</value> + </data> + <data name="sort.peakQuarter" xml:space="preserve"> + <value>meiste gleichzeitig · 90 Tage</value> + </data> + <data name="sort.group.row" xml:space="preserve"> + <value>jetzt in der Zeile</value> + </data> + <data name="sort.group.typical" xml:space="preserve"> + <value>typisch</value> + </data> + <data name="sort.group.peak" xml:space="preserve"> + <value>Spitze</value> + </data> + <data name="sort.unranked.players" xml:space="preserve"> + <value>Unbekannte Zählung</value> + </data> + <data name="sort.unranked.reached" xml:space="preserve"> + <value>noch nie erreicht — nicht etwa vor langer Zeit erreicht</value> + </data> + <data name="sort.unranked.median" xml:space="preserve"> + <value>weniger als {minimum} Zählungen im Zeitraum oder gar keine — nicht etwa eine typische Zählung von null</value> + </data> + <data name="sort.unranked.window" xml:space="preserve"> + <value>nichts, was wir im Zeitraum zählen konnten — nicht etwa ein Spiel, mit dem niemand verbunden war</value> + </data> + <data name="sort.window.median" xml:space="preserve"> + <value>Median {value} · {days, plural, one {# Tag} other {# Tage}} · {count, plural, one {# Zählung} other {# Zählungen}}</value> + </data> + <data name="sort.window.peak" xml:space="preserve"> + <value>meiste {value} gleichzeitig · {days, plural, one {# Tag} other {# Tage}} · {count, plural, one {# Zählung} other {# Zählungen}}</value> + </data> + <data name="game.connectScreen" xml:space="preserve"> + <value>Verbindungsbildschirm</value> + </data> + <data name="game.connectionsByHour" xml:space="preserve"> + <value>Verbindungen nach Stunde</value> + </data> + <data name="game.howMany" xml:space="preserve"> + <value>Wie viele, im Zeitverlauf</value> + </data> + <data name="game.reachable" xml:space="preserve"> + <value>Erreichbar</value> + </data> + <data name="game.whatChanged" xml:space="preserve"> + <value>Was sich geändert hat</value> + </data> + <data name="game.capabilities" xml:space="preserve"> + <value>Fähigkeiten</value> + </data> + <data name="game.declaredByGame" xml:space="preserve"> + <value>Vom Spiel angegeben</value> + </data> + <data name="game.referrals" xml:space="preserve"> + <value>Verweise</value> + </data> + <data name="game.unclaimed" xml:space="preserve"> + <value>Nicht beansprucht — alles hier wurde gemessen.</value> + </data> + <data name="game.claimed" xml:space="preserve"> + <value>Vom Betreiber beansprucht — die gemessenen Tatsachen unten sind weiterhin unsere.</value> + </data> + <data name="game.claim" xml:space="preserve"> + <value>Dieses Spiel beanspruchen</value> + </data> + <data name="game.answeringSince" xml:space="preserve"> + <value>antwortet seit {date}</value> + </data> + <data name="game.readAsTextRows" xml:space="preserve"> + <value>als Text lesen — {count, plural, one {# Zeile} other {# Zeilen}}</value> + </data> + <data name="capability.column" xml:space="preserve"> + <value>Fähigkeit</value> + </data> + <data name="capability.age" xml:space="preserve"> + <value>Alter</value> + </data> + <data name="capability.offered" xml:space="preserve"> + <value>angeboten</value> + </data> + <data name="capability.silent" xml:space="preserve"> + <value>stumm</value> + </data> + <data name="capability.absent" xml:space="preserve"> + <value>fehlend</value> + </data> + <data name="capability.denied" xml:space="preserve"> + <value>verweigert</value> + </data> + <data name="capability.claimed" xml:space="preserve"> + <value>behauptet</value> + </data> + <data name="capability.disagrees" xml:space="preserve"> + <value>widerspricht</value> + </data> + <data name="capability.whereTheyDisagree" xml:space="preserve"> + <value>wo sie widersprechen ({count})</value> + </data> + <data name="activity.cell.counted" xml:space="preserve"> + <value>{day} {time} — {count, plural, =0 {0 Spieler, gemessen} one {durchschnittlich # Spieler} other {durchschnittlich # Spieler}}</value> + </data> + <data name="activity.cell.notCounted" xml:space="preserve"> + <value>{day} {time} — abgefragt, keine Zählung ablesbar</value> + </data> + <data name="activity.cell.notMeasured" xml:space="preserve"> + <value>{day} {time} — keine Messung in dieser Stunde</value> + </data> + <data name="activity.none" xml:space="preserve"> + <value>Wir haben die Aktivität dieses Spiels noch nicht gemessen.</value> + </data> + <data name="activity.noCount" xml:space="preserve"> + <value>Keine Stunde der Woche hat eine Zählung ergeben.</value> + </data> + <data name="activity.allZero" xml:space="preserve"> + <value>Jede Stunde gemessen, und in keiner war jemand verbunden.</value> + </data> + <data name="activity.gap.day" xml:space="preserve"> + <value>{count, plural, one {Für # Stunde am {day} liegt noch keine Messung vor.} other {Für # Stunden am {day} liegt noch keine Messung vor.}}</value> + </data> + <data name="activity.gap.week" xml:space="preserve"> + <value>{count, plural, one {Für # Stunde der Woche liegt noch keine Messung vor.} other {Für # Stunden der Woche liegt noch keine Messung vor.}}</value> + </data> + <data name="activity.uncounted.day" xml:space="preserve"> + <value>{count, plural, one {# Stunde am {day} hat geantwortet, aber keine Zählung ergeben.} other {# Stunden am {day} haben geantwortet, aber keine Zählung ergeben.}}</value> + </data> + <data name="activity.uncounted.week" xml:space="preserve"> + <value>{count, plural, one {# Stunde der Woche hat geantwortet, aber keine Zählung ergeben.} other {# Stunden der Woche haben geantwortet, aber keine Zählung ergeben.}}</value> + </data> + <data name="activity.busiest.everyDay" xml:space="preserve"> + <value>Jeden Tag am belebtesten, {window}.</value> + </data> + <data name="activity.busiest.everyDay.part" xml:space="preserve"> + <value>Jeden Tag am belebtesten, {part}, {window}.</value> + </data> + <data name="activity.busiest.days" xml:space="preserve"> + <value>{days} am belebtesten, {window}.</value> + </data> + <data name="activity.busiest.days.part" xml:space="preserve"> + <value>{days} am belebtesten, {part}, {window}.</value> + </data> + <data name="activity.quiet" xml:space="preserve"> + <value>Verlässlich ruhig {who}, {window}.</value> + </data> + <data name="activity.quiet.part" xml:space="preserve"> + <value>Verlässlich ruhig {who} {part}, {window}.</value> + </data> + <data name="activity.quiet.everyDay" xml:space="preserve"> + <value>jeden Tag</value> + </data> + <data name="activity.quiet.everyMeasuredDay" xml:space="preserve"> + <value>an jedem gemessenen Tag</value> + </data> + <data name="activity.quiet.weekdays" xml:space="preserve"> + <value>an Wochentagen</value> + </data> + <data name="activity.quiet.onDays" xml:space="preserve"> + <value>an {days}</value> + </data> + <data name="activity.part.morning" xml:space="preserve"> + <value>morgens</value> + </data> + <data name="activity.part.afternoon" xml:space="preserve"> + <value>nachmittags</value> + </data> + <data name="activity.part.evening" xml:space="preserve"> + <value>abends</value> + </data> + <data name="activity.part.smallHours" xml:space="preserve"> + <value>nachts</value> + </data> + <data name="activity.parts.morning" xml:space="preserve"> + <value>morgens</value> + </data> + <data name="activity.parts.afternoon" xml:space="preserve"> + <value>nachmittags</value> + </data> + <data name="activity.parts.evening" xml:space="preserve"> + <value>abends</value> + </data> + <data name="activity.parts.smallHours" xml:space="preserve"> + <value>nachts</value> + </data> + <data name="activity.days.list" xml:space="preserve"> + <value>{list}, {next}</value> + </data> + <data name="activity.days.pair" xml:space="preserve"> + <value>{first} und {second}</value> + </data> + <data name="activity.sparse.kicker" xml:space="preserve"> + <value>noch nicht genug Messungen</value> + </data> + <data name="activity.sparse.none" xml:space="preserve"> + <value>Für keine Stunde der Woche liegt bisher eine Messung vor.</value> + </data> + <data name="activity.sparse.uncounted" xml:space="preserve"> + <value>{count, plural, one {# Stunde hat geantwortet und keine Zählung ergeben.} other {# Stunden haben geantwortet und keine Zählung ergeben.}}</value> + </data> + <data name="activity.sparse.wait" xml:space="preserve"> + <value>Das Raster erscheint, sobald für jeden Wochentag eine Messung vorliegt.</value> + </data> + <data name="activity.sparse.days" xml:space="preserve"> + <value>{days, plural, one {Bisher an # von sieben Tagen gemessen; das Raster erscheint, sobald jeder Tag eine gemessene Stunde hat.} other {Bisher an # von sieben Tagen gemessen; das Raster erscheint, sobald jeder Tag eine gemessene Stunde hat.}}</value> + </data> + <data name="activity.sample.zero" xml:space="preserve"> + <value>{count, plural, one {# Stunde gemessen, darin war niemand verbunden.} other {# Stunden gemessen, in allen war niemand verbunden.}}</value> + </data> + <data name="activity.sample.peak" xml:space="preserve"> + <value>{count, plural, one {# Stunde gemessen, die belebteste mit {peak} am {day} um {time} UTC.} other {# Stunden gemessen, die belebteste mit {peak} am {day} um {time} UTC.}}</value> + </data> + <data name="activity.sample.more" xml:space="preserve"> + <value>{count, plural, one {# weitere Stunde hat geantwortet und keine Zählung ergeben.} other {# weitere Stunden haben geantwortet und keine Zählung ergeben.}}</value> + </data> + <data name="activity.day.line" xml:space="preserve"> + <value>{day} — {facts}</value> + </data> + <data name="activity.day.facts" xml:space="preserve"> + <value>{first}, {second}</value> + </data> + <data name="activity.day.allZero" xml:space="preserve"> + <value>den ganzen Tag null gemessen</value> + </data> + <data name="activity.day.peak" xml:space="preserve"> + <value>Spitze {count} um {time}</value> + </data> + <data name="activity.day.nobodyOn" xml:space="preserve"> + <value>niemand verbunden {window}</value> + </data> + <data name="activity.day.noCount" xml:space="preserve"> + <value>in keiner Stunde eine Zählung</value> + </data> + <data name="activity.day.notMeasured" xml:space="preserve"> + <value>{count, plural, one {# Stunde nicht gemessen} other {# Stunden nicht gemessen}}</value> + </data> + <data name="activity.day.notCounted" xml:space="preserve"> + <value>{count, plural, one {# Stunde abgefragt, aber nicht zählbar} other {# Stunden abgefragt, aber nicht zählbar}}</value> + </data> + <data name="activity.column.day" xml:space="preserve"> + <value>Tag</value> + </data> + <data name="activity.column.quietest" xml:space="preserve"> + <value>ruhigste</value> + </data> + <data name="activity.column.busiest" xml:space="preserve"> + <value>belebteste</value> + </data> + <data name="activity.column.at" xml:space="preserve"> + <value>um</value> + </data> + <data name="activity.column.noCount" xml:space="preserve"> + <value>keine Zählung</value> + </data> + <data name="activity.caption" xml:space="preserve"> + <value>Verbundene Spieler nach Tag, in UTC. {window}.</value> + </data> + <data name="activity.times" xml:space="preserve"> + <value>Zeiten in UTC · {window}</value> + </data> + <data name="activity.rollingAverage" xml:space="preserve"> + <value>{weeks, plural, one {gleitender Durchschnitt über # Woche} other {gleitender Durchschnitt über # Wochen}}</value> + </data> + <data name="activity.legend.counted" xml:space="preserve"> + <value>gezählt, auch eine gemessene Null</value> + </data> + <data name="activity.legend.notCounted" xml:space="preserve"> + <value>abgefragt, keine Zählung ablesbar</value> + </data> + <data name="activity.legend.notMeasured" xml:space="preserve"> + <value>keine Messung in dieser Stunde</value> + </data> + <data name="activity.plain.heading" xml:space="preserve"> + <value>Wann Spieler verbunden sind (UTC)</value> + </data> + <data name="activity.key.counted" xml:space="preserve"> + <value>gezählt</value> + </data> + <data name="activity.key.counted.meaning" xml:space="preserve"> + <value>wir sind hineingekommen und haben eine Zahl abgelesen, auch eine gemessene Null</value> + </data> + <data name="activity.key.uncounted.meaning" xml:space="preserve"> + <value>wir sind hineingekommen, aber keine Zahl war ablesbar</value> + </data> + <data name="activity.key.notMeasured.meaning" xml:space="preserve"> + <value>für diese Stunde liegt uns keine Messung vor</value> + </data> + <data name="locale.label" xml:space="preserve"> + <value>Sprache</value> + </data> + <data name="locale.submit" xml:space="preserve"> + <value>Sprache wechseln</value> + </data> + <data name="about.title" xml:space="preserve"> + <value>Über mu*index</value> + </data> + <data name="about.lede" xml:space="preserve"> + <value>Jedes Spiel hier wurde von einer Maschine gemessen, die sich mit ihm verbunden hat, und jeder Wert nennt seine Herkunft und seinen Zeitpunkt. Diese Seite behandelt, was das belegt, was wir falsch machen, wessen Verzeichnisse wir lesen und wie sich der Crawler stoppen lässt.</value> + </data> + <data name="about.measures.heading" xml:space="preserve"> + <value>Was hier eine Tatsache ist</value> + </data> + <data name="about.measures.declared.lead" xml:space="preserve"> + <value>Gemessen schlägt angegeben, und beides wird gezeigt.</value> + </data> + <data name="about.measures.declared.body" xml:space="preserve"> + <value>Der MSSP-Bericht eines Spiels ist das Spiel, das sich selbst beschreibt. Der Telnet-Handshake ist das, was wir es haben tun sehen. Beides steht auf seiner Seite, versehen mit dem Wie und dem Wann. Wo beides sich widerspricht, zeigen wir den Widerspruch.</value> + </data> + <data name="about.measures.count.lead" xml:space="preserve"> + <value>Eine Spielerzahl nennt ihre Herkunft.</value> + </data> + <data name="about.measures.count.body" xml:space="preserve"> + <value>Entweder ein WHO oder DOING, am Verbindungsbildschirm gelesen und von uns gezählt, oder das MSSP-Feld PLAYERS des Spiels selbst, das es veröffentlicht hat. Niemals zusammengeführt.</value> + </data> + <data name="about.measures.unknown.lead" xml:space="preserve"> + <value>Eine Antwort, die wir nicht lesen können, ist unbekannt, niemals null.</value> + </data> + <data name="about.measures.unknown.body" xml:space="preserve"> + <value>Server passen ihre WHO-Kopfzeilen frei an, und ab einem gewissen Punkt kann unser Parser eine solche nicht mehr lesen. Das ist unzählbar, ein eigener Zustand. Eine gemessene Null — wir sind hineingekommen, und niemand war da — ist eine Zählung und wird als solche ausgegeben.</value> + </data> + <data name="about.measures.reachable.lead" xml:space="preserve"> + <value>Erreichbar, niemals Uptime.</value> + </data> + <data name="about.measures.reachable.body" xml:space="preserve"> + <value>Wir öffnen in Abständen einen Socket von einem einzigen Host aus. Ein Spiel, zu dem wir keine Route finden, ist nicht erreichbar und dennoch völlig lebendig. Nichts hier behauptet die Uptime eines Spiels, denn nichts hier hat sie gemessen.</value> + </data> + <data name="about.measures.hour.lead" xml:space="preserve"> + <value>Eine Stunde ist gezählt, unzählbar oder nicht gemessen.</value> + </data> + <data name="about.measures.hour.body" xml:space="preserve"> + <value>Das Aktivitätsraster hat drei Zustände. Der dritte ist leer und nennt keine Ursache: eine Stunde, die wir nicht erreichen konnten, und eine Stunde, die wir nie abgefragt haben, sind dieselbe Leerstelle, und keine von beiden ist die Ausfallzeit dieses Servers.</value> + </data> + <data name="about.limits.heading" xml:space="preserve"> + <value>Was wir falsch machen, soweit wir es wissen</value> + </data> + <data name="about.limits.grace.lead" xml:space="preserve"> + <value>Die Schonfrist bis zum Archiv wird ab dem Tag gemessen, an dem wir Sie gefunden haben.</value> + </data> + <data name="about.limits.grace.body" xml:space="preserve"> + <value>Ein Spiel, das nicht mehr antwortet, verlässt nach seiner Schonfrist das Standardverzeichnis: ein Viertel der erreichbaren Zeit, die wir abgefragt haben, mindestens 60 und höchstens 365 Tage. Ein Spiel, das seit 1995 läuft, beginnt am Tag seiner Entdeckung beim Minimum. Wir importieren nichts, um die Jahre vor unserer Ankunft aufzufüllen.</value> + </data> + <data name="about.limits.created.lead" xml:space="preserve"> + <value>MSSP CREATED wird auf diese Schonfrist nicht angerechnet.</value> + </data> + <data name="about.limits.created.body" xml:space="preserve"> + <value>Es ist eine von Hand getippte Zeile in einer Konfigurationsdatei; sie anzurechnen würde die Archivschwelle manipulierbar machen. Sie wird als Angabe gezeigt und bringt nichts ein.</value> + </data> + <data name="about.limits.claim.lead" xml:space="preserve"> + <value>Ein beanspruchtes Spiel erhält das Maximum.</value> + </data> + <data name="about.limits.claim.body" xml:space="preserve"> + <value>Der Nachweis von Serverzugriff ist das volle Jahr Schonfrist wert, gleich wie lange wir schon zusehen.</value> + </data> + <data name="about.limits.oneHost.lead" xml:space="preserve"> + <value>Alles hier ist ein einziger Host, der in Abständen hinsieht.</value> + </data> + <data name="about.limits.oneHost.body" xml:space="preserve"> + <value>Ein Prozentsatz erreichbarer Zeit ist ein Anteil des von uns beobachteten Zeitraums, nie eines anderen. Keine Grafik hier füllt den Rest auf.</value> + </data> + <data name="about.limits.deletion.lead" xml:space="preserve"> + <value>Nichts wird jemals gelöscht.</value> + </data> + <data name="about.limits.deletion.body" xml:space="preserve"> + <value>Das Archivieren nimmt ein Spiel aus dem Standardverzeichnis, aus den Ranglisten und aus der Zahl der heute aktiven Spiele heraus, und sonst nichts. Seine Seite, seine URL, seine Geschichte und seine Adresse bleiben, es wird weiter abgefragt, und eine einzige erfolgreiche Abfrage bringt es zurück.</value> + </data> + <data name="about.never.heading" xml:space="preserve"> + <value>Was diese Website nicht tut</value> + </data> + <data name="about.never.votes.lead" xml:space="preserve"> + <value>Keine Stimmen, Sterne, Bewertungen oder Empfehlungen.</value> + </data> + <data name="about.never.votes.body" xml:space="preserve"> + <value>Ranglisten werden ausschließlich aus gemessenen Daten berechnet. Ein Verzeichnis, das danach sortiert, wer die meisten Klicks mobilisieren kann, beschreibt den Wahlkampf und nicht das Hobby — und genau daran sind die Vorgänger zugrunde gegangen.</value> + </data> + <data name="about.never.forums.lead" xml:space="preserve"> + <value>Keine Foren, Rezensionen, Wikis, Kommentare oder Spielerprofile.</value> + </data> + <data name="about.never.forums.body" xml:space="preserve"> + <value>Einführendes Material — was ein MUSH ist, welche Codebase zu gemeinsamem Rollenspiel passt — wird geschrieben, namentlich gezeichnet und versioniert wie der Rest der Website.</value> + </data> + <data name="about.never.names.lead" xml:space="preserve"> + <value>Spielernamen werden nie gespeichert.</value> + </data> + <data name="about.never.names.body" xml:space="preserve"> + <value>Eine WHO-Antwort wird im Arbeitsspeicher auf eine Zahl und die Form der Kopfzeile hin ausgewertet. Die Namen werden nicht festgehalten; Aggregate verwenden einen gesalzenen Hash mit rotierendem Salt.</value> + </data> + <data name="about.never.population.lead" xml:space="preserve"> + <value>Es wird keine absolute Spielerzahl veröffentlicht.</value> + </data> + <data name="about.never.population.body" xml:space="preserve"> + <value>Anteile pro Codebase und pro Protokoll werden veröffentlicht: Ein Verhältnis über die gemessene Menge übersteht die Spiele, die wir nicht zählen können. „Wie viele Menschen spielen MU*“ übersteht das nicht, denn diese Zahl würde es nicht überstehen, zitiert zu werden.</value> + </data> + <data name="about.crawler.heading" xml:space="preserve"> + <value>Der Crawler und wie er sich stoppen lässt</value> + </data> + <data name="about.crawler.probe.lead" xml:space="preserve"> + <value>Eine Abfrage ist eine Verbindung, die sich nie anmeldet.</value> + </data> + <data name="about.crawler.probe.body" xml:space="preserve"> + <value>Sie öffnet einen Socket, handelt Telnet-Optionen aus, liest den Verbindungsbildschirm, fragt MSSP über Option 70 an, sendet {commands} und trennt die Verbindung. Kein Charakter, keine Anmeldung, nichts auf der Gegenseite verändert. Ein Timeout begrenzt die Sitzung, damit eine hängengebliebene Abfrage keinen Verbindungsplatz belegt.</value> + </data> + <data name="about.crawler.delay.lead" xml:space="preserve"> + <value>CRAWL DELAY hat Vorrang.</value> + </data> + <data name="about.crawler.delay.body" xml:space="preserve"> + <value>Ein Spiel, das in seinem MSSP-Bericht einen bevorzugten Mindestabstand nennt, bekommt ihn — in beide Richtungen vor unserem eigenen Zeitplan: 720 Stunden heißt monatlich, nicht wöchentlich. Ein verstummtes Spiel wird im längeren Abstand für immer weiter versucht; so trägt es sich selbst wieder ein, wenn es zurückkommt.</value> + </data> + <data name="about.crawler.referral.lead" xml:space="preserve"> + <value>Eine per Verweis genannte Adresse wird geprüft, nie geglaubt.</value> + </data> + <data name="about.crawler.referral.body" xml:space="preserve"> + <value>MSSP erlaubt es einem Spiel, andere Spiele zu nennen. Jeder Name wird aufgelöst, bevor irgendetwas angewählt wird, und abgelehnt, sofern nicht jede Adresse, auf die er auflöst, global routbar ist. Eine gemischte Antwort lehnt das ganze Ziel ab. Unsere Ablehnung wird als unsere verbucht und erscheint nie als Ausfallzeit im Datensatz eines Spiels.</value> + </data> + <data name="about.crawler.screens.lead" xml:space="preserve"> + <value>Verbindungsbildschirme werden gezeigt, weil sie an alle gesendet werden.</value> + </data> + <data name="about.crawler.screens.body" xml:space="preserve"> + <value>Ein Server malt seinen Verbindungsbildschirm ohne Anmeldung an jede anonyme Verbindung. Wir zeigen ihn als Beleg und kennzeichnen ihn. Auf Bitte hin verschwindet er.</value> + </data> + <data name="about.crawler.stop.lead" xml:space="preserve"> + <value>Ein Stopp genügt, und wir hören auf — auf drei Wegen.</value> + </data> + <data name="about.crawler.stop.body" xml:space="preserve"> + <value>Veröffentlichen Sie {variable} 1 in Ihrem MSSP-Bericht, dann ist die Abfrage, die es liest, die letzte. Oder veröffentlichen Sie einen TXT-Eintrag unter {label}.your.host mit dem Inhalt „{value}“, wofür es keine MSSP-Unterstützung und kein Konto hier braucht. Oder schreiben Sie einer Person. Alle drei werden innerhalb eines Crawl-Zyklus befolgt, mit Datum und dem Gelesenen festgehalten und auch im Eintragungsformular durchgesetzt.</value> + </data> + <data name="about.crawler.scope.lead" xml:space="preserve"> + <value>Das MSSP-Feld stoppt diesen Listener; der TXT-Eintrag stoppt den Host.</value> + </data> + <data name="about.crawler.scope.body" xml:space="preserve"> + <value>MSSP wird von dem Port veröffentlicht, der geantwortet hat, und spricht daher für diesen Port — beim MU*-Hosting laufen regelmäßig unabhängige Spiele auf einer Domain, und keines darf sein Nachbarspiel zum Schweigen bringen. Ein TXT-Eintrag umfasst jeden Port, sofern er nicht einen einzelnen nennt, etwa „{value}=4201“. Alles dort, was wir nicht als Portliste lesen können, meint den ganzen Host; deshalb funktioniert auch „{value}=all“.</value> + </data> + <data name="about.crawler.dns.lead" xml:space="preserve"> + <value>Der Weg über DNS ist der, den Sie ohne Rückfrage bei uns rückgängig machen können.</value> + </data> + <data name="about.crawler.dns.body" xml:space="preserve"> + <value>Ein TXT-Eintrag lässt sich lesen, ohne sich mit einem Server zu verbinden, der uns das untersagt hat; deshalb lesen wir ihn vor jeder Anwahl neu. Löschen Sie ihn, und wir wählen binnen einer Woche wieder an. Ein MSSP-Feld lässt sich nicht neu lesen, ohne genau das zu tun, was Sie uns untersagt haben; deshalb gelten ein Ausschluss per MSSP und schriftliche Bitten so lange, bis Sie etwas anderes sagen. Dieser TXT-Abruf ist alles, was eine ausgeschlossene Adresse noch bekommt: Er berührt Ihren Nameserver, nie Ihr Spiel.</value> + </data> + <data name="about.crawler.stopping.lead" xml:space="preserve"> + <value>Aufhören ist kein Löschen, und es ist keine Ausfallzeit.</value> + </data> + <data name="about.crawler.stopping.body" xml:space="preserve"> + <value>Ein Spiel, das sich ausschließen lässt, behält seine Seite, seine Adresse und alles, was wir vor der Bitte gemessen haben. Nur neue Daten hören auf: Das Aktivitätsraster gewinnt keine Stunden mehr hinzu und nennt keine Ursache, denn unsere Entscheidung, nicht mehr anzuklopfen, ist eine Tatsache über uns. Sie wird bei dem Crawl festgehalten, der nicht stattgefunden hat, und im Register derer, die darum gebeten haben.</value> + </data> + <data name="about.crawler.unlist.lead" xml:space="preserve"> + <value>Wenn Aufhören nicht genügt, kann auch der Eintrag verschwinden.</value> + </data> + <data name="about.crawler.unlist.body" xml:space="preserve"> + <value>Sobald wir für jede Adresse, unter der Ihr Spiel antwortet, aufgehört haben, bietet Ihre Übersicht eine weitere Möglichkeit: es aus dem Verzeichnis, aus den Ranglisten und aus der Tageszahl herauszunehmen. Die Seite und jede Adresse, die es je hatte, antworten weiterhin, und nichts wird gelöscht — es ist nur kein Ort mehr, an dem man beim Stöbern ankommt. Dafür braucht es einen bestätigten Anspruch, denn es ist eine Entscheidung über Ihr Spiel, und wir halten fest, wer sie getroffen hat. Und eine Abfrage macht sie rückgängig: Nehmen Sie Ihren Ausschluss zurück, dann bringt die nächste Anwahl, die eine Antwort erhält, Sie wieder ins Verzeichnis, ohne dass Sie uns ein zweites Mal fragen müssen.</value> + </data> + <data name="about.identity.announced" xml:space="preserve"> + <value>Der Crawler nennt sich {name}, wenn ein Server fragt, was er ist.</value> + </data> + <data name="about.identity.unannounced" xml:space="preserve"> + <value>Der Crawler ist so konfiguriert, dass er sich {name} nennt, kann das aber noch nicht mitteilen. Seine Telnet-Bibliothek bietet einem Client keine Möglichkeit, den Terminaltyp zu setzen; deshalb steht in Ihren Logs der Standardwert dieser Bibliothek, und NEW-ENVIRON wird aus der Umgebung des Crawler-Hosts beantwortet. Beides sind Lücken in der Bibliothek und von uns dort zu beheben. Bis dahin erkennen Sie eine Abfrage an ihrer Form: eine Verbindung, keine Anmeldung, ein kurzer, nur lesender Befehlssatz, weg.</value> + </data> + <data name="about.identity.crawler" xml:space="preserve"> + <value>Crawler</value> + </data> + <data name="about.identity.contact" xml:space="preserve"> + <value>Kontakt</value> + </data> + <data name="about.identity.crawler.line" xml:space="preserve"> + <value>Crawler: {name}</value> + </data> + <data name="about.identity.contact.line" xml:space="preserve"> + <value>Kontakt: {url}</value> + </data> + <data name="about.identity.placeholder" xml:space="preserve"> + <value>— Platzhalter; diese Installation hat keine Kontaktadresse gesetzt</value> + </data> + <data name="about.identity.placeholder.plain" xml:space="preserve"> + <value>Es ist keine Kontaktadresse konfiguriert; die obige ist daher ein Platzhalter und antwortet niemandem.</value> + </data> + <data name="about.sources.heading" xml:space="preserve"> + <value>Woher die Liste der Spiele stammt</value> + </data> + <data name="about.sources.addresses.lead" xml:space="preserve"> + <value>Wir übernehmen Adressen. Sonst nichts.</value> + </data> + <data name="about.sources.addresses.body" xml:space="preserve"> + <value>Ein Backfill übernimmt einen Host und einen Port. Keine Spielerzahlen, keine Erreichbarkeitsverläufe, keine Beschreibungen, keine Felder und keinen Vermerk, von welcher Website eine Adresse stammt.</value> + </data> + <data name="about.sources.less.lead" xml:space="preserve"> + <value>Bewusst weniger, als diese Websites hergeben.</value> + </data> + <data name="about.sources.less.body" xml:space="preserve"> + <value>Mehrere davon halten jahrelange, datierte Spielerzahlen bereit. Diese zu importieren würde die Aktivitätsraster genau der Spiele füllen, die schon jemand anderes beobachtet hat, und die zentrale Behauptung dieser Website auf die Abfragen eines Dritten stützen.</value> + </data> + <data name="about.sources.origin.lead" xml:space="preserve"> + <value>Die Herkunft eines Spiels ist keine einzelne Tatsache.</value> + </data> + <data name="about.sources.origin.body" xml:space="preserve"> + <value>Jedes Spiel, das einen Eintrag wert ist, steht in mehreren dieser Verzeichnisse; „importiert aus“ würde also nur den Abruf nennen, der zuerst lief. Dass ein Spiel existiert, ist öffentlich bekannt; wo wir es gelesen haben, fügt nichts hinzu und ist der Teil fremder Arbeit, auf den wir am wenigsten Anspruch haben.</value> + </data> + <data name="about.sources.etiquette.lead" xml:space="preserve"> + <value>Die Website eines anderen zu lesen bleibt: die Website eines anderen zu lesen.</value> + </data> + <data name="about.sources.etiquette.body" xml:space="preserve"> + <value>Wir bitten vor dem Scrapen um einen Massenexport oder einen dokumentierten Endpunkt, lesen zuerst robots.txt und drosseln Scrapes stark. Eine Quelle, die das Einverständnis ihrer Betreuung braucht, wird erst abgerufen, wenn eine Person bestätigen kann, dass gefragt wurde.</value> + </data> + <data name="about.source.read" xml:space="preserve"> + <value>gelesen — nur Adressen</value> + </data> + <data name="about.source.withheld" xml:space="preserve"> + <value>nicht gelesen — Erlaubnis ausstehend</value> + </data> + <data name="about.source.tintinMssp.note" xml:space="preserve"> + <value>Eine Seite, eine Anfrage. Veröffentlicht von einem Crawler, der sich mit jedem Spiel verbindet und ausgibt, was er gelesen hat.</value> + </data> + <data name="about.source.tintinMsdp.note" xml:space="preserve"> + <value>Die MSDP-Liste desselben Crawlers. Fast eine Teilmenge ihres MSSP-Gegenstücks; gelesen wegen der wenigen Adressen, die sie erreicht und das andere nicht.</value> + </data> + <data name="about.source.mudConnector.note" xml:space="preserve"> + <value>Veröffentlicht seinen gesamten Katalog auf einer Seite, das Lesen kostet also eine einzige Anfrage. Unsere größte Quelle für Adressen und für keinerlei Messungen.</value> + </data> + <data name="about.source.mudStats.note" xml:space="preserve"> + <value>Eine Übersichtsseite und je eine Seite pro Welt, also ein Scrape statt eines Exports. Am 30. Juli 2026 haben wir 143 ihrer Seiten abgerufen, im Abstand von fünfzehn Sekunden und unter Beachtung von robots.txt, aber bevor ihnen jemand geschrieben hatte. Das hätte nicht geschehen dürfen. Die Sperre verlangt nun eine Person, die bestätigt, dass die Betreuung gefragt wurde.</value> + </data> + <data name="about.source.mudVerse.note" xml:space="preserve"> + <value>Implementiert, getestet, nie ausgeführt. Die stärkste Quelle hier in jeder Hinsicht außer der Erlaubnis; es wird nichts abgerufen, bevor ihnen jemand geschrieben hat.</value> + </data> + <data name="about.licence.heading" xml:space="preserve"> + <value>Lizenz</value> + </data> + <data name="about.licence.code.lead" xml:space="preserve"> + <value>Der Code steht unter MIT.</value> + </data> + <data name="about.licence.code.body" xml:space="preserve"> + <value>Die Website, der Crawler und die Parser sind Open Source unter der MIT-Lizenz.</value> + </data> + <data name="about.licence.open.lead" xml:space="preserve"> + <value>Die Lizenz für die Daten ist eine offene Frage.</value> + </data> + <data name="about.licence.open.body" xml:space="preserve"> + <value>Eine vom Code getrennte Entscheidung, und noch nicht getroffen. Die Bedingungen unten sind die derzeitige Antwort dieser Installation, nicht die feststehende Haltung des Projekts. Dass ein konkurrierendes Verzeichnis den gesamten Katalog übernimmt, gilt hier als Erfolg; was auch immer festgelegt wird, wird einem solchen nicht im Weg stehen.</value> + </data> + <data name="about.licence.codeLabel" xml:space="preserve"> + <value>Code</value> + </data> + <data name="about.licence.dataLabel" xml:space="preserve"> + <value>Daten, so wie diese Installation sie ausliefert</value> + </data> + <data name="about.licence.creditLabel" xml:space="preserve"> + <value>Namensnennung als</value> + </data> + <data name="about.licence.code.line" xml:space="preserve"> + <value>Code: {licence}</value> + </data> + <data name="about.licence.data.line" xml:space="preserve"> + <value>Daten: {licence}</value> + </data> + <data name="about.licence.credit.line" xml:space="preserve"> + <value>Namensnennung als: {credit}</value> + </data> + <data name="about.licence.deployment" xml:space="preserve"> + <value>(was diese Installation ausliefert. Die eigene Antwort des Projekts ist noch offen.)</value> + </data> + <data name="submit.title" xml:space="preserve"> + <value>Ein Spiel eintragen</value> + </data> + <data name="submit.lede" xml:space="preserve"> + <value>Uns mitteilen, wo ein Spiel ist. Ein Host und ein Port sind das ganze Formular; alles andere auf dieser Website misst unser eigener Crawler.</value> + </data> + <data name="submit.host.label" xml:space="preserve"> + <value>Host</value> + </data> + <data name="submit.port.label" xml:space="preserve"> + <value>Port</value> + </data> + <data name="submit.host.hint" xml:space="preserve"> + <value>mud.example.org, oder mud.example.org:4201 einfügen und den Port leer lassen</value> + </data> + <data name="submit.button" xml:space="preserve"> + <value>Eintragen</value> + </data> + <data name="submit.noCatalogue" xml:space="preserve"> + <value>Das Eintragen braucht eine Datenbank, und diese Website läuft auf den Demodaten. Es gibt kein Crawl-Register zum Hineinschreiben, deshalb fehlt das Formular, statt still nichts zu tun.</value> + </data> + <data name="submit.notHere" xml:space="preserve"> + <value>Nicht hier</value> + </data> + <data name="submit.what.heading" xml:space="preserve"> + <value>Was mit einer Adresse geschieht</value> + </data> + <data name="submit.what.resolve" xml:space="preserve"> + <value>Wir lösen die Adresse auf, bevor wir sie anwählen, und lehnen alles ab, was außerhalb des öffentlichen Internets auflöst. Das ist eine Entscheidung über unseren eigenen Socket, nie eine Tatsache über ein Spiel.</value> + </data> + <data name="submit.what.optOut" xml:space="preserve"> + <value>Wenn die Betreiber dieses Hosts uns gebeten haben, ihn nicht zu crawlen, nehmen wir die Adresse nicht an, gleich wer sie einträgt. Fremde können Ihr Spiel nicht zurück auf diese Website bringen.</value> + </data> + <data name="submit.what.schedule" xml:space="preserve"> + <value>Antwortet sie, lesen wir, was der Server über sich selbst sagt, und lesen es nach seinem eigenen Zeitplan für immer weiter. Eine Adresse muss nur einmal genannt werden.</value> + </data> + <data name="submit.what.claim" xml:space="preserve"> + <value>Nichts erscheint auf der Website, bis jemand nachweist, dass er es betreibt. Ein Anspruch braucht einen Passkey und eine im Spiel selbst veröffentlichte Zeile.</value> + </data> + <data name="submit.what.duplicate" xml:space="preserve"> + <value>Eine Adresse, die wir bereits haben, fällt mit dem bestehenden Eintrag zusammen. Zweimal senden erzeugt keinen zweiten Eintrag und zieht keine Abfrage vor.</value> + </data> + <data name="submit.answer.thatAddress" xml:space="preserve"> + <value>diese Adresse</value> + </data> + <data name="submit.accepted.heading" xml:space="preserve"> + <value>Im Register.</value> + </data> + <data name="submit.accepted.sentence" xml:space="preserve"> + <value>{address} wird im nächsten Crawl-Zyklus angewählt, danach für immer nach eigenem Zeitplan. Sobald jemand nachweist, dass er es betreibt, erscheint es hier — kommen Sie mit derselben Adresse zu diesem Formular zurück, dann bekommen Sie hier den Link dazu.</value> + </data> + <data name="submit.unclaimed.heading" xml:space="preserve"> + <value>Wir haben es, nicht beansprucht.</value> + </data> + <data name="submit.unclaimed.sentence" xml:space="preserve"> + <value>{address} messen wir bereits. Es bleibt von der Website fern, bis jemand nachweist, dass er es betreibt. Sind Sie das, geht es hier hinein.</value> + </data> + <data name="submit.known.heading" xml:space="preserve"> + <value>Das haben wir schon.</value> + </data> + <data name="submit.known.sentence" xml:space="preserve"> + <value>{address} ist ein Spiel, das wir bereits messen. Es wurde nichts angelegt und nichts geändert.</value> + </data> + <data name="submit.knownAddress.heading" xml:space="preserve"> + <value>Diese Adresse haben wir schon.</value> + </data> + <data name="submit.knownAddress.sentence" xml:space="preserve"> + <value>{address} ist uns bereits bekannt. Es wurde nichts angelegt und nichts geändert.</value> + </data> + <data name="submit.queued.heading" xml:space="preserve"> + <value>Wartet bereits.</value> + </data> + <data name="submit.queued.sentence" xml:space="preserve"> + <value>{address} steht im Crawl-Register und hat noch nicht geantwortet. Erneutes Senden zieht sie nicht vor: Ein Ziel behält seinen eigenen Zeitplan, damit niemand uns am Server eines anderen antreiben kann.</value> + </data> + <data name="submit.malformed.heading" xml:space="preserve"> + <value>Keine Adresse, die wir anwählen können.</value> + </data> + <data name="submit.malformed.sentence" xml:space="preserve"> + <value>Ein Host braucht einen Punkt oder einen Doppelpunkt, und ein Port ist eine Zahl zwischen 1 und 65535. Beide Felder ausfüllen oder mud.example.org:4201 in das erste einfügen.</value> + </data> + <data name="submit.undialable.heading" xml:space="preserve"> + <value>Das können wir nicht anwählen.</value> + </data> + <data name="submit.undialable.sentence" xml:space="preserve"> + <value>Für {address} führen drei Dinge zu dieser Antwort: Der Name löst womöglich nicht auf, er löst womöglich außerhalb des öffentlichen Internets auf, oder die Betreiber dieses Hosts haben uns gebeten, fernzubleiben. Wir sagen bewusst nicht, welches davon, denn das für Fremde zu beantworten kartiert ein Netz von außen. Über die Adresse wurde nichts festgehalten; die Entscheidung war unsere und ist als unsere verbucht.</value> + </data> + <data name="submit.tooMany.heading" xml:space="preserve"> + <value>Genug für jetzt.</value> + </data> + <data name="submit.tooMany.sentence" xml:space="preserve"> + <value>Dieses Formular ist pro Absender begrenzt, und Sie haben die Grenze erreicht. Kommen Sie in einer Stunde wieder. Nichts ging verloren — was wir angenommen haben, steht bereits im Register.</value> + </data> + <data name="submit.link.claim" xml:space="preserve"> + <value>dieses Spiel beanspruchen</value> + </data> + <data name="account.signIn.title" xml:space="preserve"> + <value>Anmelden</value> + </data> + <data name="account.signIn.preview" xml:space="preserve"> + <value>Melden Sie sich mit einem Passkey an, um ein Spiel zu beanspruchen, das Sie betreiben. Es gibt kein Passwort, das verloren gehen, und keines, das gestohlen werden kann.</value> + </data> + <data name="account.signIn.noDatabase" xml:space="preserve"> + <value>Das Beanspruchen braucht eine Datenbank, und diese Website läuft auf den Demodaten. Es gibt nichts, wo man sich anmelden könnte.</value> + </data> + <data name="account.signIn.passkey.lead" xml:space="preserve"> + <value>Die Anmeldung ist ein Passkey.</value> + </data> + <data name="account.signIn.passkey.body" xml:space="preserve"> + <value>Ihr Gerät oder Ihr Passwortmanager hält den privaten Schlüssel; wir halten nur die öffentliche Hälfte. Kein Passwort, keine E-Mail.</value> + </data> + <data name="account.signIn.button" xml:space="preserve"> + <value>Mit einem Passkey anmelden</value> + </data> + <data name="account.signIn.script" xml:space="preserve"> + <value>Die einzige Seite hier, die JavaScript braucht. Passkeys funktionieren ohne es nicht.</value> + </data> + <data name="account.register.heading" xml:space="preserve"> + <value>Noch kein Konto?</value> + </data> + <data name="account.register.lede" xml:space="preserve"> + <value>Sie brauchen eines nur, um ein Spiel zu beanspruchen, das Sie betreiben. Wählen Sie einen Namen, unter dem Sie erscheinen — eine Beschriftung neben Ihrem Anspruch, kein echter Name.</value> + </data> + <data name="account.register.name.label" xml:space="preserve"> + <value>Name</value> + </data> + <data name="account.register.name.placeholder" xml:space="preserve"> + <value>z. B. corvid-admin</value> + </data> + <data name="account.register.button" xml:space="preserve"> + <value>Konto mit einem Passkey anlegen</value> + </data> + <data name="account.store.heading" xml:space="preserve"> + <value>Was wir speichern</value> + </data> + <data name="account.store.name" xml:space="preserve"> + <value>Den Namen, den Sie gewählt haben.</value> + </data> + <data name="account.store.keys" xml:space="preserve"> + <value>Den öffentlichen Schlüssel jedes Passkeys, den Sie registrieren, und den Namen, den Ihr Gerät ihm gegeben hat.</value> + </data> + <data name="account.store.claims" xml:space="preserve"> + <value>Welche Spiele Sie beansprucht haben und wann.</value> + </data> + <data name="account.store.note" xml:space="preserve"> + <value>Keine E-Mail-Adresse, kein Passwort, kein an Ihr Konto gebundenes IP-Protokoll. Verlieren Sie alle Passkeys, können Sie einen frischen Anspruchs-Token in Ihrem Spiel veröffentlichen und von vorn beginnen: Der Beweis ist das Spiel, nicht das Konto.</value> + </data> + <data name="date.absolute" xml:space="preserve"> + <value>{day}. {month} {year}</value> + </data> + <data name="date.stamp" xml:space="preserve"> + <value>{date} {time} UTC</value> + </data> + <data name="age.short.now" xml:space="preserve"> + <value>jetzt</value> + </data> + <data name="age.short.minutes" xml:space="preserve"> + <value>{count, plural, one {# Min} other {# Min}}</value> + </data> + <data name="age.short.hours" xml:space="preserve"> + <value>{count, plural, one {# Std} other {# Std}}</value> + </data> + <data name="age.short.days" xml:space="preserve"> + <value>{count, plural, one {# T} other {# T}}</value> + </data> + <data name="age.short.weeks" xml:space="preserve"> + <value>{count, plural, one {# W} other {# W}}</value> + </data> + <data name="age.short.months" xml:space="preserve"> + <value>{count, plural, one {# Mon} other {# Mon}}</value> + </data> + <data name="age.short.years" xml:space="preserve"> + <value>{count, plural, one {# J} other {# J}}</value> + </data> + <data name="age.ago.now" xml:space="preserve"> + <value>gerade eben</value> + </data> + <data name="age.ago.minutes" xml:space="preserve"> + <value>{count, plural, one {vor # Min} other {vor # Min}}</value> + </data> + <data name="age.ago.hours" xml:space="preserve"> + <value>{count, plural, one {vor # Std} other {vor # Std}}</value> + </data> + <data name="age.ago.days" xml:space="preserve"> + <value>{count, plural, one {vor # T} other {vor # T}}</value> + </data> + <data name="age.ago.weeks" xml:space="preserve"> + <value>{count, plural, one {vor # W} other {vor # W}}</value> + </data> + <data name="age.ago.months" xml:space="preserve"> + <value>{count, plural, one {vor # Mon} other {vor # Mon}}</value> + </data> + <data name="age.ago.years" xml:space="preserve"> + <value>{count, plural, one {vor # J} other {vor # J}}</value> + </data> + <data name="age.dark.now" xml:space="preserve"> + <value>gerade eben</value> + </data> + <data name="age.dark.minutes" xml:space="preserve"> + <value>{count, plural, one {vor # Min} other {vor # Min}}</value> + </data> + <data name="age.dark.hours" xml:space="preserve"> + <value>{count, plural, one {vor # Std} other {vor # Std}}</value> + </data> + <data name="age.dark.days" xml:space="preserve"> + <value>{count, plural, one {vor # T} other {vor # T}}</value> + </data> + <data name="age.dark.weeks" xml:space="preserve"> + <value>{count, plural, one {vor # W} other {vor # W}}</value> + </data> + <data name="age.dark.months" xml:space="preserve"> + <value>{count, plural, one {vor # Mon} other {vor # Mon}}</value> + </data> + <data name="age.dark.years" xml:space="preserve"> + <value>{count, plural, one {vor # J} other {vor # J}}</value> + </data> + <data name="time.title" xml:space="preserve"> + <value>{age}, {stamp}</value> + </data> + <data name="time.spoken" xml:space="preserve"> + <value>, {stamp}</value> + </data> + <data name="chip.title" xml:space="preserve"> + <value>{value} — {how}, Quelle: {source}, zuletzt bestätigt {date}</value> + </data> + <data name="chip.title.stale" xml:space="preserve"> + <value>{value} — {how}, Quelle: {source}, zuletzt bestätigt {date} (Aktualisierung überfällig)</value> + </data> + <data name="chip.plain" xml:space="preserve"> + <value>({how}, {age})</value> + </data> + <data name="chip.plain.stale" xml:space="preserve"> + <value>({how}, {age}, überfällig)</value> + </data> + <data name="provenance.game.ownerDeclared" xml:space="preserve"> + <value>vom Betreiber angegeben</value> + </data> + <data name="source.staff" xml:space="preserve"> + <value>Redaktion</value> + </data> + <data name="source.handshake" xml:space="preserve"> + <value>der Telnet-Handshake</value> + </data> + <data name="source.owner" xml:space="preserve"> + <value>der Betreiber</value> + </data> + <data name="source.who" xml:space="preserve"> + <value>WHO</value> + </data> + <data name="source.i3" xml:space="preserve"> + <value>I3</value> + </data> + <data name="source.mssp" xml:space="preserve"> + <value>MSSP</value> + </data> + <data name="source.info" xml:space="preserve"> + <value>INFO</value> + </data> + <data name="source.i3Mudlist" xml:space="preserve"> + <value>die I3-Mudlist</value> + </data> + <data name="source.banner" xml:space="preserve"> + <value>der Verbindungsbildschirm</value> + </data> + <data name="ecosystem.title" xml:space="preserve"> + <value>Das Ökosystem</value> + </data> + <data name="ecosystem.noTotals" xml:space="preserve"> + <value>Anteile, niemals Gesamtzahlen. Wir veröffentlichen keine Zahl dazu, wie viele Menschen MU* spielen: Ein Verhältnis über die von uns gemessenen Spiele übersteht die, die wir nicht erreichen können; eine Kopfzahl nicht.</value> + </data> + <data name="ecosystem.listed" xml:space="preserve"> + <value>{count, plural, one {{value} Spiel eingetragen} other {{value} Spiele eingetragen}}</value> + </data> + <data name="ecosystem.handshakes" xml:space="preserve"> + <value>{count, plural, one {{value} Spiel, dessen Handshake wir abgeschlossen haben} other {{value} Spiele, deren Handshake wir abgeschlossen haben}}</value> + </data> + <data name="ecosystem.msspReports" xml:space="preserve"> + <value>{count, plural, one {{value} Spiel, dessen MSSP-Bericht uns vorliegt} other {{value} Spiele, deren MSSP-Bericht uns vorliegt}}</value> + </data> + <data name="ecosystem.oldestHandshake" xml:space="preserve"> + <value>Ältester Handshake hier: bestätigt vor {age}.</value> + </data> + <data name="ecosystem.share" xml:space="preserve"> + <value>{count, number} von {total, number} ({fraction, number, ::percent .0})</value> + </data> + <data name="ecosystem.share.nothing" xml:space="preserve"> + <value>{count, number} von {total, number} — noch nichts gemessen</value> + </data> + <data name="ecosystem.share.percent" xml:space="preserve"> + <value>{fraction, number, ::percent .0}</value> + </data> + <data name="ecosystem.codebases.title" xml:space="preserve"> + <value>Codebases</value> + </data> + <data name="ecosystem.codebases.basis" xml:space="preserve"> + <value>Von {listed, plural, one {# eingetragenen Spiel} other {# eingetragenen Spielen}} haben uns {identified, number} mitgeteilt, was sie ausführen, und jeder Anteil unten bezieht sich auf diese {identified, number}. Eine Codebase, die wir nicht lesen konnten, bleibt aus dem Nenner heraus und wird nie als etwas anderes gezählt.</value> + </data> + <data name="ecosystem.codebases.none" xml:space="preserve"> + <value>Noch kein eingetragenes Spiel hat uns seine Codebase mitgeteilt.</value> + </data> + <data name="ecosystem.soleUse" xml:space="preserve"> + <value>{share} führen eine Codebase aus, die kein anderes eingetragenes Spiel ausführt — je ein Spiel, was ein Name ist und kein Anteil. Sie stecken im Nenner oben und sind aus den Balken herausgefaltet, nicht entfernt:</value> + </data> + <data name="ecosystem.lineages.title" xml:space="preserve"> + <value>Abstammungen</value> + </data> + <data name="ecosystem.lineages.basis" xml:space="preserve"> + <value>Dieselben Spiele, gruppiert nach der Tradition, von der ihr Server abstammt — unsere Lesart der Codebase, nicht etwas, das ein Spiel veröffentlicht hätte. Kein Spiel meldet „MUSH“: MSSP kennt keinen solchen Wert, und der größte Teil der MUSH-Welt veröffentlicht überhaupt kein MSSP, deshalb lässt sich die Frage nur so stellen.</value> + </data> + <data name="ecosystem.lineages.none" xml:space="preserve"> + <value>Noch kein eingetragenes Spiel führt eine Codebase aus, die wir einer Abstammung zuordnen.</value> + </data> + <data name="ecosystem.lineages.notClassified" xml:space="preserve"> + <value>{count, plural, one {# dieser Spiele führt eine Codebase aus} other {# dieser Spiele führen Codebases aus}}, die wir keiner Abstammung zuordnen — mehrere sagen das selbst und veröffentlichen {family}. Sie stecken im Nenner oben und in niemandes Anteil.</value> + </data> + <data name="ecosystem.protocols.title" xml:space="preserve"> + <value>Protokolle</value> + </data> + <data name="ecosystem.protocols.floor" xml:space="preserve"> + <value>Jede gemessene Zahl unten ist als Untergrenze zu lesen. MSSP fragen wir namentlich an, dort ist Schweigen also eine Antwort. Sonst wird hier nichts angefragt, und ein Server kann ein Protokoll unterstützen, ohne es je anzubieten.</value> + </data> + <data name="ecosystem.mssp.instrument" xml:space="preserve"> + <value>{instrument} ist die einzige Zeile unten, die keine Untergrenze ist: Wir fragen jeden Server namentlich danach, die Spiele, die es nicht angeboten haben, wurden also gefragt und haben abgelehnt. Es ist zugleich die einzige ohne angegebene Zahl, denn jedes Spiel, dessen Bericht uns vorliegt, unterstützt es durch Vorführung, und eine Zählung derer, die es zusätzlich aufgeführt haben, würde daran nur eine Gewohnheit messen.</value> + </data> + <data name="ecosystem.mssp.gap" xml:space="preserve"> + <value>Uns liegen {reports, number} Berichte vor, und {offered, plural, one {# Spiel bietet} other {# Spiele bieten}} MSSP heute an: Die übrigen {gap, number} haben nach unserem Lesen aufgehört, einen zu veröffentlichen, und ein Bericht wird nicht verworfen, weil er nicht mehr neu ausgegeben wird.</value> + </data> + <data name="ecosystem.protocols.caption" xml:space="preserve"> + <value>Verbreitung der Protokolle. Gemessen ist, was ein Server in einem abgeschlossenen Handshake angeboten hat; angegeben ist, was sein MSSP behauptet. Zwei Mengen von Spielen, also zwei Nenner.</value> + </data> + <data name="ecosystem.column.protocol" xml:space="preserve"> + <value>Protokoll</value> + </data> + <data name="ecosystem.column.measured" xml:space="preserve"> + <value>gemessen — von {basis}</value> + </data> + <data name="ecosystem.column.declared" xml:space="preserve"> + <value>angegeben — von {basis}</value> + </data> + <data name="ecosystem.measured.never" xml:space="preserve"> + <value>nicht gemessen — nie beobachtet</value> + </data> + <data name="ecosystem.measured.declined" xml:space="preserve"> + <value>{share} · {declined, plural, one {# Spiel hat} other {# Spiele haben}} auf Nachfrage abgelehnt</value> + </data> + <data name="ecosystem.measured.unasked" xml:space="preserve"> + <value>{share} · bei {unobserved, plural, one {# Spiel} other {# Spielen}} weder angeboten noch nachgefragt</value> + </data> + <data name="ecosystem.measured.declinedAndUnasked" xml:space="preserve"> + <value>{share} · {declined, plural, one {# Spiel hat} other {# Spiele haben}} auf Nachfrage abgelehnt · bei {unobserved, plural, one {# Spiel} other {# Spielen}} weder angeboten noch nachgefragt</value> + </data> + <data name="ecosystem.declared.none" xml:space="preserve"> + <value>nicht nachgefragt — jeder Bericht hier ist die Antwort</value> + </data> + <data name="ecosystem.curve.title" xml:space="preserve"> + <value>Verbreitung im Zeitverlauf</value> + </data> + <data name="ecosystem.curve.caveat" xml:space="preserve"> + <value>Jeder Punkt ist ein Anteil an den Spielen, die wir an jenem Tag gemessen hatten; diese Linie bewegt sich also aus zwei Gründen: weil ein Spiel ändert, was es anbietet, und weil sich die Menge der messbaren Spiele darum herum ändert. Nur das Erste ist Verbreitung. Die Zahl der Wechsel unten ist der Teil, der rein aus Spielen besteht, die es sich anders überlegt haben.</value> + </data> + <data name="ecosystem.curve.caption" xml:space="preserve"> + <value>Gemessener Anteil je Protokoll, älteste Messung zuerst</value> + </data> + <data name="ecosystem.curve.then" xml:space="preserve"> + <value>damals</value> + </data> + <data name="ecosystem.curve.now" xml:space="preserve"> + <value>jetzt</value> + </data> + <data name="ecosystem.curve.notMeasured" xml:space="preserve"> + <value>nicht gemessen</value> + </data> + <data name="ecosystem.snapshot.title" xml:space="preserve"> + <value>Eine Momentaufnahme, keine Kurve</value> + </data> + <data name="ecosystem.snapshot" xml:space="preserve"> + <value>Eine Momentaufnahme dessen, was wir jetzt messen können. Eine Verbreitungskurve zeichnet Spiele, die es sich anders überlegen; wir halten eine Änderung fest, wenn sie geschieht, die Kurve wird also zeichenbar, sobald genug davon erfasst sind. Zu zeichnen, wann wir jedes Spiel zuerst erreicht haben, würde den Crawl messen und nicht das Hobby.</value> + </data> + <data name="ecosystem.transitions" xml:space="preserve"> + <value>{count, plural, one {# geänderte Fähigkeit} other {# geänderte Fähigkeiten}} bisher erfasst — das Material, aus dem eine Kurve gezeichnet wird.</value> + </data> + <data name="ecosystem.transitions.none" xml:space="preserve"> + <value>Noch hat sich keine gemessene Fähigkeit geändert, es gibt also nichts zu zeichnen.</value> + </data> + <data name="ecosystem.plain.denominators" xml:space="preserve"> + <value>Gemessen bezieht sich auf {measured}; angegeben auf {declared}. Zwei Mengen von Spielen, also zwei Nenner.</value> + </data> + <data name="ecosystem.plain.counts" xml:space="preserve"> + <value>{listed} · {handshakes} · {mssp}.</value> + </data> + <data name="ecosystem.plain.oldestHandshake" xml:space="preserve"> + <value>Der älteste Handshake in diesem Bild wurde zuletzt vor {age} bestätigt.</value> + </data> + <data name="ecosystem.plain.lineages" xml:space="preserve"> + <value>Dieselben Spiele, gruppiert nach der Tradition, von der ihr Server abstammt. Das ist {evidence} — {meaning} — und nicht etwas, das ein Spiel veröffentlicht hätte: Kein Spiel meldet „MUSH“, denn MSSP kennt keinen solchen Wert, und der größte Teil der MUSH-Welt veröffentlicht überhaupt kein MSSP.</value> + </data> + <data name="ecosystem.plain.measured" xml:space="preserve"> + <value>gemessen: {value}</value> + </data> + <data name="ecosystem.plain.declared" xml:space="preserve"> + <value>angegeben: {value}</value> + </data> + <data name="rankings.title" xml:space="preserve"> + <value>Ranglisten</value> + </data> + <data name="rankings.noVote" xml:space="preserve"> + <value>Ausschließlich aus gemessenen Daten berechnet. Keine Stimmen, Sterne oder Bewertungen, niemals. Nichts hier ordnet nach Qualität. Die haben wir nicht gemessen.</value> + </data> + <data name="rankings.busiest.title" xml:space="preserve"> + <value>Am belebtesten, nach gemessenen gleichzeitigen Spielern</value> + </data> + <data name="rankings.window.label" xml:space="preserve"> + <value>Zeitraum der Rangliste</value> + </data> + <data name="rankings.span" xml:space="preserve"> + <value>{days, plural, one {# Tag} other {# Tage}}</value> + </data> + <data name="rankings.basis.median" xml:space="preserve"> + <value>Median der Spielerzahlen, die wir in {days, plural, one {dem letzten # Tag} other {den letzten # Tagen}} gemessen haben.</value> + </data> + <data name="rankings.basis.none" xml:space="preserve"> + <value>Noch kein Spiel hat die {samples, number} Zählungen über {days, plural, one {# Tag} other {# Tage}}, die ein Median braucht.</value> + </data> + <data name="rankings.basis.eligible" xml:space="preserve"> + <value>{eligible, plural, one {# von {listed, number} Spielen hat} other {# von {listed, number} Spielen haben}} die nötigen {samples, number} Zählungen über {days, plural, one {# Tag} other {# Tage}}.</value> + </data> + <data name="rankings.basis.zero" xml:space="preserve"> + <value>Eine gemessene Null zählt; eine unlesbare Zählung nicht.</value> + </data> + <data name="rankings.spanChoice" xml:space="preserve"> + <value>Eine Woche sagt, wer jetzt belebt ist; ein Quartal sagt, wer belebt gewesen ist. Das sind verschiedene Fragen, und ein Spiel kann die eine anführen und die andere nicht. Tage sind ganze Tage, in UTC.</value> + </data> + <data name="rankings.busiest.empty" xml:space="preserve"> + <value>Noch hat kein eingetragenes Spiel genug Zählungen für eine Rangfolge — eine Aussage darüber, wie lange wir schon messen, nicht darüber, wie belebt irgendjemand ist.</value> + </data> + <data name="rankings.busiest.caption" xml:space="preserve"> + <value>Spiele, geordnet nach dem Median der Spielerzahlen, die wir in {days, plural, one {dem letzten # Tag} other {den letzten # Tagen}} gemessen haben. Spiele mit demselben Median teilen sich einen Platz; nichts hier entscheidet den Gleichstand.</value> + </data> + <data name="rankings.column.place" xml:space="preserve"> + <value>#</value> + </data> + <data name="rankings.column.game" xml:space="preserve"> + <value>Spiel</value> + </data> + <data name="rankings.column.median" xml:space="preserve"> + <value>Median</value> + </data> + <data name="rankings.column.peak" xml:space="preserve"> + <value>Spitze</value> + </data> + <data name="rankings.column.samples" xml:space="preserve"> + <value>Zählungen</value> + </data> + <data name="rankings.column.days" xml:space="preserve"> + <value>gemessene Tage</value> + </data> + <data name="rankings.spells.title" xml:space="preserve"> + <value>Längste durchgehende Erreichbarkeit</value> + </data> + <data name="rankings.spells.basis" xml:space="preserve"> + <value>Jede Abfrage seit dem genannten Datum hat das Spiel erreichbar vorgefunden. Erreichbar, nicht online: Wir messen einen Socket von einem einzigen Host aus, und ein Spiel, zu dem wir keine Route finden, ist dennoch völlig lebendig. Eine solche Strecke kann nicht länger sein, als wir zusehen, deshalb ist das Datum die Tatsache und die Dauer folgt daraus.</value> + </data> + <data name="rankings.spells.empty" xml:space="preserve"> + <value>Zurzeit ist kein eingetragenes Spiel durchgehend erreichbar.</value> + </data> + <data name="rankings.spells.caption" xml:space="preserve"> + <value>Spiele, bei denen jede Abfrage seit dem genannten Datum sie erreichbar vorgefunden hat. Spiele, die seit demselben Datum erreichbar sind, teilen sich einen Platz; nichts hier entscheidet den Gleichstand.</value> + </data> + <data name="rankings.column.since" xml:space="preserve"> + <value>erreichbar seit</value> + </data> + <data name="rankings.column.duration" xml:space="preserve"> + <value>das sind</value> + </data> + <data name="rankings.archivedNote" xml:space="preserve"> + <value>Archivierte Spiele sind aus beiden Tabellen heraus und aus sonst nichts; eine einzige erfolgreiche Abfrage bringt sie zurück.</value> + </data> + <data name="rankings.plain.busiest" xml:space="preserve"> + <value>Am belebtesten — Median der gemessenen Spieler, {days, plural, one {letzter # Tag} other {letzte # Tage}}</value> + </data> + <data name="rankings.plain.windows" xml:space="preserve"> + <value>Zeiträume:</value> + </data> + <data name="rankings.plain.thisOne" xml:space="preserve"> + <value>dieser</value> + </data> + <data name="rankings.plain.row" xml:space="preserve"> + <value>Median {median, number} · Spitze {peak, number} · {samples, plural, one {# Zählung} other {# Zählungen}} an {days, number} von {window, number} Tagen</value> + </data> + <data name="rankings.plain.spellRow" xml:space="preserve"> + <value>bei jeder Abfrage seit {date} erreichbar · {duration}</value> + </data> + <data name="archive.title" xml:space="preserve"> + <value>Das Archiv</value> + </data> + <data name="archive.lede" xml:space="preserve"> + <value>Spiele, die nicht mehr antworten. Nichts wurde gelöscht. Sie werden weiterhin wöchentlich abgefragt, und eine einzige erfolgreiche Abfrage bringt ein Spiel noch am selben Tag zurück ins Verzeichnis.</value> + </data> + <data name="archive.search.legend" xml:space="preserve"> + <value>das Archiv durchsuchen</value> + </data> + <data name="archive.search.label" xml:space="preserve"> + <value>Archivierte Spiele suchen</value> + </data> + <data name="archive.search.placeholder" xml:space="preserve"> + <value>Name, Codebase oder Beschreibung</value> + </data> + <data name="archive.search.submit" xml:space="preserve"> + <value>zeigen</value> + </data> + <data name="archive.count" xml:space="preserve"> + <value>{count, plural, =0 {Keine archivierten Spiele} one {# archiviertes Spiel} other {# archivierte Spiele}}</value> + </data> + <data name="archive.badge" xml:space="preserve"> + <value>archiviert</value> + </data> + <data name="archive.lastReachable" xml:space="preserve"> + <value>zuletzt erreichbar</value> + </data> + <data name="archive.knownLive" xml:space="preserve"> + <value>nachweislich aktiv</value> + </data> + <data name="archive.darkFor" xml:space="preserve"> + <value>(vor {age})</value> + </data> + <data name="archive.empty" xml:space="preserve"> + <value>Keine Treffer.</value> + </data> + <data name="archive.neverReachable" xml:space="preserve"> + <value>nie, in nichts, was wir gemessen haben</value> + </data> + <data name="archive.noReachableTime" xml:space="preserve"> + <value>keine erreichbare Zeit gemessen</value> + </data> + <data name="archive.darkFor.unknown" xml:space="preserve"> + <value>unbekannt</value> + </data> + <data name="archive.knownLive.years" xml:space="preserve"> + <value>{years, number, ::.#} Jahre</value> + </data> + <data name="archive.knownLive.days" xml:space="preserve"> + <value>{days, plural, one {# Tag} other {# Tage}}</value> + </data> + <data name="archive.run" xml:space="preserve"> + <value>{from} – {to} · {span}</value> + </data> + <data name="archive.run.months" xml:space="preserve"> + <value>{count, plural, one {# Monat} other {# Monate}}</value> + </data> + <data name="archive.run.years" xml:space="preserve"> + <value>{count, plural, one {# Jahr} other {# Jahre}}</value> + </data> + <data name="archive.plain.matching" xml:space="preserve"> + <value>{count, plural, one {# Spiel passt} other {# Spiele passen}} zu „{query}“</value> + </data> + <data name="archive.plain.count" xml:space="preserve"> + <value>{count, plural, one {# Spiel} other {# Spiele}}</value> + </data> + <data name="archive.plain.lastReachable" xml:space="preserve"> + <value>Zuletzt erreichbar:</value> + </data> + <data name="archive.plain.knownLive" xml:space="preserve"> + <value>Nachweislich aktiv:</value> + </data> + <data name="archive.plain.knownLiveValue" xml:space="preserve"> + <value>{value} gemessener erreichbarer Zeit</value> + </data> + <data name="archive.plain.run" xml:space="preserve"> + <value>Laufzeit:</value> + </data> + <data name="archive.plain.codebase" xml:space="preserve"> + <value>Codebase:</value> + </data> + <data name="footer.randomGame" xml:space="preserve"> + <value>zufälliges Spiel</value> + </data> + <data name="trend.day.counted" xml:space="preserve"> + <value>{d, date, medium} — durchschnittlich {typical}, {low}–{high} über {probes, plural, one {# Abfrage} other {# Abfragen}}</value> + </data> + <data name="trend.day.flat" xml:space="preserve"> + <value>{d, date, medium} — {count, plural, =0 {0 Spieler} one {# Spieler} other {# Spieler}}, in jeder von {probes, plural, one {# Abfrage} other {# Abfragen}}</value> + </data> + <data name="trend.day.notCounted" xml:space="preserve"> + <value>{d, date, medium} — abgefragt, keine Zählung ablesbar</value> + </data> + <data name="trend.day.notMeasured" xml:space="preserve"> + <value>{d, date, medium} — keine Messung</value> + </data> + <data name="trend.summary" xml:space="preserve"> + <value>Typischerweise {typical} verbunden, Spitze {peak}, an {counted} von {days, plural, one {# Tag} other {# Tagen}}.</value> + </data> + <data name="trend.direction.steady" xml:space="preserve"> + <value>Über den Zeitraum hinweg gleichbleibend.</value> + </data> + <data name="trend.direction.up" xml:space="preserve"> + <value>Vom Anfang des Zeitraums bis zum Ende um etwa {change, number, percent} gestiegen.</value> + </data> + <data name="trend.direction.down" xml:space="preserve"> + <value>Vom Anfang des Zeitraums bis zum Ende um etwa {change, number, percent} gefallen.</value> + </data> + <data name="trend.none.probed" xml:space="preserve"> + <value>In diesem Zeitraum abgefragt, und aus nichts davon war eine Spielerzahl ablesbar.</value> + </data> + <data name="trend.none.notMeasured" xml:space="preserve"> + <value>Keine Messung in diesem Zeitraum.</value> + </data> + <data name="trend.empty" xml:space="preserve"> + <value>In diesem Zeitraum nichts gezählt.</value> + </data> + <data name="trend.week.span" xml:space="preserve"> + <value>{from, date, d MMM}–{to, date, d MMM}</value> + </data> + <data name="trend.week.oneDay" xml:space="preserve"> + <value>{d, date, d MMM}</value> + </data> + <data name="trend.week.counted" xml:space="preserve"> + <value>{span}: typischerweise {typical}, Spitze {peak}, {days, plural, one {# Tag} other {# Tage}} gezählt</value> + </data> + <data name="trend.week.notCounted" xml:space="preserve"> + <value>{span}: abgefragt, keine Zählung ablesbar</value> + </data> + <data name="trend.week.notMeasured" xml:space="preserve"> + <value>{span}: nicht gemessen</value> + </data> + <data name="trend.week.uncounted" xml:space="preserve"> + <value>{count, plural, one {# Tag ohne Zählung abgefragt} other {# Tage ohne Zählung abgefragt}}</value> + </data> + <data name="trend.week.unmeasured" xml:space="preserve"> + <value>{count, plural, one {# Tag nicht gemessen} other {# Tage nicht gemessen}}</value> + </data> + <data name="trend.week.and" xml:space="preserve"> + <value>{line}, {clause}</value> + </data> + <data name="trend.range" xml:space="preserve"> + <value>Tage in UTC · {from, date, medium} – {to, date, medium}</value> + </data> + <data name="trend.ceiling" xml:space="preserve"> + <value>{value} ganz oben</value> + </data> + <data name="trend.counted" xml:space="preserve"> + <value>{counted} von {days, plural, one {# Tag} other {# Tagen}} gezählt</value> + </data> + <data name="trend.axis.month" xml:space="preserve"> + <value>{d, date, MMM}</value> + </data> + <data name="trend.axis.monthYear" xml:space="preserve"> + <value>{d, date, MMM yyyy}</value> + </data> + <data name="trend.legend.mean" xml:space="preserve"> + <value>Mittel der an dem Tag gelesenen Zählungen</value> + </data> + <data name="trend.legend.peak" xml:space="preserve"> + <value>bis zur höchsten Zählung des Tages</value> + </data> + <data name="trend.legend.band" xml:space="preserve"> + <value>niedrigste bis höchste Zählung des Tages</value> + </data> + <data name="trend.legend.notCounted" xml:space="preserve"> + <value>abgefragt, keine Zählung ablesbar</value> + </data> + <data name="trend.legend.notMeasured.bar" xml:space="preserve"> + <value>nicht gemessen — gar kein Balken</value> + </data> + <data name="trend.legend.notMeasured.line" xml:space="preserve"> + <value>nicht gemessen — eine Lücke in der Linie</value> + </data> + <data name="trend.spans.label" xml:space="preserve"> + <value>Zeitraum des Verlaufs</value> + </data> + <data name="trend.shapes.label" xml:space="preserve"> + <value>Form des Verlaufs</value> + </data> + <data name="trend.preset" xml:space="preserve"> + <value>{days, plural, one {# Tag} other {# Tage}}</value> + </data> + <data name="trend.earlier" xml:space="preserve"> + <value>← früher</value> + </data> + <data name="trend.later" xml:space="preserve"> + <value>später →</value> + </data> + <data name="trend.shape.line" xml:space="preserve"> + <value>Linie</value> + </data> + <data name="trend.shape.bar" xml:space="preserve"> + <value>Balken</value> + </data> + <data name="trend.plain.heading" xml:space="preserve"> + <value>Wie viele, im Zeitverlauf</value> + </data> + <data name="trend.plain.range" xml:space="preserve"> + <value>{from, date, medium} – {to, date, medium}, UTC</value> + </data> + <data name="trend.plain.earlier" xml:space="preserve"> + <value>früher</value> + </data> + <data name="trend.plain.note" xml:space="preserve"> + <value>eine Woche wird über die in ihr gezählten Tage zusammengefasst; eine Woche ohne solche sagt das</value> + </data> + <data name="reach.kicker" xml:space="preserve"> + <value>erreichbar · {days, plural, one {letzter # Tag} other {letzte # Tage}}</value> + </data> + <data name="reach.stat.reachable" xml:space="preserve"> + <value>erreichbar</value> + </data> + <data name="reach.stat.longestOutage" xml:space="preserve"> + <value>längste Unterbrechung</value> + </data> + <data name="reach.stat.lastCause" xml:space="preserve"> + <value>letzte Ursache</value> + </data> + <data name="reach.noOutage" xml:space="preserve"> + <value>keine im Zeitraum</value> + </data> + <data name="reach.noCause" xml:space="preserve"> + <value>nichts festgehalten</value> + </data> + <data name="reach.scale.ago" xml:space="preserve"> + <value>{days, plural, one {vor # Tag} other {vor # Tagen}}</value> + </data> + <data name="reach.scale.today" xml:space="preserve"> + <value>heute</value> + </data> + <data name="reach.legend.reachable" xml:space="preserve"> + <value>erreichbar</value> + </data> + <data name="reach.legend.degraded" xml:space="preserve"> + <value>eingeschränkt — geantwortet, nicht abgeschlossen</value> + </data> + <data name="reach.legend.unreachable" xml:space="preserve"> + <value>nicht erreichbar</value> + </data> + <data name="reach.legend.notMeasured" xml:space="preserve"> + <value>nicht gemessen</value> + </data> + <data name="reach.word.reachable" xml:space="preserve"> + <value>erreichbar</value> + </data> + <data name="reach.word.degraded" xml:space="preserve"> + <value>eingeschränkt</value> + </data> + <data name="reach.word.unreachable" xml:space="preserve"> + <value>nicht erreichbar</value> + </data> + <data name="reach.word.notMeasured" xml:space="preserve"> + <value>nicht gemessen</value> + </data> + <data name="reach.day.reachable" xml:space="preserve"> + <value>{d, date, d MMM} — den ganzen Tag erreichbar</value> + </data> + <data name="reach.day.degraded" xml:space="preserve"> + <value>{d, date, d MMM} — eingeschränkt ({cause}): geantwortet, nicht abgeschlossen</value> + </data> + <data name="reach.day.unreachable" xml:space="preserve"> + <value>{d, date, d MMM} — nicht erreichbar ({cause})</value> + </data> + <data name="reach.day.notMeasured" xml:space="preserve"> + <value>{d, date, d MMM} — nicht gemessen; wir haben dieses Spiel damals noch nicht beobachtet</value> + </data> + <data name="reach.none" xml:space="preserve"> + <value>{days, plural, one {Für den letzten # Tag noch nicht gemessen.} other {Für die letzten # Tage noch nicht gemessen.}}</value> + </data> + <data name="reach.fraction.window" xml:space="preserve"> + <value>{days, plural, one {Erreichbar in {percent} des letzten Tages.} other {Erreichbar in {percent} der letzten # Tage.}}</value> + </data> + <data name="reach.fraction.measured" xml:space="preserve"> + <value>{days, plural, one {Erreichbar in {percent} des einen Tages, den wir gemessen haben.} other {Erreichbar in {percent} der # Tage, die wir gemessen haben.}}</value> + </data> + <data name="reach.fraction.unknown" xml:space="preserve"> + <value>{days, plural, one {Die Erreichbarkeit des letzten Tages ist noch nicht gemessen.} other {Die Erreichbarkeit der letzten # Tage ist noch nicht gemessen.}}</value> + </data> + <data name="reach.unreachable.noneInWindow" xml:space="preserve"> + <value>An keinem Tag im Zeitraum war das Spiel nicht erreichbar.</value> + </data> + <data name="reach.unreachable.noneMeasured" xml:space="preserve"> + <value>An keinem von uns gemessenen Tag war das Spiel nicht erreichbar.</value> + </data> + <data name="reach.unreachable.days" xml:space="preserve"> + <value>{count, plural, one {# Tag nicht erreichbar.} other {# Tage nicht erreichbar.}}</value> + </data> + <data name="reach.degraded.days" xml:space="preserve"> + <value>{count, plural, one {# Tag eingeschränkt — wir sind hineingekommen und konnten nicht abschließen.} other {# Tage eingeschränkt — wir sind hineingekommen und konnten nicht abschließen.}}</value> + </data> + <data name="reach.longestOutage" xml:space="preserve"> + <value>Längste Unterbrechung {duration}.</value> + </data> + <data name="reach.longestOutage.cause" xml:space="preserve"> + <value>Längste Unterbrechung {duration} ({cause}).</value> + </data> + <data name="reach.predate" xml:space="preserve"> + <value>{count, plural, one {# Tag liegt vor allem, was wir gemessen haben.} other {# Tage liegen vor allem, was wir gemessen haben.}}</value> + </data> + <data name="reach.spell.range" xml:space="preserve"> + <value>{from, date, d MMM} – {to, date, d MMM}</value> + </data> + <data name="reach.spell.oneDay" xml:space="preserve"> + <value>{d, date, d MMM}</value> + </data> + <data name="reach.spell" xml:space="preserve"> + <value>{range}: {count, plural, one {# Tag} other {# Tage}} {word}</value> + </data> + <data name="reach.spell.cause" xml:space="preserve"> + <value>{range}: {count, plural, one {# Tag} other {# Tage}} {word} ({cause})</value> + </data> + <data name="reach.plain.heading" xml:space="preserve"> + <value>Erreichbar</value> + </data> + <data name="reach.plain.window" xml:space="preserve"> + <value>{days, plural, one {letzter # Tag} other {letzte # Tage}}</value> + </data> + <data name="reach.plain.fraction" xml:space="preserve"> + <value>Erreichbar: {percent} {days, plural, one {des letzten Tages} other {der letzten # Tage}}</value> + </data> + <data name="reach.plain.longestOutage" xml:space="preserve"> + <value>Längste Unterbrechung: {duration}</value> + </data> + <data name="cause.dns" xml:space="preserve"> + <value>dns hat nicht aufgelöst</value> + </data> + <data name="cause.refused" xml:space="preserve"> + <value>Verbindung abgelehnt</value> + </data> + <data name="cause.tls" xml:space="preserve"> + <value>tls fehlgeschlagen</value> + </data> + <data name="cause.timeout" xml:space="preserve"> + <value>Zeitüberschreitung</value> + </data> + <data name="cause.handshakeStalled" xml:space="preserve"> + <value>Handshake hängen geblieben</value> + </data> + <data name="cause.none" xml:space="preserve"> + <value>keine Ursache festgehalten</value> + </data> + <data name="ansi.suppressed" xml:space="preserve"> + <value>Der Betreiber hat uns gebeten, den Verbindungsbildschirm dieses Spiels nicht erneut zu veröffentlichen.</value> + </data> + <data name="ansi.absent" xml:space="preserve"> + <value>Von diesem Spiel wurde kein Verbindungsbildschirm aufgezeichnet.</value> + </data> + <data name="ansi.tooSmall" xml:space="preserve"> + <value>{count, plural, one {Nur # Zeile kam zurück — zu wenig zum Anzeigen.} other {Nur # Zeilen kamen zurück — zu wenig zum Anzeigen.}}</value> + </data> + <data name="ansi.asSent" xml:space="preserve"> + <value>so, wie der Server ihn gesendet hat</value> + </data> + <data name="ansi.size" xml:space="preserve"> + <value>{columns}×{rows}</value> + </data> + <data name="ansi.size.doubleWidth" xml:space="preserve"> + <value>{columns}×{rows}, doppelte Breite</value> + </data> + <data name="ansi.depth.colour" xml:space="preserve"> + <value>16-Farben-SGR</value> + </data> + <data name="ansi.depth.plain" xml:space="preserve"> + <value>keine Farbe</value> + </data> + <data name="ansi.readAs" xml:space="preserve"> + <value>gelesen als {charset}</value> + </data> + <data name="ansi.captured" xml:space="preserve"> + <value>aufgezeichnet</value> + </data> + <data name="ansi.frozen" xml:space="preserve"> + <value>eingefroren — der letzte Bildschirm, den wir gesehen haben</value> + </data> + <data name="ansi.alt.named" xml:space="preserve"> + <value>ASCII-Grafik: der Verbindungsbildschirm von {game}. Sein Text steht unten unter „als Text lesen“.</value> + </data> + <data name="ansi.alt" xml:space="preserve"> + <value>ASCII-Grafik: der Verbindungsbildschirm dieses Spiels. Sein Text steht unten unter „als Text lesen“.</value> + </data> + <data name="ansi.plain.rows" xml:space="preserve"> + <value>{count, plural, one {Verbindungsbildschirm: # Zeile, nur Text} other {Verbindungsbildschirm: # Zeilen, nur Text}}</value> + </data> + <data name="ansi.plain.rows.readAs" xml:space="preserve"> + <value>{count, plural, one {Verbindungsbildschirm: # Zeile, nur Text, gelesen als {charset}} other {Verbindungsbildschirm: # Zeilen, nur Text, gelesen als {charset}}}</value> + </data> + <data name="capability.disagree.declaredNotOffered" xml:space="preserve"> + <value>das Spiel gibt es an, und der Server hat es in keinem Handshake je angeboten.</value> + </data> + <data name="capability.disagree.offeredNotDeclared" xml:space="preserve"> + <value>der Server bietet es an, und die eigene Angabe des Spiels sagt, dass er es nicht tut.</value> + </data> + <data name="capability.disagree.note" xml:space="preserve"> + <value>Meist ein veraltetes, von Hand getipptes Feld und keine Lüge. Gezeigt, weil ein Client sich auf das, worin beide sich widersprechen, nicht verlassen sollte.</value> + </data> + <data name="game.notFound" xml:space="preserve"> + <value>Nicht gefunden</value> + </data> + <data name="game.notFound.hint" xml:space="preserve"> + <value>Kein Spiel unter dieser Adresse. Schreibweise prüfen.</value> + </data> + <data name="game.endpoint.lastAnswered" xml:space="preserve"> + <value>zuletzt geantwortet</value> + </data> + <data name="game.stale" xml:space="preserve"> + <value>{count, plural, one {# ist über das Aktualisierungsfenster hinaus. Alt, nicht falsch.} other {# sind über das Aktualisierungsfenster hinaus. Alt, nicht falsch.}}</value> + </data> + <data name="game.referrals.lists" xml:space="preserve"> + <value>Die eigene Verweisliste dieses Spiels nennt:</value> + </data> + <data name="game.referrals.listedBy" xml:space="preserve"> + <value>Genannt von der Verweisliste von:</value> + </data> + <data name="game.referral.since" xml:space="preserve"> + <value>seit {date}</value> + </data> + <data name="game.referral.dropped" xml:space="preserve"> + <value>nicht mehr gelistet, zuletzt gesehen</value> + </data> + <data name="game.archived.lastAnswered" xml:space="preserve"> + <value>Zuletzt geantwortet am {date}, vor {ago}.</value> + </data> + <data name="game.archived.stillProbed" xml:space="preserve"> + <value>Wird weiterhin wöchentlich abgefragt; diese Seite aktualisiert sich an dem Tag, an dem es antwortet.</value> + </data> + <data name="game.archived.knownLive" xml:space="preserve"> + <value>{span} nachweislich aktiv</value> + </data> + <data name="game.excluded" xml:space="preserve"> + <value>Nicht im Verzeichnis, nicht in den Ranglisten und nicht in der Tageszahl: Wir halten diese Adresse nicht für ein Spiel, das sich spielen lässt. Alles unten ist das, was sie uns mitgeteilt hat, unverändert.</value> + </data> + <data name="game.excluded.reason" xml:space="preserve"> + <value>Unser Grund: {why}</value> + </data> + <data name="game.unlisted" xml:space="preserve"> + <value>Nicht im Verzeichnis, nicht in den Ranglisten und nicht in der Tageszahl, auf Bitte der Leute, die es betreiben. Alles unten bleibt erhalten, wie es war, diese Seite und jede Adresse, die es je hatte, antworten weiterhin, und wir wählen es nicht an.</value> + </data> + <data name="game.plain.playersNow" xml:space="preserve"> + <value>Jetzt verbunden: {count}</value> + </data> + <data name="game.plain.capabilities" xml:space="preserve"> + <value>Fähigkeiten ({disagreeing} von {total} widersprechen)</value> + </data> + <data name="game.plain.declared" xml:space="preserve"> + <value>Vom Spiel angegeben</value> + </data> + <data name="game.plain.connectScreen" xml:space="preserve"> + <value>Verbindungsbildschirm</value> + </data> + <data name="game.plain.whatChanged" xml:space="preserve"> + <value>Was sich geändert hat</value> + </data> + <data name="game.plain.measured" xml:space="preserve"> + <value>gemessen</value> + </data> + <data name="game.plain.declared.column" xml:space="preserve"> + <value>angegeben</value> + </data> + <data name="game.plain.disagree" xml:space="preserve"> + <value>** widersprechen</value> + </data> + <data name="listing.row.connected" xml:space="preserve"> + <value>Verbindungen</value> + </data> + <data name="listing.row.reached" xml:space="preserve"> + <value>erreicht</value> + </data> + <data name="facet.group.search" xml:space="preserve"> + <value>Suche</value> + </data> + <data name="facet.group.archived" xml:space="preserve"> + <value>archiviert</value> + </data> + <data name="facet.group.adult" xml:space="preserve"> + <value>Erwachseneninhalte</value> + </data> + <data name="facet.value.included" xml:space="preserve"> + <value>einbezogen</value> + </data> + <data name="game.count.none" xml:space="preserve"> + <value>keine Zählung</value> + </data> + <data name="game.count.none.why" xml:space="preserve"> + <value>keine aktuelle Zählung, und nichts hier nennt einen Grund</value> + </data> + <data name="game.plain.playersNoCount" xml:space="preserve"> + <value>Jetzt verbunden: keine Zählung (nichts hier nennt einen Grund)</value> + </data> + <data name="crawler.live" xml:space="preserve"> + <value>Crawler aktiv · letzte Abfrage {age}</value> + </data> + <data name="crawler.quiet" xml:space="preserve"> + <value>Crawler im Leerlauf · letzte Abfrage {age}</value> + </data> + <data name="crawler.noProbe" xml:space="preserve"> + <value>hier ist noch keine Abfrage abgeschlossen</value> + </data> + <data name="crawler.cycle.nothingDue" xml:space="preserve"> + <value>in diesem Zyklus nichts fällig</value> + </data> + <data name="crawler.cycle" xml:space="preserve"> + <value>{considered, plural, one {# fällig} other {# fällig}} · {answered, plural, one {# geantwortet} other {# geantwortet}} · {failed, plural, one {# fehlgeschlagen} other {# fehlgeschlagen}}</value> + </data> + <data name="crawler.registry" xml:space="preserve"> + <value>{targets, plural, one {# Adresse im Register} other {# Adressen im Register}}, {due, plural, one {# jetzt fällig} other {# jetzt fällig}}</value> + </data> + <data name="preview.documentTitle" xml:space="preserve"> + <value>{page} — {site}</value> + </data> + <data name="preview.site" xml:space="preserve"> + <value>Ein Verzeichnis des MU*-Hobbys — MUSHes, MUDs, MUCKs, MOOs — in dem jede Tatsache ihre Herkunft und ihr Alter nennt.</value> + </data> + <data name="preview.demo" xml:space="preserve"> + <value>Demodaten — nichts davon wurde gemessen. {description}</value> + </data> + <data name="preview.cardAlt" xml:space="preserve"> + <value>{site} — gemessen, nicht behauptet</value> + </data> + <data name="preview.cardAlt.named" xml:space="preserve"> + <value>{title} auf {site}</value> + </data> + <data name="preview.title.games" xml:space="preserve"> + <value>Spiele</value> + </data> + <data name="preview.title.archive" xml:space="preserve"> + <value>Das Archiv</value> + </data> + <data name="preview.title.rankings" xml:space="preserve"> + <value>Ranglisten</value> + </data> + <data name="preview.title.ecosystem" xml:space="preserve"> + <value>Das Ökosystem</value> + </data> + <data name="preview.title.reference" xml:space="preserve"> + <value>Referenz</value> + </data> + <data name="preview.title.about" xml:space="preserve"> + <value>Über uns</value> + </data> + <data name="preview.title.notFound" xml:space="preserve"> + <value>Nicht gefunden</value> + </data> + <data name="preview.title.random" xml:space="preserve"> + <value>Zufälliges Spiel</value> + </data> + <data name="preview.title.account" xml:space="preserve"> + <value>Ihre Spiele</value> + </data> + <data name="preview.title.claim" xml:space="preserve"> + <value>{game} beanspruchen</value> + </data> + <data name="preview.desc.games" xml:space="preserve"> + <value>Jedes MU*, das wir erreicht haben, gefiltert nach Gemessenem: Codebase, Protokolle aus dem Handshake, TLS, Kodierung, Sprache, letzter Zugang.</value> + </data> + <data name="preview.desc.archive" xml:space="preserve"> + <value>Verstummte Spiele, aufbewahrt. Jedes behält Seite, Verlauf und URL, wird wöchentlich abgefragt und kehrt bei einer erfolgreichen Verbindung zurück.</value> + </data> + <data name="preview.desc.rankings" xml:space="preserve"> + <value>Am belebtesten, am besten erreichbar, am längsten laufend — allein aus Messungen berechnet. Keine Stimmen, Sterne oder Bewertungen auf dieser Website.</value> + </data> + <data name="preview.desc.ecosystem" xml:space="preserve"> + <value>Codebase-Anteile und Protokollverbreitung über die von uns gemessenen Spiele, das Angebotene neben dem Angegebenen. Anteile, niemals Gesamtzahlen.</value> + </data> + <data name="preview.desc.reference" xml:space="preserve"> + <value>Von Hand geschriebene Seiten zu den Codebases, Clients und Protokollen des MU*-Hobbys, verlinkt mit Zahlen aus dem Crawl.</value> + </data> + <data name="preview.desc.about" xml:space="preserve"> + <value>Wie dieser Katalog entsteht: was der Crawler tut, was er zu tun verweigert und wie er sich stoppen lässt.</value> + </data> + <data name="preview.desc.notFound" xml:space="preserve"> + <value>Kein Spiel unter dieser Adresse. Hier wird nichts gelöscht, ein Spiel, das einmal unter dieser URL lag, liegt also weiterhin dort — Schreibweise prüfen.</value> + </data> + <data name="preview.desc.random" xml:space="preserve"> + <value>Ein Spiel aus dem Katalog, zufällig gewählt und nie zweimal dasselbe.</value> + </data> + <data name="preview.desc.account" xml:space="preserve"> + <value>Die Einträge, die Sie beansprucht haben, und was ein Anspruch Ihnen zu ändern erlaubt.</value> + </data> + <data name="preview.desc.claim" xml:space="preserve"> + <value>Weisen Sie nach, dass Sie dieses Spiel betreiben, indem Sie einen Token dort veröffentlichen, wo nur sein Betreiber ihn hinstellen könnte.</value> + </data> + <data name="preview.game.archived" xml:space="preserve"> + <value>Archiviert — zuletzt erreichbar {age}, wird weiter abgefragt</value> + </data> + <data name="preview.game.archived.undated" xml:space="preserve"> + <value>Archiviert, wird weiter abgefragt</value> + </data> + <data name="preview.game.countUnknown" xml:space="preserve"> + <value>Spielerzahl unbekannt — das Spiel antwortet und veröffentlicht keine Zahl, die wir lesen können</value> + </data> + <data name="preview.game.count" xml:space="preserve"> + <value>{count, plural, one {# Spieler} other {# Spieler}}, {how} {age}</value> + </data> + <data name="feed.plain.newlyDiscovered" xml:space="preserve"> + <value>Neu entdeckt</value> + </data> + <data name="feed.plain.wentDark" xml:space="preserve"> + <value>Verstummt</value> + </data> + <data name="feed.plain.cameBack" xml:space="preserve"> + <value>Wieder da</value> + </data> + <data name="home.plain.known" xml:space="preserve"> + <value>{count, plural, one {# Spiel bekannt} other {# Spiele bekannt}}</value> + </data> + <data name="home.plain.connectedNow" xml:space="preserve"> + <value>{count, plural, one {# jetzt verbunden (gemessen)} other {# jetzt verbunden (gemessen)}}</value> + </data> + <data name="home.plain.uncounted" xml:space="preserve"> + <value>{count, plural, one {# antwortend, ungezählt} other {# antwortend, ungezählt}}</value> + </data> + <data name="home.plain.archived" xml:space="preserve"> + <value>{count, plural, one {# archiviert, wird weiter abgefragt} other {# archiviert, werden weiter abgefragt}}</value> + </data> + <data name="reference.title" xml:space="preserve"> + <value>Referenz</value> + </data> + <data name="reference.lede" xml:space="preserve"> + <value>Was die Codebases sind, was die Clients tun und was die Protokolle bedeuten. Von Hand geschrieben und im Repository neben dem Crawler abgelegt — kein Wiki, und auf dieser Seite gibt es nichts zu bearbeiten. Jede {number} hier ist etwas anderes: Sie stammt aus dem Katalog und wird bei jedem Aufruf der Seite neu berechnet.</value> + </data> + <data name="reference.lede.number" xml:space="preserve"> + <value>Zahl</value> + </data> + <data name="reference.plain.lede" xml:space="preserve"> + <value>Von Hand geschrieben, namentlich gezeichnet und in git versioniert. Der Text hier ist unserer; jede Zahl daneben wurde vom Crawler gemessen und wird bei jeder Anfrage neu berechnet. Das ist kein Wiki, und von dieser Seite aus lässt sich nichts bearbeiten.</value> + </data> + <data name="reference.section.orientation" xml:space="preserve"> + <value>Hier anfangen</value> + </data> + <data name="reference.section.codebase" xml:space="preserve"> + <value>Codebases</value> + </data> + <data name="reference.section.client" xml:space="preserve"> + <value>Clients</value> + </data> + <data name="reference.section.protocol" xml:space="preserve"> + <value>Protokolle</value> + </data> + <data name="reference.kind.orientation" xml:space="preserve"> + <value>Orientierung</value> + </data> + <data name="reference.kind.codebase" xml:space="preserve"> + <value>Codebase</value> + </data> + <data name="reference.kind.client" xml:space="preserve"> + <value>Client</value> + </data> + <data name="reference.kind.protocol" xml:space="preserve"> + <value>Protokoll</value> + </data> + <data name="reference.notFound.title" xml:space="preserve"> + <value>Nicht gefunden</value> + </data> + <data name="reference.notFound.body" xml:space="preserve"> + <value>Hier gibt es keine Referenzseite. Dieser Abschnitt ist von Hand geschrieben; eine Lücke ist also Arbeit, die niemand gemacht hat, und nichts, was entfernt worden wäre — {index}.</value> + </data> + <data name="reference.notFound.index" xml:space="preserve"> + <value>sehen, was es gibt</value> + </data> + <data name="reference.codebase.heading" xml:space="preserve"> + <value>Spiele, die sie ausführen</value> + </data> + <data name="reference.codebase.none" xml:space="preserve"> + <value>Wir haben noch keines identifiziert. Das ist eine Tatsache darüber, was dieser Crawler gemessen hat, und keine darüber, was es gibt — ein Spiel, das wir nicht erreicht haben oder dessen Codebase wir nicht lesen konnten, wird hier nicht mitgezählt.</value> + </data> + <data name="reference.codebase.listed" xml:space="preserve"> + <value>{count, plural, one {# eingetragen} other {# eingetragen}}</value> + </data> + <data name="reference.codebase.archived" xml:space="preserve"> + <value>{count, plural, one {# archiviert} other {# archiviert}}</value> + </data> + <data name="reference.measuredNeverAsserted" xml:space="preserve"> + <value>gemessen, nie behauptet</value> + </data> + <data name="reference.codebase.note" xml:space="preserve"> + <value>Bei dieser Anfrage aus dem Katalog gezählt, über denselben Filter, den der Link oben trägt — diese Zahl und jenes Verzeichnis stammen also aus einer einzigen Abfrage und können nicht auseinanderlaufen.</value> + </data> + <data name="reference.codebase.offered" xml:space="preserve"> + <value>in ihren Handshakes angeboten: {protocols}</value> + </data> + <data name="reference.protocol.heading" xml:space="preserve"> + <value>Gemessene Verbreitung</value> + </data> + <data name="reference.protocol.none" xml:space="preserve"> + <value>Noch nichts gemessen.</value> + </data> + <data name="reference.protocol.share" xml:space="preserve"> + <value>von {listed, plural, one {# eingetragenen Spiel} other {# eingetragenen Spielen}} — {percent}</value> + </data> + <data name="reference.protocol.remainder" xml:space="preserve"> + <value>Die Spiele, die hier nicht mitgezählt sind, sind keine Spiele ohne das Protokoll. Ein Spiel zählt hier, wenn sein Server die Option in einem von uns beobachteten Handshake angeboten hat; der Rest sind Server, die sie uns nicht angeboten haben, und Server, deren Handshake wir nicht gelesen haben, und welches davon zutrifft, können wir Ihnen nicht sagen.</value> + </data> + <data name="reference.protocol.caption" xml:space="preserve"> + <value>Spiele, die {protocol} in einem von uns beobachteten Handshake angeboten haben, nach der Codebase, die wir bei ihnen identifiziert haben.</value> + </data> + <data name="reference.protocol.column.codebase" xml:space="preserve"> + <value>Codebase</value> + </data> + <data name="reference.protocol.column.offered" xml:space="preserve"> + <value>angeboten</value> + </data> + <data name="reference.protocol.column.identified" xml:space="preserve"> + <value>identifiziert</value> + </data> + <data name="reference.seeAlso" xml:space="preserve"> + <value>Siehe auch</value> + </data> + <data name="reference.capabilities.heading" xml:space="preserve"> + <value>Fähigkeiten</value> + </data> + <data name="reference.capabilities.established" xml:space="preserve"> + <value>{count, plural, one {# von {total} aus der Dokumentation des Projekts selbst festgestellt} other {# von {total} aus der Dokumentation des Projekts selbst festgestellt}}</value> + </data> + <data name="reference.capabilities.caveat" xml:space="preserve"> + <value>Aus der Dokumentation des jeweiligen Projekts abgelesen, nicht von uns gemessen — ein Client hat keinen Handshake, den wir beobachten könnten. „{unknown}“ heißt, dass wir nachgesehen und es nicht feststellen konnten. Es heißt nie nein.</value> + </data> + <data name="reference.capabilities.caption" xml:space="preserve"> + <value>Fähigkeiten der Clients, jede aus der Dokumentation des Projekts selbst abgelesen. Unbekannt heißt, dass wir sie nicht feststellen konnten, und nie, dass sie dem Client fehlt.</value> + </data> + <data name="reference.capabilities.column.documented" xml:space="preserve"> + <value>dokumentiert</value> + </data> + <data name="reference.capabilities.column.source" xml:space="preserve"> + <value>Quelle</value> + </data> + <data name="reference.capabilities.noSource" xml:space="preserve"> + <value>wir haben keine gefunden</value> + </data> + <data name="reference.capability.yes" xml:space="preserve"> + <value>ja</value> + </data> + <data name="reference.capability.no" xml:space="preserve"> + <value>nein</value> + </data> + <data name="reference.capability.unknown" xml:space="preserve"> + <value>unbekannt</value> + </data> + <data name="reference.plain.runsOn" xml:space="preserve"> + <value>Läuft auf: {platforms}</value> + </data> + <data name="reference.plain.codebase.heading" xml:space="preserve"> + <value>Spiele, bei denen wir diese Codebase identifiziert haben</value> + </data> + <data name="reference.plain.codebase.none" xml:space="preserve"> + <value>Noch keines. Das ist eine Aussage darüber, was wir gemessen haben, und keine darüber, was es gibt — ein Spiel, das wir nicht erreicht haben oder dessen Codebase wir nicht lesen konnten, wird hier nicht mitgezählt.</value> + </data> + <data name="reference.plain.codebase.counts" xml:space="preserve"> + <value>{listed, plural, one {# eingetragen} other {# eingetragen}}, {archived, plural, one {# archiviert} other {# archiviert}}</value> + </data> + <data name="reference.plain.codebase.offered" xml:space="preserve"> + <value>In ihren Handshakes gemessen: {protocols}</value> + </data> + <data name="reference.plain.codebase.nothingOffered" xml:space="preserve"> + <value>In keinem Handshake, den wir von ihnen gelesen haben, wurde etwas angeboten.</value> + </data> + <data name="reference.plain.protocol.share" xml:space="preserve"> + <value>{offering} von {listed, plural, one {# eingetragenen Spiel} other {# eingetragenen Spielen}} haben es in einem von uns beobachteten Handshake angeboten ({percent})</value> + </data> + <data name="reference.plain.protocol.byCodebase" xml:space="preserve"> + <value>Nach Codebase, unter den Spielen, die wir identifiziert haben</value> + </data> + <data name="reference.plain.protocol.row" xml:space="preserve"> + <value>{offering} von {identified} haben es angeboten</value> + </data> + <data name="reference.plain.capabilities.unknown" xml:space="preserve"> + <value>{count, plural, one {# von {total} Zeilen ist unbekannt} other {# von {total} Zeilen sind unbekannt}}: Wir haben in der Dokumentation des Projekts selbst nichts gefunden, was das eine oder das andere sagt. Eine kurze ehrliche Tabelle ist besser als eine lange geratene.</value> + </data> + <data name="account.title" xml:space="preserve"> + <value>Ihre Spiele</value> + </data> + <data name="account.noDatabase" xml:space="preserve"> + <value>Konten brauchen eine Datenbank, und diese Website läuft auf den Demodaten.</value> + </data> + <data name="account.signInButton" xml:space="preserve"> + <value>Anmelden</value> + </data> + <data name="account.signedInAs" xml:space="preserve"> + <value>Angemeldet als {name}.</value> + </data> + <data name="account.signOut" xml:space="preserve"> + <value>Abmelden</value> + </data> + <data name="account.empty.body" xml:space="preserve"> + <value>Sie haben noch nichts beansprucht. Suchen Sie Ihr Spiel in {listing} und drücken Sie auf seiner Seite {claimControl}.</value> + </data> + <data name="account.empty.listing" xml:space="preserve"> + <value>dem Verzeichnis</value> + </data> + <data name="account.empty.claimControl" xml:space="preserve"> + <value>Dieses Spiel beanspruchen</value> + </data> + <data name="account.resigned.lead" xml:space="preserve"> + <value>Aufgegeben.</value> + </data> + <data name="account.resigned.body" xml:space="preserve"> + <value>Der Vermerk darüber bleibt erhalten, und Sie können jederzeit erneut nachweisen, dass Sie das Spiel betreiben, indem Sie einen frischen Token veröffentlichen.</value> + </data> + <data name="account.saved.lead" xml:space="preserve"> + <value>Gespeichert.</value> + </data> + <data name="account.saved.thatGame" xml:space="preserve"> + <value>Dieses Spiel</value> + </data> + <data name="account.saved.fields" xml:space="preserve"> + <value>Die Seite von {game} zeigt es jetzt als vom Betreiber angegeben.</value> + </data> + <data name="account.saved.screenHidden" xml:space="preserve"> + <value>Wir veröffentlichen den Verbindungsbildschirm von {game} nicht mehr erneut. Die Seite sagt das deutlich, statt eine Leerstelle zu lassen.</value> + </data> + <data name="account.saved.screenShown" xml:space="preserve"> + <value>Der Verbindungsbildschirm von {game} steht wieder auf seiner Seite.</value> + </data> + <data name="account.saved.crawlStopped" xml:space="preserve"> + <value>Wir wählen {game} nicht mehr an, unter keiner Adresse, die wir dafür haben. Seine Seite behält alles, was vor Ihrer Bitte gemessen wurde.</value> + </data> + <data name="account.saved.crawlResumed" xml:space="preserve"> + <value>Wir wählen {game} wieder an, ab seinem nächsten Termin im Zeitplan.</value> + </data> + <data name="account.saved.unlisted" xml:space="preserve"> + <value>{game} ist aus dem Verzeichnis, aus den Ranglisten und aus der Tageszahl heraus. Seine Seite und jede URL, die es je hatte, antworten weiterhin.</value> + </data> + <data name="account.saved.relisted" xml:space="preserve"> + <value>{game} steht wieder im Verzeichnis. Eine einzige Abfrage, die eine Antwort erhält, genügt, damit es wieder gemessen wird.</value> + </data> + <data name="account.refused.lead" xml:space="preserve"> + <value>{field} wurde nicht geändert.</value> + </data> + <data name="account.refused.tooLong" xml:space="preserve"> + <value>Das sind einzeilige Angaben; mehr als {max} Zeichen speichern wir nicht.</value> + </data> + <data name="account.refused.measured" xml:space="preserve"> + <value>Dieses Feld ist gemessen. Ein Anspruch erlaubt Ihnen hinzuzufügen, wofür MSSP keinen Platz hat; er erlaubt niemandem, das zu ändern, was wir beobachtet haben, uns eingeschlossen.</value> + </data> + <data name="account.claimed.heading" xml:space="preserve"> + <value>Beansprucht</value> + </data> + <data name="account.claim.verified" xml:space="preserve"> + <value>bestätigt {date}</value> + </data> + <data name="account.claim.verifiedAndSeen" xml:space="preserve"> + <value>bestätigt {date}, Token zuletzt gesehen {seen}</value> + </data> + <data name="account.claim.mssp" xml:space="preserve"> + <value>Ihr MSSP prüfen</value> + </data> + <data name="account.claim.coOwners" xml:space="preserve"> + <value>{count, plural, one {Außerdem beansprucht von {names} — mit einem eigenen bestätigten Token.} other {Außerdem beansprucht von {names} — jeweils mit einem eigenen bestätigten Token.}}</value> + </data> + <data name="account.coOwner.unnamed" xml:space="preserve"> + <value>ein anderes Konto</value> + </data> + <data name="account.badge.summary" xml:space="preserve"> + <value>Ihre Spielerzahl auf Ihrer eigenen Website zeigen</value> + </data> + <data name="account.badge.carries" xml:space="preserve"> + <value>Das Abzeichen trägt die Zählung und den Zeitpunkt, an dem wir sie gemessen haben, denn eine Zahl ohne Alter ist genau das, was diese Website ersetzen soll.</value> + </data> + <data name="account.badge.states" xml:space="preserve"> + <value>Es sagt {unknown} statt null, wenn wir nicht zählen konnten, und {archived}, wenn das Spiel nicht mehr antwortet.</value> + </data> + <data name="account.badge.json" xml:space="preserve"> + <value>Es gibt auch {json}, falls Sie lieber selbst zeichnen möchten.</value> + </data> + <data name="account.history.summary" xml:space="preserve"> + <value>Verlauf</value> + </data> + <data name="account.event.issued" xml:space="preserve"> + <value>Token ausgegeben</value> + </data> + <data name="account.event.reissued" xml:space="preserve"> + <value>Token erneut ausgegeben</value> + </data> + <data name="account.event.verified" xml:space="preserve"> + <value>bestätigt — wir haben Ihren Token gelesen</value> + </data> + <data name="account.event.beaconSeen" xml:space="preserve"> + <value>Token weiterhin veröffentlicht</value> + </data> + <data name="account.event.beaconMissing" xml:space="preserve"> + <value>Token diesmal nicht gelesen</value> + </data> + <data name="account.event.revoked" xml:space="preserve"> + <value>Anspruch aufgegeben</value> + </data> + <data name="account.event.expired" xml:space="preserve"> + <value>Token ungenutzt abgelaufen</value> + </data> + <data name="account.event.counterClaimed" xml:space="preserve"> + <value>ein anderes Konto hat nachgewiesen, dass es das Spiel betreibt, und es übernommen</value> + </data> + <data name="account.event.checkRequested" xml:space="preserve"> + <value>Prüfung angefragt</value> + </data> + <data name="account.resign.summary" xml:space="preserve"> + <value>diesen Anspruch aufgeben</value> + </data> + <data name="account.resign.confirm" xml:space="preserve"> + <value>Tippen Sie {word} zur Bestätigung. Nichts wird gelöscht, und Sie können erneut nachweisen, dass Sie das Spiel betreiben, indem Sie einen frischen Token veröffentlichen; das Spiel bleibt beansprucht, solange es noch jemand anderes beansprucht.</value> + </data> + <data name="account.resign.button" xml:space="preserve"> + <value>{game} aufgeben</value> + </data> + <data name="account.pending.heading" xml:space="preserve"> + <value>Warten auf einen Token</value> + </data> + <data name="account.pending.dates" xml:space="preserve"> + <value>Token ausgegeben {issued}, gültig bis {expires}</value> + </data> + <data name="account.passkeys.heading" xml:space="preserve"> + <value>Passkeys</value> + </data> + <data name="account.passkey.unnamed" xml:space="preserve"> + <value>ohne Namen</value> + </data> + <data name="account.passkey.added" xml:space="preserve"> + <value>hinzugefügt {date}</value> + </data> + <data name="account.passkey.addedOneDevice" xml:space="preserve"> + <value>hinzugefügt {date} · nur auf einem Gerät</value> + </data> + <data name="account.passkey.single" xml:space="preserve"> + <value>Dieser Passkey liegt auf einem einzigen Gerät. Verlieren Sie ihn, kommen Sie weiterhin hinein, indem Sie einen frischen Token in Ihrem Spiel veröffentlichen, aber ein zweiter Passkey geht schneller.</value> + </data> + <data name="account.passkey.add" xml:space="preserve"> + <value>Einen weiteren Passkey hinzufügen</value> + </data> + <data name="claim.noGame" xml:space="preserve"> + <value>Kein solches Spiel</value> + </data> + <data name="claim.title" xml:space="preserve"> + <value>{game} beanspruchen</value> + </data> + <data name="claim.noDatabase" xml:space="preserve"> + <value>Das Beanspruchen braucht eine Datenbank, und diese Website läuft auf den Demodaten.</value> + </data> + <data name="claim.needAccount" xml:space="preserve"> + <value>Dafür brauchen Sie zuerst ein Konto. Es braucht einen Passkey und einen Namen.</value> + </data> + <data name="claim.signIn" xml:space="preserve"> + <value>Anmelden oder ein Konto anlegen</value> + </data> + <data name="claim.yourGames" xml:space="preserve"> + <value>Ihre Spiele</value> + </data> + <data name="claim.hasOwners" xml:space="preserve"> + <value>{count, plural, one {Dieses Spiel hat bereits einen Betreiber, der den Zugriff auf den Server nachgewiesen hat.} other {Dieses Spiel hat bereits # Betreiber, die den Zugriff auf den Server nachgewiesen haben.}} Sie können ihn ebenfalls nachweisen — die Prüfung ist in beiden Fällen dieselbe —, aber wir müssen wissen, was Sie damit meinen, denn am Token ist es nicht zu erkennen.</value> + </data> + <data name="claim.join.button" xml:space="preserve"> + <value>Ich betreibe es auch — mich als Betreiber eintragen</value> + </data> + <data name="claim.join.note" xml:space="preserve"> + <value>Alle behalten ihren Anspruch. Das sind zwei Menschen, die ein Spiel betreiben.</value> + </data> + <data name="claim.assume.button" xml:space="preserve"> + <value>Ich habe es übernommen — auf mich übertragen</value> + </data> + <data name="claim.assume.note" xml:space="preserve"> + <value>{count, plural, one {Sobald Ihr Token bestätigt ist, wird der bestehende Anspruch widerrufen und das Spiel gehört Ihnen.} other {Sobald Ihr Token bestätigt ist, werden die bestehenden Ansprüche widerrufen und das Spiel gehört Ihnen.}} In ihrem eigenen Verlauf steht, warum. Nichts wird gelöscht, und sie können erneut nachweisen, dass sie es betreiben, auf demselben Weg, den Sie gerade gehen.</value> + </data> + <data name="claim.verified.lead" xml:space="preserve"> + <value>Bestätigt.</value> + </data> + <data name="claim.verified.viaMssp" xml:space="preserve"> + <value>Wir haben Ihren Token am {date} aus dem MSSP-Bericht des Spiels gelesen.</value> + </data> + <data name="claim.verified.viaScreen" xml:space="preserve"> + <value>Wir haben Ihren Token am {date} vom Verbindungsbildschirm gelesen.</value> + </data> + <data name="claim.verified.leaveIt" xml:space="preserve"> + <value>Lassen Sie den Token, wo er ist. Er dient zugleich als Erkennungsmerkmal, damit dieses Spiel wiedererkennbar bleibt, wenn es den Host wechselt oder den Namen ändert. Ihn wegzunehmen hebt Ihren Anspruch nicht auf.</value> + </data> + <data name="claim.publish" xml:space="preserve"> + <value>Veröffentlichen Sie diesen Token irgendwo, wo das Spiel ihn einer anonymen Verbindung zeigt. Die nächste Abfrage liest ihn auf, und damit ist nachgewiesen, dass Sie auf diesen Server schreiben können.</value> + </data> + <data name="claim.transfer.lead" xml:space="preserve"> + <value>Das ist eine Übertragung.</value> + </data> + <data name="claim.transfer.body" xml:space="preserve"> + <value>{count, plural, one {Sobald wir diesen Token lesen, wird der Anspruch des bisherigen Betreibers auf dieses Spiel widerrufen und es gehört Ihnen.} other {Sobald wir diesen Token lesen, werden die Ansprüche der bisherigen Betreiber auf dieses Spiel widerrufen und es gehört Ihnen.}}</value> + </data> + <data name="claim.either.heading" xml:space="preserve"> + <value>Eines von beidem genügt</value> + </data> + <data name="claim.mssp.heading" xml:space="preserve"> + <value>Eine MSSP-Variable</value> + </data> + <data name="claim.mssp.note" xml:space="preserve"> + <value>In {codebase} ist das eine Zeile in {file}; jede Codebase mit MSSP hat eine Entsprechung.</value> + </data> + <data name="claim.mssp.aliases" xml:space="preserve"> + <value>{aliases} werden ebenfalls angenommen.</value> + </data> + <data name="claim.screen.heading" xml:space="preserve"> + <value>Eine Zeile auf dem Verbindungsbildschirm</value> + </data> + <data name="claim.screen.note" xml:space="preserve"> + <value>Irgendwo im Bildschirm, und Farbcodes darum herum sind kein Problem.</value> + </data> + <data name="claim.then.heading" xml:space="preserve"> + <value>Dann</value> + </data> + <data name="claim.then.body" xml:space="preserve"> + <value>Wir prüfen im gewöhnlichen Crawl-Zeitplan. Dieser Token ist gültig bis {date}. Kommen Sie jederzeit wieder; nichts davon muss notiert werden.</value> + </data> + <data name="claim.check.button" xml:space="preserve"> + <value>Früher nachsehen</value> + </data> + <data name="claim.check.can" xml:space="preserve"> + <value>Bringt Ihr Spiel an den Anfang der Warteschlange. Wir wählen nach unserem eigenen Zeitplan an, das heißt also früher und nicht jetzt.</value> + </data> + <data name="claim.check.rationed" xml:space="preserve"> + <value>Gerade eben schon angefragt. Versuchen Sie es in ein paar Minuten wieder — es ist begrenzt, weil es einen echten Server früher anwählt, als wir es getan hätten.</value> + </data> + <data name="owner.declare.heading" xml:space="preserve"> + <value>Was nur Sie uns über {game} sagen können</value> + </data> + <data name="owner.declare.lede" xml:space="preserve"> + <value>Das sind die Dinge, für die MSSP kein Feld hat. Sie erscheinen auf der Seite Ihres Spiels als {declared}, mit dem Datum, an dem Sie sie zuletzt bestätigt haben, neben dem, was wir gemessen haben — nie an dessen Stelle. Nichts Gemessenes lässt sich von hier aus ändern, weder von Ihnen noch von uns.</value> + </data> + <data name="owner.field.declared" xml:space="preserve"> + <value>angegeben {age}. Leeren Sie dieses Feld, um die Angabe zurückzuziehen — was darin stand, bleibt so oder so festgehalten.</value> + </data> + <data name="owner.save" xml:space="preserve"> + <value>Ihre Angaben speichern</value> + </data> + <data name="owner.override.heading" xml:space="preserve"> + <value>Was {game} meldet und was Sie stattdessen gezeigt sehen möchten</value> + </data> + <data name="owner.override.lede" xml:space="preserve"> + <value>Ihr MSSP ist das, was jeder Crawler liest, und wir zeigen es weiterhin neben allem, was Sie hier eintragen — eine Angabe von Ihnen verdeckt keine Ihres Spiels.</value> + </data> + <data name="owner.override.nothingMeasured" xml:space="preserve"> + <value>Nichts Gemessenes lässt sich von hier aus ändern: keine Spielerzahl, keine Fähigkeit, keine Stunde Erreichbarkeit.</value> + </data> + <data name="owner.override.fixItThere" xml:space="preserve"> + <value>Ist eine Zeile unten in Ihrer {file} falsch, dann genügt es, sie dort zu berichtigen — damit stimmt sie überall.</value> + </data> + <data name="owner.report.value" xml:space="preserve"> + <value>Ihr Spiel meldet {value}, bestätigt {age}</value> + </data> + <data name="owner.report.none" xml:space="preserve"> + <value>Ihr Spiel meldet hier nichts</value> + </data> + <data name="owner.rename.note" xml:space="preserve"> + <value>Den Namen zu ändern ändert, unter welchem Namen {game} eingetragen ist, und die Adresse seiner Seite. Die alte Adresse funktioniert für immer weiter — jede URL, die dieses Spiel je hatte, leitet auf die aktuelle weiter —, und wenn Sie das Feld leeren, gilt wieder der Name, den Ihr MSSP nennt.</value> + </data> + <data name="owner.screen.heading" xml:space="preserve"> + <value>Ihr Verbindungsbildschirm</value> + </data> + <data name="owner.screen.suppressed" xml:space="preserve"> + <value>Wir veröffentlichen ihn nicht erneut. Die Seite sagt das deutlich, statt eine Leerstelle zu lassen, und der Crawler liest ihn weiterhin — daran erkennen wir Ihr Spiel wieder, wenn es umzieht.</value> + </data> + <data name="owner.screen.show" xml:space="preserve"> + <value>Wieder zeigen</value> + </data> + <data name="owner.screen.shown" xml:space="preserve"> + <value>Wir zeigen ihn, weil Ihr Server ihn an jede anonyme Verbindung sendet. Ist Ihnen das nicht recht, sagen Sie es, und wir hören auf. Wir fragen nicht nach dem Grund.</value> + </data> + <data name="owner.screen.stop" xml:space="preserve"> + <value>Unseren Verbindungsbildschirm nicht mehr zeigen</value> + </data> + <data name="owner.crawl.heading" xml:space="preserve"> + <value>Gecrawlt werden</value> + </data> + <data name="owner.crawl.stopped" xml:space="preserve"> + <value>Wir haben aufgehört. Nichts an {game} wird angewählt, und die Seite behält alles, was vor Ihrer Bitte gemessen wurde — die leeren Stunden nennen keine Ursache, denn {ourFact} ist eine Tatsache über uns und keine Messung an Ihrem Spiel.</value> + </data> + <data name="owner.crawl.ourFact" xml:space="preserve"> + <value>dass Sie uns um den Stopp gebeten haben</value> + </data> + <data name="owner.crawl.resume" xml:space="preserve"> + <value>Uns wieder crawlen</value> + </data> + <data name="owner.crawl.standing" xml:space="preserve"> + <value>Dieser Ausschluss kam von Ihrem eigenen Server und nicht von hier — {routes}. Damit wir wieder crawlen, hören Sie auf, ihn zu veröffentlichen; wir bekommen das im nächsten Zyklus mit.</value> + </data> + <data name="owner.crawl.route.mssp" xml:space="preserve"> + <value>Ihr MSSP-Bericht veröffentlicht {variable}</value> + </data> + <data name="owner.crawl.route.dns" xml:space="preserve"> + <value>ein TXT-Eintrag unter {label} bittet uns aufzuhören</value> + </data> + <data name="owner.crawl.route.recorded" xml:space="preserve"> + <value>eine von uns festgehaltene Bitte</value> + </data> + <data name="owner.crawl.partial" xml:space="preserve"> + <value>Bei {stopped} haben wir aufgehört, und {dialling} wählen wir weiterhin an. Das ist meist ein Port, der nach dem Ausschluss hinzugekommen ist.</value> + </data> + <data name="owner.crawl.stopAll" xml:space="preserve"> + <value>Auch unter jeder Adresse aufhören</value> + </data> + <data name="owner.crawl.dialling" xml:space="preserve"> + <value>Wir wählen {game} nach einem Zeitplan an und lesen, was jeder anonymen Verbindung gezeigt wird. Ist Ihnen das nicht recht, sagen Sie es, und wir hören auf — innerhalb eines Zyklus, unter jeder Adresse, die wir von Ihnen haben, und wir fragen nicht nach dem Grund.</value> + </data> + <data name="owner.crawl.selfService" xml:space="preserve"> + <value>Nichts bereits Gemessenes wird gelöscht: Ihre Seite behält ihre Geschichte und ihre URL, und eine einzige Abfrage, nachdem Sie das zurückgenommen haben, setzt es wieder in Gang. Sie können es auch ohne uns sagen, in Ihrer eigenen Konfiguration — {mssp} in MSSP oder ein TXT-Eintrag unter {dns} —, und wir befolgen das, ob dieses Spiel hier jemals beansprucht wurde oder nicht.</value> + </data> + <data name="owner.crawl.stop" xml:space="preserve"> + <value>Uns nicht mehr crawlen</value> + </data> + <data name="owner.listing.heading" xml:space="preserve"> + <value>Eingetragen sein</value> + </data> + <data name="owner.listing.unlisted" xml:space="preserve"> + <value>{game} ist aus dem Verzeichnis, aus den Ranglisten und aus der Tageszahl heraus. Seine Seite und jede URL, die es je hatte, antworten weiterhin, und alles, was vor Ihrer Bitte gemessen wurde, steht weiterhin darauf. Es wurde nichts gelöscht; es ist nur kein Ort mehr, an dem man beim Stöbern ankommt.</value> + </data> + <data name="owner.listing.relist" xml:space="preserve"> + <value>Uns wieder ins Verzeichnis aufnehmen</value> + </data> + <data name="owner.listing.probeRelists" xml:space="preserve"> + <value>Eine Abfrage, die eine Antwort erhält, tut das ebenfalls. Solange Ihr Ausschluss gilt, wählen wir nicht an, es wird also keine geben — aber an dem Tag, an dem Sie ihn zurücknehmen, kommt die Adresse binnen einer Woche an die Reihe, und die Abfrage, die eine Antwort erhält, bringt Sie zurück. Sie müssen uns kein zweites Mal fragen.</value> + </data> + <data name="owner.listing.mayUnlist" xml:space="preserve"> + <value>Wir wählen Sie nicht mehr an, und Ihre Seite steht weiterhin im Verzeichnis, mit dem, was wir davor gemessen haben. Ist Ihnen das nicht recht, sagen Sie es, und sie kommt heraus — aus dem Verzeichnis, aus den Ranglisten und aus der Tageszahl.</value> + </data> + <data name="owner.listing.reversible" xml:space="preserve"> + <value>Nichts wird gelöscht und nichts geht kaputt: Die Seite antwortet, jede URL, die sie je hatte, leitet weiterhin auf sie, und wer von Ihnen dorthin geschickt wird, sieht sie. Sie ist nur kein Ort mehr, an dem ein Lesender beim Stöbern ankommt. Von hier aus rückgängig zu machen, und ebenso durch jede Abfrage, die nach der Rücknahme Ihres Ausschlusses eine Antwort erhält.</value> + </data> + <data name="owner.listing.unlist" xml:space="preserve"> + <value>Uns auch aus dem Verzeichnis nehmen</value> + </data> + <data name="facet.group.measure" xml:space="preserve"> + <value>was wir messen konnten</value> + </data> + <data name="facet.measure.note" xml:space="preserve"> + <value>Diese auszublenden nimmt sie aus der Auflistung heraus; es heißt nicht, dass das Spiel leer ist.</value> + </data> + <data name="facet.group.uncounted" xml:space="preserve"> + <value>ungezählt</value> + </data> + <data name="facet.group.unreachable" xml:space="preserve"> + <value>nicht erreichbar</value> + </data> + <data name="facet.excluded.uncounted" xml:space="preserve"> + <value>aus dieser Auflistung ausgeblendet</value> + </data> + <data name="facet.excluded.unreachable" xml:space="preserve"> + <value>aus dieser Auflistung ausgeblendet</value> + </data> + <data name="facet.plain.marks" xml:space="preserve"> + <value>In der linken Spalte steht * für einen Wert, nach dem diese Auflistung gefiltert ist, und - für einen, gegen den gefiltert wird. Beides sind Entscheidungen in der Suche, keine Tatsachen über ein Spiel.</value> + </data> +</root> diff --git a/src/MUI.Web/Resources/Messages.ja.resx b/src/MUI.Web/Resources/Messages.ja.resx new file mode 100644 index 0000000..84f452f --- /dev/null +++ b/src/MUI.Web/Resources/Messages.ja.resx @@ -0,0 +1,2877 @@ +<?xml version="1.0" encoding="utf-8"?> +<root> + <!-- + 日本語, machine-translated and not reviewed by a person. + + Every page served in this locale carries the ◆ notice saying so, and the locale is reachable but + never offered: nothing sends a reader here. Promotion to LocaleStatus.Shipped is a person reading + the locked strings against Glossary.cs, not an edit to a status enum. + + The values are ICU MessageFormat. Argument names in braces are code. + --> + <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata"> + <xsd:import namespace="http://www.w3.org/XML/1998/namespace" /> + <xsd:element name="root" msdata:IsDataSet="true"> + <xsd:complexType> + <xsd:choice maxOccurs="unbounded"> + <xsd:element name="data"> + <xsd:complexType> + <xsd:sequence> + <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" /> + <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" /> + </xsd:sequence> + <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" /> + <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" /> + <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" /> + <xsd:attribute ref="xml:space" /> + </xsd:complexType> + </xsd:element> + <xsd:element name="resheader"> + <xsd:complexType> + <xsd:sequence> + <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" /> + </xsd:sequence> + <xsd:attribute name="name" type="xsd:string" use="required" /> + </xsd:complexType> + </xsd:element> + </xsd:choice> + </xsd:complexType> + </xsd:element> + </xsd:schema> + <resheader name="resmimetype"><value>text/microsoft-resx</value></resheader> + <resheader name="version"><value>2.0</value></resheader> + <resheader name="reader"><value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader> + <resheader name="writer"><value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader> + <data name="facet.count" xml:space="preserve"> + <value>{count, plural, other {#件のゲーム}}</value> + </data> + <data name="facet.value.include" xml:space="preserve"> + <value>{value}、{count, plural, other {#件のゲーム}}、のみ</value> + </data> + <data name="facet.value.exclude" xml:space="preserve"> + <value>{value}、{count, plural, other {#件のゲーム}}、除外</value> + </data> + <data name="facet.value.choose" xml:space="preserve"> + <value>{value}、{count, plural, other {#件のゲーム}}</value> + </data> + <data name="facet.any" xml:space="preserve"> + <value>{facet}を問わない、{count, plural, other {#件のゲーム}}</value> + </data> + <data name="listing.total" xml:space="preserve"> + <value>{count, plural, =0 {ここに掲載しているゲームはなし。} other {#件のゲーム。どの事実にも、その出所が記されている。}}</value> + </data> + <data name="chart.basis" xml:space="preserve"> + <value>{days, plural, other {#日間実測}} · {probes, plural, other {#回の探査}}</value> + </data> + <data name="window.samples" xml:space="preserve"> + <value>{days, plural, other {#日}} · {count, plural, other {#件の計数}}</value> + </data> + <data name="capabilities.agree" xml:space="preserve"> + <value>{disagreeing, plural, =0 {{total}件のうち不一致はなし。} other {{total}件のうち#件がゲームの自己申告と不一致。}}</value> + </data> + <data name="find.matching" xml:space="preserve"> + <value>{count, plural, =0 {すべての回答に一致するゲームはなし。} other {すべての回答に一致するゲームは#件。}}</value> + </data> + <data name="find.basis" xml:space="preserve"> + <value>{listed, plural, other {掲載#件のゲーム}}のうち · {answers, plural, =0 {回答なし} other {回答#件}}</value> + </data> + <data name="find.show" xml:space="preserve"> + <value>{count, plural, other {この#件のゲームを表示}}</value> + </data> + <data name="find.drop" xml:space="preserve"> + <value>「{answer}」を解除 — {count, plural, other {#件のゲーム}}</value> + </data> + <data name="find.clear" xml:space="preserve"> + <value>回答を解除：{question}</value> + </data> + <data name="find.title" xml:space="preserve"> + <value>ゲームを探す</value> + </data> + <data name="find.kicker" xml:space="preserve"> + <value>すべての回答に一致</value> + </data> + <data name="find.noun" xml:space="preserve"> + <value>{count, plural, other {ゲーム}}</value> + </data> + <data name="find.clearAll" xml:space="preserve"> + <value>回答をすべて解除</value> + </data> + <data name="find.startAgain" xml:space="preserve"> + <value>やり直す</value> + </data> + <data name="find.more" xml:space="preserve"> + <value>{count, plural, other {他#件}}</value> + </data> + <data name="find.answersGiven" xml:space="preserve"> + <value>回答済み</value> + </data> + <data name="find.wholeListing" xml:space="preserve"> + <value>一覧全体</value> + </data> + <data name="find.refused" xml:space="preserve"> + <value>そのクエリは拒否された</value> + </data> + <data name="find.name.label" xml:space="preserve"> + <value>名前（分かっていれば）</value> + </data> + <data name="find.name.placeholder" xml:space="preserve"> + <value>名前、または名前の一部</value> + </data> + <data name="find.name.submit" xml:space="preserve"> + <value>名前で検索</value> + </data> + <data name="find.q.band" xml:space="preserve"> + <value>今プレイしている人はいる？</value> + </data> + <data name="find.q.genre" xml:space="preserve"> + <value>何をプレイしたい？</value> + </data> + <data name="find.q.lineage" xml:space="preserve"> + <value>どんな種類のゲーム？</value> + </data> + <data name="find.q.language" xml:space="preserve"> + <value>どの言語？</value> + </data> + <data name="find.q.client" xml:space="preserve"> + <value>クライアントに必要なものは？</value> + </data> + <data name="find.q.dark" xml:space="preserve"> + <value>消息不明のゲームも含める？</value> + </data> + <data name="find.any.band" xml:space="preserve"> + <value>問わない</value> + </data> + <data name="find.any.genre" xml:space="preserve"> + <value>ジャンルを問わない</value> + </data> + <data name="find.any.lineage" xml:space="preserve"> + <value>種類を問わない</value> + </data> + <data name="find.any.language" xml:space="preserve"> + <value>言語を問わない</value> + </data> + <data name="find.any.client" xml:space="preserve"> + <value>問わない</value> + </data> + <data name="find.dark.no" xml:space="preserve"> + <value>いいえ、ライブのゲームのみ</value> + </data> + <data name="find.dark.yes" xml:space="preserve"> + <value>はい、それらも表示</value> + </data> + <data name="find.dark.chip" xml:space="preserve"> + <value>消息不明のゲーム</value> + </data> + <data name="find.protocol.tls" xml:space="preserve"> + <value>TLS — 暗号化、ハンドシェイクは当サイトで完了</value> + </data> + <data name="find.protocol.mssp" xml:space="preserve"> + <value>MSSP — サーバーの自己申告</value> + </data> + <data name="find.protocol.mccp" xml:space="preserve"> + <value>MCCP — 出力の圧縮</value> + </data> + <data name="find.protocol.mxp" xml:space="preserve"> + <value>MXP — クリック可能なリンク</value> + </data> + <data name="find.protocol.gmcp" xml:space="preserve"> + <value>GMCP — 構造化クライアントデータ</value> + </data> + <data name="find.protocol.msdp" xml:space="preserve"> + <value>MSDP — 構造化クライアントデータ</value> + </data> + <data name="find.protocol.charset" xml:space="preserve"> + <value>CHARSET — エンコーディングのネゴシエーション</value> + </data> + <data name="find.protocol.utf8" xml:space="preserve"> + <value>UTF-8 — 非ラテン文字が表示される</value> + </data> + <data name="find.protocol.ttype" xml:space="preserve"> + <value>TTYPE — クライアントが自分の種類を伝える</value> + </data> + <data name="find.protocol.atcp" xml:space="preserve"> + <value>ATCP — 構造化クライアントデータ</value> + </data> + <data name="find.protocol.msp" xml:space="preserve"> + <value>MSP — サウンドのトリガー</value> + </data> + <data name="find.protocol.eor" xml:space="preserve"> + <value>EOR — プロンプトの区切り</value> + </data> + <data name="find.protocol.other" xml:space="preserve"> + <value>{token} — ハンドシェイクで実測</value> + </data> + <data name="provenance.count.measured" xml:space="preserve"> + <value>実測</value> + </data> + <data name="provenance.game.measured" xml:space="preserve"> + <value>実測</value> + </data> + <data name="provenance.capability.measured" xml:space="preserve"> + <value>実測</value> + </data> + <data name="provenance.screen.measured" xml:space="preserve"> + <value>実測</value> + </data> + <data name="kicker.measured" xml:space="preserve"> + <value>実測</value> + </data> + <data name="provenance.count.declared" xml:space="preserve"> + <value>自己申告</value> + </data> + <data name="provenance.game.declared" xml:space="preserve"> + <value>自己申告</value> + </data> + <data name="provenance.capability.declared" xml:space="preserve"> + <value>自己申告</value> + </data> + <data name="kicker.declared" xml:space="preserve"> + <value>自己申告</value> + </data> + <data name="provenance.derived" xml:space="preserve"> + <value>導出</value> + </data> + <data name="kicker.derived" xml:space="preserve"> + <value>導出</value> + </data> + <data name="state.notMeasured" xml:space="preserve"> + <value>未計測</value> + </data> + <data name="state.uncounted" xml:space="preserve"> + <value>接続数読み取り不可</value> + </data> + <data name="state.unreachable" xml:space="preserve"> + <value>到達不可</value> + </data> + <data name="state.notCounted" xml:space="preserve"> + <value>読み取り不可</value> + </data> + <data name="listing.count.none" xml:space="preserve"> + <value>計数なし</value> + </data> + <data name="listing.plain.fromHere" xml:space="preserve"> + <value>ここから</value> + </data> + <data name="listing.plain.archived" xml:space="preserve"> + <value>アーカイブ済</value> + </data> + <data name="listing.plain.claimed" xml:space="preserve"> + <value>申請済</value> + </data> + <data name="random.empty.title" xml:space="preserve"> + <value>選べるゲームがない</value> + </data> + <data name="random.empty.body" xml:space="preserve"> + <value>そのフィルターに一致するゲームはない。{listing}か、{archive}。</value> + </data> + <data name="random.empty.listing" xml:space="preserve"> + <value>一覧全体</value> + </data> + <data name="random.empty.archive" xml:space="preserve"> + <value>アーカイブも含める</value> + </data> + <data name="term.connected" xml:space="preserve"> + <value>接続数</value> + </data> + <data name="term.unclaimed" xml:space="preserve"> + <value>所有者未申請</value> + </data> + <data name="term.claimedByOwner" xml:space="preserve"> + <value>所有者により申請済み</value> + </data> + <data name="term.stillProbed" xml:space="preserve"> + <value>探査は継続中</value> + </data> + <data name="term.typical" xml:space="preserve"> + <value>通常</value> + </data> + <data name="term.peak" xml:space="preserve"> + <value>ピーク</value> + </data> + <data name="a11y.readAsText" xml:space="preserve"> + <value>テキストで読む</value> + </data> + <data name="a11y.plainText" xml:space="preserve"> + <value>プレーンテキスト</value> + </data> + <data name="a11y.skipToContent" xml:space="preserve"> + <value>本文へスキップ</value> + </data> + <data name="a11y.asciiBanner" xml:space="preserve"> + <value>ASCIIバナー：{game}の接続画面。</value> + </data> + <data name="nav.catalogues" xml:space="preserve"> + <value>カタログ</value> + </data> + <data name="nav.account" xml:space="preserve"> + <value>このサイトとアカウント</value> + </data> + <data name="nav.browse" xml:space="preserve"> + <value>閲覧</value> + </data> + <data name="nav.learn" xml:space="preserve"> + <value>学ぶ</value> + </data> + <data name="nav.thisSite" xml:space="preserve"> + <value>このサイト</value> + </data> + <data name="nav.menu" xml:space="preserve"> + <value>メニュー</value> + </data> + <data name="nav.games" xml:space="preserve"> + <value>ゲーム</value> + </data> + <data name="nav.find" xml:space="preserve"> + <value>探す</value> + </data> + <data name="nav.random" xml:space="preserve"> + <value>ランダム</value> + </data> + <data name="nav.archive" xml:space="preserve"> + <value>アーカイブ</value> + </data> + <data name="nav.reference" xml:space="preserve"> + <value>リファレンス</value> + </data> + <data name="nav.ecosystem" xml:space="preserve"> + <value>エコシステム</value> + </data> + <data name="nav.rankings" xml:space="preserve"> + <value>ランキング</value> + </data> + <data name="nav.about" xml:space="preserve"> + <value>概要</value> + </data> + <data name="nav.submit" xml:space="preserve"> + <value>登録</value> + </data> + <data name="nav.submitGame" xml:space="preserve"> + <value>ゲームを登録</value> + </data> + <data name="nav.signIn" xml:space="preserve"> + <value>サインイン</value> + </data> + <data name="nav.yourGames" xml:space="preserve"> + <value>自分のゲーム</value> + </data> + <data name="theme.label" xml:space="preserve"> + <value>テーマ</value> + </data> + <data name="theme.auto" xml:space="preserve"> + <value>自動</value> + </data> + <data name="theme.light" xml:space="preserve"> + <value>ライト</value> + </data> + <data name="theme.dark" xml:space="preserve"> + <value>ダーク</value> + </data> + <data name="banner.demo.lead" xml:space="preserve"> + <value>デモデータ。</value> + </data> + <data name="banner.demo" xml:space="preserve"> + <value>データベースが未設定のため、これはダミーデータ。ここにある値は実測ではない。</value> + </data> + <data name="footer.allGames" xml:space="preserve"> + <value>すべてのゲーム</value> + </data> + <data name="footer.archive" xml:space="preserve"> + <value>アーカイブ</value> + </data> + <data name="footer.declaredByGame" xml:space="preserve"> + <value>ゲームの自己申告</value> + </data> + <data name="footer.whatChanged" xml:space="preserve"> + <value>変更点</value> + </data> + <data name="home.title" xml:space="preserve"> + <value>MU*ホビーのディレクトリ</value> + </data> + <data name="home.lede" xml:space="preserve"> + <value>どの事実にも、その出所といつのものかが記されている：当サイトのクローラーが実測したものか、ゲームが自己申告し、そう明記したものか。</value> + </data> + <data name="home.search.label" xml:space="preserve"> + <value>名前・テーマ・コードベース・ホストでゲームを検索</value> + </data> + <data name="home.search.placeholder" xml:space="preserve"> + <value>名前・テーマ・コードベース・ホストで検索</value> + </data> + <data name="home.search.submit" xml:space="preserve"> + <value>検索</value> + </data> + <data name="tile.gamesKnown" xml:space="preserve"> + <value>既知のゲーム</value> + </data> + <data name="tile.connectedNow" xml:space="preserve"> + <value>現在の接続数</value> + </data> + <data name="tile.answeringUncounted" xml:space="preserve"> + <value>応答あり・読み取り不可</value> + </data> + <data name="tile.archived" xml:space="preserve"> + <value>アーカイブ済み</value> + </data> + <data name="feed.newlyDiscovered" xml:space="preserve"> + <value>新規発見</value> + </data> + <data name="feed.wentDark" xml:space="preserve"> + <value>消息不明 — 探査は継続中</value> + </data> + <data name="feed.cameBack" xml:space="preserve"> + <value>復帰</value> + </data> + <data name="feed.nothingNew" xml:space="preserve"> + <value>新規なし。</value> + </data> + <data name="feed.nothingDark" xml:space="preserve"> + <value>消息不明になったゲームはなし。</value> + </data> + <data name="feed.nothingBack" xml:space="preserve"> + <value>復帰したゲームはなし。探査は続ける。</value> + </data> + <data name="feed.live" xml:space="preserve"> + <value>ライブ</value> + </data> + <data name="games.title" xml:space="preserve"> + <value>ゲーム</value> + </data> + <data name="listing.sortedBy" xml:space="preserve"> + <value>{order}順</value> + </data> + <data name="listing.random" xml:space="preserve"> + <value>ランダム</value> + </data> + <data name="listing.columns" xml:space="preserve"> + <value>接続数 · 到達</value> + </data> + <data name="listing.fromHere" xml:space="preserve"> + <value>ここから</value> + </data> + <data name="listing.empty.head" xml:space="preserve"> + <value>該当なし。</value> + </data> + <data name="listing.empty.hint" xml:space="preserve"> + <value>語を減らすか、フィルターを外す。</value> + </data> + <data name="listing.clearFilters" xml:space="preserve"> + <value>フィルターを解除</value> + </data> + <data name="listing.aboutCodebase" xml:space="preserve"> + <value>{codebase}について</value> + </data> + <data name="listing.never" xml:space="preserve"> + <value>到達なし</value> + </data> + <data name="listing.claimed" xml:space="preserve"> + <value>所有者により申請済み</value> + </data> + <data name="listing.unknownCodebase" xml:space="preserve"> + <value>コードベース不明</value> + </data> + <data name="listing.unknownCodebase.title" xml:space="preserve"> + <value>このゲームのコードベースは特定できなかった</value> + </data> + <data name="listing.moreProtocols" xml:space="preserve"> + <value>ほか{count, plural, other {#件}}：{names}</value> + </data> + <data name="switch.order" xml:space="preserve"> + <value>並び順</value> + </data> + <data name="switch.window" xml:space="preserve"> + <value>期間</value> + </data> + <data name="switch.now" xml:space="preserve"> + <value>現在</value> + </data> + <data name="switch.typical" xml:space="preserve"> + <value>通常</value> + </data> + <data name="switch.peak" xml:space="preserve"> + <value>ピーク</value> + </data> + <data name="switch.name" xml:space="preserve"> + <value>名前</value> + </data> + <data name="switch.reached" xml:space="preserve"> + <value>到達</value> + </data> + <data name="window.7" xml:space="preserve"> + <value>7日</value> + </data> + <data name="window.30" xml:space="preserve"> + <value>30日</value> + </data> + <data name="window.90" xml:space="preserve"> + <value>90日</value> + </data> + <data name="filters.search.label" xml:space="preserve"> + <value>ゲームを検索</value> + </data> + <data name="filters.search.placeholder" xml:space="preserve"> + <value>ゲームを検索</value> + </data> + <data name="filters.summary" xml:space="preserve"> + <value>フィルター</value> + </data> + <data name="filters.showing" xml:space="preserve"> + <value>表示中</value> + </data> + <data name="filters.clearAll" xml:space="preserve"> + <value>すべて解除</value> + </data> + <data name="filters.stopFiltering" xml:space="preserve"> + <value>— この絞り込みを解除</value> + </data> + <data name="facet.anyValue" xml:space="preserve"> + <value>問わない</value> + </data> + <data name="facet.more" xml:space="preserve"> + <value>他のフィルター（{count}）</value> + </data> + <data name="facet.moreValues" xml:space="preserve"> + <value>{count, plural, other {他#件}}</value> + </data> + <data name="facet.alsoShow" xml:space="preserve"> + <value>追加で表示</value> + </data> + <data name="facet.alsoShow.note" xml:space="preserve"> + <value>既定ではオフ。どちらもゲームへの評価ではない。</value> + </data> + <data name="facet.archived" xml:space="preserve"> + <value>アーカイブ済み</value> + </data> + <data name="facet.adult" xml:space="preserve"> + <value>アダルト</value> + </data> + <data name="facet.archived.state" xml:space="preserve"> + <value>アーカイブ済みのゲーム、{shown, select, true {表示} other {非表示}}</value> + </data> + <data name="facet.adult.state" xml:space="preserve"> + <value>アダルト指定を自己申告したゲーム、{shown, select, true {表示} other {非表示}}</value> + </data> + <data name="facet.countsNote" xml:space="preserve"> + <value>件数は実測したゲーム数であり、推定値ではない。</value> + </data> + <data name="facet.key.summary" xml:space="preserve"> + <value>バッジと空欄の意味</value> + </data> + <data name="facet.key.blank" xml:space="preserve"> + <value>空欄は実測の欠落であり、否定ではない。ファセットごとに表記が異なる：特定できず、申告なし、ネゴシエーションなし。</value> + </data> + <data name="facet.key.zero" xml:space="preserve"> + <value>実測のゼロは計数である。接続数不明はゼロではなく、ゼロとして並べ替えられることもない。</value> + </data> + <data name="facet.key.openEnded" xml:space="preserve"> + <value>値が定まらないファセットは最頻の{count}件の値のみを挙げる。残りは検索とURLから到達可能。</value> + </data> + <data name="facet.presence.note" xml:space="preserve"> + <value>未チェックは未計測の意味 — ゲームに備わっていないという意味ではない。</value> + </data> + <data name="facet.group.band" xml:space="preserve"> + <value>活動</value> + </data> + <data name="facet.group.seen" xml:space="preserve"> + <value>最終確認</value> + </data> + <data name="facet.group.protocol" xml:space="preserve"> + <value>提供プロトコル</value> + </data> + <data name="facet.group.tls" xml:space="preserve"> + <value>暗号化</value> + </data> + <data name="facet.group.charset" xml:space="preserve"> + <value>エンコーディング</value> + </data> + <data name="facet.group.codebase" xml:space="preserve"> + <value>コードベース</value> + </data> + <data name="facet.group.version" xml:space="preserve"> + <value>バージョン</value> + </data> + <data name="facet.group.lineage" xml:space="preserve"> + <value>系統</value> + </data> + <data name="facet.group.family" xml:space="preserve"> + <value>ファミリー</value> + </data> + <data name="facet.group.genre" xml:space="preserve"> + <value>ジャンル</value> + </data> + <data name="facet.group.language" xml:space="preserve"> + <value>言語</value> + </data> + <data name="facet.band.playersNow" xml:space="preserve"> + <value>現在接続あり</value> + </data> + <data name="facet.band.activeThisWeek" xml:space="preserve"> + <value>今週アクティブ</value> + </data> + <data name="facet.band.quiet" xml:space="preserve"> + <value>閑散 — 計数は0を超えず</value> + </data> + <data name="facet.band.dark" xml:space="preserve"> + <value>消息不明 — 1か月間到達なし</value> + </data> + <data name="facet.band.archived" xml:space="preserve"> + <value>アーカイブ済み</value> + </data> + <data name="facet.seen.day" xml:space="preserve"> + <value>24時間以内</value> + </data> + <data name="facet.seen.week" xml:space="preserve"> + <value>7日以内</value> + </data> + <data name="facet.seen.month" xml:space="preserve"> + <value>30日以内</value> + </data> + <data name="facet.seen.older" xml:space="preserve"> + <value>それ以前</value> + </data> + <data name="facet.seen.never" xml:space="preserve"> + <value>一度も到達なし</value> + </data> + <data name="facet.unknown.charset" xml:space="preserve"> + <value>ネゴシエーションなし</value> + </data> + <data name="facet.unknown.codebase" xml:space="preserve"> + <value>特定できず</value> + </data> + <data name="facet.unknown.other" xml:space="preserve"> + <value>申告なし</value> + </data> + <data name="facet.tls.yes" xml:space="preserve"> + <value>TLSで接続</value> + </data> + <data name="facet.excluded" xml:space="preserve"> + <value>{value}以外</value> + </data> + <data name="facet.known.charset" xml:space="preserve"> + <value>ネゴシエーションあり</value> + </data> + <data name="facet.known.codebase" xml:space="preserve"> + <value>特定済み</value> + </data> + <data name="facet.known.other" xml:space="preserve"> + <value>申告あり</value> + </data> + <data name="evidence.measured.meaning" xml:space="preserve"> + <value>実際に観測した</value> + </data> + <data name="evidence.declared.meaning" xml:space="preserve"> + <value>ゲームの申告であり、検証はしていない</value> + </data> + <data name="evidence.derived.meaning" xml:space="preserve"> + <value>ゲームの申告を分類したもの</value> + </data> + <data name="sort.name" xml:space="preserve"> + <value>名前</value> + </data> + <data name="sort.players" xml:space="preserve"> + <value>現在の接続数</value> + </data> + <data name="sort.reached" xml:space="preserve"> + <value>最終到達</value> + </data> + <data name="sort.medianWeek" xml:space="preserve"> + <value>通常の接続数 · 7日</value> + </data> + <data name="sort.medianMonth" xml:space="preserve"> + <value>通常の接続数 · 30日</value> + </data> + <data name="sort.medianQuarter" xml:space="preserve"> + <value>通常の接続数 · 90日</value> + </data> + <data name="sort.peakWeek" xml:space="preserve"> + <value>同時接続ピーク · 7日</value> + </data> + <data name="sort.peakMonth" xml:space="preserve"> + <value>同時接続ピーク · 30日</value> + </data> + <data name="sort.peakQuarter" xml:space="preserve"> + <value>同時接続ピーク · 90日</value> + </data> + <data name="sort.group.row" xml:space="preserve"> + <value>行の現在値</value> + </data> + <data name="sort.group.typical" xml:space="preserve"> + <value>通常</value> + </data> + <data name="sort.group.peak" xml:space="preserve"> + <value>ピーク</value> + </data> + <data name="sort.unranked.players" xml:space="preserve"> + <value>接続数不明</value> + </data> + <data name="sort.unranked.reached" xml:space="preserve"> + <value>一度も到達なし — 到達が古いのではない</value> + </data> + <data name="sort.unranked.median" xml:space="preserve"> + <value>期間内の計数が{minimum}件未満、または皆無 — 通常の接続数がゼロなのではない</value> + </data> + <data name="sort.unranked.window" xml:space="preserve"> + <value>期間内に計数を読み取れず — 誰も接続していなかったのではない</value> + </data> + <data name="sort.window.median" xml:space="preserve"> + <value>中央値 {value} · {days, plural, other {#日}} · {count, plural, other {#件の計数}}</value> + </data> + <data name="sort.window.peak" xml:space="preserve"> + <value>同時最大 {value} · {days, plural, other {#日}} · {count, plural, other {#件の計数}}</value> + </data> + <data name="game.connectScreen" xml:space="preserve"> + <value>接続画面</value> + </data> + <data name="game.connectionsByHour" xml:space="preserve"> + <value>時間帯別の接続数</value> + </data> + <data name="game.howMany" xml:space="preserve"> + <value>接続数の推移</value> + </data> + <data name="game.reachable" xml:space="preserve"> + <value>到達可能</value> + </data> + <data name="game.whatChanged" xml:space="preserve"> + <value>変更点</value> + </data> + <data name="game.capabilities" xml:space="preserve"> + <value>機能</value> + </data> + <data name="game.declaredByGame" xml:space="preserve"> + <value>ゲームの自己申告</value> + </data> + <data name="game.referrals" xml:space="preserve"> + <value>リファラル</value> + </data> + <data name="game.unclaimed" xml:space="preserve"> + <value>所有者未申請 — ここにある情報はすべて実測。</value> + </data> + <data name="game.claimed" xml:space="preserve"> + <value>所有者により申請済み — 以下の実測値は引き続き当サイトのもの。</value> + </data> + <data name="game.claim" xml:space="preserve"> + <value>このゲームを申請する</value> + </data> + <data name="game.answeringSince" xml:space="preserve"> + <value>{date}から応答</value> + </data> + <data name="game.readAsTextRows" xml:space="preserve"> + <value>テキストで読む — {count, plural, other {#行}}</value> + </data> + <data name="capability.column" xml:space="preserve"> + <value>機能</value> + </data> + <data name="capability.age" xml:space="preserve"> + <value>経過</value> + </data> + <data name="capability.offered" xml:space="preserve"> + <value>提供</value> + </data> + <data name="capability.silent" xml:space="preserve"> + <value>無応答</value> + </data> + <data name="capability.absent" xml:space="preserve"> + <value>なし</value> + </data> + <data name="capability.denied" xml:space="preserve"> + <value>拒否</value> + </data> + <data name="capability.claimed" xml:space="preserve"> + <value>自己申告</value> + </data> + <data name="capability.disagrees" xml:space="preserve"> + <value>不一致</value> + </data> + <data name="capability.whereTheyDisagree" xml:space="preserve"> + <value>不一致の箇所（{count}）</value> + </data> + <data name="activity.cell.counted" xml:space="preserve"> + <value>{day} {time} — {count, plural, =0 {接続数0、実測} other {平均#人}}</value> + </data> + <data name="activity.cell.notCounted" xml:space="preserve"> + <value>{day} {time} — 探査したが接続数は読み取れず</value> + </data> + <data name="activity.cell.notMeasured" xml:space="preserve"> + <value>{day} {time} — この時間は未計測</value> + </data> + <data name="activity.none" xml:space="preserve"> + <value>このゲームの活動はまだ実測していない。</value> + </data> + <data name="activity.noCount" xml:space="preserve"> + <value>週のどの時間にも接続数は得られていない。</value> + </data> + <data name="activity.allZero" xml:space="preserve"> + <value>すべての時間を実測し、どの時間も接続はなかった。</value> + </data> + <data name="activity.gap.day" xml:space="preserve"> + <value>{count, plural, other {{day}の#時間はまだ未計測。}}</value> + </data> + <data name="activity.gap.week" xml:space="preserve"> + <value>{count, plural, other {週全体で#時間がまだ未計測。}}</value> + </data> + <data name="activity.uncounted.day" xml:space="preserve"> + <value>{count, plural, other {{day}の#時間は応答したが接続数は読み取れず。}}</value> + </data> + <data name="activity.uncounted.week" xml:space="preserve"> + <value>{count, plural, other {週全体で#時間が応答したが接続数は読み取れず。}}</value> + </data> + <data name="activity.busiest.everyDay" xml:space="preserve"> + <value>毎日、{window}が最も多い。</value> + </data> + <data name="activity.busiest.everyDay.part" xml:space="preserve"> + <value>毎日、{part}の{window}が最も多い。</value> + </data> + <data name="activity.busiest.days" xml:space="preserve"> + <value>{days}は{window}が最も多い。</value> + </data> + <data name="activity.busiest.days.part" xml:space="preserve"> + <value>{days}は{part}、{window}が最も多い。</value> + </data> + <data name="activity.quiet" xml:space="preserve"> + <value>{who}の{window}は常に接続が少ない。</value> + </data> + <data name="activity.quiet.part" xml:space="preserve"> + <value>{who}の{part}、{window}は常に接続が少ない。</value> + </data> + <data name="activity.quiet.everyDay" xml:space="preserve"> + <value>毎日</value> + </data> + <data name="activity.quiet.everyMeasuredDay" xml:space="preserve"> + <value>実測できたすべての日</value> + </data> + <data name="activity.quiet.weekdays" xml:space="preserve"> + <value>平日</value> + </data> + <data name="activity.quiet.onDays" xml:space="preserve"> + <value>{days}</value> + </data> + <data name="activity.part.morning" xml:space="preserve"> + <value>午前</value> + </data> + <data name="activity.part.afternoon" xml:space="preserve"> + <value>午後</value> + </data> + <data name="activity.part.evening" xml:space="preserve"> + <value>夜</value> + </data> + <data name="activity.part.smallHours" xml:space="preserve"> + <value>深夜</value> + </data> + <data name="activity.parts.morning" xml:space="preserve"> + <value>午前</value> + </data> + <data name="activity.parts.afternoon" xml:space="preserve"> + <value>午後</value> + </data> + <data name="activity.parts.evening" xml:space="preserve"> + <value>夜</value> + </data> + <data name="activity.parts.smallHours" xml:space="preserve"> + <value>深夜</value> + </data> + <data name="activity.days.list" xml:space="preserve"> + <value>{list}、{next}</value> + </data> + <data name="activity.days.pair" xml:space="preserve"> + <value>{first}と{second}</value> + </data> + <data name="activity.sparse.kicker" xml:space="preserve"> + <value>実測がまだ足りない</value> + </data> + <data name="activity.sparse.none" xml:space="preserve"> + <value>週のどの時間もまだ未計測。</value> + </data> + <data name="activity.sparse.uncounted" xml:space="preserve"> + <value>{count, plural, other {#時間は応答したが接続数は読み取れず。}}</value> + </data> + <data name="activity.sparse.wait" xml:space="preserve"> + <value>週のすべての曜日に実測が入るとグリッドが表示される。</value> + </data> + <data name="activity.sparse.days" xml:space="preserve"> + <value>{days, plural, other {これまでに7日のうち#日を実測。すべての曜日に1時間でも入るとグリッドが表示される。}}</value> + </data> + <data name="activity.sample.zero" xml:space="preserve"> + <value>{count, plural, other {#時間を実測、いずれも接続なし。}}</value> + </data> + <data name="activity.sample.peak" xml:space="preserve"> + <value>{count, plural, other {#時間を実測、最多は{day} {time} UTCの{peak}。}}</value> + </data> + <data name="activity.sample.more" xml:space="preserve"> + <value>{count, plural, other {他に#時間が応答したが接続数は読み取れず。}}</value> + </data> + <data name="activity.day.line" xml:space="preserve"> + <value>{day} — {facts}</value> + </data> + <data name="activity.day.facts" xml:space="preserve"> + <value>{first}、{second}</value> + </data> + <data name="activity.day.allZero" xml:space="preserve"> + <value>終日ゼロを実測</value> + </data> + <data name="activity.day.peak" xml:space="preserve"> + <value>{time}にピーク{count}</value> + </data> + <data name="activity.day.nobodyOn" xml:space="preserve"> + <value>{window}は接続なし</value> + </data> + <data name="activity.day.noCount" xml:space="preserve"> + <value>どの時間も接続数を読み取れず</value> + </data> + <data name="activity.day.notMeasured" xml:space="preserve"> + <value>{count, plural, other {#時間が未計測}}</value> + </data> + <data name="activity.day.notCounted" xml:space="preserve"> + <value>{count, plural, other {#時間は探査したが読み取り不可}}</value> + </data> + <data name="activity.column.day" xml:space="preserve"> + <value>曜日</value> + </data> + <data name="activity.column.quietest" xml:space="preserve"> + <value>最少</value> + </data> + <data name="activity.column.busiest" xml:space="preserve"> + <value>最多</value> + </data> + <data name="activity.column.at" xml:space="preserve"> + <value>時刻</value> + </data> + <data name="activity.column.noCount" xml:space="preserve"> + <value>読み取り不可</value> + </data> + <data name="activity.caption" xml:space="preserve"> + <value>曜日別の接続数（UTC）。{window}。</value> + </data> + <data name="activity.times" xml:space="preserve"> + <value>時刻はUTC · {window}</value> + </data> + <data name="activity.rollingAverage" xml:space="preserve"> + <value>{weeks, plural, other {#週の移動平均}}</value> + </data> + <data name="activity.legend.counted" xml:space="preserve"> + <value>計数あり（実測のゼロを含む）</value> + </data> + <data name="activity.legend.notCounted" xml:space="preserve"> + <value>探査したが接続数は読み取れず</value> + </data> + <data name="activity.legend.notMeasured" xml:space="preserve"> + <value>その時間は未計測</value> + </data> + <data name="activity.plain.heading" xml:space="preserve"> + <value>人がいる時間帯（UTC）</value> + </data> + <data name="activity.key.counted" xml:space="preserve"> + <value>計数あり</value> + </data> + <data name="activity.key.counted.meaning" xml:space="preserve"> + <value>接続でき、数値を読み取れた（実測のゼロを含む）</value> + </data> + <data name="activity.key.uncounted.meaning" xml:space="preserve"> + <value>接続できたが、数値は読み取れなかった</value> + </data> + <data name="activity.key.notMeasured.meaning" xml:space="preserve"> + <value>その時間の実測がない</value> + </data> + <data name="locale.label" xml:space="preserve"> + <value>言語</value> + </data> + <data name="locale.submit" xml:space="preserve"> + <value>言語を変更</value> + </data> + <data name="about.title" xml:space="preserve"> + <value>mu*indexについて</value> + </data> + <data name="about.lede" xml:space="preserve"> + <value>ここにあるゲームはすべて、接続した機械が実測したもの。どの値にも、出所といつのものかが記されている。このページでは、それが何を証明するのか、何を誤ると分かっているのか、誰のディレクトリを読んでいるのか、そしてクローラーを止める方法を扱う。</value> + </data> + <data name="about.measures.heading" xml:space="preserve"> + <value>ここでの事実とは何か</value> + </data> + <data name="about.measures.declared.lead" xml:space="preserve"> + <value>実測は自己申告に優先し、どちらも表示する。</value> + </data> + <data name="about.measures.declared.body" xml:space="preserve"> + <value>ゲームのMSSPレポートは、そのゲームが自分自身を説明したもの。telnetハンドシェイクは、当サイトがそのゲームの振る舞いを実際に見たもの。どちらもそのゲームのページに、方法と時期を添えて表示する。両者が食い違う場合は、その不一致を示す。</value> + </data> + <data name="about.measures.count.lead" xml:space="preserve"> + <value>接続数は、その出所を明示する。</value> + </data> + <data name="about.measures.count.body" xml:space="preserve"> + <value>接続画面で読み取ったWHOかDOING（当サイトが数えたもの）、あるいはゲーム自身が公開したMSSPのPLAYERSフィールドのいずれか。両者を混ぜることはない。</value> + </data> + <data name="about.measures.unknown.lead" xml:space="preserve"> + <value>読み取れなかった応答は不明であって、ゼロではない。</value> + </data> + <data name="about.measures.unknown.body" xml:space="preserve"> + <value>サーバーはWHOのヘッダーを自由に書き換えるので、ある程度を超えると当サイトのパーサーは読み取れない。それは接続数読み取り不可という、それ自体で一つの状態。実測のゼロ — 接続でき、誰もいなかった — は計数であり、計数として表示する。</value> + </data> + <data name="about.measures.reachable.lead" xml:space="preserve"> + <value>到達可能であって、稼働率ではない。</value> + </data> + <data name="about.measures.reachable.body" xml:space="preserve"> + <value>当サイトは1台のホストから一定の間隔でソケットを開く。経路が通らないゲームは到達不可であり、それでいて健在。実測していない以上、ここではどのゲームの稼働率も主張しない。</value> + </data> + <data name="about.measures.hour.lead" xml:space="preserve"> + <value>1時間は、計数あり、読み取り不可、未計測のいずれか。</value> + </data> + <data name="about.measures.hour.body" xml:space="preserve"> + <value>活動グリッドには3つの状態がある。3つ目は空欄であり、原因を名指ししない：到達できなかった時間も、一度も探査しなかった時間も、同じ欠落であって、どちらもそのサーバーの停止時間ではない。</value> + </data> + <data name="about.limits.heading" xml:space="preserve"> + <value>誤ると分かっていること</value> + </data> + <data name="about.limits.grace.lead" xml:space="preserve"> + <value>アーカイブまでの猶予は、こちらが見つけた日から数える。</value> + </data> + <data name="about.limits.grace.body" xml:space="preserve"> + <value>応答しなくなったゲームは、猶予期間を過ぎると既定の一覧から外れる：猶予は探査した到達可能時間の4分の1で、下限60日、上限365日。1995年から動いているゲームでも、発見した日には下限から始まる。当サイトが来る前の年月を埋めるためのインポートは一切しない。</value> + </data> + <data name="about.limits.created.lead" xml:space="preserve"> + <value>MSSPのCREATEDはその猶予に算入しない。</value> + </data> + <data name="about.limits.created.body" xml:space="preserve"> + <value>設定ファイルに手で書かれた1行にすぎず、算入すればアーカイブのしきい値を操作できてしまう。自己申告として表示するが、それで得られるものはない。</value> + </data> + <data name="about.limits.claim.lead" xml:space="preserve"> + <value>ゲームを申請すれば上限が得られる。</value> + </data> + <data name="about.limits.claim.body" xml:space="preserve"> + <value>サーバーへのアクセスを証明すれば、観測してきた期間の長さにかかわらず、猶予は満1年になる。</value> + </data> + <data name="about.limits.oneHost.lead" xml:space="preserve"> + <value>ここにあるものはすべて、1台のホストが一定間隔で見た結果。</value> + </data> + <data name="about.limits.oneHost.body" xml:space="preserve"> + <value>到達可能時間の割合は、観測した期間に対する割合であって、観測しなかった期間に対するものではない。ここにあるどの図も、残りを埋めることはしない。</value> + </data> + <data name="about.limits.deletion.lead" xml:space="preserve"> + <value>削除は一切しない。</value> + </data> + <data name="about.limits.deletion.body" xml:space="preserve"> + <value>アーカイブはゲームを既定の一覧、ランキング、本日アクティブの数値から外すだけで、それ以上のことはしない。ページ、URL、履歴、アドレスはそのまま残り、探査は続き、1回の探査が成功すれば元に戻る。</value> + </data> + <data name="about.never.heading" xml:space="preserve"> + <value>このサイトがしないこと</value> + </data> + <data name="about.never.votes.lead" xml:space="preserve"> + <value>投票も、星も、評価も、おすすめもない。</value> + </data> + <data name="about.never.votes.body" xml:space="preserve"> + <value>ランキングは実測データのみから算出する。最も多くクリックを動員できた者で順位が決まるディレクトリが表すのは、その動員活動であってこのホビーではない。先行したディレクトリを滅ぼしたのはそれだ。</value> + </data> + <data name="about.never.forums.lead" xml:space="preserve"> + <value>フォーラムも、レビューも、ウィキも、コメントも、プレイヤープロフィールもない。</value> + </data> + <data name="about.never.forums.body" xml:space="preserve"> + <value>入門的な解説 — MUSHとは何か、共同ロールプレイにはどのコードベースが向くか — は、サイトの他の部分と同じく、執筆され、署名され、バージョン管理される。</value> + </data> + <data name="about.never.names.lead" xml:space="preserve"> + <value>プレイヤー名は一切保存しない。</value> + </data> + <data name="about.never.names.body" xml:space="preserve"> + <value>WHOの応答は、人数とヘッダーの形を得るためにメモリ上で解析する。名前は書き出さない。集計には、ローテーションするソルトを用いたソルト付きハッシュを使う。</value> + </data> + <data name="about.never.population.lead" xml:space="preserve"> + <value>人口の絶対数は公表しない。</value> + </data> + <data name="about.never.population.body" xml:space="preserve"> + <value>コードベース別・プロトコル別のシェアは公開する：実測した集合に対する比率は、計数できないゲームがあっても意味を保つ。「MU*を遊んでいる人は何人か」は保たない。その数字は引用に耐えないから。</value> + </data> + <data name="about.crawler.heading" xml:space="preserve"> + <value>クローラーと、その止め方</value> + </data> + <data name="about.crawler.probe.lead" xml:space="preserve"> + <value>探査とは、ログインしない1本の接続のこと。</value> + </data> + <data name="about.crawler.probe.body" xml:space="preserve"> + <value>ソケットを開き、telnetオプションをネゴシエートし、接続画面を読み、オプション70のネゴシエーションでMSSPを要求し、{commands}を送り、切断する。キャラクターも作らず、ログインもせず、相手側では何も変わらない。セッションにはタイムアウトを設けてあり、詰まった探査が接続枠を占有し続けることはない。</value> + </data> + <data name="about.crawler.delay.lead" xml:space="preserve"> + <value>CRAWL DELAYが優先する。</value> + </data> + <data name="about.crawler.delay.body" xml:space="preserve"> + <value>MSSPレポートで希望する最小間隔を示したゲームには、そのとおりにする。当サイト自身のスケジュールより双方向に優先する：720時間なら週次ではなく月次。消息不明のゲームも、その長い間隔で永久に試し続ける。復帰したときに自力で一覧に戻るのは、そのおかげ。</value> + </data> + <data name="about.crawler.referral.lead" xml:space="preserve"> + <value>紹介されたアドレスは検証する。信用はしない。</value> + </data> + <data name="about.crawler.referral.body" xml:space="preserve"> + <value>MSSPでは、ゲームが他のゲームを名指しできる。名前はダイヤルする前にすべて解決し、解決先のアドレスがすべてグローバルに到達可能でなければ拒否する。混在した応答は、その対象全体を拒否する。この拒否は当サイトの判断として記録し、ゲームの記録に停止時間として現れることはない。</value> + </data> + <data name="about.crawler.screens.lead" xml:space="preserve"> + <value>接続画面を表示するのは、それが誰にでも送られるものだから。</value> + </data> + <data name="about.crawler.screens.body" xml:space="preserve"> + <value>サーバーは接続画面を、認証なしで、すべての匿名接続に描き出す。当サイトはそれを証拠として表示し、ラベルを付ける。求められれば取り下げる。</value> + </data> + <data name="about.crawler.stop.lead" xml:space="preserve"> + <value>止めろと言われれば止める — 方法は3つ。</value> + </data> + <data name="about.crawler.stop.body" xml:space="preserve"> + <value>MSSPレポートに{variable} 1を公開すれば、それを読んだ探査が最後になる。または{label}.your.hostに「{value}」と書いたTXTレコードを公開する。MSSPへの対応も当サイトのアカウントも要らない。あるいは人に連絡する。3つとも1回のクロールサイクル以内に反映し、日付と読み取った内容とともに記録し、登録フォームにも適用する。</value> + </data> + <data name="about.crawler.scope.lead" xml:space="preserve"> + <value>MSSPフィールドはそのリスナーを止め、レコードはホストを止める。</value> + </data> + <data name="about.crawler.scope.body" xml:space="preserve"> + <value>MSSPは応答したポートが公開するものなので、そのポートについてしか語らない — MU*のホスティングでは無関係なゲームが1つのドメインで動いているのが普通であり、一方が隣を黙らせてはならない。TXTレコードは、「{value}=4201」のようにポートを名指ししない限り、すべてのポートを対象とする。そこにポート一覧として読めないものが書かれていればホスト全体を意味するので、「{value}=all」でも通る。</value> + </data> + <data name="about.crawler.dns.lead" xml:space="preserve"> + <value>DNSによる方法は、こちらに頼まずに自分で取り消せる唯一の方法。</value> + </data> + <data name="about.crawler.dns.body" xml:space="preserve"> + <value>TXTレコードは、来るなと言ったサーバーに接続しなくても読めるので、ダイヤルのたびに読み直す。削除すれば1週間以内にまたダイヤルする。MSSPフィールドは、止めてくれと言われたその行為をしなければ読み直せない。そのためMSSPによる離脱と書面での要請は、撤回の連絡があるまで有効なまま。離脱したアドレスに対して行うのはそのTXT参照だけ：触れるのはネームサーバーであって、ゲームではない。</value> + </data> + <data name="about.crawler.stopping.lead" xml:space="preserve"> + <value>停止は削除ではないし、停止時間でもない。</value> + </data> + <data name="about.crawler.stopping.body" xml:space="preserve"> + <value>離脱したゲームも、ページ、アドレス、そして要請より前に実測したものはすべて残る。止まるのは新しいデータだけ：活動グリッドは時間が増えなくなり、原因は名指ししない。ノックをやめるという判断は当サイトについての事実だから。それは行われなかったクロールの記録として、また誰が要請したかの台帳に記録する。</value> + </data> + <data name="about.crawler.unlist.lead" xml:space="preserve"> + <value>停止だけで足りなければ、掲載も取り下げられる。</value> + </data> + <data name="about.crawler.unlist.body" xml:space="preserve"> + <value>そのゲームが応答するすべてのアドレスで探査を止めたあと、ダッシュボードにもう一つの選択肢が出る：一覧、ランキング、日次の数値から取り下げること。ページも、これまで持っていたすべてのアドレスも応答し続け、何も削除されない — 閲覧してたどり着ける場所ではなくなるだけ。これには検証済みの申請が要る。あなたのゲームについての判断であり、誰が下したかを記録するから。そして探査がそれを取り消す：離脱を撤回すれば、次に応答が返ったダイヤルで、二度頼まなくても一覧に戻る。</value> + </data> + <data name="about.identity.announced" xml:space="preserve"> + <value>サーバーから何者かと尋ねられたとき、クローラーは自らを{name}と名乗る。</value> + </data> + <data name="about.identity.unannounced" xml:space="preserve"> + <value>クローラーは自らを{name}と名乗るよう設定されているが、まだそう伝えられない。使っているtelnetライブラリには、クライアント側から端末種別を設定する手段がなく、そちらのログにはそのライブラリの既定値が見える。NEW-ENVIRONもクローラーホストの環境から応答される。どちらもライブラリ側の欠落であり、そこを直すのは当方の仕事。それまでは、探査はその形で見分けられる：1本の接続、ログインなし、読み取り専用の短いコマンド列、そして退出。</value> + </data> + <data name="about.identity.crawler" xml:space="preserve"> + <value>クローラー</value> + </data> + <data name="about.identity.contact" xml:space="preserve"> + <value>連絡先</value> + </data> + <data name="about.identity.crawler.line" xml:space="preserve"> + <value>クローラー：{name}</value> + </data> + <data name="about.identity.contact.line" xml:space="preserve"> + <value>連絡先：{url}</value> + </data> + <data name="about.identity.placeholder" xml:space="preserve"> + <value>— プレースホルダー。このデプロイでは連絡先が設定されていない</value> + </data> + <data name="about.identity.placeholder.plain" xml:space="preserve"> + <value>連絡先が設定されていないため、上のものはプレースホルダーであり、誰にもつながらない。</value> + </data> + <data name="about.sources.heading" xml:space="preserve"> + <value>ゲーム一覧の出どころ</value> + </data> + <data name="about.sources.addresses.lead" xml:space="preserve"> + <value>受け取るのはアドレス。それ以外は何も。</value> + </data> + <data name="about.sources.addresses.body" xml:space="preserve"> + <value>バックフィルが受け取るのはホストとポート。接続数も、到達可能性の履歴も、説明も、各種フィールドも、アドレスがどのサイト由来かの記録も取らない。</value> + </data> + <data name="about.sources.less.lead" xml:space="preserve"> + <value>それらのサイトが渡せるものより、意図的に少なく。</value> + </data> + <data name="about.sources.less.body" xml:space="preserve"> + <value>いくつかは何年分もの日付付き接続数を持っている。それを取り込めば、他人がすでに観測していたゲームのヒートマップが埋まり、このサイトの中心的な主張が他者の探査機に寄りかかることになる。</value> + </data> + <data name="about.sources.origin.lead" xml:space="preserve"> + <value>ゲームの出どころは一つの事実ではない。</value> + </data> + <data name="about.sources.origin.body" xml:space="preserve"> + <value>掲載する価値のあるゲームは、これらのディレクトリのいくつもに載っている。だから「インポート元」は、たまたま先に走った取得を指すだけになる。ゲームが存在することは公開情報。どこで読んだかは何も足さず、他人の仕事のうち当サイトのものだと最も言いにくい部分でもある。</value> + </data> + <data name="about.sources.etiquette.lead" xml:space="preserve"> + <value>他人のサイトを読むことは、やはり他人のサイトを読むこと。</value> + </data> + <data name="about.sources.etiquette.body" xml:space="preserve"> + <value>スクレイプの前に一括エクスポートか文書化されたエンドポイントを求め、まずrobots.txtを読み、スクレイプには厳しくレート制限をかける。管理者の了承が要る情報源は、依頼した旨を人が明言できるまで取得しない。</value> + </data> + <data name="about.source.read" xml:space="preserve"> + <value>読み取り済み — アドレスのみ</value> + </data> + <data name="about.source.withheld" xml:space="preserve"> + <value>未読 — 許諾待ち</value> + </data> + <data name="about.source.tintinMssp.note" xml:space="preserve"> + <value>1ページ、1リクエスト。各ゲームに接続して読み取った内容を出力するクローラーが公開している。</value> + </data> + <data name="about.source.tintinMsdp.note" xml:space="preserve"> + <value>同じクローラーによるMSDPの一覧。ほぼMSSP版の部分集合で、そちらでは届かない少数のアドレスのために読んでいる。</value> + </data> + <data name="about.source.mudConnector.note" xml:space="preserve"> + <value>カタログ全体を1ページで公開しているので、読むのに要するリクエストは1回。最大のアドレス供給源であり、実測値は一つも取っていない。</value> + </data> + <data name="about.source.mudStats.note" xml:space="preserve"> + <value>インデックスが1ページと、ワールドごとに1ページなので、エクスポートではなくスクレイプになる。2026年7月30日、robots.txtを守り15秒間隔で、先方の143ページを取得した。ただし誰も先方に連絡していなかった。あれは起きてはならなかった。現在の関門は、管理者に依頼したと明言する用意のある人を要求する。</value> + </data> + <data name="about.source.mudVerse.note" xml:space="preserve"> + <value>実装済み、テスト済み、実行はしていない。許諾を除くあらゆる軸でここでは最も優れた情報源だが、誰かが先方に連絡するまで何も取得しない。</value> + </data> + <data name="about.licence.heading" xml:space="preserve"> + <value>ライセンス</value> + </data> + <data name="about.licence.code.lead" xml:space="preserve"> + <value>コードはMIT。</value> + </data> + <data name="about.licence.code.body" xml:space="preserve"> + <value>サイトもクローラーもパーサーも、MITライセンスのオープンソース。</value> + </data> + <data name="about.licence.open.lead" xml:space="preserve"> + <value>データのライセンスは未解決の問題。</value> + </data> + <data name="about.licence.open.body" xml:space="preserve"> + <value>コードとは別の判断であり、まだ下していない。以下の条件は、このデプロイの現時点での答えであって、プロジェクトとして定まった立場ではない。競合するディレクトリがカタログ全体を持っていくことはここでは成功条件なので、どう決まるにせよそれを妨げることはない。</value> + </data> + <data name="about.licence.codeLabel" xml:space="preserve"> + <value>コード</value> + </data> + <data name="about.licence.dataLabel" xml:space="preserve"> + <value>データ、このデプロイが提供する形での</value> + </data> + <data name="about.licence.creditLabel" xml:space="preserve"> + <value>クレジット表記</value> + </data> + <data name="about.licence.code.line" xml:space="preserve"> + <value>コード：{licence}</value> + </data> + <data name="about.licence.data.line" xml:space="preserve"> + <value>データ：{licence}</value> + </data> + <data name="about.licence.credit.line" xml:space="preserve"> + <value>クレジット表記：{credit}</value> + </data> + <data name="about.licence.deployment" xml:space="preserve"> + <value>（このデプロイが提供する内容。プロジェクト自身の答えはまだ未定。）</value> + </data> + <data name="submit.title" xml:space="preserve"> + <value>ゲームを登録</value> + </data> + <data name="submit.lede" xml:space="preserve"> + <value>ゲームの所在を教えてほしい。フォームはホストとポートだけ。このサイトのそれ以外はすべて、当サイト自身のクローラーが実測する。</value> + </data> + <data name="submit.host.label" xml:space="preserve"> + <value>ホスト</value> + </data> + <data name="submit.port.label" xml:space="preserve"> + <value>ポート</value> + </data> + <data name="submit.host.hint" xml:space="preserve"> + <value>mud.example.org、または mud.example.org:4201 を貼り付けてポートは空のまま</value> + </data> + <data name="submit.button" xml:space="preserve"> + <value>登録</value> + </data> + <data name="submit.noCatalogue" xml:space="preserve"> + <value>登録にはデータベースが必要だが、このサイトはデモ用のダミーデータで動いている。書き込む先のクロール登録簿がないので、黙って何もしないフォームを出すのではなく、フォーム自体を置いていない。</value> + </data> + <data name="submit.notHere" xml:space="preserve"> + <value>ここにはない</value> + </data> + <data name="submit.what.heading" xml:space="preserve"> + <value>アドレスに何が起きるか</value> + </data> + <data name="submit.what.resolve" xml:space="preserve"> + <value>ダイヤルの前にアドレスを解決し、公開インターネットの外に解決するものは拒否する。それは当サイト自身のソケットについての判断であり、ゲームについての事実ではない。</value> + </data> + <data name="submit.what.optOut" xml:space="preserve"> + <value>そのホストを運用している人からクロールしないよう要請されている場合、誰が登録しようとそのアドレスは受け取らない。他人があなたのゲームをこのサイトに戻すことはできない。</value> + </data> + <data name="submit.what.schedule" xml:space="preserve"> + <value>応答があれば、サーバーが自分について語る内容を読み、そのゲーム自身のスケジュールで永久に読み続ける。アドレスを渡すのは一度でいい。</value> + </data> + <data name="submit.what.claim" xml:space="preserve"> + <value>運用者だと誰かが証明するまで、サイトには何も出ない。申請にはパスキーと、ゲーム自体に公開する1行が要る。</value> + </data> + <data name="submit.what.duplicate" xml:space="preserve"> + <value>すでに持っているアドレスは既存の項目にまとめられる。二度送っても掲載が二つになることはなく、探査が早まることもない。</value> + </data> + <data name="submit.answer.thatAddress" xml:space="preserve"> + <value>そのアドレス</value> + </data> + <data name="submit.accepted.heading" xml:space="preserve"> + <value>登録簿に入った。</value> + </data> + <data name="submit.accepted.sentence" xml:space="preserve"> + <value>{address}は次のクロールサイクルでダイヤルし、以降はそのゲーム自身のスケジュールで永久に続ける。運用者だと誰かが証明した時点でここに現れる — 同じアドレスでこのフォームに戻れば、そのリンクを渡す。</value> + </data> + <data name="submit.unclaimed.heading" xml:space="preserve"> + <value>こちらにはある、所有者未申請。</value> + </data> + <data name="submit.unclaimed.sentence" xml:space="preserve"> + <value>{address}はすでに実測しているもの。運用者だと誰かが証明するまで、サイトには出ないまま。それがあなたなら、ここが入口。</value> + </data> + <data name="submit.known.heading" xml:space="preserve"> + <value>それはすでにある。</value> + </data> + <data name="submit.known.sentence" xml:space="preserve"> + <value>{address}はすでに実測しているゲーム。何も作られず、何も変わっていない。</value> + </data> + <data name="submit.knownAddress.heading" xml:space="preserve"> + <value>そのアドレスはすでにある。</value> + </data> + <data name="submit.knownAddress.sentence" xml:space="preserve"> + <value>{address}はすでに把握している。何も作られず、何も変わっていない。</value> + </data> + <data name="submit.queued.heading" xml:space="preserve"> + <value>すでに待機中。</value> + </data> + <data name="submit.queued.sentence" xml:space="preserve"> + <value>{address}はクロール登録簿にあり、まだ応答がない。もう一度送っても順番は早まらない：対象はそれぞれ自分のスケジュールを保つので、他人のサーバーに対して当サイトを急かすことは誰にもできない。</value> + </data> + <data name="submit.malformed.heading" xml:space="preserve"> + <value>ダイヤルできるアドレスではない。</value> + </data> + <data name="submit.malformed.sentence" xml:space="preserve"> + <value>ホストにはドットかコロンが要り、ポートは1から65535までの数値。両方の欄を埋めるか、最初の欄に mud.example.org:4201 を貼り付ける。</value> + </data> + <data name="submit.undialable.heading" xml:space="preserve"> + <value>それにはダイヤルできない。</value> + </data> + <data name="submit.undialable.sentence" xml:space="preserve"> + <value>{address}にこの答えが出る理由は3つ：名前が解決しない、公開インターネットの外に解決する、あるいはそのホストを運用している人から近寄らないよう要請されている。どれなのかは意図的に言わない。見知らぬ相手にそれを答えることは、ネットワークを外側から地図にすることだから。アドレスについては何も記録していない。この判断は当サイトのものであり、当サイトのものとして記録する。</value> + </data> + <data name="submit.tooMany.heading" xml:space="preserve"> + <value>今はここまで。</value> + </data> + <data name="submit.tooMany.sentence" xml:space="preserve"> + <value>このフォームは送信者ごとにレート制限があり、その上限に達した。1時間後にまた来てほしい。失われたものはない — 受け取ったものはすでに登録簿にある。</value> + </data> + <data name="submit.link.claim" xml:space="preserve"> + <value>このゲームを申請する</value> + </data> + <data name="account.signIn.title" xml:space="preserve"> + <value>サインイン</value> + </data> + <data name="account.signIn.preview" xml:space="preserve"> + <value>自分が運用するゲームを申請するには、パスキーでサインインする。失くすパスワードも、盗まれるパスワードもない。</value> + </data> + <data name="account.signIn.noDatabase" xml:space="preserve"> + <value>申請にはデータベースが必要だが、このサイトはデモ用のダミーデータで動いている。サインインする先がない。</value> + </data> + <data name="account.signIn.passkey.lead" xml:space="preserve"> + <value>サインインはパスキーで行う。</value> + </data> + <data name="account.signIn.passkey.body" xml:space="preserve"> + <value>秘密鍵はあなたの端末かパスワードマネージャーが持ち、当サイトが持つのは公開鍵の側だけ。パスワードもメールアドレスもない。</value> + </data> + <data name="account.signIn.button" xml:space="preserve"> + <value>パスキーでサインイン</value> + </data> + <data name="account.signIn.script" xml:space="preserve"> + <value>このサイトでJavaScriptを必要とする唯一のページ。パスキーはそれなしでは動かない。</value> + </data> + <data name="account.register.heading" xml:space="preserve"> + <value>アカウントがまだない場合</value> + </data> + <data name="account.register.lede" xml:space="preserve"> + <value>アカウントが要るのは、自分が運用するゲームを申請するときだけ。名乗る名前を選ぶ — 申請の横に並ぶラベルであって、本名ではない。</value> + </data> + <data name="account.register.name.label" xml:space="preserve"> + <value>名前</value> + </data> + <data name="account.register.name.placeholder" xml:space="preserve"> + <value>例：corvid-admin</value> + </data> + <data name="account.register.button" xml:space="preserve"> + <value>パスキーでアカウントを作成</value> + </data> + <data name="account.store.heading" xml:space="preserve"> + <value>保存するもの</value> + </data> + <data name="account.store.name" xml:space="preserve"> + <value>選んだ名前。</value> + </data> + <data name="account.store.keys" xml:space="preserve"> + <value>登録した各パスキーの公開鍵と、端末が付けた名称。</value> + </data> + <data name="account.store.claims" xml:space="preserve"> + <value>申請したゲームと、その時期。</value> + </data> + <data name="account.store.note" xml:space="preserve"> + <value>アカウントに紐づくメールアドレスも、パスワードも、IPの記録もない。パスキーをすべて失っても、ゲームに新しい申請トークンを公開すればやり直せる：証明になるのはゲームであって、アカウントではない。</value> + </data> + <data name="date.absolute" xml:space="preserve"> + <value>{year}年{month}{day}日</value> + </data> + <data name="date.stamp" xml:space="preserve"> + <value>{date} {time} UTC</value> + </data> + <data name="age.short.now" xml:space="preserve"> + <value>今</value> + </data> + <data name="age.short.minutes" xml:space="preserve"> + <value>{count, plural, other {#分}}</value> + </data> + <data name="age.short.hours" xml:space="preserve"> + <value>{count, plural, other {#時間}}</value> + </data> + <data name="age.short.days" xml:space="preserve"> + <value>{count, plural, other {#日}}</value> + </data> + <data name="age.short.weeks" xml:space="preserve"> + <value>{count, plural, other {#週}}</value> + </data> + <data name="age.short.months" xml:space="preserve"> + <value>{count, plural, other {#か月}}</value> + </data> + <data name="age.short.years" xml:space="preserve"> + <value>{count, plural, other {#年}}</value> + </data> + <data name="age.ago.now" xml:space="preserve"> + <value>たった今</value> + </data> + <data name="age.ago.minutes" xml:space="preserve"> + <value>{count, plural, other {#分前}}</value> + </data> + <data name="age.ago.hours" xml:space="preserve"> + <value>{count, plural, other {#時間前}}</value> + </data> + <data name="age.ago.days" xml:space="preserve"> + <value>{count, plural, other {#日前}}</value> + </data> + <data name="age.ago.weeks" xml:space="preserve"> + <value>{count, plural, other {#週前}}</value> + </data> + <data name="age.ago.months" xml:space="preserve"> + <value>{count, plural, other {#か月前}}</value> + </data> + <data name="age.ago.years" xml:space="preserve"> + <value>{count, plural, other {#年前}}</value> + </data> + <data name="age.dark.now" xml:space="preserve"> + <value>たった今</value> + </data> + <data name="age.dark.minutes" xml:space="preserve"> + <value>{count, plural, other {#分前}}</value> + </data> + <data name="age.dark.hours" xml:space="preserve"> + <value>{count, plural, other {#時間前}}</value> + </data> + <data name="age.dark.days" xml:space="preserve"> + <value>{count, plural, other {#日前}}</value> + </data> + <data name="age.dark.weeks" xml:space="preserve"> + <value>{count, plural, other {#週前}}</value> + </data> + <data name="age.dark.months" xml:space="preserve"> + <value>{count, plural, other {#か月前}}</value> + </data> + <data name="age.dark.years" xml:space="preserve"> + <value>{count, plural, other {#年前}}</value> + </data> + <data name="time.title" xml:space="preserve"> + <value>{age}、{stamp}</value> + </data> + <data name="time.spoken" xml:space="preserve"> + <value>、{stamp}</value> + </data> + <data name="chip.title" xml:space="preserve"> + <value>{value} — {source}による{how}、最終確認{date}</value> + </data> + <data name="chip.title.stale" xml:space="preserve"> + <value>{value} — {source}による{how}、最終確認{date}（想定の更新期間を過ぎている）</value> + </data> + <data name="chip.plain" xml:space="preserve"> + <value>（{how}、{age}）</value> + </data> + <data name="chip.plain.stale" xml:space="preserve"> + <value>（{how}、{age}、更新期間超過）</value> + </data> + <data name="provenance.game.ownerDeclared" xml:space="preserve"> + <value>所有者申告</value> + </data> + <data name="source.staff" xml:space="preserve"> + <value>スタッフ</value> + </data> + <data name="source.handshake" xml:space="preserve"> + <value>telnetハンドシェイク</value> + </data> + <data name="source.owner" xml:space="preserve"> + <value>所有者</value> + </data> + <data name="source.who" xml:space="preserve"> + <value>WHO</value> + </data> + <data name="source.i3" xml:space="preserve"> + <value>I3</value> + </data> + <data name="source.mssp" xml:space="preserve"> + <value>MSSP</value> + </data> + <data name="source.info" xml:space="preserve"> + <value>INFO</value> + </data> + <data name="source.i3Mudlist" xml:space="preserve"> + <value>I3のmudlist</value> + </data> + <data name="source.banner" xml:space="preserve"> + <value>接続画面</value> + </data> + <data name="ecosystem.title" xml:space="preserve"> + <value>エコシステム</value> + </data> + <data name="ecosystem.noTotals" xml:space="preserve"> + <value>示すのはシェアであって、総数ではない。MU*を遊んでいる人数の数値は公表しない：実測したゲームに対する比率は、到達できないゲームがあっても意味を保つが、人数の総計は保たない。</value> + </data> + <data name="ecosystem.listed" xml:space="preserve"> + <value>{count, plural, other {掲載ゲーム{value}件}}</value> + </data> + <data name="ecosystem.handshakes" xml:space="preserve"> + <value>{count, plural, other {ハンドシェイクを完了したゲーム{value}件}}</value> + </data> + <data name="ecosystem.msspReports" xml:space="preserve"> + <value>{count, plural, other {MSSPレポートを保有するゲーム{value}件}}</value> + </data> + <data name="ecosystem.oldestHandshake" xml:space="preserve"> + <value>ここで最も古いハンドシェイク：{age}前に確認。</value> + </data> + <data name="ecosystem.share" xml:space="preserve"> + <value>{total, number}件中{count, number}件（{fraction, number, ::percent .0}）</value> + </data> + <data name="ecosystem.share.nothing" xml:space="preserve"> + <value>{total, number}件中{count, number}件 — 実測はまだなし</value> + </data> + <data name="ecosystem.share.percent" xml:space="preserve"> + <value>{fraction, number, ::percent .0}</value> + </data> + <data name="ecosystem.codebases.title" xml:space="preserve"> + <value>コードベース</value> + </data> + <data name="ecosystem.codebases.basis" xml:space="preserve"> + <value>掲載している{listed, plural, other {#件のゲーム}}のうち、{identified, number}件が動かしているものを伝えてきた。以下のシェアはすべてその{identified, number}件に対するもの。読み取れなかったコードベースは分母から外し、別の何かとして数えることはしない。</value> + </data> + <data name="ecosystem.codebases.none" xml:space="preserve"> + <value>コードベースを伝えてきた掲載ゲームはまだない。</value> + </data> + <data name="ecosystem.soleUse" xml:space="preserve"> + <value>{share}は、他のどの掲載ゲームも使っていないコードベースを動かしている — それぞれ1件ずつで、シェアというより名前。上の分母には含まれており、棒グラフからまとめて外してあるだけで、除外はしていない：</value> + </data> + <data name="ecosystem.lineages.title" xml:space="preserve"> + <value>系統</value> + </data> + <data name="ecosystem.lineages.basis" xml:space="preserve"> + <value>同じゲームを、サーバーが受け継いだ伝統ごとにまとめたもの — コードベースについての当サイトの読み取りであって、ゲームが公開した内容ではない。「MUSH」と報告するゲームはない：MSSPにその値はなく、MUSH界の大半はそもそもMSSPを公開していないので、この問いを立てる方法はこれしかない。</value> + </data> + <data name="ecosystem.lineages.none" xml:space="preserve"> + <value>系統に位置づけているコードベースを動かしている掲載ゲームは、まだない。</value> + </data> + <data name="ecosystem.lineages.notClassified" xml:space="preserve"> + <value>{count, plural, other {そのうち#件は、どの系統にも位置づけていないコードベースを動かしている}} — {family}を公開して、そう自ら述べているものもいくつかある。上の分母には含まれており、どのシェアにも入っていない。</value> + </data> + <data name="ecosystem.protocols.title" xml:space="preserve"> + <value>プロトコル</value> + </data> + <data name="ecosystem.protocols.floor" xml:space="preserve"> + <value>以下の実測値はいずれも下限として読むこと。MSSPは名指しで要求するので、そこでの沈黙は一つの答え。それ以外は要求していないので、サーバーが一度も提供しないまま対応していることもありうる。</value> + </data> + <data name="ecosystem.mssp.instrument" xml:space="preserve"> + <value>{instrument}は、以下で唯一、下限ではない行：すべてのサーバーに名指しで要求しているので、提供しなかったゲームは訊かれたうえで断ったことになる。自己申告の数値がない唯一の行でもある。レポートを保有しているゲームは実演によって対応を示しており、そのうえで自ら列挙したゲームを数えても、測れるのは習慣のほうだから。</value> + </data> + <data name="ecosystem.mssp.gap" xml:space="preserve"> + <value>保有しているレポートは{reports, number}件で、現在MSSPを提供しているのは{offered, plural, other {#件のゲーム}}：残る{gap, number}件は、こちらが読んだあとに公開をやめたもの。再発行されなくなったからといって、レポートを捨てることはしない。</value> + </data> + <data name="ecosystem.protocols.caption" xml:space="preserve"> + <value>プロトコルの採用状況。実測は完了したハンドシェイクでサーバーが提供したもの、自己申告はそのMSSPが主張するもの。ゲームの集合が2つなので、分母も2つ。</value> + </data> + <data name="ecosystem.column.protocol" xml:space="preserve"> + <value>プロトコル</value> + </data> + <data name="ecosystem.column.measured" xml:space="preserve"> + <value>実測 — {basis}中</value> + </data> + <data name="ecosystem.column.declared" xml:space="preserve"> + <value>自己申告 — {basis}中</value> + </data> + <data name="ecosystem.measured.never" xml:space="preserve"> + <value>未計測 — 一度も観測なし</value> + </data> + <data name="ecosystem.measured.declined" xml:space="preserve"> + <value>{share} · {declined, plural, other {#件のゲーム}}が要求に対して辞退</value> + </data> + <data name="ecosystem.measured.unasked" xml:space="preserve"> + <value>{share} · {unobserved, plural, other {#件のゲーム}}は提供も要求もなし</value> + </data> + <data name="ecosystem.measured.declinedAndUnasked" xml:space="preserve"> + <value>{share} · {declined, plural, other {#件のゲーム}}が要求に対して辞退 · {unobserved, plural, other {#件のゲーム}}は提供も要求もなし</value> + </data> + <data name="ecosystem.declared.none" xml:space="preserve"> + <value>要求せず — ここにあるレポートのすべてが答え</value> + </data> + <data name="ecosystem.curve.title" xml:space="preserve"> + <value>採用状況の推移</value> + </data> + <data name="ecosystem.curve.caveat" xml:space="preserve"> + <value>各点は、その日までに実測していたゲームに対するシェアなので、この線が動く理由は2つある：ゲームが提供内容を変えること、そして実測できるゲームの集合が周りで変わること。採用と言えるのは前者だけ。以下の変化件数は、純粋にゲームが考えを変えた分。</value> + </data> + <data name="ecosystem.curve.caption" xml:space="preserve"> + <value>プロトコルごとの実測シェア、古い読み取りから順に</value> + </data> + <data name="ecosystem.curve.then" xml:space="preserve"> + <value>当時</value> + </data> + <data name="ecosystem.curve.now" xml:space="preserve"> + <value>現在</value> + </data> + <data name="ecosystem.curve.notMeasured" xml:space="preserve"> + <value>未計測</value> + </data> + <data name="ecosystem.snapshot.title" xml:space="preserve"> + <value>曲線ではなくスナップショット</value> + </data> + <data name="ecosystem.snapshot" xml:space="preserve"> + <value>現在実測できるもののスナップショット。採用曲線が描くのはゲームが考えを変えた点であり、当サイトは変化が起きたときにそれを記録しているので、十分な数がたまれば曲線を描けるようになる。各ゲームに最初に到達した時点を描いても、測れるのはクロールであってホビーではない。</value> + </data> + <data name="ecosystem.transitions" xml:space="preserve"> + <value>{count, plural, other {これまでに記録した機能の変化は#件}} — 曲線を描くための材料。</value> + </data> + <data name="ecosystem.transitions.none" xml:space="preserve"> + <value>実測した機能はまだ一つも変化していないので、描くものがない。</value> + </data> + <data name="ecosystem.plain.denominators" xml:space="preserve"> + <value>実測は{measured}に対するもの、自己申告は{declared}に対するもの。ゲームの集合が2つなので、分母も2つ。</value> + </data> + <data name="ecosystem.plain.counts" xml:space="preserve"> + <value>{listed} · {handshakes} · {mssp}。</value> + </data> + <data name="ecosystem.plain.oldestHandshake" xml:space="preserve"> + <value>この図で最も古いハンドシェイクの最終確認は{age}前。</value> + </data> + <data name="ecosystem.plain.lineages" xml:space="preserve"> + <value>同じゲームを、サーバーが受け継いだ伝統ごとにまとめたもの。これは{evidence} — {meaning} — であって、ゲームが公開した内容ではない：「MUSH」と報告するゲームはない。MSSPにその値はなく、MUSH界の大半はそもそもMSSPを公開していないから。</value> + </data> + <data name="ecosystem.plain.measured" xml:space="preserve"> + <value>実測：{value}</value> + </data> + <data name="ecosystem.plain.declared" xml:space="preserve"> + <value>自己申告：{value}</value> + </data> + <data name="rankings.title" xml:space="preserve"> + <value>ランキング</value> + </data> + <data name="rankings.noVote" xml:space="preserve"> + <value>実測データのみから算出。投票も、星も、評価も一切ない。ここでは品質の順位づけはしない。それは実測していない。</value> + </data> + <data name="rankings.busiest.title" xml:space="preserve"> + <value>最も賑わうゲーム、実測の同時接続数順</value> + </data> + <data name="rankings.window.label" xml:space="preserve"> + <value>ランキングの期間</value> + </data> + <data name="rankings.span" xml:space="preserve"> + <value>{days, plural, other {#日}}</value> + </data> + <data name="rankings.basis.median" xml:space="preserve"> + <value>直近{days, plural, other {#日}}に実測した接続数の中央値。</value> + </data> + <data name="rankings.basis.none" xml:space="preserve"> + <value>中央値に必要な、{days, plural, other {#日}}にわたる{samples, number}件のサンプルを満たすゲームは、まだない。</value> + </data> + <data name="rankings.basis.eligible" xml:space="preserve"> + <value>掲載{listed, number}件のうち{eligible, plural, other {#件のゲーム}}が、必要な、{days, plural, other {#日}}にわたる{samples, number}件のサンプルを満たしている。</value> + </data> + <data name="rankings.basis.zero" xml:space="preserve"> + <value>実測のゼロは数に入る。読み取れなかった計数は入らない。</value> + </data> + <data name="rankings.spanChoice" xml:space="preserve"> + <value>1週間は今誰が賑わっているかを、四半期はこれまで誰が賑わってきたかを示す。別々の問いであり、一方で首位のゲームが他方でもそうとは限らない。日は暦日、UTC。</value> + </data> + <data name="rankings.busiest.empty" xml:space="preserve"> + <value>順位づけに足るだけの計数サンプルがある掲載ゲームは、まだない — これは実測を続けてきた期間についての言明であって、誰かの賑わいについてのものではない。</value> + </data> + <data name="rankings.busiest.caption" xml:space="preserve"> + <value>直近{days, plural, other {#日}}に実測した接続数の中央値でゲームを順位づけたもの。中央値が同じゲームは同順位で、ここでは同点を崩さない。</value> + </data> + <data name="rankings.column.place" xml:space="preserve"> + <value>#</value> + </data> + <data name="rankings.column.game" xml:space="preserve"> + <value>ゲーム</value> + </data> + <data name="rankings.column.median" xml:space="preserve"> + <value>中央値</value> + </data> + <data name="rankings.column.peak" xml:space="preserve"> + <value>ピーク</value> + </data> + <data name="rankings.column.samples" xml:space="preserve"> + <value>計数サンプル</value> + </data> + <data name="rankings.column.days" xml:space="preserve"> + <value>実測日数</value> + </data> + <data name="rankings.spells.title" xml:space="preserve"> + <value>到達可能が途切れなかった最長期間</value> + </data> + <data name="rankings.spells.basis" xml:space="preserve"> + <value>示した日付以降、すべての探査でそのゲームは到達可能だった。稼働ではなく到達可能：1台のホストからソケットを実測しているだけで、経路が通らないゲームも健在。この期間が観測してきた期間より長くなることはないので、事実は日付のほうであり、長さはそこから導かれる。</value> + </data> + <data name="rankings.spells.empty" xml:space="preserve"> + <value>現在、到達可能が途切れずに続いている掲載ゲームはない。</value> + </data> + <data name="rankings.spells.caption" xml:space="preserve"> + <value>示した日付以降のすべての探査で到達可能だったゲーム。到達可能の起点が同じゲームは同順位で、ここでは同点を崩さない。</value> + </data> + <data name="rankings.column.since" xml:space="preserve"> + <value>到達可能の起点</value> + </data> + <data name="rankings.column.duration" xml:space="preserve"> + <value>その長さ</value> + </data> + <data name="rankings.archivedNote" xml:space="preserve"> + <value>アーカイブ済みのゲームは両方の表から外れるだけで、それ以外は何も変わらない。1回の探査が成功すれば戻る。</value> + </data> + <data name="rankings.plain.busiest" xml:space="preserve"> + <value>最も賑わうゲーム — 実測接続数の中央値、直近{days, plural, other {#日}}</value> + </data> + <data name="rankings.plain.windows" xml:space="preserve"> + <value>期間：</value> + </data> + <data name="rankings.plain.thisOne" xml:space="preserve"> + <value>これ</value> + </data> + <data name="rankings.plain.row" xml:space="preserve"> + <value>中央値{median, number} · ピーク{peak, number} · {window, number}日のうち{days, number}日で{samples, plural, other {計数サンプル#件}}</value> + </data> + <data name="rankings.plain.spellRow" xml:space="preserve"> + <value>{date}以降のすべての探査で到達可能 · {duration}</value> + </data> + <data name="archive.title" xml:space="preserve"> + <value>アーカイブ</value> + </data> + <data name="archive.lede" xml:space="preserve"> + <value>応答しなくなったゲーム。削除はしていない。毎週の探査は続いており、1回の探査が成功すれば、その日のうちに一覧へ戻る。</value> + </data> + <data name="archive.search.legend" xml:space="preserve"> + <value>アーカイブを検索</value> + </data> + <data name="archive.search.label" xml:space="preserve"> + <value>アーカイブ済みのゲームを検索</value> + </data> + <data name="archive.search.placeholder" xml:space="preserve"> + <value>名前・コードベース・説明</value> + </data> + <data name="archive.search.submit" xml:space="preserve"> + <value>表示</value> + </data> + <data name="archive.count" xml:space="preserve"> + <value>{count, plural, =0 {アーカイブ済みのゲームなし} other {アーカイブ済みのゲーム#件}}</value> + </data> + <data name="archive.badge" xml:space="preserve"> + <value>アーカイブ済み</value> + </data> + <data name="archive.lastReachable" xml:space="preserve"> + <value>最終到達</value> + </data> + <data name="archive.knownLive" xml:space="preserve"> + <value>稼働確認期間</value> + </data> + <data name="archive.darkFor" xml:space="preserve"> + <value>（{age}前）</value> + </data> + <data name="archive.empty" xml:space="preserve"> + <value>該当なし。</value> + </data> + <data name="archive.neverReachable" xml:space="preserve"> + <value>実測した範囲では一度もなし</value> + </data> + <data name="archive.noReachableTime" xml:space="preserve"> + <value>到達可能時間の実測なし</value> + </data> + <data name="archive.darkFor.unknown" xml:space="preserve"> + <value>不明</value> + </data> + <data name="archive.knownLive.years" xml:space="preserve"> + <value>{years, number, ::.#}年</value> + </data> + <data name="archive.knownLive.days" xml:space="preserve"> + <value>{days, plural, other {#日}}</value> + </data> + <data name="archive.run" xml:space="preserve"> + <value>{from} – {to} · {span}</value> + </data> + <data name="archive.run.months" xml:space="preserve"> + <value>{count, plural, other {#か月}}</value> + </data> + <data name="archive.run.years" xml:space="preserve"> + <value>{count, plural, other {#年}}</value> + </data> + <data name="archive.plain.matching" xml:space="preserve"> + <value>「{query}」に一致する{count, plural, other {#件のゲーム}}</value> + </data> + <data name="archive.plain.count" xml:space="preserve"> + <value>{count, plural, other {#件のゲーム}}</value> + </data> + <data name="archive.plain.lastReachable" xml:space="preserve"> + <value>最終到達：</value> + </data> + <data name="archive.plain.knownLive" xml:space="preserve"> + <value>稼働確認期間：</value> + </data> + <data name="archive.plain.knownLiveValue" xml:space="preserve"> + <value>実測した到達可能時間のうち{value}</value> + </data> + <data name="archive.plain.run" xml:space="preserve"> + <value>稼働期間：</value> + </data> + <data name="archive.plain.codebase" xml:space="preserve"> + <value>コードベース：</value> + </data> + <data name="footer.randomGame" xml:space="preserve"> + <value>ランダムなゲーム</value> + </data> + <data name="trend.day.counted" xml:space="preserve"> + <value>{d, date, medium} — 平均{typical}、{probes, plural, other {#回の探査}}で{low}〜{high}</value> + </data> + <data name="trend.day.flat" xml:space="preserve"> + <value>{d, date, medium} — {count, plural, =0 {接続数0} other {#人}}、{probes, plural, other {#回の探査}}のいずれでも同じ</value> + </data> + <data name="trend.day.notCounted" xml:space="preserve"> + <value>{d, date, medium} — 探査したが接続数は読み取れず</value> + </data> + <data name="trend.day.notMeasured" xml:space="preserve"> + <value>{d, date, medium} — 実測なし</value> + </data> + <data name="trend.summary" xml:space="preserve"> + <value>{days, plural, other {#日}}のうち{counted}日で、通常{typical}、ピークは{peak}。</value> + </data> + <data name="trend.direction.steady" xml:space="preserve"> + <value>この範囲を通じて横ばい。</value> + </data> + <data name="trend.direction.up" xml:space="preserve"> + <value>範囲の始めから終わりまでで約{change, number, percent}の増加。</value> + </data> + <data name="trend.direction.down" xml:space="preserve"> + <value>範囲の始めから終わりまでで約{change, number, percent}の減少。</value> + </data> + <data name="trend.none.probed" xml:space="preserve"> + <value>この範囲では探査したが、そのどこからも接続数は読み取れず。</value> + </data> + <data name="trend.none.notMeasured" xml:space="preserve"> + <value>この範囲に実測なし。</value> + </data> + <data name="trend.empty" xml:space="preserve"> + <value>この範囲に計数なし。</value> + </data> + <data name="trend.week.span" xml:space="preserve"> + <value>{from, date, d MMM}〜{to, date, d MMM}</value> + </data> + <data name="trend.week.oneDay" xml:space="preserve"> + <value>{d, date, d MMM}</value> + </data> + <data name="trend.week.counted" xml:space="preserve"> + <value>{span}：通常{typical}、ピーク{peak}、{days, plural, other {#日}}を計数</value> + </data> + <data name="trend.week.notCounted" xml:space="preserve"> + <value>{span}：探査したが接続数は読み取れず</value> + </data> + <data name="trend.week.notMeasured" xml:space="preserve"> + <value>{span}：未計測</value> + </data> + <data name="trend.week.uncounted" xml:space="preserve"> + <value>{count, plural, other {#日は探査したが計数なし}}</value> + </data> + <data name="trend.week.unmeasured" xml:space="preserve"> + <value>{count, plural, other {#日は未計測}}</value> + </data> + <data name="trend.week.and" xml:space="preserve"> + <value>{line}、{clause}</value> + </data> + <data name="trend.range" xml:space="preserve"> + <value>日付はUTC · {from, date, medium} – {to, date, medium}</value> + </data> + <data name="trend.ceiling" xml:space="preserve"> + <value>上端は{value}</value> + </data> + <data name="trend.counted" xml:space="preserve"> + <value>{days, plural, other {#日}}のうち{counted}日を計数</value> + </data> + <data name="trend.axis.month" xml:space="preserve"> + <value>{d, date, MMM}</value> + </data> + <data name="trend.axis.monthYear" xml:space="preserve"> + <value>{d, date, MMM yyyy}</value> + </data> + <data name="trend.legend.mean" xml:space="preserve"> + <value>その日に読み取った計数の平均</value> + </data> + <data name="trend.legend.peak" xml:space="preserve"> + <value>その日の最多の計数まで</value> + </data> + <data name="trend.legend.band" xml:space="preserve"> + <value>その日の最少から最多までの計数</value> + </data> + <data name="trend.legend.notCounted" xml:space="preserve"> + <value>探査したが接続数は読み取れず</value> + </data> + <data name="trend.legend.notMeasured.bar" xml:space="preserve"> + <value>未計測 — 棒そのものなし</value> + </data> + <data name="trend.legend.notMeasured.line" xml:space="preserve"> + <value>未計測 — 線が途切れる</value> + </data> + <data name="trend.spans.label" xml:space="preserve"> + <value>推移の範囲</value> + </data> + <data name="trend.shapes.label" xml:space="preserve"> + <value>推移の形</value> + </data> + <data name="trend.preset" xml:space="preserve"> + <value>{days, plural, other {#日}}</value> + </data> + <data name="trend.earlier" xml:space="preserve"> + <value>← 前の期間</value> + </data> + <data name="trend.later" xml:space="preserve"> + <value>後の期間 →</value> + </data> + <data name="trend.shape.line" xml:space="preserve"> + <value>折れ線</value> + </data> + <data name="trend.shape.bar" xml:space="preserve"> + <value>棒</value> + </data> + <data name="trend.plain.heading" xml:space="preserve"> + <value>接続数の推移</value> + </data> + <data name="trend.plain.range" xml:space="preserve"> + <value>{from, date, medium} – {to, date, medium}、UTC</value> + </data> + <data name="trend.plain.earlier" xml:space="preserve"> + <value>前の期間</value> + </data> + <data name="trend.plain.note" xml:space="preserve"> + <value>週は、その週のうち計数できた日をまとめたもの。1日もない週はそう記す</value> + </data> + <data name="reach.kicker" xml:space="preserve"> + <value>到達可能 · 直近{days, plural, other {#日}}</value> + </data> + <data name="reach.stat.reachable" xml:space="preserve"> + <value>到達可能</value> + </data> + <data name="reach.stat.longestOutage" xml:space="preserve"> + <value>最長の途絶</value> + </data> + <data name="reach.stat.lastCause" xml:space="preserve"> + <value>直近の原因</value> + </data> + <data name="reach.noOutage" xml:space="preserve"> + <value>期間内になし</value> + </data> + <data name="reach.noCause" xml:space="preserve"> + <value>記録なし</value> + </data> + <data name="reach.scale.ago" xml:space="preserve"> + <value>{days, plural, other {#日前}}</value> + </data> + <data name="reach.scale.today" xml:space="preserve"> + <value>今日</value> + </data> + <data name="reach.legend.reachable" xml:space="preserve"> + <value>到達可能</value> + </data> + <data name="reach.legend.degraded" xml:space="preserve"> + <value>劣化 — 応答はあったが完了せず</value> + </data> + <data name="reach.legend.unreachable" xml:space="preserve"> + <value>到達不可</value> + </data> + <data name="reach.legend.notMeasured" xml:space="preserve"> + <value>未計測</value> + </data> + <data name="reach.word.reachable" xml:space="preserve"> + <value>到達可能</value> + </data> + <data name="reach.word.degraded" xml:space="preserve"> + <value>劣化</value> + </data> + <data name="reach.word.unreachable" xml:space="preserve"> + <value>到達不可</value> + </data> + <data name="reach.word.notMeasured" xml:space="preserve"> + <value>未計測</value> + </data> + <data name="reach.day.reachable" xml:space="preserve"> + <value>{d, date, d MMM} — 終日到達可能</value> + </data> + <data name="reach.day.degraded" xml:space="preserve"> + <value>{d, date, d MMM} — 劣化（{cause}）：応答はあったが完了せず</value> + </data> + <data name="reach.day.unreachable" xml:space="preserve"> + <value>{d, date, d MMM} — 到達不可（{cause}）</value> + </data> + <data name="reach.day.notMeasured" xml:space="preserve"> + <value>{d, date, d MMM} — 未計測。このゲームはまだ観測していなかった</value> + </data> + <data name="reach.none" xml:space="preserve"> + <value>{days, plural, other {直近#日はまだ未計測。}}</value> + </data> + <data name="reach.fraction.window" xml:space="preserve"> + <value>直近{days, plural, other {#日}}のうち{percent}が到達可能。</value> + </data> + <data name="reach.fraction.measured" xml:space="preserve"> + <value>実測した{days, plural, other {#日}}のうち{percent}が到達可能。</value> + </data> + <data name="reach.fraction.unknown" xml:space="preserve"> + <value>{days, plural, other {直近#日の到達可能性は、まだ未計測。}}</value> + </data> + <data name="reach.unreachable.noneInWindow" xml:space="preserve"> + <value>期間内に到達不可の日はなし。</value> + </data> + <data name="reach.unreachable.noneMeasured" xml:space="preserve"> + <value>実測した日に到達不可はなし。</value> + </data> + <data name="reach.unreachable.days" xml:space="preserve"> + <value>{count, plural, other {#日が到達不可。}}</value> + </data> + <data name="reach.degraded.days" xml:space="preserve"> + <value>{count, plural, other {#日が劣化 — 接続はできたが完了できず。}}</value> + </data> + <data name="reach.longestOutage" xml:space="preserve"> + <value>最長の途絶は{duration}。</value> + </data> + <data name="reach.longestOutage.cause" xml:space="preserve"> + <value>最長の途絶は{duration}（{cause}）。</value> + </data> + <data name="reach.predate" xml:space="preserve"> + <value>{count, plural, other {#日は、実測が始まる前。}}</value> + </data> + <data name="reach.spell.range" xml:space="preserve"> + <value>{from, date, d MMM} – {to, date, d MMM}</value> + </data> + <data name="reach.spell.oneDay" xml:space="preserve"> + <value>{d, date, d MMM}</value> + </data> + <data name="reach.spell" xml:space="preserve"> + <value>{range}：{count, plural, other {#日}}{word}</value> + </data> + <data name="reach.spell.cause" xml:space="preserve"> + <value>{range}：{count, plural, other {#日}}{word}（{cause}）</value> + </data> + <data name="reach.plain.heading" xml:space="preserve"> + <value>到達可能</value> + </data> + <data name="reach.plain.window" xml:space="preserve"> + <value>{days, plural, other {直近#日}}</value> + </data> + <data name="reach.plain.fraction" xml:space="preserve"> + <value>到達可能：{days, plural, other {直近#日}}のうち{percent}</value> + </data> + <data name="reach.plain.longestOutage" xml:space="preserve"> + <value>最長の途絶：{duration}</value> + </data> + <data name="cause.dns" xml:space="preserve"> + <value>dnsが解決しなかった</value> + </data> + <data name="cause.refused" xml:space="preserve"> + <value>接続を拒否された</value> + </data> + <data name="cause.tls" xml:space="preserve"> + <value>tlsが失敗した</value> + </data> + <data name="cause.timeout" xml:space="preserve"> + <value>タイムアウトした</value> + </data> + <data name="cause.handshakeStalled" xml:space="preserve"> + <value>ハンドシェイクが止まった</value> + </data> + <data name="cause.none" xml:space="preserve"> + <value>原因の記録なし</value> + </data> + <data name="ansi.suppressed" xml:space="preserve"> + <value>このゲームの接続画面を再公開しないよう、所有者から要請があった。</value> + </data> + <data name="ansi.absent" xml:space="preserve"> + <value>このゲームから接続画面は取得できていない。</value> + </data> + <data name="ansi.tooSmall" xml:space="preserve"> + <value>{count, plural, other {返ってきたのは#行だけ — 表示するには少なすぎる。}}</value> + </data> + <data name="ansi.asSent" xml:space="preserve"> + <value>サーバーが送ったまま</value> + </data> + <data name="ansi.size" xml:space="preserve"> + <value>{columns}×{rows}</value> + </data> + <data name="ansi.size.doubleWidth" xml:space="preserve"> + <value>{columns}×{rows}、倍幅</value> + </data> + <data name="ansi.depth.colour" xml:space="preserve"> + <value>16色SGR</value> + </data> + <data name="ansi.depth.plain" xml:space="preserve"> + <value>色なし</value> + </data> + <data name="ansi.readAs" xml:space="preserve"> + <value>{charset}として読み取り</value> + </data> + <data name="ansi.captured" xml:space="preserve"> + <value>取得</value> + </data> + <data name="ansi.frozen" xml:space="preserve"> + <value>凍結 — 最後に見た画面</value> + </data> + <data name="ansi.alt.named" xml:space="preserve"> + <value>ASCIIアート：{game}の接続画面。その文字は下の「テキストで読む」にある。</value> + </data> + <data name="ansi.alt" xml:space="preserve"> + <value>ASCIIアート：このゲームの接続画面。その文字は下の「テキストで読む」にある。</value> + </data> + <data name="ansi.plain.rows" xml:space="preserve"> + <value>{count, plural, other {接続画面：#行、テキストのみ}}</value> + </data> + <data name="ansi.plain.rows.readAs" xml:space="preserve"> + <value>{count, plural, other {接続画面：#行、テキストのみ、{charset}として読み取り}}</value> + </data> + <data name="capability.disagree.declaredNotOffered" xml:space="preserve"> + <value>ゲームは申告しているが、サーバーはハンドシェイクで一度も提供していない。</value> + </data> + <data name="capability.disagree.offeredNotDeclared" xml:space="preserve"> + <value>サーバーは提供しているが、ゲーム自身の記載では非対応となっている。</value> + </data> + <data name="capability.disagree.note" xml:space="preserve"> + <value>たいていは手書きのフィールドが古いだけで、嘘ではない。両者が食い違う点にクライアントが依存すべきではないので表示している。</value> + </data> + <data name="game.notFound" xml:space="preserve"> + <value>見つからない</value> + </data> + <data name="game.notFound.hint" xml:space="preserve"> + <value>このアドレスにゲームはない。綴りを確認。</value> + </data> + <data name="game.endpoint.lastAnswered" xml:space="preserve"> + <value>最終応答</value> + </data> + <data name="game.stale" xml:space="preserve"> + <value>{count, plural, other {#件が更新期間を過ぎている。古いだけで、誤りではない。}}</value> + </data> + <data name="game.referrals.lists" xml:space="preserve"> + <value>このゲーム自身のリファラル一覧が挙げているもの：</value> + </data> + <data name="game.referrals.listedBy" xml:space="preserve"> + <value>このゲームを挙げているリファラル一覧：</value> + </data> + <data name="game.referral.since" xml:space="preserve"> + <value>{date}から</value> + </data> + <data name="game.referral.dropped" xml:space="preserve"> + <value>掲載終了、最終確認</value> + </data> + <data name="game.archived.lastAnswered" xml:space="preserve"> + <value>最終応答は{date}、{ago}前。</value> + </data> + <data name="game.archived.stillProbed" xml:space="preserve"> + <value>毎週の探査は継続中。応答があれば、その日のうちにこのページが更新される。</value> + </data> + <data name="game.archived.knownLive" xml:space="preserve"> + <value>稼働確認期間{span}</value> + </data> + <data name="game.excluded" xml:space="preserve"> + <value>一覧、ランキング、日次の数値には含まれない：このアドレスが誰かの遊べるゲームだとは考えていない。以下はすべて、このアドレスが伝えてきた内容そのまま。</value> + </data> + <data name="game.excluded.reason" xml:space="preserve"> + <value>当サイトの理由：{why}</value> + </data> + <data name="game.unlisted" xml:space="preserve"> + <value>運用している人たちの要請により、一覧、ランキング、日次の数値には含まれない。以下はすべてそのまま保存されており、このページとこれまで持っていたすべてのアドレスは応答し続け、当サイトはダイヤルしていない。</value> + </data> + <data name="game.plain.playersNow" xml:space="preserve"> + <value>現在の接続数：{count}</value> + </data> + <data name="game.plain.capabilities" xml:space="preserve"> + <value>機能（{total}件のうち{disagreeing}件が不一致）</value> + </data> + <data name="game.plain.declared" xml:space="preserve"> + <value>ゲームの自己申告</value> + </data> + <data name="game.plain.connectScreen" xml:space="preserve"> + <value>接続画面</value> + </data> + <data name="game.plain.whatChanged" xml:space="preserve"> + <value>変更点</value> + </data> + <data name="game.plain.measured" xml:space="preserve"> + <value>実測</value> + </data> + <data name="game.plain.declared.column" xml:space="preserve"> + <value>自己申告</value> + </data> + <data name="game.plain.disagree" xml:space="preserve"> + <value>** 不一致</value> + </data> + <data name="listing.row.connected" xml:space="preserve"> + <value>接続数</value> + </data> + <data name="listing.row.reached" xml:space="preserve"> + <value>到達</value> + </data> + <data name="facet.group.search" xml:space="preserve"> + <value>検索</value> + </data> + <data name="facet.group.archived" xml:space="preserve"> + <value>アーカイブ済み</value> + </data> + <data name="facet.group.adult" xml:space="preserve"> + <value>アダルト</value> + </data> + <data name="facet.value.included" xml:space="preserve"> + <value>含む</value> + </data> + <data name="game.count.none" xml:space="preserve"> + <value>計数なし</value> + </data> + <data name="game.count.none.why" xml:space="preserve"> + <value>現在の計数なし、理由もここには記されていない</value> + </data> + <data name="game.plain.playersNoCount" xml:space="preserve"> + <value>現在の接続数：計数なし（理由もここには記されていない）</value> + </data> + <data name="crawler.live" xml:space="preserve"> + <value>クローラー実行中 · 最終探査{age}</value> + </data> + <data name="crawler.quiet" xml:space="preserve"> + <value>クローラー待機中 · 最終探査{age}</value> + </data> + <data name="crawler.noProbe" xml:space="preserve"> + <value>ここではまだ探査が一度も完了していない</value> + </data> + <data name="crawler.cycle.nothingDue" xml:space="preserve"> + <value>このサイクルに探査予定なし</value> + </data> + <data name="crawler.cycle" xml:space="preserve"> + <value>{considered, plural, other {#件が探査予定}} · {answered, plural, other {#件が応答}} · {failed, plural, other {#件が失敗}}</value> + </data> + <data name="crawler.registry" xml:space="preserve"> + <value>登録簿に{targets, plural, other {#件のアドレス}}、{due, plural, other {うち#件が現在探査予定}}</value> + </data> + <data name="preview.documentTitle" xml:space="preserve"> + <value>{page} — {site}</value> + </data> + <data name="preview.site" xml:space="preserve"> + <value>MU*ホビーのディレクトリ — MUSH、MUD、MUCK、MOO — どの事実にも、その出所といつのものかが記されている。</value> + </data> + <data name="preview.demo" xml:space="preserve"> + <value>デモデータ — ここにある値は実測ではない。{description}</value> + </data> + <data name="preview.cardAlt" xml:space="preserve"> + <value>{site} — 実測であって、申告ではない</value> + </data> + <data name="preview.cardAlt.named" xml:space="preserve"> + <value>{site}の{title}</value> + </data> + <data name="preview.title.games" xml:space="preserve"> + <value>ゲーム</value> + </data> + <data name="preview.title.archive" xml:space="preserve"> + <value>アーカイブ</value> + </data> + <data name="preview.title.rankings" xml:space="preserve"> + <value>ランキング</value> + </data> + <data name="preview.title.ecosystem" xml:space="preserve"> + <value>エコシステム</value> + </data> + <data name="preview.title.reference" xml:space="preserve"> + <value>リファレンス</value> + </data> + <data name="preview.title.about" xml:space="preserve"> + <value>概要</value> + </data> + <data name="preview.title.notFound" xml:space="preserve"> + <value>見つからない</value> + </data> + <data name="preview.title.random" xml:space="preserve"> + <value>ランダムなゲーム</value> + </data> + <data name="preview.title.account" xml:space="preserve"> + <value>自分のゲーム</value> + </data> + <data name="preview.title.claim" xml:space="preserve"> + <value>{game}を申請</value> + </data> + <data name="preview.desc.games" xml:space="preserve"> + <value>到達したすべてのMU*を、実測した内容で絞り込む：コードベース、サーバーがハンドシェイクで提供したプロトコル、TLS、エンコーディング、言語、そして最後に到達した時期。</value> + </data> + <data name="preview.desc.archive" xml:space="preserve"> + <value>消息不明になったゲームを、そのまま保持している。ページも履歴もURLも残り、毎週の探査は続き、1回接続できれば一覧に戻る。</value> + </data> + <data name="preview.desc.rankings" xml:space="preserve"> + <value>最も賑わう、最も到達可能、最も長く続く — 実測データのみから算出。投票も、星も、評価も、このサイトのどこにもない。</value> + </data> + <data name="preview.desc.ecosystem" xml:space="preserve"> + <value>実測しているゲーム全体でのコードベースのシェアとプロトコルの採用状況。サーバーが提供するものを、自己申告の内容と並べて示す。示すのはシェアであって、総数ではない。</value> + </data> + <data name="preview.desc.reference" xml:space="preserve"> + <value>MU*ホビーのコードベース、クライアント、プロトコルについて、人の手で書いたページ。クロールから得た件数と相互にリンクしている。</value> + </data> + <data name="preview.desc.about" xml:space="preserve"> + <value>このカタログの作り方：クローラーが何をするか、何を拒むか、そしてどう止めるか。</value> + </data> + <data name="preview.desc.notFound" xml:space="preserve"> + <value>このアドレスにゲームはない。ここでは何も削除しないので、かつてこのURLにあったゲームは今もある — 綴りを確認。</value> + </data> + <data name="preview.desc.random" xml:space="preserve"> + <value>カタログから1件、ランダムに選んだゲーム。同じものが二度出ることはない。</value> + </data> + <data name="preview.desc.account" xml:space="preserve"> + <value>申請した掲載と、申請によって何を変えられるか。</value> + </data> + <data name="preview.desc.claim" xml:space="preserve"> + <value>運用者にしか置けない場所にトークンを公開して、このゲームを運用していることを証明する。</value> + </data> + <data name="preview.game.archived" xml:space="preserve"> + <value>アーカイブ済み — 最終到達{age}、探査は継続中</value> + </data> + <data name="preview.game.archived.undated" xml:space="preserve"> + <value>アーカイブ済み、探査は継続中</value> + </data> + <data name="preview.game.countUnknown" xml:space="preserve"> + <value>接続数不明 — ゲームは応答するが、読み取れる数値は公開していない</value> + </data> + <data name="preview.game.count" xml:space="preserve"> + <value>{count, plural, other {#人}}、{how}、{age}</value> + </data> + <data name="feed.plain.newlyDiscovered" xml:space="preserve"> + <value>新規発見</value> + </data> + <data name="feed.plain.wentDark" xml:space="preserve"> + <value>消息不明</value> + </data> + <data name="feed.plain.cameBack" xml:space="preserve"> + <value>復帰</value> + </data> + <data name="home.plain.known" xml:space="preserve"> + <value>{count, plural, other {既知のゲーム#件}}</value> + </data> + <data name="home.plain.connectedNow" xml:space="preserve"> + <value>{count, plural, other {現在接続中#人（実測）}}</value> + </data> + <data name="home.plain.uncounted" xml:space="preserve"> + <value>{count, plural, other {応答あり・読み取り不可#件}}</value> + </data> + <data name="home.plain.archived" xml:space="preserve"> + <value>{count, plural, other {アーカイブ済み#件、探査は継続中}}</value> + </data> + <data name="reference.title" xml:space="preserve"> + <value>リファレンス</value> + </data> + <data name="reference.lede" xml:space="preserve"> + <value>コードベースとは何か、クライアントは何をするか、プロトコルは何を意味するか。人の手で書き、クローラーと同じリポジトリに置いている — ウィキではなく、このページに編集できるものはない。ここにある{number}はどれも別物：カタログから取り、ページを読み込むたびに再計算している。</value> + </data> + <data name="reference.lede.number" xml:space="preserve"> + <value>数値</value> + </data> + <data name="reference.plain.lede" xml:space="preserve"> + <value>人の手で書き、著者は一人、gitでバージョン管理している。ここにある文章は当サイトのもの。その横にある数値はすべてクローラーが実測し、リクエストのたびに再計算している。ウィキではなく、このページから編集する方法もない。</value> + </data> + <data name="reference.section.orientation" xml:space="preserve"> + <value>はじめに</value> + </data> + <data name="reference.section.codebase" xml:space="preserve"> + <value>コードベース</value> + </data> + <data name="reference.section.client" xml:space="preserve"> + <value>クライアント</value> + </data> + <data name="reference.section.protocol" xml:space="preserve"> + <value>プロトコル</value> + </data> + <data name="reference.kind.orientation" xml:space="preserve"> + <value>入門</value> + </data> + <data name="reference.kind.codebase" xml:space="preserve"> + <value>コードベース</value> + </data> + <data name="reference.kind.client" xml:space="preserve"> + <value>クライアント</value> + </data> + <data name="reference.kind.protocol" xml:space="preserve"> + <value>プロトコル</value> + </data> + <data name="reference.notFound.title" xml:space="preserve"> + <value>見つからない</value> + </data> + <data name="reference.notFound.body" xml:space="preserve"> + <value>ここにリファレンスのページはない。この節は人の手で書いているので、空白は誰も手をつけていない仕事であって、削除されたものではない — {index}。</value> + </data> + <data name="reference.notFound.index" xml:space="preserve"> + <value>何があるかを見る</value> + </data> + <data name="reference.codebase.heading" xml:space="preserve"> + <value>これを動かしているゲーム</value> + </data> + <data name="reference.codebase.none" xml:space="preserve"> + <value>まだ一つも特定していない。これはこのクローラーが実測した内容についての事実であって、存在するものについてのものではない — 到達していないゲームや、コードベースを読み取れなかったゲームは、ここには数えていない。</value> + </data> + <data name="reference.codebase.listed" xml:space="preserve"> + <value>{count, plural, other {掲載#件}}</value> + </data> + <data name="reference.codebase.archived" xml:space="preserve"> + <value>{count, plural, other {アーカイブ済み#件}}</value> + </data> + <data name="reference.measuredNeverAsserted" xml:space="preserve"> + <value>実測であって、申告ではない</value> + </data> + <data name="reference.codebase.note" xml:space="preserve"> + <value>このリクエストの時点でカタログから数えたもので、上のリンクが持つのと同じフィルターによる — この数値とその一覧は一つのクエリであり、食い違うことはない。</value> + </data> + <data name="reference.codebase.offered" xml:space="preserve"> + <value>ハンドシェイクで提供していたもの：{protocols}</value> + </data> + <data name="reference.protocol.heading" xml:space="preserve"> + <value>実測した採用状況</value> + </data> + <data name="reference.protocol.none" xml:space="preserve"> + <value>まだ実測なし。</value> + </data> + <data name="reference.protocol.share" xml:space="preserve"> + <value>{listed, plural, other {掲載#件のゲーム}}のうち — {percent}</value> + </data> + <data name="reference.protocol.remainder" xml:space="preserve"> + <value>ここに数えていないゲームは、そのプロトコルを持たないゲームということではない。数えるのは、そのサーバーがハンドシェイクでそのオプションを提供するのを観測したとき。残りは、当サイトに提供しなかったサーバーと、ハンドシェイクをまだ読んでいないサーバーであり、どちらなのかは言えない。</value> + </data> + <data name="reference.protocol.caption" xml:space="preserve"> + <value>ハンドシェイクで{protocol}を提供するのを観測したゲームを、動かしていると特定したコードベース別に示したもの。</value> + </data> + <data name="reference.protocol.column.codebase" xml:space="preserve"> + <value>コードベース</value> + </data> + <data name="reference.protocol.column.offered" xml:space="preserve"> + <value>提供あり</value> + </data> + <data name="reference.protocol.column.identified" xml:space="preserve"> + <value>特定済み</value> + </data> + <data name="reference.seeAlso" xml:space="preserve"> + <value>関連項目</value> + </data> + <data name="reference.capabilities.heading" xml:space="preserve"> + <value>機能</value> + </data> + <data name="reference.capabilities.established" xml:space="preserve"> + <value>{count, plural, other {{total}件のうち#件はプロジェクト自身のドキュメントで確認}}</value> + </data> + <data name="reference.capabilities.caveat" xml:space="preserve"> + <value>各プロジェクト自身のドキュメントから読み取ったものであり、当サイトの実測ではない — クライアントには観測できるハンドシェイクがない。「{unknown}」は、調べたが確認できなかったという意味。「いいえ」の意味では決してない。</value> + </data> + <data name="reference.capabilities.caption" xml:space="preserve"> + <value>クライアントの機能。いずれも各プロジェクト自身のドキュメントから読み取ったもの。不明は確認できなかったという意味であって、そのクライアントに備わっていないという意味ではない。</value> + </data> + <data name="reference.capabilities.column.documented" xml:space="preserve"> + <value>文書化</value> + </data> + <data name="reference.capabilities.column.source" xml:space="preserve"> + <value>典拠</value> + </data> + <data name="reference.capabilities.noSource" xml:space="preserve"> + <value>見つけられなかった</value> + </data> + <data name="reference.capability.yes" xml:space="preserve"> + <value>はい</value> + </data> + <data name="reference.capability.no" xml:space="preserve"> + <value>いいえ</value> + </data> + <data name="reference.capability.unknown" xml:space="preserve"> + <value>不明</value> + </data> + <data name="reference.plain.runsOn" xml:space="preserve"> + <value>動作環境：{platforms}</value> + </data> + <data name="reference.plain.codebase.heading" xml:space="preserve"> + <value>このコードベースを動かしていると特定したゲーム</value> + </data> + <data name="reference.plain.codebase.none" xml:space="preserve"> + <value>まだない。これは当サイトが実測した内容についての言明であって、存在するものについてのものではない — 到達していないゲームや、コードベースを読み取れなかったゲームは、ここには数えていない。</value> + </data> + <data name="reference.plain.codebase.counts" xml:space="preserve"> + <value>{listed, plural, other {掲載#件}}、{archived, plural, other {アーカイブ済み#件}}</value> + </data> + <data name="reference.plain.codebase.offered" xml:space="preserve"> + <value>ハンドシェイクで実測：{protocols}</value> + </data> + <data name="reference.plain.codebase.nothingOffered" xml:space="preserve"> + <value>これまで読んだどのハンドシェイクでも、何も提供されなかった。</value> + </data> + <data name="reference.plain.protocol.share" xml:space="preserve"> + <value>{listed, plural, other {掲載#件のゲーム}}のうち{offering}件で提供を観測（{percent}）</value> + </data> + <data name="reference.plain.protocol.byCodebase" xml:space="preserve"> + <value>特定できたゲームの、コードベース別</value> + </data> + <data name="reference.plain.protocol.row" xml:space="preserve"> + <value>{identified}件のうち{offering}件が提供</value> + </data> + <data name="reference.plain.capabilities.unknown" xml:space="preserve"> + <value>{count, plural, other {{total}行のうち#行が不明}}：どちらとも述べたプロジェクト自身のドキュメントを見つけられなかった。短くて正直な表のほうが、長くて当て推量の表よりよい。</value> + </data> + <data name="account.title" xml:space="preserve"> + <value>自分のゲーム</value> + </data> + <data name="account.noDatabase" xml:space="preserve"> + <value>アカウントにはデータベースが必要だが、このサイトはデモ用のダミーデータで動いている。</value> + </data> + <data name="account.signInButton" xml:space="preserve"> + <value>サインイン</value> + </data> + <data name="account.signedInAs" xml:space="preserve"> + <value>{name}としてサインイン中。</value> + </data> + <data name="account.signOut" xml:space="preserve"> + <value>サインアウト</value> + </data> + <data name="account.empty.body" xml:space="preserve"> + <value>まだ何も申請していない。{listing}で自分のゲームを見つけ、そのページで{claimControl}を押す。</value> + </data> + <data name="account.empty.listing" xml:space="preserve"> + <value>一覧</value> + </data> + <data name="account.empty.claimControl" xml:space="preserve"> + <value>このゲームを申請する</value> + </data> + <data name="account.resigned.lead" xml:space="preserve"> + <value>手放した。</value> + </data> + <data name="account.resigned.body" xml:space="preserve"> + <value>その記録は残る。新しいトークンを公開すれば、いつでもまた管理していることを証明できる。</value> + </data> + <data name="account.saved.lead" xml:space="preserve"> + <value>保存した。</value> + </data> + <data name="account.saved.thatGame" xml:space="preserve"> + <value>そのゲーム</value> + </data> + <data name="account.saved.fields" xml:space="preserve"> + <value>{game}のページに、所有者申告として表示されるようになった。</value> + </data> + <data name="account.saved.screenHidden" xml:space="preserve"> + <value>{game}の接続画面の再公開をやめた。ページには穴を残さず、そのことを明記する。</value> + </data> + <data name="account.saved.screenShown" xml:space="preserve"> + <value>{game}の接続画面を、またそのページに表示している。</value> + </data> + <data name="account.saved.crawlStopped" xml:space="preserve"> + <value>把握しているすべてのアドレスで、{game}へのダイヤルをやめた。そのページには、要請より前に実測したものがすべて残る。</value> + </data> + <data name="account.saved.crawlResumed" xml:space="preserve"> + <value>スケジュールで次の順番が来たときから、{game}へのダイヤルを再開する。</value> + </data> + <data name="account.saved.unlisted" xml:space="preserve"> + <value>{game}は一覧、ランキング、日次の数値から外れた。そのページと、これまで持っていたすべてのURLは応答し続ける。</value> + </data> + <data name="account.saved.relisted" xml:space="preserve"> + <value>{game}は一覧に戻った。また実測されるのに要るのは、応答が返る探査1回だけ。</value> + </data> + <data name="account.refused.lead" xml:space="preserve"> + <value>{field}は変更していない。</value> + </data> + <data name="account.refused.tooLong" xml:space="preserve"> + <value>ここは1行で答える欄で、保存するのは最大{max}文字まで。</value> + </data> + <data name="account.refused.measured" xml:space="preserve"> + <value>その項目は実測。申請で足せるのはMSSPに収まらない内容であって、観測した内容は誰にも編集できない。当サイト自身にも。</value> + </data> + <data name="account.claimed.heading" xml:space="preserve"> + <value>申請済み</value> + </data> + <data name="account.claim.verified" xml:space="preserve"> + <value>{date}に検証</value> + </data> + <data name="account.claim.verifiedAndSeen" xml:space="preserve"> + <value>{date}に検証、トークンの最終確認{seen}</value> + </data> + <data name="account.claim.mssp" xml:space="preserve"> + <value>MSSPを確認する</value> + </data> + <data name="account.claim.coOwners" xml:space="preserve"> + <value>{count, plural, other {{names}も所有者 — それぞれ自分のトークンを検証している。}}</value> + </data> + <data name="account.coOwner.unnamed" xml:space="preserve"> + <value>別のアカウント</value> + </data> + <data name="account.badge.summary" xml:space="preserve"> + <value>自分のサイトに接続数を載せる</value> + </data> + <data name="account.badge.carries" xml:space="preserve"> + <value>バッジは接続数と、それを実測した時期を併せて示す。古さの分からない数値こそ、このサイトが置き換えるために存在するものだから。</value> + </data> + <data name="account.badge.states" xml:space="preserve"> + <value>数えられなかったときはゼロではなく{unknown}と表示し、ゲームが応答しなくなれば{archived}と表示する。</value> + </data> + <data name="account.badge.json" xml:space="preserve"> + <value>自分で描きたければ{json}もある。</value> + </data> + <data name="account.history.summary" xml:space="preserve"> + <value>履歴</value> + </data> + <data name="account.event.issued" xml:space="preserve"> + <value>トークン発行</value> + </data> + <data name="account.event.reissued" xml:space="preserve"> + <value>トークン再発行</value> + </data> + <data name="account.event.verified" xml:space="preserve"> + <value>検証 — トークンを読み取った</value> + </data> + <data name="account.event.beaconSeen" xml:space="preserve"> + <value>トークンは引き続き公開中</value> + </data> + <data name="account.event.beaconMissing" xml:space="preserve"> + <value>今回はトークンを読み取れず</value> + </data> + <data name="account.event.revoked" xml:space="preserve"> + <value>申請を手放した</value> + </data> + <data name="account.event.expired" xml:space="preserve"> + <value>トークンが未使用のまま期限切れ</value> + </data> + <data name="account.event.counterClaimed" xml:space="preserve"> + <value>別のアカウントが管理していることを証明し、ゲームを引き継いだ</value> + </data> + <data name="account.event.checkRequested" xml:space="preserve"> + <value>確認を要請</value> + </data> + <data name="account.resign.summary" xml:space="preserve"> + <value>この申請を手放す</value> + </data> + <data name="account.resign.confirm" xml:space="preserve"> + <value>確認のため{word}と入力する。何も削除されず、新しいトークンを公開すればまた管理していることを証明できる。他に所有者がいれば、ゲームは申請済みのまま。</value> + </data> + <data name="account.resign.button" xml:space="preserve"> + <value>{game}を手放す</value> + </data> + <data name="account.pending.heading" xml:space="preserve"> + <value>トークン待ち</value> + </data> + <data name="account.pending.dates" xml:space="preserve"> + <value>トークン発行{issued}、有効期限{expires}</value> + </data> + <data name="account.passkeys.heading" xml:space="preserve"> + <value>パスキー</value> + </data> + <data name="account.passkey.unnamed" xml:space="preserve"> + <value>名称なし</value> + </data> + <data name="account.passkey.added" xml:space="preserve"> + <value>追加{date}</value> + </data> + <data name="account.passkey.addedOneDevice" xml:space="preserve"> + <value>追加{date} · 端末1台のみ</value> + </data> + <data name="account.passkey.single" xml:space="preserve"> + <value>このパスキーは1台の端末にしかない。失くしても、ゲームに新しいトークンを公開すれば入り直せるが、2つ目のパスキーがあるほうが早い。</value> + </data> + <data name="account.passkey.add" xml:space="preserve"> + <value>パスキーをもう1つ追加</value> + </data> + <data name="claim.noGame" xml:space="preserve"> + <value>そのゲームはない</value> + </data> + <data name="claim.title" xml:space="preserve"> + <value>{game}を申請</value> + </data> + <data name="claim.noDatabase" xml:space="preserve"> + <value>申請にはデータベースが必要だが、このサイトはデモ用のダミーデータで動いている。</value> + </data> + <data name="claim.needAccount" xml:space="preserve"> + <value>先にアカウントが要る。要るのはパスキーと名前だけ。</value> + </data> + <data name="claim.signIn" xml:space="preserve"> + <value>サインイン、またはアカウントを作成</value> + </data> + <data name="claim.yourGames" xml:space="preserve"> + <value>自分のゲーム</value> + </data> + <data name="claim.hasOwners" xml:space="preserve"> + <value>{count, plural, other {このゲームには、サーバーを管理していることを証明した所有者がすでに#人いる。}}こちらも証明できる — 確かめ方はどちらでも同じ — が、それが何を意味するのかは伝えてもらう必要がある。トークンからは判別できないから。</value> + </data> + <data name="claim.join.button" xml:space="preserve"> + <value>こちらも運用している — 所有者に加えてほしい</value> + </data> + <data name="claim.join.note" xml:space="preserve"> + <value>全員が自分の申請を保つ。1つのゲームを2人で運用している状態。</value> + </data> + <data name="claim.assume.button" xml:space="preserve"> + <value>引き継いだ — こちらに移してほしい</value> + </data> + <data name="claim.assume.note" xml:space="preserve"> + <value>{count, plural, other {トークンが検証された時点で、既存の申請は取り消され、ゲームはこちらのものになる。}}相手には自分の履歴でその理由が見える。何も削除されず、相手はこれから行うのと同じ方法で、また管理していることを証明できる。</value> + </data> + <data name="claim.verified.lead" xml:space="preserve"> + <value>検証できた。</value> + </data> + <data name="claim.verified.viaMssp" xml:space="preserve"> + <value>{date}、そのゲームのMSSPレポートからトークンを読み取った。</value> + </data> + <data name="claim.verified.viaScreen" xml:space="preserve"> + <value>{date}、接続画面からトークンを読み取った。</value> + </data> + <data name="claim.verified.leaveIt" xml:space="preserve"> + <value>トークンはそのままにしておく。同一性の手がかりも兼ねるので、ホストを移しても名前を変えても、このゲームは見分けがつく。外しても申請が解けるわけではない。</value> + </data> + <data name="claim.publish" xml:space="preserve"> + <value>匿名の接続に見える場所であれば、どこにこのトークンを公開してもよい。次の探査がそれを拾い、それがそのサーバーに書き込めることの証明になる。</value> + </data> + <data name="claim.transfer.lead" xml:space="preserve"> + <value>これは移管。</value> + </data> + <data name="claim.transfer.body" xml:space="preserve"> + <value>{count, plural, other {このトークンを読み取った時点で、このゲームに対する現所有者の申請は取り消され、こちらのものになる。}}</value> + </data> + <data name="claim.either.heading" xml:space="preserve"> + <value>どちらか一方でよい</value> + </data> + <data name="claim.mssp.heading" xml:space="preserve"> + <value>MSSPの変数</value> + </data> + <data name="claim.mssp.note" xml:space="preserve"> + <value>{codebase}では{file}の1行。MSSPを持つコードベースには、どれも同じものがある。</value> + </data> + <data name="claim.mssp.aliases" xml:space="preserve"> + <value>{aliases}も受け付ける。</value> + </data> + <data name="claim.screen.heading" xml:space="preserve"> + <value>接続画面の1行</value> + </data> + <data name="claim.screen.note" xml:space="preserve"> + <value>画面内のどこでもよく、周りに色コードがあっても構わない。</value> + </data> + <data name="claim.then.heading" xml:space="preserve"> + <value>そのあと</value> + </data> + <data name="claim.then.body" xml:space="preserve"> + <value>確認は通常のクロールスケジュールで行う。このトークンの有効期限は{date}。いつ戻ってきてもよく、書き留めておくものは何もない。</value> + </data> + <data name="claim.check.button" xml:space="preserve"> + <value>早めに見に行く</value> + </data> + <data name="claim.check.can" xml:space="preserve"> + <value>自分のゲームを待ち行列の先頭に入れる。ダイヤルは当サイト自身のスケジュールで行うので、今すぐではなく、早まるだけ。</value> + </data> + <data name="claim.check.rationed" xml:space="preserve"> + <value>今要請したばかり。数分おいてからもう一度 — 本来より早く実際のサーバーにダイヤルすることになるので、回数を制限している。</value> + </data> + <data name="owner.declare.heading" xml:space="preserve"> + <value>{game}について、運用者にしか伝えられないこと</value> + </data> + <data name="owner.declare.lede" xml:space="preserve"> + <value>ここにあるのは、MSSPに対応する欄がないもの。自分のゲームのページには、最後に確認した日付を添えて{declared}として、実測した内容と並べて表示する — 実測に代えて表示することは決してない。実測したものは、ここからは誰にも編集できない。運用者にも当サイトにも。</value> + </data> + <data name="owner.field.declared" xml:space="preserve"> + <value>{age}に自己申告。取り下げるにはこの欄を空にする — どちらにせよ、何と書かれていたかの記録は残る。</value> + </data> + <data name="owner.save" xml:space="preserve"> + <value>自己申告した内容を保存</value> + </data> + <data name="owner.override.heading" xml:space="preserve"> + <value>{game}が報告している内容と、代わりに表示してほしい内容</value> + </data> + <data name="owner.override.lede" xml:space="preserve"> + <value>MSSPはどのクローラーも読むものであり、ここに入れた内容の横に、当サイトはそれを表示し続ける — 運用者の回答が、ゲーム自身の回答を隠すことはない。</value> + </data> + <data name="owner.override.nothingMeasured" xml:space="preserve"> + <value>実測したものは、ここからは何も編集できない：接続数も、機能も、到達可能だった1時間も。</value> + </data> + <data name="owner.override.fixItThere" xml:space="preserve"> + <value>下の行が{file}で誤っているなら、そこで直せばすべての場所で直る。</value> + </data> + <data name="owner.report.value" xml:space="preserve"> + <value>ゲームの報告は{value}、確認は{age}</value> + </data> + <data name="owner.report.none" xml:space="preserve"> + <value>ゲームはここで何も報告していない</value> + </data> + <data name="owner.rename.note" xml:space="preserve"> + <value>名前を変えると、{game}の掲載名と、そのページのアドレスが変わる。古いアドレスは永久に動き続け — このゲームがこれまで持っていたすべてのURLは現在のURLへ転送される — 欄を空にすれば、名前はMSSPの内容に戻る。</value> + </data> + <data name="owner.screen.heading" xml:space="preserve"> + <value>自分の接続画面</value> + </data> + <data name="owner.screen.suppressed" xml:space="preserve"> + <value>再公開はしていない。ページには穴を残さず、そのことを明記しており、クローラーは読み続けている — ゲームが移ったときに見分ける手がかりがそれだから。</value> + </data> + <data name="owner.screen.show" xml:space="preserve"> + <value>また表示する</value> + </data> + <data name="owner.screen.shown" xml:space="preserve"> + <value>表示しているのは、サーバーがそれをすべての匿名接続に送っているから。表示してほしくなければ、そう言えばやめる。理由は訊かない。</value> + </data> + <data name="owner.screen.stop" xml:space="preserve"> + <value>接続画面の表示をやめてほしい</value> + </data> + <data name="owner.crawl.heading" xml:space="preserve"> + <value>クロールされること</value> + </data> + <data name="owner.crawl.stopped" xml:space="preserve"> + <value>停止した。{game}へは一切ダイヤルしておらず、ページには要請より前に実測したものがすべて残る — 空いた時間は原因を名指ししない。{ourFact}というのは当サイトについての事実であって、そのゲームについての実測ではないから。</value> + </data> + <data name="owner.crawl.ourFact" xml:space="preserve"> + <value>停止を要請された</value> + </data> + <data name="owner.crawl.resume" xml:space="preserve"> + <value>またクロールしてほしい</value> + </data> + <data name="owner.crawl.standing" xml:space="preserve"> + <value>これはここからではなく、サーバー自身から来たもの — {routes}。またクロールされるには、その公開をやめる。次のサイクルでそれを受け取る。</value> + </data> + <data name="owner.crawl.route.mssp" xml:space="preserve"> + <value>MSSPレポートが{variable}を公開している</value> + </data> + <data name="owner.crawl.route.dns" xml:space="preserve"> + <value>{label}のTXTレコードが停止を求めている</value> + </data> + <data name="owner.crawl.route.recorded" xml:space="preserve"> + <value>記録済みの要請</value> + </data> + <data name="owner.crawl.partial" xml:space="preserve"> + <value>{stopped}では停止し、{dialling}には引き続きダイヤルしている。たいていは離脱のあとに追加されたポート。</value> + </data> + <data name="owner.crawl.stopAll" xml:space="preserve"> + <value>すべてのアドレスでも停止してほしい</value> + </data> + <data name="owner.crawl.dialling" xml:space="preserve"> + <value>{game}へは一定のスケジュールでダイヤルし、匿名の接続に見えるものを読んでいる。やめてほしければ、そう言えばやめる — 1回のサイクル以内に、把握しているすべてのアドレスで。理由は訊かない。</value> + </data> + <data name="owner.crawl.selfService" xml:space="preserve"> + <value>すでに実測したものは何も削除されない：ページは履歴とURLを保ち、これを撤回したあとの探査1回で再開する。当サイトを通さず、自分の設定で伝えることもできる — MSSPの{mssp}か、{dns}のTXTレコード — このゲームをここで誰かが申請しているかどうかにかかわらず、それに従う。</value> + </data> + <data name="owner.crawl.stop" xml:space="preserve"> + <value>クロールをやめてほしい</value> + </data> + <data name="owner.listing.heading" xml:space="preserve"> + <value>掲載されること</value> + </data> + <data name="owner.listing.unlisted" xml:space="preserve"> + <value>{game}は一覧からも、ランキングからも、日次の数値からも外れている。ページと、これまで持っていたすべてのURLは応答し続け、要請より前に実測したものはすべてそこに残っている。何も削除していない。閲覧してたどり着ける場所ではなくなるだけ。</value> + </data> + <data name="owner.listing.relist" xml:space="preserve"> + <value>一覧に戻してほしい</value> + </data> + <data name="owner.listing.probeRelists" xml:space="preserve"> + <value>応答が返る探査1回でも同じことが起きる。離脱が有効な間はダイヤルしないので、そうなることはない — ただし撤回した日から1週間以内にそのアドレスの順番が来て、応答が返った探査が一覧に戻す。二度頼む必要はない。</value> + </data> + <data name="owner.listing.mayUnlist" xml:space="preserve"> + <value>ダイヤルは停止しており、ページはそれ以前に実測した内容とともに一覧に残っている。残したくなければ、そう言えば外す — 一覧からも、ランキングからも、日次の数値からも。</value> + </data> + <data name="owner.listing.reversible" xml:space="preserve"> + <value>何も削除されず、何も壊れない：ページは応答し、これまで持っていたすべてのURLは今もそこへ転送され、案内した相手には見える。閲覧してたどり着ける場所ではなくなるだけ。ここから元に戻せるし、離脱を撤回したあとに応答が返った探査でも元に戻る。</value> + </data> + <data name="owner.listing.unlist" xml:space="preserve"> + <value>一覧からも外してほしい</value> + </data> + <data name="facet.group.measure" xml:space="preserve"> + <value>実測できたもの</value> + </data> + <data name="facet.measure.note" xml:space="preserve"> + <value>非表示にすると一覧から外れる — そのゲームが無人だという意味ではない。</value> + </data> + <data name="facet.group.uncounted" xml:space="preserve"> + <value>接続数読み取り不可</value> + </data> + <data name="facet.group.unreachable" xml:space="preserve"> + <value>到達不可</value> + </data> + <data name="facet.excluded.uncounted" xml:space="preserve"> + <value>この一覧では非表示</value> + </data> + <data name="facet.excluded.unreachable" xml:space="preserve"> + <value>この一覧では非表示</value> + </data> + <data name="facet.plain.marks" xml:space="preserve"> + <value>左の列で、* はこの一覧が絞り込みに使っている値、- は除外に使っている値。どちらもクエリでの選択であって、ゲームについての事実ではない。</value> + </data> +</root> diff --git a/src/MUI.Web/Resources/Messages.nl.resx b/src/MUI.Web/Resources/Messages.nl.resx new file mode 100644 index 0000000..56549b8 --- /dev/null +++ b/src/MUI.Web/Resources/Messages.nl.resx @@ -0,0 +1,2877 @@ +<?xml version="1.0" encoding="utf-8"?> +<root> + <!-- + Nederlands, machine-translated and not reviewed by a person. + + Every page served in this locale carries the ◆ notice saying so, and the locale is reachable but + never offered: nothing sends a reader here. Promotion to LocaleStatus.Shipped is a person reading + the locked strings against Glossary.cs, not an edit to a status enum. + + The values are ICU MessageFormat. Argument names in braces are code. + --> + <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata"> + <xsd:import namespace="http://www.w3.org/XML/1998/namespace" /> + <xsd:element name="root" msdata:IsDataSet="true"> + <xsd:complexType> + <xsd:choice maxOccurs="unbounded"> + <xsd:element name="data"> + <xsd:complexType> + <xsd:sequence> + <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" /> + <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" /> + </xsd:sequence> + <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" /> + <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" /> + <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" /> + <xsd:attribute ref="xml:space" /> + </xsd:complexType> + </xsd:element> + <xsd:element name="resheader"> + <xsd:complexType> + <xsd:sequence> + <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" /> + </xsd:sequence> + <xsd:attribute name="name" type="xsd:string" use="required" /> + </xsd:complexType> + </xsd:element> + </xsd:choice> + </xsd:complexType> + </xsd:element> + </xsd:schema> + <resheader name="resmimetype"><value>text/microsoft-resx</value></resheader> + <resheader name="version"><value>2.0</value></resheader> + <resheader name="reader"><value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader> + <resheader name="writer"><value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader> + <data name="facet.count" xml:space="preserve"> + <value>{count, plural, one {# spel} other {# spellen}}</value> + </data> + <data name="facet.value.include" xml:space="preserve"> + <value>{value}, {count, plural, one {# spel} other {# spellen}}, alleen</value> + </data> + <data name="facet.value.exclude" xml:space="preserve"> + <value>{value}, {count, plural, one {# spel} other {# spellen}}, uitgesloten</value> + </data> + <data name="facet.value.choose" xml:space="preserve"> + <value>{value}, {count, plural, one {# spel} other {# spellen}}</value> + </data> + <data name="facet.any" xml:space="preserve"> + <value>ongeacht {facet}, {count, plural, one {# spel} other {# spellen}}</value> + </data> + <data name="listing.total" xml:space="preserve"> + <value>{count, plural, =0 {Hier staan geen spellen.} one {# spel, waarvan elk feit vermeldt hoe het verkregen is.} other {# spellen, waarvan elk feit vermeldt hoe het verkregen is.}}</value> + </data> + <data name="chart.basis" xml:space="preserve"> + <value>{days, plural, one {# dag} other {# dagen}} gemeten · {probes, plural, one {# peiling} other {# peilingen}}</value> + </data> + <data name="window.samples" xml:space="preserve"> + <value>{days, plural, one {#d} other {#d}} · {count, plural, one {# telling} other {# tellingen}}</value> + </data> + <data name="capabilities.agree" xml:space="preserve"> + <value>{disagreeing, plural, =0 {Geen van de {total} wijkt af.} one {# van de {total} wijkt af van wat het spel opgeeft.} other {# van de {total} wijken af van wat het spel opgeeft.}}</value> + </data> + <data name="find.matching" xml:space="preserve"> + <value>{count, plural, =0 {Geen spel past bij elk antwoord.} one {# spel past bij elk antwoord.} other {# spellen passen bij elk antwoord.}}</value> + </data> + <data name="find.basis" xml:space="preserve"> + <value>van {listed, plural, one {# vermeld spel} other {# vermelde spellen}} · {answers, plural, =0 {geen antwoorden gegeven} one {# antwoord gegeven} other {# antwoorden gegeven}}</value> + </data> + <data name="find.show" xml:space="preserve"> + <value>{count, plural, one {Toon het ene spel} other {Toon deze # spellen}}</value> + </data> + <data name="find.drop" xml:space="preserve"> + <value>"{answer}" laten vallen — {count, plural, one {# spel} other {# spellen}}</value> + </data> + <data name="find.clear" xml:space="preserve"> + <value>antwoord wissen op: {question}</value> + </data> + <data name="find.title" xml:space="preserve"> + <value>Een spel zoeken</value> + </data> + <data name="find.kicker" xml:space="preserve"> + <value>passend bij alle antwoorden</value> + </data> + <data name="find.noun" xml:space="preserve"> + <value>{count, plural, one {spel} other {spellen}}</value> + </data> + <data name="find.clearAll" xml:space="preserve"> + <value>alle antwoorden wissen</value> + </data> + <data name="find.startAgain" xml:space="preserve"> + <value>opnieuw beginnen</value> + </data> + <data name="find.more" xml:space="preserve"> + <value>{count, plural, one {# meer} other {# meer}}</value> + </data> + <data name="find.answersGiven" xml:space="preserve"> + <value>gegeven antwoorden</value> + </data> + <data name="find.wholeListing" xml:space="preserve"> + <value>de hele lijst</value> + </data> + <data name="find.refused" xml:space="preserve"> + <value>die zoekopdracht is geweigerd</value> + </data> + <data name="find.name.label" xml:space="preserve"> + <value>een naam, als je er een hebt</value> + </data> + <data name="find.name.placeholder" xml:space="preserve"> + <value>naam, of een deel ervan</value> + </data> + <data name="find.name.submit" xml:space="preserve"> + <value>Zoeken op naam</value> + </data> + <data name="find.q.band" xml:space="preserve"> + <value>Speelt er nu iemand?</value> + </data> + <data name="find.q.genre" xml:space="preserve"> + <value>Wat wil je spelen?</value> + </data> + <data name="find.q.lineage" xml:space="preserve"> + <value>Wat voor spel?</value> + </data> + <data name="find.q.language" xml:space="preserve"> + <value>In welke taal?</value> + </data> + <data name="find.q.client" xml:space="preserve"> + <value>Heeft je client iets nodig?</value> + </data> + <data name="find.q.dark" xml:space="preserve"> + <value>Ook stilgevallen spellen meenemen?</value> + </data> + <data name="find.any.band" xml:space="preserve"> + <value>maakt niet uit</value> + </data> + <data name="find.any.genre" xml:space="preserve"> + <value>elk genre</value> + </data> + <data name="find.any.lineage" xml:space="preserve"> + <value>elke soort</value> + </data> + <data name="find.any.language" xml:space="preserve"> + <value>elke taal</value> + </data> + <data name="find.any.client" xml:space="preserve"> + <value>maakt niet uit</value> + </data> + <data name="find.dark.no" xml:space="preserve"> + <value>nee, alleen live spellen</value> + </data> + <data name="find.dark.yes" xml:space="preserve"> + <value>ja, toon die ook</value> + </data> + <data name="find.dark.chip" xml:space="preserve"> + <value>stilgevallen spellen</value> + </data> + <data name="find.protocol.tls" xml:space="preserve"> + <value>TLS — versleuteld, handshake door ons voltooid</value> + </data> + <data name="find.protocol.mssp" xml:space="preserve"> + <value>MSSP — zelfbeschrijving van de server</value> + </data> + <data name="find.protocol.mccp" xml:space="preserve"> + <value>MCCP — gecomprimeerde uitvoer</value> + </data> + <data name="find.protocol.mxp" xml:space="preserve"> + <value>MXP — klikbare links</value> + </data> + <data name="find.protocol.gmcp" xml:space="preserve"> + <value>GMCP — gestructureerde clientgegevens</value> + </data> + <data name="find.protocol.msdp" xml:space="preserve"> + <value>MSDP — gestructureerde clientgegevens</value> + </data> + <data name="find.protocol.charset" xml:space="preserve"> + <value>CHARSET — onderhandeling over codering</value> + </data> + <data name="find.protocol.utf8" xml:space="preserve"> + <value>UTF-8 — niet-Latijnse tekst wordt weergegeven</value> + </data> + <data name="find.protocol.ttype" xml:space="preserve"> + <value>TTYPE — client meldt zijn type</value> + </data> + <data name="find.protocol.atcp" xml:space="preserve"> + <value>ATCP — gestructureerde clientgegevens</value> + </data> + <data name="find.protocol.msp" xml:space="preserve"> + <value>MSP — geluidstriggers</value> + </data> + <data name="find.protocol.eor" xml:space="preserve"> + <value>EOR — promptmarkering</value> + </data> + <data name="find.protocol.other" xml:space="preserve"> + <value>{token} — gemeten in de handshake</value> + </data> + <data name="provenance.count.measured" xml:space="preserve"> + <value>gemeten</value> + </data> + <data name="provenance.game.measured" xml:space="preserve"> + <value>gemeten</value> + </data> + <data name="provenance.capability.measured" xml:space="preserve"> + <value>gemeten</value> + </data> + <data name="provenance.screen.measured" xml:space="preserve"> + <value>gemeten</value> + </data> + <data name="kicker.measured" xml:space="preserve"> + <value>gemeten</value> + </data> + <data name="provenance.count.declared" xml:space="preserve"> + <value>opgegeven</value> + </data> + <data name="provenance.game.declared" xml:space="preserve"> + <value>opgegeven</value> + </data> + <data name="provenance.capability.declared" xml:space="preserve"> + <value>opgegeven</value> + </data> + <data name="kicker.declared" xml:space="preserve"> + <value>opgegeven</value> + </data> + <data name="provenance.derived" xml:space="preserve"> + <value>afgeleid</value> + </data> + <data name="kicker.derived" xml:space="preserve"> + <value>afgeleid</value> + </data> + <data name="state.notMeasured" xml:space="preserve"> + <value>niet gemeten</value> + </data> + <data name="state.uncounted" xml:space="preserve"> + <value>ongeteld</value> + </data> + <data name="state.unreachable" xml:space="preserve"> + <value>onbereikbaar</value> + </data> + <data name="state.notCounted" xml:space="preserve"> + <value>niet geteld</value> + </data> + <data name="listing.count.none" xml:space="preserve"> + <value>geen telling</value> + </data> + <data name="listing.plain.fromHere" xml:space="preserve"> + <value>van hieruit</value> + </data> + <data name="listing.plain.archived" xml:space="preserve"> + <value>gearchiveerd</value> + </data> + <data name="listing.plain.claimed" xml:space="preserve"> + <value>geclaimd</value> + </data> + <data name="random.empty.title" xml:space="preserve"> + <value>Niets om uit te kiezen</value> + </data> + <data name="random.empty.body" xml:space="preserve"> + <value>Geen spel past bij dat filter. Probeer {listing}, of {archive}.</value> + </data> + <data name="random.empty.listing" xml:space="preserve"> + <value>de hele lijst</value> + </data> + <data name="random.empty.archive" xml:space="preserve"> + <value>het archief meenemen</value> + </data> + <data name="term.connected" xml:space="preserve"> + <value>verbonden</value> + </data> + <data name="term.unclaimed" xml:space="preserve"> + <value>niet geclaimd</value> + </data> + <data name="term.claimedByOwner" xml:space="preserve"> + <value>geclaimd door de eigenaar</value> + </data> + <data name="term.stillProbed" xml:space="preserve"> + <value>wordt nog gepeild</value> + </data> + <data name="term.typical" xml:space="preserve"> + <value>typisch</value> + </data> + <data name="term.peak" xml:space="preserve"> + <value>piek</value> + </data> + <data name="a11y.readAsText" xml:space="preserve"> + <value>als tekst lezen</value> + </data> + <data name="a11y.plainText" xml:space="preserve"> + <value>platte tekst</value> + </data> + <data name="a11y.skipToContent" xml:space="preserve"> + <value>naar de inhoud</value> + </data> + <data name="a11y.asciiBanner" xml:space="preserve"> + <value>ASCII-banner: het verbindingsscherm van {game}.</value> + </data> + <data name="nav.catalogues" xml:space="preserve"> + <value>Catalogi</value> + </data> + <data name="nav.account" xml:space="preserve"> + <value>Deze site en je account</value> + </data> + <data name="nav.browse" xml:space="preserve"> + <value>bladeren</value> + </data> + <data name="nav.learn" xml:space="preserve"> + <value>uitleg</value> + </data> + <data name="nav.thisSite" xml:space="preserve"> + <value>deze site</value> + </data> + <data name="nav.menu" xml:space="preserve"> + <value>menu</value> + </data> + <data name="nav.games" xml:space="preserve"> + <value>spellen</value> + </data> + <data name="nav.find" xml:space="preserve"> + <value>zoeken</value> + </data> + <data name="nav.random" xml:space="preserve"> + <value>willekeurig</value> + </data> + <data name="nav.archive" xml:space="preserve"> + <value>archief</value> + </data> + <data name="nav.reference" xml:space="preserve"> + <value>naslag</value> + </data> + <data name="nav.ecosystem" xml:space="preserve"> + <value>ecosysteem</value> + </data> + <data name="nav.rankings" xml:space="preserve"> + <value>ranglijsten</value> + </data> + <data name="nav.about" xml:space="preserve"> + <value>over</value> + </data> + <data name="nav.submit" xml:space="preserve"> + <value>aanmelden</value> + </data> + <data name="nav.submitGame" xml:space="preserve"> + <value>een spel aanmelden</value> + </data> + <data name="nav.signIn" xml:space="preserve"> + <value>inloggen</value> + </data> + <data name="nav.yourGames" xml:space="preserve"> + <value>je spellen</value> + </data> + <data name="theme.label" xml:space="preserve"> + <value>thema</value> + </data> + <data name="theme.auto" xml:space="preserve"> + <value>automatisch</value> + </data> + <data name="theme.light" xml:space="preserve"> + <value>licht</value> + </data> + <data name="theme.dark" xml:space="preserve"> + <value>donker</value> + </data> + <data name="banner.demo.lead" xml:space="preserve"> + <value>Demogegevens.</value> + </data> + <data name="banner.demo" xml:space="preserve"> + <value>Er is geen database geconfigureerd, dus dit zijn testgegevens. Niets hiervan is gemeten.</value> + </data> + <data name="footer.allGames" xml:space="preserve"> + <value>alle spellen</value> + </data> + <data name="footer.archive" xml:space="preserve"> + <value>archief</value> + </data> + <data name="footer.declaredByGame" xml:space="preserve"> + <value>opgegeven door het spel</value> + </data> + <data name="footer.whatChanged" xml:space="preserve"> + <value>wat er veranderd is</value> + </data> + <data name="home.title" xml:space="preserve"> + <value>Een gids voor de MU*-hobby</value> + </data> + <data name="home.lede" xml:space="preserve"> + <value>Elk feit vermeldt hoe het verkregen is en hoe oud het is: gemeten door onze crawler, of opgegeven door het spel en als zodanig gemarkeerd.</value> + </data> + <data name="home.search.label" xml:space="preserve"> + <value>Spellen zoeken op naam, thema, codebase of host</value> + </data> + <data name="home.search.placeholder" xml:space="preserve"> + <value>zoeken op naam, thema, codebase of host</value> + </data> + <data name="home.search.submit" xml:space="preserve"> + <value>zoeken</value> + </data> + <data name="tile.gamesKnown" xml:space="preserve"> + <value>bekende spellen</value> + </data> + <data name="tile.connectedNow" xml:space="preserve"> + <value>nu verbonden</value> + </data> + <data name="tile.answeringUncounted" xml:space="preserve"> + <value>antwoordt, ongeteld</value> + </data> + <data name="tile.archived" xml:space="preserve"> + <value>gearchiveerd</value> + </data> + <data name="feed.newlyDiscovered" xml:space="preserve"> + <value>nieuw ontdekt</value> + </data> + <data name="feed.wentDark" xml:space="preserve"> + <value>stilgevallen — wordt nog gepeild</value> + </data> + <data name="feed.cameBack" xml:space="preserve"> + <value>weer terug</value> + </data> + <data name="feed.nothingNew" xml:space="preserve"> + <value>Niets nieuws.</value> + </data> + <data name="feed.nothingDark" xml:space="preserve"> + <value>Er is niets stilgevallen.</value> + </data> + <data name="feed.nothingBack" xml:space="preserve"> + <value>Er is niets teruggekomen. We blijven kloppen.</value> + </data> + <data name="feed.live" xml:space="preserve"> + <value>live</value> + </data> + <data name="games.title" xml:space="preserve"> + <value>Spellen</value> + </data> + <data name="listing.sortedBy" xml:space="preserve"> + <value>gesorteerd op {order}</value> + </data> + <data name="listing.random" xml:space="preserve"> + <value>willekeurig</value> + </data> + <data name="listing.columns" xml:space="preserve"> + <value>verbonden · bereikt</value> + </data> + <data name="listing.fromHere" xml:space="preserve"> + <value>van hieruit</value> + </data> + <data name="listing.empty.head" xml:space="preserve"> + <value>Geen treffers.</value> + </data> + <data name="listing.empty.hint" xml:space="preserve"> + <value>Probeer minder woorden, of laat een filter vallen.</value> + </data> + <data name="listing.clearFilters" xml:space="preserve"> + <value>filters wissen</value> + </data> + <data name="listing.aboutCodebase" xml:space="preserve"> + <value>over {codebase}</value> + </data> + <data name="listing.never" xml:space="preserve"> + <value>nooit</value> + </data> + <data name="listing.claimed" xml:space="preserve"> + <value>geclaimd door de eigenaar</value> + </data> + <data name="listing.unknownCodebase" xml:space="preserve"> + <value>Onbekende codebase</value> + </data> + <data name="listing.unknownCodebase.title" xml:space="preserve"> + <value>we konden niet vaststellen op welke codebase dit spel draait</value> + </data> + <data name="listing.moreProtocols" xml:space="preserve"> + <value>en {count, plural, one {# meer} other {# meer}}: {names}</value> + </data> + <data name="switch.order" xml:space="preserve"> + <value>Volgorde</value> + </data> + <data name="switch.window" xml:space="preserve"> + <value>Periode</value> + </data> + <data name="switch.now" xml:space="preserve"> + <value>nu</value> + </data> + <data name="switch.typical" xml:space="preserve"> + <value>typisch</value> + </data> + <data name="switch.peak" xml:space="preserve"> + <value>piek</value> + </data> + <data name="switch.name" xml:space="preserve"> + <value>naam</value> + </data> + <data name="switch.reached" xml:space="preserve"> + <value>bereikt</value> + </data> + <data name="window.7" xml:space="preserve"> + <value>7 dagen</value> + </data> + <data name="window.30" xml:space="preserve"> + <value>30 dagen</value> + </data> + <data name="window.90" xml:space="preserve"> + <value>90 dagen</value> + </data> + <data name="filters.search.label" xml:space="preserve"> + <value>Spellen zoeken</value> + </data> + <data name="filters.search.placeholder" xml:space="preserve"> + <value>spellen zoeken</value> + </data> + <data name="filters.summary" xml:space="preserve"> + <value>filters</value> + </data> + <data name="filters.showing" xml:space="preserve"> + <value>getoond</value> + </data> + <data name="filters.clearAll" xml:space="preserve"> + <value>alles wissen</value> + </data> + <data name="filters.stopFiltering" xml:space="preserve"> + <value>— hier niet meer op filteren</value> + </data> + <data name="facet.anyValue" xml:space="preserve"> + <value>alle</value> + </data> + <data name="facet.more" xml:space="preserve"> + <value>meer filters ({count})</value> + </data> + <data name="facet.moreValues" xml:space="preserve"> + <value>{count, plural, one {# meer} other {# meer}}</value> + </data> + <data name="facet.alsoShow" xml:space="preserve"> + <value>ook tonen</value> + </data> + <data name="facet.alsoShow.note" xml:space="preserve"> + <value>Standaard uit. Geen van beide is een oordeel over het spel.</value> + </data> + <data name="facet.archived" xml:space="preserve"> + <value>gearchiveerd</value> + </data> + <data name="facet.adult" xml:space="preserve"> + <value>voor volwassenen</value> + </data> + <data name="facet.archived.state" xml:space="preserve"> + <value>gearchiveerde spellen, {shown, select, true {getoond} other {verborgen}}</value> + </data> + <data name="facet.adult.state" xml:space="preserve"> + <value>spellen die inhoud voor volwassenen opgeven, {shown, select, true {getoond} other {verborgen}}</value> + </data> + <data name="facet.countsNote" xml:space="preserve"> + <value>Aantallen zijn spellen die we gemeten hebben, nooit schattingen.</value> + </data> + <data name="facet.key.summary" xml:space="preserve"> + <value>wat de badges en de lege plekken betekenen</value> + </data> + <data name="facet.key.blank" xml:space="preserve"> + <value>Een lege plek is een gat in onze meting, geen nee. Elk facet zegt het op zijn eigen manier: niet vastgesteld, niet opgegeven, niets onderhandeld.</value> + </data> + <data name="facet.key.zero" xml:space="preserve"> + <value>Een gemeten nul is een telling. Een onbekende telling is geen nul en wordt ook nooit als nul gesorteerd.</value> + </data> + <data name="facet.key.openEnded" xml:space="preserve"> + <value>Open facetten tonen hun {count} meest voorkomende waarden. De rest is bereikbaar via zoeken en via URL.</value> + </data> + <data name="facet.presence.note" xml:space="preserve"> + <value>Niet aangevinkt betekent niet gemeten — niet dat het spel het mist.</value> + </data> + <data name="facet.group.band" xml:space="preserve"> + <value>activiteit</value> + </data> + <data name="facet.group.seen" xml:space="preserve"> + <value>laatst gezien</value> + </data> + <data name="facet.group.protocol" xml:space="preserve"> + <value>aangeboden protocollen</value> + </data> + <data name="facet.group.tls" xml:space="preserve"> + <value>versleuteld</value> + </data> + <data name="facet.group.charset" xml:space="preserve"> + <value>codering</value> + </data> + <data name="facet.group.codebase" xml:space="preserve"> + <value>codebase</value> + </data> + <data name="facet.group.version" xml:space="preserve"> + <value>versie</value> + </data> + <data name="facet.group.lineage" xml:space="preserve"> + <value>afstamming</value> + </data> + <data name="facet.group.family" xml:space="preserve"> + <value>familie</value> + </data> + <data name="facet.group.genre" xml:space="preserve"> + <value>genre</value> + </data> + <data name="facet.group.language" xml:space="preserve"> + <value>taal</value> + </data> + <data name="facet.band.playersNow" xml:space="preserve"> + <value>nu verbonden</value> + </data> + <data name="facet.band.activeThisWeek" xml:space="preserve"> + <value>actief deze week</value> + </data> + <data name="facet.band.quiet" xml:space="preserve"> + <value>rustig — nooit boven 0 geteld</value> + </data> + <data name="facet.band.dark" xml:space="preserve"> + <value>stil — een maand niet bereikt</value> + </data> + <data name="facet.band.archived" xml:space="preserve"> + <value>gearchiveerd</value> + </data> + <data name="facet.seen.day" xml:space="preserve"> + <value>in de laatste 24 uur</value> + </data> + <data name="facet.seen.week" xml:space="preserve"> + <value>in de laatste 7 dagen</value> + </data> + <data name="facet.seen.month" xml:space="preserve"> + <value>in de laatste 30 dagen</value> + </data> + <data name="facet.seen.older" xml:space="preserve"> + <value>langer geleden</value> + </data> + <data name="facet.seen.never" xml:space="preserve"> + <value>nooit bereikt</value> + </data> + <data name="facet.unknown.charset" xml:space="preserve"> + <value>niets onderhandeld</value> + </data> + <data name="facet.unknown.codebase" xml:space="preserve"> + <value>niet vastgesteld</value> + </data> + <data name="facet.unknown.other" xml:space="preserve"> + <value>niet opgegeven</value> + </data> + <data name="facet.tls.yes" xml:space="preserve"> + <value>verbonden via TLS</value> + </data> + <data name="facet.excluded" xml:space="preserve"> + <value>niet {value}</value> + </data> + <data name="facet.known.charset" xml:space="preserve"> + <value>iets onderhandeld</value> + </data> + <data name="facet.known.codebase" xml:space="preserve"> + <value>wel vastgesteld</value> + </data> + <data name="facet.known.other" xml:space="preserve"> + <value>wel opgegeven</value> + </data> + <data name="evidence.measured.meaning" xml:space="preserve"> + <value>we hebben dit zien gebeuren</value> + </data> + <data name="evidence.declared.meaning" xml:space="preserve"> + <value>het spel zegt het, en wij hebben het niet gecontroleerd</value> + </data> + <data name="evidence.derived.meaning" xml:space="preserve"> + <value>we hebben gegroepeerd wat het spel ons vertelde</value> + </data> + <data name="sort.name" xml:space="preserve"> + <value>naam</value> + </data> + <data name="sort.players" xml:space="preserve"> + <value>nu verbonden</value> + </data> + <data name="sort.reached" xml:space="preserve"> + <value>laatst bereikt</value> + </data> + <data name="sort.medianWeek" xml:space="preserve"> + <value>typisch verbonden · 7 dagen</value> + </data> + <data name="sort.medianMonth" xml:space="preserve"> + <value>typisch verbonden · 30 dagen</value> + </data> + <data name="sort.medianQuarter" xml:space="preserve"> + <value>typisch verbonden · 90 dagen</value> + </data> + <data name="sort.peakWeek" xml:space="preserve"> + <value>meeste tegelijk verbonden · 7 dagen</value> + </data> + <data name="sort.peakMonth" xml:space="preserve"> + <value>meeste tegelijk verbonden · 30 dagen</value> + </data> + <data name="sort.peakQuarter" xml:space="preserve"> + <value>meeste tegelijk verbonden · 90 dagen</value> + </data> + <data name="sort.group.row" xml:space="preserve"> + <value>nu op de rij</value> + </data> + <data name="sort.group.typical" xml:space="preserve"> + <value>typisch</value> + </data> + <data name="sort.group.peak" xml:space="preserve"> + <value>piek</value> + </data> + <data name="sort.unranked.players" xml:space="preserve"> + <value>Onbekende telling</value> + </data> + <data name="sort.unranked.reached" xml:space="preserve"> + <value>nog nooit bereikt — niet dat het lang geleden bereikt is</value> + </data> + <data name="sort.unranked.median" xml:space="preserve"> + <value>minder dan {minimum} tellingen in de periode, of helemaal geen — geen typische telling van nul</value> + </data> + <data name="sort.unranked.window" xml:space="preserve"> + <value>niets dat we in de periode konden tellen — niet dat er niemand verbonden was</value> + </data> + <data name="sort.window.median" xml:space="preserve"> + <value>mediaan {value} · {days, plural, one {#d} other {#d}} · {count, plural, one {# telling} other {# tellingen}}</value> + </data> + <data name="sort.window.peak" xml:space="preserve"> + <value>meeste {value} tegelijk · {days, plural, one {#d} other {#d}} · {count, plural, one {# telling} other {# tellingen}}</value> + </data> + <data name="game.connectScreen" xml:space="preserve"> + <value>Verbindingsscherm</value> + </data> + <data name="game.connectionsByHour" xml:space="preserve"> + <value>Verbindingen per uur</value> + </data> + <data name="game.howMany" xml:space="preserve"> + <value>Hoeveel, in de loop van de tijd</value> + </data> + <data name="game.reachable" xml:space="preserve"> + <value>Bereikbaar</value> + </data> + <data name="game.whatChanged" xml:space="preserve"> + <value>Wat er veranderd is</value> + </data> + <data name="game.capabilities" xml:space="preserve"> + <value>Mogelijkheden</value> + </data> + <data name="game.declaredByGame" xml:space="preserve"> + <value>Opgegeven door het spel</value> + </data> + <data name="game.referrals" xml:space="preserve"> + <value>Verwijzingen</value> + </data> + <data name="game.unclaimed" xml:space="preserve"> + <value>Niet geclaimd — alles hier is gemeten.</value> + </data> + <data name="game.claimed" xml:space="preserve"> + <value>Geclaimd door de eigenaar — de gemeten feiten hieronder blijven van ons.</value> + </data> + <data name="game.claim" xml:space="preserve"> + <value>Dit spel claimen</value> + </data> + <data name="game.answeringSince" xml:space="preserve"> + <value>antwoordt sinds {date}</value> + </data> + <data name="game.readAsTextRows" xml:space="preserve"> + <value>als tekst lezen — {count, plural, one {# rij} other {# rijen}}</value> + </data> + <data name="capability.column" xml:space="preserve"> + <value>mogelijkheid</value> + </data> + <data name="capability.age" xml:space="preserve"> + <value>leeftijd</value> + </data> + <data name="capability.offered" xml:space="preserve"> + <value>aangeboden</value> + </data> + <data name="capability.silent" xml:space="preserve"> + <value>stil</value> + </data> + <data name="capability.absent" xml:space="preserve"> + <value>afwezig</value> + </data> + <data name="capability.denied" xml:space="preserve"> + <value>geweigerd</value> + </data> + <data name="capability.claimed" xml:space="preserve"> + <value>geclaimd</value> + </data> + <data name="capability.disagrees" xml:space="preserve"> + <value>wijkt af</value> + </data> + <data name="capability.whereTheyDisagree" xml:space="preserve"> + <value>waar ze afwijken ({count})</value> + </data> + <data name="activity.cell.counted" xml:space="preserve"> + <value>{day} {time} — {count, plural, =0 {0 spelers, gemeten} one {gemiddeld # speler} other {gemiddeld # spelers}}</value> + </data> + <data name="activity.cell.notCounted" xml:space="preserve"> + <value>{day} {time} — gepeild, geen telling kon worden gelezen</value> + </data> + <data name="activity.cell.notMeasured" xml:space="preserve"> + <value>{day} {time} — geen meting in dit uur</value> + </data> + <data name="activity.none" xml:space="preserve"> + <value>We hebben de activiteit van dit spel nog niet gemeten.</value> + </data> + <data name="activity.noCount" xml:space="preserve"> + <value>Geen enkel uur van de week heeft een spelerstelling opgeleverd.</value> + </data> + <data name="activity.allZero" xml:space="preserve"> + <value>Elk uur gemeten en in geen enkel uur was er iemand verbonden.</value> + </data> + <data name="activity.gap.day" xml:space="preserve"> + <value>{count, plural, one {# uur op {day} heeft nog geen meting.} other {# uren op {day} hebben nog geen meting.}}</value> + </data> + <data name="activity.gap.week" xml:space="preserve"> + <value>{count, plural, one {# uur in de week heeft nog geen meting.} other {# uren in de week hebben nog geen meting.}}</value> + </data> + <data name="activity.uncounted.day" xml:space="preserve"> + <value>{count, plural, one {# uur op {day} antwoordde maar leverde geen telling op.} other {# uren op {day} antwoordden maar leverden geen telling op.}}</value> + </data> + <data name="activity.uncounted.week" xml:space="preserve"> + <value>{count, plural, one {# uur in de week antwoordde maar leverde geen telling op.} other {# uren in de week antwoordden maar leverden geen telling op.}}</value> + </data> + <data name="activity.busiest.everyDay" xml:space="preserve"> + <value>Elke dag het drukst, {window}.</value> + </data> + <data name="activity.busiest.everyDay.part" xml:space="preserve"> + <value>Elke dag het drukst in de {part}, {window}.</value> + </data> + <data name="activity.busiest.days" xml:space="preserve"> + <value>Het drukst op {days}, {window}.</value> + </data> + <data name="activity.busiest.days.part" xml:space="preserve"> + <value>Het drukst op {days} in de {part}, {window}.</value> + </data> + <data name="activity.quiet" xml:space="preserve"> + <value>Steevast rustig {who}, {window}.</value> + </data> + <data name="activity.quiet.part" xml:space="preserve"> + <value>Steevast rustig {who} in de {part}, {window}.</value> + </data> + <data name="activity.quiet.everyDay" xml:space="preserve"> + <value>elke dag</value> + </data> + <data name="activity.quiet.everyMeasuredDay" xml:space="preserve"> + <value>elke dag die we konden meten</value> + </data> + <data name="activity.quiet.weekdays" xml:space="preserve"> + <value>op werkdagen</value> + </data> + <data name="activity.quiet.onDays" xml:space="preserve"> + <value>op {days}</value> + </data> + <data name="activity.part.morning" xml:space="preserve"> + <value>ochtend</value> + </data> + <data name="activity.part.afternoon" xml:space="preserve"> + <value>middag</value> + </data> + <data name="activity.part.evening" xml:space="preserve"> + <value>avond</value> + </data> + <data name="activity.part.smallHours" xml:space="preserve"> + <value>nachtelijke uren</value> + </data> + <data name="activity.parts.morning" xml:space="preserve"> + <value>ochtenden</value> + </data> + <data name="activity.parts.afternoon" xml:space="preserve"> + <value>middagen</value> + </data> + <data name="activity.parts.evening" xml:space="preserve"> + <value>avonden</value> + </data> + <data name="activity.parts.smallHours" xml:space="preserve"> + <value>nachtelijke uren</value> + </data> + <data name="activity.days.list" xml:space="preserve"> + <value>{list}, {next}</value> + </data> + <data name="activity.days.pair" xml:space="preserve"> + <value>{first} en {second}</value> + </data> + <data name="activity.sparse.kicker" xml:space="preserve"> + <value>nog te weinig metingen</value> + </data> + <data name="activity.sparse.none" xml:space="preserve"> + <value>Nog geen enkel uur van de week is gemeten.</value> + </data> + <data name="activity.sparse.uncounted" xml:space="preserve"> + <value>{count, plural, one {# uur antwoordde en leverde geen telling op.} other {# uren antwoordden en leverden geen telling op.}}</value> + </data> + <data name="activity.sparse.wait" xml:space="preserve"> + <value>Het raster verschijnt zodra elke dag van de week er een heeft.</value> + </data> + <data name="activity.sparse.days" xml:space="preserve"> + <value>{days, plural, one {Tot nu toe op # van de zeven dagen gemeten; het raster verschijnt zodra elke dag een uur bevat.} other {Tot nu toe op # van de zeven dagen gemeten; het raster verschijnt zodra elke dag een uur bevat.}}</value> + </data> + <data name="activity.sample.zero" xml:space="preserve"> + <value>{count, plural, one {# uur gemeten, met niemand verbonden.} other {# uren gemeten, allemaal met niemand verbonden.}}</value> + </data> + <data name="activity.sample.peak" xml:space="preserve"> + <value>{count, plural, one {# uur gemeten, het drukst met {peak} op {day} om {time} UTC.} other {# uren gemeten, het drukst met {peak} op {day} om {time} UTC.}}</value> + </data> + <data name="activity.sample.more" xml:space="preserve"> + <value>{count, plural, one {Nog # uur antwoordde en leverde geen telling op.} other {Nog # uren antwoordden en leverden geen telling op.}}</value> + </data> + <data name="activity.day.line" xml:space="preserve"> + <value>{day} — {facts}</value> + </data> + <data name="activity.day.facts" xml:space="preserve"> + <value>{first}, {second}</value> + </data> + <data name="activity.day.allZero" xml:space="preserve"> + <value>de hele dag op nul gemeten</value> + </data> + <data name="activity.day.peak" xml:space="preserve"> + <value>piek {count} om {time}</value> + </data> + <data name="activity.day.nobodyOn" xml:space="preserve"> + <value>niemand verbonden {window}</value> + </data> + <data name="activity.day.noCount" xml:space="preserve"> + <value>in geen enkel uur een telling</value> + </data> + <data name="activity.day.notMeasured" xml:space="preserve"> + <value>{count, plural, one {# uur niet gemeten} other {# uren niet gemeten}}</value> + </data> + <data name="activity.day.notCounted" xml:space="preserve"> + <value>{count, plural, one {# uur gepeild maar niet telbaar} other {# uren gepeild maar niet telbaar}}</value> + </data> + <data name="activity.column.day" xml:space="preserve"> + <value>dag</value> + </data> + <data name="activity.column.quietest" xml:space="preserve"> + <value>rustigst</value> + </data> + <data name="activity.column.busiest" xml:space="preserve"> + <value>drukst</value> + </data> + <data name="activity.column.at" xml:space="preserve"> + <value>om</value> + </data> + <data name="activity.column.noCount" xml:space="preserve"> + <value>geen telling</value> + </data> + <data name="activity.caption" xml:space="preserve"> + <value>Spelers verbonden per dag, in UTC. {window}.</value> + </data> + <data name="activity.times" xml:space="preserve"> + <value>tijden in UTC · {window}</value> + </data> + <data name="activity.rollingAverage" xml:space="preserve"> + <value>{weeks, plural, one {voortschrijdend gemiddelde over # week} other {voortschrijdend gemiddelde over # weken}}</value> + </data> + <data name="activity.legend.counted" xml:space="preserve"> + <value>geteld, inclusief een gemeten nul</value> + </data> + <data name="activity.legend.notCounted" xml:space="preserve"> + <value>gepeild, geen telling kon worden gelezen</value> + </data> + <data name="activity.legend.notMeasured" xml:space="preserve"> + <value>geen meting in dat uur</value> + </data> + <data name="activity.plain.heading" xml:space="preserve"> + <value>Wanneer er spelers verbonden zijn (UTC)</value> + </data> + <data name="activity.key.counted" xml:space="preserve"> + <value>geteld</value> + </data> + <data name="activity.key.counted.meaning" xml:space="preserve"> + <value>we kwamen binnen en lazen een getal, inclusief een gemeten nul</value> + </data> + <data name="activity.key.uncounted.meaning" xml:space="preserve"> + <value>we kwamen binnen en er was geen getal te lezen</value> + </data> + <data name="activity.key.notMeasured.meaning" xml:space="preserve"> + <value>we hebben geen meting voor dat uur</value> + </data> + <data name="locale.label" xml:space="preserve"> + <value>taal</value> + </data> + <data name="locale.submit" xml:space="preserve"> + <value>taal wijzigen</value> + </data> + <data name="about.title" xml:space="preserve"> + <value>Over mu*index</value> + </data> + <data name="about.lede" xml:space="preserve"> + <value>Elk spel hier is gemeten door een machine die er verbinding mee maakte, en elke waarde vermeldt waar hij vandaan komt en wanneer. Deze pagina behandelt wat dat bewijst, wat we fout doen, wiens gidsen we lezen, en hoe de crawler te stoppen is.</value> + </data> + <data name="about.measures.heading" xml:space="preserve"> + <value>Wat een feit hier is</value> + </data> + <data name="about.measures.declared.lead" xml:space="preserve"> + <value>Gemeten wint van opgegeven, en beide worden getoond.</value> + </data> + <data name="about.measures.declared.body" xml:space="preserve"> + <value>Het MSSP-rapport van een spel is het spel dat zichzelf beschrijft. De telnet-handshake is wat we het hebben zien doen. Beide staan op zijn pagina, gelabeld met hoe en wanneer. Waar ze van elkaar afwijken, tonen we de afwijking.</value> + </data> + <data name="about.measures.count.lead" xml:space="preserve"> + <value>Een spelerstelling vermeldt waar hij vandaan komt.</value> + </data> + <data name="about.measures.count.body" xml:space="preserve"> + <value>Ofwel een WHO of DOING die bij het verbindingsscherm gelezen is en door ons geteld, ofwel het eigen MSSP PLAYERS-veld van het spel, dat het zelf publiceerde. Nooit samengevoegd.</value> + </data> + <data name="about.measures.unknown.lead" xml:space="preserve"> + <value>Een antwoord dat we niet kunnen lezen is onbekend, nooit nul.</value> + </data> + <data name="about.measures.unknown.body" xml:space="preserve"> + <value>Servers passen hun WHO-koppen naar believen aan, en voorbij een zeker punt kan onze parser er geen meer lezen. Dat is niet telbaar, een toestand op zichzelf. Een gemeten nul — we kwamen binnen, er was niemand — is een telling, en wordt ook als telling weergegeven.</value> + </data> + <data name="about.measures.reachable.lead" xml:space="preserve"> + <value>Bereikbaar, nooit uptime.</value> + </data> + <data name="about.measures.reachable.body" xml:space="preserve"> + <value>We openen met tussenpozen een socket vanaf één host. Een spel waarheen we geen route hebben is onbereikbaar en volkomen springlevend. Niets hier beweert iets over de uptime van een spel, omdat niets hier die gemeten heeft.</value> + </data> + <data name="about.measures.hour.lead" xml:space="preserve"> + <value>Een uur is geteld, niet telbaar, of niet gemeten.</value> + </data> + <data name="about.measures.hour.body" xml:space="preserve"> + <value>Het activiteitenraster heeft drie toestanden. De derde is leeg en noemt geen oorzaak: een uur dat we niet konden bereiken en een uur dat we nooit gepeild hebben zijn dezelfde afwezigheid, en geen van beide is downtime van die server.</value> + </data> + <data name="about.limits.heading" xml:space="preserve"> + <value>Wat we weten dat we fout doen</value> + </data> + <data name="about.limits.grace.lead" xml:space="preserve"> + <value>Het archiefrespijt wordt gemeten vanaf de dag dat we je vonden.</value> + </data> + <data name="about.limits.grace.body" xml:space="preserve"> + <value>Een spel dat stopt met antwoorden verlaat de standaardlijst na zijn respijtperiode: een kwart van de bereikbare tijd die we gepeild hebben, met een ondergrens van 60 dagen en een bovengrens van 365. Een spel dat sinds 1995 draait, begint op de ondergrens op de dag dat we het ontdekken. We importeren niets om de jaren vóór onze komst in te vullen.</value> + </data> + <data name="about.limits.created.lead" xml:space="preserve"> + <value>We laten MSSP CREATED niet meetellen voor dat respijt.</value> + </data> + <data name="about.limits.created.body" xml:space="preserve"> + <value>Het is één met de hand ingetypte regel in een configuratiebestand, dus meetellen zou de archiefdrempel manipuleerbaar maken. Het wordt als opgave getoond en koopt niets.</value> + </data> + <data name="about.limits.claim.lead" xml:space="preserve"> + <value>Een spel claimen levert de bovengrens op.</value> + </data> + <data name="about.limits.claim.body" xml:space="preserve"> + <value>Aantonen dat er servertoegang is, is het volle jaar respijt waard, hoe lang we ook al meekijken.</value> + </data> + <data name="about.limits.oneHost.lead" xml:space="preserve"> + <value>Alles hier is één host die met tussenpozen kijkt.</value> + </data> + <data name="about.limits.oneHost.body" xml:space="preserve"> + <value>Een percentage bereikbare tijd is een deel van de periode die we waarnamen, nooit van een periode die we niet waarnamen. Geen enkele grafiek hier vult de rest in.</value> + </data> + <data name="about.limits.deletion.lead" xml:space="preserve"> + <value>Er wordt nooit iets verwijderd.</value> + </data> + <data name="about.limits.deletion.body" xml:space="preserve"> + <value>Archiveren haalt een spel uit de standaardlijst, de ranglijsten en het cijfer van vandaag actief, en verder niets. Zijn pagina, URL, geschiedenis en adres blijven bestaan, het wordt nog gepeild, en één geslaagde peiling zet het terug.</value> + </data> + <data name="about.never.heading" xml:space="preserve"> + <value>Wat deze site niet zal doen</value> + </data> + <data name="about.never.votes.lead" xml:space="preserve"> + <value>Geen stemmen, sterren, beoordelingen of aanbevelingen.</value> + </data> + <data name="about.never.votes.body" xml:space="preserve"> + <value>Ranglijsten worden alleen uit gemeten gegevens berekend. Een gids die gerangschikt is naar wie de meeste klikken kan mobiliseren, beschrijft de campagne en niet de hobby, en daaraan zijn de gevestigde gidsen ten onder gegaan.</value> + </data> + <data name="about.never.forums.lead" xml:space="preserve"> + <value>Geen forums, recensies, wiki’s, reacties of spelersprofielen.</value> + </data> + <data name="about.never.forums.body" xml:space="preserve"> + <value>Oriënterend materiaal — wat een MUSH is, welke codebase past bij gezamenlijk rollenspel — wordt geschreven, ondertekend en van versies voorzien zoals de rest van de site.</value> + </data> + <data name="about.never.names.lead" xml:space="preserve"> + <value>Spelersnamen worden nooit bewaard.</value> + </data> + <data name="about.never.names.body" xml:space="preserve"> + <value>Een WHO-antwoord wordt in het geheugen ontleed op een telling en de vorm van de kop. De namen worden niet vastgelegd; aggregaten gebruiken een gezouten hash met een roulerende salt.</value> + </data> + <data name="about.never.population.lead" xml:space="preserve"> + <value>Er wordt geen absoluut spelersaantal gepubliceerd.</value> + </data> + <data name="about.never.population.body" xml:space="preserve"> + <value>Aandelen per codebase en per protocol gaan wel de deur uit: een verhouding over de gemeten verzameling overleeft de spellen die we niet kunnen tellen. ‘Hoeveel mensen spelen MU*’ overleeft dat niet, want dat getal zou het niet houden zodra het geciteerd werd.</value> + </data> + <data name="about.crawler.heading" xml:space="preserve"> + <value>De crawler, en hoe die te stoppen is</value> + </data> + <data name="about.crawler.probe.lead" xml:space="preserve"> + <value>Een peiling is één verbinding die nooit inlogt.</value> + </data> + <data name="about.crawler.probe.body" xml:space="preserve"> + <value>Die opent een socket, onderhandelt over telnet-opties, leest het verbindingsscherm, vraagt om MSSP door optie 70 te onderhandelen, stuurt {commands} en verbreekt de verbinding. Geen personage, geen login, niets veranderd aan de andere kant. Een time-out begrenst de sessie, zodat een vastgelopen peiling geen verbindingsplek bezet kan houden.</value> + </data> + <data name="about.crawler.delay.lead" xml:space="preserve"> + <value>CRAWL DELAY wint.</value> + </data> + <data name="about.crawler.delay.body" xml:space="preserve"> + <value>Een spel dat in zijn MSSP-rapport een gewenste minimale tussenpoos opgeeft, krijgt die, boven ons eigen schema in beide richtingen: 720 uur betekent maandelijks, niet wekelijks. Bij een stilgevallen spel wordt voor altijd op de langere tussenpoos aangeklopt, en zo zet het zichzelf weer in de lijst wanneer het terugkomt.</value> + </data> + <data name="about.crawler.referral.lead" xml:space="preserve"> + <value>Een doorverwezen adres wordt geverifieerd, nooit vertrouwd.</value> + </data> + <data name="about.crawler.referral.body" xml:space="preserve"> + <value>Met MSSP kan een spel andere spellen noemen. Elke naam wordt opgelost voordat er ergens wordt aangeklopt, en geweigerd tenzij elk adres waarnaar hij oplost wereldwijd routeerbaar is. Een gemengd antwoord weigert het hele doel. Onze weigering wordt als de onze vastgelegd en verschijnt nooit als downtime in het dossier van een spel.</value> + </data> + <data name="about.crawler.screens.lead" xml:space="preserve"> + <value>Verbindingsschermen worden getoond omdat ze naar iedereen gestuurd worden.</value> + </data> + <data name="about.crawler.screens.body" xml:space="preserve"> + <value>Een server tekent zijn verbindingsscherm, zonder authenticatie, naar elke anonieme verbinding. We tonen het als bewijs en labelen het. Eén verzoek en het gaat eraf.</value> + </data> + <data name="about.crawler.stop.lead" xml:space="preserve"> + <value>Zeg stop, en we stoppen — op drie manieren.</value> + </data> + <data name="about.crawler.stop.body" xml:space="preserve"> + <value>Publiceer {variable} 1 in je MSSP-rapport, en de peiling die dat leest is de laatste. Of publiceer een TXT-record op {label}.jouw.host met de inhoud ‘{value}’, waarvoor geen MSSP-ondersteuning en geen account hier nodig is. Of schrijf een mens aan. Alle drie worden binnen één crawlcyclus gehonoreerd, vastgelegd met de datum en met wat we lazen, en ook op het aanmeldformulier afgedwongen.</value> + </data> + <data name="about.crawler.scope.lead" xml:space="preserve"> + <value>Het MSSP-veld stopt die luisterpoort; het record stopt de host.</value> + </data> + <data name="about.crawler.scope.body" xml:space="preserve"> + <value>MSSP wordt gepubliceerd door de poort die antwoordde, dus spreekt het voor die poort — bij MU*-hosting draaien routinematig ongerelateerde spellen op één domein, en het ene mag het andere niet het zwijgen opleggen. Een TXT-record geldt voor elke poort tenzij het er een noemt, als ‘{value}=4201’. Alles wat daar staat en wat we niet als poortenlijst kunnen lezen betekent de hele host, dus ‘{value}=all’ werkt.</value> + </data> + <data name="about.crawler.dns.lead" xml:space="preserve"> + <value>De DNS-route is de enige die je ongedaan kunt maken zonder het ons te vragen.</value> + </data> + <data name="about.crawler.dns.body" xml:space="preserve"> + <value>Een TXT-record is leesbaar zonder verbinding te maken met een server die dat verboden heeft, dus we lezen het opnieuw voordat we aankloppen. Verwijder het en we kloppen binnen een week weer aan. Een MSSP-veld kan niet opnieuw gelezen worden zonder precies te doen wat je ons gevraagd hebt te laten, dus afmeldingen via MSSP en schriftelijke verzoeken blijven staan tot je het tegendeel zegt. Die TXT-opzoeking is alles wat een afgemeld adres krijgt: ze raakt je nameserver, nooit je spel.</value> + </data> + <data name="about.crawler.stopping.lead" xml:space="preserve"> + <value>Stoppen is niet verwijderen, en het is geen downtime.</value> + </data> + <data name="about.crawler.stopping.body" xml:space="preserve"> + <value>Een spel dat zich afmeldt, houdt zijn pagina, zijn adres en alles wat we gemeten hebben voordat het erom vroeg. Alleen nieuwe gegevens stoppen: het activiteitenraster krijgt er geen uren meer bij en noemt geen oorzaak, want ons besluit om te stoppen met kloppen is een feit over ons. Het wordt vastgelegd bij de crawl die niet plaatsvond, en in het register van wie erom vroeg.</value> + </data> + <data name="about.crawler.unlist.lead" xml:space="preserve"> + <value>Als stoppen niet genoeg is, kan de vermelding er ook af.</value> + </data> + <data name="about.crawler.unlist.body" xml:space="preserve"> + <value>Zodra we gestopt zijn op elk adres waarop je spel antwoordt, biedt je dashboard nog één ding: het uit de lijst, de ranglijsten en het dagcijfer halen. De pagina en elk adres dat het ooit gehad heeft blijven antwoorden, en er wordt niets verwijderd — het houdt op een plek te zijn waar een lezer al bladerend aankomt. Er is een geverifieerde claim voor nodig, want het is een besluit over je spel en we leggen vast wie het genomen heeft. En een peiling maakt het ongedaan: trek je afmelding in, en de eerstvolgende keer dat er aangeklopt wordt en er antwoord komt, sta je weer in de lijst zonder dat je het ons nog eens hoeft te vragen.</value> + </data> + <data name="about.identity.announced" xml:space="preserve"> + <value>De crawler noemt zichzelf {name} wanneer een server vraagt wat hij is.</value> + </data> + <data name="about.identity.unannounced" xml:space="preserve"> + <value>De crawler is ingesteld om zichzelf {name} te noemen, maar kan dat nog niet zeggen. Zijn telnet-bibliotheek biedt een client geen manier om het terminaltype in te stellen, dus je logboeken zien de standaardwaarde van die bibliotheek, en NEW-ENVIRON wordt beantwoord vanuit de omgeving van de crawlerhost. Beide zijn gaten in de bibliotheek en aan ons om ze daar te dichten. Tot die tijd: herken een peiling aan de vorm ervan — één verbinding, geen login, een korte set alleen-lezen-commando’s, weg.</value> + </data> + <data name="about.identity.crawler" xml:space="preserve"> + <value>crawler</value> + </data> + <data name="about.identity.contact" xml:space="preserve"> + <value>contact</value> + </data> + <data name="about.identity.crawler.line" xml:space="preserve"> + <value>Crawler: {name}</value> + </data> + <data name="about.identity.contact.line" xml:space="preserve"> + <value>Contact: {url}</value> + </data> + <data name="about.identity.placeholder" xml:space="preserve"> + <value>— tijdelijke aanduiding; deze installatie heeft geen contactadres ingesteld</value> + </data> + <data name="about.identity.placeholder.plain" xml:space="preserve"> + <value>Er is geen contactadres ingesteld, dus het adres hierboven is een tijdelijke aanduiding en beantwoordt niemand.</value> + </data> + <data name="about.sources.heading" xml:space="preserve"> + <value>Waar de lijst met spellen vandaan komt</value> + </data> + <data name="about.sources.addresses.lead" xml:space="preserve"> + <value>We nemen adressen over. Verder niets.</value> + </data> + <data name="about.sources.addresses.body" xml:space="preserve"> + <value>Een backfill haalt een host en een poort op. Geen spelerstellingen, geen bereikbaarheidsgeschiedenis, geen beschrijvingen, geen velden, en geen aantekening van welke site een adres kwam.</value> + </data> + <data name="about.sources.less.lead" xml:space="preserve"> + <value>Bewust minder dan die sites kunnen geven.</value> + </data> + <data name="about.sources.less.body" xml:space="preserve"> + <value>Verschillende bewaren jaren aan gedateerde spelerstellingen. Dat importeren zou de heatmaps vullen van de spellen die iemand anders al in de gaten hield, en de centrale claim van deze site laten steunen op de peilingen van een ander.</value> + </data> + <data name="about.sources.origin.lead" xml:space="preserve"> + <value>De herkomst van een spel is niet één feit.</value> + </data> + <data name="about.sources.origin.body" xml:space="preserve"> + <value>Elk spel dat het vermelden waard is, staat in meerdere van deze gidsen, dus ‘geïmporteerd uit’ zou noemen welke ophaalronde toevallig het eerst liep. Dat een spel bestaat is openbare informatie; waar we het gelezen hebben voegt niets toe en is het deel van andermans werk waarop wij de minste aanspraak hebben.</value> + </data> + <data name="about.sources.etiquette.lead" xml:space="preserve"> + <value>Andermans site lezen blijft andermans site lezen.</value> + </data> + <data name="about.sources.etiquette.body" xml:space="preserve"> + <value>We vragen om een bulkexport of een gedocumenteerd endpoint voordat we scrapen, lezen eerst robots.txt, en beperken de snelheid van scrapes streng. Een bron waarvoor toestemming van de beheerder nodig is, wordt niet opgehaald tot een mens kan verklaren dat het gevraagd is.</value> + </data> + <data name="about.source.read" xml:space="preserve"> + <value>gelezen — alleen adressen</value> + </data> + <data name="about.source.withheld" xml:space="preserve"> + <value>niet gelezen — wacht op toestemming</value> + </data> + <data name="about.source.tintinMssp.note" xml:space="preserve"> + <value>Eén pagina, één verzoek. Gepubliceerd door een crawler die met elk spel verbinding maakt en afdrukt wat hij las.</value> + </data> + <data name="about.source.tintinMsdp.note" xml:space="preserve"> + <value>De MSDP-lijst van dezelfde crawler. Bijna een deelverzameling van zijn MSSP-tegenhanger, gelezen om de paar adressen die hij wel bereikt en de andere niet.</value> + </data> + <data name="about.source.mudConnector.note" xml:space="preserve"> + <value>Publiceert zijn hele catalogus op één pagina, dus het lezen ervan kost één verzoek. Onze grootste bron van adressen, en van geen enkele meting.</value> + </data> + <data name="about.source.mudStats.note" xml:space="preserve"> + <value>Eén indexpagina en één pagina per wereld, dus een scrape in plaats van een export. Op 30 juli 2026 hebben we 143 van hun pagina’s opgehaald, met vijftien seconden ertussen en met inachtneming van robots.txt, maar voordat iemand hun geschreven had. Dat had niet mogen gebeuren. De poort vraagt nu om een mens die wil verklaren dat de beheerder gevraagd is.</value> + </data> + <data name="about.source.mudVerse.note" xml:space="preserve"> + <value>Geïmplementeerd, getest, nooit uitgevoerd. De sterkste bron hier op elke as behalve toestemming, en er wordt niets opgehaald tot iemand hun geschreven heeft.</value> + </data> + <data name="about.licence.heading" xml:space="preserve"> + <value>Licentie</value> + </data> + <data name="about.licence.code.lead" xml:space="preserve"> + <value>De code is MIT.</value> + </data> + <data name="about.licence.code.body" xml:space="preserve"> + <value>De site, de crawler en de parsers zijn opensource onder de MIT-licentie.</value> + </data> + <data name="about.licence.open.lead" xml:space="preserve"> + <value>De licentie voor de gegevens is een open vraag.</value> + </data> + <data name="about.licence.open.body" xml:space="preserve"> + <value>Een besluit los van dat over de code, en nog niet genomen. Lees de voorwaarden hieronder als het huidige antwoord van deze installatie, niet als het vastgelegde standpunt van het project. Dat een concurrerende gids de hele catalogus overneemt geldt hier als succes, dus wat er ook wordt vastgelegd, het zal zo’n gids niet in de weg staan.</value> + </data> + <data name="about.licence.codeLabel" xml:space="preserve"> + <value>code</value> + </data> + <data name="about.licence.dataLabel" xml:space="preserve"> + <value>gegevens, zoals deze installatie ze aanbiedt</value> + </data> + <data name="about.licence.creditLabel" xml:space="preserve"> + <value>vermelden als</value> + </data> + <data name="about.licence.code.line" xml:space="preserve"> + <value>Code: {licence}</value> + </data> + <data name="about.licence.data.line" xml:space="preserve"> + <value>Gegevens: {licence}</value> + </data> + <data name="about.licence.credit.line" xml:space="preserve"> + <value>Vermelden als: {credit}</value> + </data> + <data name="about.licence.deployment" xml:space="preserve"> + <value>(wat deze installatie aanbiedt. Het antwoord van het project zelf ligt nog open.)</value> + </data> + <data name="submit.title" xml:space="preserve"> + <value>Een spel aanmelden</value> + </data> + <data name="submit.lede" xml:space="preserve"> + <value>Vertel ons waar een spel staat. Een host en een poort zijn het hele formulier; al het andere op deze site wordt door onze eigen crawler gemeten.</value> + </data> + <data name="submit.host.label" xml:space="preserve"> + <value>Host</value> + </data> + <data name="submit.port.label" xml:space="preserve"> + <value>Poort</value> + </data> + <data name="submit.host.hint" xml:space="preserve"> + <value>mud.example.org, of plak mud.example.org:4201 en laat de poort leeg</value> + </data> + <data name="submit.button" xml:space="preserve"> + <value>Aanmelden</value> + </data> + <data name="submit.noCatalogue" xml:space="preserve"> + <value>Aanmelden vereist een database, en deze site draait op de demofixture. Er is geen crawlregister om in te schrijven, dus het formulier ontbreekt in plaats van stilletjes niets te doen.</value> + </data> + <data name="submit.notHere" xml:space="preserve"> + <value>Niet hier</value> + </data> + <data name="submit.what.heading" xml:space="preserve"> + <value>Wat er met een adres gebeurt</value> + </data> + <data name="submit.what.resolve" xml:space="preserve"> + <value>We lossen het adres op voordat we aankloppen, en weigeren alles wat buiten het publieke internet uitkomt. Dat is een besluit over onze eigen socket, nooit een feit over een spel.</value> + </data> + <data name="submit.what.optOut" xml:space="preserve"> + <value>Als degene die die host draait ons gevraagd heeft er niet te crawlen, nemen we het adres niet aan, door wie het ook wordt aangemeld. Een vreemde kan je spel niet terugzetten op deze site.</value> + </data> + <data name="submit.what.schedule" xml:space="preserve"> + <value>Als het antwoordt, lezen we wat de server over zichzelf zegt en blijven we dat lezen op zijn eigen schema, voor altijd. Een adres hoeft maar één keer gegeven te worden.</value> + </data> + <data name="submit.what.claim" xml:space="preserve"> + <value>Er verschijnt niets op de site voordat iemand bewezen heeft het te draaien. Claimen vereist een passkey en één regel die op het spel zelf gepubliceerd wordt.</value> + </data> + <data name="submit.what.duplicate" xml:space="preserve"> + <value>Een adres dat we al hebben valt samen met de bestaande vermelding. Het twee keer sturen levert geen tweede vermelding op en haalt geen peiling naar voren.</value> + </data> + <data name="submit.answer.thatAddress" xml:space="preserve"> + <value>dat adres</value> + </data> + <data name="submit.accepted.heading" xml:space="preserve"> + <value>In het register.</value> + </data> + <data name="submit.accepted.sentence" xml:space="preserve"> + <value>Bij {address} wordt in de volgende crawlcyclus aangeklopt, daarna op zijn eigen schema, voor altijd. Het verschijnt hier zodra iemand bewijst het te draaien — kom met hetzelfde adres terug naar dit formulier en het geeft je de link.</value> + </data> + <data name="submit.unclaimed.heading" xml:space="preserve"> + <value>We hebben het, niet geclaimd.</value> + </data> + <data name="submit.unclaimed.sentence" xml:space="preserve"> + <value>{address} is er een die we al meten. Het blijft van de site af tot iemand bewijst het te draaien. Ben jij dat, dan is dit de weg naar binnen.</value> + </data> + <data name="submit.known.heading" xml:space="preserve"> + <value>Die hebben we al.</value> + </data> + <data name="submit.known.sentence" xml:space="preserve"> + <value>{address} is een spel dat we al meten. Er is niets aangemaakt en niets gewijzigd.</value> + </data> + <data name="submit.knownAddress.heading" xml:space="preserve"> + <value>Dat adres hebben we al.</value> + </data> + <data name="submit.knownAddress.sentence" xml:space="preserve"> + <value>{address} is bij ons al bekend. Er is niets aangemaakt en niets gewijzigd.</value> + </data> + <data name="submit.queued.heading" xml:space="preserve"> + <value>Staat al te wachten.</value> + </data> + <data name="submit.queued.sentence" xml:space="preserve"> + <value>{address} staat in het crawlregister en heeft nog niet geantwoord. Het opnieuw sturen haalt het niet naar voren: een doel houdt zijn eigen schema aan, dus niemand kan ons opjagen bij andermans server.</value> + </data> + <data name="submit.malformed.heading" xml:space="preserve"> + <value>Geen adres waar we kunnen aankloppen.</value> + </data> + <data name="submit.malformed.sentence" xml:space="preserve"> + <value>Een host heeft een punt of een dubbele punt nodig, en een poort is een getal tussen 1 en 65535. Vul beide velden in, of plak mud.example.org:4201 in het eerste.</value> + </data> + <data name="submit.undialable.heading" xml:space="preserve"> + <value>Daar kunnen we niet aankloppen.</value> + </data> + <data name="submit.undialable.sentence" xml:space="preserve"> + <value>Drie dingen leveren dit antwoord op voor {address}: de naam wordt misschien niet opgelost, hij komt misschien buiten het publieke internet uit, of degene die die host draait heeft ons misschien gevraagd weg te blijven. We zeggen bewust niet welke, want dat voor een vreemde beantwoorden brengt een netwerk van buitenaf in kaart. Er is niets over het adres vastgelegd; het besluit was het onze en het is als het onze vastgelegd.</value> + </data> + <data name="submit.tooMany.heading" xml:space="preserve"> + <value>Genoeg voor nu.</value> + </data> + <data name="submit.tooMany.sentence" xml:space="preserve"> + <value>Dit formulier is per afzender in snelheid beperkt, en je hebt de grens bereikt. Kom over een uur terug. Er is niets verloren gegaan — alles wat we aangenomen hebben staat al in het register.</value> + </data> + <data name="submit.link.claim" xml:space="preserve"> + <value>dit spel claimen</value> + </data> + <data name="account.signIn.title" xml:space="preserve"> + <value>Inloggen</value> + </data> + <data name="account.signIn.preview" xml:space="preserve"> + <value>Log in met een passkey om een spel te claimen dat je zelf draait. Er is geen wachtwoord om kwijt te raken en geen om te stelen.</value> + </data> + <data name="account.signIn.noDatabase" xml:space="preserve"> + <value>Claimen vereist een database, en deze site draait op de demofixture. Er is niets om op in te loggen.</value> + </data> + <data name="account.signIn.passkey.lead" xml:space="preserve"> + <value>Inloggen gaat met een passkey.</value> + </data> + <data name="account.signIn.passkey.body" xml:space="preserve"> + <value>Je apparaat of wachtwoordmanager houdt de privésleutel; wij houden alleen de publieke helft. Geen wachtwoord, geen e-mail.</value> + </data> + <data name="account.signIn.button" xml:space="preserve"> + <value>Inloggen met een passkey</value> + </data> + <data name="account.signIn.script" xml:space="preserve"> + <value>De enige pagina hier die JavaScript nodig heeft. Passkeys werken er niet zonder.</value> + </data> + <data name="account.register.heading" xml:space="preserve"> + <value>Nog geen account?</value> + </data> + <data name="account.register.lede" xml:space="preserve"> + <value>Je hebt er alleen een nodig om een spel te claimen dat je zelf draait. Kies een naam om onder bekend te staan — een label naast je claim, geen echte naam.</value> + </data> + <data name="account.register.name.label" xml:space="preserve"> + <value>Naam</value> + </data> + <data name="account.register.name.placeholder" xml:space="preserve"> + <value>bijv. corvid-admin</value> + </data> + <data name="account.register.button" xml:space="preserve"> + <value>Een account aanmaken met een passkey</value> + </data> + <data name="account.store.heading" xml:space="preserve"> + <value>Wat we opslaan</value> + </data> + <data name="account.store.name" xml:space="preserve"> + <value>De naam die je gekozen hebt.</value> + </data> + <data name="account.store.keys" xml:space="preserve"> + <value>De publieke sleutel van elke passkey die je registreert, en hoe je apparaat die noemde.</value> + </data> + <data name="account.store.claims" xml:space="preserve"> + <value>Welke spellen je geclaimd hebt, en wanneer.</value> + </data> + <data name="account.store.note" xml:space="preserve"> + <value>Geen e-mailadres, geen wachtwoord, geen IP-log gekoppeld aan je account. Raak je elke passkey kwijt, dan kun je een nieuw claimtoken op je spel publiceren en opnieuw beginnen: het spel is het bewijs, niet het account.</value> + </data> + <data name="date.absolute" xml:space="preserve"> + <value>{day} {month} {year}</value> + </data> + <data name="date.stamp" xml:space="preserve"> + <value>{date} {time} UTC</value> + </data> + <data name="age.short.now" xml:space="preserve"> + <value>nu</value> + </data> + <data name="age.short.minutes" xml:space="preserve"> + <value>{count, plural, one {#m} other {#m}}</value> + </data> + <data name="age.short.hours" xml:space="preserve"> + <value>{count, plural, one {#u} other {#u}}</value> + </data> + <data name="age.short.days" xml:space="preserve"> + <value>{count, plural, one {#d} other {#d}}</value> + </data> + <data name="age.short.weeks" xml:space="preserve"> + <value>{count, plural, one {#w} other {#w}}</value> + </data> + <data name="age.short.months" xml:space="preserve"> + <value>{count, plural, one {#mnd} other {#mnd}}</value> + </data> + <data name="age.short.years" xml:space="preserve"> + <value>{count, plural, one {#j} other {#j}}</value> + </data> + <data name="age.ago.now" xml:space="preserve"> + <value>zojuist</value> + </data> + <data name="age.ago.minutes" xml:space="preserve"> + <value>{count, plural, one {#m geleden} other {#m geleden}}</value> + </data> + <data name="age.ago.hours" xml:space="preserve"> + <value>{count, plural, one {#u geleden} other {#u geleden}}</value> + </data> + <data name="age.ago.days" xml:space="preserve"> + <value>{count, plural, one {#d geleden} other {#d geleden}}</value> + </data> + <data name="age.ago.weeks" xml:space="preserve"> + <value>{count, plural, one {#w geleden} other {#w geleden}}</value> + </data> + <data name="age.ago.months" xml:space="preserve"> + <value>{count, plural, one {#mnd geleden} other {#mnd geleden}}</value> + </data> + <data name="age.ago.years" xml:space="preserve"> + <value>{count, plural, one {#j geleden} other {#j geleden}}</value> + </data> + <data name="age.dark.now" xml:space="preserve"> + <value>zojuist</value> + </data> + <data name="age.dark.minutes" xml:space="preserve"> + <value>{count, plural, one {#m geleden} other {#m geleden}}</value> + </data> + <data name="age.dark.hours" xml:space="preserve"> + <value>{count, plural, one {#u geleden} other {#u geleden}}</value> + </data> + <data name="age.dark.days" xml:space="preserve"> + <value>{count, plural, one {#d geleden} other {#d geleden}}</value> + </data> + <data name="age.dark.weeks" xml:space="preserve"> + <value>{count, plural, one {#w geleden} other {#w geleden}}</value> + </data> + <data name="age.dark.months" xml:space="preserve"> + <value>{count, plural, one {#mnd geleden} other {#mnd geleden}}</value> + </data> + <data name="age.dark.years" xml:space="preserve"> + <value>{count, plural, one {#j geleden} other {#j geleden}}</value> + </data> + <data name="time.title" xml:space="preserve"> + <value>{age}, {stamp}</value> + </data> + <data name="time.spoken" xml:space="preserve"> + <value>, {stamp}</value> + </data> + <data name="chip.title" xml:space="preserve"> + <value>{value} — {how} via {source}, laatst bevestigd {date}</value> + </data> + <data name="chip.title.stale" xml:space="preserve"> + <value>{value} — {how} via {source}, laatst bevestigd {date} (voorbij de verwachte verversing)</value> + </data> + <data name="chip.plain" xml:space="preserve"> + <value>({how}, {age})</value> + </data> + <data name="chip.plain.stale" xml:space="preserve"> + <value>({how}, {age}, verouderd)</value> + </data> + <data name="provenance.game.ownerDeclared" xml:space="preserve"> + <value>opgegeven door de eigenaar</value> + </data> + <data name="source.staff" xml:space="preserve"> + <value>de redactie</value> + </data> + <data name="source.handshake" xml:space="preserve"> + <value>de telnet-handshake</value> + </data> + <data name="source.owner" xml:space="preserve"> + <value>de eigenaar</value> + </data> + <data name="source.who" xml:space="preserve"> + <value>WHO</value> + </data> + <data name="source.i3" xml:space="preserve"> + <value>I3</value> + </data> + <data name="source.mssp" xml:space="preserve"> + <value>MSSP</value> + </data> + <data name="source.info" xml:space="preserve"> + <value>INFO</value> + </data> + <data name="source.i3Mudlist" xml:space="preserve"> + <value>de I3-mudlist</value> + </data> + <data name="source.banner" xml:space="preserve"> + <value>het verbindingsscherm</value> + </data> + <data name="ecosystem.title" xml:space="preserve"> + <value>Het ecosysteem</value> + </data> + <data name="ecosystem.noTotals" xml:space="preserve"> + <value>Aandelen, nooit totalen. We publiceren geen cijfer voor hoeveel mensen MU* spelen: een verhouding over de spellen die we gemeten hebben overleeft de spellen die we niet kunnen bereiken, en een koppentelling niet.</value> + </data> + <data name="ecosystem.listed" xml:space="preserve"> + <value>{count, plural, one {{value} spel vermeld} other {{value} spellen vermeld}}</value> + </data> + <data name="ecosystem.handshakes" xml:space="preserve"> + <value>{count, plural, one {{value} spel waarvan we de handshake voltooiden} other {{value} spellen waarvan we de handshake voltooiden}}</value> + </data> + <data name="ecosystem.msspReports" xml:space="preserve"> + <value>{count, plural, one {{value} spel waarvan we het MSSP-rapport hebben} other {{value} spellen waarvan we het MSSP-rapport hebben}}</value> + </data> + <data name="ecosystem.oldestHandshake" xml:space="preserve"> + <value>Oudste handshake hier: {age} geleden bevestigd.</value> + </data> + <data name="ecosystem.share" xml:space="preserve"> + <value>{count, number} van {total, number} ({fraction, number, ::percent .0})</value> + </data> + <data name="ecosystem.share.nothing" xml:space="preserve"> + <value>{count, number} van {total, number} — nog niets gemeten</value> + </data> + <data name="ecosystem.share.percent" xml:space="preserve"> + <value>{fraction, number, ::percent .0}</value> + </data> + <data name="ecosystem.codebases.title" xml:space="preserve"> + <value>Codebases</value> + </data> + <data name="ecosystem.codebases.basis" xml:space="preserve"> + <value>Van de {listed, plural, one {# vermelde spel} other {# vermelde spellen}} hebben er {identified, number} ons verteld waarop ze draaien, en elk aandeel hieronder gaat over die {identified, number}. Een codebase die we niet konden lezen valt buiten de noemer, en wordt nooit als iets anders geteld.</value> + </data> + <data name="ecosystem.codebases.none" xml:space="preserve"> + <value>Nog geen vermeld spel heeft ons zijn codebase verteld.</value> + </data> + <data name="ecosystem.soleUse" xml:space="preserve"> + <value>{share} draait op een codebase die geen enkel ander vermeld spel draait — één spel per stuk, wat een naam is en geen aandeel. Ze vallen binnen de noemer hierboven en zijn uit de balken gevouwen, niet weggelaten:</value> + </data> + <data name="ecosystem.lineages.title" xml:space="preserve"> + <value>Afstammingen</value> + </data> + <data name="ecosystem.lineages.basis" xml:space="preserve"> + <value>Dezelfde spellen, gegroepeerd naar de traditie waar hun server van afstamt — onze lezing van de codebase, niet iets wat een spel gepubliceerd heeft. Geen enkel spel meldt ‘MUSH’: MSSP kent die waarde niet, en het grootste deel van de MUSH-wereld publiceert helemaal geen MSSP, dus alleen zo kan de vraag gesteld worden.</value> + </data> + <data name="ecosystem.lineages.none" xml:space="preserve"> + <value>Nog geen vermeld spel draait op een codebase die we in een afstamming plaatsen.</value> + </data> + <data name="ecosystem.lineages.notClassified" xml:space="preserve"> + <value>{count, plural, one {# van die spellen draait op een codebase} other {# van die spellen draaien op codebases}} die we in geen enkele afstamming plaatsen — verschillende zeggen dat zelf ook, door {family} te publiceren. Ze vallen binnen de noemer hierboven en in niemands aandeel.</value> + </data> + <data name="ecosystem.protocols.title" xml:space="preserve"> + <value>Protocollen</value> + </data> + <data name="ecosystem.protocols.floor" xml:space="preserve"> + <value>Lees elk gemeten cijfer hieronder als een ondergrens. We vragen MSSP met name aan, dus stilte daar is een antwoord. Om de rest hier wordt niet gevraagd, en een server kan een protocol ondersteunen zonder het ooit aan te bieden.</value> + </data> + <data name="ecosystem.mssp.instrument" xml:space="preserve"> + <value>{instrument} is de enige rij hieronder die geen ondergrens is: we vragen elke server er met name om, dus de spellen die het niet aanboden zijn gevraagd en hebben geweigerd. Het is ook de enige zonder opgegeven cijfer, want elk spel waarvan we het rapport hebben ondersteunt het bij wijze van bewijs, en een telling van de spellen die het ook vermeldden zou daartegen een gewoonte meten.</value> + </data> + <data name="ecosystem.mssp.gap" xml:space="preserve"> + <value>We hebben {reports, number} rapporten en {offered, plural, one {# spel biedt} other {# spellen bieden}} MSSP vandaag aan: de andere {gap, number} zijn gestopt met publiceren nadat we het gelezen hadden, en een rapport wordt niet weggegooid omdat het niet meer opnieuw uitgegeven wordt.</value> + </data> + <data name="ecosystem.protocols.caption" xml:space="preserve"> + <value>Protocoladoptie. Gemeten is wat een server aanbood in een voltooide handshake; opgegeven is wat zijn MSSP beweert. Twee verzamelingen spellen, dus twee noemers.</value> + </data> + <data name="ecosystem.column.protocol" xml:space="preserve"> + <value>protocol</value> + </data> + <data name="ecosystem.column.measured" xml:space="preserve"> + <value>gemeten — van {basis}</value> + </data> + <data name="ecosystem.column.declared" xml:space="preserve"> + <value>opgegeven — van {basis}</value> + </data> + <data name="ecosystem.measured.never" xml:space="preserve"> + <value>niet gemeten — nooit waargenomen</value> + </data> + <data name="ecosystem.measured.declined" xml:space="preserve"> + <value>{share} · {declined, plural, one {# spel weigerde toen we het vroegen} other {# spellen weigerden toen we het vroegen}}</value> + </data> + <data name="ecosystem.measured.unasked" xml:space="preserve"> + <value>{share} · {unobserved, plural, one {bij # spel niet aangeboden en niet gevraagd} other {bij # spellen niet aangeboden en niet gevraagd}}</value> + </data> + <data name="ecosystem.measured.declinedAndUnasked" xml:space="preserve"> + <value>{share} · {declined, plural, one {# spel weigerde toen we het vroegen} other {# spellen weigerden toen we het vroegen}} · {unobserved, plural, one {bij # spel niet aangeboden en niet gevraagd} other {bij # spellen niet aangeboden en niet gevraagd}}</value> + </data> + <data name="ecosystem.declared.none" xml:space="preserve"> + <value>niet gevraagd — elk rapport hier is het antwoord</value> + </data> + <data name="ecosystem.curve.title" xml:space="preserve"> + <value>Adoptie, in de loop van de tijd</value> + </data> + <data name="ecosystem.curve.caveat" xml:space="preserve"> + <value>Elk punt is een aandeel over de spellen die we die dag gemeten hadden, dus deze lijn beweegt om twee redenen: doordat een spel verandert wat het aanbiedt, en doordat de verzameling spellen die we kunnen meten eromheen verandert. Alleen het eerste is adoptie. De telling van veranderingen hieronder is het deel dat puur spellen zijn die van gedachten veranderen.</value> + </data> + <data name="ecosystem.curve.caption" xml:space="preserve"> + <value>Gemeten aandeel van elk protocol, oudste meting eerst</value> + </data> + <data name="ecosystem.curve.then" xml:space="preserve"> + <value>toen</value> + </data> + <data name="ecosystem.curve.now" xml:space="preserve"> + <value>nu</value> + </data> + <data name="ecosystem.curve.notMeasured" xml:space="preserve"> + <value>niet gemeten</value> + </data> + <data name="ecosystem.snapshot.title" xml:space="preserve"> + <value>Een momentopname, geen curve</value> + </data> + <data name="ecosystem.snapshot" xml:space="preserve"> + <value>Een momentopname van wat we nu kunnen meten. Een adoptiecurve zet spellen uit die van gedachten veranderen, en we leggen een verandering vast wanneer die gebeurt, dus de curve wordt tekenbaar zodra er genoeg vastgelegd zijn. Uitzetten wanneer we elk spel voor het eerst bereikten zou de crawl meten, niet de hobby.</value> + </data> + <data name="ecosystem.transitions" xml:space="preserve"> + <value>{count, plural, one {# wijziging in mogelijkheden} other {# wijzigingen in mogelijkheden}} tot nu toe vastgelegd — het materiaal waaruit een curve getekend wordt.</value> + </data> + <data name="ecosystem.transitions.none" xml:space="preserve"> + <value>Er is nog geen gemeten mogelijkheid veranderd, dus er valt niets uit te zetten.</value> + </data> + <data name="ecosystem.plain.denominators" xml:space="preserve"> + <value>Gemeten is van {measured}; opgegeven is van {declared}. Twee verzamelingen spellen, dus twee noemers.</value> + </data> + <data name="ecosystem.plain.counts" xml:space="preserve"> + <value>{listed} · {handshakes} · {mssp}.</value> + </data> + <data name="ecosystem.plain.oldestHandshake" xml:space="preserve"> + <value>De oudste handshake in dit beeld is {age} geleden voor het laatst bevestigd.</value> + </data> + <data name="ecosystem.plain.lineages" xml:space="preserve"> + <value>Dezelfde spellen, gegroepeerd naar de traditie waar hun server van afstamt. Dit is {evidence} — {meaning} — en niet iets wat een spel gepubliceerd heeft: geen enkel spel meldt ‘MUSH’, want MSSP kent die waarde niet en het grootste deel van de MUSH-wereld publiceert helemaal geen MSSP.</value> + </data> + <data name="ecosystem.plain.measured" xml:space="preserve"> + <value>gemeten: {value}</value> + </data> + <data name="ecosystem.plain.declared" xml:space="preserve"> + <value>opgegeven: {value}</value> + </data> + <data name="rankings.title" xml:space="preserve"> + <value>Ranglijsten</value> + </data> + <data name="rankings.noVote" xml:space="preserve"> + <value>Alleen berekend uit gemeten gegevens. Nooit stemmen, sterren of beoordelingen. Niets hier rangschikt kwaliteit. Die hebben we niet gemeten.</value> + </data> + <data name="rankings.busiest.title" xml:space="preserve"> + <value>Drukst, naar gemeten gelijktijdige spelers</value> + </data> + <data name="rankings.window.label" xml:space="preserve"> + <value>Ranglijstperiode</value> + </data> + <data name="rankings.span" xml:space="preserve"> + <value>{days, plural, one {# dag} other {# dagen}}</value> + </data> + <data name="rankings.basis.median" xml:space="preserve"> + <value>Mediaan van de spelerstellingen die we over de laatste {days, plural, one {# dag} other {# dagen}} gemeten hebben.</value> + </data> + <data name="rankings.basis.none" xml:space="preserve"> + <value>Nog geen spel heeft de {samples, number} tellingen over {days, plural, one {# dag} other {# dagen}} die een mediaan nodig heeft.</value> + </data> + <data name="rankings.basis.eligible" xml:space="preserve"> + <value>Van de {listed, number} spellen {eligible, plural, one {heeft # spel} other {hebben # spellen}} de {samples, number} tellingen over {days, plural, one {# dag} other {# dagen}} die daarvoor nodig zijn.</value> + </data> + <data name="rankings.basis.zero" xml:space="preserve"> + <value>Een gemeten nul telt mee; een onleesbare telling niet.</value> + </data> + <data name="rankings.spanChoice" xml:space="preserve"> + <value>Een week zegt wie er nu druk is; een kwartaal zegt wie druk is geweest. Dat zijn verschillende vragen, en een spel kan de ene aanvoeren en de andere niet. Dagen zijn hele dagen, UTC.</value> + </data> + <data name="rankings.busiest.empty" xml:space="preserve"> + <value>Nog geen vermeld spel heeft genoeg tellingen om te rangschikken — een uitspraak over hoe lang we al meten, niet over hoe druk het ergens is.</value> + </data> + <data name="rankings.busiest.caption" xml:space="preserve"> + <value>Spellen gerangschikt naar de mediaan van de spelerstellingen die we over de laatste {days, plural, one {# dag} other {# dagen}} gemeten hebben. Spellen met dezelfde mediaan delen een plaats; niets hier breekt de gelijkstand.</value> + </data> + <data name="rankings.column.place" xml:space="preserve"> + <value>#</value> + </data> + <data name="rankings.column.game" xml:space="preserve"> + <value>spel</value> + </data> + <data name="rankings.column.median" xml:space="preserve"> + <value>mediaan</value> + </data> + <data name="rankings.column.peak" xml:space="preserve"> + <value>piek</value> + </data> + <data name="rankings.column.samples" xml:space="preserve"> + <value>tellingen</value> + </data> + <data name="rankings.column.days" xml:space="preserve"> + <value>gemeten dagen</value> + </data> + <data name="rankings.spells.title" xml:space="preserve"> + <value>Langste ononderbroken bereikbaarheid</value> + </data> + <data name="rankings.spells.basis" xml:space="preserve"> + <value>Elke peiling sinds de genoemde datum trof het spel bereikbaar aan. Bereikbaar, niet ‘up’: we meten een socket vanaf één host, en een spel waarheen we geen route hebben is volkomen springlevend. Zo’n reeks kan niet langer zijn dan we al meekijken, dus de datum is het feit en de duur volgt daaruit.</value> + </data> + <data name="rankings.spells.empty" xml:space="preserve"> + <value>Geen vermeld spel zit op dit moment in een ononderbroken reeks bereikbaarheid.</value> + </data> + <data name="rankings.spells.caption" xml:space="preserve"> + <value>Spellen die bij elke peiling sinds de genoemde datum bereikbaar waren. Spellen die sinds dezelfde datum bereikbaar zijn delen een plaats; niets hier breekt de gelijkstand.</value> + </data> + <data name="rankings.column.since" xml:space="preserve"> + <value>bereikbaar sinds</value> + </data> + <data name="rankings.column.duration" xml:space="preserve"> + <value>dat is</value> + </data> + <data name="rankings.archivedNote" xml:space="preserve"> + <value>Gearchiveerde spellen staan buiten beide tabellen en verder niets; één geslaagde peiling zet ze terug.</value> + </data> + <data name="rankings.plain.busiest" xml:space="preserve"> + <value>Drukst — mediaan gemeten spelers, laatste {days, plural, one {# dag} other {# dagen}}</value> + </data> + <data name="rankings.plain.windows" xml:space="preserve"> + <value>periodes:</value> + </data> + <data name="rankings.plain.thisOne" xml:space="preserve"> + <value>deze</value> + </data> + <data name="rankings.plain.row" xml:space="preserve"> + <value>mediaan {median, number} · piek {peak, number} · {samples, plural, one {# telling} other {# tellingen}} over {days, number} van {window, number} dagen</value> + </data> + <data name="rankings.plain.spellRow" xml:space="preserve"> + <value>bereikbaar bij elke peiling sinds {date} · {duration}</value> + </data> + <data name="archive.title" xml:space="preserve"> + <value>Het archief</value> + </data> + <data name="archive.lede" xml:space="preserve"> + <value>Spellen die gestopt zijn met antwoorden. Er is niets verwijderd. Ze worden nog wekelijks gepeild, en één geslaagde peiling zet een spel diezelfde dag terug in de lijst.</value> + </data> + <data name="archive.search.legend" xml:space="preserve"> + <value>het archief doorzoeken</value> + </data> + <data name="archive.search.label" xml:space="preserve"> + <value>Gearchiveerde spellen zoeken</value> + </data> + <data name="archive.search.placeholder" xml:space="preserve"> + <value>naam, codebase of beschrijving</value> + </data> + <data name="archive.search.submit" xml:space="preserve"> + <value>tonen</value> + </data> + <data name="archive.count" xml:space="preserve"> + <value>{count, plural, =0 {Geen gearchiveerde spellen} one {# gearchiveerd spel} other {# gearchiveerde spellen}}</value> + </data> + <data name="archive.badge" xml:space="preserve"> + <value>gearchiveerd</value> + </data> + <data name="archive.lastReachable" xml:space="preserve"> + <value>laatst bereikbaar</value> + </data> + <data name="archive.knownLive" xml:space="preserve"> + <value>bekend live</value> + </data> + <data name="archive.darkFor" xml:space="preserve"> + <value>({age} geleden)</value> + </data> + <data name="archive.empty" xml:space="preserve"> + <value>Geen treffers.</value> + </data> + <data name="archive.neverReachable" xml:space="preserve"> + <value>nooit, in niets wat we gemeten hebben</value> + </data> + <data name="archive.noReachableTime" xml:space="preserve"> + <value>geen bereikbare tijd gemeten</value> + </data> + <data name="archive.darkFor.unknown" xml:space="preserve"> + <value>onbekend</value> + </data> + <data name="archive.knownLive.years" xml:space="preserve"> + <value>{years, number, ::.#} jaar</value> + </data> + <data name="archive.knownLive.days" xml:space="preserve"> + <value>{days, plural, one {# dag} other {# dagen}}</value> + </data> + <data name="archive.run" xml:space="preserve"> + <value>{from} – {to} · {span}</value> + </data> + <data name="archive.run.months" xml:space="preserve"> + <value>{count, plural, one {# maand} other {# maanden}}</value> + </data> + <data name="archive.run.years" xml:space="preserve"> + <value>{count, plural, one {# jaar} other {# jaar}}</value> + </data> + <data name="archive.plain.matching" xml:space="preserve"> + <value>{count, plural, one {# spel dat overeenkomt met ‘{query}’} other {# spellen die overeenkomen met ‘{query}’}}</value> + </data> + <data name="archive.plain.count" xml:space="preserve"> + <value>{count, plural, one {# spel} other {# spellen}}</value> + </data> + <data name="archive.plain.lastReachable" xml:space="preserve"> + <value>Laatst bereikbaar:</value> + </data> + <data name="archive.plain.knownLive" xml:space="preserve"> + <value>Bekend live:</value> + </data> + <data name="archive.plain.knownLiveValue" xml:space="preserve"> + <value>{value} van de gemeten bereikbare tijd</value> + </data> + <data name="archive.plain.run" xml:space="preserve"> + <value>Looptijd:</value> + </data> + <data name="archive.plain.codebase" xml:space="preserve"> + <value>Codebase:</value> + </data> + <data name="footer.randomGame" xml:space="preserve"> + <value>willekeurig spel</value> + </data> + <data name="trend.day.counted" xml:space="preserve"> + <value>{d, date, medium} — gemiddeld {typical}, {low}–{high} over {probes, plural, one {# peiling} other {# peilingen}}</value> + </data> + <data name="trend.day.flat" xml:space="preserve"> + <value>{d, date, medium} — {count, plural, =0 {0 spelers} one {# speler} other {# spelers}}, bij elk van {probes, plural, one {# peiling} other {# peilingen}}</value> + </data> + <data name="trend.day.notCounted" xml:space="preserve"> + <value>{d, date, medium} — gepeild, geen telling kon worden gelezen</value> + </data> + <data name="trend.day.notMeasured" xml:space="preserve"> + <value>{d, date, medium} — geen meting</value> + </data> + <data name="trend.summary" xml:space="preserve"> + <value>Typisch {typical} verbonden, met een piek van {peak}, over {counted} van {days, plural, one {# dag} other {# dagen}}.</value> + </data> + <data name="trend.direction.steady" xml:space="preserve"> + <value>Gelijkmatig over het hele bereik.</value> + </data> + <data name="trend.direction.up" xml:space="preserve"> + <value>Ongeveer {change, number, percent} omhoog van het begin van het bereik tot het eind.</value> + </data> + <data name="trend.direction.down" xml:space="preserve"> + <value>Ongeveer {change, number, percent} omlaag van het begin van het bereik tot het eind.</value> + </data> + <data name="trend.none.probed" xml:space="preserve"> + <value>In dit bereik gepeild, en uit niets ervan kon een spelerstelling worden gelezen.</value> + </data> + <data name="trend.none.notMeasured" xml:space="preserve"> + <value>Geen meting in dit bereik.</value> + </data> + <data name="trend.empty" xml:space="preserve"> + <value>Niets geteld in dit bereik.</value> + </data> + <data name="trend.week.span" xml:space="preserve"> + <value>{from, date, d MMM}–{to, date, d MMM}</value> + </data> + <data name="trend.week.oneDay" xml:space="preserve"> + <value>{d, date, d MMM}</value> + </data> + <data name="trend.week.counted" xml:space="preserve"> + <value>{span}: typisch {typical}, piek {peak}, {days, plural, one {# dag} other {# dagen}} geteld</value> + </data> + <data name="trend.week.notCounted" xml:space="preserve"> + <value>{span}: gepeild, geen telling kon worden gelezen</value> + </data> + <data name="trend.week.notMeasured" xml:space="preserve"> + <value>{span}: niet gemeten</value> + </data> + <data name="trend.week.uncounted" xml:space="preserve"> + <value>{count, plural, one {# dag gepeild zonder telling} other {# dagen gepeild zonder telling}}</value> + </data> + <data name="trend.week.unmeasured" xml:space="preserve"> + <value>{count, plural, one {# dag niet gemeten} other {# dagen niet gemeten}}</value> + </data> + <data name="trend.week.and" xml:space="preserve"> + <value>{line}, {clause}</value> + </data> + <data name="trend.range" xml:space="preserve"> + <value>dagen in UTC · {from, date, medium} – {to, date, medium}</value> + </data> + <data name="trend.ceiling" xml:space="preserve"> + <value>{value} bovenaan</value> + </data> + <data name="trend.counted" xml:space="preserve"> + <value>{counted} van {days, plural, one {# dag} other {# dagen}} geteld</value> + </data> + <data name="trend.axis.month" xml:space="preserve"> + <value>{d, date, MMM}</value> + </data> + <data name="trend.axis.monthYear" xml:space="preserve"> + <value>{d, date, MMM yyyy}</value> + </data> + <data name="trend.legend.mean" xml:space="preserve"> + <value>gemiddelde van de tellingen die we die dag lazen</value> + </data> + <data name="trend.legend.peak" xml:space="preserve"> + <value>tot aan de drukste telling van die dag</value> + </data> + <data name="trend.legend.band" xml:space="preserve"> + <value>laagste tot hoogste telling van die dag</value> + </data> + <data name="trend.legend.notCounted" xml:space="preserve"> + <value>gepeild, geen telling kon worden gelezen</value> + </data> + <data name="trend.legend.notMeasured.bar" xml:space="preserve"> + <value>niet gemeten — helemaal geen balk</value> + </data> + <data name="trend.legend.notMeasured.line" xml:space="preserve"> + <value>niet gemeten — een onderbreking in de lijn</value> + </data> + <data name="trend.spans.label" xml:space="preserve"> + <value>Trendbereik</value> + </data> + <data name="trend.shapes.label" xml:space="preserve"> + <value>Trendvorm</value> + </data> + <data name="trend.preset" xml:space="preserve"> + <value>{days, plural, one {# dag} other {# dagen}}</value> + </data> + <data name="trend.earlier" xml:space="preserve"> + <value>← eerder</value> + </data> + <data name="trend.later" xml:space="preserve"> + <value>later →</value> + </data> + <data name="trend.shape.line" xml:space="preserve"> + <value>lijn</value> + </data> + <data name="trend.shape.bar" xml:space="preserve"> + <value>staven</value> + </data> + <data name="trend.plain.heading" xml:space="preserve"> + <value>Hoeveel, in de loop van de tijd</value> + </data> + <data name="trend.plain.range" xml:space="preserve"> + <value>{from, date, medium} – {to, date, medium}, UTC</value> + </data> + <data name="trend.plain.earlier" xml:space="preserve"> + <value>eerder</value> + </data> + <data name="trend.plain.note" xml:space="preserve"> + <value>een week wordt samengevat over de dagen erin die we geteld hebben; een week zonder zegt dat</value> + </data> + <data name="reach.kicker" xml:space="preserve"> + <value>bereikbaar · laatste {days, plural, one {# dag} other {# dagen}}</value> + </data> + <data name="reach.stat.reachable" xml:space="preserve"> + <value>bereikbaar</value> + </data> + <data name="reach.stat.longestOutage" xml:space="preserve"> + <value>langste onderbreking</value> + </data> + <data name="reach.stat.lastCause" xml:space="preserve"> + <value>laatste oorzaak</value> + </data> + <data name="reach.noOutage" xml:space="preserve"> + <value>geen in de periode</value> + </data> + <data name="reach.noCause" xml:space="preserve"> + <value>niets vastgelegd</value> + </data> + <data name="reach.scale.ago" xml:space="preserve"> + <value>{days, plural, one {# dag geleden} other {# dagen geleden}}</value> + </data> + <data name="reach.scale.today" xml:space="preserve"> + <value>vandaag</value> + </data> + <data name="reach.legend.reachable" xml:space="preserve"> + <value>bereikbaar</value> + </data> + <data name="reach.legend.degraded" xml:space="preserve"> + <value>haperend — antwoordde, kon niet afronden</value> + </data> + <data name="reach.legend.unreachable" xml:space="preserve"> + <value>onbereikbaar</value> + </data> + <data name="reach.legend.notMeasured" xml:space="preserve"> + <value>niet gemeten</value> + </data> + <data name="reach.word.reachable" xml:space="preserve"> + <value>bereikbaar</value> + </data> + <data name="reach.word.degraded" xml:space="preserve"> + <value>haperend</value> + </data> + <data name="reach.word.unreachable" xml:space="preserve"> + <value>onbereikbaar</value> + </data> + <data name="reach.word.notMeasured" xml:space="preserve"> + <value>niet gemeten</value> + </data> + <data name="reach.day.reachable" xml:space="preserve"> + <value>{d, date, d MMM} — de hele dag bereikbaar</value> + </data> + <data name="reach.day.degraded" xml:space="preserve"> + <value>{d, date, d MMM} — haperend ({cause}): antwoordde, kon niet afronden</value> + </data> + <data name="reach.day.unreachable" xml:space="preserve"> + <value>{d, date, d MMM} — onbereikbaar ({cause})</value> + </data> + <data name="reach.day.notMeasured" xml:space="preserve"> + <value>{d, date, d MMM} — niet gemeten; we volgden dit spel toen nog niet</value> + </data> + <data name="reach.none" xml:space="preserve"> + <value>{days, plural, one {Nog niet gemeten over de laatste # dag.} other {Nog niet gemeten over de laatste # dagen.}}</value> + </data> + <data name="reach.fraction.window" xml:space="preserve"> + <value>Bereikbaar {percent} van de laatste {days, plural, one {# dag} other {# dagen}}.</value> + </data> + <data name="reach.fraction.measured" xml:space="preserve"> + <value>Bereikbaar {percent} van de {days, plural, one {# dag} other {# dagen}} die we gemeten hebben.</value> + </data> + <data name="reach.fraction.unknown" xml:space="preserve"> + <value>{days, plural, one {De bereikbaarheid over de laatste # dag is nog niet gemeten.} other {De bereikbaarheid over de laatste # dagen is nog niet gemeten.}}</value> + </data> + <data name="reach.unreachable.noneInWindow" xml:space="preserve"> + <value>Geen enkele dag in de periode was onbereikbaar.</value> + </data> + <data name="reach.unreachable.noneMeasured" xml:space="preserve"> + <value>Geen enkele dag die we gemeten hebben was onbereikbaar.</value> + </data> + <data name="reach.unreachable.days" xml:space="preserve"> + <value>{count, plural, one {# dag onbereikbaar.} other {# dagen onbereikbaar.}}</value> + </data> + <data name="reach.degraded.days" xml:space="preserve"> + <value>{count, plural, one {# dag haperend — we kwamen binnen en konden niet afronden.} other {# dagen haperend — we kwamen binnen en konden niet afronden.}}</value> + </data> + <data name="reach.longestOutage" xml:space="preserve"> + <value>Langste onderbreking {duration}.</value> + </data> + <data name="reach.longestOutage.cause" xml:space="preserve"> + <value>Langste onderbreking {duration} ({cause}).</value> + </data> + <data name="reach.predate" xml:space="preserve"> + <value>{count, plural, one {# dag ligt vóór alles wat we gemeten hebben.} other {# dagen liggen vóór alles wat we gemeten hebben.}}</value> + </data> + <data name="reach.spell.range" xml:space="preserve"> + <value>{from, date, d MMM} – {to, date, d MMM}</value> + </data> + <data name="reach.spell.oneDay" xml:space="preserve"> + <value>{d, date, d MMM}</value> + </data> + <data name="reach.spell" xml:space="preserve"> + <value>{range}: {count, plural, one {# dag} other {# dagen}} {word}</value> + </data> + <data name="reach.spell.cause" xml:space="preserve"> + <value>{range}: {count, plural, one {# dag} other {# dagen}} {word} ({cause})</value> + </data> + <data name="reach.plain.heading" xml:space="preserve"> + <value>Bereikbaar</value> + </data> + <data name="reach.plain.window" xml:space="preserve"> + <value>{days, plural, one {laatste # dag} other {laatste # dagen}}</value> + </data> + <data name="reach.plain.fraction" xml:space="preserve"> + <value>Bereikbaar: {percent} van de {days, plural, one {laatste # dag} other {laatste # dagen}}</value> + </data> + <data name="reach.plain.longestOutage" xml:space="preserve"> + <value>Langste onderbreking: {duration}</value> + </data> + <data name="cause.dns" xml:space="preserve"> + <value>dns loste niet op</value> + </data> + <data name="cause.refused" xml:space="preserve"> + <value>verbinding geweigerd</value> + </data> + <data name="cause.tls" xml:space="preserve"> + <value>tls mislukt</value> + </data> + <data name="cause.timeout" xml:space="preserve"> + <value>time-out</value> + </data> + <data name="cause.handshakeStalled" xml:space="preserve"> + <value>handshake liep vast</value> + </data> + <data name="cause.none" xml:space="preserve"> + <value>geen oorzaak vastgelegd</value> + </data> + <data name="ansi.suppressed" xml:space="preserve"> + <value>De eigenaar heeft ons gevraagd het verbindingsscherm van dit spel niet opnieuw te publiceren.</value> + </data> + <data name="ansi.absent" xml:space="preserve"> + <value>Van dit spel is geen verbindingsscherm vastgelegd.</value> + </data> + <data name="ansi.tooSmall" xml:space="preserve"> + <value>{count, plural, one {Er kwam maar # rij terug — te weinig om te tonen.} other {Er kwamen maar # rijen terug — te weinig om te tonen.}}</value> + </data> + <data name="ansi.asSent" xml:space="preserve"> + <value>zoals verzonden door de server</value> + </data> + <data name="ansi.size" xml:space="preserve"> + <value>{columns}×{rows}</value> + </data> + <data name="ansi.size.doubleWidth" xml:space="preserve"> + <value>{columns}×{rows}, dubbele breedte</value> + </data> + <data name="ansi.depth.colour" xml:space="preserve"> + <value>16-kleuren SGR</value> + </data> + <data name="ansi.depth.plain" xml:space="preserve"> + <value>geen kleur</value> + </data> + <data name="ansi.readAs" xml:space="preserve"> + <value>gelezen als {charset}</value> + </data> + <data name="ansi.captured" xml:space="preserve"> + <value>vastgelegd</value> + </data> + <data name="ansi.frozen" xml:space="preserve"> + <value>bevroren — het laatste scherm dat we zagen</value> + </data> + <data name="ansi.alt.named" xml:space="preserve"> + <value>ASCII-kunst: het verbindingsscherm van {game}. De tekst ervan staat onder ‘als tekst lezen’, hieronder.</value> + </data> + <data name="ansi.alt" xml:space="preserve"> + <value>ASCII-kunst: het verbindingsscherm van dit spel. De tekst ervan staat onder ‘als tekst lezen’, hieronder.</value> + </data> + <data name="ansi.plain.rows" xml:space="preserve"> + <value>{count, plural, one {verbindingsscherm: # regel, alleen tekst} other {verbindingsscherm: # regels, alleen tekst}}</value> + </data> + <data name="ansi.plain.rows.readAs" xml:space="preserve"> + <value>{count, plural, one {verbindingsscherm: # regel, alleen tekst, gelezen als {charset}} other {verbindingsscherm: # regels, alleen tekst, gelezen als {charset}}}</value> + </data> + <data name="capability.disagree.declaredNotOffered" xml:space="preserve"> + <value>het spel geeft het op, en de server heeft het nooit aangeboden in een handshake.</value> + </data> + <data name="capability.disagree.offeredNotDeclared" xml:space="preserve"> + <value>de server biedt het aan, en het spel zegt in zijn eigen opgave van niet.</value> + </data> + <data name="capability.disagree.note" xml:space="preserve"> + <value>Meestal een verouderd, met de hand ingetypt veld, geen leugen. Getoond omdat een client niet moet vertrouwen op datgene waarover de twee van elkaar afwijken.</value> + </data> + <data name="game.notFound" xml:space="preserve"> + <value>Niet gevonden</value> + </data> + <data name="game.notFound.hint" xml:space="preserve"> + <value>Geen spel op dit adres. Controleer de spelling.</value> + </data> + <data name="game.endpoint.lastAnswered" xml:space="preserve"> + <value>laatst geantwoord</value> + </data> + <data name="game.stale" xml:space="preserve"> + <value>{count, plural, one {# is voorbij zijn verversingstermijn. Oud, niet fout.} other {# zijn voorbij hun verversingstermijn. Oud, niet fout.}}</value> + </data> + <data name="game.referrals.lists" xml:space="preserve"> + <value>De eigen verwijzingslijst van dit spel noemt:</value> + </data> + <data name="game.referrals.listedBy" xml:space="preserve"> + <value>Genoemd door de verwijzingslijst van:</value> + </data> + <data name="game.referral.since" xml:space="preserve"> + <value>sinds {date}</value> + </data> + <data name="game.referral.dropped" xml:space="preserve"> + <value>niet meer vermeld, laatst gezien</value> + </data> + <data name="game.archived.lastAnswered" xml:space="preserve"> + <value>Laatst geantwoord op {date}, {ago} geleden.</value> + </data> + <data name="game.archived.stillProbed" xml:space="preserve"> + <value>Wordt nog wekelijks gepeild; deze pagina wordt bijgewerkt op de dag dat het antwoordt.</value> + </data> + <data name="game.archived.knownLive" xml:space="preserve"> + <value>{span} bekend live</value> + </data> + <data name="game.excluded" xml:space="preserve"> + <value>Niet in de lijst, de ranglijsten of het dagcijfer: we denken niet dat dit adres een spel is dat iemand kan spelen. Alles hieronder is wat het ons vertelde, ongewijzigd.</value> + </data> + <data name="game.excluded.reason" xml:space="preserve"> + <value>Onze reden: {why}</value> + </data> + <data name="game.unlisted" xml:space="preserve"> + <value>Niet in de lijst, de ranglijsten of het dagcijfer, op verzoek van de mensen die het draaien. Alles hieronder is bewaard zoals het was, deze pagina en elk adres dat het ooit gehad heeft blijven antwoorden, en we kloppen er niet aan.</value> + </data> + <data name="game.plain.playersNow" xml:space="preserve"> + <value>Spelers nu: {count}</value> + </data> + <data name="game.plain.capabilities" xml:space="preserve"> + <value>Mogelijkheden ({disagreeing} van {total} wijken af)</value> + </data> + <data name="game.plain.declared" xml:space="preserve"> + <value>Opgegeven door het spel</value> + </data> + <data name="game.plain.connectScreen" xml:space="preserve"> + <value>Verbindingsscherm</value> + </data> + <data name="game.plain.whatChanged" xml:space="preserve"> + <value>Wat er veranderd is</value> + </data> + <data name="game.plain.measured" xml:space="preserve"> + <value>gemeten</value> + </data> + <data name="game.plain.declared.column" xml:space="preserve"> + <value>opgegeven</value> + </data> + <data name="game.plain.disagree" xml:space="preserve"> + <value>** wijkt af</value> + </data> + <data name="listing.row.connected" xml:space="preserve"> + <value>verbonden</value> + </data> + <data name="listing.row.reached" xml:space="preserve"> + <value>bereikt</value> + </data> + <data name="facet.group.search" xml:space="preserve"> + <value>zoeken</value> + </data> + <data name="facet.group.archived" xml:space="preserve"> + <value>gearchiveerd</value> + </data> + <data name="facet.group.adult" xml:space="preserve"> + <value>voor volwassenen</value> + </data> + <data name="facet.value.included" xml:space="preserve"> + <value>opgenomen</value> + </data> + <data name="game.count.none" xml:space="preserve"> + <value>geen telling</value> + </data> + <data name="game.count.none.why" xml:space="preserve"> + <value>geen actuele telling, en niets hier zegt waarom</value> + </data> + <data name="game.plain.playersNoCount" xml:space="preserve"> + <value>Spelers nu: geen telling (niets hier zegt waarom)</value> + </data> + <data name="crawler.live" xml:space="preserve"> + <value>crawler actief · laatste peiling {age}</value> + </data> + <data name="crawler.quiet" xml:space="preserve"> + <value>crawler wacht · laatste peiling {age}</value> + </data> + <data name="crawler.noProbe" xml:space="preserve"> + <value>hier is nog geen peiling afgerond</value> + </data> + <data name="crawler.cycle.nothingDue" xml:space="preserve"> + <value>niets aan de beurt deze cyclus</value> + </data> + <data name="crawler.cycle" xml:space="preserve"> + <value>{considered, plural, one {# aan de beurt} other {# aan de beurt}} · {answered, plural, one {# beantwoord} other {# beantwoord}} · {failed, plural, one {# mislukt} other {# mislukt}}</value> + </data> + <data name="crawler.registry" xml:space="preserve"> + <value>{targets, plural, one {# adres in het register} other {# adressen in het register}}, {due, plural, one {# nu aan de beurt} other {# nu aan de beurt}}</value> + </data> + <data name="preview.documentTitle" xml:space="preserve"> + <value>{page} — {site}</value> + </data> + <data name="preview.site" xml:space="preserve"> + <value>Een gids voor de MU*-hobby — MUSHes, MUDs, MUCKs, MOOs — waar elk feit vermeldt hoe het verkregen is en hoe oud het is.</value> + </data> + <data name="preview.demo" xml:space="preserve"> + <value>Demogegevens — niets hiervan is gemeten. {description}</value> + </data> + <data name="preview.cardAlt" xml:space="preserve"> + <value>{site} — gemeten, niet beweerd</value> + </data> + <data name="preview.cardAlt.named" xml:space="preserve"> + <value>{title} op {site}</value> + </data> + <data name="preview.title.games" xml:space="preserve"> + <value>Spellen</value> + </data> + <data name="preview.title.archive" xml:space="preserve"> + <value>Het archief</value> + </data> + <data name="preview.title.rankings" xml:space="preserve"> + <value>Ranglijsten</value> + </data> + <data name="preview.title.ecosystem" xml:space="preserve"> + <value>Het ecosysteem</value> + </data> + <data name="preview.title.reference" xml:space="preserve"> + <value>Naslag</value> + </data> + <data name="preview.title.about" xml:space="preserve"> + <value>Over</value> + </data> + <data name="preview.title.notFound" xml:space="preserve"> + <value>Niet gevonden</value> + </data> + <data name="preview.title.random" xml:space="preserve"> + <value>Willekeurig spel</value> + </data> + <data name="preview.title.account" xml:space="preserve"> + <value>Je spellen</value> + </data> + <data name="preview.title.claim" xml:space="preserve"> + <value>{game} claimen</value> + </data> + <data name="preview.desc.games" xml:space="preserve"> + <value>Elke MU* die we bereikt hebben, gefacetteerd op onze metingen: codebase, protocollen uit de handshake, TLS, codering, taal, laatst gezien.</value> + </data> + <data name="preview.desc.archive" xml:space="preserve"> + <value>Stilgevallen spellen, bewaard. Elk houdt zijn pagina, geschiedenis en URL, wordt wekelijks gepeild en keert terug in de lijst bij één geslaagde verbinding.</value> + </data> + <data name="preview.desc.rankings" xml:space="preserve"> + <value>Drukst, best bereikbaar, langst draaiend — alleen berekend uit metingen. Nergens op deze site stemmen, sterren of beoordelingen.</value> + </data> + <data name="preview.desc.ecosystem" xml:space="preserve"> + <value>Aandeel per codebase en protocoladoptie over de spellen die we meten, met wat servers aanbieden naast wat ze opgeven. Aandelen, nooit totalen.</value> + </data> + <data name="preview.desc.reference" xml:space="preserve"> + <value>Met de hand geschreven pagina’s over de codebases, clients en protocollen van de MU*-hobby, met verwijzingen naar tellingen uit de crawl.</value> + </data> + <data name="preview.desc.about" xml:space="preserve"> + <value>Hoe deze catalogus gebouwd wordt: wat de crawler doet, wat hij weigert te doen, en hoe hij te stoppen is.</value> + </data> + <data name="preview.desc.notFound" xml:space="preserve"> + <value>Geen spel op dit adres. Hier wordt nooit iets verwijderd, dus een spel dat ooit op deze URL stond, staat er nog — controleer de spelling.</value> + </data> + <data name="preview.desc.random" xml:space="preserve"> + <value>Eén spel uit de catalogus, willekeurig gekozen en nooit twee keer hetzelfde.</value> + </data> + <data name="preview.desc.account" xml:space="preserve"> + <value>De vermeldingen die je geclaimd hebt, en wat je met een claim kunt wijzigen.</value> + </data> + <data name="preview.desc.claim" xml:space="preserve"> + <value>Bewijs dat je dit spel draait door een token te publiceren waar alleen wie het draait het kan neerzetten.</value> + </data> + <data name="preview.game.archived" xml:space="preserve"> + <value>Gearchiveerd — laatst bereikbaar {age}, en wordt nog gepeild</value> + </data> + <data name="preview.game.archived.undated" xml:space="preserve"> + <value>Gearchiveerd, en wordt nog gepeild</value> + </data> + <data name="preview.game.countUnknown" xml:space="preserve"> + <value>Spelerstelling onbekend — het spel antwoordt en publiceert geen getal dat wij kunnen lezen</value> + </data> + <data name="preview.game.count" xml:space="preserve"> + <value>{count, plural, one {# speler} other {# spelers}}, {how} {age}</value> + </data> + <data name="feed.plain.newlyDiscovered" xml:space="preserve"> + <value>Nieuw ontdekt</value> + </data> + <data name="feed.plain.wentDark" xml:space="preserve"> + <value>Stilgevallen</value> + </data> + <data name="feed.plain.cameBack" xml:space="preserve"> + <value>Weer terug</value> + </data> + <data name="home.plain.known" xml:space="preserve"> + <value>{count, plural, one {# bekend spel} other {# bekende spellen}}</value> + </data> + <data name="home.plain.connectedNow" xml:space="preserve"> + <value>{count, plural, one {# nu verbonden (gemeten)} other {# nu verbonden (gemeten)}}</value> + </data> + <data name="home.plain.uncounted" xml:space="preserve"> + <value>{count, plural, one {# antwoordt, ongeteld} other {# antwoorden, ongeteld}}</value> + </data> + <data name="home.plain.archived" xml:space="preserve"> + <value>{count, plural, one {# gearchiveerd, wordt nog gepeild} other {# gearchiveerd, worden nog gepeild}}</value> + </data> + <data name="reference.title" xml:space="preserve"> + <value>Naslag</value> + </data> + <data name="reference.lede" xml:space="preserve"> + <value>Wat de codebases zijn, wat de clients doen, en wat de protocollen betekenen. Met de hand geschreven en in de repository naast de crawler bewaard — geen wiki, en er valt op deze pagina niets te bewerken. Elk {number} hier is iets anders: het komt uit de catalogus en wordt opnieuw berekend telkens als de pagina geladen wordt.</value> + </data> + <data name="reference.lede.number" xml:space="preserve"> + <value>getal</value> + </data> + <data name="reference.plain.lede" xml:space="preserve"> + <value>Met de hand geschreven, door één auteur, en van versies voorzien in git. De tekst hier is van ons; elk getal ernaast is door de crawler gemeten en wordt bij elk verzoek opnieuw berekend. Dit is geen wiki, en vanaf deze pagina is er niets te bewerken.</value> + </data> + <data name="reference.section.orientation" xml:space="preserve"> + <value>Begin hier</value> + </data> + <data name="reference.section.codebase" xml:space="preserve"> + <value>Codebases</value> + </data> + <data name="reference.section.client" xml:space="preserve"> + <value>Clients</value> + </data> + <data name="reference.section.protocol" xml:space="preserve"> + <value>Protocollen</value> + </data> + <data name="reference.kind.orientation" xml:space="preserve"> + <value>oriëntatie</value> + </data> + <data name="reference.kind.codebase" xml:space="preserve"> + <value>codebase</value> + </data> + <data name="reference.kind.client" xml:space="preserve"> + <value>client</value> + </data> + <data name="reference.kind.protocol" xml:space="preserve"> + <value>protocol</value> + </data> + <data name="reference.notFound.title" xml:space="preserve"> + <value>Niet gevonden</value> + </data> + <data name="reference.notFound.body" xml:space="preserve"> + <value>Hier staat geen naslagpagina. Dit onderdeel is met de hand geschreven, dus een gat is werk dat niemand gedaan heeft en niet iets wat verwijderd is — {index}.</value> + </data> + <data name="reference.notFound.index" xml:space="preserve"> + <value>kijk wat er wel is</value> + </data> + <data name="reference.codebase.heading" xml:space="preserve"> + <value>Spellen die erop draaien</value> + </data> + <data name="reference.codebase.none" xml:space="preserve"> + <value>We hebben er nog geen vastgesteld. Dat is een feit over wat deze crawler gemeten heeft, niet over wat er bestaat — een spel dat we niet bereikt hebben, of waarvan we de codebase niet konden lezen, telt hier niet mee.</value> + </data> + <data name="reference.codebase.listed" xml:space="preserve"> + <value>{count, plural, one {# vermeld} other {# vermeld}}</value> + </data> + <data name="reference.codebase.archived" xml:space="preserve"> + <value>{count, plural, one {# gearchiveerd} other {# gearchiveerd}}</value> + </data> + <data name="reference.measuredNeverAsserted" xml:space="preserve"> + <value>gemeten, nooit beweerd</value> + </data> + <data name="reference.codebase.note" xml:space="preserve"> + <value>Geteld uit de catalogus bij dit verzoek, over hetzelfde filter als de link hierboven — dus dit getal en die lijst zijn één zoekopdracht en kunnen niet uit elkaar lopen.</value> + </data> + <data name="reference.codebase.offered" xml:space="preserve"> + <value>aangeboden in hun handshakes: {protocols}</value> + </data> + <data name="reference.protocol.heading" xml:space="preserve"> + <value>Gemeten adoptie</value> + </data> + <data name="reference.protocol.none" xml:space="preserve"> + <value>Nog niets gemeten.</value> + </data> + <data name="reference.protocol.share" xml:space="preserve"> + <value>van {listed, plural, one {# vermeld spel} other {# vermelde spellen}} — {percent}</value> + </data> + <data name="reference.protocol.remainder" xml:space="preserve"> + <value>De spellen die hier niet meetellen zijn geen spellen zonder het protocol. Een spel telt mee wanneer we zijn server de optie in een handshake hebben zien aanbieden; de rest zijn servers die het ons niet aangeboden hebben en servers waarvan we de handshake niet gelezen hebben, en welke van beide het is kunnen we niet zeggen.</value> + </data> + <data name="reference.protocol.caption" xml:space="preserve"> + <value>Spellen die we {protocol} in een handshake hebben zien aanbieden, naar de codebase waarvan we vaststelden dat ze erop draaien.</value> + </data> + <data name="reference.protocol.column.codebase" xml:space="preserve"> + <value>codebase</value> + </data> + <data name="reference.protocol.column.offered" xml:space="preserve"> + <value>bood het aan</value> + </data> + <data name="reference.protocol.column.identified" xml:space="preserve"> + <value>vastgesteld</value> + </data> + <data name="reference.seeAlso" xml:space="preserve"> + <value>Zie ook</value> + </data> + <data name="reference.capabilities.heading" xml:space="preserve"> + <value>Mogelijkheden</value> + </data> + <data name="reference.capabilities.established" xml:space="preserve"> + <value>{count, plural, one {# van de {total} vastgesteld uit de eigen documentatie van het project} other {# van de {total} vastgesteld uit de eigen documentatie van het project}}</value> + </data> + <data name="reference.capabilities.caveat" xml:space="preserve"> + <value>Afgelezen uit de eigen documentatie van elk project, niet door ons gemeten — een client heeft geen handshake die wij kunnen waarnemen. ‘{unknown}’ betekent dat we gekeken hebben en het niet vastgesteld hebben. Het betekent nooit nee.</value> + </data> + <data name="reference.capabilities.caption" xml:space="preserve"> + <value>Mogelijkheden van clients, elk afgelezen uit de eigen documentatie van het project. Onbekend betekent dat we het niet vastgesteld hebben, en nooit dat de client het mist.</value> + </data> + <data name="reference.capabilities.column.documented" xml:space="preserve"> + <value>gedocumenteerd</value> + </data> + <data name="reference.capabilities.column.source" xml:space="preserve"> + <value>bron</value> + </data> + <data name="reference.capabilities.noSource" xml:space="preserve"> + <value>we hebben er geen gevonden</value> + </data> + <data name="reference.capability.yes" xml:space="preserve"> + <value>ja</value> + </data> + <data name="reference.capability.no" xml:space="preserve"> + <value>nee</value> + </data> + <data name="reference.capability.unknown" xml:space="preserve"> + <value>onbekend</value> + </data> + <data name="reference.plain.runsOn" xml:space="preserve"> + <value>Draait op: {platforms}</value> + </data> + <data name="reference.plain.codebase.heading" xml:space="preserve"> + <value>Spellen waarvan we vastgesteld hebben dat ze op deze codebase draaien</value> + </data> + <data name="reference.plain.codebase.none" xml:space="preserve"> + <value>Nog geen. Dat is een uitspraak over wat we gemeten hebben, niet over wat er bestaat — een spel dat we niet bereikt hebben, of waarvan we de codebase niet konden lezen, telt hier niet mee.</value> + </data> + <data name="reference.plain.codebase.counts" xml:space="preserve"> + <value>{listed, plural, one {# vermeld} other {# vermeld}}, {archived, plural, one {# gearchiveerd} other {# gearchiveerd}}</value> + </data> + <data name="reference.plain.codebase.offered" xml:space="preserve"> + <value>Gemeten in hun handshakes: {protocols}</value> + </data> + <data name="reference.plain.codebase.nothingOffered" xml:space="preserve"> + <value>In geen enkele handshake die we van hen gelezen hebben, is er iets aangeboden.</value> + </data> + <data name="reference.plain.protocol.share" xml:space="preserve"> + <value>{offering} van {listed, plural, one {# vermeld spel} other {# vermelde spellen}} hebben we het zien aanbieden ({percent})</value> + </data> + <data name="reference.plain.protocol.byCodebase" xml:space="preserve"> + <value>Naar codebase, van de spellen die we hebben vastgesteld</value> + </data> + <data name="reference.plain.protocol.row" xml:space="preserve"> + <value>{offering} van {identified} boden het aan</value> + </data> + <data name="reference.plain.capabilities.unknown" xml:space="preserve"> + <value>{count, plural, one {# van de {total} rijen is onbekend} other {# van de {total} rijen zijn onbekend}}: we hebben in de eigen documentatie van het project niets gevonden dat het een of het ander zegt. Een korte eerlijke tabel is beter dan een lange geraden.</value> + </data> + <data name="account.title" xml:space="preserve"> + <value>Je spellen</value> + </data> + <data name="account.noDatabase" xml:space="preserve"> + <value>Accounts vereisen een database, en deze site draait op de demofixture.</value> + </data> + <data name="account.signInButton" xml:space="preserve"> + <value>Inloggen</value> + </data> + <data name="account.signedInAs" xml:space="preserve"> + <value>Ingelogd als {name}.</value> + </data> + <data name="account.signOut" xml:space="preserve"> + <value>Uitloggen</value> + </data> + <data name="account.empty.body" xml:space="preserve"> + <value>Je hebt nog niets geclaimd. Zoek je spel op in {listing} en druk op zijn pagina op {claimControl}.</value> + </data> + <data name="account.empty.listing" xml:space="preserve"> + <value>de lijst</value> + </data> + <data name="account.empty.claimControl" xml:space="preserve"> + <value>dit spel claimen</value> + </data> + <data name="account.resigned.lead" xml:space="preserve"> + <value>Afstand gedaan.</value> + </data> + <data name="account.resigned.body" xml:space="preserve"> + <value>Het blijft vastgelegd, en je kunt altijd opnieuw aantonen dat je de controle hebt door een nieuw token te publiceren.</value> + </data> + <data name="account.saved.lead" xml:space="preserve"> + <value>Opgeslagen.</value> + </data> + <data name="account.saved.thatGame" xml:space="preserve"> + <value>Dat spel</value> + </data> + <data name="account.saved.fields" xml:space="preserve"> + <value>De pagina van {game} toont het nu als opgegeven door de eigenaar.</value> + </data> + <data name="account.saved.screenHidden" xml:space="preserve"> + <value>We publiceren het verbindingsscherm van {game} niet meer opnieuw. De pagina zegt dat met zoveel woorden in plaats van een gat te laten.</value> + </data> + <data name="account.saved.screenShown" xml:space="preserve"> + <value>Het verbindingsscherm van {game} staat weer op zijn pagina.</value> + </data> + <data name="account.saved.crawlStopped" xml:space="preserve"> + <value>We kloppen niet meer aan bij {game}, op geen enkel adres dat we ervan hebben. Zijn pagina houdt alles wat vóór je verzoek gemeten is.</value> + </data> + <data name="account.saved.crawlResumed" xml:space="preserve"> + <value>We kloppen weer aan bij {game}, vanaf zijn volgende beurt in het schema.</value> + </data> + <data name="account.saved.unlisted" xml:space="preserve"> + <value>{game} staat niet meer in de lijst, de ranglijsten en het dagcijfer. Zijn pagina en elk adres dat het ooit gehad heeft blijven antwoorden.</value> + </data> + <data name="account.saved.relisted" xml:space="preserve"> + <value>{game} staat weer in de lijst. Eén peiling die antwoord krijgt is genoeg om het weer te meten.</value> + </data> + <data name="account.refused.lead" xml:space="preserve"> + <value>{field} is niet gewijzigd.</value> + </data> + <data name="account.refused.tooLong" xml:space="preserve"> + <value>Dit zijn antwoorden van één regel; {max} tekens is het meeste dat we opslaan.</value> + </data> + <data name="account.refused.measured" xml:space="preserve"> + <value>Dat veld is gemeten. Met een claim kun je toevoegen waar MSSP geen ruimte voor heeft; hij laat niemand wijzigen wat wij waargenomen hebben, ons ook niet.</value> + </data> + <data name="account.claimed.heading" xml:space="preserve"> + <value>Geclaimd</value> + </data> + <data name="account.claim.verified" xml:space="preserve"> + <value>geverifieerd {date}</value> + </data> + <data name="account.claim.verifiedAndSeen" xml:space="preserve"> + <value>geverifieerd {date}, token laatst gezien {seen}</value> + </data> + <data name="account.claim.mssp" xml:space="preserve"> + <value>je MSSP controleren</value> + </data> + <data name="account.claim.coOwners" xml:space="preserve"> + <value>{count, plural, one {Ook eigendom van {names} — die een eigen token geverifieerd heeft.} other {Ook eigendom van {names} — die elk een eigen token geverifieerd hebben.}}</value> + </data> + <data name="account.coOwner.unnamed" xml:space="preserve"> + <value>een ander account</value> + </data> + <data name="account.badge.summary" xml:space="preserve"> + <value>je spelerstelling op je eigen site zetten</value> + </data> + <data name="account.badge.carries" xml:space="preserve"> + <value>De badge draagt de telling én wanneer we die gemeten hebben, want een getal zonder ouderdom is precies wat deze site wil vervangen.</value> + </data> + <data name="account.badge.states" xml:space="preserve"> + <value>Hij zegt {unknown} in plaats van nul wanneer we niet konden tellen, en {archived} als het spel stopt met antwoorden.</value> + </data> + <data name="account.badge.json" xml:space="preserve"> + <value>Er is ook {json}, als je hem liever zelf tekent.</value> + </data> + <data name="account.history.summary" xml:space="preserve"> + <value>geschiedenis</value> + </data> + <data name="account.event.issued" xml:space="preserve"> + <value>token uitgegeven</value> + </data> + <data name="account.event.reissued" xml:space="preserve"> + <value>token opnieuw uitgegeven</value> + </data> + <data name="account.event.verified" xml:space="preserve"> + <value>geverifieerd — we hebben je token gelezen</value> + </data> + <data name="account.event.beaconSeen" xml:space="preserve"> + <value>token nog steeds gepubliceerd</value> + </data> + <data name="account.event.beaconMissing" xml:space="preserve"> + <value>token deze keer niet gelezen</value> + </data> + <data name="account.event.revoked" xml:space="preserve"> + <value>afstand gedaan van de claim</value> + </data> + <data name="account.event.expired" xml:space="preserve"> + <value>token ongebruikt verlopen</value> + </data> + <data name="account.event.counterClaimed" xml:space="preserve"> + <value>een ander account heeft de controle aangetoond en het spel overgenomen</value> + </data> + <data name="account.event.checkRequested" xml:space="preserve"> + <value>controle aangevraagd</value> + </data> + <data name="account.resign.summary" xml:space="preserve"> + <value>afstand doen van deze claim</value> + </data> + <data name="account.resign.confirm" xml:space="preserve"> + <value>Typ {word} om te bevestigen. Er wordt niets verwijderd en je kunt opnieuw aantonen dat je de controle hebt door een nieuw token te publiceren; het spel blijft geclaimd als iemand anders het ook in eigendom heeft.</value> + </data> + <data name="account.resign.button" xml:space="preserve"> + <value>Afstand doen van {game}</value> + </data> + <data name="account.pending.heading" xml:space="preserve"> + <value>Wachten op een token</value> + </data> + <data name="account.pending.dates" xml:space="preserve"> + <value>token uitgegeven {issued}, geldig tot {expires}</value> + </data> + <data name="account.passkeys.heading" xml:space="preserve"> + <value>Passkeys</value> + </data> + <data name="account.passkey.unnamed" xml:space="preserve"> + <value>naamloos</value> + </data> + <data name="account.passkey.added" xml:space="preserve"> + <value>toegevoegd {date}</value> + </data> + <data name="account.passkey.addedOneDevice" xml:space="preserve"> + <value>toegevoegd {date} · slechts op één apparaat</value> + </data> + <data name="account.passkey.single" xml:space="preserve"> + <value>Deze passkey staat op één apparaat. Raak je hem kwijt, dan kom je er nog steeds in door een nieuw token op je spel te publiceren, maar met een tweede passkey gaat het sneller.</value> + </data> + <data name="account.passkey.add" xml:space="preserve"> + <value>Nog een passkey toevoegen</value> + </data> + <data name="claim.noGame" xml:space="preserve"> + <value>Zo’n spel is er niet</value> + </data> + <data name="claim.title" xml:space="preserve"> + <value>{game} claimen</value> + </data> + <data name="claim.noDatabase" xml:space="preserve"> + <value>Claimen vereist een database, en deze site draait op de demofixture.</value> + </data> + <data name="claim.needAccount" xml:space="preserve"> + <value>Je hebt eerst een account nodig. Daar zijn een passkey en een naam voor nodig.</value> + </data> + <data name="claim.signIn" xml:space="preserve"> + <value>Inloggen of een account aanmaken</value> + </data> + <data name="claim.yourGames" xml:space="preserve"> + <value>Je spellen</value> + </data> + <data name="claim.hasOwners" xml:space="preserve"> + <value>{count, plural, one {Dit spel heeft al een eigenaar die de controle over de server heeft aangetoond.} other {Dit spel heeft al # eigenaren die de controle over de server hebben aangetoond.}} Jij kunt dat ook aantonen — de toets is in beide gevallen dezelfde — maar we moeten weten wat je ermee bedoelt, want aan het token kunnen we dat niet zien.</value> + </data> + <data name="claim.join.button" xml:space="preserve"> + <value>Ik draai het ook — voeg me toe als eigenaar</value> + </data> + <data name="claim.join.note" xml:space="preserve"> + <value>Iedereen houdt zijn claim. Dit zijn twee mensen die één spel draaien.</value> + </data> + <data name="claim.assume.button" xml:space="preserve"> + <value>Ik heb het overgenomen — draag het aan mij over</value> + </data> + <data name="claim.assume.note" xml:space="preserve"> + <value>{count, plural, one {Zodra je token geverifieerd is, wordt de bestaande claim ingetrokken en is het spel van jou.} other {Zodra je token geverifieerd is, worden de bestaande claims ingetrokken en is het spel van jou.}} Zij zien in hun eigen geschiedenis waarom. Er wordt niets verwijderd, en zij kunnen op dezelfde manier als jij nu opnieuw de controle aantonen.</value> + </data> + <data name="claim.verified.lead" xml:space="preserve"> + <value>Geverifieerd.</value> + </data> + <data name="claim.verified.viaMssp" xml:space="preserve"> + <value>We hebben je token op {date} uit het MSSP-rapport van het spel gelezen.</value> + </data> + <data name="claim.verified.viaScreen" xml:space="preserve"> + <value>We hebben je token op {date} van het verbindingsscherm gelezen.</value> + </data> + <data name="claim.verified.leaveIt" xml:space="preserve"> + <value>Laat het token staan waar het staat. Het dient ook als identiteitssignaal, zodat dit spel herkenbaar blijft als het van host of van naam verandert. Het weghalen maakt je claim niet ongedaan.</value> + </data> + <data name="claim.publish" xml:space="preserve"> + <value>Publiceer dit token overal waar het spel het aan een anonieme verbinding laat zien. De volgende peiling pikt het op, en daarmee is aangetoond dat je naar die server kunt schrijven.</value> + </data> + <data name="claim.transfer.lead" xml:space="preserve"> + <value>Dit is een overdracht.</value> + </data> + <data name="claim.transfer.body" xml:space="preserve"> + <value>{count, plural, one {Zodra we dit token lezen, wordt de claim van de huidige eigenaar op dit spel ingetrokken en wordt het van jou.} other {Zodra we dit token lezen, worden de claims van de huidige eigenaren op dit spel ingetrokken en wordt het van jou.}}</value> + </data> + <data name="claim.either.heading" xml:space="preserve"> + <value>Een van deze twee volstaat</value> + </data> + <data name="claim.mssp.heading" xml:space="preserve"> + <value>Een MSSP-variabele</value> + </data> + <data name="claim.mssp.note" xml:space="preserve"> + <value>In {codebase} is dat een regel in {file}; elke codebase met MSSP heeft een equivalent.</value> + </data> + <data name="claim.mssp.aliases" xml:space="preserve"> + <value>{aliases} worden ook geaccepteerd.</value> + </data> + <data name="claim.screen.heading" xml:space="preserve"> + <value>Een regel op het verbindingsscherm</value> + </data> + <data name="claim.screen.note" xml:space="preserve"> + <value>Overal op het scherm, en kleurcodes eromheen zijn geen probleem.</value> + </data> + <data name="claim.then.heading" xml:space="preserve"> + <value>Daarna</value> + </data> + <data name="claim.then.body" xml:space="preserve"> + <value>We kijken op het gewone crawlschema. Dit token is geldig tot {date}. Kom gerust later terug; er hoeft niets opgeschreven te worden.</value> + </data> + <data name="claim.check.button" xml:space="preserve"> + <value>Eerder kijken</value> + </data> + <data name="claim.check.can" xml:space="preserve"> + <value>Zet je spel vooraan in de rij. We kloppen aan op ons eigen schema, dus dit is eerder en niet nu.</value> + </data> + <data name="claim.check.rationed" xml:space="preserve"> + <value>Net gevraagd. Probeer het over een paar minuten opnieuw — het is gerantsoeneerd omdat er eerder bij een echte server wordt aangeklopt dan wij anders gedaan hadden.</value> + </data> + <data name="owner.declare.heading" xml:space="preserve"> + <value>Wat alleen jij ons over {game} kunt vertellen</value> + </data> + <data name="owner.declare.lede" xml:space="preserve"> + <value>Dit zijn de dingen waar MSSP geen veld voor heeft. Ze verschijnen op de pagina van je spel als {declared}, met de datum waarop je ze voor het laatst bevestigd hebt, naast wat wij gemeten hebben — nooit in plaats daarvan. Niets wat gemeten is kan hiervandaan gewijzigd worden, niet door jou en niet door ons.</value> + </data> + <data name="owner.field.declared" xml:space="preserve"> + <value>opgegeven {age}. Maak dit vak leeg om het in te trekken — wat erin stond blijft hoe dan ook vastgelegd.</value> + </data> + <data name="owner.save" xml:space="preserve"> + <value>Opslaan wat je opgegeven hebt</value> + </data> + <data name="owner.override.heading" xml:space="preserve"> + <value>Wat {game} meldt, en wat jij liever getoond ziet</value> + </data> + <data name="owner.override.lede" xml:space="preserve"> + <value>Je MSSP is wat elke crawler leest, en we blijven het tonen naast alles wat je hier neerzet — een antwoord van jou verbergt er geen van je spel.</value> + </data> + <data name="owner.override.nothingMeasured" xml:space="preserve"> + <value>Niets wat gemeten is kan hiervandaan gewijzigd worden: geen spelerstelling, geen mogelijkheid, geen uur bereikbaarheid.</value> + </data> + <data name="owner.override.fixItThere" xml:space="preserve"> + <value>Klopt een regel hieronder niet in je {file}, dan lost het daar oplossen het overal op.</value> + </data> + <data name="owner.report.value" xml:space="preserve"> + <value>je spel meldt {value}, bevestigd {age}</value> + </data> + <data name="owner.report.none" xml:space="preserve"> + <value>je spel meldt hier niets</value> + </data> + <data name="owner.rename.note" xml:space="preserve"> + <value>De naam wijzigen verandert waaronder {game} vermeld staat en het adres van zijn pagina. Het oude adres blijft voor altijd werken — elk adres dat dit spel ooit gehad heeft verwijst door naar het huidige — en het vak leegmaken geeft de naam terug aan wat je MSSP zegt.</value> + </data> + <data name="owner.screen.heading" xml:space="preserve"> + <value>Je verbindingsscherm</value> + </data> + <data name="owner.screen.suppressed" xml:space="preserve"> + <value>We publiceren het niet opnieuw. De pagina zegt dat met zoveel woorden in plaats van een gat te laten, en de crawler blijft het lezen — zo herkennen we je spel als het verhuist.</value> + </data> + <data name="owner.screen.show" xml:space="preserve"> + <value>Weer tonen</value> + </data> + <data name="owner.screen.shown" xml:space="preserve"> + <value>We tonen het omdat je server het naar elke anonieme verbinding stuurt. Wil je dat liever niet, zeg het dan en we stoppen ermee. We vragen niet waarom.</value> + </data> + <data name="owner.screen.stop" xml:space="preserve"> + <value>Toon ons verbindingsscherm niet meer</value> + </data> + <data name="owner.crawl.heading" xml:space="preserve"> + <value>Gecrawld worden</value> + </data> + <data name="owner.crawl.stopped" xml:space="preserve"> + <value>We zijn gestopt. Er wordt bij {game} nergens meer aangeklopt, en de pagina houdt alles wat vóór je verzoek gemeten is — de lege uren noemen geen oorzaak, want {ourFact} is een feit over ons en geen meting van je spel.</value> + </data> + <data name="owner.crawl.ourFact" xml:space="preserve"> + <value>dat je ons gevraagd hebt te stoppen</value> + </data> + <data name="owner.crawl.resume" xml:space="preserve"> + <value>Crawl ons weer</value> + </data> + <data name="owner.crawl.standing" xml:space="preserve"> + <value>Deze kwam van je eigen server en niet van hier — {routes}. Wil je weer gecrawld worden, stop dan met het publiceren ervan; dat horen we in de volgende cyclus.</value> + </data> + <data name="owner.crawl.route.mssp" xml:space="preserve"> + <value>je MSSP-rapport publiceert {variable}</value> + </data> + <data name="owner.crawl.route.dns" xml:space="preserve"> + <value>een TXT-record op {label} vraagt ons te stoppen</value> + </data> + <data name="owner.crawl.route.recorded" xml:space="preserve"> + <value>een verzoek dat we vastgelegd hebben</value> + </data> + <data name="owner.crawl.partial" xml:space="preserve"> + <value>We zijn gestopt op {stopped} en kloppen nog aan bij {dialling}. Dat is meestal een poort die na de afmelding is toegevoegd.</value> + </data> + <data name="owner.crawl.stopAll" xml:space="preserve"> + <value>Stop ook op elk adres</value> + </data> + <data name="owner.crawl.dialling" xml:space="preserve"> + <value>We kloppen volgens een schema aan bij {game} en lezen wat elke anonieme verbinding te zien krijgt. Wil je dat liever niet, zeg het dan en we stoppen — binnen één cyclus, op elk adres dat we van je hebben, en we vragen niet waarom.</value> + </data> + <data name="owner.crawl.selfService" xml:space="preserve"> + <value>Wat al gemeten is wordt niet verwijderd: je pagina houdt zijn geschiedenis en zijn adres, en één peiling nadat je dit intrekt begint het weer. Je kunt het ook zonder ons zeggen, in je eigen configuratie — {mssp} in MSSP, of een TXT-record op {dns} — en die honoreren we, of iemand het spel hier nu ooit geclaimd heeft of niet.</value> + </data> + <data name="owner.crawl.stop" xml:space="preserve"> + <value>Crawl ons niet meer</value> + </data> + <data name="owner.listing.heading" xml:space="preserve"> + <value>In de lijst staan</value> + </data> + <data name="owner.listing.unlisted" xml:space="preserve"> + <value>{game} staat niet meer in de lijst, niet in de ranglijsten en niet in het dagcijfer. Zijn pagina en elk adres dat het ooit gehad heeft blijven antwoorden, en alles wat vóór je verzoek gemeten is staat er nog op. Er is niets verwijderd; het is alleen geen plek meer waar een lezer al bladerend aankomt.</value> + </data> + <data name="owner.listing.relist" xml:space="preserve"> + <value>Zet ons terug in de lijst</value> + </data> + <data name="owner.listing.probeRelists" xml:space="preserve"> + <value>Eén peiling die antwoord krijgt doet dit ook. Zolang je afmelding staat kloppen we niet aan, dus gebeurt dat niet — maar de dag dat je haar intrekt, komt het adres binnen een week aan de beurt en zet de peiling die antwoord krijgt je terug. Je hoeft het ons geen tweede keer te vragen.</value> + </data> + <data name="owner.listing.mayUnlist" xml:space="preserve"> + <value>We kloppen niet meer bij je aan, en je pagina staat nog in de lijst met wat we daarvóór gemeten hebben. Wil je dat liever niet, zeg het dan en hij gaat eruit — uit de lijst, de ranglijsten en het dagcijfer.</value> + </data> + <data name="owner.listing.reversible" xml:space="preserve"> + <value>Er wordt niets verwijderd en er gaat niets stuk: de pagina antwoordt, elk adres dat hij ooit gehad heeft verwijst er nog naar door, en iedereen die je erheen stuurt ziet hem. Hij houdt op een plek te zijn waar een lezer al bladerend aankomt. Vanaf hier terug te draaien, en door elke peiling die antwoord krijgt nadat je je afmelding intrekt.</value> + </data> + <data name="owner.listing.unlist" xml:space="preserve"> + <value>Haal ons ook uit de lijst</value> + </data> + <data name="facet.group.measure" xml:space="preserve"> + <value>wat we konden meten</value> + </data> + <data name="facet.measure.note" xml:space="preserve"> + <value>Deze verbergen haalt ze uit deze lijst; het betekent niet dat het spel leeg is.</value> + </data> + <data name="facet.group.uncounted" xml:space="preserve"> + <value>konden niet tellen</value> + </data> + <data name="facet.group.unreachable" xml:space="preserve"> + <value>konden niet bereiken</value> + </data> + <data name="facet.excluded.uncounted" xml:space="preserve"> + <value>niet getoond in deze lijst</value> + </data> + <data name="facet.excluded.unreachable" xml:space="preserve"> + <value>niet getoond in deze lijst</value> + </data> + <data name="facet.plain.marks" xml:space="preserve"> + <value>In de linkerkolom is * een waarde waarop deze lijst gefilterd is en - een waarde die is uitgesloten. Beide zijn keuzes in de zoekopdracht, geen feiten over een spel.</value> + </data> +</root> diff --git a/src/MUI.Web/Resources/Messages.resx b/src/MUI.Web/Resources/Messages.resx new file mode 100644 index 0000000..0e39845 --- /dev/null +++ b/src/MUI.Web/Resources/Messages.resx @@ -0,0 +1,3823 @@ +<?xml version="1.0" encoding="utf-8"?> +<root> + <!-- + The chrome's strings, in ICU MessageFormat. + + resx because that is what .NET, every translation-management tool and every translator already + understand: the SDK compiles a Messages.<culture>.resx into a satellite assembly on its own, and + a translator receives a file their software opens rather than a C# dictionary they must not + break. The values are ICU patterns rather than composite-format strings, because {0} cannot + express agreement — see MessagePattern. + + A locked id may only be changed by a maintainer. Glossary.cs says which, and why for each. + --> + <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata"> + <xsd:import namespace="http://www.w3.org/XML/1998/namespace" /> + <xsd:element name="root" msdata:IsDataSet="true"> + <xsd:complexType> + <xsd:choice maxOccurs="unbounded"> + <xsd:element name="data"> + <xsd:complexType> + <xsd:sequence> + <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" /> + <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" /> + </xsd:sequence> + <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" /> + <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" /> + <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" /> + <xsd:attribute ref="xml:space" /> + </xsd:complexType> + </xsd:element> + <xsd:element name="resheader"> + <xsd:complexType> + <xsd:sequence> + <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" /> + </xsd:sequence> + <xsd:attribute name="name" type="xsd:string" use="required" /> + </xsd:complexType> + </xsd:element> + </xsd:choice> + </xsd:complexType> + </xsd:element> + </xsd:schema> + <resheader name="resmimetype"><value>text/microsoft-resx</value></resheader> + <resheader name="version"><value>2.0</value></resheader> + <resheader name="reader"><value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader> + <resheader name="writer"><value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader> + <data name="facet.count" xml:space="preserve"> + <value>{count, plural, one {# game} other {# games}}</value> + <comment>counts, which is where the concatenations were</comment> + </data> + <data name="facet.value.include" xml:space="preserve"> + <value>{value}, {count, plural, one {# game} other {# games}}, only</value> + <comment>counts, which is where the concatenations were</comment> + </data> + <data name="facet.value.exclude" xml:space="preserve"> + <value>{value}, {count, plural, one {# game} other {# games}}, excluded</value> + <comment>counts, which is where the concatenations were</comment> + </data> + <data name="facet.value.choose" xml:space="preserve"> + <value>{value}, {count, plural, one {# game} other {# games}}</value> + <comment>counts, which is where the concatenations were</comment> + </data> + <data name="facet.any" xml:space="preserve"> + <value>any {facet}, {count, plural, one {# game} other {# games}}</value> + <comment>counts, which is where the concatenations were</comment> + </data> + <data name="listing.total" xml:space="preserve"> + <value>{count, plural, =0 {No games listed here.} one {# game, each fact carrying how it was obtained.} other {# games, each fact carrying how it was obtained.}}</value> + <comment>counts, which is where the concatenations were</comment> + </data> + <data name="chart.basis" xml:space="preserve"> + <value>{days, plural, one {# day} other {# days}} measured · {probes, plural, one {# probe} other {# probes}}</value> + <comment>counts, which is where the concatenations were</comment> + </data> + <data name="window.samples" xml:space="preserve"> + <value>{days, plural, one {#d} other {#d}} · {count, plural, one {# count} other {# counts}}</value> + <comment>counts, which is where the concatenations were</comment> + </data> + <data name="capabilities.agree" xml:space="preserve"> + <value>{disagreeing, plural, =0 {None of the {total} disagree.} one {# of {total} disagrees with what the game declares.} other {# of {total} disagree with what the game declares.}}</value> + <comment>counts, which is where the concatenations were</comment> + </data> + <data name="find.matching" xml:space="preserve"> + <value>{count, plural, =0 {No games match every answer.} one {# game matches every answer.} other {# games match every answer.}}</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.basis" xml:space="preserve"> + <value>of {listed, plural, one {# listed game} other {# listed games}} · {answers, plural, =0 {no answers given} one {# answer given} other {# answers given}}</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.show" xml:space="preserve"> + <value>{count, plural, one {Show the one game} other {Show these # games}}</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.drop" xml:space="preserve"> + <value>drop "{answer}" — {count, plural, one {# game} other {# games}}</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.clear" xml:space="preserve"> + <value>clear answer to: {question}</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.title" xml:space="preserve"> + <value>Find a game</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.kicker" xml:space="preserve"> + <value>matching all answers</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.noun" xml:space="preserve"> + <value>{count, plural, one {game} other {games}}</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.clearAll" xml:space="preserve"> + <value>clear all answers</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.startAgain" xml:space="preserve"> + <value>start again</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.more" xml:space="preserve"> + <value>{count, plural, one {# more} other {# more}}</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.answersGiven" xml:space="preserve"> + <value>answers given</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.wholeListing" xml:space="preserve"> + <value>the whole listing</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.refused" xml:space="preserve"> + <value>that query was refused</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.name.label" xml:space="preserve"> + <value>a name, if you have one</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.name.placeholder" xml:space="preserve"> + <value>name, or part of one</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.name.submit" xml:space="preserve"> + <value>Search by name</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.q.band" xml:space="preserve"> + <value>Is anyone playing right now?</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.q.genre" xml:space="preserve"> + <value>What do you want to play?</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.q.lineage" xml:space="preserve"> + <value>What kind of game?</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.q.language" xml:space="preserve"> + <value>In which language?</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.q.client" xml:space="preserve"> + <value>Anything your client needs?</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.q.dark" xml:space="preserve"> + <value>Include games that have gone dark?</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.any.band" xml:space="preserve"> + <value>doesn't matter</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.any.genre" xml:space="preserve"> + <value>any genre</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.any.lineage" xml:space="preserve"> + <value>any kind</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.any.language" xml:space="preserve"> + <value>any language</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.any.client" xml:space="preserve"> + <value>doesn't matter</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.dark.no" xml:space="preserve"> + <value>no, only live games</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.dark.yes" xml:space="preserve"> + <value>yes, show me those too</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.dark.chip" xml:space="preserve"> + <value>games that have gone dark</value> + <comment>find a game, where the count is the whole point of the page</comment> + </data> + <data name="find.protocol.tls" xml:space="preserve"> + <value>TLS — encrypted, handshake completed by us</value> + <comment>the client question's options</comment> + </data> + <data name="find.protocol.mssp" xml:space="preserve"> + <value>MSSP — server self-description</value> + <comment>the client question's options</comment> + </data> + <data name="find.protocol.mccp" xml:space="preserve"> + <value>MCCP — compressed output</value> + <comment>the client question's options</comment> + </data> + <data name="find.protocol.mxp" xml:space="preserve"> + <value>MXP — clickable links</value> + <comment>the client question's options</comment> + </data> + <data name="find.protocol.gmcp" xml:space="preserve"> + <value>GMCP — structured client data</value> + <comment>the client question's options</comment> + </data> + <data name="find.protocol.msdp" xml:space="preserve"> + <value>MSDP — structured client data</value> + <comment>the client question's options</comment> + </data> + <data name="find.protocol.charset" xml:space="preserve"> + <value>CHARSET — encoding negotiation</value> + <comment>the client question's options</comment> + </data> + <data name="find.protocol.utf8" xml:space="preserve"> + <value>UTF-8 — non-Latin text renders</value> + <comment>the client question's options</comment> + </data> + <data name="find.protocol.ttype" xml:space="preserve"> + <value>TTYPE — client tells its type</value> + <comment>the client question's options</comment> + </data> + <data name="find.protocol.atcp" xml:space="preserve"> + <value>ATCP — structured client data</value> + <comment>the client question's options</comment> + </data> + <data name="find.protocol.msp" xml:space="preserve"> + <value>MSP — sound triggers</value> + <comment>the client question's options</comment> + </data> + <data name="find.protocol.eor" xml:space="preserve"> + <value>EOR — prompt marking</value> + <comment>the client question's options</comment> + </data> + <data name="find.protocol.other" xml:space="preserve"> + <value>{token} — measured in the handshake</value> + <comment>the client question's options</comment> + </data> + <data name="provenance.count.measured" xml:space="preserve"> + <value>measured</value> + <comment>the locked provenance words, one id per context</comment> + </data> + <data name="provenance.game.measured" xml:space="preserve"> + <value>measured</value> + <comment>the locked provenance words, one id per context</comment> + </data> + <data name="provenance.capability.measured" xml:space="preserve"> + <value>measured</value> + <comment>the locked provenance words, one id per context</comment> + </data> + <data name="provenance.screen.measured" xml:space="preserve"> + <value>measured</value> + <comment>the locked provenance words, one id per context</comment> + </data> + <data name="kicker.measured" xml:space="preserve"> + <value>measured</value> + <comment>the locked provenance words, one id per context</comment> + </data> + <data name="provenance.count.declared" xml:space="preserve"> + <value>declared</value> + <comment>the locked provenance words, one id per context</comment> + </data> + <data name="provenance.game.declared" xml:space="preserve"> + <value>declared</value> + <comment>the locked provenance words, one id per context</comment> + </data> + <data name="provenance.capability.declared" xml:space="preserve"> + <value>declared</value> + <comment>the locked provenance words, one id per context</comment> + </data> + <data name="kicker.declared" xml:space="preserve"> + <value>declared</value> + <comment>the locked provenance words, one id per context</comment> + </data> + <data name="provenance.derived" xml:space="preserve"> + <value>derived</value> + <comment>the locked provenance words, one id per context</comment> + </data> + <data name="kicker.derived" xml:space="preserve"> + <value>derived</value> + <comment>the locked provenance words, one id per context</comment> + </data> + <data name="state.notMeasured" xml:space="preserve"> + <value>not measured</value> + <comment>the four kinds of absence</comment> + </data> + <data name="state.uncounted" xml:space="preserve"> + <value>uncounted</value> + <comment>the four kinds of absence</comment> + </data> + <data name="state.unreachable" xml:space="preserve"> + <value>unreachable</value> + <comment>the four kinds of absence</comment> + </data> + <data name="state.notCounted" xml:space="preserve"> + <value>not counted</value> + <comment>the four kinds of absence</comment> + </data> + <data name="listing.count.none" xml:space="preserve"> + <value>no count</value> + <comment>the listing's own absences, which are not the game page's</comment> + </data> + <data name="listing.plain.fromHere" xml:space="preserve"> + <value>from here</value> + <comment>the listing's own absences, which are not the game page's</comment> + </data> + <data name="listing.plain.archived" xml:space="preserve"> + <value>archived</value> + <comment>the listing's own absences, which are not the game page's</comment> + </data> + <data name="listing.plain.claimed" xml:space="preserve"> + <value>claimed</value> + <comment>the listing's own absences, which are not the game page's</comment> + </data> + <data name="random.empty.title" xml:space="preserve"> + <value>Nothing to pick from</value> + <comment>the listing's own absences, which are not the game page's</comment> + </data> + <data name="random.empty.body" xml:space="preserve"> + <value>No game matches that filter. Try {listing}, or {archive}.</value> + <comment>the listing's own absences, which are not the game page's</comment> + </data> + <data name="random.empty.listing" xml:space="preserve"> + <value>the whole listing</value> + <comment>the listing's own absences, which are not the game page's</comment> + </data> + <data name="random.empty.archive" xml:space="preserve"> + <value>include the archive</value> + <comment>the listing's own absences, which are not the game page's</comment> + </data> + <data name="term.connected" xml:space="preserve"> + <value>connected</value> + <comment>the words the product rests on</comment> + </data> + <data name="term.unclaimed" xml:space="preserve"> + <value>unclaimed</value> + <comment>the words the product rests on</comment> + </data> + <data name="term.claimedByOwner" xml:space="preserve"> + <value>claimed by its owner</value> + <comment>the words the product rests on</comment> + </data> + <data name="term.stillProbed" xml:space="preserve"> + <value>still probed</value> + <comment>the words the product rests on</comment> + </data> + <data name="term.typical" xml:space="preserve"> + <value>typical</value> + <comment>the words the product rests on</comment> + </data> + <data name="term.peak" xml:space="preserve"> + <value>peak</value> + <comment>the words the product rests on</comment> + </data> + <data name="a11y.readAsText" xml:space="preserve"> + <value>read as text</value> + <comment>the accessibility promises</comment> + </data> + <data name="a11y.plainText" xml:space="preserve"> + <value>plain text</value> + <comment>the accessibility promises</comment> + </data> + <data name="a11y.skipToContent" xml:space="preserve"> + <value>skip to content</value> + <comment>the accessibility promises</comment> + </data> + <data name="a11y.asciiBanner" xml:space="preserve"> + <value>ASCII banner: the connect screen of {game}.</value> + <comment>the accessibility promises</comment> + </data> + <data name="nav.catalogues" xml:space="preserve"> + <value>Catalogues</value> + <comment>site chrome</comment> + </data> + <data name="nav.account" xml:space="preserve"> + <value>This site and your account</value> + <comment>site chrome</comment> + </data> + <data name="nav.browse" xml:space="preserve"> + <value>browse</value> + <comment>site chrome</comment> + </data> + <data name="nav.learn" xml:space="preserve"> + <value>learn</value> + <comment>site chrome</comment> + </data> + <data name="nav.thisSite" xml:space="preserve"> + <value>this site</value> + <comment>site chrome</comment> + </data> + <data name="nav.menu" xml:space="preserve"> + <value>menu</value> + <comment>site chrome</comment> + </data> + <data name="nav.games" xml:space="preserve"> + <value>games</value> + <comment>site chrome</comment> + </data> + <data name="nav.find" xml:space="preserve"> + <value>find</value> + <comment>site chrome</comment> + </data> + <data name="nav.random" xml:space="preserve"> + <value>random</value> + <comment>site chrome</comment> + </data> + <data name="nav.archive" xml:space="preserve"> + <value>archive</value> + <comment>site chrome</comment> + </data> + <data name="nav.reference" xml:space="preserve"> + <value>reference</value> + <comment>site chrome</comment> + </data> + <data name="nav.ecosystem" xml:space="preserve"> + <value>ecosystem</value> + <comment>site chrome</comment> + </data> + <data name="nav.rankings" xml:space="preserve"> + <value>rankings</value> + <comment>site chrome</comment> + </data> + <data name="nav.about" xml:space="preserve"> + <value>about</value> + <comment>site chrome</comment> + </data> + <data name="nav.submit" xml:space="preserve"> + <value>submit</value> + <comment>site chrome</comment> + </data> + <data name="nav.submitGame" xml:space="preserve"> + <value>submit a game</value> + <comment>site chrome</comment> + </data> + <data name="nav.signIn" xml:space="preserve"> + <value>sign in</value> + <comment>site chrome</comment> + </data> + <data name="nav.yourGames" xml:space="preserve"> + <value>your games</value> + <comment>site chrome</comment> + </data> + <data name="theme.label" xml:space="preserve"> + <value>theme</value> + <comment>site chrome</comment> + </data> + <data name="theme.auto" xml:space="preserve"> + <value>auto</value> + <comment>site chrome</comment> + </data> + <data name="theme.light" xml:space="preserve"> + <value>light</value> + <comment>site chrome</comment> + </data> + <data name="theme.dark" xml:space="preserve"> + <value>dark</value> + <comment>site chrome</comment> + </data> + <data name="banner.demo.lead" xml:space="preserve"> + <value>Demo data.</value> + <comment>site chrome</comment> + </data> + <data name="banner.demo" xml:space="preserve"> + <value>No database is configured, so this is a fixture. Nothing here was measured.</value> + <comment>site chrome</comment> + </data> + <data name="footer.allGames" xml:space="preserve"> + <value>all games</value> + <comment>site chrome</comment> + </data> + <data name="footer.archive" xml:space="preserve"> + <value>archive</value> + <comment>site chrome</comment> + </data> + <data name="footer.declaredByGame" xml:space="preserve"> + <value>declared by the game</value> + <comment>site chrome</comment> + </data> + <data name="footer.whatChanged" xml:space="preserve"> + <value>what changed</value> + <comment>site chrome</comment> + </data> + <data name="home.title" xml:space="preserve"> + <value>A directory of the MU* hobby</value> + <comment>home</comment> + </data> + <data name="home.lede" xml:space="preserve"> + <value>Every fact carries how it was obtained and how old it is: measured by our crawler, or declared by the game and marked as such.</value> + <comment>home</comment> + </data> + <data name="home.search.label" xml:space="preserve"> + <value>Search games by name, theme, codebase or host</value> + <comment>home</comment> + </data> + <data name="home.search.placeholder" xml:space="preserve"> + <value>search by name, theme, codebase or host</value> + <comment>home</comment> + </data> + <data name="home.search.submit" xml:space="preserve"> + <value>search</value> + <comment>home</comment> + </data> + <data name="tile.gamesKnown" xml:space="preserve"> + <value>games known</value> + <comment>home</comment> + </data> + <data name="tile.connectedNow" xml:space="preserve"> + <value>connected now</value> + <comment>home</comment> + </data> + <data name="tile.answeringUncounted" xml:space="preserve"> + <value>answering, uncounted</value> + <comment>home</comment> + </data> + <data name="tile.archived" xml:space="preserve"> + <value>archived</value> + <comment>home</comment> + </data> + <data name="feed.newlyDiscovered" xml:space="preserve"> + <value>newly discovered</value> + <comment>home</comment> + </data> + <data name="feed.wentDark" xml:space="preserve"> + <value>went dark — still probed</value> + <comment>home</comment> + </data> + <data name="feed.cameBack" xml:space="preserve"> + <value>came back</value> + <comment>home</comment> + </data> + <data name="feed.nothingNew" xml:space="preserve"> + <value>Nothing new.</value> + <comment>home</comment> + </data> + <data name="feed.nothingDark" xml:space="preserve"> + <value>Nothing went dark.</value> + <comment>home</comment> + </data> + <data name="feed.nothingBack" xml:space="preserve"> + <value>Nothing came back. We keep knocking.</value> + <comment>home</comment> + </data> + <data name="feed.live" xml:space="preserve"> + <value>live</value> + <comment>home</comment> + </data> + <data name="games.title" xml:space="preserve"> + <value>Games</value> + <comment>the listing</comment> + </data> + <data name="listing.sortedBy" xml:space="preserve"> + <value>sorted by {order}</value> + <comment>the listing</comment> + </data> + <data name="listing.random" xml:space="preserve"> + <value>random</value> + <comment>the listing</comment> + </data> + <data name="listing.columns" xml:space="preserve"> + <value>connected · reached</value> + <comment>the listing</comment> + </data> + <data name="listing.fromHere" xml:space="preserve"> + <value>from here</value> + <comment>the listing</comment> + </data> + <data name="listing.empty.head" xml:space="preserve"> + <value>Nothing matched.</value> + <comment>the listing</comment> + </data> + <data name="listing.empty.hint" xml:space="preserve"> + <value>Try fewer words, or drop a filter.</value> + <comment>the listing</comment> + </data> + <data name="listing.clearFilters" xml:space="preserve"> + <value>clear filters</value> + <comment>the listing</comment> + </data> + <data name="listing.aboutCodebase" xml:space="preserve"> + <value>about {codebase}</value> + <comment>the listing</comment> + </data> + <data name="listing.never" xml:space="preserve"> + <value>never</value> + <comment>the listing</comment> + </data> + <data name="listing.claimed" xml:space="preserve"> + <value>claimed by its owner</value> + <comment>the listing</comment> + </data> + <data name="listing.unknownCodebase" xml:space="preserve"> + <value>Unknown Codebase</value> + <comment>the listing</comment> + </data> + <data name="listing.unknownCodebase.title" xml:space="preserve"> + <value>we could not identify the codebase this game runs</value> + <comment>the listing</comment> + </data> + <data name="listing.moreProtocols" xml:space="preserve"> + <value>and {count, plural, one {# more} other {# more}}: {names}</value> + <comment>the listing</comment> + </data> + <data name="switch.order" xml:space="preserve"> + <value>Order</value> + <comment>the order switch</comment> + </data> + <data name="switch.window" xml:space="preserve"> + <value>Window</value> + <comment>the order switch</comment> + </data> + <data name="switch.now" xml:space="preserve"> + <value>now</value> + <comment>the order switch</comment> + </data> + <data name="switch.typical" xml:space="preserve"> + <value>typical</value> + <comment>the order switch</comment> + </data> + <data name="switch.peak" xml:space="preserve"> + <value>peak</value> + <comment>the order switch</comment> + </data> + <data name="switch.name" xml:space="preserve"> + <value>name</value> + <comment>the order switch</comment> + </data> + <data name="switch.reached" xml:space="preserve"> + <value>reached</value> + <comment>the order switch</comment> + </data> + <data name="window.7" xml:space="preserve"> + <value>7 days</value> + <comment>the order switch</comment> + </data> + <data name="window.30" xml:space="preserve"> + <value>30 days</value> + <comment>the order switch</comment> + </data> + <data name="window.90" xml:space="preserve"> + <value>90 days</value> + <comment>the order switch</comment> + </data> + <data name="filters.search.label" xml:space="preserve"> + <value>Search games</value> + <comment>the filter panel</comment> + </data> + <data name="filters.search.placeholder" xml:space="preserve"> + <value>search games</value> + <comment>the filter panel</comment> + </data> + <data name="filters.summary" xml:space="preserve"> + <value>filters</value> + <comment>the filter panel</comment> + </data> + <data name="filters.showing" xml:space="preserve"> + <value>showing</value> + <comment>the filter panel</comment> + </data> + <data name="filters.clearAll" xml:space="preserve"> + <value>clear all</value> + <comment>the filter panel</comment> + </data> + <data name="filters.stopFiltering" xml:space="preserve"> + <value>— stop filtering by this</value> + <comment>the filter panel</comment> + </data> + <data name="facet.anyValue" xml:space="preserve"> + <value>any</value> + <comment>the filter panel</comment> + </data> + <data name="facet.more" xml:space="preserve"> + <value>more filters ({count})</value> + <comment>the filter panel</comment> + </data> + <data name="facet.moreValues" xml:space="preserve"> + <value>{count, plural, one {# more} other {# more}}</value> + <comment>the filter panel</comment> + </data> + <data name="facet.alsoShow" xml:space="preserve"> + <value>also show</value> + <comment>the filter panel</comment> + </data> + <data name="facet.alsoShow.note" xml:space="preserve"> + <value>Off by default. Neither is a judgement about the game.</value> + <comment>the filter panel</comment> + </data> + <data name="facet.archived" xml:space="preserve"> + <value>archived</value> + <comment>the filter panel</comment> + </data> + <data name="facet.adult" xml:space="preserve"> + <value>adult</value> + <comment>the filter panel</comment> + </data> + <data name="facet.archived.state" xml:space="preserve"> + <value>archived games, {shown, select, true {shown} other {hidden}}</value> + <comment>the filter panel</comment> + </data> + <data name="facet.adult.state" xml:space="preserve"> + <value>games declaring adult content, {shown, select, true {shown} other {hidden}}</value> + <comment>the filter panel</comment> + </data> + <data name="facet.countsNote" xml:space="preserve"> + <value>Counts are games we measured, never estimates.</value> + <comment>the filter panel</comment> + </data> + <data name="facet.key.summary" xml:space="preserve"> + <value>what the badges and the blanks mean</value> + <comment>the filter panel</comment> + </data> + <data name="facet.key.blank" xml:space="preserve"> + <value>A blank is a gap in our measurement, not a no. Each facet spells its own: not identified, not declared, nothing negotiated.</value> + <comment>the filter panel</comment> + </data> + <data name="facet.key.zero" xml:space="preserve"> + <value>A measured zero is a count. An unknown count is not a zero and never sorts as one.</value> + <comment>the filter panel</comment> + </data> + <data name="facet.key.openEnded" xml:space="preserve"> + <value>Open-ended facets list their {count} commonest values. The rest are reachable by search and by URL.</value> + <comment>the filter panel</comment> + </data> + <data name="facet.presence.note" xml:space="preserve"> + <value>Unticked means not measured — not that the game lacks it.</value> + <comment>the filter panel</comment> + </data> + <data name="facet.group.band" xml:space="preserve"> + <value>activity</value> + <comment>facet groups</comment> + </data> + <data name="facet.group.seen" xml:space="preserve"> + <value>last seen</value> + <comment>facet groups</comment> + </data> + <data name="facet.group.protocol" xml:space="preserve"> + <value>protocols offered</value> + <comment>facet groups</comment> + </data> + <data name="facet.group.tls" xml:space="preserve"> + <value>encrypted</value> + <comment>facet groups</comment> + </data> + <data name="facet.group.charset" xml:space="preserve"> + <value>encoding</value> + <comment>facet groups</comment> + </data> + <data name="facet.group.codebase" xml:space="preserve"> + <value>codebase</value> + <comment>facet groups</comment> + </data> + <data name="facet.group.version" xml:space="preserve"> + <value>version</value> + <comment>facet groups</comment> + </data> + <data name="facet.group.lineage" xml:space="preserve"> + <value>lineage</value> + <comment>facet groups</comment> + </data> + <data name="facet.group.family" xml:space="preserve"> + <value>family</value> + <comment>facet groups</comment> + </data> + <data name="facet.group.genre" xml:space="preserve"> + <value>genre</value> + <comment>facet groups</comment> + </data> + <data name="facet.group.language" xml:space="preserve"> + <value>language</value> + <comment>facet groups</comment> + </data> + <data name="facet.band.playersNow" xml:space="preserve"> + <value>connected now</value> + <comment>facet values</comment> + </data> + <data name="facet.band.activeThisWeek" xml:space="preserve"> + <value>active this week</value> + <comment>facet values</comment> + </data> + <data name="facet.band.quiet" xml:space="preserve"> + <value>quiet — no count above 0</value> + <comment>facet values</comment> + </data> + <data name="facet.band.dark" xml:space="preserve"> + <value>dark — not reached in a month</value> + <comment>facet values</comment> + </data> + <data name="facet.band.archived" xml:space="preserve"> + <value>archived</value> + <comment>facet values</comment> + </data> + <data name="facet.seen.day" xml:space="preserve"> + <value>in the last 24 hours</value> + <comment>facet values</comment> + </data> + <data name="facet.seen.week" xml:space="preserve"> + <value>in the last 7 days</value> + <comment>facet values</comment> + </data> + <data name="facet.seen.month" xml:space="preserve"> + <value>in the last 30 days</value> + <comment>facet values</comment> + </data> + <data name="facet.seen.older" xml:space="preserve"> + <value>longer ago</value> + <comment>facet values</comment> + </data> + <data name="facet.seen.never" xml:space="preserve"> + <value>never reached</value> + <comment>facet values</comment> + </data> + <data name="facet.unknown.charset" xml:space="preserve"> + <value>nothing negotiated</value> + <comment>facet values</comment> + </data> + <data name="facet.unknown.codebase" xml:space="preserve"> + <value>not identified</value> + <comment>facet values</comment> + </data> + <data name="facet.unknown.other" xml:space="preserve"> + <value>not declared</value> + <comment>facet values</comment> + </data> + <data name="facet.tls.yes" xml:space="preserve"> + <value>connected over TLS</value> + <comment>facet values</comment> + </data> + <data name="facet.excluded" xml:space="preserve"> + <value>not {value}</value> + <comment>facet values</comment> + </data> + <data name="facet.known.charset" xml:space="preserve"> + <value>something negotiated</value> + <comment>facet values</comment> + </data> + <data name="facet.known.codebase" xml:space="preserve"> + <value>identified at all</value> + <comment>facet values</comment> + </data> + <data name="facet.known.other" xml:space="preserve"> + <value>declared at all</value> + <comment>facet values</comment> + </data> + <data name="evidence.measured.meaning" xml:space="preserve"> + <value>we watched this happen</value> + <comment>evidence, and what each word means</comment> + </data> + <data name="evidence.declared.meaning" xml:space="preserve"> + <value>the game says so, and we did not check</value> + <comment>evidence, and what each word means</comment> + </data> + <data name="evidence.derived.meaning" xml:space="preserve"> + <value>we grouped what the game told us</value> + <comment>evidence, and what each word means</comment> + </data> + <data name="sort.name" xml:space="preserve"> + <value>name</value> + <comment>sort orders</comment> + </data> + <data name="sort.players" xml:space="preserve"> + <value>connected now</value> + <comment>sort orders</comment> + </data> + <data name="sort.reached" xml:space="preserve"> + <value>last reached</value> + <comment>sort orders</comment> + </data> + <data name="sort.medianWeek" xml:space="preserve"> + <value>typically on · 7 days</value> + <comment>sort orders</comment> + </data> + <data name="sort.medianMonth" xml:space="preserve"> + <value>typically on · 30 days</value> + <comment>sort orders</comment> + </data> + <data name="sort.medianQuarter" xml:space="preserve"> + <value>typically on · 90 days</value> + <comment>sort orders</comment> + </data> + <data name="sort.peakWeek" xml:space="preserve"> + <value>most on at once · 7 days</value> + <comment>sort orders</comment> + </data> + <data name="sort.peakMonth" xml:space="preserve"> + <value>most on at once · 30 days</value> + <comment>sort orders</comment> + </data> + <data name="sort.peakQuarter" xml:space="preserve"> + <value>most on at once · 90 days</value> + <comment>sort orders</comment> + </data> + <data name="sort.group.row" xml:space="preserve"> + <value>on the row now</value> + <comment>sort orders</comment> + </data> + <data name="sort.group.typical" xml:space="preserve"> + <value>typical</value> + <comment>sort orders</comment> + </data> + <data name="sort.group.peak" xml:space="preserve"> + <value>peak</value> + <comment>sort orders</comment> + </data> + <data name="sort.unranked.players" xml:space="preserve"> + <value>Unknown count</value> + <comment>sort orders</comment> + </data> + <data name="sort.unranked.reached" xml:space="preserve"> + <value>never once reached — not reached long ago</value> + <comment>sort orders</comment> + </data> + <data name="sort.unranked.median" xml:space="preserve"> + <value>fewer than {minimum} counts in the window, or none at all — not a typical count of zero</value> + <comment>sort orders</comment> + </data> + <data name="sort.unranked.window" xml:space="preserve"> + <value>nothing we could count in the window — not a game nobody was on</value> + <comment>sort orders</comment> + </data> + <data name="sort.window.median" xml:space="preserve"> + <value>median {value} · {days, plural, one {#d} other {#d}} · {count, plural, one {# count} other {# counts}}</value> + <comment>sort orders</comment> + </data> + <data name="sort.window.peak" xml:space="preserve"> + <value>most {value} at once · {days, plural, one {#d} other {#d}} · {count, plural, one {# count} other {# counts}}</value> + <comment>sort orders</comment> + </data> + <data name="game.connectScreen" xml:space="preserve"> + <value>Connect screen</value> + <comment>the game page's own headings</comment> + </data> + <data name="game.connectionsByHour" xml:space="preserve"> + <value>Connections by hour</value> + <comment>the game page's own headings</comment> + </data> + <data name="game.howMany" xml:space="preserve"> + <value>How many, over time</value> + <comment>the game page's own headings</comment> + </data> + <data name="game.reachable" xml:space="preserve"> + <value>Reachable</value> + <comment>the game page's own headings</comment> + </data> + <data name="game.whatChanged" xml:space="preserve"> + <value>What changed</value> + <comment>the game page's own headings</comment> + </data> + <data name="game.capabilities" xml:space="preserve"> + <value>Capabilities</value> + <comment>the game page's own headings</comment> + </data> + <data name="game.declaredByGame" xml:space="preserve"> + <value>Declared by the game</value> + <comment>the game page's own headings</comment> + </data> + <data name="game.referrals" xml:space="preserve"> + <value>Referrals</value> + <comment>the game page's own headings</comment> + </data> + <data name="game.unclaimed" xml:space="preserve"> + <value>Unclaimed — everything here was measured.</value> + <comment>the game page's own headings</comment> + </data> + <data name="game.claimed" xml:space="preserve"> + <value>Claimed by its owner — measured facts below are still ours.</value> + <comment>the game page's own headings</comment> + </data> + <data name="game.claim" xml:space="preserve"> + <value>Claim this game</value> + <comment>the game page's own headings</comment> + </data> + <data name="game.answeringSince" xml:space="preserve"> + <value>answering since {date}</value> + <comment>the game page's own headings</comment> + </data> + <data name="game.readAsTextRows" xml:space="preserve"> + <value>read as text — {count, plural, one {# row} other {# rows}}</value> + <comment>the game page's own headings</comment> + </data> + <data name="capability.column" xml:space="preserve"> + <value>capability</value> + <comment>the game page's own headings</comment> + </data> + <data name="capability.age" xml:space="preserve"> + <value>age</value> + <comment>the game page's own headings</comment> + </data> + <data name="capability.offered" xml:space="preserve"> + <value>offered</value> + <comment>the game page's own headings</comment> + </data> + <data name="capability.silent" xml:space="preserve"> + <value>silent</value> + <comment>the game page's own headings</comment> + </data> + <data name="capability.absent" xml:space="preserve"> + <value>absent</value> + <comment>the game page's own headings</comment> + </data> + <data name="capability.denied" xml:space="preserve"> + <value>denied</value> + <comment>the game page's own headings</comment> + </data> + <data name="capability.claimed" xml:space="preserve"> + <value>claimed</value> + <comment>the game page's own headings</comment> + </data> + <data name="capability.disagrees" xml:space="preserve"> + <value>disagrees</value> + <comment>the game page's own headings</comment> + </data> + <data name="capability.whereTheyDisagree" xml:space="preserve"> + <value>where they disagree ({count})</value> + <comment>the game page's own headings</comment> + </data> + <data name="activity.cell.counted" xml:space="preserve"> + <value>{day} {time} — {count, plural, =0 {0 players, measured} one {# player on average} other {# players on average}}</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.cell.notCounted" xml:space="preserve"> + <value>{day} {time} — probed, no count could be read</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.cell.notMeasured" xml:space="preserve"> + <value>{day} {time} — no measurement in this hour</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.none" xml:space="preserve"> + <value>We have not measured this game's activity yet.</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.noCount" xml:space="preserve"> + <value>No hour of the week has produced a player count.</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.allZero" xml:space="preserve"> + <value>Measured every hour and nobody has been on in any of them.</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.gap.day" xml:space="preserve"> + <value>{count, plural, one {# hour on {day} has no measurement yet.} other {# hours on {day} have no measurement yet.}}</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.gap.week" xml:space="preserve"> + <value>{count, plural, one {# hour across the week has no measurement yet.} other {# hours across the week have no measurement yet.}}</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.uncounted.day" xml:space="preserve"> + <value>{count, plural, one {# hour on {day} answered but produced no count.} other {# hours on {day} answered but produced no count.}}</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.uncounted.week" xml:space="preserve"> + <value>{count, plural, one {# hour across the week answered but produced no count.} other {# hours across the week answered but produced no count.}}</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.busiest.everyDay" xml:space="preserve"> + <value>Busiest every day, {window}.</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.busiest.everyDay.part" xml:space="preserve"> + <value>Busiest every day, {part}, {window}.</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.busiest.days" xml:space="preserve"> + <value>Busiest {days} {window}.</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.busiest.days.part" xml:space="preserve"> + <value>Busiest {days} {part}, {window}.</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.quiet" xml:space="preserve"> + <value>Reliably quiet {who}, {window}.</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.quiet.part" xml:space="preserve"> + <value>Reliably quiet {who} in the {part}, {window}.</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.quiet.everyDay" xml:space="preserve"> + <value>every day</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.quiet.everyMeasuredDay" xml:space="preserve"> + <value>every day we could measure</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.quiet.weekdays" xml:space="preserve"> + <value>on weekdays</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.quiet.onDays" xml:space="preserve"> + <value>on {days}</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.part.morning" xml:space="preserve"> + <value>morning</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.part.afternoon" xml:space="preserve"> + <value>afternoon</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.part.evening" xml:space="preserve"> + <value>evening</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.part.smallHours" xml:space="preserve"> + <value>small hours</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.parts.morning" xml:space="preserve"> + <value>mornings</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.parts.afternoon" xml:space="preserve"> + <value>afternoons</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.parts.evening" xml:space="preserve"> + <value>evenings</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.parts.smallHours" xml:space="preserve"> + <value>small hours</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.days.list" xml:space="preserve"> + <value>{list}, {next}</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.days.pair" xml:space="preserve"> + <value>{first} and {second}</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.sparse.kicker" xml:space="preserve"> + <value>not enough measurements yet</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.sparse.none" xml:space="preserve"> + <value>No hour of the week has a measurement yet.</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.sparse.uncounted" xml:space="preserve"> + <value>{count, plural, one {# hour answered and produced no count.} other {# hours answered and produced no count.}}</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.sparse.wait" xml:space="preserve"> + <value>The grid appears once every day of the week has one.</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.sparse.days" xml:space="preserve"> + <value>{days, plural, one {Measured on # of the seven days so far; the grid appears once every day has an hour in it.} other {Measured on # of the seven days so far; the grid appears once every day has an hour in it.}}</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.sample.zero" xml:space="preserve"> + <value>{count, plural, one {# hour measured, all of it at nobody on.} other {# hours measured, all of them at nobody on.}}</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.sample.peak" xml:space="preserve"> + <value>{count, plural, one {# hour measured, the busiest {peak} on {day} at {time} UTC.} other {# hours measured, the busiest {peak} on {day} at {time} UTC.}}</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.sample.more" xml:space="preserve"> + <value>{count, plural, one {# more hour answered and produced no count.} other {# more hours answered and produced no count.}}</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.day.line" xml:space="preserve"> + <value>{day} — {facts}</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.day.facts" xml:space="preserve"> + <value>{first}, {second}</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.day.allZero" xml:space="preserve"> + <value>measured at zero all day</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.day.peak" xml:space="preserve"> + <value>peak {count} at {time}</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.day.nobodyOn" xml:space="preserve"> + <value>nobody on {window}</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.day.noCount" xml:space="preserve"> + <value>no count in any hour</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.day.notMeasured" xml:space="preserve"> + <value>{count, plural, one {# hour not measured} other {# hours not measured}}</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.day.notCounted" xml:space="preserve"> + <value>{count, plural, one {# hour probed but uncountable} other {# hours probed but uncountable}}</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.column.day" xml:space="preserve"> + <value>day</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.column.quietest" xml:space="preserve"> + <value>quietest</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.column.busiest" xml:space="preserve"> + <value>busiest</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.column.at" xml:space="preserve"> + <value>at</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.column.noCount" xml:space="preserve"> + <value>no count</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.caption" xml:space="preserve"> + <value>Players on by day, in UTC. {window}.</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.times" xml:space="preserve"> + <value>times in UTC · {window}</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.rollingAverage" xml:space="preserve"> + <value>{weeks, plural, one {#-week rolling average} other {#-week rolling average}}</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.legend.counted" xml:space="preserve"> + <value>counted, including a measured zero</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.legend.notCounted" xml:space="preserve"> + <value>probed, no count could be read</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.legend.notMeasured" xml:space="preserve"> + <value>no measurement in that hour</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.plain.heading" xml:space="preserve"> + <value>When people are on (UTC)</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.key.counted" xml:space="preserve"> + <value>counted</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.key.counted.meaning" xml:space="preserve"> + <value>we got in and read a number, including a measured zero</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.key.uncounted.meaning" xml:space="preserve"> + <value>we got in and no number could be read</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="activity.key.notMeasured.meaning" xml:space="preserve"> + <value>we have no measurement for that hour</value> + <comment>the week of hours, said in words</comment> + </data> + <data name="locale.label" xml:space="preserve"> + <value>language</value> + <comment>the switcher's own chrome, which has to read in the locale being left</comment> + </data> + <data name="locale.submit" xml:space="preserve"> + <value>change language</value> + <comment>the switcher's own chrome, which has to read in the locale being left</comment> + </data> + <data name="about.title" xml:space="preserve"> + <value>About mu*index</value> + <comment>about: the page, and what a fact here is</comment> + </data> + <data name="about.lede" xml:space="preserve"> + <value>Every game here was measured by a machine that connected to it, and every value says where it came from and when. This page covers what that proves, what we get wrong, whose directories we read, and how to make the crawler stop.</value> + <comment>about: the page, and what a fact here is</comment> + </data> + <data name="about.measures.heading" xml:space="preserve"> + <value>What a fact here is</value> + <comment>about: the page, and what a fact here is</comment> + </data> + <data name="about.measures.declared.lead" xml:space="preserve"> + <value>Measured beats declared, and both are shown.</value> + <comment>about: the page, and what a fact here is</comment> + </data> + <data name="about.measures.declared.body" xml:space="preserve"> + <value>A game's MSSP report is the game describing itself. The telnet handshake is what we watched it do. Both appear on its page, labelled with how and when. Where they disagree, we show the disagreement.</value> + <comment>about: the page, and what a fact here is</comment> + </data> + <data name="about.measures.count.lead" xml:space="preserve"> + <value>A player count says where it came from.</value> + <comment>about: the page, and what a fact here is</comment> + </data> + <data name="about.measures.count.body" xml:space="preserve"> + <value>Either a WHO or DOING read at the connect screen, which we counted, or the game's own MSSP PLAYERS field, which it published. Never merged.</value> + <comment>about: the page, and what a fact here is</comment> + </data> + <data name="about.measures.unknown.lead" xml:space="preserve"> + <value>An answer we cannot read is unknown, never zero.</value> + <comment>about: the page, and what a fact here is</comment> + </data> + <data name="about.measures.unknown.body" xml:space="preserve"> + <value>Servers customise their WHO headers freely, and past a point our parser cannot read one. That is uncountable, its own state. A measured zero — we got in, nobody was there — is a count, and prints as one.</value> + <comment>about: the page, and what a fact here is</comment> + </data> + <data name="about.measures.reachable.lead" xml:space="preserve"> + <value>Reachable, never uptime.</value> + <comment>about: the page, and what a fact here is</comment> + </data> + <data name="about.measures.reachable.body" xml:space="preserve"> + <value>We open a socket from one host at intervals. A game we cannot route to is unreachable and perfectly alive. Nothing here claims a game's uptime, because nothing here measured it.</value> + <comment>about: the page, and what a fact here is</comment> + </data> + <data name="about.measures.hour.lead" xml:space="preserve"> + <value>An hour is counted, uncountable, or not measured.</value> + <comment>about: the page, and what a fact here is</comment> + </data> + <data name="about.measures.hour.body" xml:space="preserve"> + <value>The activity grid has three states. The third is empty and names no cause: an hour we could not reach and an hour we never probed are the same absence, and neither is that server's downtime.</value> + <comment>about: the page, and what a fact here is</comment> + </data> + <data name="about.limits.heading" xml:space="preserve"> + <value>What we know we get wrong</value> + <comment>about: what we know we get wrong</comment> + </data> + <data name="about.limits.grace.lead" xml:space="preserve"> + <value>Archive grace is measured from the day we found you.</value> + <comment>about: what we know we get wrong</comment> + </data> + <data name="about.limits.grace.body" xml:space="preserve"> + <value>A game that stops answering leaves the default listing after its grace period: a quarter of the reachable time we probed, floored at 60 days and capped at 365. A game running since 1995 starts at the floor on the day we discover it. We import nothing to fill in the years before we arrived.</value> + <comment>about: what we know we get wrong</comment> + </data> + <data name="about.limits.created.lead" xml:space="preserve"> + <value>We do not credit MSSP CREATED toward that grace.</value> + <comment>about: what we know we get wrong</comment> + </data> + <data name="about.limits.created.body" xml:space="preserve"> + <value>It is one hand-typed line in a config file, so crediting it would make the archive threshold gameable. It is shown as a declaration and buys nothing.</value> + <comment>about: what we know we get wrong</comment> + </data> + <data name="about.limits.claim.lead" xml:space="preserve"> + <value>Claiming a game earns the ceiling.</value> + <comment>about: what we know we get wrong</comment> + </data> + <data name="about.limits.claim.body" xml:space="preserve"> + <value>Proving server access is worth the full year of grace, however long we have been watching.</value> + <comment>about: what we know we get wrong</comment> + </data> + <data name="about.limits.oneHost.lead" xml:space="preserve"> + <value>Everything here is one host, looking at intervals.</value> + <comment>about: what we know we get wrong</comment> + </data> + <data name="about.limits.oneHost.body" xml:space="preserve"> + <value>A percentage of reachable time is a fraction of the window we observed, never of one we did not. No graphic here fills in the rest.</value> + <comment>about: what we know we get wrong</comment> + </data> + <data name="about.limits.deletion.lead" xml:space="preserve"> + <value>Nothing is ever deleted.</value> + <comment>about: what we know we get wrong</comment> + </data> + <data name="about.limits.deletion.body" xml:space="preserve"> + <value>Archiving takes a game out of the default listing, the rankings and the active-today figure, and nothing else. Its page, URL, history and address survive, it keeps being probed, and one successful probe puts it back.</value> + <comment>about: what we know we get wrong</comment> + </data> + <data name="about.never.heading" xml:space="preserve"> + <value>What this site will not do</value> + <comment>about: what this site will not do</comment> + </data> + <data name="about.never.votes.lead" xml:space="preserve"> + <value>No votes, stars, ratings or recommendations.</value> + <comment>about: what this site will not do</comment> + </data> + <data name="about.never.votes.body" xml:space="preserve"> + <value>Rankings are computed from measured data only. A directory ranked by who can mobilise the most clicks describes the campaigning, not the hobby, and that is what killed the incumbents.</value> + <comment>about: what this site will not do</comment> + </data> + <data name="about.never.forums.lead" xml:space="preserve"> + <value>No forums, reviews, wikis, comments or player profiles.</value> + <comment>about: what this site will not do</comment> + </data> + <data name="about.never.forums.body" xml:space="preserve"> + <value>Orientation material — what a MUSH is, which codebase suits collaborative roleplay — is written, signed and versioned like the rest of the site.</value> + <comment>about: what this site will not do</comment> + </data> + <data name="about.never.names.lead" xml:space="preserve"> + <value>Player names are never persisted.</value> + <comment>about: what this site will not do</comment> + </data> + <data name="about.never.names.body" xml:space="preserve"> + <value>A WHO reply is parsed in memory for a count and the shape of the header. The names are not written down; aggregates use a salted hash with a rotating salt.</value> + <comment>about: what this site will not do</comment> + </data> + <data name="about.never.population.lead" xml:space="preserve"> + <value>No absolute population figure is published.</value> + <comment>about: what this site will not do</comment> + </data> + <data name="about.never.population.body" xml:space="preserve"> + <value>Per-codebase and per-protocol shares ship: a ratio over the measured set survives the games we cannot count. "How many people play MU*" does not, because that number would not survive being quoted.</value> + <comment>about: what this site will not do</comment> + </data> + <data name="about.crawler.heading" xml:space="preserve"> + <value>The crawler, and how to make it stop</value> + <comment>about: the crawler, and how to make it stop</comment> + </data> + <data name="about.crawler.probe.lead" xml:space="preserve"> + <value>A probe is one connection that never logs in.</value> + <comment>about: the crawler, and how to make it stop</comment> + </data> + <data name="about.crawler.probe.body" xml:space="preserve"> + <value>It opens a socket, negotiates telnet options, reads the connect screen, asks for MSSP by negotiating option 70, sends {commands}, and disconnects. No character, no login, nothing changed on the far side. A timeout bounds the session so a wedged probe cannot sit on a connection slot.</value> + <comment>about: the crawler, and how to make it stop</comment> + </data> + <data name="about.crawler.delay.lead" xml:space="preserve"> + <value>CRAWL DELAY wins.</value> + <comment>about: the crawler, and how to make it stop</comment> + </data> + <data name="about.crawler.delay.body" xml:space="preserve"> + <value>A game that states a preferred minimum gap in its MSSP report gets it, over our own schedule in both directions: 720 hours means monthly, not weekly. A dark game is still tried for ever at the longer interval, which is how it re-lists itself when it comes back.</value> + <comment>about: the crawler, and how to make it stop</comment> + </data> + <data name="about.crawler.referral.lead" xml:space="preserve"> + <value>A referred address is verified, never trusted.</value> + <comment>about: the crawler, and how to make it stop</comment> + </data> + <data name="about.crawler.referral.body" xml:space="preserve"> + <value>MSSP lets a game name other games. Every name is resolved before anything is dialled, and refused unless every address it resolves to is globally routable. A mixed answer refuses the whole target. Our refusal is filed as ours and never appears in a game's record as downtime.</value> + <comment>about: the crawler, and how to make it stop</comment> + </data> + <data name="about.crawler.screens.lead" xml:space="preserve"> + <value>Connect screens are shown because they are sent to everybody.</value> + <comment>about: the crawler, and how to make it stop</comment> + </data> + <data name="about.crawler.screens.body" xml:space="preserve"> + <value>A server paints its connect screen, unauthenticated, to every anonymous connection. We display it as evidence and label it. Ask and it comes down.</value> + <comment>about: the crawler, and how to make it stop</comment> + </data> + <data name="about.crawler.stop.lead" xml:space="preserve"> + <value>Say stop, and we stop — three ways.</value> + <comment>about: the crawler, and how to make it stop</comment> + </data> + <data name="about.crawler.stop.body" xml:space="preserve"> + <value>Publish {variable} 1 in your MSSP report, and the probe that reads it is the last one. Or publish a TXT record at {label}.your.host reading "{value}", which needs no MSSP support and no account here. Or write to a person. All three are honoured within one crawl cycle, recorded with the date and what we read, and enforced on the submission form too.</value> + <comment>about: the crawler, and how to make it stop</comment> + </data> + <data name="about.crawler.scope.lead" xml:space="preserve"> + <value>The MSSP field stops that listener; the record stops the host.</value> + <comment>about: the crawler, and how to make it stop</comment> + </data> + <data name="about.crawler.scope.body" xml:space="preserve"> + <value>MSSP is published by the port that answered, so it speaks for that port — MU* hosting routinely runs unrelated games on one domain, and one must not silence its neighbour. A TXT record covers every port unless it names one, as "{value}=4201". Anything there we cannot read as a port list means the whole host, so "{value}=all" works.</value> + <comment>about: the crawler, and how to make it stop</comment> + </data> + <data name="about.crawler.dns.lead" xml:space="preserve"> + <value>The DNS route is the one you can undo without asking us.</value> + <comment>about: the crawler, and how to make it stop</comment> + </data> + <data name="about.crawler.dns.body" xml:space="preserve"> + <value>A TXT record is readable without connecting to a server that told us not to, so we re-read it before every dial. Delete it and we dial again within a week. An MSSP field cannot be re-read without doing the thing you asked us to stop, so MSSP opt-outs and written requests stand until you say otherwise. That TXT lookup is all an opted-out address gets: it touches your nameserver, never your game.</value> + <comment>about: the crawler, and how to make it stop</comment> + </data> + <data name="about.crawler.stopping.lead" xml:space="preserve"> + <value>Stopping is not deleting, and it is not downtime.</value> + <comment>about: the crawler, and how to make it stop</comment> + </data> + <data name="about.crawler.stopping.body" xml:space="preserve"> + <value>A game that opts out keeps its page, its address and everything we measured before it asked. Only new data stops: the activity grid stops gaining hours and names no cause, because our decision to stop knocking is a fact about us. It is recorded on the crawl that did not happen, and in the register of who asked.</value> + <comment>about: the crawler, and how to make it stop</comment> + </data> + <data name="about.crawler.unlist.lead" xml:space="preserve"> + <value>If stopping is not enough, the listing can go too.</value> + <comment>about: the crawler, and how to make it stop</comment> + </data> + <data name="about.crawler.unlist.body" xml:space="preserve"> + <value>Once we have stopped on every address your game answers on, your dashboard offers one more thing: take it out of the listing, the rankings and the daily figure. The page and every address it has ever had still answer, and nothing is deleted — it stops being somewhere a reader arrives by browsing. It needs a verified claim, because it is a decision about your game and we record who made it. And a probe undoes it: take your opt-out back, and the next dial that gets an answer puts you back in the listing without asking us twice.</value> + <comment>about: the crawler, and how to make it stop</comment> + </data> + <data name="about.identity.announced" xml:space="preserve"> + <value>The crawler names itself {name} when a server asks what it is.</value> + <comment>about: who is knocking</comment> + </data> + <data name="about.identity.unannounced" xml:space="preserve"> + <value>The crawler is configured to call itself {name} but cannot yet say so. Its telnet library gives a client no way to set the terminal type, so your logs see that library's default, and NEW-ENVIRON is answered from the crawler host's environment. Both are gaps in the library and ours to fix there. Until then, recognise a probe by its shape: one connection, no login, a short read-only command set, gone.</value> + <comment>about: who is knocking</comment> + </data> + <data name="about.identity.crawler" xml:space="preserve"> + <value>crawler</value> + <comment>about: who is knocking</comment> + </data> + <data name="about.identity.contact" xml:space="preserve"> + <value>contact</value> + <comment>about: who is knocking</comment> + </data> + <data name="about.identity.crawler.line" xml:space="preserve"> + <value>Crawler: {name}</value> + <comment>about: who is knocking</comment> + </data> + <data name="about.identity.contact.line" xml:space="preserve"> + <value>Contact: {url}</value> + <comment>about: who is knocking</comment> + </data> + <data name="about.identity.placeholder" xml:space="preserve"> + <value>— placeholder; this deployment set no contact address</value> + <comment>about: who is knocking</comment> + </data> + <data name="about.identity.placeholder.plain" xml:space="preserve"> + <value>No contact address is configured, so the one above is a placeholder and answers nobody.</value> + <comment>about: who is knocking</comment> + </data> + <data name="about.sources.heading" xml:space="preserve"> + <value>Where the list of games came from</value> + <comment>about: where the list of games came from</comment> + </data> + <data name="about.sources.addresses.lead" xml:space="preserve"> + <value>We take addresses. Nothing else.</value> + <comment>about: where the list of games came from</comment> + </data> + <data name="about.sources.addresses.body" xml:space="preserve"> + <value>A backfill takes a host and a port. No player counts, no reachability history, no descriptions, no fields, and no note of which site an address came from.</value> + <comment>about: where the list of games came from</comment> + </data> + <data name="about.sources.less.lead" xml:space="preserve"> + <value>Deliberately less than those sites can give.</value> + <comment>about: where the list of games came from</comment> + </data> + <data name="about.sources.less.body" xml:space="preserve"> + <value>Several hold years of dated player counts. Importing that would fill the heatmaps of the games somebody else was already watching, and rest this site's central claim on another party's prober.</value> + <comment>about: where the list of games came from</comment> + </data> + <data name="about.sources.origin.lead" xml:space="preserve"> + <value>A game's origin is not one fact.</value> + <comment>about: where the list of games came from</comment> + </data> + <data name="about.sources.origin.body" xml:space="preserve"> + <value>Any game worth listing appears in several of these directories, so "imported from" would name whichever fetch ran first. That a game exists is public information; where we read it adds nothing and is the part of somebody else's work with the least claim to be ours.</value> + <comment>about: where the list of games came from</comment> + </data> + <data name="about.sources.etiquette.lead" xml:space="preserve"> + <value>Reading somebody's site is still reading somebody's site.</value> + <comment>about: where the list of games came from</comment> + </data> + <data name="about.sources.etiquette.body" xml:space="preserve"> + <value>We ask for a bulk export or a documented endpoint before scraping, read robots.txt first, and rate-limit scrapes hard. A source that needs its maintainer's say-so is not fetched until a person can state they were asked.</value> + <comment>about: where the list of games came from</comment> + </data> + <data name="about.source.read" xml:space="preserve"> + <value>read — addresses only</value> + <comment>about: where the list of games came from</comment> + </data> + <data name="about.source.withheld" xml:space="preserve"> + <value>not read — awaiting permission</value> + <comment>about: where the list of games came from</comment> + </data> + <data name="about.source.tintinMssp.note" xml:space="preserve"> + <value>One page, one request. Published by a crawler that connects to each game and prints what it read.</value> + <comment>about: where the list of games came from</comment> + </data> + <data name="about.source.tintinMsdp.note" xml:space="preserve"> + <value>The same crawler's MSDP listing. Nearly a subset of its MSSP sibling, read for the few addresses it reaches that the other does not.</value> + <comment>about: where the list of games came from</comment> + </data> + <data name="about.source.mudConnector.note" xml:space="preserve"> + <value>Publishes its whole catalogue on one page, so reading it costs a single request. Our largest source of addresses, and of no measurements.</value> + <comment>about: where the list of games came from</comment> + </data> + <data name="about.source.mudStats.note" xml:space="preserve"> + <value>One index page and one page per world, so a scrape rather than an export. On 30 July 2026 we fetched 143 of their pages, fifteen seconds apart and honouring robots.txt, but before anyone had written to them. That should not have happened. The gate now takes a person willing to state the maintainer was asked.</value> + <comment>about: where the list of games came from</comment> + </data> + <data name="about.source.mudVerse.note" xml:space="preserve"> + <value>Implemented, tested, never run. The strongest source here on every axis except permission, and nothing will be fetched until somebody has written to them.</value> + <comment>about: where the list of games came from</comment> + </data> + <data name="about.licence.heading" xml:space="preserve"> + <value>Licence</value> + <comment>about: licence</comment> + </data> + <data name="about.licence.code.lead" xml:space="preserve"> + <value>The code is MIT.</value> + <comment>about: licence</comment> + </data> + <data name="about.licence.code.body" xml:space="preserve"> + <value>The site, the crawler and the parsers are open source under the MIT licence.</value> + <comment>about: licence</comment> + </data> + <data name="about.licence.open.lead" xml:space="preserve"> + <value>The licence for the data is an open question.</value> + <comment>about: licence</comment> + </data> + <data name="about.licence.open.body" xml:space="preserve"> + <value>A separate decision from the code's, and not yet taken. Treat the terms below as this deployment's current answer, not the project's settled position. A rival directory taking the whole catalogue is a success condition here, so whatever is settled will not stand in the way of one.</value> + <comment>about: licence</comment> + </data> + <data name="about.licence.codeLabel" xml:space="preserve"> + <value>code</value> + <comment>about: licence</comment> + </data> + <data name="about.licence.dataLabel" xml:space="preserve"> + <value>data, as this deployment serves it</value> + <comment>about: licence</comment> + </data> + <data name="about.licence.creditLabel" xml:space="preserve"> + <value>credit as</value> + <comment>about: licence</comment> + </data> + <data name="about.licence.code.line" xml:space="preserve"> + <value>Code: {licence}</value> + <comment>about: licence</comment> + </data> + <data name="about.licence.data.line" xml:space="preserve"> + <value>Data: {licence}</value> + <comment>about: licence</comment> + </data> + <data name="about.licence.credit.line" xml:space="preserve"> + <value>Credit as: {credit}</value> + <comment>about: licence</comment> + </data> + <data name="about.licence.deployment" xml:space="preserve"> + <value>(what this deployment serves. The project's own answer is still open.)</value> + <comment>about: licence</comment> + </data> + <data name="submit.title" xml:space="preserve"> + <value>Submit a game</value> + <comment>submit a game</comment> + </data> + <data name="submit.lede" xml:space="preserve"> + <value>Tell us where a game is. A host and a port is the whole form; everything else on this site is measured by our own crawler.</value> + <comment>submit a game</comment> + </data> + <data name="submit.host.label" xml:space="preserve"> + <value>Host</value> + <comment>submit a game</comment> + </data> + <data name="submit.port.label" xml:space="preserve"> + <value>Port</value> + <comment>submit a game</comment> + </data> + <data name="submit.host.hint" xml:space="preserve"> + <value>mud.example.org, or paste mud.example.org:4201 and leave the port empty</value> + <comment>submit a game</comment> + </data> + <data name="submit.button" xml:space="preserve"> + <value>Submit</value> + <comment>submit a game</comment> + </data> + <data name="submit.noCatalogue" xml:space="preserve"> + <value>Submitting needs a database, and this site is running on the demo fixture. There is no crawl registry to write into, so the form is absent rather than quietly doing nothing.</value> + <comment>submit a game</comment> + </data> + <data name="submit.notHere" xml:space="preserve"> + <value>Not here</value> + <comment>submit a game</comment> + </data> + <data name="submit.what.heading" xml:space="preserve"> + <value>What happens to an address</value> + <comment>submit a game</comment> + </data> + <data name="submit.what.resolve" xml:space="preserve"> + <value>We resolve the address before dialling it, and refuse anything that resolves off the public internet. That is a decision about our own socket, never a fact about a game.</value> + <comment>submit a game</comment> + </data> + <data name="submit.what.optOut" xml:space="preserve"> + <value>If whoever runs that host has asked us not to crawl it, we will not take the address, whoever submits it. A stranger cannot put your game back on this site.</value> + <comment>submit a game</comment> + </data> + <data name="submit.what.schedule" xml:space="preserve"> + <value>If it answers, we read what the server says for itself and keep reading it on its own schedule, for ever. An address only has to be given once.</value> + <comment>submit a game</comment> + </data> + <data name="submit.what.claim" xml:space="preserve"> + <value>Nothing appears on the site until somebody proves they run it. Claiming takes a passkey and one line published on the game itself.</value> + <comment>submit a game</comment> + </data> + <data name="submit.what.duplicate" xml:space="preserve"> + <value>An address we already have collapses onto the existing entry. Sending it twice makes no second listing and brings no probe forward.</value> + <comment>submit a game</comment> + </data> + <data name="submit.answer.thatAddress" xml:space="preserve"> + <value>that address</value> + <comment>submit a game</comment> + </data> + <data name="submit.accepted.heading" xml:space="preserve"> + <value>In the registry.</value> + <comment>submit a game</comment> + </data> + <data name="submit.accepted.sentence" xml:space="preserve"> + <value>{address} will be dialled on the next crawl cycle, then on its own schedule for ever. It appears here once somebody proves they run it — come back to this form with the same address and it will hand you the link.</value> + <comment>submit a game</comment> + </data> + <data name="submit.unclaimed.heading" xml:space="preserve"> + <value>We have it, unclaimed.</value> + <comment>submit a game</comment> + </data> + <data name="submit.unclaimed.sentence" xml:space="preserve"> + <value>{address} is one we already measure. It stays off the site until somebody proves they run it. If that is you, this is the way in.</value> + <comment>submit a game</comment> + </data> + <data name="submit.known.heading" xml:space="preserve"> + <value>We already have that one.</value> + <comment>submit a game</comment> + </data> + <data name="submit.known.sentence" xml:space="preserve"> + <value>{address} is a game we already measure. Nothing was created and nothing was changed.</value> + <comment>submit a game</comment> + </data> + <data name="submit.knownAddress.heading" xml:space="preserve"> + <value>We already have that address.</value> + <comment>submit a game</comment> + </data> + <data name="submit.knownAddress.sentence" xml:space="preserve"> + <value>{address} is already known to us. Nothing was created and nothing was changed.</value> + <comment>submit a game</comment> + </data> + <data name="submit.queued.heading" xml:space="preserve"> + <value>Already waiting.</value> + <comment>submit a game</comment> + </data> + <data name="submit.queued.sentence" xml:space="preserve"> + <value>{address} is in the crawl registry and has not answered yet. Sending it again does not bring it forward: a target keeps its own schedule, so nobody can hurry us at somebody else's server.</value> + <comment>submit a game</comment> + </data> + <data name="submit.malformed.heading" xml:space="preserve"> + <value>Not an address we can dial.</value> + <comment>submit a game</comment> + </data> + <data name="submit.malformed.sentence" xml:space="preserve"> + <value>A host needs a dot or a colon in it, and a port is a number between 1 and 65535. Fill in both boxes, or paste mud.example.org:4201 into the first.</value> + <comment>submit a game</comment> + </data> + <data name="submit.undialable.heading" xml:space="preserve"> + <value>We cannot dial that.</value> + <comment>submit a game</comment> + </data> + <data name="submit.undialable.sentence" xml:space="preserve"> + <value>Three things produce this answer for {address}: the name may not resolve, it may resolve off the public internet, or whoever runs that host may have asked us to stay away. We deliberately do not say which, because answering that for a stranger maps a network from outside it. Nothing was recorded about the address; the decision was ours and it is filed as ours.</value> + <comment>submit a game</comment> + </data> + <data name="submit.tooMany.heading" xml:space="preserve"> + <value>Enough for now.</value> + <comment>submit a game</comment> + </data> + <data name="submit.tooMany.sentence" xml:space="preserve"> + <value>This form is rate-limited by sender, and you have hit the bound. Come back in an hour. Nothing was lost — anything we took is already in the registry.</value> + <comment>submit a game</comment> + </data> + <data name="submit.link.claim" xml:space="preserve"> + <value>claim this game</value> + <comment>submit a game</comment> + </data> + <data name="account.signIn.title" xml:space="preserve"> + <value>Sign in</value> + <comment>signing in, which is a passkey and nothing else</comment> + </data> + <data name="account.signIn.preview" xml:space="preserve"> + <value>Sign in with a passkey to claim a game you run. There is no password to lose and none to steal.</value> + <comment>signing in, which is a passkey and nothing else</comment> + </data> + <data name="account.signIn.noDatabase" xml:space="preserve"> + <value>Claiming needs a database, and this site is running on the demo fixture. There is nothing to sign in to.</value> + <comment>signing in, which is a passkey and nothing else</comment> + </data> + <data name="account.signIn.passkey.lead" xml:space="preserve"> + <value>Sign-in is a passkey.</value> + <comment>signing in, which is a passkey and nothing else</comment> + </data> + <data name="account.signIn.passkey.body" xml:space="preserve"> + <value>Your device or password manager holds the private key; we hold only the public half. No password, no email.</value> + <comment>signing in, which is a passkey and nothing else</comment> + </data> + <data name="account.signIn.button" xml:space="preserve"> + <value>Sign in with a passkey</value> + <comment>signing in, which is a passkey and nothing else</comment> + </data> + <data name="account.signIn.script" xml:space="preserve"> + <value>The one page here that needs JavaScript. Passkeys cannot work without it.</value> + <comment>signing in, which is a passkey and nothing else</comment> + </data> + <data name="account.register.heading" xml:space="preserve"> + <value>No account yet?</value> + <comment>signing in, which is a passkey and nothing else</comment> + </data> + <data name="account.register.lede" xml:space="preserve"> + <value>You need one only to claim a game you run. Pick a name to be known by — a label beside your claim, not a real name.</value> + <comment>signing in, which is a passkey and nothing else</comment> + </data> + <data name="account.register.name.label" xml:space="preserve"> + <value>Name</value> + <comment>signing in, which is a passkey and nothing else</comment> + </data> + <data name="account.register.name.placeholder" xml:space="preserve"> + <value>e.g. corvid-admin</value> + <comment>signing in, which is a passkey and nothing else</comment> + </data> + <data name="account.register.button" xml:space="preserve"> + <value>Create an account with a passkey</value> + <comment>signing in, which is a passkey and nothing else</comment> + </data> + <data name="account.store.heading" xml:space="preserve"> + <value>What we store</value> + <comment>signing in, which is a passkey and nothing else</comment> + </data> + <data name="account.store.name" xml:space="preserve"> + <value>The name you chose.</value> + <comment>signing in, which is a passkey and nothing else</comment> + </data> + <data name="account.store.keys" xml:space="preserve"> + <value>The public key of each passkey you register, and what your device called it.</value> + <comment>signing in, which is a passkey and nothing else</comment> + </data> + <data name="account.store.claims" xml:space="preserve"> + <value>Which games you have claimed, and when.</value> + <comment>signing in, which is a passkey and nothing else</comment> + </data> + <data name="account.store.note" xml:space="preserve"> + <value>No email address, no password, no IP log tied to your account. Lose every passkey and you can publish a fresh claim token on your game and start again: the game is the proof, not the account.</value> + <comment>signing in, which is a passkey and nothing else</comment> + </data> + <data name="date.absolute" xml:space="preserve"> + <value>{day} {month} {year}</value> + <comment>dates, ages and provenance — the two shapes on nearly every page</comment> + </data> + <data name="date.stamp" xml:space="preserve"> + <value>{date} {time} UTC</value> + <comment>dates, ages and provenance — the two shapes on nearly every page</comment> + </data> + <data name="age.short.now" xml:space="preserve"> + <value>now</value> + <comment>the age ladder, in three registers</comment> + </data> + <data name="age.short.minutes" xml:space="preserve"> + <value>{count, plural, one {#m} other {#m}}</value> + <comment>the age ladder, in three registers</comment> + </data> + <data name="age.short.hours" xml:space="preserve"> + <value>{count, plural, one {#h} other {#h}}</value> + <comment>the age ladder, in three registers</comment> + </data> + <data name="age.short.days" xml:space="preserve"> + <value>{count, plural, one {#d} other {#d}}</value> + <comment>the age ladder, in three registers</comment> + </data> + <data name="age.short.weeks" xml:space="preserve"> + <value>{count, plural, one {#w} other {#w}}</value> + <comment>the age ladder, in three registers</comment> + </data> + <data name="age.short.months" xml:space="preserve"> + <value>{count, plural, one {#mo} other {#mo}}</value> + <comment>the age ladder, in three registers</comment> + </data> + <data name="age.short.years" xml:space="preserve"> + <value>{count, plural, one {#y} other {#y}}</value> + <comment>the age ladder, in three registers</comment> + </data> + <data name="age.ago.now" xml:space="preserve"> + <value>just now</value> + <comment>the age ladder, in three registers</comment> + </data> + <data name="age.ago.minutes" xml:space="preserve"> + <value>{count, plural, one {#m ago} other {#m ago}}</value> + <comment>the age ladder, in three registers</comment> + </data> + <data name="age.ago.hours" xml:space="preserve"> + <value>{count, plural, one {#h ago} other {#h ago}}</value> + <comment>the age ladder, in three registers</comment> + </data> + <data name="age.ago.days" xml:space="preserve"> + <value>{count, plural, one {#d ago} other {#d ago}}</value> + <comment>the age ladder, in three registers</comment> + </data> + <data name="age.ago.weeks" xml:space="preserve"> + <value>{count, plural, one {#w ago} other {#w ago}}</value> + <comment>the age ladder, in three registers</comment> + </data> + <data name="age.ago.months" xml:space="preserve"> + <value>{count, plural, one {#mo ago} other {#mo ago}}</value> + <comment>the age ladder, in three registers</comment> + </data> + <data name="age.ago.years" xml:space="preserve"> + <value>{count, plural, one {#y ago} other {#y ago}}</value> + <comment>the age ladder, in three registers</comment> + </data> + <data name="age.dark.now" xml:space="preserve"> + <value>just now</value> + <comment>the age ladder, in three registers</comment> + </data> + <data name="age.dark.minutes" xml:space="preserve"> + <value>{count, plural, one {#m ago} other {#m ago}}</value> + <comment>the age ladder, in three registers</comment> + </data> + <data name="age.dark.hours" xml:space="preserve"> + <value>{count, plural, one {#h ago} other {#h ago}}</value> + <comment>the age ladder, in three registers</comment> + </data> + <data name="age.dark.days" xml:space="preserve"> + <value>{count, plural, one {#d ago} other {#d ago}}</value> + <comment>the age ladder, in three registers</comment> + </data> + <data name="age.dark.weeks" xml:space="preserve"> + <value>{count, plural, one {#w ago} other {#w ago}}</value> + <comment>the age ladder, in three registers</comment> + </data> + <data name="age.dark.months" xml:space="preserve"> + <value>{count, plural, one {#mo ago} other {#mo ago}}</value> + <comment>the age ladder, in three registers</comment> + </data> + <data name="age.dark.years" xml:space="preserve"> + <value>{count, plural, one {#y ago} other {#y ago}}</value> + <comment>the age ladder, in three registers</comment> + </data> + <data name="time.title" xml:space="preserve"> + <value>{age}, {stamp}</value> + <comment>the age ladder, in three registers</comment> + </data> + <data name="time.spoken" xml:space="preserve"> + <value>, {stamp}</value> + <comment>the age ladder, in three registers</comment> + </data> + <data name="chip.title" xml:space="preserve"> + <value>{value} — {how} via {source}, last confirmed {date}</value> + <comment>the provenance chip's tooltip</comment> + </data> + <data name="chip.title.stale" xml:space="preserve"> + <value>{value} — {how} via {source}, last confirmed {date} (past its expected refresh)</value> + <comment>the provenance chip's tooltip</comment> + </data> + <data name="chip.plain" xml:space="preserve"> + <value>({how}, {age})</value> + <comment>the provenance chip's tooltip</comment> + </data> + <data name="chip.plain.stale" xml:space="preserve"> + <value>({how}, {age}, stale)</value> + <comment>the provenance chip's tooltip</comment> + </data> + <data name="provenance.game.ownerDeclared" xml:space="preserve"> + <value>owner-declared</value> + <comment>the provenance chip's tooltip</comment> + </data> + <data name="source.staff" xml:space="preserve"> + <value>staff</value> + <comment>how a value reached us, one id per source</comment> + </data> + <data name="source.handshake" xml:space="preserve"> + <value>the telnet handshake</value> + <comment>how a value reached us, one id per source</comment> + </data> + <data name="source.owner" xml:space="preserve"> + <value>the owner</value> + <comment>how a value reached us, one id per source</comment> + </data> + <data name="source.who" xml:space="preserve"> + <value>WHO</value> + <comment>how a value reached us, one id per source</comment> + </data> + <data name="source.i3" xml:space="preserve"> + <value>I3</value> + <comment>how a value reached us, one id per source</comment> + </data> + <data name="source.mssp" xml:space="preserve"> + <value>MSSP</value> + <comment>how a value reached us, one id per source</comment> + </data> + <data name="source.info" xml:space="preserve"> + <value>INFO</value> + <comment>how a value reached us, one id per source</comment> + </data> + <data name="source.i3Mudlist" xml:space="preserve"> + <value>the I3 mudlist</value> + <comment>how a value reached us, one id per source</comment> + </data> + <data name="source.banner" xml:space="preserve"> + <value>the connect screen</value> + <comment>how a value reached us, one id per source</comment> + </data> + <data name="ecosystem.title" xml:space="preserve"> + <value>The ecosystem</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.noTotals" xml:space="preserve"> + <value>Shares, never totals. We do not publish a figure for how many people play MU*: a ratio over the games we measured survives the ones we cannot reach, and a headcount does not.</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.listed" xml:space="preserve"> + <value>{count, plural, one {{value} game listed} other {{value} games listed}}</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.handshakes" xml:space="preserve"> + <value>{count, plural, one {{value} game whose handshake we completed} other {{value} games whose handshake we completed}}</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.msspReports" xml:space="preserve"> + <value>{count, plural, one {{value} game whose MSSP report we hold} other {{value} games whose MSSP report we hold}}</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.oldestHandshake" xml:space="preserve"> + <value>Oldest handshake here: confirmed {age} ago.</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.share" xml:space="preserve"> + <value>{count, number} of {total, number} ({fraction, number, ::percent .0})</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.share.nothing" xml:space="preserve"> + <value>{count, number} of {total, number} — nothing measured yet</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.share.percent" xml:space="preserve"> + <value>{fraction, number, ::percent .0}</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.codebases.title" xml:space="preserve"> + <value>Codebases</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.codebases.basis" xml:space="preserve"> + <value>Of the {listed, plural, one {# game} other {# games}} listed, {identified, number} told us what they run, and every share below is over those {identified, number}. A codebase we could not read is left out of the denominator, never counted as something else.</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.codebases.none" xml:space="preserve"> + <value>No listed game has told us its codebase yet.</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.soleUse" xml:space="preserve"> + <value>{share} run a codebase no other listed game runs — one game each, which is a name rather than a share. They are inside the denominator above and folded out of the bars, not dropped:</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.lineages.title" xml:space="preserve"> + <value>Lineages</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.lineages.basis" xml:space="preserve"> + <value>The same games, grouped by the tradition their server descends from — our reading of the codebase, not anything a game published. No game reports "MUSH": MSSP has no such value, and most of the MUSH world publishes no MSSP at all, so this is the only way the question can be asked.</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.lineages.none" xml:space="preserve"> + <value>No listed game runs a codebase we place in a lineage yet.</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.lineages.notClassified" xml:space="preserve"> + <value>{count, plural, one {# of those games runs a codebase} other {# of those games run codebases}} we do not place in any lineage — several say as much themselves, publishing {family}. They are inside the denominator above and in nobody's share.</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.protocols.title" xml:space="preserve"> + <value>Protocols</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.protocols.floor" xml:space="preserve"> + <value>Read every measured figure below as a floor. We ask for MSSP by name, so silence there is an answer. Nothing else here is requested, and a server may support a protocol without ever offering it.</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.mssp.instrument" xml:space="preserve"> + <value>{instrument} is the one row below that is not a floor: we ask every server for it by name, so the games that did not offer it were asked and declined. It is also the only one with no declared figure, because every game whose report we hold supports it by demonstration and a count of the ones that also listed it would measure a habit against that.</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.mssp.gap" xml:space="preserve"> + <value>We hold {reports, number} reports and {offered, plural, one {# game} other {# games}} offer MSSP today: the other {gap, number} stopped publishing one after we read it, and a report is not thrown away because it stopped being reissued.</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.protocols.caption" xml:space="preserve"> + <value>Protocol adoption. Measured is what a server offered in a completed handshake; declared is what its MSSP claims. Two sets of games, so two denominators.</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.column.protocol" xml:space="preserve"> + <value>protocol</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.column.measured" xml:space="preserve"> + <value>measured — of {basis}</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.column.declared" xml:space="preserve"> + <value>declared — of {basis}</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.measured.never" xml:space="preserve"> + <value>not measured — never observed</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.measured.declined" xml:space="preserve"> + <value>{share} · {declined, plural, one {# game} other {# games}} declined when asked</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.measured.unasked" xml:space="preserve"> + <value>{share} · {unobserved, plural, one {# game} other {# games}} neither offered nor asked</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.measured.declinedAndUnasked" xml:space="preserve"> + <value>{share} · {declined, plural, one {# game} other {# games}} declined when asked · {unobserved, plural, one {# game} other {# games}} neither offered nor asked</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.declared.none" xml:space="preserve"> + <value>not asked — every report here is the answer</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.curve.title" xml:space="preserve"> + <value>Adoption over time</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.curve.caveat" xml:space="preserve"> + <value>Each point is a share over the games we had measured that day, so this line moves for two reasons: a game changing what it offers, and the set of games we can measure changing around it. Only the first is adoption. The transition count below is the part that is purely games changing their minds.</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.curve.caption" xml:space="preserve"> + <value>Measured share of each protocol, oldest reading first</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.curve.then" xml:space="preserve"> + <value>then</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.curve.now" xml:space="preserve"> + <value>now</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.curve.notMeasured" xml:space="preserve"> + <value>not measured</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.snapshot.title" xml:space="preserve"> + <value>A snapshot, not a curve</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.snapshot" xml:space="preserve"> + <value>A snapshot of what we can measure now. An adoption curve plots games changing their minds, and we record a change when it happens, so the curve becomes drawable once enough have been recorded. Plotting when we first reached each game would measure the crawl, not the hobby.</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.transitions" xml:space="preserve"> + <value>{count, plural, one {# capability change} other {# capability changes}} recorded so far — the material a curve is drawn from.</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.transitions.none" xml:space="preserve"> + <value>No measured capability has changed yet, so there is nothing to plot.</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.plain.denominators" xml:space="preserve"> + <value>Measured is of {measured}; declared is of {declared}. Two sets of games, so two denominators.</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.plain.counts" xml:space="preserve"> + <value>{listed} · {handshakes} · {mssp}.</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.plain.oldestHandshake" xml:space="preserve"> + <value>The oldest handshake in this picture was last confirmed {age} ago.</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.plain.lineages" xml:space="preserve"> + <value>The same games, grouped by the tradition their server descends from. This is {evidence} — {meaning} — and not anything a game published: no game reports "MUSH", because MSSP has no such value and most of the MUSH world publishes no MSSP at all.</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.plain.measured" xml:space="preserve"> + <value>measured: {value}</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="ecosystem.plain.declared" xml:space="preserve"> + <value>declared: {value}</value> + <comment>the ecosystem dashboard: shares, never totals, and never a share without its set</comment> + </data> + <data name="rankings.title" xml:space="preserve"> + <value>Rankings</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.noVote" xml:space="preserve"> + <value>Computed from measured data only. No votes, stars or ratings, ever. Nothing here ranks quality. We have not measured it.</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.busiest.title" xml:space="preserve"> + <value>Busiest, by measured concurrent players</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.window.label" xml:space="preserve"> + <value>Ranking window</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.span" xml:space="preserve"> + <value>{days, plural, one {# day} other {# days}}</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.basis.median" xml:space="preserve"> + <value>Median of the player counts we measured over the last {days, plural, one {# day} other {# days}}.</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.basis.none" xml:space="preserve"> + <value>No game yet has the {samples, number} samples across {days, plural, one {# day} other {# days}} that a median needs.</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.basis.eligible" xml:space="preserve"> + <value>{eligible, plural, one {# game} other {# games}} of {listed, number} have the {samples, number} samples across {days, plural, one {# day} other {# days}} it needs.</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.basis.zero" xml:space="preserve"> + <value>A measured zero counts; an unreadable count does not.</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.spanChoice" xml:space="preserve"> + <value>A week says who is busy now; a quarter says who has been busy. They are different questions and a game can lead one and not the other. Days are whole days, UTC.</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.busiest.empty" xml:space="preserve"> + <value>No listed game has enough counted samples to rank yet — a statement about how long we have been measuring, not about how busy anybody is.</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.busiest.caption" xml:space="preserve"> + <value>Games ranked by the median of the player counts we measured over the last {days, plural, one {# day} other {# days}}. Games on the same median share a place; nothing here breaks the tie.</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.column.place" xml:space="preserve"> + <value>#</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.column.game" xml:space="preserve"> + <value>game</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.column.median" xml:space="preserve"> + <value>median</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.column.peak" xml:space="preserve"> + <value>peak</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.column.samples" xml:space="preserve"> + <value>counted samples</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.column.days" xml:space="preserve"> + <value>days measured</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.spells.title" xml:space="preserve"> + <value>Longest unbroken reachable spell</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.spells.basis" xml:space="preserve"> + <value>Every probe since the date given found the game reachable. Reachable, not up: we measure a socket from one host, and a game we cannot route to is perfectly alive. A spell cannot be longer than we have been watching, so the date is the fact and the duration follows.</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.spells.empty" xml:space="preserve"> + <value>No listed game is in an unbroken reachable spell right now.</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.spells.caption" xml:space="preserve"> + <value>Games whose every probe since the date given found them reachable. Games reachable since the same date share a place; nothing here breaks the tie.</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.column.since" xml:space="preserve"> + <value>reachable since</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.column.duration" xml:space="preserve"> + <value>that is</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.archivedNote" xml:space="preserve"> + <value>Archived games are out of both tables and nothing else; one successful probe puts them back.</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.plain.busiest" xml:space="preserve"> + <value>Busiest — median measured players, last {days, plural, one {# day} other {# days}}</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.plain.windows" xml:space="preserve"> + <value>windows:</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.plain.thisOne" xml:space="preserve"> + <value>this one</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.plain.row" xml:space="preserve"> + <value>median {median, number} · peak {peak, number} · {samples, plural, one {# counted sample} other {# counted samples}} over {days, number} of {window, number} days</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="rankings.plain.spellRow" xml:space="preserve"> + <value>reachable on every probe since {date} · {duration}</value> + <comment>the rankings: computed from measured data only, and it says so first</comment> + </data> + <data name="archive.title" xml:space="preserve"> + <value>The archive</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.lede" xml:space="preserve"> + <value>Games that have stopped answering. Nothing was deleted. Still probed weekly, and one successful probe puts a game back in the listing the same day.</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.search.legend" xml:space="preserve"> + <value>search the archive</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.search.label" xml:space="preserve"> + <value>Search archived games</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.search.placeholder" xml:space="preserve"> + <value>name, codebase or description</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.search.submit" xml:space="preserve"> + <value>show</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.count" xml:space="preserve"> + <value>{count, plural, =0 {No archived games} one {# archived game} other {# archived games}}</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.badge" xml:space="preserve"> + <value>archived</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.lastReachable" xml:space="preserve"> + <value>last reachable</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.knownLive" xml:space="preserve"> + <value>known live</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.darkFor" xml:space="preserve"> + <value>({age} ago)</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.empty" xml:space="preserve"> + <value>Nothing matched.</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.neverReachable" xml:space="preserve"> + <value>never, in anything we measured</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.noReachableTime" xml:space="preserve"> + <value>no reachable time measured</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.darkFor.unknown" xml:space="preserve"> + <value>unknown</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.knownLive.years" xml:space="preserve"> + <value>{years, number, ::.#} years</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.knownLive.days" xml:space="preserve"> + <value>{days, plural, one {# day} other {# days}}</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.run" xml:space="preserve"> + <value>{from} – {to} · {span}</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.run.months" xml:space="preserve"> + <value>{count, plural, one {# month} other {# months}}</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.run.years" xml:space="preserve"> + <value>{count, plural, one {# year} other {# years}}</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.plain.matching" xml:space="preserve"> + <value>{count, plural, one {# game} other {# games}} matching "{query}"</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.plain.count" xml:space="preserve"> + <value>{count, plural, one {# game} other {# games}}</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.plain.lastReachable" xml:space="preserve"> + <value>Last reachable:</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.plain.knownLive" xml:space="preserve"> + <value>Known live:</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.plain.knownLiveValue" xml:space="preserve"> + <value>{value} of measured reachable time</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.plain.run" xml:space="preserve"> + <value>Run:</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="archive.plain.codebase" xml:space="preserve"> + <value>Codebase:</value> + <comment>the archive: removed from the default listing, and from nothing else</comment> + </data> + <data name="footer.randomGame" xml:space="preserve"> + <value>random game</value> + <comment>/find's footer, which the rebuild left in English</comment> + </data> + <data name="trend.day.counted" xml:space="preserve"> + <value>{d, date, medium} — {typical} on average, {low}–{high} across {probes, plural, one {# probe} other {# probes}}</value> + <comment>the trend chart's per-day title, one per column</comment> + </data> + <data name="trend.day.flat" xml:space="preserve"> + <value>{d, date, medium} — {count, plural, =0 {0 players} one {# player} other {# players}}, every one of {probes, plural, one {# probe} other {# probes}}</value> + <comment>the trend chart's per-day title, one per column</comment> + </data> + <data name="trend.day.notCounted" xml:space="preserve"> + <value>{d, date, medium} — probed, no count could be read</value> + <comment>the trend chart's per-day title, one per column</comment> + </data> + <data name="trend.day.notMeasured" xml:space="preserve"> + <value>{d, date, medium} — no measurement</value> + <comment>the trend chart's per-day title, one per column</comment> + </data> + <data name="trend.summary" xml:space="preserve"> + <value>Typically {typical} on, peaking at {peak}, over {counted} of {days, plural, one {# day} other {# days}}.</value> + <comment>the sentence above the chart</comment> + </data> + <data name="trend.direction.steady" xml:space="preserve"> + <value>Steady across the range.</value> + <comment>the sentence above the chart</comment> + </data> + <data name="trend.direction.up" xml:space="preserve"> + <value>Up about {change, number, percent} from the start of the range to the end.</value> + <comment>the sentence above the chart</comment> + </data> + <data name="trend.direction.down" xml:space="preserve"> + <value>Down about {change, number, percent} from the start of the range to the end.</value> + <comment>the sentence above the chart</comment> + </data> + <data name="trend.none.probed" xml:space="preserve"> + <value>Probed in this range, and no player count could be read from any of it.</value> + <comment>the sentence above the chart</comment> + </data> + <data name="trend.none.notMeasured" xml:space="preserve"> + <value>No measurement in this range.</value> + <comment>the sentence above the chart</comment> + </data> + <data name="trend.empty" xml:space="preserve"> + <value>Nothing counted in this range.</value> + <comment>the sentence above the chart</comment> + </data> + <data name="trend.week.span" xml:space="preserve"> + <value>{from, date, d MMM}–{to, date, d MMM}</value> + <comment>the week lines, which are the text alternative and the plain surface both</comment> + </data> + <data name="trend.week.oneDay" xml:space="preserve"> + <value>{d, date, d MMM}</value> + <comment>the week lines, which are the text alternative and the plain surface both</comment> + </data> + <data name="trend.week.counted" xml:space="preserve"> + <value>{span}: typically {typical}, peak {peak}, {days, plural, one {# day} other {# days}} counted</value> + <comment>the week lines, which are the text alternative and the plain surface both</comment> + </data> + <data name="trend.week.notCounted" xml:space="preserve"> + <value>{span}: probed, no count could be read</value> + <comment>the week lines, which are the text alternative and the plain surface both</comment> + </data> + <data name="trend.week.notMeasured" xml:space="preserve"> + <value>{span}: not measured</value> + <comment>the week lines, which are the text alternative and the plain surface both</comment> + </data> + <data name="trend.week.uncounted" xml:space="preserve"> + <value>{count, plural, one {# day probed without a count} other {# days probed without a count}}</value> + <comment>the week lines, which are the text alternative and the plain surface both</comment> + </data> + <data name="trend.week.unmeasured" xml:space="preserve"> + <value>{count, plural, one {# day not measured} other {# days not measured}}</value> + <comment>the week lines, which are the text alternative and the plain surface both</comment> + </data> + <data name="trend.week.and" xml:space="preserve"> + <value>{line}, {clause}</value> + <comment>the week lines, which are the text alternative and the plain surface both</comment> + </data> + <data name="trend.range" xml:space="preserve"> + <value>days in UTC · {from, date, medium} – {to, date, medium}</value> + <comment>the chart's own chrome</comment> + </data> + <data name="trend.ceiling" xml:space="preserve"> + <value>{value} at the top</value> + <comment>the chart's own chrome</comment> + </data> + <data name="trend.counted" xml:space="preserve"> + <value>{counted} of {days, plural, one {# day} other {# days}} counted</value> + <comment>the chart's own chrome</comment> + </data> + <data name="trend.axis.month" xml:space="preserve"> + <value>{d, date, MMM}</value> + <comment>the chart's own chrome</comment> + </data> + <data name="trend.axis.monthYear" xml:space="preserve"> + <value>{d, date, MMM yyyy}</value> + <comment>the chart's own chrome</comment> + </data> + <data name="trend.legend.mean" xml:space="preserve"> + <value>mean of the counts we read that day</value> + <comment>the chart's own chrome</comment> + </data> + <data name="trend.legend.peak" xml:space="preserve"> + <value>up to the busiest count that day</value> + <comment>the chart's own chrome</comment> + </data> + <data name="trend.legend.band" xml:space="preserve"> + <value>lowest to highest count that day</value> + <comment>the chart's own chrome</comment> + </data> + <data name="trend.legend.notCounted" xml:space="preserve"> + <value>probed, no count could be read</value> + <comment>the chart's own chrome</comment> + </data> + <data name="trend.legend.notMeasured.bar" xml:space="preserve"> + <value>not measured — no bar at all</value> + <comment>the chart's own chrome</comment> + </data> + <data name="trend.legend.notMeasured.line" xml:space="preserve"> + <value>not measured — a break in the line</value> + <comment>the chart's own chrome</comment> + </data> + <data name="trend.spans.label" xml:space="preserve"> + <value>Trend range</value> + <comment>seeking and switching, which are links because the range is in the address</comment> + </data> + <data name="trend.shapes.label" xml:space="preserve"> + <value>Trend shape</value> + <comment>seeking and switching, which are links because the range is in the address</comment> + </data> + <data name="trend.preset" xml:space="preserve"> + <value>{days, plural, one {# day} other {# days}}</value> + <comment>seeking and switching, which are links because the range is in the address</comment> + </data> + <data name="trend.earlier" xml:space="preserve"> + <value>← earlier</value> + <comment>seeking and switching, which are links because the range is in the address</comment> + </data> + <data name="trend.later" xml:space="preserve"> + <value>later →</value> + <comment>seeking and switching, which are links because the range is in the address</comment> + </data> + <data name="trend.shape.line" xml:space="preserve"> + <value>line</value> + <comment>seeking and switching, which are links because the range is in the address</comment> + </data> + <data name="trend.shape.bar" xml:space="preserve"> + <value>bars</value> + <comment>seeking and switching, which are links because the range is in the address</comment> + </data> + <data name="trend.plain.heading" xml:space="preserve"> + <value>How many, over time</value> + <comment>seeking and switching, which are links because the range is in the address</comment> + </data> + <data name="trend.plain.range" xml:space="preserve"> + <value>{from, date, medium} – {to, date, medium}, UTC</value> + <comment>seeking and switching, which are links because the range is in the address</comment> + </data> + <data name="trend.plain.earlier" xml:space="preserve"> + <value>earlier</value> + <comment>seeking and switching, which are links because the range is in the address</comment> + </data> + <data name="trend.plain.note" xml:space="preserve"> + <value>a week is summarised over the days in it we counted; a week with none says so</value> + <comment>seeking and switching, which are links because the range is in the address</comment> + </data> + <data name="reach.kicker" xml:space="preserve"> + <value>reachable · last {days, plural, one {# day} other {# days}}</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.stat.reachable" xml:space="preserve"> + <value>reachable</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.stat.longestOutage" xml:space="preserve"> + <value>longest outage</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.stat.lastCause" xml:space="preserve"> + <value>last cause</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.noOutage" xml:space="preserve"> + <value>none in the window</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.noCause" xml:space="preserve"> + <value>nothing recorded</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.scale.ago" xml:space="preserve"> + <value>{days, plural, one {# day ago} other {# days ago}}</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.scale.today" xml:space="preserve"> + <value>today</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.legend.reachable" xml:space="preserve"> + <value>reachable</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.legend.degraded" xml:space="preserve"> + <value>degraded — answered, could not finish</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.legend.unreachable" xml:space="preserve"> + <value>unreachable</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.legend.notMeasured" xml:space="preserve"> + <value>not measured</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.word.reachable" xml:space="preserve"> + <value>reachable</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.word.degraded" xml:space="preserve"> + <value>degraded</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.word.unreachable" xml:space="preserve"> + <value>unreachable</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.word.notMeasured" xml:space="preserve"> + <value>not measured</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.day.reachable" xml:space="preserve"> + <value>{d, date, d MMM} — reachable all day</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.day.degraded" xml:space="preserve"> + <value>{d, date, d MMM} — degraded ({cause}): answered, could not finish</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.day.unreachable" xml:space="preserve"> + <value>{d, date, d MMM} — unreachable ({cause})</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.day.notMeasured" xml:space="preserve"> + <value>{d, date, d MMM} — not measured; we were not watching this game yet</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.none" xml:space="preserve"> + <value>{days, plural, one {Not yet measured over the last # day.} other {Not yet measured over the last # days.}}</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.fraction.window" xml:space="preserve"> + <value>Reachable {percent} of the last {days, plural, one {# day} other {# days}}.</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.fraction.measured" xml:space="preserve"> + <value>Reachable {percent} of the {days, plural, one {# day} other {# days}} we have measured.</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.fraction.unknown" xml:space="preserve"> + <value>{days, plural, one {Reachability over the last # day is not yet measured.} other {Reachability over the last # days is not yet measured.}}</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.unreachable.noneInWindow" xml:space="preserve"> + <value>No day in the window was unreachable.</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.unreachable.noneMeasured" xml:space="preserve"> + <value>No day we measured was unreachable.</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.unreachable.days" xml:space="preserve"> + <value>{count, plural, one {# day unreachable.} other {# days unreachable.}}</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.degraded.days" xml:space="preserve"> + <value>{count, plural, one {# day degraded — we got in and could not finish.} other {# days degraded — we got in and could not finish.}}</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.longestOutage" xml:space="preserve"> + <value>Longest outage {duration}.</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.longestOutage.cause" xml:space="preserve"> + <value>Longest outage {duration} ({cause}).</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.predate" xml:space="preserve"> + <value>{count, plural, one {# day predates anything we measured.} other {# days predate anything we measured.}}</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.spell.range" xml:space="preserve"> + <value>{from, date, d MMM} – {to, date, d MMM}</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.spell.oneDay" xml:space="preserve"> + <value>{d, date, d MMM}</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.spell" xml:space="preserve"> + <value>{range}: {count, plural, one {# day} other {# days}} {word}</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.spell.cause" xml:space="preserve"> + <value>{range}: {count, plural, one {# day} other {# days}} {word} ({cause})</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.plain.heading" xml:space="preserve"> + <value>Reachable</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.plain.window" xml:space="preserve"> + <value>{days, plural, one {last # day} other {last # days}}</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.plain.fraction" xml:space="preserve"> + <value>Reachable: {percent} of the {days, plural, one {last # day} other {last # days}}</value> + <comment>the reachability strip</comment> + </data> + <data name="reach.plain.longestOutage" xml:space="preserve"> + <value>Longest outage: {duration}</value> + <comment>the reachability strip</comment> + </data> + <data name="cause.dns" xml:space="preserve"> + <value>dns did not resolve</value> + <comment>why a dial did not complete, in a person's words</comment> + </data> + <data name="cause.refused" xml:space="preserve"> + <value>connection refused</value> + <comment>why a dial did not complete, in a person's words</comment> + </data> + <data name="cause.tls" xml:space="preserve"> + <value>tls failed</value> + <comment>why a dial did not complete, in a person's words</comment> + </data> + <data name="cause.timeout" xml:space="preserve"> + <value>timed out</value> + <comment>why a dial did not complete, in a person's words</comment> + </data> + <data name="cause.handshakeStalled" xml:space="preserve"> + <value>handshake stalled</value> + <comment>why a dial did not complete, in a person's words</comment> + </data> + <data name="cause.none" xml:space="preserve"> + <value>no cause recorded</value> + <comment>why a dial did not complete, in a person's words</comment> + </data> + <data name="ansi.suppressed" xml:space="preserve"> + <value>The owner asked us not to republish this game's connect screen.</value> + <comment>the ANSI capture's frame</comment> + </data> + <data name="ansi.absent" xml:space="preserve"> + <value>No connect screen has been captured from this game.</value> + <comment>the ANSI capture's frame</comment> + </data> + <data name="ansi.tooSmall" xml:space="preserve"> + <value>{count, plural, one {Only # row came back — too little to show.} other {Only # rows came back — too little to show.}}</value> + <comment>the ANSI capture's frame</comment> + </data> + <data name="ansi.asSent" xml:space="preserve"> + <value>as sent by the server</value> + <comment>the ANSI capture's frame</comment> + </data> + <data name="ansi.size" xml:space="preserve"> + <value>{columns}×{rows}</value> + <comment>the ANSI capture's frame</comment> + </data> + <data name="ansi.size.doubleWidth" xml:space="preserve"> + <value>{columns}×{rows}, double-width</value> + <comment>the ANSI capture's frame</comment> + </data> + <data name="ansi.depth.colour" xml:space="preserve"> + <value>16-colour SGR</value> + <comment>the ANSI capture's frame</comment> + </data> + <data name="ansi.depth.plain" xml:space="preserve"> + <value>no colour</value> + <comment>the ANSI capture's frame</comment> + </data> + <data name="ansi.readAs" xml:space="preserve"> + <value>read as {charset}</value> + <comment>the ANSI capture's frame</comment> + </data> + <data name="ansi.captured" xml:space="preserve"> + <value>captured</value> + <comment>the ANSI capture's frame</comment> + </data> + <data name="ansi.frozen" xml:space="preserve"> + <value>frozen — the last screen we saw</value> + <comment>the ANSI capture's frame</comment> + </data> + <data name="ansi.alt.named" xml:space="preserve"> + <value>ASCII art: the connect screen of {game}. Its text is under "read as text", below.</value> + <comment>the ANSI capture's frame</comment> + </data> + <data name="ansi.alt" xml:space="preserve"> + <value>ASCII art: this game's connect screen. Its text is under "read as text", below.</value> + <comment>the ANSI capture's frame</comment> + </data> + <data name="ansi.plain.rows" xml:space="preserve"> + <value>{count, plural, one {connect screen: # line, text only} other {connect screen: # lines, text only}}</value> + <comment>the ANSI capture's frame</comment> + </data> + <data name="ansi.plain.rows.readAs" xml:space="preserve"> + <value>{count, plural, one {connect screen: # line, text only, read as {charset}} other {connect screen: # lines, text only, read as {charset}}}</value> + <comment>the ANSI capture's frame</comment> + </data> + <data name="capability.disagree.declaredNotOffered" xml:space="preserve"> + <value>the game declares it, and the server has never offered it in a handshake.</value> + <comment>the capability matrix's disagreements, said in prose</comment> + </data> + <data name="capability.disagree.offeredNotDeclared" xml:space="preserve"> + <value>the server offers it, and the game's own record says it does not.</value> + <comment>the capability matrix's disagreements, said in prose</comment> + </data> + <data name="capability.disagree.note" xml:space="preserve"> + <value>Usually a stale hand-typed field, not a lie. Shown because a client should not rely on what the two disagree about.</value> + <comment>the capability matrix's disagreements, said in prose</comment> + </data> + <data name="game.notFound" xml:space="preserve"> + <value>Not found</value> + <comment>the rest of the game page</comment> + </data> + <data name="game.notFound.hint" xml:space="preserve"> + <value>No game at this address. Check the spelling.</value> + <comment>the rest of the game page</comment> + </data> + <data name="game.endpoint.lastAnswered" xml:space="preserve"> + <value>last answered</value> + <comment>the rest of the game page</comment> + </data> + <data name="game.stale" xml:space="preserve"> + <value>{count, plural, one {# is past its refresh window. Old, not wrong.} other {# are past their refresh window. Old, not wrong.}}</value> + <comment>the rest of the game page</comment> + </data> + <data name="game.referrals.lists" xml:space="preserve"> + <value>This game's own referral list names:</value> + <comment>the rest of the game page</comment> + </data> + <data name="game.referrals.listedBy" xml:space="preserve"> + <value>Named by the referral list of:</value> + <comment>the rest of the game page</comment> + </data> + <data name="game.referral.since" xml:space="preserve"> + <value>since {date}</value> + <comment>the rest of the game page</comment> + </data> + <data name="game.referral.dropped" xml:space="preserve"> + <value>no longer listed, last seen</value> + <comment>the rest of the game page</comment> + </data> + <data name="game.archived.lastAnswered" xml:space="preserve"> + <value>Last answered {date}, {ago} ago.</value> + <comment>the rest of the game page</comment> + </data> + <data name="game.archived.stillProbed" xml:space="preserve"> + <value>Still probed weekly; this page updates the day it answers.</value> + <comment>the rest of the game page</comment> + </data> + <data name="game.archived.knownLive" xml:space="preserve"> + <value>{span} known live</value> + <comment>the rest of the game page</comment> + </data> + <data name="game.excluded" xml:space="preserve"> + <value>Not in the listing, the rankings or the daily figure: we do not think this address is a game somebody can play. Everything below is what it told us, unchanged.</value> + <comment>the rest of the game page</comment> + </data> + <data name="game.excluded.reason" xml:space="preserve"> + <value>Our reason: {why}</value> + <comment>the rest of the game page</comment> + </data> + <data name="game.unlisted" xml:space="preserve"> + <value>Not in the listing, the rankings or the daily figure, at the request of the people who run it. Everything below is preserved as it was, this page and every address it has ever had go on answering, and we are not dialling it.</value> + <comment>the rest of the game page</comment> + </data> + <data name="game.plain.playersNow" xml:space="preserve"> + <value>Players now: {count}</value> + <comment>the plain surface's own headings for this page</comment> + </data> + <data name="game.plain.capabilities" xml:space="preserve"> + <value>Capabilities ({disagreeing, plural, one {# of {total} disagrees} other {# of {total} disagree}})</value> + <comment>the plain surface's own headings for this page</comment> + </data> + <data name="game.plain.declared" xml:space="preserve"> + <value>Declared by the game</value> + <comment>the plain surface's own headings for this page</comment> + </data> + <data name="game.plain.connectScreen" xml:space="preserve"> + <value>Connect screen</value> + <comment>the plain surface's own headings for this page</comment> + </data> + <data name="game.plain.whatChanged" xml:space="preserve"> + <value>What changed</value> + <comment>the plain surface's own headings for this page</comment> + </data> + <data name="game.plain.measured" xml:space="preserve"> + <value>measured</value> + <comment>the plain surface's own headings for this page</comment> + </data> + <data name="game.plain.declared.column" xml:space="preserve"> + <value>declared</value> + <comment>the plain surface's own headings for this page</comment> + </data> + <data name="game.plain.disagree" xml:space="preserve"> + <value>** disagree</value> + <comment>the plain surface's own headings for this page</comment> + </data> + <data name="listing.row.connected" xml:space="preserve"> + <value>connected</value> + <comment>appended block: the listing row's own labels and the last three chips</comment> + </data> + <data name="listing.row.reached" xml:space="preserve"> + <value>reached</value> + <comment>appended block: the listing row's own labels and the last three chips</comment> + </data> + <data name="facet.group.search" xml:space="preserve"> + <value>search</value> + <comment>appended block: the listing row's own labels and the last three chips</comment> + </data> + <data name="facet.group.archived" xml:space="preserve"> + <value>archived</value> + <comment>appended block: the listing row's own labels and the last three chips</comment> + </data> + <data name="facet.group.adult" xml:space="preserve"> + <value>adult</value> + <comment>appended block: the listing row's own labels and the last three chips</comment> + </data> + <data name="facet.value.included" xml:space="preserve"> + <value>included</value> + <comment>appended block: the listing row's own labels and the last three chips</comment> + </data> + <data name="game.count.none" xml:space="preserve"> + <value>no count</value> + <comment>added by the accessibility review, second pass</comment> + </data> + <data name="game.count.none.why" xml:space="preserve"> + <value>no current count, and nothing here says why</value> + <comment>added by the accessibility review, second pass</comment> + </data> + <data name="game.plain.playersNoCount" xml:space="preserve"> + <value>Players now: no count (nothing here says why)</value> + <comment>added by the accessibility review, second pass</comment> + </data> + <data name="crawler.live" xml:space="preserve"> + <value>crawler live · last probe {age}</value> + <comment>the crawler strip, whose sentence was English around a localized age</comment> + </data> + <data name="crawler.quiet" xml:space="preserve"> + <value>crawler quiet · last probe {age}</value> + <comment>the crawler strip, whose sentence was English around a localized age</comment> + </data> + <data name="crawler.noProbe" xml:space="preserve"> + <value>no probe has finished here yet</value> + <comment>the crawler strip, whose sentence was English around a localized age</comment> + </data> + <data name="crawler.cycle.nothingDue" xml:space="preserve"> + <value>nothing due this cycle</value> + <comment>the crawler strip, whose sentence was English around a localized age</comment> + </data> + <data name="crawler.cycle" xml:space="preserve"> + <value>{considered, plural, one {# due} other {# due}} · {answered, plural, one {# answered} other {# answered}} · {failed, plural, one {# failed} other {# failed}}</value> + <comment>the crawler strip, whose sentence was English around a localized age</comment> + </data> + <data name="crawler.registry" xml:space="preserve"> + <value>{targets, plural, one {# address in the registry} other {# addresses in the registry}}, {due, plural, one {# due now} other {# due now}}</value> + <comment>the crawler strip, whose sentence was English around a localized age</comment> + </data> + <data name="preview.documentTitle" xml:space="preserve"> + <value>{page} — {site}</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.site" xml:space="preserve"> + <value>A directory of the MU* hobby — MUSHes, MUDs, MUCKs, MOOs — where every fact carries how it was obtained and how old it is.</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.demo" xml:space="preserve"> + <value>Demo data — nothing here was measured. {description}</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.cardAlt" xml:space="preserve"> + <value>{site} — measured, not asserted</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.cardAlt.named" xml:space="preserve"> + <value>{title} on {site}</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.title.games" xml:space="preserve"> + <value>Games</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.title.archive" xml:space="preserve"> + <value>The archive</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.title.rankings" xml:space="preserve"> + <value>Rankings</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.title.ecosystem" xml:space="preserve"> + <value>The ecosystem</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.title.reference" xml:space="preserve"> + <value>Reference</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.title.about" xml:space="preserve"> + <value>About</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.title.notFound" xml:space="preserve"> + <value>Not found</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.title.random" xml:space="preserve"> + <value>Random game</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.title.account" xml:space="preserve"> + <value>Your games</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.title.claim" xml:space="preserve"> + <value>Claim {game}</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.desc.games" xml:space="preserve"> + <value>Every MU* we have reached, faceted on what we measured: codebase, the protocols a server offered in the handshake, TLS, charset, language, and when we last got in.</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.desc.archive" xml:space="preserve"> + <value>The games that went dark, kept. Each keeps its page, history and URL, is still probed weekly, and returns to the listing on one successful connection.</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.desc.rankings" xml:space="preserve"> + <value>Busiest, most reachable, longest running — computed from measurements only. No votes, stars or ratings anywhere on this site.</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.desc.ecosystem" xml:space="preserve"> + <value>Codebase share and protocol adoption across the games we measure, with what servers offer set beside what they declare. Shares, never totals.</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.desc.reference" xml:space="preserve"> + <value>Hand-written pages on the codebases, clients and protocols of the MU* hobby, cross-linked to counts taken from the crawl.</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.desc.about" xml:space="preserve"> + <value>How this catalogue is built: what the crawler does, what it refuses to do, and how to make it stop.</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.desc.notFound" xml:space="preserve"> + <value>No game at this address. Nothing here is ever deleted, so a game that once lived at this URL still does — check the spelling.</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.desc.random" xml:space="preserve"> + <value>One game from the catalogue, chosen at random and never the same one twice.</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.desc.account" xml:space="preserve"> + <value>The listings you have claimed, and what a claim lets you change.</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.desc.claim" xml:space="preserve"> + <value>Prove you run this game by publishing a token where only its operator could put it.</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.game.archived" xml:space="preserve"> + <value>Archived — last reachable {age}, and still probed</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.game.archived.undated" xml:space="preserve"> + <value>Archived, and still probed</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.game.countUnknown" xml:space="preserve"> + <value>Player count unknown — the game answers, and publishes no number we can read</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="preview.game.count" xml:space="preserve"> + <value>{count, plural, one {# player} other {# players}}, {how} {age}</value> + <comment>what this site says about itself where it is not this site</comment> + </data> + <data name="feed.plain.newlyDiscovered" xml:space="preserve"> + <value>Newly discovered</value> + <comment>the plain mirror's feed headings and home counts</comment> + </data> + <data name="feed.plain.wentDark" xml:space="preserve"> + <value>Went dark</value> + <comment>the plain mirror's feed headings and home counts</comment> + </data> + <data name="feed.plain.cameBack" xml:space="preserve"> + <value>Came back</value> + <comment>the plain mirror's feed headings and home counts</comment> + </data> + <data name="home.plain.known" xml:space="preserve"> + <value>{count, plural, one {# game known} other {# games known}}</value> + <comment>the plain mirror's feed headings and home counts</comment> + </data> + <data name="home.plain.connectedNow" xml:space="preserve"> + <value>{count, plural, one {# connected now (measured)} other {# connected now (measured)}}</value> + <comment>the plain mirror's feed headings and home counts</comment> + </data> + <data name="home.plain.uncounted" xml:space="preserve"> + <value>{count, plural, one {# answering, uncounted} other {# answering, uncounted}}</value> + <comment>the plain mirror's feed headings and home counts</comment> + </data> + <data name="home.plain.archived" xml:space="preserve"> + <value>{count, plural, one {# archived, still probed} other {# archived, still probed}}</value> + <comment>the plain mirror's feed headings and home counts</comment> + </data> + <data name="reference.title" xml:space="preserve"> + <value>Reference</value> + <comment>THE REFERENCE SECTION'S CHROME</comment> + </data> + <data name="reference.lede" xml:space="preserve"> + <value>What the codebases are, what the clients do, and what the protocols mean. Written by hand and kept in the repository beside the crawler — not a wiki, and there is nothing on this page to edit. Every {number} here is a different thing: it comes from the catalogue and is recomputed each time you load the page.</value> + <comment>THE REFERENCE SECTION'S CHROME</comment> + </data> + <data name="reference.lede.number" xml:space="preserve"> + <value>number</value> + <comment>THE REFERENCE SECTION'S CHROME</comment> + </data> + <data name="reference.plain.lede" xml:space="preserve"> + <value>Hand-written, single-author, and versioned in git. The prose here is ours; every number beside it was measured by the crawler and is recomputed on each request. This is not a wiki, and there is no way to edit it from this page.</value> + <comment>THE REFERENCE SECTION'S CHROME</comment> + </data> + <data name="reference.section.orientation" xml:space="preserve"> + <value>Start here</value> + <comment>THE REFERENCE SECTION'S CHROME</comment> + </data> + <data name="reference.section.codebase" xml:space="preserve"> + <value>Codebases</value> + <comment>THE REFERENCE SECTION'S CHROME</comment> + </data> + <data name="reference.section.client" xml:space="preserve"> + <value>Clients</value> + <comment>THE REFERENCE SECTION'S CHROME</comment> + </data> + <data name="reference.section.protocol" xml:space="preserve"> + <value>Protocols</value> + <comment>THE REFERENCE SECTION'S CHROME</comment> + </data> + <data name="reference.kind.orientation" xml:space="preserve"> + <value>orientation</value> + <comment>THE REFERENCE SECTION'S CHROME</comment> + </data> + <data name="reference.kind.codebase" xml:space="preserve"> + <value>codebase</value> + <comment>THE REFERENCE SECTION'S CHROME</comment> + </data> + <data name="reference.kind.client" xml:space="preserve"> + <value>client</value> + <comment>THE REFERENCE SECTION'S CHROME</comment> + </data> + <data name="reference.kind.protocol" xml:space="preserve"> + <value>protocol</value> + <comment>THE REFERENCE SECTION'S CHROME</comment> + </data> + <data name="reference.notFound.title" xml:space="preserve"> + <value>Not found</value> + <comment>THE REFERENCE SECTION'S CHROME</comment> + </data> + <data name="reference.notFound.body" xml:space="preserve"> + <value>No reference page here. This section is hand-written, so a gap is work nobody has done rather than something that was removed — {index}.</value> + <comment>THE REFERENCE SECTION'S CHROME</comment> + </data> + <data name="reference.notFound.index" xml:space="preserve"> + <value>see what there is</value> + <comment>THE REFERENCE SECTION'S CHROME</comment> + </data> + <data name="reference.codebase.heading" xml:space="preserve"> + <value>Games running it</value> + <comment>a codebase page's measured half</comment> + </data> + <data name="reference.codebase.none" xml:space="preserve"> + <value>We have not identified any yet. That is a fact about what this crawler has measured, not about what exists — a game we have not reached, or whose codebase we could not read, is not counted here.</value> + <comment>a codebase page's measured half</comment> + </data> + <data name="reference.codebase.listed" xml:space="preserve"> + <value>{count, plural, one {# listed} other {# listed}}</value> + <comment>a codebase page's measured half</comment> + </data> + <data name="reference.codebase.archived" xml:space="preserve"> + <value>{count, plural, one {# archived} other {# archived}}</value> + <comment>a codebase page's measured half</comment> + </data> + <data name="reference.measuredNeverAsserted" xml:space="preserve"> + <value>measured, never asserted</value> + <comment>a codebase page's measured half</comment> + </data> + <data name="reference.codebase.note" xml:space="preserve"> + <value>Counted from the catalogue on this request, over the same filter the link above carries — so this number and that listing are one query and cannot drift apart.</value> + <comment>a codebase page's measured half</comment> + </data> + <data name="reference.codebase.offered" xml:space="preserve"> + <value>offered in their handshakes: {protocols}</value> + <comment>a codebase page's measured half</comment> + </data> + <data name="reference.protocol.heading" xml:space="preserve"> + <value>Measured adoption</value> + <comment>a protocol page's measured half</comment> + </data> + <data name="reference.protocol.none" xml:space="preserve"> + <value>Nothing measured yet.</value> + <comment>a protocol page's measured half</comment> + </data> + <data name="reference.protocol.share" xml:space="preserve"> + <value>of {listed, plural, one {# listed game} other {# listed games}} — {percent}</value> + <comment>a protocol page's measured half</comment> + </data> + <data name="reference.protocol.remainder" xml:space="preserve"> + <value>The games not counted here are not games without the protocol. A game is counted when we observed its server offering the option in a handshake; the rest are servers that did not offer it to us and servers whose handshake we have not read, and we cannot tell you which.</value> + <comment>a protocol page's measured half</comment> + </data> + <data name="reference.protocol.caption" xml:space="preserve"> + <value>Games observed offering {protocol} in a handshake, by the codebase we identified them as running.</value> + <comment>a protocol page's measured half</comment> + </data> + <data name="reference.protocol.column.codebase" xml:space="preserve"> + <value>codebase</value> + <comment>a protocol page's measured half</comment> + </data> + <data name="reference.protocol.column.offered" xml:space="preserve"> + <value>offered it</value> + <comment>a protocol page's measured half</comment> + </data> + <data name="reference.protocol.column.identified" xml:space="preserve"> + <value>identified</value> + <comment>a protocol page's measured half</comment> + </data> + <data name="reference.seeAlso" xml:space="preserve"> + <value>See also</value> + <comment>a protocol page's measured half</comment> + </data> + <data name="reference.capabilities.heading" xml:space="preserve"> + <value>Capabilities</value> + <comment>the client capability matrix, which is documentation rather than measurement</comment> + </data> + <data name="reference.capabilities.established" xml:space="preserve"> + <value>{count, plural, one {# of {total} established from the project's own documentation} other {# of {total} established from the project's own documentation}}</value> + <comment>the client capability matrix, which is documentation rather than measurement</comment> + </data> + <data name="reference.capabilities.caveat" xml:space="preserve"> + <value>Read off each project's own documentation, not measured by us — a client has no handshake for us to observe. "{unknown}" means we looked and did not establish it. It never means no.</value> + <comment>the client capability matrix, which is documentation rather than measurement</comment> + </data> + <data name="reference.capabilities.caption" xml:space="preserve"> + <value>Client capabilities, each read off the project's own documentation. Unknown means we did not establish it, and never that the client lacks it.</value> + <comment>the client capability matrix, which is documentation rather than measurement</comment> + </data> + <data name="reference.capabilities.column.documented" xml:space="preserve"> + <value>documented</value> + <comment>the client capability matrix, which is documentation rather than measurement</comment> + </data> + <data name="reference.capabilities.column.source" xml:space="preserve"> + <value>source</value> + <comment>the client capability matrix, which is documentation rather than measurement</comment> + </data> + <data name="reference.capabilities.noSource" xml:space="preserve"> + <value>we did not find one</value> + <comment>the client capability matrix, which is documentation rather than measurement</comment> + </data> + <data name="reference.capability.yes" xml:space="preserve"> + <value>yes</value> + <comment>the client capability matrix, which is documentation rather than measurement</comment> + </data> + <data name="reference.capability.no" xml:space="preserve"> + <value>no</value> + <comment>the client capability matrix, which is documentation rather than measurement</comment> + </data> + <data name="reference.capability.unknown" xml:space="preserve"> + <value>unknown</value> + <comment>the client capability matrix, which is documentation rather than measurement</comment> + </data> + <data name="reference.plain.runsOn" xml:space="preserve"> + <value>Runs on: {platforms}</value> + <comment>the plain mirror's own wording</comment> + </data> + <data name="reference.plain.codebase.heading" xml:space="preserve"> + <value>Games we have identified as running this codebase</value> + <comment>the plain mirror's own wording</comment> + </data> + <data name="reference.plain.codebase.none" xml:space="preserve"> + <value>None yet. That is a statement about what we have measured, not about what exists — a game we have not reached, or whose codebase we could not read, is not counted here.</value> + <comment>the plain mirror's own wording</comment> + </data> + <data name="reference.plain.codebase.counts" xml:space="preserve"> + <value>{listed, plural, one {# listed} other {# listed}}, {archived, plural, one {# archived} other {# archived}}</value> + <comment>the plain mirror's own wording</comment> + </data> + <data name="reference.plain.codebase.offered" xml:space="preserve"> + <value>Measured in their handshakes: {protocols}</value> + <comment>the plain mirror's own wording</comment> + </data> + <data name="reference.plain.codebase.nothingOffered" xml:space="preserve"> + <value>Nothing was offered in any handshake we have read from them.</value> + <comment>the plain mirror's own wording</comment> + </data> + <data name="reference.plain.protocol.share" xml:space="preserve"> + <value>{offering} of {listed, plural, one {# listed game} other {# listed games}} were observed offering it ({percent})</value> + <comment>the plain mirror's own wording</comment> + </data> + <data name="reference.plain.protocol.byCodebase" xml:space="preserve"> + <value>By codebase, of the games we identified</value> + <comment>the plain mirror's own wording</comment> + </data> + <data name="reference.plain.protocol.row" xml:space="preserve"> + <value>{offering} of {identified} offered it</value> + <comment>the plain mirror's own wording</comment> + </data> + <data name="reference.plain.capabilities.unknown" xml:space="preserve"> + <value>{count, plural, one {# of {total} rows is unknown} other {# of {total} rows are unknown}}: we did not find the project's own documentation saying either way. A short honest table beats a long guessed one.</value> + <comment>the plain mirror's own wording</comment> + </data> + <data name="account.title" xml:space="preserve"> + <value>Your games</value> + <comment>the dashboard's frame</comment> + </data> + <data name="account.noDatabase" xml:space="preserve"> + <value>Accounts need a database behind them, and this site is running on the demo fixture.</value> + <comment>the dashboard's frame</comment> + </data> + <data name="account.signInButton" xml:space="preserve"> + <value>Sign in</value> + <comment>the dashboard's frame</comment> + </data> + <data name="account.signedInAs" xml:space="preserve"> + <value>Signed in as {name}.</value> + <comment>the dashboard's frame</comment> + </data> + <data name="account.signOut" xml:space="preserve"> + <value>Sign out</value> + <comment>the dashboard's frame</comment> + </data> + <data name="account.empty.body" xml:space="preserve"> + <value>You have not claimed anything yet. Find your game in {listing} and press {claimControl} on its page.</value> + <comment>the dashboard's frame</comment> + </data> + <data name="account.empty.listing" xml:space="preserve"> + <value>the listing</value> + <comment>the dashboard's frame</comment> + </data> + <data name="account.empty.claimControl" xml:space="preserve"> + <value>claim this game</value> + <comment>the dashboard's frame</comment> + </data> + <data name="account.resigned.lead" xml:space="preserve"> + <value>Given up.</value> + <comment>the one banner a POST comes back with</comment> + </data> + <data name="account.resigned.body" xml:space="preserve"> + <value>The record of it is kept, and you can prove control again any time by publishing a fresh token.</value> + <comment>the one banner a POST comes back with</comment> + </data> + <data name="account.saved.lead" xml:space="preserve"> + <value>Saved.</value> + <comment>the one banner a POST comes back with</comment> + </data> + <data name="account.saved.thatGame" xml:space="preserve"> + <value>That game</value> + <comment>the one banner a POST comes back with</comment> + </data> + <data name="account.saved.fields" xml:space="preserve"> + <value>{game}'s page now shows it as owner-declared.</value> + <comment>the one banner a POST comes back with</comment> + </data> + <data name="account.saved.screenHidden" xml:space="preserve"> + <value>We have stopped republishing {game}'s connect screen. The page says so plainly rather than leaving a hole.</value> + <comment>the one banner a POST comes back with</comment> + </data> + <data name="account.saved.screenShown" xml:space="preserve"> + <value>{game}'s connect screen is on its page again.</value> + <comment>the one banner a POST comes back with</comment> + </data> + <data name="account.saved.crawlStopped" xml:space="preserve"> + <value>We have stopped dialling {game}, on every address we have for it. Its page keeps everything measured before you asked.</value> + <comment>the one banner a POST comes back with</comment> + </data> + <data name="account.saved.crawlResumed" xml:space="preserve"> + <value>We are dialling {game} again, from its next turn in the schedule.</value> + <comment>the one banner a POST comes back with</comment> + </data> + <data name="account.saved.unlisted" xml:space="preserve"> + <value>{game} is out of the listing, the rankings and the daily figure. Its page and every URL it has ever had go on answering.</value> + <comment>the one banner a POST comes back with</comment> + </data> + <data name="account.saved.relisted" xml:space="preserve"> + <value>{game} is back in the listing. One probe that answers is all it needs to be measured again.</value> + <comment>the one banner a POST comes back with</comment> + </data> + <data name="account.refused.lead" xml:space="preserve"> + <value>{field} was not changed.</value> + <comment>the one banner a POST comes back with</comment> + </data> + <data name="account.refused.tooLong" xml:space="preserve"> + <value>These are one-line answers; {max} characters is the most we store.</value> + <comment>the one banner a POST comes back with</comment> + </data> + <data name="account.refused.measured" xml:space="preserve"> + <value>That field is measured. A claim lets you add what MSSP has no room for; it never lets anybody edit what we observed, and that includes us.</value> + <comment>the one banner a POST comes back with</comment> + </data> + <data name="account.claimed.heading" xml:space="preserve"> + <value>Claimed</value> + <comment>a claimed game's block</comment> + </data> + <data name="account.claim.verified" xml:space="preserve"> + <value>verified {date}</value> + <comment>a claimed game's block</comment> + </data> + <data name="account.claim.verifiedAndSeen" xml:space="preserve"> + <value>verified {date}, token last seen {seen}</value> + <comment>a claimed game's block</comment> + </data> + <data name="account.claim.mssp" xml:space="preserve"> + <value>check your MSSP</value> + <comment>a claimed game's block</comment> + </data> + <data name="account.claim.coOwners" xml:space="preserve"> + <value>{count, plural, one {Also owned by {names} — who verified a token of their own.} other {Also owned by {names} — each having verified a token of their own.}}</value> + <comment>a claimed game's block</comment> + </data> + <data name="account.coOwner.unnamed" xml:space="preserve"> + <value>another account</value> + <comment>a claimed game's block</comment> + </data> + <data name="account.badge.summary" xml:space="preserve"> + <value>put your player count on your own site</value> + <comment>a claimed game's block</comment> + </data> + <data name="account.badge.carries" xml:space="preserve"> + <value>The badge carries the count and when we measured it, because a number with no age is the thing this site exists to replace.</value> + <comment>a claimed game's block</comment> + </data> + <data name="account.badge.states" xml:space="preserve"> + <value>It says {unknown} rather than nought when we could not count, and {archived} if the game stops answering.</value> + <comment>a claimed game's block</comment> + </data> + <data name="account.badge.json" xml:space="preserve"> + <value>There is {json} too, if you would rather draw your own.</value> + <comment>a claimed game's block</comment> + </data> + <data name="account.history.summary" xml:space="preserve"> + <value>history</value> + <comment>the audit log</comment> + </data> + <data name="account.event.issued" xml:space="preserve"> + <value>token issued</value> + <comment>the audit log</comment> + </data> + <data name="account.event.reissued" xml:space="preserve"> + <value>token issued again</value> + <comment>the audit log</comment> + </data> + <data name="account.event.verified" xml:space="preserve"> + <value>verified — we read your token</value> + <comment>the audit log</comment> + </data> + <data name="account.event.beaconSeen" xml:space="preserve"> + <value>token still published</value> + <comment>the audit log</comment> + </data> + <data name="account.event.beaconMissing" xml:space="preserve"> + <value>token not read this time</value> + <comment>the audit log</comment> + </data> + <data name="account.event.revoked" xml:space="preserve"> + <value>claim given up</value> + <comment>the audit log</comment> + </data> + <data name="account.event.expired" xml:space="preserve"> + <value>token expired unused</value> + <comment>the audit log</comment> + </data> + <data name="account.event.counterClaimed" xml:space="preserve"> + <value>another account proved control and took the game over</value> + <comment>the audit log</comment> + </data> + <data name="account.event.checkRequested" xml:space="preserve"> + <value>check requested</value> + <comment>the audit log</comment> + </data> + <data name="account.resign.summary" xml:space="preserve"> + <value>give up this claim</value> + <comment>the audit log</comment> + </data> + <data name="account.resign.confirm" xml:space="preserve"> + <value>Type {word} to confirm. Nothing is deleted and you can prove control again by publishing a fresh token; the game stays claimed if anybody else owns it.</value> + <comment>the audit log</comment> + </data> + <data name="account.resign.button" xml:space="preserve"> + <value>Give up {game}</value> + <comment>the audit log</comment> + </data> + <data name="account.pending.heading" xml:space="preserve"> + <value>Waiting on a token</value> + <comment>waiting on a token, and the passkeys</comment> + </data> + <data name="account.pending.dates" xml:space="preserve"> + <value>token issued {issued}, good until {expires}</value> + <comment>waiting on a token, and the passkeys</comment> + </data> + <data name="account.passkeys.heading" xml:space="preserve"> + <value>Passkeys</value> + <comment>waiting on a token, and the passkeys</comment> + </data> + <data name="account.passkey.unnamed" xml:space="preserve"> + <value>unnamed</value> + <comment>waiting on a token, and the passkeys</comment> + </data> + <data name="account.passkey.added" xml:space="preserve"> + <value>added {date}</value> + <comment>waiting on a token, and the passkeys</comment> + </data> + <data name="account.passkey.addedOneDevice" xml:space="preserve"> + <value>added {date} · on one device only</value> + <comment>waiting on a token, and the passkeys</comment> + </data> + <data name="account.passkey.single" xml:space="preserve"> + <value>This passkey lives on one device. If you lose it you can still get back in by publishing a fresh token on your game, but a second passkey is quicker.</value> + <comment>waiting on a token, and the passkeys</comment> + </data> + <data name="account.passkey.add" xml:space="preserve"> + <value>Add another passkey</value> + <comment>waiting on a token, and the passkeys</comment> + </data> + <data name="claim.noGame" xml:space="preserve"> + <value>No such game</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.title" xml:space="preserve"> + <value>Claim {game}</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.noDatabase" xml:space="preserve"> + <value>Claiming needs a database behind it, and this site is running on the demo fixture.</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.needAccount" xml:space="preserve"> + <value>You need an account first. It takes a passkey and a name.</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.signIn" xml:space="preserve"> + <value>Sign in or create an account</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.yourGames" xml:space="preserve"> + <value>Your games</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.hasOwners" xml:space="preserve"> + <value>{count, plural, one {This game already has an owner who proved control of the server.} other {This game already has # owners who proved control of the server.}} You can prove it too — the test is the same either way — but we need to know what you mean by it, because we cannot tell from the token.</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.join.button" xml:space="preserve"> + <value>I run it too — add me as an owner</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.join.note" xml:space="preserve"> + <value>Everyone keeps their claim. This is two people running one game.</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.assume.button" xml:space="preserve"> + <value>I have taken it over — transfer it to me</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.assume.note" xml:space="preserve"> + <value>{count, plural, one {When your token verifies, the existing claim is revoked and the game is yours.} other {When your token verifies, the existing claims are revoked and the game is yours.}} They will see why in their own history. Nothing is deleted, and they can prove control again the same way you are about to.</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.verified.lead" xml:space="preserve"> + <value>Verified.</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.verified.viaMssp" xml:space="preserve"> + <value>We read your token from the game's MSSP report on {date}.</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.verified.viaScreen" xml:space="preserve"> + <value>We read your token from the connect screen on {date}.</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.verified.leaveIt" xml:space="preserve"> + <value>Leave the token where it is. It doubles as an identity signal, so this game stays recognisable if it moves host or changes name. Removing it will not un-claim you.</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.publish" xml:space="preserve"> + <value>Publish this token anywhere the game shows it to an anonymous connection. The next probe picks it up, which proves you can write to that server.</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.transfer.lead" xml:space="preserve"> + <value>This is a transfer.</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.transfer.body" xml:space="preserve"> + <value>{count, plural, one {When we read this token, the current owner's claim on this game is revoked and it becomes yours.} other {When we read this token, the current owners' claims on this game are revoked and it becomes yours.}}</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.either.heading" xml:space="preserve"> + <value>Either of these will do</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.mssp.heading" xml:space="preserve"> + <value>An MSSP variable</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.mssp.note" xml:space="preserve"> + <value>In {codebase} that is a line in {file}; every codebase with MSSP has an equivalent.</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.mssp.aliases" xml:space="preserve"> + <value>{aliases} are accepted too.</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.screen.heading" xml:space="preserve"> + <value>A line on the connect screen</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.screen.note" xml:space="preserve"> + <value>Anywhere in the screen, and colour codes around it are fine.</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.then.heading" xml:space="preserve"> + <value>Then</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.then.body" xml:space="preserve"> + <value>We check on the ordinary crawl schedule. This token is good until {date}. Come back any time; nothing needs writing down.</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.check.button" xml:space="preserve"> + <value>Look sooner</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.check.can" xml:space="preserve"> + <value>Brings your game to the front of the queue. We dial on our own schedule, so this is sooner rather than now.</value> + <comment>claiming a game you run</comment> + </data> + <data name="claim.check.rationed" xml:space="preserve"> + <value>Just asked. Try again in a few minutes — it is rationed because it dials a real server sooner than we would have.</value> + <comment>claiming a game you run</comment> + </data> + <data name="owner.declare.heading" xml:space="preserve"> + <value>What only you can tell us about {game}</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.declare.lede" xml:space="preserve"> + <value>These are the things MSSP has no field for. They appear on your game's page as {declared}, with the date you last confirmed them, beside what we measured — never instead of it. Nothing measured can be edited from here, by you or by us.</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.field.declared" xml:space="preserve"> + <value>declared {age}. Empty this box to withdraw it — the record of what it said is kept either way.</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.save" xml:space="preserve"> + <value>Save what you declared</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.override.heading" xml:space="preserve"> + <value>What {game} reports, and what you would rather we showed</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.override.lede" xml:space="preserve"> + <value>Your MSSP is what every crawler reads, and we go on showing it beside anything you put here — an answer of yours does not hide one of your game's.</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.override.nothingMeasured" xml:space="preserve"> + <value>Nothing measured can be edited from here: not a player count, not a capability, not an hour of reachability.</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.override.fixItThere" xml:space="preserve"> + <value>If a line below is wrong in your {file}, fixing it there fixes it everywhere.</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.report.value" xml:space="preserve"> + <value>your game reports {value}, confirmed {age}</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.report.none" xml:space="preserve"> + <value>your game reports nothing here</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.rename.note" xml:space="preserve"> + <value>Changing the name changes what {game} is listed as and the address of its page. The old address goes on working for ever — every URL this game has ever had redirects to its current one — and clearing the box hands the name back to whatever your MSSP says.</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.screen.heading" xml:space="preserve"> + <value>Your connect screen</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.screen.suppressed" xml:space="preserve"> + <value>We are not republishing it. The page says so plainly rather than leaving a hole, and the crawler goes on reading it — it is how we recognise your game if it moves.</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.screen.show" xml:space="preserve"> + <value>Show it again</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.screen.shown" xml:space="preserve"> + <value>We show it because your server sends it to every anonymous connection. If you would rather we did not, say so and we stop. We will not ask why.</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.screen.stop" xml:space="preserve"> + <value>Stop showing our connect screen</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.crawl.heading" xml:space="preserve"> + <value>Being crawled</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.crawl.stopped" xml:space="preserve"> + <value>We have stopped. Nothing on {game} is dialled, and the page keeps everything measured before you asked — the empty hours name no cause, because {ourFact} is our fact and not a measurement of your game.</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.crawl.ourFact" xml:space="preserve"> + <value>you asked us to stop</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.crawl.resume" xml:space="preserve"> + <value>Start crawling us again</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.crawl.standing" xml:space="preserve"> + <value>This one came from your own server rather than from here — {routes}. To be crawled again, stop publishing it; we will hear that on the next cycle.</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.crawl.route.mssp" xml:space="preserve"> + <value>your MSSP report publishes {variable}</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.crawl.route.dns" xml:space="preserve"> + <value>a {label} TXT record asks us to stop</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.crawl.route.recorded" xml:space="preserve"> + <value>a request we recorded</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.crawl.partial" xml:space="preserve"> + <value>We have stopped on {stopped} and are still dialling {dialling}. That is usually a port added after the opt-out.</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.crawl.stopAll" xml:space="preserve"> + <value>Stop on every address too</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.crawl.dialling" xml:space="preserve"> + <value>We dial {game} on a schedule and read what any anonymous connection is shown. If you would rather we did not, say so and we stop — within one cycle, on every address we have for you, and we will not ask why.</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.crawl.selfService" xml:space="preserve"> + <value>Nothing already measured is deleted: your page keeps its history and its URL, and one probe after you take this back starts it again. You can also say it without us, in your own config — {mssp} in MSSP, or a {dns} TXT record — and we honour those whether or not anybody has ever claimed the game here.</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.crawl.stop" xml:space="preserve"> + <value>Stop crawling us</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.listing.heading" xml:space="preserve"> + <value>Being listed</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.listing.unlisted" xml:space="preserve"> + <value>{game} is out of the listing, out of the rankings and out of the daily figure. Its page and every URL it has ever had go on answering, and everything measured before you asked is still on it. Nothing was deleted; it is simply not somewhere a reader arrives by browsing.</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.listing.relist" xml:space="preserve"> + <value>Put us back in the listing</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.listing.probeRelists" xml:space="preserve"> + <value>One probe that answers does this too. While your opt-out stands we do not dial, so nothing will — but the day you take it back, the address comes up within a week and the probe that gets an answer puts you back. You do not have to ask us twice.</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.listing.mayUnlist" xml:space="preserve"> + <value>We have stopped dialling you, and your page is still in the listing with what we measured before that. If you would rather it were not, say so and it comes out — of the listing, the rankings and the daily figure.</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.listing.reversible" xml:space="preserve"> + <value>Nothing is deleted and nothing breaks: the page answers, every URL it has ever had still redirects to it, and anyone you send there sees it. It stops being somewhere a reader can arrive by browsing. Reversible from here, and by any probe that answers after you take your opt-out back.</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="owner.listing.unlist" xml:space="preserve"> + <value>Take us out of the listing too</value> + <comment>what a claim actually grants (the owner panel, §8.5 and §11)</comment> + </data> + <data name="facet.group.measure" xml:space="preserve"> + <value>what we could measure</value> + <comment>what we could measure (the two measurement switches, spec §9)</comment> + </data> + <data name="facet.measure.note" xml:space="preserve"> + <value>Hiding these takes them out of your listing; it does not mean the game is empty.</value> + <comment>what we could measure (the two measurement switches, spec §9)</comment> + </data> + <data name="facet.group.uncounted" xml:space="preserve"> + <value>could not count</value> + <comment>what we could measure (the two measurement switches, spec §9)</comment> + </data> + <data name="facet.group.unreachable" xml:space="preserve"> + <value>could not reach</value> + <comment>what we could measure (the two measurement switches, spec §9)</comment> + </data> + <data name="facet.excluded.uncounted" xml:space="preserve"> + <value>hidden from this listing</value> + <comment>what we could measure (the two measurement switches, spec §9)</comment> + </data> + <data name="facet.excluded.unreachable" xml:space="preserve"> + <value>hidden from this listing</value> + <comment>what we could measure (the two measurement switches, spec §9)</comment> + </data> + <data name="facet.plain.marks" xml:space="preserve"> + <value>In the left column, * is a value this listing is filtered to and - is one it is filtered against. Both are choices in the query, not facts about a game.</value> + <comment>what we could measure (the two measurement switches, spec §9)</comment> + </data> +</root> diff --git a/src/MUI.Web/Resources/Messages.zh-Hans.resx b/src/MUI.Web/Resources/Messages.zh-Hans.resx new file mode 100644 index 0000000..a303b42 --- /dev/null +++ b/src/MUI.Web/Resources/Messages.zh-Hans.resx @@ -0,0 +1,2877 @@ +<?xml version="1.0" encoding="utf-8"?> +<root> + <!-- + 中文, machine-translated and not reviewed by a person. + + Every page served in this locale carries the ◆ notice saying so, and the locale is reachable but + never offered: nothing sends a reader here. Promotion to LocaleStatus.Shipped is a person reading + the locked strings against Glossary.cs, not an edit to a status enum. + + The values are ICU MessageFormat. Argument names in braces are code. + --> + <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata"> + <xsd:import namespace="http://www.w3.org/XML/1998/namespace" /> + <xsd:element name="root" msdata:IsDataSet="true"> + <xsd:complexType> + <xsd:choice maxOccurs="unbounded"> + <xsd:element name="data"> + <xsd:complexType> + <xsd:sequence> + <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" /> + <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" /> + </xsd:sequence> + <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" /> + <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" /> + <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" /> + <xsd:attribute ref="xml:space" /> + </xsd:complexType> + </xsd:element> + <xsd:element name="resheader"> + <xsd:complexType> + <xsd:sequence> + <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" /> + </xsd:sequence> + <xsd:attribute name="name" type="xsd:string" use="required" /> + </xsd:complexType> + </xsd:element> + </xsd:choice> + </xsd:complexType> + </xsd:element> + </xsd:schema> + <resheader name="resmimetype"><value>text/microsoft-resx</value></resheader> + <resheader name="version"><value>2.0</value></resheader> + <resheader name="reader"><value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader> + <resheader name="writer"><value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader> + <data name="facet.count" xml:space="preserve"> + <value>{count, plural, other {#个游戏}}</value> + </data> + <data name="facet.value.include" xml:space="preserve"> + <value>{value}，{count, plural, other {#个游戏}}，仅此项</value> + </data> + <data name="facet.value.exclude" xml:space="preserve"> + <value>{value}，{count, plural, other {#个游戏}}，已排除</value> + </data> + <data name="facet.value.choose" xml:space="preserve"> + <value>{value}，{count, plural, other {#个游戏}}</value> + </data> + <data name="facet.any" xml:space="preserve"> + <value>任意{facet}，{count, plural, other {#个游戏}}</value> + </data> + <data name="listing.total" xml:space="preserve"> + <value>{count, plural, =0 {此处未列出任何游戏。} other {#个游戏，每项事实都标明它的来源。}}</value> + </data> + <data name="chart.basis" xml:space="preserve"> + <value>{days, plural, other {#天}}实测 · {probes, plural, other {#次探测}}</value> + </data> + <data name="window.samples" xml:space="preserve"> + <value>{days, plural, other {#天}} · {count, plural, other {#次计数}}</value> + </data> + <data name="capabilities.agree" xml:space="preserve"> + <value>{disagreeing, plural, =0 {全部{total}项均一致。} other {在{total}项中，有#项与游戏自述不符。}}</value> + </data> + <data name="find.matching" xml:space="preserve"> + <value>{count, plural, =0 {没有游戏符合全部回答。} other {有#个游戏符合全部回答。}}</value> + </data> + <data name="find.basis" xml:space="preserve"> + <value>在{listed, plural, other {#个已列出的游戏}}中 · {answers, plural, =0 {未作回答} other {已回答#项}}</value> + </data> + <data name="find.show" xml:space="preserve"> + <value>{count, plural, other {显示这#个游戏}}</value> + </data> + <data name="find.drop" xml:space="preserve"> + <value>去掉“{answer}”——{count, plural, other {#个游戏}}</value> + </data> + <data name="find.clear" xml:space="preserve"> + <value>清除该问题的回答：{question}</value> + </data> + <data name="find.title" xml:space="preserve"> + <value>查找游戏</value> + </data> + <data name="find.kicker" xml:space="preserve"> + <value>符合全部回答</value> + </data> + <data name="find.noun" xml:space="preserve"> + <value>{count, plural, other {游戏}}</value> + </data> + <data name="find.clearAll" xml:space="preserve"> + <value>清除全部回答</value> + </data> + <data name="find.startAgain" xml:space="preserve"> + <value>重新开始</value> + </data> + <data name="find.more" xml:space="preserve"> + <value>{count, plural, other {另有#项}}</value> + </data> + <data name="find.answersGiven" xml:space="preserve"> + <value>已回答</value> + </data> + <data name="find.wholeListing" xml:space="preserve"> + <value>全部列表</value> + </data> + <data name="find.refused" xml:space="preserve"> + <value>该查询已被拒绝</value> + </data> + <data name="find.name.label" xml:space="preserve"> + <value>名称（若有）</value> + </data> + <data name="find.name.placeholder" xml:space="preserve"> + <value>名称或部分名称</value> + </data> + <data name="find.name.submit" xml:space="preserve"> + <value>按名称搜索</value> + </data> + <data name="find.q.band" xml:space="preserve"> + <value>现在有人在玩吗？</value> + </data> + <data name="find.q.genre" xml:space="preserve"> + <value>你想玩什么？</value> + </data> + <data name="find.q.lineage" xml:space="preserve"> + <value>哪种游戏？</value> + </data> + <data name="find.q.language" xml:space="preserve"> + <value>使用哪种语言？</value> + </data> + <data name="find.q.client" xml:space="preserve"> + <value>你的客户端有什么需求吗？</value> + </data> + <data name="find.q.dark" xml:space="preserve"> + <value>是否包含已失联的游戏？</value> + </data> + <data name="find.any.band" xml:space="preserve"> + <value>不限</value> + </data> + <data name="find.any.genre" xml:space="preserve"> + <value>任意题材</value> + </data> + <data name="find.any.lineage" xml:space="preserve"> + <value>任意类型</value> + </data> + <data name="find.any.language" xml:space="preserve"> + <value>任意语言</value> + </data> + <data name="find.any.client" xml:space="preserve"> + <value>不限</value> + </data> + <data name="find.dark.no" xml:space="preserve"> + <value>否，仅未失联的游戏</value> + </data> + <data name="find.dark.yes" xml:space="preserve"> + <value>是，也一并显示</value> + </data> + <data name="find.dark.chip" xml:space="preserve"> + <value>已失联的游戏</value> + </data> + <data name="find.protocol.tls" xml:space="preserve"> + <value>TLS——已加密，握手由我们完成</value> + </data> + <data name="find.protocol.mssp" xml:space="preserve"> + <value>MSSP——服务器自述</value> + </data> + <data name="find.protocol.mccp" xml:space="preserve"> + <value>MCCP——输出压缩</value> + </data> + <data name="find.protocol.mxp" xml:space="preserve"> + <value>MXP——可点击链接</value> + </data> + <data name="find.protocol.gmcp" xml:space="preserve"> + <value>GMCP——结构化客户端数据</value> + </data> + <data name="find.protocol.msdp" xml:space="preserve"> + <value>MSDP——结构化客户端数据</value> + </data> + <data name="find.protocol.charset" xml:space="preserve"> + <value>CHARSET——编码协商</value> + </data> + <data name="find.protocol.utf8" xml:space="preserve"> + <value>UTF-8——非拉丁文本可正常显示</value> + </data> + <data name="find.protocol.ttype" xml:space="preserve"> + <value>TTYPE——客户端自述类型</value> + </data> + <data name="find.protocol.atcp" xml:space="preserve"> + <value>ATCP——结构化客户端数据</value> + </data> + <data name="find.protocol.msp" xml:space="preserve"> + <value>MSP——声音触发</value> + </data> + <data name="find.protocol.eor" xml:space="preserve"> + <value>EOR——提示符标记</value> + </data> + <data name="find.protocol.other" xml:space="preserve"> + <value>{token}——握手中实测</value> + </data> + <data name="provenance.count.measured" xml:space="preserve"> + <value>实测</value> + </data> + <data name="provenance.game.measured" xml:space="preserve"> + <value>实测</value> + </data> + <data name="provenance.capability.measured" xml:space="preserve"> + <value>实测</value> + </data> + <data name="provenance.screen.measured" xml:space="preserve"> + <value>实测</value> + </data> + <data name="kicker.measured" xml:space="preserve"> + <value>实测</value> + </data> + <data name="provenance.count.declared" xml:space="preserve"> + <value>自述</value> + </data> + <data name="provenance.game.declared" xml:space="preserve"> + <value>自述</value> + </data> + <data name="provenance.capability.declared" xml:space="preserve"> + <value>自述</value> + </data> + <data name="kicker.declared" xml:space="preserve"> + <value>自述</value> + </data> + <data name="provenance.derived" xml:space="preserve"> + <value>推算</value> + </data> + <data name="kicker.derived" xml:space="preserve"> + <value>推算</value> + </data> + <data name="state.notMeasured" xml:space="preserve"> + <value>未实测</value> + </data> + <data name="state.uncounted" xml:space="preserve"> + <value>未能计数</value> + </data> + <data name="state.unreachable" xml:space="preserve"> + <value>无法连通</value> + </data> + <data name="state.notCounted" xml:space="preserve"> + <value>未计数</value> + </data> + <data name="listing.count.none" xml:space="preserve"> + <value>无计数</value> + </data> + <data name="listing.plain.fromHere" xml:space="preserve"> + <value>自本站</value> + </data> + <data name="listing.plain.archived" xml:space="preserve"> + <value>已归档</value> + </data> + <data name="listing.plain.claimed" xml:space="preserve"> + <value>已认领</value> + </data> + <data name="random.empty.title" xml:space="preserve"> + <value>没有可挑的游戏</value> + </data> + <data name="random.empty.body" xml:space="preserve"> + <value>没有游戏符合该筛选。试试{listing}，或者{archive}。</value> + </data> + <data name="random.empty.listing" xml:space="preserve"> + <value>全部列表</value> + </data> + <data name="random.empty.archive" xml:space="preserve"> + <value>把归档也算上</value> + </data> + <data name="term.connected" xml:space="preserve"> + <value>连接数</value> + </data> + <data name="term.unclaimed" xml:space="preserve"> + <value>无人认领</value> + </data> + <data name="term.claimedByOwner" xml:space="preserve"> + <value>已由所有者认领</value> + </data> + <data name="term.stillProbed" xml:space="preserve"> + <value>仍在探测</value> + </data> + <data name="term.typical" xml:space="preserve"> + <value>典型值</value> + </data> + <data name="term.peak" xml:space="preserve"> + <value>峰值</value> + </data> + <data name="a11y.readAsText" xml:space="preserve"> + <value>以文本形式阅读</value> + </data> + <data name="a11y.plainText" xml:space="preserve"> + <value>纯文本</value> + </data> + <data name="a11y.skipToContent" xml:space="preserve"> + <value>跳至主要内容</value> + </data> + <data name="a11y.asciiBanner" xml:space="preserve"> + <value>ASCII 横幅：{game} 的连接画面。</value> + </data> + <data name="nav.catalogues" xml:space="preserve"> + <value>目录</value> + </data> + <data name="nav.account" xml:space="preserve"> + <value>本站与账户</value> + </data> + <data name="nav.browse" xml:space="preserve"> + <value>浏览</value> + </data> + <data name="nav.learn" xml:space="preserve"> + <value>了解</value> + </data> + <data name="nav.thisSite" xml:space="preserve"> + <value>本站</value> + </data> + <data name="nav.menu" xml:space="preserve"> + <value>菜单</value> + </data> + <data name="nav.games" xml:space="preserve"> + <value>游戏</value> + </data> + <data name="nav.find" xml:space="preserve"> + <value>查找</value> + </data> + <data name="nav.random" xml:space="preserve"> + <value>随机</value> + </data> + <data name="nav.archive" xml:space="preserve"> + <value>归档</value> + </data> + <data name="nav.reference" xml:space="preserve"> + <value>参考</value> + </data> + <data name="nav.ecosystem" xml:space="preserve"> + <value>生态</value> + </data> + <data name="nav.rankings" xml:space="preserve"> + <value>排行</value> + </data> + <data name="nav.about" xml:space="preserve"> + <value>关于</value> + </data> + <data name="nav.submit" xml:space="preserve"> + <value>提交</value> + </data> + <data name="nav.submitGame" xml:space="preserve"> + <value>提交游戏</value> + </data> + <data name="nav.signIn" xml:space="preserve"> + <value>登录</value> + </data> + <data name="nav.yourGames" xml:space="preserve"> + <value>我的游戏</value> + </data> + <data name="theme.label" xml:space="preserve"> + <value>主题</value> + </data> + <data name="theme.auto" xml:space="preserve"> + <value>自动</value> + </data> + <data name="theme.light" xml:space="preserve"> + <value>浅色</value> + </data> + <data name="theme.dark" xml:space="preserve"> + <value>深色</value> + </data> + <data name="banner.demo.lead" xml:space="preserve"> + <value>演示数据。</value> + </data> + <data name="banner.demo" xml:space="preserve"> + <value>未配置数据库，因此这是一份样例。此处没有任何内容经过实测。</value> + </data> + <data name="footer.allGames" xml:space="preserve"> + <value>全部游戏</value> + </data> + <data name="footer.archive" xml:space="preserve"> + <value>归档</value> + </data> + <data name="footer.declaredByGame" xml:space="preserve"> + <value>游戏自述</value> + </data> + <data name="footer.whatChanged" xml:space="preserve"> + <value>变更记录</value> + </data> + <data name="home.title" xml:space="preserve"> + <value>MU* 爱好者的游戏目录</value> + </data> + <data name="home.lede" xml:space="preserve"> + <value>每一项事实都标明它的来源与时间：由我们的爬虫实测，或由游戏自述并明确标出。</value> + </data> + <data name="home.search.label" xml:space="preserve"> + <value>按名称、主题、代码库或主机搜索游戏</value> + </data> + <data name="home.search.placeholder" xml:space="preserve"> + <value>按名称、主题、代码库或主机搜索</value> + </data> + <data name="home.search.submit" xml:space="preserve"> + <value>搜索</value> + </data> + <data name="tile.gamesKnown" xml:space="preserve"> + <value>已知游戏</value> + </data> + <data name="tile.connectedNow" xml:space="preserve"> + <value>当前连接数</value> + </data> + <data name="tile.answeringUncounted" xml:space="preserve"> + <value>有应答，未能计数</value> + </data> + <data name="tile.archived" xml:space="preserve"> + <value>已归档</value> + </data> + <data name="feed.newlyDiscovered" xml:space="preserve"> + <value>新发现</value> + </data> + <data name="feed.wentDark" xml:space="preserve"> + <value>已失联——仍在探测</value> + </data> + <data name="feed.cameBack" xml:space="preserve"> + <value>已恢复</value> + </data> + <data name="feed.nothingNew" xml:space="preserve"> + <value>没有新发现。</value> + </data> + <data name="feed.nothingDark" xml:space="preserve"> + <value>没有游戏失联。</value> + </data> + <data name="feed.nothingBack" xml:space="preserve"> + <value>没有游戏恢复。我们仍会继续叩门。</value> + </data> + <data name="feed.live" xml:space="preserve"> + <value>实时</value> + </data> + <data name="games.title" xml:space="preserve"> + <value>游戏</value> + </data> + <data name="listing.sortedBy" xml:space="preserve"> + <value>按{order}排序</value> + </data> + <data name="listing.random" xml:space="preserve"> + <value>随机</value> + </data> + <data name="listing.columns" xml:space="preserve"> + <value>连接数 · 连通</value> + </data> + <data name="listing.fromHere" xml:space="preserve"> + <value>自本站</value> + </data> + <data name="listing.empty.head" xml:space="preserve"> + <value>没有匹配结果。</value> + </data> + <data name="listing.empty.hint" xml:space="preserve"> + <value>试试减少关键词，或去掉一个筛选条件。</value> + </data> + <data name="listing.clearFilters" xml:space="preserve"> + <value>清除筛选</value> + </data> + <data name="listing.aboutCodebase" xml:space="preserve"> + <value>关于 {codebase}</value> + </data> + <data name="listing.never" xml:space="preserve"> + <value>从未</value> + </data> + <data name="listing.claimed" xml:space="preserve"> + <value>已由所有者认领</value> + </data> + <data name="listing.unknownCodebase" xml:space="preserve"> + <value>未知代码库</value> + </data> + <data name="listing.unknownCodebase.title" xml:space="preserve"> + <value>我们无法识别该游戏运行的代码库</value> + </data> + <data name="listing.moreProtocols" xml:space="preserve"> + <value>另有{count, plural, other {#项}}：{names}</value> + </data> + <data name="switch.order" xml:space="preserve"> + <value>排序</value> + </data> + <data name="switch.window" xml:space="preserve"> + <value>时间窗</value> + </data> + <data name="switch.now" xml:space="preserve"> + <value>当前</value> + </data> + <data name="switch.typical" xml:space="preserve"> + <value>典型值</value> + </data> + <data name="switch.peak" xml:space="preserve"> + <value>峰值</value> + </data> + <data name="switch.name" xml:space="preserve"> + <value>名称</value> + </data> + <data name="switch.reached" xml:space="preserve"> + <value>连通</value> + </data> + <data name="window.7" xml:space="preserve"> + <value>7天</value> + </data> + <data name="window.30" xml:space="preserve"> + <value>30天</value> + </data> + <data name="window.90" xml:space="preserve"> + <value>90天</value> + </data> + <data name="filters.search.label" xml:space="preserve"> + <value>搜索游戏</value> + </data> + <data name="filters.search.placeholder" xml:space="preserve"> + <value>搜索游戏</value> + </data> + <data name="filters.summary" xml:space="preserve"> + <value>筛选</value> + </data> + <data name="filters.showing" xml:space="preserve"> + <value>当前显示</value> + </data> + <data name="filters.clearAll" xml:space="preserve"> + <value>全部清除</value> + </data> + <data name="filters.stopFiltering" xml:space="preserve"> + <value>——取消此项筛选</value> + </data> + <data name="facet.anyValue" xml:space="preserve"> + <value>任意</value> + </data> + <data name="facet.more" xml:space="preserve"> + <value>更多筛选（{count}）</value> + </data> + <data name="facet.moreValues" xml:space="preserve"> + <value>{count, plural, other {另有#项}}</value> + </data> + <data name="facet.alsoShow" xml:space="preserve"> + <value>同时显示</value> + </data> + <data name="facet.alsoShow.note" xml:space="preserve"> + <value>默认关闭。两者都不是对游戏的评判。</value> + </data> + <data name="facet.archived" xml:space="preserve"> + <value>已归档</value> + </data> + <data name="facet.adult" xml:space="preserve"> + <value>成人</value> + </data> + <data name="facet.archived.state" xml:space="preserve"> + <value>已归档游戏，{shown, select, true {显示} other {隐藏}}</value> + </data> + <data name="facet.adult.state" xml:space="preserve"> + <value>自述含成人内容的游戏，{shown, select, true {显示} other {隐藏}}</value> + </data> + <data name="facet.countsNote" xml:space="preserve"> + <value>计数均为我们实测到的游戏，绝非估算。</value> + </data> + <data name="facet.key.summary" xml:space="preserve"> + <value>徽标与留空的含义</value> + </data> + <data name="facet.key.blank" xml:space="preserve"> + <value>留空是我们测量中的缺口，而不是否定。每个分面各有说法：未识别、未自述、无协商结果。</value> + </data> + <data name="facet.key.zero" xml:space="preserve"> + <value>实测到的零是一个计数。未知的计数不是零，排序时也绝不按零处理。</value> + </data> + <data name="facet.key.openEnded" xml:space="preserve"> + <value>开放式分面只列出最常见的 {count} 个值。其余的可通过搜索和 URL 访问。</value> + </data> + <data name="facet.presence.note" xml:space="preserve"> + <value>未勾选表示未实测，而不是游戏不具备该项。</value> + </data> + <data name="facet.group.band" xml:space="preserve"> + <value>活跃度</value> + </data> + <data name="facet.group.seen" xml:space="preserve"> + <value>最近可见</value> + </data> + <data name="facet.group.protocol" xml:space="preserve"> + <value>提供的协议</value> + </data> + <data name="facet.group.tls" xml:space="preserve"> + <value>加密</value> + </data> + <data name="facet.group.charset" xml:space="preserve"> + <value>编码</value> + </data> + <data name="facet.group.codebase" xml:space="preserve"> + <value>代码库</value> + </data> + <data name="facet.group.version" xml:space="preserve"> + <value>版本</value> + </data> + <data name="facet.group.lineage" xml:space="preserve"> + <value>谱系</value> + </data> + <data name="facet.group.family" xml:space="preserve"> + <value>家族</value> + </data> + <data name="facet.group.genre" xml:space="preserve"> + <value>题材</value> + </data> + <data name="facet.group.language" xml:space="preserve"> + <value>语言</value> + </data> + <data name="facet.band.playersNow" xml:space="preserve"> + <value>当前有连接</value> + </data> + <data name="facet.band.activeThisWeek" xml:space="preserve"> + <value>本周活跃</value> + </data> + <data name="facet.band.quiet" xml:space="preserve"> + <value>冷清——没有高于 0 的计数</value> + </data> + <data name="facet.band.dark" xml:space="preserve"> + <value>失联——一个月未连通</value> + </data> + <data name="facet.band.archived" xml:space="preserve"> + <value>已归档</value> + </data> + <data name="facet.seen.day" xml:space="preserve"> + <value>24 小时内</value> + </data> + <data name="facet.seen.week" xml:space="preserve"> + <value>7 天内</value> + </data> + <data name="facet.seen.month" xml:space="preserve"> + <value>30 天内</value> + </data> + <data name="facet.seen.older" xml:space="preserve"> + <value>更早</value> + </data> + <data name="facet.seen.never" xml:space="preserve"> + <value>从未连通</value> + </data> + <data name="facet.unknown.charset" xml:space="preserve"> + <value>无协商结果</value> + </data> + <data name="facet.unknown.codebase" xml:space="preserve"> + <value>未识别</value> + </data> + <data name="facet.unknown.other" xml:space="preserve"> + <value>未自述</value> + </data> + <data name="facet.tls.yes" xml:space="preserve"> + <value>已通过 TLS 连接</value> + </data> + <data name="facet.excluded" xml:space="preserve"> + <value>非{value}</value> + </data> + <data name="facet.known.charset" xml:space="preserve"> + <value>有协商结果</value> + </data> + <data name="facet.known.codebase" xml:space="preserve"> + <value>已识别</value> + </data> + <data name="facet.known.other" xml:space="preserve"> + <value>有自述</value> + </data> + <data name="evidence.measured.meaning" xml:space="preserve"> + <value>我们亲眼观测到</value> + </data> + <data name="evidence.declared.meaning" xml:space="preserve"> + <value>游戏这样说，我们未加核实</value> + </data> + <data name="evidence.derived.meaning" xml:space="preserve"> + <value>我们对游戏所述内容做了归类</value> + </data> + <data name="sort.name" xml:space="preserve"> + <value>名称</value> + </data> + <data name="sort.players" xml:space="preserve"> + <value>当前连接数</value> + </data> + <data name="sort.reached" xml:space="preserve"> + <value>最近连通</value> + </data> + <data name="sort.medianWeek" xml:space="preserve"> + <value>典型连接数 · 7天</value> + </data> + <data name="sort.medianMonth" xml:space="preserve"> + <value>典型连接数 · 30天</value> + </data> + <data name="sort.medianQuarter" xml:space="preserve"> + <value>典型连接数 · 90天</value> + </data> + <data name="sort.peakWeek" xml:space="preserve"> + <value>同时最多连接 · 7天</value> + </data> + <data name="sort.peakMonth" xml:space="preserve"> + <value>同时最多连接 · 30天</value> + </data> + <data name="sort.peakQuarter" xml:space="preserve"> + <value>同时最多连接 · 90天</value> + </data> + <data name="sort.group.row" xml:space="preserve"> + <value>当前行内</value> + </data> + <data name="sort.group.typical" xml:space="preserve"> + <value>典型值</value> + </data> + <data name="sort.group.peak" xml:space="preserve"> + <value>峰值</value> + </data> + <data name="sort.unranked.players" xml:space="preserve"> + <value>未知计数</value> + </data> + <data name="sort.unranked.reached" xml:space="preserve"> + <value>从未连通过——并非只是很久未连通</value> + </data> + <data name="sort.unranked.median" xml:space="preserve"> + <value>窗口内计数少于 {minimum} 次，或完全没有——并非典型连接数为零</value> + </data> + <data name="sort.unranked.window" xml:space="preserve"> + <value>窗口内没有任何我们能计到的数——并非无人连接的游戏</value> + </data> + <data name="sort.window.median" xml:space="preserve"> + <value>中位 {value} · {days, plural, other {#天}} · {count, plural, other {#次计数}}</value> + </data> + <data name="sort.window.peak" xml:space="preserve"> + <value>同时最多 {value} · {days, plural, other {#天}} · {count, plural, other {#次计数}}</value> + </data> + <data name="game.connectScreen" xml:space="preserve"> + <value>连接画面</value> + </data> + <data name="game.connectionsByHour" xml:space="preserve"> + <value>按小时的连接数</value> + </data> + <data name="game.howMany" xml:space="preserve"> + <value>人数随时间变化</value> + </data> + <data name="game.reachable" xml:space="preserve"> + <value>可连通</value> + </data> + <data name="game.whatChanged" xml:space="preserve"> + <value>变更记录</value> + </data> + <data name="game.capabilities" xml:space="preserve"> + <value>能力</value> + </data> + <data name="game.declaredByGame" xml:space="preserve"> + <value>游戏自述</value> + </data> + <data name="game.referrals" xml:space="preserve"> + <value>转介</value> + </data> + <data name="game.unclaimed" xml:space="preserve"> + <value>无人认领——此处的一切均为实测。</value> + </data> + <data name="game.claimed" xml:space="preserve"> + <value>已由所有者认领——下方的实测事实仍出自我们。</value> + </data> + <data name="game.claim" xml:space="preserve"> + <value>认领此游戏</value> + </data> + <data name="game.answeringSince" xml:space="preserve"> + <value>自 {date} 起有应答</value> + </data> + <data name="game.readAsTextRows" xml:space="preserve"> + <value>以文本形式阅读——{count, plural, other {#行}}</value> + </data> + <data name="capability.column" xml:space="preserve"> + <value>能力</value> + </data> + <data name="capability.age" xml:space="preserve"> + <value>距今</value> + </data> + <data name="capability.offered" xml:space="preserve"> + <value>已提供</value> + </data> + <data name="capability.silent" xml:space="preserve"> + <value>静默</value> + </data> + <data name="capability.absent" xml:space="preserve"> + <value>缺失</value> + </data> + <data name="capability.denied" xml:space="preserve"> + <value>已拒绝</value> + </data> + <data name="capability.claimed" xml:space="preserve"> + <value>自述有</value> + </data> + <data name="capability.disagrees" xml:space="preserve"> + <value>不一致</value> + </data> + <data name="capability.whereTheyDisagree" xml:space="preserve"> + <value>不一致之处（{count}）</value> + </data> + <data name="activity.cell.counted" xml:space="preserve"> + <value>{day} {time}——{count, plural, =0 {0人连接，实测} other {平均#人连接}}</value> + </data> + <data name="activity.cell.notCounted" xml:space="preserve"> + <value>{day} {time}——已探测，未能读取计数</value> + </data> + <data name="activity.cell.notMeasured" xml:space="preserve"> + <value>{day} {time}——该小时未实测</value> + </data> + <data name="activity.none" xml:space="preserve"> + <value>我们尚未实测该游戏的活跃度。</value> + </data> + <data name="activity.noCount" xml:space="preserve"> + <value>一周中没有任何一个小时得出过连接人数。</value> + </data> + <data name="activity.allZero" xml:space="preserve"> + <value>每个小时都已实测，其中没有任何一个小时有人连接。</value> + </data> + <data name="activity.gap.day" xml:space="preserve"> + <value>{count, plural, other {{day}有#小时尚未实测。}}</value> + </data> + <data name="activity.gap.week" xml:space="preserve"> + <value>{count, plural, other {一周中有#小时尚未实测。}}</value> + </data> + <data name="activity.uncounted.day" xml:space="preserve"> + <value>{count, plural, other {{day}有#小时有应答，但未能计数。}}</value> + </data> + <data name="activity.uncounted.week" xml:space="preserve"> + <value>{count, plural, other {一周中有#小时有应答，但未能计数。}}</value> + </data> + <data name="activity.busiest.everyDay" xml:space="preserve"> + <value>每天最热闹，{window}。</value> + </data> + <data name="activity.busiest.everyDay.part" xml:space="preserve"> + <value>每天{part}最热闹，{window}。</value> + </data> + <data name="activity.busiest.days" xml:space="preserve"> + <value>{days}最热闹，{window}。</value> + </data> + <data name="activity.busiest.days.part" xml:space="preserve"> + <value>{days}{part}最热闹，{window}。</value> + </data> + <data name="activity.quiet" xml:space="preserve"> + <value>{who}一贯冷清，{window}。</value> + </data> + <data name="activity.quiet.part" xml:space="preserve"> + <value>{who}的{part}一贯冷清，{window}。</value> + </data> + <data name="activity.quiet.everyDay" xml:space="preserve"> + <value>每天</value> + </data> + <data name="activity.quiet.everyMeasuredDay" xml:space="preserve"> + <value>我们实测到的每一天</value> + </data> + <data name="activity.quiet.weekdays" xml:space="preserve"> + <value>工作日</value> + </data> + <data name="activity.quiet.onDays" xml:space="preserve"> + <value>{days}</value> + </data> + <data name="activity.part.morning" xml:space="preserve"> + <value>上午</value> + </data> + <data name="activity.part.afternoon" xml:space="preserve"> + <value>下午</value> + </data> + <data name="activity.part.evening" xml:space="preserve"> + <value>晚上</value> + </data> + <data name="activity.part.smallHours" xml:space="preserve"> + <value>凌晨</value> + </data> + <data name="activity.parts.morning" xml:space="preserve"> + <value>上午</value> + </data> + <data name="activity.parts.afternoon" xml:space="preserve"> + <value>下午</value> + </data> + <data name="activity.parts.evening" xml:space="preserve"> + <value>晚上</value> + </data> + <data name="activity.parts.smallHours" xml:space="preserve"> + <value>凌晨</value> + </data> + <data name="activity.days.list" xml:space="preserve"> + <value>{list}、{next}</value> + </data> + <data name="activity.days.pair" xml:space="preserve"> + <value>{first}和{second}</value> + </data> + <data name="activity.sparse.kicker" xml:space="preserve"> + <value>实测次数尚不足</value> + </data> + <data name="activity.sparse.none" xml:space="preserve"> + <value>一周中尚无任何一个小时有过实测。</value> + </data> + <data name="activity.sparse.uncounted" xml:space="preserve"> + <value>{count, plural, other {#小时有应答，但未能计数。}}</value> + </data> + <data name="activity.sparse.wait" xml:space="preserve"> + <value>待一周七天每天都有实测后，网格才会显示。</value> + </data> + <data name="activity.sparse.days" xml:space="preserve"> + <value>{days, plural, other {七天中已实测#天；待每天都有实测小时后，网格才会显示。}}</value> + </data> + <data name="activity.sample.zero" xml:space="preserve"> + <value>{count, plural, other {已实测#小时，其中始终无人连接。}}</value> + </data> + <data name="activity.sample.peak" xml:space="preserve"> + <value>{count, plural, other {已实测#小时，最热闹的是{day} {time} UTC，{peak}人连接。}}</value> + </data> + <data name="activity.sample.more" xml:space="preserve"> + <value>{count, plural, other {另有#小时有应答，但未能计数。}}</value> + </data> + <data name="activity.day.line" xml:space="preserve"> + <value>{day}——{facts}</value> + </data> + <data name="activity.day.facts" xml:space="preserve"> + <value>{first}，{second}</value> + </data> + <data name="activity.day.allZero" xml:space="preserve"> + <value>全天实测为零</value> + </data> + <data name="activity.day.peak" xml:space="preserve"> + <value>{time}峰值{count}人</value> + </data> + <data name="activity.day.nobodyOn" xml:space="preserve"> + <value>{window}无人连接</value> + </data> + <data name="activity.day.noCount" xml:space="preserve"> + <value>各小时均无计数</value> + </data> + <data name="activity.day.notMeasured" xml:space="preserve"> + <value>{count, plural, other {#小时未实测}}</value> + </data> + <data name="activity.day.notCounted" xml:space="preserve"> + <value>{count, plural, other {#小时已探测但未能计数}}</value> + </data> + <data name="activity.column.day" xml:space="preserve"> + <value>星期</value> + </data> + <data name="activity.column.quietest" xml:space="preserve"> + <value>最冷清</value> + </data> + <data name="activity.column.busiest" xml:space="preserve"> + <value>最热闹</value> + </data> + <data name="activity.column.at" xml:space="preserve"> + <value>时间</value> + </data> + <data name="activity.column.noCount" xml:space="preserve"> + <value>无计数</value> + </data> + <data name="activity.caption" xml:space="preserve"> + <value>按天显示的连接人数，时间为 UTC。{window}。</value> + </data> + <data name="activity.times" xml:space="preserve"> + <value>时间为 UTC · {window}</value> + </data> + <data name="activity.rollingAverage" xml:space="preserve"> + <value>{weeks, plural, other {#周滚动平均}}</value> + </data> + <data name="activity.legend.counted" xml:space="preserve"> + <value>已计数，含实测为零</value> + </data> + <data name="activity.legend.notCounted" xml:space="preserve"> + <value>已探测，未能读取计数</value> + </data> + <data name="activity.legend.notMeasured" xml:space="preserve"> + <value>该小时未实测</value> + </data> + <data name="activity.plain.heading" xml:space="preserve"> + <value>有人连接的时段（UTC）</value> + </data> + <data name="activity.key.counted" xml:space="preserve"> + <value>已计数</value> + </data> + <data name="activity.key.counted.meaning" xml:space="preserve"> + <value>我们连上了并读到了数字，包括实测为零</value> + </data> + <data name="activity.key.uncounted.meaning" xml:space="preserve"> + <value>我们连上了，但读不到数字</value> + </data> + <data name="activity.key.notMeasured.meaning" xml:space="preserve"> + <value>我们没有该小时的实测数据</value> + </data> + <data name="locale.label" xml:space="preserve"> + <value>语言</value> + </data> + <data name="locale.submit" xml:space="preserve"> + <value>切换语言</value> + </data> + <data name="about.title" xml:space="preserve"> + <value>关于 mu*index</value> + </data> + <data name="about.lede" xml:space="preserve"> + <value>这里的每一个游戏，都由一台连入其中的机器实测得出，每一项数值都标明它的来源与时间。本页说明这能证明什么、我们哪里会出错、我们读了谁的目录，以及如何让爬虫停下。</value> + </data> + <data name="about.measures.heading" xml:space="preserve"> + <value>本站所说的事实是什么</value> + </data> + <data name="about.measures.declared.lead" xml:space="preserve"> + <value>实测优先于自述，两者都会呈现。</value> + </data> + <data name="about.measures.declared.body" xml:space="preserve"> + <value>游戏的 MSSP 报告是它对自己的描述，telnet 握手则是我们亲眼看到它做了什么。两者都会出现在它的页面上，并标注来源与时间。两者不一致时，我们把这份不一致本身呈现出来。</value> + </data> + <data name="about.measures.count.lead" xml:space="preserve"> + <value>每一项人数计数都标明它从何而来。</value> + </data> + <data name="about.measures.count.body" xml:space="preserve"> + <value>要么是我们在连接画面上读到并数出的 WHO 或 DOING，要么是游戏自己发布的 MSSP PLAYERS 字段。二者从不合并。</value> + </data> + <data name="about.measures.unknown.lead" xml:space="preserve"> + <value>读不出来的回应是未知，绝不是零。</value> + </data> + <data name="about.measures.unknown.body" xml:space="preserve"> + <value>服务器可以随意定制自己的 WHO 表头，超过一定程度，我们的解析器就读不出来了。那是无法计数，自成一种状态。而实测到的零——我们连上了，里面没有人——是一个计数，也按计数显示。</value> + </data> + <data name="about.measures.reachable.lead" xml:space="preserve"> + <value>只说可连通，从不说在线率。</value> + </data> + <data name="about.measures.reachable.body" xml:space="preserve"> + <value>我们从一台主机上按间隔打开一个套接字。路由不到的游戏是无法连通，而它完全可能好好活着。本站不宣称任何游戏的在线率，因为本站没有测过它。</value> + </data> + <data name="about.measures.hour.lead" xml:space="preserve"> + <value>一个小时要么已计数，要么无法计数，要么未实测。</value> + </data> + <data name="about.measures.hour.body" xml:space="preserve"> + <value>活跃度网格有三种状态。第三种是空白，并且不指明原因：我们连不上的那个小时，和我们从未探测过的那个小时，是同一种缺失，两者都不是那台服务器的停机时间。</value> + </data> + <data name="about.limits.heading" xml:space="preserve"> + <value>我们知道自己哪里会出错</value> + </data> + <data name="about.limits.grace.lead" xml:space="preserve"> + <value>归档宽限期从我们发现你的那天算起。</value> + </data> + <data name="about.limits.grace.body" xml:space="preserve"> + <value>游戏停止应答后，会在宽限期结束时离开默认列表：宽限期是我们探测到的可连通时长的四分之一，下限 60 天，上限 365 天。一个从 1995 年就在运行的游戏，在我们发现它的那天也只从下限起算。我们不会导入任何数据，去填补我们到来之前的那些年。</value> + </data> + <data name="about.limits.created.lead" xml:space="preserve"> + <value>MSSP CREATED 不计入这段宽限期。</value> + </data> + <data name="about.limits.created.body" xml:space="preserve"> + <value>它只是配置文件里手打的一行，若予采信，归档门槛就会变得可以操纵。它以自述的身份显示，换不来任何东西。</value> + </data> + <data name="about.limits.claim.lead" xml:space="preserve"> + <value>认领游戏可以拿到上限。</value> + </data> + <data name="about.limits.claim.body" xml:space="preserve"> + <value>只要证明拥有服务器访问权，无论我们观察了多久，都值整整一年的宽限期。</value> + </data> + <data name="about.limits.oneHost.lead" xml:space="preserve"> + <value>本站的一切，都出自一台主机的间隔观测。</value> + </data> + <data name="about.limits.oneHost.body" xml:space="preserve"> + <value>可连通时间的百分比，是我们观测过的那段窗口内的比例，绝不是我们没观测过的窗口的比例。本站的任何图形都不会替其余部分补上数据。</value> + </data> + <data name="about.limits.deletion.lead" xml:space="preserve"> + <value>任何内容都不会被删除。</value> + </data> + <data name="about.limits.deletion.body" xml:space="preserve"> + <value>归档只是把游戏移出默认列表、排行和今日活跃数字，仅此而已。它的页面、URL、历史和地址都保留，我们仍会继续探测，一次成功的探测就能让它回来。</value> + </data> + <data name="about.never.heading" xml:space="preserve"> + <value>本站不会做的事</value> + </data> + <data name="about.never.votes.lead" xml:space="preserve"> + <value>没有投票、星级、评分或推荐。</value> + </data> + <data name="about.never.votes.body" xml:space="preserve"> + <value>排行仅由实测数据算出。一个按谁能动员最多点击来排名的目录，描述的是拉票活动，而不是这个爱好本身——前辈们正是这样倒下的。</value> + </data> + <data name="about.never.forums.lead" xml:space="preserve"> + <value>没有论坛、评测、维基、评论或玩家资料页。</value> + </data> + <data name="about.never.forums.body" xml:space="preserve"> + <value>入门资料——什么是 MUSH、哪种代码库适合协作扮演——和本站其余内容一样，由人撰写、署名，并纳入版本管理。</value> + </data> + <data name="about.never.names.lead" xml:space="preserve"> + <value>玩家名称从不留存。</value> + </data> + <data name="about.never.names.body" xml:space="preserve"> + <value>WHO 的回复只在内存中解析，取出一个计数和表头的形状。名称不会被记录下来；汇总使用加盐哈希，盐值会轮换。</value> + </data> + <data name="about.never.population.lead" xml:space="preserve"> + <value>不发布任何绝对人口数字。</value> + </data> + <data name="about.never.population.body" xml:space="preserve"> + <value>我们发布按代码库和按协议的占比：在实测集合上算出的比例，即使还有我们数不出来的游戏也依然成立。“有多少人在玩 MU*”则不然，因为那个数字一经引用就站不住脚。</value> + </data> + <data name="about.crawler.heading" xml:space="preserve"> + <value>爬虫，以及如何让它停下</value> + </data> + <data name="about.crawler.probe.lead" xml:space="preserve"> + <value>一次探测就是一个从不登录的连接。</value> + </data> + <data name="about.crawler.probe.body" xml:space="preserve"> + <value>它打开一个套接字，协商 telnet 选项，读取连接画面，通过协商选项 70 索取 MSSP，发送 {commands}，然后断开。不建角色，不登录，对端没有任何改动。会话有超时上限，卡住的探测不会一直占着一个连接位。</value> + </data> + <data name="about.crawler.delay.lead" xml:space="preserve"> + <value>CRAWL DELAY 说了算。</value> + </data> + <data name="about.crawler.delay.body" xml:space="preserve"> + <value>游戏若在 MSSP 报告中给出希望的最小间隔，我们就照办，并在两个方向上都优先于我们自己的排期：720 小时就是每月一次，而不是每周一次。失联的游戏仍会按这个更长的间隔被一直尝试下去，它恢复之后，正是这样重新回到列表的。</value> + </data> + <data name="about.crawler.referral.lead" xml:space="preserve"> + <value>转介来的地址只做核验，从不轻信。</value> + </data> + <data name="about.crawler.referral.body" xml:space="preserve"> + <value>MSSP 允许一个游戏点名其他游戏。任何拨号之前，每个名称都先做解析；除非它解析出的每一个地址都是全球可路由的，否则一律拒绝。解析结果混杂时，整个目标都被拒绝。这种拒绝记在我们自己名下，绝不会作为停机出现在某个游戏的记录里。</value> + </data> + <data name="about.crawler.screens.lead" xml:space="preserve"> + <value>展示连接画面，是因为它本来就发给所有人。</value> + </data> + <data name="about.crawler.screens.body" xml:space="preserve"> + <value>服务器会向每一个匿名连接、无需认证地绘出自己的连接画面。我们把它作为证据展示，并加以标注。你若开口，我们就撤下。</value> + </data> + <data name="about.crawler.stop.lead" xml:space="preserve"> + <value>说停我们就停——有三种方式。</value> + </data> + <data name="about.crawler.stop.body" xml:space="preserve"> + <value>在你的 MSSP 报告中发布 {variable} 1，读到它的那次探测就是最后一次。或者在 {label}.your.host 上发布一条内容为“{value}”的 TXT 记录，这既不需要支持 MSSP，也不需要在本站注册账户。再或者，写信给一个人。这三种方式都会在一个爬取周期之内生效，并连同日期和我们读到的内容一起记录，提交表单上同样照此执行。</value> + </data> + <data name="about.crawler.scope.lead" xml:space="preserve"> + <value>MSSP 字段停的是那个监听端口，TXT 记录停的是整台主机。</value> + </data> + <data name="about.crawler.scope.body" xml:space="preserve"> + <value>MSSP 由应答的那个端口发布，因此它只代表那个端口——MU* 托管商常常在同一个域名下运行互不相关的游戏，谁也不该替邻居闭嘴。TXT 记录默认覆盖所有端口，除非它指名某一个，写作“{value}=4201”。凡是我们读不出端口清单的写法，都按整台主机处理，所以“{value}=all”也是有效的。</value> + </data> + <data name="about.crawler.dns.lead" xml:space="preserve"> + <value>DNS 这条路，你不用问我们就能撤销。</value> + </data> + <data name="about.crawler.dns.body" xml:space="preserve"> + <value>读一条 TXT 记录，不必连上那台叫我们别来的服务器，所以我们在每次拨号前都会重新读它。你把它删掉，一周之内我们就会再次拨号。而 MSSP 字段不做你叫我们别做的那件事就无法重读，所以通过 MSSP 提出的退出和书面请求会一直有效，直到你另行告知。已退出的地址只会得到这一次 TXT 查询：它触及的是你的域名服务器，绝不会触及你的游戏。</value> + </data> + <data name="about.crawler.stopping.lead" xml:space="preserve"> + <value>停下不是删除，也不是停机。</value> + </data> + <data name="about.crawler.stopping.body" xml:space="preserve"> + <value>选择退出的游戏保留它的页面、它的地址，以及它开口之前我们实测到的一切。停下的只有新数据：活跃度网格不再增加小时，并且不指明原因，因为不再叩门是我们的决定，那是关于我们的事实。它记录在那次没有发生的爬取上，也记录在提出请求者的名册里。</value> + </data> + <data name="about.crawler.unlist.lead" xml:space="preserve"> + <value>如果只是停下还不够，列表条目也可以撤下。</value> + </data> + <data name="about.crawler.unlist.body" xml:space="preserve"> + <value>当我们在你游戏应答的每一个地址上都已停手之后，你的控制台会多出一项：把它移出列表、排行和每日数字。页面和它曾用过的每一个地址仍然照常应答，任何内容都不会被删除——它只是不再是读者靠浏览就能走到的地方。这需要一次经过验证的认领，因为这是关于你游戏的决定，我们会记录是谁做的。而一次探测就能撤销它：收回你的退出声明，下一次拨号只要得到应答，你就会重新回到列表，不必再来问我们第二次。</value> + </data> + <data name="about.identity.announced" xml:space="preserve"> + <value>服务器询问来者何人时，爬虫自报为 {name}。</value> + </data> + <data name="about.identity.unannounced" xml:space="preserve"> + <value>爬虫已配置为自称 {name}，但目前还说不出口。它使用的 telnet 库没有给客户端设置终端类型的途径，所以你的日志里看到的是那个库的默认值，而 NEW-ENVIRON 是用爬虫主机的环境作答的。这两处都是那个库的缺口，该由我们去那里修补。在此之前，请靠形态辨认一次探测：一个连接，不登录，一组简短的只读命令，然后就走。</value> + </data> + <data name="about.identity.crawler" xml:space="preserve"> + <value>爬虫</value> + </data> + <data name="about.identity.contact" xml:space="preserve"> + <value>联系方式</value> + </data> + <data name="about.identity.crawler.line" xml:space="preserve"> + <value>爬虫：{name}</value> + </data> + <data name="about.identity.contact.line" xml:space="preserve"> + <value>联系方式：{url}</value> + </data> + <data name="about.identity.placeholder" xml:space="preserve"> + <value>——占位值；本部署未设置联系地址</value> + </data> + <data name="about.identity.placeholder.plain" xml:space="preserve"> + <value>未配置联系地址，因此上面那个只是占位值，不会有人回应。</value> + </data> + <data name="about.sources.heading" xml:space="preserve"> + <value>游戏名单从何而来</value> + </data> + <data name="about.sources.addresses.lead" xml:space="preserve"> + <value>我们只取地址，别的都不取。</value> + </data> + <data name="about.sources.addresses.body" xml:space="preserve"> + <value>一次回填只取一个主机和一个端口。不取人数计数，不取连通历史，不取简介，不取字段，也不记录某个地址来自哪个站点。</value> + </data> + <data name="about.sources.less.lead" xml:space="preserve"> + <value>刻意少于那些站点能给的。</value> + </data> + <data name="about.sources.less.body" xml:space="preserve"> + <value>其中有几家存着多年的带日期人数计数。把它们导进来，会用别人早已在观测的游戏去填满热力图，也会把本站最核心的主张，架在别人的探测器上。</value> + </data> + <data name="about.sources.origin.lead" xml:space="preserve"> + <value>一个游戏的出处不是单一事实。</value> + </data> + <data name="about.sources.origin.body" xml:space="preserve"> + <value>凡是值得列出的游戏，都会同时出现在其中好几个目录里，所以“导入自”只会写上先跑完的那次抓取。某个游戏存在，这是公开信息；我们从哪里读到的，既不增添任何东西，也是别人劳动成果里最没理由算作我们的那一部分。</value> + </data> + <data name="about.sources.etiquette.lead" xml:space="preserve"> + <value>读别人的站点，终究是在读别人的站点。</value> + </data> + <data name="about.sources.etiquette.body" xml:space="preserve"> + <value>抓取之前，我们先索要批量导出或有文档的接口，先读 robots.txt，并对抓取严格限速。凡是需要维护者点头的来源，在有人能声明已经征询过之前，一律不抓。</value> + </data> + <data name="about.source.read" xml:space="preserve"> + <value>已读取——仅地址</value> + </data> + <data name="about.source.withheld" xml:space="preserve"> + <value>未读取——等待许可</value> + </data> + <data name="about.source.tintinMssp.note" xml:space="preserve"> + <value>一个页面，一次请求。由一个逐个连入游戏、并打印所读内容的爬虫发布。</value> + </data> + <data name="about.source.tintinMsdp.note" xml:space="preserve"> + <value>同一个爬虫的 MSDP 列表。几乎是其 MSSP 版本的子集，读取它只为那少数几个另一份没有覆盖到的地址。</value> + </data> + <data name="about.source.mudConnector.note" xml:space="preserve"> + <value>在一个页面上发布整份目录，因此读一次只花一个请求。它是我们最大的地址来源，而不是任何实测数据的来源。</value> + </data> + <data name="about.source.mudStats.note" xml:space="preserve"> + <value>一个索引页，外加每个世界一个页面，所以只能抓取，而不能导出。2026 年 7 月 30 日，我们以十五秒的间隔、遵守 robots.txt 抓取了他们的 143 个页面，但当时还没有人写信联系过他们。这本不该发生。现在这道闸门需要有人愿意声明已经征询过维护者才会打开。</value> + </data> + <data name="about.source.mudVerse.note" xml:space="preserve"> + <value>已实现，已测试，从未运行。除许可这一项之外，它在各方面都是这里最强的来源；在有人写信联系他们之前，我们不会抓取任何内容。</value> + </data> + <data name="about.licence.heading" xml:space="preserve"> + <value>许可协议</value> + </data> + <data name="about.licence.code.lead" xml:space="preserve"> + <value>代码采用 MIT 许可协议。</value> + </data> + <data name="about.licence.code.body" xml:space="preserve"> + <value>本站、爬虫和各个解析器，均在 MIT 许可协议下开源。</value> + </data> + <data name="about.licence.open.lead" xml:space="preserve"> + <value>数据的许可协议尚无定论。</value> + </data> + <data name="about.licence.open.body" xml:space="preserve"> + <value>这是与代码分开的一项决定，目前尚未作出。请把下面的条款当作本部署当前的答复，而不是本项目已定的立场。竞争的目录把整份名录拿走，在这里算作一项成功，所以无论最终如何定夺，都不会挡它的路。</value> + </data> + <data name="about.licence.codeLabel" xml:space="preserve"> + <value>代码</value> + </data> + <data name="about.licence.dataLabel" xml:space="preserve"> + <value>数据，按本部署提供的形式</value> + </data> + <data name="about.licence.creditLabel" xml:space="preserve"> + <value>署名为</value> + </data> + <data name="about.licence.code.line" xml:space="preserve"> + <value>代码：{licence}</value> + </data> + <data name="about.licence.data.line" xml:space="preserve"> + <value>数据：{licence}</value> + </data> + <data name="about.licence.credit.line" xml:space="preserve"> + <value>署名为：{credit}</value> + </data> + <data name="about.licence.deployment" xml:space="preserve"> + <value>（这是本部署提供的形式。本项目自己的答复仍未定。）</value> + </data> + <data name="submit.title" xml:space="preserve"> + <value>提交游戏</value> + </data> + <data name="submit.lede" xml:space="preserve"> + <value>告诉我们某个游戏在哪里。一个主机加一个端口就是整张表单；本站其余的一切，都由我们自己的爬虫实测得出。</value> + </data> + <data name="submit.host.label" xml:space="preserve"> + <value>主机</value> + </data> + <data name="submit.port.label" xml:space="preserve"> + <value>端口</value> + </data> + <data name="submit.host.hint" xml:space="preserve"> + <value>mud.example.org，或者粘贴 mud.example.org:4201 并把端口留空</value> + </data> + <data name="submit.button" xml:space="preserve"> + <value>提交</value> + </data> + <data name="submit.noCatalogue" xml:space="preserve"> + <value>提交需要数据库，而本站正运行在演示数据上。没有可写入的爬取登记表，所以这里干脆不放表单，而不是放一个悄悄什么也不做的表单。</value> + </data> + <data name="submit.notHere" xml:space="preserve"> + <value>此处没有</value> + </data> + <data name="submit.what.heading" xml:space="preserve"> + <value>一个地址会经历什么</value> + </data> + <data name="submit.what.resolve" xml:space="preserve"> + <value>拨号之前我们先解析地址，凡是解析到公网之外的一律拒绝。那是关于我们自己套接字的决定，绝不是关于某个游戏的事实。</value> + </data> + <data name="submit.what.optOut" xml:space="preserve"> + <value>如果运行那台主机的人已经要求我们不要爬取，那么无论谁提交，我们都不会接受这个地址。陌生人无法把你的游戏重新放上本站。</value> + </data> + <data name="submit.what.schedule" xml:space="preserve"> + <value>如果它有应答，我们就读取服务器对自己的说法，并按它自己的节奏一直读下去。一个地址只需要给我们一次。</value> + </data> + <data name="submit.what.claim" xml:space="preserve"> + <value>在有人证明自己是运营者之前，站上不会出现任何内容。认领需要一个通行密钥，以及在游戏本身上发布的一行文字。</value> + </data> + <data name="submit.what.duplicate" xml:space="preserve"> + <value>我们已经有的地址会并入现有条目。重复提交不会产生第二个条目，也不会让探测提前。</value> + </data> + <data name="submit.answer.thatAddress" xml:space="preserve"> + <value>那个地址</value> + </data> + <data name="submit.accepted.heading" xml:space="preserve"> + <value>已进入登记表。</value> + </data> + <data name="submit.accepted.sentence" xml:space="preserve"> + <value>{address} 会在下一个爬取周期被拨号，此后一直按它自己的节奏进行。等有人证明自己是运营者，它就会出现在这里——带着同一个地址回到这张表单，它会把链接交给你。</value> + </data> + <data name="submit.unclaimed.heading" xml:space="preserve"> + <value>我们有它，尚无人认领。</value> + </data> + <data name="submit.unclaimed.sentence" xml:space="preserve"> + <value>{address} 是我们已经在实测的地址。在有人证明自己是运营者之前，它不会出现在站上。如果那个人就是你，这里就是入口。</value> + </data> + <data name="submit.known.heading" xml:space="preserve"> + <value>这个我们已经有了。</value> + </data> + <data name="submit.known.sentence" xml:space="preserve"> + <value>{address} 是我们已经在实测的游戏。没有创建任何内容，也没有改动任何内容。</value> + </data> + <data name="submit.knownAddress.heading" xml:space="preserve"> + <value>这个地址我们已经有了。</value> + </data> + <data name="submit.knownAddress.sentence" xml:space="preserve"> + <value>{address} 我们已经知道了。没有创建任何内容，也没有改动任何内容。</value> + </data> + <data name="submit.queued.heading" xml:space="preserve"> + <value>已经在等了。</value> + </data> + <data name="submit.queued.sentence" xml:space="preserve"> + <value>{address} 已在爬取登记表中，尚未应答。再次提交不会让它提前：每个目标都按自己的节奏来，所以谁也不能借我们去催别人的服务器。</value> + </data> + <data name="submit.malformed.heading" xml:space="preserve"> + <value>这不是我们能拨号的地址。</value> + </data> + <data name="submit.malformed.sentence" xml:space="preserve"> + <value>主机名里需要有一个点或一个冒号，端口是 1 到 65535 之间的数字。请把两个框都填上，或者把 mud.example.org:4201 粘贴到第一个框里。</value> + </data> + <data name="submit.undialable.heading" xml:space="preserve"> + <value>我们无法拨号到那里。</value> + </data> + <data name="submit.undialable.sentence" xml:space="preserve"> + <value>对 {address} 给出这个答复有三种可能：名称可能解析不了，可能解析到公网之外，也可能运行那台主机的人已经要求我们别去。我们刻意不说是哪一种，因为向陌生人回答这个问题，等于从外部把一张网络画出来。关于该地址没有记录任何内容；这个决定是我们做的，也记在我们自己名下。</value> + </data> + <data name="submit.tooMany.heading" xml:space="preserve"> + <value>暂时够了。</value> + </data> + <data name="submit.tooMany.sentence" xml:space="preserve"> + <value>这张表单按提交者限速，你已经到上限了。请一小时后再来。没有丢失任何东西——我们收下的内容都已经在登记表里。</value> + </data> + <data name="submit.link.claim" xml:space="preserve"> + <value>认领此游戏</value> + </data> + <data name="account.signIn.title" xml:space="preserve"> + <value>登录</value> + </data> + <data name="account.signIn.preview" xml:space="preserve"> + <value>用通行密钥登录，即可认领你运营的游戏。没有密码可丢，也没有密码可偷。</value> + </data> + <data name="account.signIn.noDatabase" xml:space="preserve"> + <value>认领需要数据库，而本站正运行在演示数据上。这里没有可登录的东西。</value> + </data> + <data name="account.signIn.passkey.lead" xml:space="preserve"> + <value>登录就是一个通行密钥。</value> + </data> + <data name="account.signIn.passkey.body" xml:space="preserve"> + <value>私钥保存在你的设备或密码管理器里；我们只保存公钥那一半。没有密码，没有电子邮箱。</value> + </data> + <data name="account.signIn.button" xml:space="preserve"> + <value>用通行密钥登录</value> + </data> + <data name="account.signIn.script" xml:space="preserve"> + <value>本站唯一需要 JavaScript 的页面。没有它，通行密钥无法工作。</value> + </data> + <data name="account.register.heading" xml:space="preserve"> + <value>还没有账户？</value> + </data> + <data name="account.register.lede" xml:space="preserve"> + <value>只有在认领你运营的游戏时才需要账户。取一个对外显示的名字——它是认领旁边的一个标签，不是真名。</value> + </data> + <data name="account.register.name.label" xml:space="preserve"> + <value>名称</value> + </data> + <data name="account.register.name.placeholder" xml:space="preserve"> + <value>例如 corvid-admin</value> + </data> + <data name="account.register.button" xml:space="preserve"> + <value>用通行密钥创建账户</value> + </data> + <data name="account.store.heading" xml:space="preserve"> + <value>我们存什么</value> + </data> + <data name="account.store.name" xml:space="preserve"> + <value>你选择的名称。</value> + </data> + <data name="account.store.keys" xml:space="preserve"> + <value>你注册的每个通行密钥的公钥，以及你的设备给它取的名字。</value> + </data> + <data name="account.store.claims" xml:space="preserve"> + <value>你认领了哪些游戏，以及认领的时间。</value> + </data> + <data name="account.store.note" xml:space="preserve"> + <value>不存电子邮箱，不存密码，也不把 IP 日志与你的账户关联。即使丢失了全部通行密钥，你也可以在自己的游戏上发布一个新的认领令牌，重新来过：凭据是游戏，不是账户。</value> + </data> + <data name="date.absolute" xml:space="preserve"> + <value>{year}年{month}{day}日</value> + </data> + <data name="date.stamp" xml:space="preserve"> + <value>{date} {time} UTC</value> + </data> + <data name="age.short.now" xml:space="preserve"> + <value>刚刚</value> + </data> + <data name="age.short.minutes" xml:space="preserve"> + <value>{count, plural, other {#分钟}}</value> + </data> + <data name="age.short.hours" xml:space="preserve"> + <value>{count, plural, other {#小时}}</value> + </data> + <data name="age.short.days" xml:space="preserve"> + <value>{count, plural, other {#天}}</value> + </data> + <data name="age.short.weeks" xml:space="preserve"> + <value>{count, plural, other {#周}}</value> + </data> + <data name="age.short.months" xml:space="preserve"> + <value>{count, plural, other {#个月}}</value> + </data> + <data name="age.short.years" xml:space="preserve"> + <value>{count, plural, other {#年}}</value> + </data> + <data name="age.ago.now" xml:space="preserve"> + <value>刚刚</value> + </data> + <data name="age.ago.minutes" xml:space="preserve"> + <value>{count, plural, other {#分钟前}}</value> + </data> + <data name="age.ago.hours" xml:space="preserve"> + <value>{count, plural, other {#小时前}}</value> + </data> + <data name="age.ago.days" xml:space="preserve"> + <value>{count, plural, other {#天前}}</value> + </data> + <data name="age.ago.weeks" xml:space="preserve"> + <value>{count, plural, other {#周前}}</value> + </data> + <data name="age.ago.months" xml:space="preserve"> + <value>{count, plural, other {#个月前}}</value> + </data> + <data name="age.ago.years" xml:space="preserve"> + <value>{count, plural, other {#年前}}</value> + </data> + <data name="age.dark.now" xml:space="preserve"> + <value>刚刚</value> + </data> + <data name="age.dark.minutes" xml:space="preserve"> + <value>{count, plural, other {#分钟前}}</value> + </data> + <data name="age.dark.hours" xml:space="preserve"> + <value>{count, plural, other {#小时前}}</value> + </data> + <data name="age.dark.days" xml:space="preserve"> + <value>{count, plural, other {#天前}}</value> + </data> + <data name="age.dark.weeks" xml:space="preserve"> + <value>{count, plural, other {#周前}}</value> + </data> + <data name="age.dark.months" xml:space="preserve"> + <value>{count, plural, other {#个月前}}</value> + </data> + <data name="age.dark.years" xml:space="preserve"> + <value>{count, plural, other {#年前}}</value> + </data> + <data name="time.title" xml:space="preserve"> + <value>{age}，{stamp}</value> + </data> + <data name="time.spoken" xml:space="preserve"> + <value>，{stamp}</value> + </data> + <data name="chip.title" xml:space="preserve"> + <value>{value}——经{source}{how}，最近确认于 {date}</value> + </data> + <data name="chip.title.stale" xml:space="preserve"> + <value>{value}——经{source}{how}，最近确认于 {date}（已过预期刷新期）</value> + </data> + <data name="chip.plain" xml:space="preserve"> + <value>（{how}，{age}）</value> + </data> + <data name="chip.plain.stale" xml:space="preserve"> + <value>（{how}，{age}，已过刷新期）</value> + </data> + <data name="provenance.game.ownerDeclared" xml:space="preserve"> + <value>所有者自述</value> + </data> + <data name="source.staff" xml:space="preserve"> + <value>本站工作人员</value> + </data> + <data name="source.handshake" xml:space="preserve"> + <value>telnet 握手</value> + </data> + <data name="source.owner" xml:space="preserve"> + <value>游戏所有者</value> + </data> + <data name="source.who" xml:space="preserve"> + <value>WHO</value> + </data> + <data name="source.i3" xml:space="preserve"> + <value>I3</value> + </data> + <data name="source.mssp" xml:space="preserve"> + <value>MSSP</value> + </data> + <data name="source.info" xml:space="preserve"> + <value>INFO</value> + </data> + <data name="source.i3Mudlist" xml:space="preserve"> + <value>I3 的游戏列表</value> + </data> + <data name="source.banner" xml:space="preserve"> + <value>连接画面</value> + </data> + <data name="ecosystem.title" xml:space="preserve"> + <value>生态</value> + </data> + <data name="ecosystem.noTotals" xml:space="preserve"> + <value>只讲占比，绝不讲总量。我们不发布有多少人在玩 MU* 的数字：在我们实测过的游戏上算出的比例，即使还有连不上的游戏也依然成立，人头总数则不然。</value> + </data> + <data name="ecosystem.listed" xml:space="preserve"> + <value>{count, plural, other {已列出的游戏 {value} 个}}</value> + </data> + <data name="ecosystem.handshakes" xml:space="preserve"> + <value>{count, plural, other {已完成握手的游戏 {value} 个}}</value> + </data> + <data name="ecosystem.msspReports" xml:space="preserve"> + <value>{count, plural, other {已持有 MSSP 报告的游戏 {value} 个}}</value> + </data> + <data name="ecosystem.oldestHandshake" xml:space="preserve"> + <value>此处最早的握手：{age}前确认。</value> + </data> + <data name="ecosystem.share" xml:space="preserve"> + <value>{total, number} 个中的 {count, number}（{fraction, number, ::percent .0}）</value> + </data> + <data name="ecosystem.share.nothing" xml:space="preserve"> + <value>{total, number} 个中的 {count, number}——尚无实测</value> + </data> + <data name="ecosystem.share.percent" xml:space="preserve"> + <value>{fraction, number, ::percent .0}</value> + </data> + <data name="ecosystem.codebases.title" xml:space="preserve"> + <value>代码库</value> + </data> + <data name="ecosystem.codebases.basis" xml:space="preserve"> + <value>在已列出的{listed, plural, other {#个游戏}}中，有 {identified, number} 个告诉了我们它们运行的是什么，下面每一项占比都是相对这 {identified, number} 个算出来的。读不出代码库的游戏被排除在分母之外，绝不会被算作别的东西。</value> + </data> + <data name="ecosystem.codebases.none" xml:space="preserve"> + <value>还没有已列出的游戏告诉过我们它的代码库。</value> + </data> + <data name="ecosystem.soleUse" xml:space="preserve"> + <value>{share} 运行的代码库，没有任何其他已列出的游戏在用——每种各一个游戏，那是一个名字，而不是一份占比。它们计入上面的分母，只是从条形图中折叠起来，并没有被丢弃：</value> + </data> + <data name="ecosystem.lineages.title" xml:space="preserve"> + <value>谱系</value> + </data> + <data name="ecosystem.lineages.basis" xml:space="preserve"> + <value>还是这些游戏，按其服务器所承袭的传统分组——这是我们对代码库的判读，而不是任何游戏发布过的东西。没有游戏会报告“MUSH”：MSSP 里没有这个取值，而 MUSH 世界的大多数根本不发布 MSSP，所以只有这样，这个问题才问得出来。</value> + </data> + <data name="ecosystem.lineages.none" xml:space="preserve"> + <value>还没有已列出的游戏运行我们能归入某个谱系的代码库。</value> + </data> + <data name="ecosystem.lineages.notClassified" xml:space="preserve"> + <value>{count, plural, other {其中#个游戏运行的代码库}}我们没有归入任何谱系——有几个自己也这么说，它们发布的是 {family}。它们计入上面的分母，但不属于任何一份占比。</value> + </data> + <data name="ecosystem.protocols.title" xml:space="preserve"> + <value>协议</value> + </data> + <data name="ecosystem.protocols.floor" xml:space="preserve"> + <value>下面每一个实测数字都应读作下限。MSSP 是我们指名索取的，所以在这一项上，沉默本身就是一种回答。其余各项我们都不索取，服务器可能支持某个协议，却从不主动提供。</value> + </data> + <data name="ecosystem.mssp.instrument" xml:space="preserve"> + <value>{instrument} 是下面唯一不算下限的一行：我们向每台服务器指名索取它，所以没有提供它的游戏，是被问过之后拒绝的。它也是唯一没有自述数字的一项，因为凡是我们持有其报告的游戏，都已用行动证明支持它，再去数其中有多少同时把它列了出来，量到的只是一种习惯。</value> + </data> + <data name="ecosystem.mssp.gap" xml:space="preserve"> + <value>我们持有 {reports, number} 份报告，而今天提供 MSSP 的有{offered, plural, other {#个游戏}}：另外 {gap, number} 个在我们读过之后就不再发布了，一份报告不会因为不再重发而被丢弃。</value> + </data> + <data name="ecosystem.protocols.caption" xml:space="preserve"> + <value>协议采用情况。实测是服务器在一次完成的握手中提供的内容，自述是它的 MSSP 所声称的内容。两组不同的游戏，因此有两个分母。</value> + </data> + <data name="ecosystem.column.protocol" xml:space="preserve"> + <value>协议</value> + </data> + <data name="ecosystem.column.measured" xml:space="preserve"> + <value>实测——占 {basis}</value> + </data> + <data name="ecosystem.column.declared" xml:space="preserve"> + <value>自述——占 {basis}</value> + </data> + <data name="ecosystem.measured.never" xml:space="preserve"> + <value>未实测——从未观测到</value> + </data> + <data name="ecosystem.measured.declined" xml:space="preserve"> + <value>{share} · {declined, plural, other {#个游戏}}被问及时拒绝</value> + </data> + <data name="ecosystem.measured.unasked" xml:space="preserve"> + <value>{share} · {unobserved, plural, other {#个游戏}}既未提供也未被问及</value> + </data> + <data name="ecosystem.measured.declinedAndUnasked" xml:space="preserve"> + <value>{share} · {declined, plural, other {#个游戏}}被问及时拒绝 · {unobserved, plural, other {#个游戏}}既未提供也未被问及</value> + </data> + <data name="ecosystem.declared.none" xml:space="preserve"> + <value>未索取——这里的每一份报告本身就是回答</value> + </data> + <data name="ecosystem.curve.title" xml:space="preserve"> + <value>采用情况随时间的变化</value> + </data> + <data name="ecosystem.curve.caveat" xml:space="preserve"> + <value>每个点都是当天我们已实测的那些游戏上的占比，所以这条线会因两件事而移动：某个游戏改变了它提供的内容，以及我们能实测的游戏集合在它周围发生了变化。只有前者才是采用。下面的变更次数，才是纯粹由游戏改变主意构成的那一部分。</value> + </data> + <data name="ecosystem.curve.caption" xml:space="preserve"> + <value>各协议的实测占比，最早的读数在前</value> + </data> + <data name="ecosystem.curve.then" xml:space="preserve"> + <value>当时</value> + </data> + <data name="ecosystem.curve.now" xml:space="preserve"> + <value>现在</value> + </data> + <data name="ecosystem.curve.notMeasured" xml:space="preserve"> + <value>未实测</value> + </data> + <data name="ecosystem.snapshot.title" xml:space="preserve"> + <value>这是快照，不是曲线</value> + </data> + <data name="ecosystem.snapshot" xml:space="preserve"> + <value>这是我们现在能实测到的情况的一张快照。采用曲线画的是游戏改变主意，而我们在变化发生时才记录它，所以等记录得足够多，曲线才画得出来。若改用我们首次连通各个游戏的时间来作图，量到的将是这次爬取，而不是这个爱好。</value> + </data> + <data name="ecosystem.transitions" xml:space="preserve"> + <value>{count, plural, other {迄今已记录#次能力变更}}——曲线正是用这些材料画出来的。</value> + </data> + <data name="ecosystem.transitions.none" xml:space="preserve"> + <value>还没有任何实测能力发生过变化，因此无从作图。</value> + </data> + <data name="ecosystem.plain.denominators" xml:space="preserve"> + <value>实测的分母是 {measured}，自述的分母是 {declared}。两组不同的游戏，因此有两个分母。</value> + </data> + <data name="ecosystem.plain.counts" xml:space="preserve"> + <value>{listed} · {handshakes} · {mssp}。</value> + </data> + <data name="ecosystem.plain.oldestHandshake" xml:space="preserve"> + <value>这张图里最早的握手，最近一次确认是在 {age}前。</value> + </data> + <data name="ecosystem.plain.lineages" xml:space="preserve"> + <value>还是这些游戏，按其服务器所承袭的传统分组。这是{evidence}——{meaning}——而不是任何游戏发布过的东西：没有游戏会报告“MUSH”，因为 MSSP 里没有这个取值，而 MUSH 世界的大多数根本不发布 MSSP。</value> + </data> + <data name="ecosystem.plain.measured" xml:space="preserve"> + <value>实测：{value}</value> + </data> + <data name="ecosystem.plain.declared" xml:space="preserve"> + <value>自述：{value}</value> + </data> + <data name="rankings.title" xml:space="preserve"> + <value>排行</value> + </data> + <data name="rankings.noVote" xml:space="preserve"> + <value>仅由实测数据算出。永远没有投票、星级或评分。这里没有任何东西是对质量的排名。我们没有测过质量。</value> + </data> + <data name="rankings.busiest.title" xml:space="preserve"> + <value>最热闹——按实测的同时连接人数</value> + </data> + <data name="rankings.window.label" xml:space="preserve"> + <value>排行时间窗</value> + </data> + <data name="rankings.span" xml:space="preserve"> + <value>{days, plural, other {#天}}</value> + </data> + <data name="rankings.basis.median" xml:space="preserve"> + <value>最近{days, plural, other {#天}}内我们实测到的人数的中位数。</value> + </data> + <data name="rankings.basis.none" xml:space="preserve"> + <value>还没有游戏在{days, plural, other {#天}}内取得中位数所需的 {samples, number} 个样本。</value> + </data> + <data name="rankings.basis.eligible" xml:space="preserve"> + <value>{listed, number} 个已列出的游戏中，有{eligible, plural, other {#个}}在{days, plural, other {#天}}内取得了所需的 {samples, number} 个样本。</value> + </data> + <data name="rankings.basis.zero" xml:space="preserve"> + <value>实测到的零算数；读不出来的计数不算。</value> + </data> + <data name="rankings.spanChoice" xml:space="preserve"> + <value>一周说的是现在谁热闹，一个季度说的是一直以来谁热闹。这是两个不同的问题，一个游戏可能在其中一项领先，而在另一项不然。天数按整天计，时间为 UTC。</value> + </data> + <data name="rankings.busiest.empty" xml:space="preserve"> + <value>还没有已列出的游戏拥有足以参与排行的已计数样本——这说的是我们测了多久，而不是谁有多热闹。</value> + </data> + <data name="rankings.busiest.caption" xml:space="preserve"> + <value>按最近{days, plural, other {#天}}内我们实测到的人数的中位数为游戏排名。中位数相同的游戏并列同一名次，这里不做任何附加排序来分先后。</value> + </data> + <data name="rankings.column.place" xml:space="preserve"> + <value>#</value> + </data> + <data name="rankings.column.game" xml:space="preserve"> + <value>游戏</value> + </data> + <data name="rankings.column.median" xml:space="preserve"> + <value>中位数</value> + </data> + <data name="rankings.column.peak" xml:space="preserve"> + <value>峰值</value> + </data> + <data name="rankings.column.samples" xml:space="preserve"> + <value>已计数样本</value> + </data> + <data name="rankings.column.days" xml:space="preserve"> + <value>实测天数</value> + </data> + <data name="rankings.spells.title" xml:space="preserve"> + <value>连续可连通时间最长</value> + </data> + <data name="rankings.spells.basis" xml:space="preserve"> + <value>自所给日期起的每一次探测，都发现该游戏可连通。是可连通，不是在线：我们从一台主机上测一个套接字，路由不到的游戏完全可能好好活着。一段连续时长不可能超过我们观察的时长，所以日期才是事实，时长由它推出。</value> + </data> + <data name="rankings.spells.empty" xml:space="preserve"> + <value>目前没有已列出的游戏处在连续可连通的时段中。</value> + </data> + <data name="rankings.spells.caption" xml:space="preserve"> + <value>自所给日期起每一次探测都可连通的游戏。自同一日期起可连通的游戏并列同一名次，这里不做任何附加排序来分先后。</value> + </data> + <data name="rankings.column.since" xml:space="preserve"> + <value>可连通起始</value> + </data> + <data name="rankings.column.duration" xml:space="preserve"> + <value>即</value> + </data> + <data name="rankings.archivedNote" xml:space="preserve"> + <value>已归档的游戏只是不在这两张表里，仅此而已；一次成功的探测就能让它们回来。</value> + </data> + <data name="rankings.plain.busiest" xml:space="preserve"> + <value>最热闹——最近{days, plural, other {#天}}实测人数中位数</value> + </data> + <data name="rankings.plain.windows" xml:space="preserve"> + <value>时间窗：</value> + </data> + <data name="rankings.plain.thisOne" xml:space="preserve"> + <value>当前这个</value> + </data> + <data name="rankings.plain.row" xml:space="preserve"> + <value>中位数 {median, number} · 峰值 {peak, number} · {window, number} 天中的 {days, number} 天里共有{samples, plural, other {#个已计数样本}}</value> + </data> + <data name="rankings.plain.spellRow" xml:space="preserve"> + <value>自 {date} 起每次探测均可连通 · {duration}</value> + </data> + <data name="archive.title" xml:space="preserve"> + <value>归档</value> + </data> + <data name="archive.lede" xml:space="preserve"> + <value>已经停止应答的游戏。没有删除任何内容。我们仍每周探测，一次成功的探测当天就能把游戏放回列表。</value> + </data> + <data name="archive.search.legend" xml:space="preserve"> + <value>搜索归档</value> + </data> + <data name="archive.search.label" xml:space="preserve"> + <value>搜索已归档的游戏</value> + </data> + <data name="archive.search.placeholder" xml:space="preserve"> + <value>名称、代码库或简介</value> + </data> + <data name="archive.search.submit" xml:space="preserve"> + <value>显示</value> + </data> + <data name="archive.count" xml:space="preserve"> + <value>{count, plural, =0 {没有已归档的游戏} other {#个已归档的游戏}}</value> + </data> + <data name="archive.badge" xml:space="preserve"> + <value>已归档</value> + </data> + <data name="archive.lastReachable" xml:space="preserve"> + <value>最近连通</value> + </data> + <data name="archive.knownLive" xml:space="preserve"> + <value>已知存活</value> + </data> + <data name="archive.darkFor" xml:space="preserve"> + <value>（{age}前）</value> + </data> + <data name="archive.empty" xml:space="preserve"> + <value>没有匹配结果。</value> + </data> + <data name="archive.neverReachable" xml:space="preserve"> + <value>在我们实测过的范围内从未连通</value> + </data> + <data name="archive.noReachableTime" xml:space="preserve"> + <value>未实测到可连通时长</value> + </data> + <data name="archive.darkFor.unknown" xml:space="preserve"> + <value>未知</value> + </data> + <data name="archive.knownLive.years" xml:space="preserve"> + <value>{years, number, ::.#} 年</value> + </data> + <data name="archive.knownLive.days" xml:space="preserve"> + <value>{days, plural, other {#天}}</value> + </data> + <data name="archive.run" xml:space="preserve"> + <value>{from} – {to} · {span}</value> + </data> + <data name="archive.run.months" xml:space="preserve"> + <value>{count, plural, other {#个月}}</value> + </data> + <data name="archive.run.years" xml:space="preserve"> + <value>{count, plural, other {#年}}</value> + </data> + <data name="archive.plain.matching" xml:space="preserve"> + <value>{count, plural, other {有#个游戏}}匹配“{query}”</value> + </data> + <data name="archive.plain.count" xml:space="preserve"> + <value>{count, plural, other {#个游戏}}</value> + </data> + <data name="archive.plain.lastReachable" xml:space="preserve"> + <value>最近连通：</value> + </data> + <data name="archive.plain.knownLive" xml:space="preserve"> + <value>已知存活：</value> + </data> + <data name="archive.plain.knownLiveValue" xml:space="preserve"> + <value>实测可连通时长 {value}</value> + </data> + <data name="archive.plain.run" xml:space="preserve"> + <value>运行期：</value> + </data> + <data name="archive.plain.codebase" xml:space="preserve"> + <value>代码库：</value> + </data> + <data name="footer.randomGame" xml:space="preserve"> + <value>随机游戏</value> + </data> + <data name="trend.day.counted" xml:space="preserve"> + <value>{d, date, medium}——平均 {typical}，{probes, plural, other {#次探测}}中介于 {low}–{high}</value> + </data> + <data name="trend.day.flat" xml:space="preserve"> + <value>{d, date, medium}——{count, plural, =0 {0 人} other {#人}}，{probes, plural, other {#次探测}}次次如此</value> + </data> + <data name="trend.day.notCounted" xml:space="preserve"> + <value>{d, date, medium}——已探测，未能读取计数</value> + </data> + <data name="trend.day.notMeasured" xml:space="preserve"> + <value>{d, date, medium}——无实测</value> + </data> + <data name="trend.summary" xml:space="preserve"> + <value>在{days, plural, other {#天}}中的 {counted} 天里，典型有 {typical} 人在线，峰值 {peak}。</value> + </data> + <data name="trend.direction.steady" xml:space="preserve"> + <value>整个区间内保持平稳。</value> + </data> + <data name="trend.direction.up" xml:space="preserve"> + <value>从区间开始到结束，约上升 {change, number, percent}。</value> + </data> + <data name="trend.direction.down" xml:space="preserve"> + <value>从区间开始到结束，约下降 {change, number, percent}。</value> + </data> + <data name="trend.none.probed" xml:space="preserve"> + <value>本区间内有过探测，其中任何一次都未能读出在线人数。</value> + </data> + <data name="trend.none.notMeasured" xml:space="preserve"> + <value>本区间内没有实测。</value> + </data> + <data name="trend.empty" xml:space="preserve"> + <value>本区间内没有计到任何数。</value> + </data> + <data name="trend.week.span" xml:space="preserve"> + <value>{from, date, d MMM}–{to, date, d MMM}</value> + </data> + <data name="trend.week.oneDay" xml:space="preserve"> + <value>{d, date, d MMM}</value> + </data> + <data name="trend.week.counted" xml:space="preserve"> + <value>{span}：典型 {typical}，峰值 {peak}，已计数{days, plural, other {#天}}</value> + </data> + <data name="trend.week.notCounted" xml:space="preserve"> + <value>{span}：已探测，未能读取计数</value> + </data> + <data name="trend.week.notMeasured" xml:space="preserve"> + <value>{span}：未实测</value> + </data> + <data name="trend.week.uncounted" xml:space="preserve"> + <value>{count, plural, other {#天已探测但没有计数}}</value> + </data> + <data name="trend.week.unmeasured" xml:space="preserve"> + <value>{count, plural, other {#天未实测}}</value> + </data> + <data name="trend.week.and" xml:space="preserve"> + <value>{line}，{clause}</value> + </data> + <data name="trend.range" xml:space="preserve"> + <value>按 UTC 计日 · {from, date, medium} – {to, date, medium}</value> + </data> + <data name="trend.ceiling" xml:space="preserve"> + <value>顶端为 {value}</value> + </data> + <data name="trend.counted" xml:space="preserve"> + <value>{days, plural, other {#天}}中已计数 {counted} 天</value> + </data> + <data name="trend.axis.month" xml:space="preserve"> + <value>{d, date, MMM}</value> + </data> + <data name="trend.axis.monthYear" xml:space="preserve"> + <value>{d, date, MMM yyyy}</value> + </data> + <data name="trend.legend.mean" xml:space="preserve"> + <value>当天我们读到的各次计数的平均值</value> + </data> + <data name="trend.legend.peak" xml:space="preserve"> + <value>直到当天最热闹的那次计数</value> + </data> + <data name="trend.legend.band" xml:space="preserve"> + <value>当天最低到最高的计数</value> + </data> + <data name="trend.legend.notCounted" xml:space="preserve"> + <value>已探测，未能读取计数</value> + </data> + <data name="trend.legend.notMeasured.bar" xml:space="preserve"> + <value>未实测——完全没有条形</value> + </data> + <data name="trend.legend.notMeasured.line" xml:space="preserve"> + <value>未实测——线条断开一段</value> + </data> + <data name="trend.spans.label" xml:space="preserve"> + <value>趋势区间</value> + </data> + <data name="trend.shapes.label" xml:space="preserve"> + <value>趋势图形</value> + </data> + <data name="trend.preset" xml:space="preserve"> + <value>{days, plural, other {#天}}</value> + </data> + <data name="trend.earlier" xml:space="preserve"> + <value>← 更早</value> + </data> + <data name="trend.later" xml:space="preserve"> + <value>更近 →</value> + </data> + <data name="trend.shape.line" xml:space="preserve"> + <value>折线</value> + </data> + <data name="trend.shape.bar" xml:space="preserve"> + <value>条形</value> + </data> + <data name="trend.plain.heading" xml:space="preserve"> + <value>人数随时间变化</value> + </data> + <data name="trend.plain.range" xml:space="preserve"> + <value>{from, date, medium} – {to, date, medium}，UTC</value> + </data> + <data name="trend.plain.earlier" xml:space="preserve"> + <value>更早</value> + </data> + <data name="trend.plain.note" xml:space="preserve"> + <value>一周的概况按其中我们计到数的那些天汇总；一天也没有的那一周会明确说明</value> + </data> + <data name="reach.kicker" xml:space="preserve"> + <value>可连通 · 最近{days, plural, other {#天}}</value> + </data> + <data name="reach.stat.reachable" xml:space="preserve"> + <value>可连通</value> + </data> + <data name="reach.stat.longestOutage" xml:space="preserve"> + <value>最长中断</value> + </data> + <data name="reach.stat.lastCause" xml:space="preserve"> + <value>最近原因</value> + </data> + <data name="reach.noOutage" xml:space="preserve"> + <value>窗口内没有</value> + </data> + <data name="reach.noCause" xml:space="preserve"> + <value>未记录</value> + </data> + <data name="reach.scale.ago" xml:space="preserve"> + <value>{days, plural, other {#天前}}</value> + </data> + <data name="reach.scale.today" xml:space="preserve"> + <value>今天</value> + </data> + <data name="reach.legend.reachable" xml:space="preserve"> + <value>可连通</value> + </data> + <data name="reach.legend.degraded" xml:space="preserve"> + <value>降级——有应答，未能完成</value> + </data> + <data name="reach.legend.unreachable" xml:space="preserve"> + <value>无法连通</value> + </data> + <data name="reach.legend.notMeasured" xml:space="preserve"> + <value>未实测</value> + </data> + <data name="reach.word.reachable" xml:space="preserve"> + <value>可连通</value> + </data> + <data name="reach.word.degraded" xml:space="preserve"> + <value>降级</value> + </data> + <data name="reach.word.unreachable" xml:space="preserve"> + <value>无法连通</value> + </data> + <data name="reach.word.notMeasured" xml:space="preserve"> + <value>未实测</value> + </data> + <data name="reach.day.reachable" xml:space="preserve"> + <value>{d, date, d MMM}——全天可连通</value> + </data> + <data name="reach.day.degraded" xml:space="preserve"> + <value>{d, date, d MMM}——降级（{cause}）：有应答，未能完成</value> + </data> + <data name="reach.day.unreachable" xml:space="preserve"> + <value>{d, date, d MMM}——无法连通（{cause}）</value> + </data> + <data name="reach.day.notMeasured" xml:space="preserve"> + <value>{d, date, d MMM}——未实测；当时我们还没有开始观测这个游戏</value> + </data> + <data name="reach.none" xml:space="preserve"> + <value>{days, plural, other {最近#天尚未实测。}}</value> + </data> + <data name="reach.fraction.window" xml:space="preserve"> + <value>最近{days, plural, other {#天}}中，有 {percent} 的时间可连通。</value> + </data> + <data name="reach.fraction.measured" xml:space="preserve"> + <value>在我们已实测的{days, plural, other {#天}}中，有 {percent} 的时间可连通。</value> + </data> + <data name="reach.fraction.unknown" xml:space="preserve"> + <value>{days, plural, other {最近#天的可连通情况尚未实测。}}</value> + </data> + <data name="reach.unreachable.noneInWindow" xml:space="preserve"> + <value>窗口内没有哪一天是无法连通的。</value> + </data> + <data name="reach.unreachable.noneMeasured" xml:space="preserve"> + <value>我们实测过的日子里，没有哪一天是无法连通的。</value> + </data> + <data name="reach.unreachable.days" xml:space="preserve"> + <value>{count, plural, other {#天无法连通。}}</value> + </data> + <data name="reach.degraded.days" xml:space="preserve"> + <value>{count, plural, other {#天降级——我们连上了，但未能完成。}}</value> + </data> + <data name="reach.longestOutage" xml:space="preserve"> + <value>最长中断 {duration}。</value> + </data> + <data name="reach.longestOutage.cause" xml:space="preserve"> + <value>最长中断 {duration}（{cause}）。</value> + </data> + <data name="reach.predate" xml:space="preserve"> + <value>{count, plural, other {有#天早于我们的任何实测。}}</value> + </data> + <data name="reach.spell.range" xml:space="preserve"> + <value>{from, date, d MMM} – {to, date, d MMM}</value> + </data> + <data name="reach.spell.oneDay" xml:space="preserve"> + <value>{d, date, d MMM}</value> + </data> + <data name="reach.spell" xml:space="preserve"> + <value>{range}：{word}{count, plural, other {#天}}</value> + </data> + <data name="reach.spell.cause" xml:space="preserve"> + <value>{range}：{word}{count, plural, other {#天}}（{cause}）</value> + </data> + <data name="reach.plain.heading" xml:space="preserve"> + <value>可连通</value> + </data> + <data name="reach.plain.window" xml:space="preserve"> + <value>{days, plural, other {最近#天}}</value> + </data> + <data name="reach.plain.fraction" xml:space="preserve"> + <value>可连通：{days, plural, other {最近#天}}中的 {percent}</value> + </data> + <data name="reach.plain.longestOutage" xml:space="preserve"> + <value>最长中断：{duration}</value> + </data> + <data name="cause.dns" xml:space="preserve"> + <value>dns 未能解析</value> + </data> + <data name="cause.refused" xml:space="preserve"> + <value>连接被拒绝</value> + </data> + <data name="cause.tls" xml:space="preserve"> + <value>tls 失败</value> + </data> + <data name="cause.timeout" xml:space="preserve"> + <value>超时</value> + </data> + <data name="cause.handshakeStalled" xml:space="preserve"> + <value>握手停滞</value> + </data> + <data name="cause.none" xml:space="preserve"> + <value>未记录原因</value> + </data> + <data name="ansi.suppressed" xml:space="preserve"> + <value>所有者要求我们不要再发布这个游戏的连接画面。</value> + </data> + <data name="ansi.absent" xml:space="preserve"> + <value>尚未从这个游戏捕获到连接画面。</value> + </data> + <data name="ansi.tooSmall" xml:space="preserve"> + <value>{count, plural, other {只回来了#行——太少，无法显示。}}</value> + </data> + <data name="ansi.asSent" xml:space="preserve"> + <value>按服务器发送的原样</value> + </data> + <data name="ansi.size" xml:space="preserve"> + <value>{columns}×{rows}</value> + </data> + <data name="ansi.size.doubleWidth" xml:space="preserve"> + <value>{columns}×{rows}，双倍宽</value> + </data> + <data name="ansi.depth.colour" xml:space="preserve"> + <value>16 色 SGR</value> + </data> + <data name="ansi.depth.plain" xml:space="preserve"> + <value>无颜色</value> + </data> + <data name="ansi.readAs" xml:space="preserve"> + <value>按 {charset} 解读</value> + </data> + <data name="ansi.captured" xml:space="preserve"> + <value>已捕获</value> + </data> + <data name="ansi.frozen" xml:space="preserve"> + <value>已冻结——我们最后看到的画面</value> + </data> + <data name="ansi.alt.named" xml:space="preserve"> + <value>ASCII 图画：{game} 的连接画面。它的文本在下方的“以文本形式阅读”中。</value> + </data> + <data name="ansi.alt" xml:space="preserve"> + <value>ASCII 图画：这个游戏的连接画面。它的文本在下方的“以文本形式阅读”中。</value> + </data> + <data name="ansi.plain.rows" xml:space="preserve"> + <value>{count, plural, other {连接画面：#行，仅文本}}</value> + </data> + <data name="ansi.plain.rows.readAs" xml:space="preserve"> + <value>{count, plural, other {连接画面：#行，仅文本，按 {charset} 解读}}</value> + </data> + <data name="capability.disagree.declaredNotOffered" xml:space="preserve"> + <value>游戏自述具备该项，而服务器在握手中从未提供过它。</value> + </data> + <data name="capability.disagree.offeredNotDeclared" xml:space="preserve"> + <value>服务器提供该项，而游戏自己的记录说它没有。</value> + </data> + <data name="capability.disagree.note" xml:space="preserve"> + <value>通常只是一个久未更新的手打字段，而不是谎言。之所以显示出来，是因为客户端不该依赖两者不一致的部分。</value> + </data> + <data name="game.notFound" xml:space="preserve"> + <value>未找到</value> + </data> + <data name="game.notFound.hint" xml:space="preserve"> + <value>这个地址上没有游戏。请检查拼写。</value> + </data> + <data name="game.endpoint.lastAnswered" xml:space="preserve"> + <value>最近应答</value> + </data> + <data name="game.stale" xml:space="preserve"> + <value>{count, plural, other {有#项已超过刷新窗口。是旧，不是错。}}</value> + </data> + <data name="game.referrals.lists" xml:space="preserve"> + <value>这个游戏自己的转介列表点名了：</value> + </data> + <data name="game.referrals.listedBy" xml:space="preserve"> + <value>被以下游戏的转介列表点名：</value> + </data> + <data name="game.referral.since" xml:space="preserve"> + <value>自 {date} 起</value> + </data> + <data name="game.referral.dropped" xml:space="preserve"> + <value>已不再列出，最后一次见于</value> + </data> + <data name="game.archived.lastAnswered" xml:space="preserve"> + <value>最近一次应答是 {date}，距今 {ago}。</value> + </data> + <data name="game.archived.stillProbed" xml:space="preserve"> + <value>仍每周探测；它一应答，本页当天就会更新。</value> + </data> + <data name="game.archived.knownLive" xml:space="preserve"> + <value>已知存活 {span}</value> + </data> + <data name="game.excluded" xml:space="preserve"> + <value>不在列表、排行或每日数字中：我们认为这个地址不是一个可供人游玩的游戏。下面的一切都是它告诉我们的内容，原样未改。</value> + </data> + <data name="game.excluded.reason" xml:space="preserve"> + <value>我们的理由：{why}</value> + </data> + <data name="game.unlisted" xml:space="preserve"> + <value>应运营者的要求，不在列表、排行或每日数字中。下面的一切按原样保留，本页和它曾用过的每一个地址都继续应答，而我们不再向它拨号。</value> + </data> + <data name="game.plain.playersNow" xml:space="preserve"> + <value>当前人数：{count}</value> + </data> + <data name="game.plain.capabilities" xml:space="preserve"> + <value>能力（{total} 项中有 {disagreeing} 项不一致）</value> + </data> + <data name="game.plain.declared" xml:space="preserve"> + <value>游戏自述</value> + </data> + <data name="game.plain.connectScreen" xml:space="preserve"> + <value>连接画面</value> + </data> + <data name="game.plain.whatChanged" xml:space="preserve"> + <value>变更记录</value> + </data> + <data name="game.plain.measured" xml:space="preserve"> + <value>实测</value> + </data> + <data name="game.plain.declared.column" xml:space="preserve"> + <value>自述</value> + </data> + <data name="game.plain.disagree" xml:space="preserve"> + <value>** 不一致</value> + </data> + <data name="listing.row.connected" xml:space="preserve"> + <value>连接数</value> + </data> + <data name="listing.row.reached" xml:space="preserve"> + <value>连通</value> + </data> + <data name="facet.group.search" xml:space="preserve"> + <value>搜索</value> + </data> + <data name="facet.group.archived" xml:space="preserve"> + <value>已归档</value> + </data> + <data name="facet.group.adult" xml:space="preserve"> + <value>成人</value> + </data> + <data name="facet.value.included" xml:space="preserve"> + <value>已包含</value> + </data> + <data name="game.count.none" xml:space="preserve"> + <value>无计数</value> + </data> + <data name="game.count.none.why" xml:space="preserve"> + <value>当前无计数，此处也不指明原因</value> + </data> + <data name="game.plain.playersNoCount" xml:space="preserve"> + <value>当前人数：无计数（此处不指明原因）</value> + </data> + <data name="crawler.live" xml:space="preserve"> + <value>爬虫运行中 · 最近探测 {age}</value> + </data> + <data name="crawler.quiet" xml:space="preserve"> + <value>爬虫空闲 · 最近探测 {age}</value> + </data> + <data name="crawler.noProbe" xml:space="preserve"> + <value>此处尚未完成过任何探测</value> + </data> + <data name="crawler.cycle.nothingDue" xml:space="preserve"> + <value>本周期无到期目标</value> + </data> + <data name="crawler.cycle" xml:space="preserve"> + <value>{considered, plural, other {#个到期}} · {answered, plural, other {#个应答}} · {failed, plural, other {#个失败}}</value> + </data> + <data name="crawler.registry" xml:space="preserve"> + <value>登记表中有{targets, plural, other {#个地址}}，{due, plural, other {其中#个已到期}}</value> + </data> + <data name="preview.documentTitle" xml:space="preserve"> + <value>{page} — {site}</value> + </data> + <data name="preview.site" xml:space="preserve"> + <value>MU* 爱好的游戏目录——MUSH、MUD、MUCK、MOO——每一项事实都标明它的来源与时间。</value> + </data> + <data name="preview.demo" xml:space="preserve"> + <value>演示数据——此处没有任何内容经过实测。{description}</value> + </data> + <data name="preview.cardAlt" xml:space="preserve"> + <value>{site}——实测，而非自述</value> + </data> + <data name="preview.cardAlt.named" xml:space="preserve"> + <value>{site} 上的 {title}</value> + </data> + <data name="preview.title.games" xml:space="preserve"> + <value>游戏</value> + </data> + <data name="preview.title.archive" xml:space="preserve"> + <value>归档</value> + </data> + <data name="preview.title.rankings" xml:space="preserve"> + <value>排行</value> + </data> + <data name="preview.title.ecosystem" xml:space="preserve"> + <value>生态</value> + </data> + <data name="preview.title.reference" xml:space="preserve"> + <value>参考</value> + </data> + <data name="preview.title.about" xml:space="preserve"> + <value>关于</value> + </data> + <data name="preview.title.notFound" xml:space="preserve"> + <value>未找到</value> + </data> + <data name="preview.title.random" xml:space="preserve"> + <value>随机游戏</value> + </data> + <data name="preview.title.account" xml:space="preserve"> + <value>我的游戏</value> + </data> + <data name="preview.title.claim" xml:space="preserve"> + <value>认领 {game}</value> + </data> + <data name="preview.desc.games" xml:space="preserve"> + <value>我们连通过的每一个 MU*，按实测结果分面：代码库、服务器在握手中提供的协议、TLS、编码、语言，以及我们最近一次连入的时间。</value> + </data> + <data name="preview.desc.archive" xml:space="preserve"> + <value>已经失联的游戏，都保留下来。每个都保有自己的页面、历史和 URL，仍每周探测，一次成功连接即可回到列表。</value> + </data> + <data name="preview.desc.rankings" xml:space="preserve"> + <value>最热闹、最可连通、运行最久——仅由实测数据算出。本站任何地方都没有投票、星级或评分。</value> + </data> + <data name="preview.desc.ecosystem" xml:space="preserve"> + <value>我们实测的游戏中，代码库的占比与协议的采用情况，服务器提供的内容与它自述的内容并列呈现。只讲占比，绝不讲总量。</value> + </data> + <data name="preview.desc.reference" xml:space="preserve"> + <value>关于 MU* 爱好中的代码库、客户端与协议的手写页面，并与爬取所得的计数相互链接。</value> + </data> + <data name="preview.desc.about" xml:space="preserve"> + <value>这份目录是如何建成的：爬虫做什么、拒绝做什么，以及如何让它停下。</value> + </data> + <data name="preview.desc.notFound" xml:space="preserve"> + <value>这个地址上没有游戏。本站任何内容都不会被删除，所以曾经在这个 URL 上的游戏如今依然在——请检查拼写。</value> + </data> + <data name="preview.desc.random" xml:space="preserve"> + <value>从目录中随机挑出的一个游戏，绝不会连着两次相同。</value> + </data> + <data name="preview.desc.account" xml:space="preserve"> + <value>你已认领的条目，以及一次认领能让你改动什么。</value> + </data> + <data name="preview.desc.claim" xml:space="preserve"> + <value>在只有运营者才能放置的地方发布一个令牌，以此证明这个游戏由你运营。</value> + </data> + <data name="preview.game.archived" xml:space="preserve"> + <value>已归档——最近连通 {age}，仍在探测</value> + </data> + <data name="preview.game.archived.undated" xml:space="preserve"> + <value>已归档，仍在探测</value> + </data> + <data name="preview.game.countUnknown" xml:space="preserve"> + <value>人数未知——游戏有应答，但没有发布我们能读出的数字</value> + </data> + <data name="preview.game.count" xml:space="preserve"> + <value>{count, plural, other {#人连接}}，{age}{how}</value> + </data> + <data name="feed.plain.newlyDiscovered" xml:space="preserve"> + <value>新发现</value> + </data> + <data name="feed.plain.wentDark" xml:space="preserve"> + <value>已失联</value> + </data> + <data name="feed.plain.cameBack" xml:space="preserve"> + <value>已恢复</value> + </data> + <data name="home.plain.known" xml:space="preserve"> + <value>{count, plural, other {已知#个游戏}}</value> + </data> + <data name="home.plain.connectedNow" xml:space="preserve"> + <value>{count, plural, other {当前#人连接（实测）}}</value> + </data> + <data name="home.plain.uncounted" xml:space="preserve"> + <value>{count, plural, other {#个游戏有应答，未能计数}}</value> + </data> + <data name="home.plain.archived" xml:space="preserve"> + <value>{count, plural, other {#个已归档，仍在探测}}</value> + </data> + <data name="reference.title" xml:space="preserve"> + <value>参考</value> + </data> + <data name="reference.lede" xml:space="preserve"> + <value>代码库是什么，客户端做什么，协议又意味着什么。由人手写，与爬虫一同存放在代码仓库里——这不是维基，本页上也没有任何可编辑的东西。这里的每一个{number}都是另一回事：它取自目录，每次加载页面时都重新算出。</value> + </data> + <data name="reference.lede.number" xml:space="preserve"> + <value>数字</value> + </data> + <data name="reference.plain.lede" xml:space="preserve"> + <value>手写，单一作者，并用 git 做版本管理。这里的文字出自我们；旁边的每一个数字都由爬虫实测得出，并在每次请求时重新算出。这不是维基，本页也没有任何编辑它的途径。</value> + </data> + <data name="reference.section.orientation" xml:space="preserve"> + <value>从这里开始</value> + </data> + <data name="reference.section.codebase" xml:space="preserve"> + <value>代码库</value> + </data> + <data name="reference.section.client" xml:space="preserve"> + <value>客户端</value> + </data> + <data name="reference.section.protocol" xml:space="preserve"> + <value>协议</value> + </data> + <data name="reference.kind.orientation" xml:space="preserve"> + <value>入门</value> + </data> + <data name="reference.kind.codebase" xml:space="preserve"> + <value>代码库</value> + </data> + <data name="reference.kind.client" xml:space="preserve"> + <value>客户端</value> + </data> + <data name="reference.kind.protocol" xml:space="preserve"> + <value>协议</value> + </data> + <data name="reference.notFound.title" xml:space="preserve"> + <value>未找到</value> + </data> + <data name="reference.notFound.body" xml:space="preserve"> + <value>这里没有参考页面。本节由人手写，所以缺口是还没人做的工作，而不是被移除的内容——{index}。</value> + </data> + <data name="reference.notFound.index" xml:space="preserve"> + <value>看看现有的内容</value> + </data> + <data name="reference.codebase.heading" xml:space="preserve"> + <value>运行它的游戏</value> + </data> + <data name="reference.codebase.none" xml:space="preserve"> + <value>我们尚未识别到任何一个。这是关于这台爬虫实测到了什么的事实，而不是关于存在什么的事实——我们没有连通过的游戏，或者代码库读不出来的游戏，都不算进这里。</value> + </data> + <data name="reference.codebase.listed" xml:space="preserve"> + <value>{count, plural, other {已列出#个}}</value> + </data> + <data name="reference.codebase.archived" xml:space="preserve"> + <value>{count, plural, other {已归档#个}}</value> + </data> + <data name="reference.measuredNeverAsserted" xml:space="preserve"> + <value>实测，绝非断言</value> + </data> + <data name="reference.codebase.note" xml:space="preserve"> + <value>这是本次请求时从目录中数出的，用的正是上方链接所带的同一个筛选条件——所以这个数字和那份列表出自同一个查询，不可能对不上。</value> + </data> + <data name="reference.codebase.offered" xml:space="preserve"> + <value>在它们的握手中提供：{protocols}</value> + </data> + <data name="reference.protocol.heading" xml:space="preserve"> + <value>实测采用情况</value> + </data> + <data name="reference.protocol.none" xml:space="preserve"> + <value>尚无实测。</value> + </data> + <data name="reference.protocol.share" xml:space="preserve"> + <value>在{listed, plural, other {#个已列出的游戏}}中——{percent}</value> + </data> + <data name="reference.protocol.remainder" xml:space="preserve"> + <value>未算进这里的游戏，并不是没有这个协议的游戏。一个游戏被算进这里，条件是我们观测到它的服务器在一次握手中提供了这个选项；其余的既包括没有向我们提供它的服务器，也包括我们还没有读到过握手的服务器，而我们说不出是哪一种。</value> + </data> + <data name="reference.protocol.caption" xml:space="preserve"> + <value>在一次握手中被观测到提供 {protocol} 的游戏，按我们识别出的其运行代码库分组。</value> + </data> + <data name="reference.protocol.column.codebase" xml:space="preserve"> + <value>代码库</value> + </data> + <data name="reference.protocol.column.offered" xml:space="preserve"> + <value>已提供</value> + </data> + <data name="reference.protocol.column.identified" xml:space="preserve"> + <value>已识别</value> + </data> + <data name="reference.seeAlso" xml:space="preserve"> + <value>另见</value> + </data> + <data name="reference.capabilities.heading" xml:space="preserve"> + <value>能力</value> + </data> + <data name="reference.capabilities.established" xml:space="preserve"> + <value>{count, plural, other {在{total}项中，有#项依据项目自己的文档确定}}</value> + </data> + <data name="reference.capabilities.caveat" xml:space="preserve"> + <value>逐项读自各项目自己的文档，而非由我们实测——客户端没有握手可供我们观测。“{unknown}”表示我们查过，没能确定。它绝不表示“否”。</value> + </data> + <data name="reference.capabilities.caption" xml:space="preserve"> + <value>客户端能力，每一项都读自项目自己的文档。未知表示我们没能确定，而绝不表示这个客户端不具备该项。</value> + </data> + <data name="reference.capabilities.column.documented" xml:space="preserve"> + <value>有文档</value> + </data> + <data name="reference.capabilities.column.source" xml:space="preserve"> + <value>来源</value> + </data> + <data name="reference.capabilities.noSource" xml:space="preserve"> + <value>我们没有找到</value> + </data> + <data name="reference.capability.yes" xml:space="preserve"> + <value>有</value> + </data> + <data name="reference.capability.no" xml:space="preserve"> + <value>否</value> + </data> + <data name="reference.capability.unknown" xml:space="preserve"> + <value>未知</value> + </data> + <data name="reference.plain.runsOn" xml:space="preserve"> + <value>运行平台：{platforms}</value> + </data> + <data name="reference.plain.codebase.heading" xml:space="preserve"> + <value>我们识别为运行该代码库的游戏</value> + </data> + <data name="reference.plain.codebase.none" xml:space="preserve"> + <value>尚无。这是关于我们实测到了什么的说法，而不是关于存在什么的说法——我们没有连通过的游戏，或者代码库读不出来的游戏，都不算进这里。</value> + </data> + <data name="reference.plain.codebase.counts" xml:space="preserve"> + <value>{listed, plural, other {已列出#个}}，{archived, plural, other {已归档#个}}</value> + </data> + <data name="reference.plain.codebase.offered" xml:space="preserve"> + <value>在它们的握手中实测到：{protocols}</value> + </data> + <data name="reference.plain.codebase.nothingOffered" xml:space="preserve"> + <value>在我们读到过的它们的任何一次握手中，都没有提供过任何东西。</value> + </data> + <data name="reference.plain.protocol.share" xml:space="preserve"> + <value>在{listed, plural, other {#个已列出的游戏}}中，有 {offering} 个被观测到提供了它（{percent}）</value> + </data> + <data name="reference.plain.protocol.byCodebase" xml:space="preserve"> + <value>按代码库，在我们已识别的游戏中</value> + </data> + <data name="reference.plain.protocol.row" xml:space="preserve"> + <value>{identified} 个中有 {offering} 个提供了它</value> + </data> + <data name="reference.plain.capabilities.unknown" xml:space="preserve"> + <value>{count, plural, other {在{total}行中，有#行是未知}}：我们没有找到项目自己的文档给出任何一种说法。一张诚实的短表胜过一张靠猜的长表。</value> + </data> + <data name="account.title" xml:space="preserve"> + <value>我的游戏</value> + </data> + <data name="account.noDatabase" xml:space="preserve"> + <value>账户需要数据库支撑，而本站正运行在演示数据上。</value> + </data> + <data name="account.signInButton" xml:space="preserve"> + <value>登录</value> + </data> + <data name="account.signedInAs" xml:space="preserve"> + <value>已以 {name} 登录。</value> + </data> + <data name="account.signOut" xml:space="preserve"> + <value>退出登录</value> + </data> + <data name="account.empty.body" xml:space="preserve"> + <value>你还没有认领任何游戏。在{listing}中找到你的游戏，在它的页面上点击{claimControl}。</value> + </data> + <data name="account.empty.listing" xml:space="preserve"> + <value>列表</value> + </data> + <data name="account.empty.claimControl" xml:space="preserve"> + <value>认领此游戏</value> + </data> + <data name="account.resigned.lead" xml:space="preserve"> + <value>已放弃。</value> + </data> + <data name="account.resigned.body" xml:space="preserve"> + <value>相关记录会保留，你随时可以再发布一个新令牌，重新证明控制权。</value> + </data> + <data name="account.saved.lead" xml:space="preserve"> + <value>已保存。</value> + </data> + <data name="account.saved.thatGame" xml:space="preserve"> + <value>那个游戏</value> + </data> + <data name="account.saved.fields" xml:space="preserve"> + <value>{game} 的页面现在把它标为所有者自述。</value> + </data> + <data name="account.saved.screenHidden" xml:space="preserve"> + <value>我们已停止发布 {game} 的连接画面。页面会明确说明，而不是留一个空洞。</value> + </data> + <data name="account.saved.screenShown" xml:space="preserve"> + <value>{game} 的连接画面又回到了它的页面上。</value> + </data> + <data name="account.saved.crawlStopped" xml:space="preserve"> + <value>我们已停止向 {game} 拨号，我们掌握的它的每一个地址都停了。它的页面保留你开口之前实测到的一切。</value> + </data> + <data name="account.saved.crawlResumed" xml:space="preserve"> + <value>我们又开始向 {game} 拨号，从它在排期中的下一轮起。</value> + </data> + <data name="account.saved.unlisted" xml:space="preserve"> + <value>{game} 已不在列表、排行和每日数字中。它的页面和它曾用过的每一个 URL 仍然照常应答。</value> + </data> + <data name="account.saved.relisted" xml:space="preserve"> + <value>{game} 已回到列表中。一次得到应答的探测，就足以让它重新被实测。</value> + </data> + <data name="account.refused.lead" xml:space="preserve"> + <value>{field} 未作改动。</value> + </data> + <data name="account.refused.tooLong" xml:space="preserve"> + <value>这些是一行以内的回答；我们最多保存 {max} 个字符。</value> + </data> + <data name="account.refused.measured" xml:space="preserve"> + <value>该字段是实测的。认领让你补上 MSSP 放不下的内容；它绝不让任何人改动我们观测到的内容，我们自己也不例外。</value> + </data> + <data name="account.claimed.heading" xml:space="preserve"> + <value>已认领</value> + </data> + <data name="account.claim.verified" xml:space="preserve"> + <value>已于 {date} 验证</value> + </data> + <data name="account.claim.verifiedAndSeen" xml:space="preserve"> + <value>已于 {date} 验证，令牌最近一次见于 {seen}</value> + </data> + <data name="account.claim.mssp" xml:space="preserve"> + <value>检查你的 MSSP</value> + </data> + <data name="account.claim.coOwners" xml:space="preserve"> + <value>{count, plural, other {另有 {names} 共同拥有——各自验证过自己的令牌。}}</value> + </data> + <data name="account.coOwner.unnamed" xml:space="preserve"> + <value>另一个账户</value> + </data> + <data name="account.badge.summary" xml:space="preserve"> + <value>把你的在线人数放到自己的网站上</value> + </data> + <data name="account.badge.carries" xml:space="preserve"> + <value>这个徽标同时带上计数和我们实测它的时间，因为一个没有时间的数字，正是本站要取而代之的东西。</value> + </data> + <data name="account.badge.states" xml:space="preserve"> + <value>我们未能计数时，它显示{unknown}而不是零；游戏停止应答时，它显示{archived}。</value> + </data> + <data name="account.badge.json" xml:space="preserve"> + <value>还有{json}，如果你更愿意自己画。</value> + </data> + <data name="account.history.summary" xml:space="preserve"> + <value>历史</value> + </data> + <data name="account.event.issued" xml:space="preserve"> + <value>已签发令牌</value> + </data> + <data name="account.event.reissued" xml:space="preserve"> + <value>已再次签发令牌</value> + </data> + <data name="account.event.verified" xml:space="preserve"> + <value>已验证——我们读到了你的令牌</value> + </data> + <data name="account.event.beaconSeen" xml:space="preserve"> + <value>令牌仍在发布</value> + </data> + <data name="account.event.beaconMissing" xml:space="preserve"> + <value>本次未读到令牌</value> + </data> + <data name="account.event.revoked" xml:space="preserve"> + <value>已放弃认领</value> + </data> + <data name="account.event.expired" xml:space="preserve"> + <value>令牌未使用即过期</value> + </data> + <data name="account.event.counterClaimed" xml:space="preserve"> + <value>另一个账户证明了控制权，接管了这个游戏</value> + </data> + <data name="account.event.checkRequested" xml:space="preserve"> + <value>已请求提前查看</value> + </data> + <data name="account.resign.summary" xml:space="preserve"> + <value>放弃此认领</value> + </data> + <data name="account.resign.confirm" xml:space="preserve"> + <value>输入{word}以确认。任何内容都不会被删除，你可以再发布一个新令牌重新证明控制权；如果还有别人拥有它，这个游戏仍是已认领状态。</value> + </data> + <data name="account.resign.button" xml:space="preserve"> + <value>放弃 {game}</value> + </data> + <data name="account.pending.heading" xml:space="preserve"> + <value>等待令牌</value> + </data> + <data name="account.pending.dates" xml:space="preserve"> + <value>令牌签发于 {issued}，有效期至 {expires}</value> + </data> + <data name="account.passkeys.heading" xml:space="preserve"> + <value>通行密钥</value> + </data> + <data name="account.passkey.unnamed" xml:space="preserve"> + <value>未命名</value> + </data> + <data name="account.passkey.added" xml:space="preserve"> + <value>添加于 {date}</value> + </data> + <data name="account.passkey.addedOneDevice" xml:space="preserve"> + <value>添加于 {date} · 仅在一台设备上</value> + </data> + <data name="account.passkey.single" xml:space="preserve"> + <value>这个通行密钥只存在于一台设备上。万一丢了，你仍可以在自己的游戏上发布一个新令牌重新进来，但再加一个通行密钥更快。</value> + </data> + <data name="account.passkey.add" xml:space="preserve"> + <value>再添加一个通行密钥</value> + </data> + <data name="claim.noGame" xml:space="preserve"> + <value>没有这个游戏</value> + </data> + <data name="claim.title" xml:space="preserve"> + <value>认领 {game}</value> + </data> + <data name="claim.noDatabase" xml:space="preserve"> + <value>认领需要数据库，而本站正运行在演示数据上。</value> + </data> + <data name="claim.needAccount" xml:space="preserve"> + <value>你需要先有一个账户。只需一个通行密钥和一个名称。</value> + </data> + <data name="claim.signIn" xml:space="preserve"> + <value>登录或创建账户</value> + </data> + <data name="claim.yourGames" xml:space="preserve"> + <value>我的游戏</value> + </data> + <data name="claim.hasOwners" xml:space="preserve"> + <value>{count, plural, other {这个游戏已经有#位所有者证明了对该服务器的控制权。}}你也可以证明——两种情况下的检验方式相同——但我们需要知道你的意思是什么，因为从令牌上看不出来。</value> + </data> + <data name="claim.join.button" xml:space="preserve"> + <value>我也在运营它——把我加为所有者</value> + </data> + <data name="claim.join.note" xml:space="preserve"> + <value>每个人都保留自己的认领。这是两个人一起运营一个游戏。</value> + </data> + <data name="claim.assume.button" xml:space="preserve"> + <value>我已经接手了它——把它转给我</value> + </data> + <data name="claim.assume.note" xml:space="preserve"> + <value>{count, plural, other {你的令牌通过验证后，现有的认领会被撤销，这个游戏归你。}}他们会在自己的历史里看到原因。任何内容都不会被删除，他们也可以用你即将采用的同一种方式重新证明控制权。</value> + </data> + <data name="claim.verified.lead" xml:space="preserve"> + <value>已验证。</value> + </data> + <data name="claim.verified.viaMssp" xml:space="preserve"> + <value>我们在 {date} 从这个游戏的 MSSP 报告中读到了你的令牌。</value> + </data> + <data name="claim.verified.viaScreen" xml:space="preserve"> + <value>我们在 {date} 从连接画面上读到了你的令牌。</value> + </data> + <data name="claim.verified.leaveIt" xml:space="preserve"> + <value>把令牌留在原处。它同时也是一个身份标记，这样即使这个游戏换了主机或改了名字，我们仍认得出它。把它撤掉不会取消你的认领。</value> + </data> + <data name="claim.publish" xml:space="preserve"> + <value>把这个令牌发布在游戏会展示给匿名连接的任何地方。下一次探测就会读到它，这就证明了你能写入那台服务器。</value> + </data> + <data name="claim.transfer.lead" xml:space="preserve"> + <value>这是一次转移。</value> + </data> + <data name="claim.transfer.body" xml:space="preserve"> + <value>{count, plural, other {我们读到这个令牌时，当前所有者对这个游戏的认领会被撤销，它归你。}}</value> + </data> + <data name="claim.either.heading" xml:space="preserve"> + <value>两种方式都可以</value> + </data> + <data name="claim.mssp.heading" xml:space="preserve"> + <value>一个 MSSP 变量</value> + </data> + <data name="claim.mssp.note" xml:space="preserve"> + <value>在 {codebase} 中那是 {file} 里的一行；每个支持 MSSP 的代码库都有对应的做法。</value> + </data> + <data name="claim.mssp.aliases" xml:space="preserve"> + <value>{aliases} 同样可用。</value> + </data> + <data name="claim.screen.heading" xml:space="preserve"> + <value>连接画面上的一行</value> + </data> + <data name="claim.screen.note" xml:space="preserve"> + <value>画面中任何位置都行，周围有颜色代码也没关系。</value> + </data> + <data name="claim.then.heading" xml:space="preserve"> + <value>然后</value> + </data> + <data name="claim.then.body" xml:space="preserve"> + <value>我们按平常的爬取排期来查看。这个令牌有效期至 {date}。你随时可以再来；没有什么需要记下来。</value> + </data> + <data name="claim.check.button" xml:space="preserve"> + <value>提前查看</value> + </data> + <data name="claim.check.can" xml:space="preserve"> + <value>把你的游戏排到队列前面。我们按自己的排期拨号，所以这只是提前，而不是立刻。</value> + </data> + <data name="claim.check.rationed" xml:space="preserve"> + <value>刚刚请求过。请过几分钟再试——之所以限量，是因为它会让我们比原定更早去拨一台真实的服务器。</value> + </data> + <data name="owner.declare.heading" xml:space="preserve"> + <value>关于 {game}，只有你能告诉我们的事</value> + </data> + <data name="owner.declare.lede" xml:space="preserve"> + <value>这些是 MSSP 没有字段可放的东西。它们会以{declared}的身份出现在你游戏的页面上，带着你最后一次确认的日期，与我们实测到的内容并列——绝不取而代之。实测到的任何内容都无法从这里编辑，你不能，我们也不能。</value> + </data> + <data name="owner.field.declared" xml:space="preserve"> + <value>{age}自述。清空此框即可撤回——不论如何，它曾写过什么的记录都会保留。</value> + </data> + <data name="owner.save" xml:space="preserve"> + <value>保存你的自述</value> + </data> + <data name="owner.override.heading" xml:space="preserve"> + <value>{game} 报告了什么，以及你更希望我们显示什么</value> + </data> + <data name="owner.override.lede" xml:space="preserve"> + <value>你的 MSSP 是每个爬虫都会读到的内容，无论你在这里填了什么，我们都会把它并列显示出来——你给的答案不会遮住你游戏给的答案。</value> + </data> + <data name="owner.override.nothingMeasured" xml:space="preserve"> + <value>实测到的任何内容都无法从这里编辑：人数计数不行，能力不行，可连通的某个小时也不行。</value> + </data> + <data name="owner.override.fixItThere" xml:space="preserve"> + <value>如果下面某一行在你的 {file} 里就是错的，在那里改掉，处处都会跟着改。</value> + </data> + <data name="owner.report.value" xml:space="preserve"> + <value>你的游戏报告 {value}，{age}确认</value> + </data> + <data name="owner.report.none" xml:space="preserve"> + <value>你的游戏在这里什么也没有报告</value> + </data> + <data name="owner.rename.note" xml:space="preserve"> + <value>改名会同时改变 {game} 在列表中的名称和它页面的地址。旧地址永远继续有效——这个游戏曾用过的每一个 URL 都会重定向到它当前的地址——而清空此框，名称就交还给你的 MSSP 所说的内容。</value> + </data> + <data name="owner.screen.heading" xml:space="preserve"> + <value>你的连接画面</value> + </data> + <data name="owner.screen.suppressed" xml:space="preserve"> + <value>我们不再发布它。页面会明确说明，而不是留一个空洞；爬虫仍会继续读它——你的游戏搬了家，我们靠的就是它认出你。</value> + </data> + <data name="owner.screen.show" xml:space="preserve"> + <value>重新显示</value> + </data> + <data name="owner.screen.shown" xml:space="preserve"> + <value>我们展示它，是因为你的服务器本来就把它发给每一个匿名连接。你若不愿意，说一声我们就撤下。我们不会问为什么。</value> + </data> + <data name="owner.screen.stop" xml:space="preserve"> + <value>不要再展示我们的连接画面</value> + </data> + <data name="owner.crawl.heading" xml:space="preserve"> + <value>被爬取</value> + </data> + <data name="owner.crawl.stopped" xml:space="preserve"> + <value>我们已经停下。{game} 上没有任何地址还在被拨号，页面保留你开口之前实测到的一切——那些空白的小时不指明原因，因为{ourFact}是关于我们的事实，而不是对你游戏的实测。</value> + </data> + <data name="owner.crawl.ourFact" xml:space="preserve"> + <value>你要求我们停下</value> + </data> + <data name="owner.crawl.resume" xml:space="preserve"> + <value>重新开始爬取我们</value> + </data> + <data name="owner.crawl.standing" xml:space="preserve"> + <value>这一条来自你自己的服务器，而不是来自这里——{routes}。要重新被爬取，请停止发布它；下一个周期我们就会知道。</value> + </data> + <data name="owner.crawl.route.mssp" xml:space="preserve"> + <value>你的 MSSP 报告发布了 {variable}</value> + </data> + <data name="owner.crawl.route.dns" xml:space="preserve"> + <value>一条 {label} TXT 记录要求我们停下</value> + </data> + <data name="owner.crawl.route.recorded" xml:space="preserve"> + <value>一份我们记录在案的请求</value> + </data> + <data name="owner.crawl.partial" xml:space="preserve"> + <value>我们已在 {stopped} 上停下，仍在拨 {dialling}。这通常是在退出声明之后又新增的端口。</value> + </data> + <data name="owner.crawl.stopAll" xml:space="preserve"> + <value>在每一个地址上也都停下</value> + </data> + <data name="owner.crawl.dialling" xml:space="preserve"> + <value>我们按排期向 {game} 拨号，读取任何匿名连接都能看到的内容。你若不愿意，说一声我们就停——在一个爬取周期之内，在我们掌握的你的每一个地址上，而且我们不会问为什么。</value> + </data> + <data name="owner.crawl.selfService" xml:space="preserve"> + <value>已经实测到的内容不会被删除：你的页面保留它的历史和它的 URL，而你收回这项设置之后，一次探测就会让它重新开始。你也可以不经过我们，在自己的配置里说出来——MSSP 里的 {mssp}，或者一条 {dns} TXT 记录——无论有没有人在这里认领过这个游戏，我们都照办。</value> + </data> + <data name="owner.crawl.stop" xml:space="preserve"> + <value>不要再爬取我们</value> + </data> + <data name="owner.listing.heading" xml:space="preserve"> + <value>被列出</value> + </data> + <data name="owner.listing.unlisted" xml:space="preserve"> + <value>{game} 已不在列表中，不在排行中，也不在每日数字中。它的页面和它曾用过的每一个 URL 仍然照常应答，你开口之前实测到的一切也都还在上面。任何内容都没有被删除；它只是不再是读者靠浏览就能走到的地方。</value> + </data> + <data name="owner.listing.relist" xml:space="preserve"> + <value>把我们放回列表</value> + </data> + <data name="owner.listing.probeRelists" xml:space="preserve"> + <value>一次得到应答的探测同样能做到这件事。你的退出声明还立着的时候我们不会拨号，所以不会有这样的探测——但你收回它的那一天，这个地址会在一周之内轮到，得到应答的那次探测就会把你放回去。你不必再来问我们第二次。</value> + </data> + <data name="owner.listing.mayUnlist" xml:space="preserve"> + <value>我们已经不再向你拨号，而你的页面仍在列表中，带着在那之前我们实测到的内容。你若不愿意，说一声它就撤出来——从列表、排行和每日数字中撤出。</value> + </data> + <data name="owner.listing.reversible" xml:space="preserve"> + <value>任何内容都不会被删除，也不会有什么坏掉：页面照常应答，它曾用过的每一个 URL 仍然重定向到它，你指引过去的人都能看到它。它只是不再是读者靠浏览就能走到的地方。这可以从这里撤销，而你收回退出声明之后，任何一次得到应答的探测也能撤销它。</value> + </data> + <data name="owner.listing.unlist" xml:space="preserve"> + <value>把我们也移出列表</value> + </data> + <data name="facet.group.measure" xml:space="preserve"> + <value>实测到了什么</value> + </data> + <data name="facet.measure.note" xml:space="preserve"> + <value>隐藏这些会把它们从当前列表中移出；这并不表示该游戏里没有人。</value> + </data> + <data name="facet.group.uncounted" xml:space="preserve"> + <value>未能计数</value> + </data> + <data name="facet.group.unreachable" xml:space="preserve"> + <value>无法连通</value> + </data> + <data name="facet.excluded.uncounted" xml:space="preserve"> + <value>已从此列表中隐藏</value> + </data> + <data name="facet.excluded.unreachable" xml:space="preserve"> + <value>已从此列表中隐藏</value> + </data> + <data name="facet.plain.marks" xml:space="preserve"> + <value>左栏中，* 表示此列表已筛选为该值，- 表示此列表已把该值排除。两者都是查询中的选择，而不是关于某个游戏的事实。</value> + </data> +</root> diff --git a/src/MUI.Web/SiteComposition.cs b/src/MUI.Web/SiteComposition.cs index bc336b7..f502805 100644 --- a/src/MUI.Web/SiteComposition.cs +++ b/src/MUI.Web/SiteComposition.cs @@ -1,3 +1,5 @@ +using Microsoft.Extensions.Localization; + using MUI.Catalog; using MUI.Crawler; using MUI.Web.Accounts; @@ -6,6 +8,7 @@ using MUI.Web.Data; using MUI.Web.Fixtures; using MUI.Web.Icons; +using MUI.Web.Localization; using MUI.Web.Submissions; using MUI.Web.Theme; @@ -52,6 +55,9 @@ public static IServiceCollection AddMuiSite( services.AddRazorComponents(); + // The chrome's own words, before anything that renders them. + services.AddMuiLocalization(); + // The read API (spec §10) reads through the same IGameQueries the pages do, so the two // surfaces cannot disagree about a fact. What it adds of its own — the dataset licence, the // slug aliases and the attribution list — is configuration, because none of it is a @@ -112,6 +118,25 @@ public static IServiceCollection AddMuiSite( return services; } + /// <summary> + /// The resource set the chrome's strings are read from. + /// </summary> + /// <remarks> + /// The arrangement SharpMUSH's portal uses for its own chrome — <c>AddLocalization</c> over a + /// <c>Resources</c> folder, resolved through a marker class, with the SDK compiling one + /// satellite assembly per culture and no <c><EmbeddedResource></c> entries anywhere. What + /// differs is the values: theirs are composite-format strings and these are ICU patterns, + /// because <c>{0}</c> substitutes and cannot agree. See <see cref="Localization.Messages"/>. + /// </remarks> + public static IServiceCollection AddMuiLocalization(this IServiceCollection services) + { + ArgumentNullException.ThrowIfNull(services); + + services.AddLocalization(options => options.ResourcesPath = "Resources"); + + return services; + } + /// <summary> /// The middleware and the routes, in the order they have to be in. /// </summary> @@ -129,6 +154,18 @@ public static WebApplication UseMuiSite(this WebApplication app, string? connect // limit. app.UseSubmitterAddress(); + // Before anything routes, because the locale is a path segment and every @page directive is + // written without it: the middleware moves the prefix into PathBase so one route table + // serves every language. It is also before the not-found page, so a mistyped URL inside a + // locale is answered in that locale rather than in English. + app.UseMuiLocale(); + + // Explicit, and that is load-bearing rather than tidy: with no UseRouting call of its own an + // app gets one inserted at the very top of the pipeline, which resolved the endpoint before + // the middleware above had rewritten the path — so every localized URL 404'd while the + // unprefixed one worked. Naming it here is what puts routing after the rewrite. + app.UseRouting(); + // A reader who mistyped a URL, and a crawler indexing one, both got a 404 with an empty body: // the <NotFound> fragment inside <Router> is never rendered under static server rendering, so // the site's own "no game here" paragraph was dead copy. This answers those with the page — @@ -168,6 +205,10 @@ public static WebApplication UseMuiSite(this WebApplication app, string? connect // deployment has the same eyes as a reader of the real one. app.MapMuiTheme(); + // Beside the theme endpoint and for the same reason: it writes a cookie and redirects, and + // a reader of the demo deployment reads the same language as a reader of the real one. + app.MapMuiLocale(); + // §5.7, and before the route that would answer with "not found": a slug this game used to // have is a URL somebody is still holding, and it redirects to the page it has now — // permanently, and for an archived game exactly as for a live one. diff --git a/src/MUI.Web/Submissions/SubmissionEndpoint.cs b/src/MUI.Web/Submissions/SubmissionEndpoint.cs index e503b7d..53d60fc 100644 --- a/src/MUI.Web/Submissions/SubmissionEndpoint.cs +++ b/src/MUI.Web/Submissions/SubmissionEndpoint.cs @@ -3,6 +3,7 @@ using MUI.Catalog.Persistence; using MUI.Discovery; using MUI.Web.Components; +using MUI.Web.Localization; namespace MUI.Web.Submissions; @@ -56,7 +57,9 @@ await sources.OfAsync(SubmitterAddress.Of(context), context.RequestAborted), ? game.Slug : null; - return Results.Redirect(SubmitLinks.For(receipt.Outcome, receipt.Address, slug)); + return Results.Redirect(LocaleRouting.Link( + context.LocaleOf().Tag, + SubmitLinks.For(receipt.Outcome, receipt.Address, slug))); }); } } diff --git a/src/MUI.Web/Theme/ThemeEndpoint.cs b/src/MUI.Web/Theme/ThemeEndpoint.cs index 0904882..7b0b61b 100644 --- a/src/MUI.Web/Theme/ThemeEndpoint.cs +++ b/src/MUI.Web/Theme/ThemeEndpoint.cs @@ -1,4 +1,5 @@ using Microsoft.AspNetCore.Mvc; +using MUI.Web.Localization; namespace MUI.Web.Theme; @@ -42,7 +43,13 @@ public static IEndpointRouteBuilder MapMuiTheme(this IEndpointRouteBuilder endpo // 303 rather than 302: the reader posted a form and what they should now be holding is // the page they came from, fetched with GET. A 302 gets there by convention on every // browser written since 1996, and this says what was meant. - context.Response.Headers.Location = ReaderTheme.Back(returnTo); + // + // And back into the language they were reading, which the return field cannot carry: it + // holds Request.Path, from which the middleware has already taken the prefix. A reader + // who followed a shared /de/… link has no cookie either, so this redirect was the whole + // of what stood between them and an English page — for choosing a light background. + context.Response.Headers.Location = + LocaleRouting.Link(context.LocaleOf().Tag, ReaderTheme.Back(returnTo)); return Results.StatusCode(StatusCodes.Status303SeeOther); }).DisableAntiforgery(); diff --git a/src/MUI.Web/wwwroot/app.css b/src/MUI.Web/wwwroot/app.css index 09d448e..0e0ae29 100644 --- a/src/MUI.Web/wwwroot/app.css +++ b/src/MUI.Web/wwwroot/app.css @@ -12,23 +12,74 @@ */ :root { - --cpad: 14px; /* the density control writes this, and only this */ - --row-pad: 9px; + /* + Spacing, radii and motion, in the relationships the design handoff's own token files carry. + The values are theirs; the colours below are ours — the handoff's palette is a different + product's and its README says so. What transfers is the scale: content padding at 20px rather + than the 14 this site had, one radius for controls and a larger one for the surfaces that hold + them, and a single easing curve at an eighth of a second. + */ + --cpad: 24px; /* the density control writes this, and only this */ + --row-pad: 13px; /* a listing row: 13px 20px, over a 44px floor */ + + /* + The one horizontal inset the whole site shares — the bar, every content band, every listing + row. Fluid rather than fixed because the page is full-bleed now: at the width the handoff was + drawn to it lands on the 24px the drawing uses, and it grows a little rather than leaving a + wide monitor's chrome pinned to the very edge of the glass. + */ + --gutter: clamp(14px, 1.6vw, 28px); + + --radius: 9px; /* controls, chips, rows, nav items */ + --radius-lg: 14px; /* cards and panels — the things controls sit in */ + --radius-pill: 99px; /* pills and badges */ + + --ease: cubic-bezier(0.4, 0, 0.2, 1); + --dur: 0.14s; --bg: #0f1113; --surface: #16191c; --raised: #1d2125; --recessed: #0b0d0f; + + /* + Two hairline steps, as the handoff's tokens carry them: --line is a control's own edge and + --line-soft is the rule between two panels. One value did both, so a filter column's edge and + a button's border were the same weight — and the panel rules, which are ten times longer, + read as the loudest thing on the page. + */ --line: #262b30; + --line-soft: #1c2024; --text: #e8eaec; /* values and names */ --dim: #9aa2a9; /* prose and secondary */ --faint: #6b747c; /* provenance, ages, meta */ --accent: #35d29a; /* measured */ + + /* + The accent as *text on an accent tint* — the selected facet row, which paints a 12% wash of + the accent behind accent-coloured words. Every ratio beside a token here is measured against + the page, and a tinted row is not the page: in light, --accent is 5.0:1 on the background it + was tuned for and 3.9:1 on this one, which is the row a reader has just clicked. Dark clears + it either way, so there the two are the same colour. + */ + --accent-ink: var(--accent); --amber: #d8a13a; /* declared / ageing */ --derived: #a394f0; /* our own classification, and nobody else's */ + /* + Refusal, and only refusal. Not a provenance colour — nothing on this site is red because of + what we did or did not measure. It marks one thing: a facet value the reader has excluded, + where the handoff draws a danger tint, a danger ring and a struck-through label. A state the + reader put the control into, never a state of the data. + */ + --danger: #f4574c; + + /* The card's own elevation, and the one glow the accent is allowed. */ + --shadow: 0 1px 0 rgb(255 255 255 / 3%) inset, 0 4px 16px rgb(0 0 0 / 40%); + --glow: 0 0 8px color-mix(in srgb, var(--accent) 55%, transparent); + --sans: "Hanken Grotesk", ui-sans-serif, system-ui, -apple-system, sans-serif; --mono: "Cascadia Mono", ui-monospace, "SFMono-Regular", Consolas, monospace; --kick: "JetBrains Mono", var(--mono); @@ -60,38 +111,69 @@ data-theme wins over the system in both directions, so a toggle can be added without moving any of this. */ +/* + ── the light theme, and why none of it is white ─────────────────────────── + The page surface was #ffffff, and once the card went full-bleed that stopped being a panel and + became the whole window. A large field of pure white glares: the halation it produces around dark + text is worst for readers with astigmatism and is one of the things dyslexic readers most often + ask to be turned down, and 21:1 body contrast is past the point where more helps and into the + point where it tires. Nobody's guideline forbids it — WCAG has a floor and no ceiling — which is + why every design system that has thought about it lands in the same place by convention instead: + GitHub Primer's canvas.subtle #f6f8fa, IBM Carbon's #f4f4f4 background under white layers, + Material 3's tinted surfaces, Solarized Light's cream. All of them are off-white. + + So the ramp is a soft cool grey and the near-white is reserved for the things that are supposed to + sit *above* it — tiles, the hover plane. That also restores a distinction the light theme had lost + entirely: --surface and --raised were both #ffffff, so a card lifted off the page by a step in the + dark theme was lifted by nothing at all here, and its border was doing all the work. + + Text is a near-black with the ramp's own hue rather than #000, at ~15:1 — comfortably past the + 4.5:1 floor and short of the glare. Every step below was measured against the new surface, and + --faint moved because it did not clear 4.5:1 against the old one: it carries ages and provenance + at 12px, which is exactly the small low-contrast text the handoff asked to have checked. +*/ @media (prefers-color-scheme: light) { :root { - --bg: #f7f8f9; - --surface: #ffffff; - --raised: #ffffff; - --recessed: #eef0f2; - --line: #dfe3e6; - - --text: #14181b; - --dim: #4d565d; - --faint: #79838a; - - --accent: #04795b; /* same hue, dropped in value to clear 4.5:1 on white */ - --amber: #8a5d00; - --derived: #5b46c4; + --bg: #eef1f2; /* behind the page; barely visible now the shell is full-bleed */ + --surface: #f4f6f7; /* the page itself */ + --raised: #fbfcfc; /* tiles, hover planes — above the page, never below it */ + --recessed: #e9edee; /* the bar, the filter column */ + --line: #d3d9dc; + --line-soft: #e2e7e9; + + --text: #1a1f23; /* 15.3:1 — past the floor, short of the glare */ + --dim: #4d585f; /* 6.7:1 */ + --faint: #646f76; /* 4.8:1 — was 3.5:1 and carried 12px ages */ + + --accent: #04795b; /* same hue, dropped in value: 5.0:1 */ + --accent-ink: #036349; /* 5.3:1 on the accent's own 12% tint, where --accent is 3.9:1 */ + --amber: #7d5400; /* 6.2:1 */ + --derived: #5240b8; /* 7.0:1 */ + --danger: #a8261e; /* 6.5:1 */ + + --shadow: 0 1px 2px rgb(16 24 32 / 4%), 0 4px 16px rgb(16 24 32 / 5%); } } :root[data-theme="light"] { - --bg: #f7f8f9; - --surface: #ffffff; - --raised: #ffffff; - --recessed: #eef0f2; - --line: #dfe3e6; + --bg: #eef1f2; + --surface: #f4f6f7; + --raised: #fbfcfc; + --recessed: #e9edee; + --line: #d3d9dc; + --line-soft: #e2e7e9; - --text: #14181b; - --dim: #4d565d; - --faint: #79838a; + --text: #1a1f23; + --dim: #4d585f; + --faint: #646f76; --accent: #04795b; - --amber: #8a5d00; - --derived: #5b46c4; + --accent-ink: #036349; + --amber: #7d5400; + --derived: #5240b8; + --danger: #a8261e; + + --shadow: 0 1px 2px rgb(16 24 32 / 4%), 0 4px 16px rgb(16 24 32 / 5%); } :root[data-theme="dark"] { @@ -100,19 +182,29 @@ --raised: #1d2125; --recessed: #0b0d0f; --line: #262b30; + --line-soft: #1c2024; --text: #e8eaec; --dim: #9aa2a9; --faint: #6b747c; --accent: #35d29a; + + /* Reset with the rest of them. The light media block sets this unconditionally, so a reader who + pinned dark on a light-preferring system kept the light ink — a dark green on a dark tint, + 2.7:1, which is worse than the value it was added to fix. Every token this block redeclares + is redeclared for that reason; this one was missed. */ + --accent-ink: var(--accent); --amber: #d8a13a; --derived: #a394f0; + --danger: #f4574c; + + --shadow: 0 1px 0 rgb(255 255 255 / 3%) inset, 0 4px 16px rgb(0 0 0 / 40%); } :root[data-density="compact"] { - --cpad: 9px; - --row-pad: 5px; + --cpad: 13px; + --row-pad: 8px; } * { box-sizing: border-box; } @@ -125,16 +217,74 @@ body { text-wrap: pretty; } -main { max-width: 1080px; margin: 0 auto; padding: calc(var(--cpad) * 2) var(--cpad); } +/* + The shell: everything the handoff draws sits in one card — the bar along its top edge, the content + under it — rather than loose on the page. It is the difference between a document and an + instrument, and this site is the second: a directory whose bar, filters and rows are one panel. +*/ +/* + ── the shell ────────────────────────────────────────────────────────────── + Full-bleed. The handoff draws the site as one card floating on a ground, and that is a drawing + convention rather than a product decision — a directory is an instrument you fill the window with, + not a document you frame. So the card's border, radius, shadow and side margins are gone and the + page IS the surface; what the card was actually carrying — one bar along the top, bands separated + by hairlines, every block sharing one left edge — is unchanged and is the part that mattered. + + The radial that used to sit on the body moves here, because the body is no longer visible behind + anything. It is the one thing keeping a full-height dark page from reading as flat black. +*/ +.shell { + min-height: 100vh; + margin: 0; + background: var(--surface) radial-gradient(80% 90% at 78% -20%, + color-mix(in srgb, var(--raised) 45%, var(--surface)) 0%, var(--surface) 100%) fixed; + + /* + Clipped sideways and open downwards. `hidden` on both axes is what a card wants and it + swallowed the nav's own menu: at the width where both groups collapse into a disclosure, the + panel is positioned under the bar and every pixel of it was being clipped away, so the one + control that carries the whole catalogue on a narrow window opened onto nothing. `clip` pairs + with `visible` — `hidden` would coerce it to `auto` and hand the page a scrollbar. + */ + overflow-x: clip; + overflow-y: visible; +} + +/* + The content column's own padding, at the handoff's 30px/24px/26px. A page whose blocks bleed to + the card's edges — the listing's two columns, the game page's hairline-separated bands — cancels + it and pads each block itself, because a full-bleed rule cannot be drawn inside a padded box. +*/ +main { padding: 30px var(--gutter) 40px; } +main:has(> .card-page) { padding: 0; } + +/* + One vertical rhythm for the whole content column, as a gap rather than as margins on each block. + Margins collapse, disagree with each other and leave a dead band wherever a block renders nothing + — which is what the absent crawler strip did to the front page. +*/ +main > .card-page, +.hero { display: flex; flex-direction: column; gap: 22px; } h1 { font-size: 26px; font-weight: 600; letter-spacing: -0.01em; margin: 0 0 6px; } -h2 { font-size: 19px; font-weight: 600; margin: calc(var(--cpad) * 2) 0 var(--cpad); } +h2 { font-size: 20px; font-weight: 600; margin: calc(var(--cpad) * 1.4) 0 10px; } a { color: inherit; } .dim { color: var(--dim); } .faint { color: var(--faint); } .mono { font-family: var(--mono); font-variant-ligatures: none; } +/* Every count and every age, so the columns scan. */ +.mono, .tabular { font-variant-numeric: tabular-nums; } + +/* + ── the kicker, and why its typography is locale-gated ────────────────────── + Uppercase plus 0.16em tracking is this site's most recognisable label, and it is Latin-specific + twice over (i18n S1). Letter-spacing severs the cursive joins in Arabic, so connected words come + apart into unrelated shapes; Devanagari and Thai lose conjuncts and mark stacks the same way. + text-transform: uppercase is a no-op in CJK, turns ß into SS, and gets Turkish dotted/dotless i + wrong. The class is the semantics; :lang() decides the typography. +*/ .kicker { font: 10px/1 var(--kick); letter-spacing: 0.16em; @@ -142,18 +292,100 @@ a { color: inherit; } color: var(--faint); } -/* ── site chrome ───────────────────────────────────────────────────────── */ +/* Cursive and complex scripts: prominence from weight and size, never from tracking. */ +:is(.kicker, .nav-label, .bar-label, .facet-name, .evidence, .kick):is( + :lang(ar), :lang(he), :lang(fa), :lang(ur), :lang(th), :lang(hi), :lang(mr), :lang(ne)) { + text-transform: none; + letter-spacing: normal; + font-weight: 600; + font-size: 11.5px; + line-height: 1.5; +} + +/* CJK: uppercase does nothing, tracking looks like a fault, and 10px is unreadable. */ +:is(.kicker, .nav-label, .bar-label, .facet-name, .evidence, .kick):is( + :lang(zh), :lang(ja), :lang(ko)) { + text-transform: none; + letter-spacing: 0.02em; + font-size: 12px; +} + +/* ── site chrome ─────────────────────────────────────────────────────────── + A fixed 60px bar that never wraps. It stretches rather than centres, so a nav item is a + full-height box and its current-page marker can land on the bar's own bottom edge. */ header.site { + /* One row is 60px and stays 60px; a bar that has wrapped is as tall as what it holds. */ + min-height: 60px; + row-gap: 4px; + flex: none; border-bottom: 1px solid var(--line); - padding: var(--cpad); + background: var(--recessed); + padding: 0 var(--gutter); display: flex; - gap: var(--cpad); - align-items: baseline; + align-items: stretch; + justify-content: space-between; + gap: 20px; + + /* + A bar spanning the window is chrome, so it stays where chrome belongs. The game page runs to + three and a half thousand pixels and the catalogue is at the top of it; scrolling back up to + reach the nav is a cost the card layout hid by being short. + */ + position: sticky; + top: 0; + z-index: 30; + + /* + Sideways only. `overflow: hidden` is what a fixed-height bar wants — nothing may spill out of + it — but it clipped the nav's own dropdown to nothing at the width where that dropdown IS the + navigation. `clip` on one axis leaves `visible` legal on the other; `hidden` would coerce it. + */ + overflow-x: clip; + overflow-y: visible; } -header.site .mark { font-family: var(--mono); font-weight: 600; text-decoration: none; } -header.site .mark .star { color: var(--accent); } +/* + The bar is one line of chrome and the demo banner above it is a statement about the whole site, so + the banner scrolls away and the bar does not. Where there is no banner the bar is simply at the + top of the document. +*/ +.demo-banner { position: relative; z-index: 31; } + +/* + The bar measures itself. + + Every threshold in the ladder below used to be a pixel count, and every one of them was really a + measurement of *English*: the seven catalogue links are 430px in English and 517px in Japanese, so + 860 was the width at which the English bar stopped fitting and German, Dutch and Japanese spent the + whole 861–1100 band with links running out of their box. 1024 is one of the four widths this design + is reviewed at, and all three failed at it. + + `max-content` is the browser's own answer to "how wide is this text, in this language, in this + font" — so the nav asks for exactly what its links need and `flex-wrap` gives it its own row the + moment the bar cannot. No number to keep in step with a translation, nothing to re-tune when a + string changes, and a language nobody has measured yet is right on arrival. + + What the reader gets in that band is a two-row bar rather than a menu, which is the trade: every + destination stays visible and in the same order, and the row that moves is the one that was being + clipped. Below the collapse width it is still one disclosure, because a menu is the right shape on + a phone whatever the language. +*/ +header.site { flex-wrap: wrap; } +header.site .mark { flex: 0 0 auto; } +header.site .site-nav { flex: 1 1 auto; min-width: max-content; } +header.site nav.account { flex: 0 0 auto; } +header.site form.theme { flex: 0 0 auto; } + +header.site .mark { + display: flex; + align-items: center; + font: 700 17px/1 var(--sans); + letter-spacing: -0.01em; + text-decoration: none; + white-space: nowrap; +} +header.site .mark .star { color: var(--accent); text-shadow: var(--glow); } /* ── provenance chip ─────────────────────────────────────────────────────── Not a box. At rest it is the value, one state glyph and a relative age — no border, no fill, @@ -178,14 +410,43 @@ header.site .mark .star { color: var(--accent); } /* ── capability matrix ─────────────────────────────────────────────────── */ -table.matrix { border-collapse: collapse; width: 100%; } +/* + A framed table, as the handoff draws it: a header row on the recessed surface, hairlines between + the rows, and the caption as a foot band inside the same frame rather than a loose line under it. + A caption that sits outside the border reads as a note about the section; inside it, it reads as + what it is — the table's own summary, with the table still in view. +*/ +table.matrix { + border-collapse: collapse; + width: 100%; + border: 1px solid var(--line-soft); + border-radius: var(--radius); + overflow: hidden; +} table.matrix th, table.matrix td { text-align: left; - padding: var(--row-pad) var(--cpad); - border-bottom: 1px solid var(--line); + /* Its own padding rather than the row token: this table is six rows of two-word states, and a + listing row's 13px by 20px turns each of them into a paragraph. */ + padding: 11px 16px; + border-top: 1px solid var(--line-soft); + white-space: nowrap; +} +table.matrix thead th { + font: 10px/1 var(--kick); letter-spacing: 0.16em; text-transform: uppercase; color: var(--faint); + background: var(--recessed); + border-top: 0; + padding: 10px 16px; } -table.matrix thead th { font: 10px/1 var(--kick); letter-spacing: 0.16em; text-transform: uppercase; color: var(--faint); } +table.matrix tbody tr:first-child th, table.matrix tbody tr:first-child td { border-top: 1px solid var(--line-soft); } table.matrix tr.disagrees { background: color-mix(in srgb, var(--amber) 9%, transparent); } +/* At the foot and inside the frame, where a caption belongs on a table whose heading is directly + above it — and stated once, here, rather than in the heading as well. */ +table.matrix caption.count { + caption-side: bottom; text-align: left; font-size: 12.5px; + padding: 10px 16px; + background: var(--recessed); + border-top: 1px solid var(--line-soft); +} .state-present { color: var(--accent); } .state-absent { color: var(--dim); } .state-unknown { color: var(--faint); } @@ -210,15 +471,30 @@ td.gap { background: transparent; outline: 1px dashed var(--faint); out Foreign colour is quoted, not hosted. Its own fixed black ground and its own locked 16-colour table in both themes, so arbitrary SGR is expected inside and nothing bleeds either way. */ -figure.ansi { margin: 0; border: 1px solid var(--line); background: #000; } +/* + One panel holding the art, the words and the caption — rather than a black box with a kicker strip + welded under it and the words in a separate disclosure below. The frame is the site's own recessed + surface at the controls' radius; the art keeps its fixed black ground inside, because the SGR it + carries is somebody else's and has to sit on the terminal it was drawn for. +*/ +figure.ansi { + margin: 0; + border: 1px solid var(--line-soft); + border-radius: var(--radius); + background: var(--recessed); + padding: 16px 18px; + display: flex; + flex-direction: column; + gap: 12px; + overflow: hidden; +} figure.ansi figcaption { - font: 10px/1 var(--kick); - letter-spacing: 0.16em; - text-transform: uppercase; + font-family: var(--mono); + font-size: 11.5px; color: var(--faint); - padding: 8px var(--cpad); - border-top: 1px solid var(--line); - background: var(--surface); + padding: 0; + background: none; + border: 0; } /* @@ -258,22 +534,259 @@ figure.ansi figcaption { .skip:focus { left: 8px; top: 8px; } -:where(a, button, input, summary):focus-visible { +:where(a, button, input, select, summary):focus-visible { outline: 2px solid var(--accent); outline-offset: 2px; } /* ── chrome ────────────────────────────────────────────────────────────── */ -/* Wrapping, because seven catalogue links do not fit a 390px phone on one line and the alternative - is a page that scrolls sideways — which the whole layout is otherwise careful never to do. */ -header.site nav { display: flex; gap: var(--cpad); flex-wrap: wrap; } -header.site nav a { color: var(--dim); text-decoration: none; } +/* + Every item is a full-height flex box, and nothing wraps. The bar's job is to be one line of + chrome; when it stops fitting it degrades through the steps below rather than reflowing. +*/ +header.site nav { display: flex; align-items: stretch; min-width: 0; } +header.site nav a, header.site nav span.nav-item { + display: flex; align-items: center; white-space: nowrap; + color: var(--dim); text-decoration: none; font-size: 13.5px; +} header.site nav a:hover { color: var(--text); text-decoration: underline; text-underline-offset: 3px; } -/* The one link in this bar that leads somewhere only you can go, so it is not dimmed like the - catalogues beside it. */ +/* ── the two groups ──────────────────────────────────────────────────────── + Places to browse, and things to read about the hobby. The label is the kicker face the rest of + the site uses for column heads, and it is aria-hidden: the group carries the same word as its + accessible name, and a screen reader announcing "browse" as a text node and again as a label is + the duplication this pass exists to remove. */ + +header.site .site-nav { display: flex; align-items: stretch; justify-content: center; gap: 14px; } +header.site .nav-group { display: flex; align-items: stretch; gap: 11px; min-width: 0; } +header.site .nav-label { + display: flex; align-items: center; white-space: nowrap; + font: 9px/1 var(--kick); letter-spacing: 0.16em; text-transform: uppercase; color: var(--faint); +} + +/* A hairline between the groups rather than a wider gap: the bar is short and the gap that would + read as a separation is one that reads as a wrap. 18px, centred in the 60px bar. */ +header.site .nav-rule { flex: 0 0 auto; width: 1px; margin: 21px 0; background: var(--line); } + +/* + The page you are on, marked *inside* the item's own box. + + The marker is an inset shadow and NOTHING else — no border, no padding change. Either of those + adds a pixel to the current item's box, and because the bar is a flex line that grows to its + tallest child, the whole row moved down one pixel the moment a marked item was on it. A bar that + shifts when you arrive is a bar you cannot aim at, and it is the defect the handoff names by hand. +*/ +header.site nav a.on { color: var(--text); box-shadow: inset 0 -2px 0 0 var(--accent); } +header.site nav a.on:hover { text-decoration: none; } + +/* The far end of the bar: what to do, rather than where to go. Submit is an action and about is + site meta, so neither is a catalogue and neither sits in a group above. */ +header.site nav.account { display: flex; align-items: center; gap: 12px; } header.site nav.account a { color: var(--text); } +header.site nav.account a.action { + border: 1px solid var(--line); border-radius: var(--radius); padding: 6px 12px; + font-size: 13px; white-space: nowrap; +} +header.site nav.account a.action:hover { border-color: var(--dim); text-decoration: none; } + +/* The accent button: ring and tint together, as the handoff draws it — the fill is what tells it + apart from the bordered one beside it at a glance. */ +header.site nav.account a.action.primary { + border-color: color-mix(in srgb, var(--accent) 40%, transparent); + background: color-mix(in srgb, var(--accent) 12%, transparent); + color: var(--accent); +} + +/* + ── the nav's degradation order (i18n S2) ────────────────────────────────── + Width triggers the steps, never language: a German reader on a wide monitor never leaves step 0 + and an English reader in a narrow window reaches step 2. Each step loses DECORATION, never a + destination — which is the whole point, and why the collapse at the end is a disclosure holding + every link rather than a shorter bar. + + step 1 group labels drop; the divider keeps the grouping + step 2 submit loses its border, becoming a plain link + step 3 both groups collapse into one `menu` disclosure + + Budget every nav string at 1.4x the English width when reviewing a locale. +*/ + +/* + Step 0 to 2 the disclosure is not a disclosure: the summary is hidden and its content forced + visible, so the two groups sit in the bar exactly as if the <details> were not there. Guarded on + ::details-content, because a browser without it cannot be made to show a closed <details> — there + the summary stays and the nav is a menu button at every width, which is a worse bar and a working + one. +*/ +header.site .nav-menu { display: flex; position: relative; align-items: stretch; min-width: 0; } +header.site .nav-menu > summary { + display: flex; align-items: center; gap: 6px; cursor: pointer; + color: var(--dim); font-size: 13.5px; white-space: nowrap; list-style: none; +} +header.site .nav-menu > summary::-webkit-details-marker { display: none; } +header.site .nav-menu > summary:hover { color: var(--text); } +header.site .nav-menu[open] > summary { color: var(--text); } + +/* The panel, as a dropdown. Above the collapse width the same element is the bar's own centre row. */ +header.site .nav-menu .menu-panel { + position: absolute; top: 100%; left: 0; z-index: 20; min-width: 200px; + display: flex; flex-direction: column; gap: 2px; + padding: 8px; margin-top: 1px; + background: var(--raised); border: 1px solid var(--line); + border-radius: var(--radius); box-shadow: var(--shadow); +} +header.site .nav-menu .menu-panel > .nav-group { flex-direction: column; align-items: stretch; gap: 2px; } +header.site .nav-menu .menu-panel a { padding: 6px 10px; border-radius: 6px; } +header.site .nav-menu .menu-panel a:hover { background: var(--surface); text-decoration: none; } + +/* + The current page, marked for a list rather than for a bar — and only while the panel IS a list. + The inset shadow that lands on the bar's bottom edge becomes a full-width rule under one row of a + dropdown, which reads as a text field rather than as "you are here", so in the panel the marker + moves to the leading edge. Scoped to the collapsed width: unscoped it drew a vertical accent bar + and a tinted box down the side of the current item in the open bar. +*/ +@media (max-width: 880px) { + header.site .nav-menu .menu-panel a.on { + box-shadow: inset 2px 0 0 0 var(--accent); + background: color-mix(in srgb, var(--accent) 10%, transparent); + color: var(--accent); + } +} +header.site .nav-menu .menu-panel .nav-label { padding: 6px 8px 2px; } +header.site .nav-menu .menu-panel .nav-rule { display: none; } +header.site .menu-tail { display: flex; flex-direction: column; gap: 2px; } + +@supports selector(::details-content) { + @media (min-width: 881px) { + header.site .nav-menu > summary { display: none; } + + /* + The wrapper has to carry the bar's full height, not its content's. A nav item is a + full-height box so that the current-page marker — an inset shadow, drawn inside the box — + lands on the bar's own bottom edge; with the wrapper sized to its text the marker floated + eighteen pixels above it, which is the underline hanging in mid-bar rather than sitting on + it. `display: flex` is what makes the panel below a stretched flex item. + */ + header.site .nav-menu::details-content { + content-visibility: visible; + block-size: 100%; + display: flex; + align-items: stretch; + } + + /* The panel is the bar's middle row: a static flex line, not a dropdown. */ + header.site .nav-menu .menu-panel { + position: static; min-width: 0; height: 100%; + display: flex; flex-direction: row; align-items: stretch; gap: 14px; + padding: 0; margin: 0; background: none; border: 0; border-radius: 0; box-shadow: none; + } + header.site .nav-menu .menu-panel > .nav-group { flex-direction: row; align-items: stretch; gap: 11px; } + header.site .nav-menu .menu-panel a { padding: 0; border-radius: 0; } + header.site .nav-menu .menu-panel a:hover { background: none; } + header.site .nav-menu .menu-panel .nav-rule { display: block; } + header.site .nav-menu .menu-panel .nav-label { padding: 0; } + + /* Step 4's overflow home, which the bar itself still carries at these widths. */ + header.site .menu-tail { display: none; } + } + + /* + Step 1 — the labels go and the divider stays. The grouping is the fact; the words naming the + groups are a gloss on it, and the rule between them carries the same fact in one pixel. Losing + both at once would leave seven links in a row in no order anybody could name, which is the + state this bar was rebuilt out of. + */ + @media (min-width: 881px) and (max-width: 1180px) { + header.site .nav-label { display: none; } + header.site .nav-menu .menu-panel { gap: 14px; } + header.site .nav-menu .menu-panel > .nav-group { gap: 11px; } + } +} + +@media (max-width: 1000px) { /* step 2 — submit keeps the word, loses the box */ + header.site nav.account a.action:not(.primary) { + border-color: transparent; padding: 6px 0; color: var(--dim); + } + header.site nav.account a.action:not(.primary):hover { color: var(--text); } +} + +@media (max-width: 880px) { /* step 3 — one disclosure, every destination kept */ + header.site .site-nav { justify-content: flex-start; } + + /* + And it stops being the bar's shock absorber. Above this width the nav holds seven links and + `flex: 1 1 auto; min-width: 0` is what lets it give room back to the two ends; below it the + nav is one word and a chevron, and the same rule let flexbox squeeze that word to 33px — the + German bar rendered "Men" with the chevron cut off, on the only control that reaches the other + six pages. The ends are sized by their content and the middle was the only thing that could + yield, so a longer word at either end came out of the one item that must never shrink. + */ + header.site .site-nav { flex: 0 0 auto; } +} + +/* + Step 4 — the right cluster runs out too. `submit` joins the menu, which is where the markup + already carries it; `about` and `sign in` stay, the first because it is two words and the second + because it is the one item at that end that changes what the site will let a reader do. Still no + destination lost. +*/ +@media (max-width: 640px) { + header.site { padding: 0 14px; gap: 12px; } + header.site nav.account a.action:not(.primary) { display: none; } + header.site form.theme { gap: 6px; } +} + +/* + Step 5 — below a small phone the type gives way before anything else does. Nothing is dropped and + nothing moves; the two clusters at the ends are simply set a step smaller, which is the last + decoration the bar has left to spend. +*/ +@media (max-width: 460px) { + header.site { padding: 0 8px; gap: 6px; } + header.site .mark { font-size: 15px; } + header.site form.theme { gap: 4px; } + header.site form.theme button { font-size: 12px; } + header.site nav.account { gap: 6px; } + header.site nav.account a { font-size: 12.5px; } + header.site nav.account a.action { padding: 5px 8px; } +} + +/* + Step 6 — and the bar is measured in a language, not in English. + + Every step above was tuned against a bar reading "menu · about · submit · sign in · auto light + dark", which is the shortest this chrome is ever going to be. The same bar in German is "Menü · + über uns · anmelden · auto hell dunkel" and wanted seventeen more pixels than a 430px phone has; + Dutch was twelve pixels from the same wall. So the last step is a real one rather than a hedge, + and it spends the only thing left that is not a destination: the theme control's three words + become the row's tightest type, and the wordmark gives up a point with them. Nothing moves and + nothing is dropped — the German bar and the English bar hold the same seven pages either side of + it, which is the property the whole ladder exists to keep. +*/ +/* + Step 7 — and on the narrowest phone the bar stops being one line, for whichever language needs it. + + At 360px the German bar wants 412px: "mu*index · Menü ▾ · über uns · anmelden · auto hell dunkel". + Everything above this step spends decoration and the ladder has none left — and the item that fell + off the end was the theme control, clipped past `.shell`'s `overflow-x: clip` and so not merely + cramped but gone. A reader on a 360px phone in German could not change the theme at all. + + No width triggers this and no language is named in it: the bar already wraps on content, so the + theme control takes a second row exactly where it stops fitting. German and Dutch reach it at 360 + and English and Chinese do not, which is the ladder working rather than a rule about German. The + one thing set here is what happens *after* a wrap — the control keeps the trailing edge it has on + one line, so the bar does not appear to change its mind about which end it belongs to. +*/ +header.site form.theme { margin-inline-start: auto; } + +@media (max-width: 480px) { + header.site .mark { font-size: 14px; letter-spacing: 0; } + header.site form.theme { gap: 4px; } + header.site form.theme button { font-size: 11.5px; } + header.site nav.account a { font-size: 12px; } +} /* ── the reader's theme ──────────────────────────────────────────────────── Buttons drawn as the links beside them, because they belong to that row and a row of three real @@ -281,7 +794,10 @@ header.site nav.account a { color: var(--text); } brighter: a state carried by colour alone is a state a greyscale display does not carry, which is the same rule the heatmap's hatch exists for. */ -form.theme { display: flex; align-items: baseline; gap: 8px; margin: 0; } +/* Centred in the bar rather than baseline-aligned to it: the bar stretches its children to 60px, + and a baseline inside a stretched box lands wherever the box's first line happens to be — which + put this cluster sixteen pixels above the buttons beside it. */ +form.theme { display: flex; align-items: center; gap: 8px; margin: 0; } form.theme .kick { font: 10px/1 var(--kick); letter-spacing: 0.16em; @@ -312,19 +828,55 @@ pre.plain { white-space: pre-wrap; font-size: 13px; line-height: 1.6; color: var /* ── home ──────────────────────────────────────────────────────────────── */ -.hero h1 { font-size: 28px; max-width: 24ch; line-height: 1.2; } +.page-flow { display: flex; flex-direction: column; gap: 22px; } + +/* + The heading runs to whatever width it has. It carried a 24ch clamp, which broke "A directory of + the MU* hobby" across two lines at every width including 1440 — a measure is for paragraphs, and + this is one short line whose whole job is to be read at a glance. +*/ +.hero-head { display: flex; flex-direction: column; gap: 8px; } +.hero h1 { font-size: 26px; line-height: 1.2; letter-spacing: -0.01em; margin: 0; } -form.search { display: flex; gap: 8px; max-width: 560px; margin: var(--cpad) 0; } -form.search input { flex: 1; min-width: 0; } +/* The one sentence a stranger needs before they read a count. Dimmed a step so the heading above it + stays the first thing the eye takes, and measured so it never runs past a comfortable line. */ +.hero .lede { font-size: 14.5px; line-height: 1.6; color: var(--dim); max-width: 62ch; margin: 0; } +/* + One field with the search glyph inside it, and the submit beside it at the field's own height. + The two used to be separate boxes at two different sizes, which read as a form rather than as the + one control it is. +*/ +form.search { display: flex; gap: 8px; max-width: 520px; margin: 0; } +.search-field { + flex: 1 1 auto; min-width: 0; + display: flex; align-items: center; gap: 10px; + background: var(--recessed); + border: 1px solid var(--line); + border-radius: var(--radius); + padding: 0 14px; +} +.search-field:focus-within { border-color: color-mix(in srgb, var(--accent) 55%, var(--line)); } +.search-glyph { color: var(--accent); font-size: 15px; line-height: 1; } input[type="search"], input[type="text"] { background: var(--recessed); border: 1px solid var(--line); color: var(--text); font: 14px var(--sans); padding: 8px 11px; - border-radius: 6px; + border-radius: var(--radius); +} + +/* After the generic input rule, not before it: the field's own box is the bordered thing here and + the input inside it is only the caret. Ordered the other way round the generic rule won on equal + specificity and drew a second border inside the first. */ +.search-field input[type="search"] { + flex: 1; min-width: 0; + background: none; border: 0; padding: 11px 0; border-radius: 0; + color: var(--text); font: 14px var(--sans); } +.search-field input[type="search"]:focus { outline: none; } +.search-field input[type="search"]::placeholder { color: var(--faint); } button { background: var(--raised); @@ -332,95 +884,268 @@ button { color: var(--text); font: 14px var(--sans); padding: 8px 14px; - border-radius: 6px; + border-radius: var(--radius); cursor: pointer; } -ul.counts { +/* ── the four figures ────────────────────────────────────────────────────── + A label and a value, in a framed tile, at the size a front page's whole claim deserves. They were + one 12px mono line reading like a caption, which is what a count of the hobby is not. */ + +ul.tiles { list-style: none; margin: 0; padding: 0; - display: flex; flex-wrap: wrap; gap: 20px; font-size: 12px; color: var(--dim); + display: grid; grid-template-columns: repeat(auto-fit, minmax(170px, 1fr)); gap: 12px; +} +ul.tiles li { + border: 1px solid var(--line-soft); border-radius: var(--radius-lg); + background: var(--surface); box-shadow: var(--shadow); padding: 16px; + display: grid; gap: 8px; align-content: start; +} +ul.tiles a { text-decoration: none; display: grid; gap: 8px; } + +/* + The value stays in the machine face. The drawing sets it in the UI sans, and the handoff's own + token rules say the opposite two pages earlier — "mono for anything the machine said: counts, + versions, ages … the one typographic rule carrying meaning". A count of the hobby is the purest + case of a machine-said value on this site, so the prose wins over the component. The size is the + drawing's. +*/ +ul.tiles .kicker { color: var(--faint); } +ul.tiles .figure { + font-size: 28px; font-weight: 600; letter-spacing: -0.01em; color: var(--text); + line-height: 1; } -ul.counts strong { color: var(--text); font-weight: 400; } +ul.tiles .figure.state-present { color: var(--accent); } /* The crawler strip, under the counts it is the provenance of. A step smaller and dimmer than they are, because it is about the instrument rather than about the hobby — a reader who never notices it has lost nothing, and one who comes looking for it knows where to look. */ +/* Hairlines top and bottom, as the handoff frames it: the strip is a band of provenance under the + figures it qualifies, and a band reads as one thing where a loose line reads as a footnote. */ p.crawler { - margin: 10px 0 0; font-size: 11px; + margin: 0; padding: 12px 0; font-size: 12.5px; + display: flex; align-items: center; gap: 10px; + border-top: 1px solid var(--line-soft); border-bottom: 1px solid var(--line-soft); } +p.crawler .state-present { text-shadow: var(--glow); } .feeds { display: grid; grid-template-columns: repeat(auto-fit, minmax(280px, 1fr)); - gap: var(--cpad); - margin: calc(var(--cpad) * 2) 0; + gap: 22px; + margin: 0; } +/* A column: its heading, then rows. The heading carried a 33.6px top margin from the global h2 + rule, which put each of the three columns a block lower than the rhythm the page is set on. */ +.feeds .feed { display: flex; flex-direction: column; } +.feeds .feed h2 { margin: 0 0 10px; } +.feeds .feed-lit h2 { color: var(--accent); } +.feeds .feed-dark h2 { color: var(--amber); } + /* ── liveness feed cards ─────────────────────────────────────────────────── One shape, three registers. Neutral, unlit, and — for a return — the one place the site raises its voice, because a game dark for two years answering is what no incumbent can tell you. */ -.feed-card { - border: 1px solid var(--line); - background: var(--recessed); - border-radius: 8px; - padding: 12px 14px; - margin-bottom: 10px; +/* A row: name left, age right, a hairline between. Three columns of boxed cards gave a name and an + age the furniture of a section, and framed things on this site are supposed to mean something — + the connect screen is quoted in a frame because it is somebody else's. */ + +.feed-row { + display: flex; + justify-content: space-between; + align-items: baseline; + gap: 12px; + padding: 9px 0; + border-bottom: 1px solid var(--line-soft); } -.feed-card .feed-name { display: flex; align-items: baseline; gap: 8px; flex-wrap: wrap; margin-top: 6px; } -.feed-card .feed-name a { font-size: 15px; font-weight: 600; text-decoration: none; } -.feed-card .detail { font-size: 11.5px; color: var(--dim); margin: 4px 0 0; } -.feed-card.unlit { opacity: 0.78; } -.feed-card.unlit .feed-name a { color: var(--dim); } +/* The last row of a column closes on the column's own edge rather than on a rule to nothing. */ +.feeds .feed-row:last-child { border-bottom: 0; } -.feed-card.returned { - border-color: color-mix(in srgb, var(--accent) 34%, transparent); - background: color-mix(in srgb, var(--accent) 10%, transparent); - animation: return-glow 1.4s ease-out 1; +.feed-row .feed-name { + min-width: 0; font-size: 14px; color: var(--text); text-decoration: none; +} +.feed-row .feed-name:hover { text-decoration: underline; text-underline-offset: 3px; } +.feed-row .feed-state { + flex: none; display: inline-flex; align-items: baseline; gap: 5px; + font-size: 12.5px; color: var(--faint); +} +.feed-row .feed-state .sep { color: var(--faint); } +.feed-row.unlit .feed-name { color: var(--dim); } + +/* The return is the same row as the other two. The accent is on the word that says it is back and + nowhere else — a tinted card with a glow gave one column furniture the other two did not have, + and the eye cannot run down three lists that are drawn as different kinds of thing. */ +.feed-row.returned .feed-state .state-present { color: var(--accent); } + +/* ── the card's own footer ───────────────────────────────────────────────── + The same row on every page: where else to go, and the text mirror last. A rule above it, because + it is the end of the card and not another block in the column. */ + +.card-footer { + display: flex; flex-wrap: wrap; gap: 16px; + margin: 0; padding-top: 14px; + border-top: 1px solid var(--line-soft); + font-size: 13px; color: var(--dim); +} + +/* On a card page the footer is a band of the card rather than a block in a padded column, so it + pads itself to the same edge every other band uses. */ +.card-page > .card-footer { padding: 14px var(--gutter) 22px; } +.card-footer { align-items: baseline; } +.card-footer a { text-decoration: none; } +.card-footer a:hover { text-decoration: underline; text-underline-offset: 3px; } +.card-footer .sep { color: var(--faint); } + +/* + The language switcher, at the far end of the footer beside the plain-text link — the two controls + that change how the page is read rather than which page it is. Pushed there rather than placed, so + the destinations keep the left edge they had. +*/ +form.locale { display: flex; align-items: center; gap: 10px; margin: 0 0 0 auto; } + +/* The label is the theme control's kicker, because these two sit side by side and are the same kind + of thing: a small named control that changes how the page is read. */ +form.locale .kick { + font: 10px/1 var(--kick); + letter-spacing: 0.16em; + text-transform: uppercase; + color: var(--faint); } -/* Motion budget, one of three: once, on arrival, never repeating. */ -@keyframes return-glow { - from { box-shadow: 0 0 0 0 color-mix(in srgb, var(--accent) 55%, transparent); } - to { box-shadow: 0 0 0 14px transparent; } +/* + One box, drawn as the search field is: the control and its submit inside a single hairline rather + than a native dropdown and a wide button beside it. The footer is otherwise text, and two heavy + rectangles in it read as the loudest thing on the page — which a language switcher is not. +*/ +.locale-field { + display: flex; align-items: center; gap: 2px; + background: var(--recessed); + border: 1px solid var(--line); + border-radius: var(--radius); + padding: 0 4px 0 11px; +} +.locale-field:focus-within { border-color: color-mix(in srgb, var(--accent) 55%, var(--line)); } + +/* Stripped of the platform's own chrome so it matches the site rather than the OS — a native select + is a different shade, a different radius and a different caret on each of the three, and none of + them is this one. */ +form.locale select { + appearance: none; + background: none; border: 0; border-radius: 0; margin: 0; + padding: 7px 18px 7px 0; + color: var(--text); font: 13px var(--sans); + cursor: pointer; + + /* Sized to the option in force rather than to the longest one in the list. A select is as wide + as its widest child by default, so "English" sat in a box cut for "Русский (CI canary)" and + the caret ended up a hand's width from the word it belongs to. Where this is not supported the + box is merely the old width, which is the behaviour it replaces — nothing is lost by it. */ + field-sizing: content; +} +/* + The ring goes round the box, not round the flat control inside it. Stripping `appearance` takes the + platform's focus ring with it, and the border tint below is a mouse affordance rather than an + indicator a keyboard reader can rely on — 2.4.7 wants something that survives at any contrast. +*/ +form.locale select:focus { outline: none; } +.locale-field:has(select:focus-visible) { + outline: 2px solid var(--accent); + outline-offset: 2px; +} + +/* The nav's chevron, not a new glyph. Pulled back over the select's right padding and transparent to + the pointer, so the caret is part of the same click target rather than a dead spot beside it. */ +.locale-caret { + margin-left: -16px; + color: var(--faint); font-size: 11px; line-height: 1; + pointer-events: none; +} + +/* The search's own arrow. A submit is needed because this site runs no script, and this is the + smallest shape that says "commit" in a vocabulary the reader has already met. */ +.locale-go { + flex: none; display: flex; align-items: center; justify-content: center; + width: 22px; height: 22px; padding: 0; + background: none; border: 0; border-radius: 6px; + color: var(--faint); font-size: 13px; cursor: pointer; } +.locale-go:hover { color: var(--accent); background: var(--raised); } + -.feed-card.returned .return-line { font-size: 15px; line-height: 1.5; color: var(--text); margin: 6px 0 0; } /* ── game page ─────────────────────────────────────────────────────────── */ -.game-head { display: flex; gap: var(--cpad); flex-wrap: wrap; align-items: flex-start; } -.game-head .game-title { flex: 1; min-width: 260px; } +/* The header band: padded like every other band on a card page, with a rule under it running the + card's full width. */ +.game-head { + display: flex; gap: 20px; flex-wrap: wrap; + align-items: flex-start; justify-content: space-between; + padding: 24px var(--gutter); + border-bottom: 1px solid var(--line-soft); +} + +.game-identity { display: flex; gap: 16px; align-items: flex-start; min-width: 0; flex: 1 1 340px; } +.game-head .game-title { display: flex; flex-direction: column; gap: 6px; min-width: 0; } +.game-head .game-title h1 { margin: 0; } +.game-head .claim-line { margin: 0; font-size: 13.5px; } .game-head .plate { - width: 68px; height: 68px; flex: none; - border: 1px solid var(--line); border-radius: 8px; + width: 64px; height: 64px; flex: none; + border: 1px solid var(--line-soft); border-radius: 12px; background: var(--recessed); color: var(--dim); display: grid; place-items: center; font-size: 22px; + padding: 8px; box-sizing: border-box; +} + +/* + The count and the probe that produced it, as one block. It was a number and a provenance chip on + one line at body size, which set the fact most readers came for at the size of the metadata + qualifying it. +*/ +.game-figure { + flex: 0 0 auto; display: flex; flex-direction: column; align-items: flex-end; gap: 6px; + text-align: right; } +.game-figure .figure-count { + margin: 0; font-size: 20px; color: var(--accent); + text-shadow: var(--glow); font-variant-numeric: tabular-nums; +} +.game-figure .figure-count .unit { font-size: 15px; } + +/* A count the game states about itself rather than one we read: amber, which is what declared means + everywhere else here, and no glow — the glow is the accent's, and the accent means measured. */ +.game-figure .figure-count.declared { color: var(--amber); text-shadow: none; } +.game-figure .figure-count.unknown { + color: var(--faint); text-shadow: none; font-size: 15px; font-variant-numeric: normal; +} +.game-figure .figure-age { margin: 0; } + +/* One column, and the sections spaced by it rather than by margins that disagree. */ +.game-body { display: flex; flex-direction: column; gap: 28px; padding: 28px var(--gutter) 8px; } +.game-body > section { display: flex; flex-direction: column; gap: 10px; } +.game-body > section > h2 { margin: 0; font-size: 17px; } /* An icon sits in the monogram's place and at its size. `contain` rather than `cover`: a logo that is not square is letterboxed rather than cropped, because cropping somebody's artwork to fit our box is a small edit to a thing they published. The plate's own background shows through where the image does not reach, so a transparent PNG lands on the same recessed square as the monogram. */ .game-head img.plate { object-fit: contain; padding: 4px; } -.game-head .connect { flex: none; min-width: 240px; } -.game-head .lede { font-size: 15px; line-height: 1.65; max-width: 62ch; } -.game-head .tagline { font-size: 16px; } -.game-head .live { font-size: 14px; } +.game-head .lede { font-size: 14.5px; line-height: 1.6; max-width: 62ch; margin: 0; color: var(--dim); } +.game-head .tagline { font-size: 15px; margin: 0; } -/* The count's label, beside the count. Spaced in CSS rather than by a space in the markup, because - the renderer trims whitespace around a conditional — and sized to the line it qualifies. */ -.game-head .live .chip { margin-left: 6px; } -.game-head .live .chip .age { font-size: inherit; } +/* + An address is a line, not a card. Each was a bordered panel the full width of the title column, + which gave a hostname the furniture of the one framed thing on this page — somebody else's output, + quoted. +*/ .game-head .endpoint { - background: var(--raised); border: 1px solid var(--line); border-radius: 6px; - padding: 7px 10px; font-size: 12.5px; margin-bottom: 6px; + display: flex; flex-wrap: wrap; align-items: baseline; gap: 12px; + margin: 0; padding-top: 4px; + font-size: 13.5px; color: var(--text); } -/* Same reason as the chip above, and it shipped as "penultimatemush.com 9500answering here since - Jul 2026": the renderer trims the whitespace between the port and a conditional span, so the gap - has to be a margin rather than a space in the markup. */ -.game-head .endpoint > span { margin-left: 8px; } +.game-head .endpoint .faint { font-size: 12.5px; } +.game-head .endpoint.former .address { color: var(--dim); } .badges { margin: 4px 0 6px; } .badge.claimed { color: var(--accent); border-color: color-mix(in srgb, var(--accent) 34%, transparent); } @@ -433,6 +1158,7 @@ p.crawler { } .archive-plate strong { color: var(--text); font-weight: 500; } +/* Kept for any surface that still wants two columns; the game page is one column now. */ .two-up { display: grid; grid-template-columns: minmax(0, 1.15fr) minmax(0, 0.85fr); gap: calc(var(--cpad) * 2); } /* @@ -441,7 +1167,7 @@ p.crawler { on it was clipped, while .heat-wrap's own overflow-x sat there doing nothing. The only region allowed to scroll sideways is the ANSI frame. */ -.two-up > *, .feeds > *, .row-main > * { min-width: 0; } +.two-up > *, .feeds > *, .row-main > *, .game-body > * { min-width: 0; } .section-head { display: flex; align-items: baseline; justify-content: space-between; gap: var(--cpad); flex-wrap: wrap; } .section-head .count { font-size: 12px; margin: 0; } @@ -556,8 +1282,14 @@ nav.spans .span { padding: 6px 10px; border: 1px solid var(--line); border-radius: 999px; color: var(--dim); text-decoration: none; } -nav.spans .span:hover { border-color: var(--dim); color: var(--text); } -nav.spans .span.on { border-color: var(--accent); color: var(--accent); } +nav.spans a.span:hover { border-color: var(--dim); color: var(--text); } + +/* The pressed one, which is a span rather than a link to the page you are on. Tinted as well as + outlined, because with no hover to distinguish it the border alone was doing all the work. */ +nav.spans .span.on { + border-color: var(--accent); color: var(--accent); + background: color-mix(in srgb, var(--accent) 10%, transparent); +} /* The shape sits under the range and is the smaller question of the two, so it follows immediately rather than being spaced as a second block. */ nav.spans.shapes { margin-top: -4px; } @@ -569,11 +1301,37 @@ details.read-as-text[open] > *:not(summary) { animation: reveal 120ms ease-out; /* Motion budget, three of three. */ @keyframes reveal { from { opacity: 0; } to { opacity: 1; } } -ul.perday, ul.spells { +ul.spells { list-style: none; margin: 6px 0 0; padding: 0; font-family: var(--mono); font-size: 12px; color: var(--dim); } -ul.perday li, ul.spells li { padding: 2px 0; } +ul.spells li { padding: 2px 0; } + +/* The grid's text alternative: seven rows rather than a hundred and sixty-eight cells. Numbers are + tabular so the columns scan, and the caption sits under the table it describes. */ +table.perday { + width: 100%; margin: 6px 0 0; border-collapse: collapse; + font-family: var(--mono); font-size: 12px; color: var(--dim); + caption-side: bottom; +} +table.perday caption { padding: 8px 0 0; color: var(--faint); text-align: left; } +table.perday th, table.perday td { padding: 4px 8px 4px 0; text-align: left; } +table.perday thead th { + font: 10px/1 var(--kick); letter-spacing: 0.16em; text-transform: uppercase; color: var(--faint); + border-bottom: 1px solid var(--line); padding-bottom: 6px; +} +table.perday tbody th { color: var(--text); font-weight: 600; } +table.perday td.num { font-variant-numeric: tabular-nums; } + +/* Not enough measured days to draw a week. A panel rather than a bare line, so the section reads as + answered rather than as a graphic that failed to load. */ +.sparse { + margin: 10px 0 var(--cpad); padding: calc(var(--cpad) * 1.5) var(--cpad); + border: 1px dashed var(--line); border-radius: 8px; + background: var(--recessed); color: var(--dim); text-align: center; +} +.sparse p { margin: 0; } +.sparse .kicker { margin-bottom: 6px; } /* ── availability strip ──────────────────────────────────────────────────── Ninety bars, oldest left. Degraded is a *short* bar and not merely another colour; unreachable @@ -600,19 +1358,50 @@ dl.stats dd { margin: 3px 0 0; font-size: 17px; } /* ── the ANSI quotation frame ──────────────────────────────────────────── */ -figure.ansi .quote { position: relative; background: #000; } -figure.ansi .quote pre { - margin: 0; padding: var(--cpad); - font: 13px/1.5 var(--mono-cjk); font-variant-ligatures: none; - color: #aaaaaa; white-space: pre; overflow-x: auto; +/* Every row, once, in a region that scrolls — a screen twice the height of the frame is scrolled + rather than cropped and offered again below. The cap is about 26 rows, which is what a terminal + showed the player; past that the reader scrolls the same way they would have on connecting. + Focusable, because a scrolling region a keyboard cannot reach is one a keyboard cannot read. */ +figure.ansi .quote { + position: relative; background: #000; + border-radius: 6px; + max-height: 33em; overflow: auto; overscroll-behavior: contain; } -figure.ansi .crop-fade { - position: absolute; left: 0; right: 0; bottom: 0; height: 56px; - background: linear-gradient(to bottom, rgba(0, 0, 0, 0), #000); - pointer-events: none; +figure.ansi .quote:focus-visible { outline: 2px solid var(--accent); outline-offset: -2px; } +figure.ansi .quote pre { + margin: 0; padding: 14px 16px; + font: 12px/1.4 var(--mono-cjk); font-variant-ligatures: none; + color: #aaaaaa; white-space: pre; } figure.ansi figcaption { display: flex; gap: 8px; flex-wrap: wrap; } -details.read-as-text .ansi { border: 1px solid var(--line); } + +/* + ── the words, in the same figure ────────────────────────────────────────── + The prose lines are what a player actually needs — the address and the connect/create/QUIT + instructions — and they were behind a disclosure outside the frame, which made the block a picture + with a footnote rather than a quotation with a reading. Under a hairline, with the kicker the + handoff names, and open: this is the one text copy of the art, and a text alternative a reader has + to open is one most readers never see. +*/ +.screen-text { + border-top: 1px solid var(--line-soft); + padding-top: 12px; +} +.screen-text > summary { cursor: pointer; list-style: none; } +.screen-text > summary::-webkit-details-marker { display: none; } +.screen-text > summary::after { content: " ▾"; color: var(--faint); letter-spacing: normal; } +.screen-text[open] > summary::after { content: " ▴"; } +.screen-text .kicker { color: var(--accent); } +.screen-text > summary:hover .kicker { color: var(--text); } +.screen-text > pre { margin-top: 8px; } +.screen-text pre { + margin: 0; + font: 12.5px/1.7 var(--mono-cjk); font-variant-ligatures: none; + color: var(--text); + white-space: pre-wrap; + overflow-wrap: anywhere; +} + pre.plain-screen { background: var(--recessed); padding: var(--cpad); overflow-x: auto; font-size: 12px; } .ansi-plate { @@ -637,28 +1426,54 @@ pre.plain-screen { background: var(--recessed); padding: var(--cpad); overflow-x ul.games, ul.archive { list-style: none; margin: 0; padding: 0; } +/* + The row pads itself and the hairline runs the column's full width. It used to hang on a negative + margin so a hover plane could reach past the reading measure — the results column owns its own + padding now, so the row simply is the width it is drawn at. +*/ ul.games > li, ul.archive > li { - border-bottom: 1px solid var(--line); - padding: var(--row-pad) var(--cpad); - - /* Negative margin so the hover plane runs to the reading measure's own edge and the text does - not shift when it appears — a row that moves under the pointer is a row you mis-click. */ - margin: 0 calc(var(--cpad) * -1); + border-bottom: 1px solid var(--line-soft); + padding: var(--row-pad) var(--gutter); + margin: 0; } -ul.games > li.game-row:hover { background: var(--surface); } +ul.games > li.game-row:hover { background: var(--raised); } + +/* The row is a touch target before it is a layout: the game's name is the link, and on a phone a + list of five hundred of them is a list of five hundred things to hit. The handoff's geometry — + 13px by 20px over a 46px floor — is what puts a comfortable target under every name. */ +ul.games > li.game-row { min-height: 46px; padding: var(--row-pad) var(--gutter); } /* Three columns: the game's face, what it is, and what we measured. The plate is what gives a five-hundred-row list a left edge the eye can run down — before it, every row began with a different-length name and the only way to find a game was to read them. `start` rather than `baseline` because a 36px box has no baseline worth aligning a name to. */ +/* Two zones on the row and a third under them: identity on the left, measurement on the right, and + the meta line spanning beneath the name. The handoff's geometry exactly. */ +/* + Three columns and two lines: identity, measurement, freshness across the top, and the machine + facts spanning beneath. The count and the age are siblings on one baseline — they were a nested + two-row grid in the third column, which stacked the age under the count and left neither able to + line up down the page. +*/ .row-main { display: grid; - grid-template-columns: auto minmax(0, 1fr) auto; - gap: 2px var(--cpad); - align-items: start; + grid-template-columns: minmax(0, 1fr) auto auto; + gap: 3px 20px; + align-items: baseline; } +/* + `contents` so the name and the metadata are grid items of the row itself rather than of a box + inside column one — that is what lets the metadata span all three columns while the name occupies + only the first. +*/ +.row-main .row-text { display: contents; } +.row-main .row-head { grid-column: 1; grid-row: 1; min-width: 0; } +.row-main .row-count { grid-column: 2; grid-row: 1; } +.row-main .row-seen { grid-column: 3; grid-row: 1; } +.row-main .meta { grid-column: 1 / -1; grid-row: 2; min-width: 0; } + /* The row's own plate. Same recessed square, same border, same monogram treatment as the game page's — one vocabulary at two sizes, so a reader who has seen the page recognises the row. */ .row-main .plate { @@ -683,9 +1498,9 @@ ul.games .name, ul.archive .name { font-size: 15px; font-weight: 600; text-decor ul.games .name:hover { text-decoration: underline; text-underline-offset: 3px; } ul.archive .name { color: var(--dim); } -/* The majority state of the catalogue, so it is the quiet word rather than the third pill. A badge - every row wears distinguishes no row from any other, and at 700 rows it is chrome. */ -ul.games .unclaimed { font: 10px/1 var(--kick); letter-spacing: 0.14em; text-transform: uppercase; color: var(--faint); } +/* No rule for "unclaimed": it is not on a row any more. The majority state of the catalogue said on + every row is an administrative fact about our records, repeated once per game at a reader looking + for somewhere to play. It stays on the game page, where it arrives with the way to change it. */ .row-text .tagline { margin: 2px 0 0; @@ -699,70 +1514,75 @@ ul.games .unclaimed { font: 10px/1 var(--kick); letter-spacing: 0.14em; text-tra white-space: nowrap; } -ul.games .meta, ul.archive .meta { margin: 3px 0 0; font-size: 11.5px; color: var(--faint); } +ul.games .meta, ul.archive .meta { margin: 3px 0 0; font-size: 12.5px; color: var(--dim); } ul.games .meta .protocol { white-space: nowrap; } +/* The protocols this row did not print. A count rather than a name, and the names are in its title + for a pointer and on the game's page for everybody. */ +ul.games .meta .protocol.more { color: var(--dim); } + /* A provenance chip on a listing or archive row. The chip's own age size is set for body copy, and these contexts are already smaller than that — so the age rides the row's size rather than growing larger than the text it qualifies. Everything else about the chip is unchanged, deliberately: the row, the archive and the game page have to be one vocabulary and not three that resemble each other. `.meta` is the class both lists give that line, so both are covered by naming it once. */ -.meta .chip .age, .row-figure .chip .age { font-size: inherit; } +.meta .chip .age { font-size: inherit; } + +/* ── the two measured columns ────────────────────────────────────────────── + Tabular figures so the counts line up down the page without a table, and right-aligned so the + units place is the edge the eye runs down. + + The count carries no unit and no provenance glyph. "on" after every number was one English word + repeated 515 times — the column is named once, above, which is also one string per locale rather + than five hundred — and where a number came from is a fact you weigh when choosing between two + games rather than while scanning five hundred, so it lives on the game page and on the facet + badges instead. */ -/* The measured column. Tabular figures so the counts line up down the page without a table. */ -.row-figure { +.row-count { margin: 0; + grid-column: 2; text-align: right; - font-size: 12px; white-space: nowrap; + font-size: 15px; font-variant-numeric: tabular-nums; - display: grid; - gap: 2px; - justify-items: end; + color: var(--text); } -/* ── the count, which is the fact most readers came for ──────────────────── - Players on now is a fact like any other and is labelled like any other — the glyph beside it means - measured or declared exactly as it does in every other column, because a second meaning for the - accent dot would cost it the first one. What sets it apart is scale and position, which carry no - meaning to lose: the number is 17px and nothing else in a row is above 15, so it is what the eye - lands on, and it sits at the head of a column that lines up down the page. - - The number's own weight then does the rest of the work. A count with somebody in it is at full - text colour; a measured zero is dimmed one step — still a measurement, still glyphed, still above - the break, and visibly not somewhere to go tonight. An unknown says so in words and is dimmer - again. Three states, three weights, no new colours. */ +/* Somebody is on. The one place a live count is marked as such, and the glow follows the digits + rather than a pip beside them. */ +.row-count.live { color: var(--accent); } -.row-figure .players { color: var(--text); display: block; } -.row-figure .players .count { font-size: 17px; font-weight: 600; letter-spacing: -0.01em; } -.row-figure .players .pip { margin-right: 5px; } +/* A measured zero: dimmed one step, never faint. We got in and nobody was there is a result, and + it is not the same fact as a count we could not read. */ +.row-count.empty { color: var(--dim); } -/* A count of nobody, measured. Dimmed rather than hidden — we got in and nobody was there is a - result, and the row above the break is where it belongs. */ -.row-figure .players.empty .count { color: var(--dim); font-weight: 400; } +/* Not a number at all, so it is not set as one: smaller, faint, and in words. */ +.row-count.unknown { color: var(--faint); font-size: 13.5px; font-variant-numeric: normal; } -/* The one place a live count is marked as such: a soft glow on the pip where somebody is actually on - right now. A text-shadow rather than a ring, because a ring is drawn on the glyph's inline box — - which is a tall narrow rectangle, not the dot — and rendered as a lozenge round a circle. This - follows the glyph itself at any font and any size. - - Static. Five hundred of these animating is a page that cannot be read, and the motion budget is - spent on the "came back" card. It is a reinforcement and never the carrier: the count, the glyph - and the word behind it all say the same thing without it. */ -.row-figure .players.live .pip.state-present { - text-shadow: 0 0 7px color-mix(in srgb, var(--accent) 60%, transparent); +.row-seen { + margin: 0; + grid-column: 3; + text-align: right; + white-space: nowrap; + font-size: 12.5px; + color: var(--faint); + font-variant-numeric: tabular-nums; } -/* The count's own chip rides beside the figure. Spaced in CSS and not by a space in the markup, - because the renderer trims whitespace around a conditional and "219 on" ran into its own glyph. */ -.row-figure .players .chip { margin-left: 6px; } -.row-figure .players .unit { color: var(--faint); } -.row-figure .players.unknown { color: var(--faint); } -.row-figure .seen { color: var(--faint); font-size: 11.5px; } - -/* What a window sort ranked this row on, printed on the row it ranked. Faint and small: it is the - basis for the order rather than a fact the row is about, and the count above it stays the figure. */ -.row-figure .window { color: var(--faint); font-size: 11.5px; } +/* + Claimed: a ring with a tick in it and no visible word. It was a pill the width of "claimed" on the + handful of rows that carry it — furniture for a fact a browsing reader did not come for. The name + is on the element, where a screen reader and a tooltip both reach it. +*/ +.claim-ring { + display: inline-flex; align-items: center; justify-content: center; + width: 16px; height: 16px; flex: none; + border-radius: 99px; + border: 1px solid color-mix(in srgb, var(--accent) 40%, transparent); + background: color-mix(in srgb, var(--accent) 12%, transparent); + color: var(--accent); + font: 10px/1 var(--mono); +} /* Archived: dimmed one step, and that is the whole treatment. No red, no strikethrough, no "dead" — the entry is a library record for a periodical that ceased publication. */ @@ -788,26 +1608,84 @@ li.unranked-break { li.unranked-break:hover { background: var(--surface); } -dl.archive-facts { margin: 0; font-size: 12px; min-width: 220px; } +/* + The archive row is two zones, not the listing's three — it has no count column, and its facts + panel is a definition list rather than two cells. It shares .row-main with the listing for the + gap and the baseline, so it names its own columns rather than inheriting a third it has nothing + to put in. +*/ +ul.archive .row-main { grid-template-columns: minmax(0, 1fr) auto; } + +dl.archive-facts { margin: 0; font-size: 12px; min-width: 200px; } dl.archive-facts dd { margin: 0 0 6px; color: var(--dim); } +/* Below the width where a 200px facts panel and a game's metadata both fit, they stack — the panel + was holding its minimum and clipping the name and codebase beside it. */ +@media (max-width: 620px) { + ul.archive .row-main { grid-template-columns: minmax(0, 1fr); } + dl.archive-facts { min-width: 0; } +} + /* ── the listing's own header ────────────────────────────────────────────── */ -.listing-head { margin-bottom: var(--cpad); } -.listing-head p { margin: 0; max-width: 62ch; } +/* The card's own header band: padded like the drawing, with a rule under it running the full + width of the card rather than stopping at a content measure. */ +.listing-head { + margin: 0; + padding: 22px var(--gutter) 18px; + border-bottom: 1px solid var(--line-soft); + display: flex; flex-direction: column; gap: 7px; +} +.listing-head h1 { margin: 0; } +.listing-head p { margin: 0; max-width: 62ch; font-size: 14px; } + +/* ── the listing's toolbar ───────────────────────────────────────────────── + What order this is in on the left, the control that changes it and the two column names on the + right, over the columns they name. */ .listing-bar { display: flex; align-items: baseline; - gap: var(--cpad); + justify-content: space-between; + gap: 12px 20px; flex-wrap: wrap; - margin: calc(var(--cpad) * 1.5) 0 4px; + margin: 0; + padding: 11px var(--gutter); + border-bottom: 1px solid var(--line-soft); + font-size: 13px; + color: var(--dim); } -.listing-bar .result-count { margin: 0; font-size: 13px; } -.listing-bar .result-count strong { font-size: 19px; font-weight: 600; } .listing-bar .listing-order { margin: 0; } -.listing-bar .listing-order a { color: var(--faint); } +.listing-bar .listing-order .order-name { color: var(--text); } +.listing-bar .listing-order .sep { margin: 0 6px; color: var(--faint); } +.listing-bar .listing-order a { color: var(--dim); } + +.listing-tools { display: flex; align-items: baseline; gap: 20px; } +.listing-tools .column-head { margin: 0; } + +/* ── a pressed-state toggle group ────────────────────────────────────────── + Not links to the page you are already reading. The one in force is a <span> with aria-current, so + there is no keystroke that lands on a control whose only effect is to re-fetch this page — the + same fix the trend range and shape selectors already carry. */ + +.switch { display: flex; align-items: baseline; gap: 8px; font-size: 12.5px; } +.switch a { color: var(--dim); text-decoration: none; } +.switch a:hover { color: var(--text); text-decoration: underline; text-underline-offset: 3px; } +.switch .on { color: var(--accent); } +/* A rule, not a wider gap: the two halves of the switch are different kinds of order — three that + change which measurement the column shows, and two that only change the stacking. */ +.switch .switch-rule { + width: 1px; height: 13px; align-self: center; margin: 0 2px; background: var(--line); +} + +/* The window under the statistic it belongs to, quieter than the switch that produced it. */ +.switch.windows { + padding: 8px var(--gutter); + border-bottom: 1px solid var(--line-soft); + font-size: 12px; + justify-content: flex-end; +} /* Nothing matched. A plate rather than a paragraph, because an empty listing is a state and not an @@ -829,9 +1707,25 @@ dl.archive-facts dd { margin: 0 0 6px; color: var(--dim); } /* ── one column below 900px; no horizontal scroll except inside the frame ── */ @media (max-width: 900px) { - .two-up, .feeds { grid-template-columns: minmax(0, 1fr); } - .game-head { flex-direction: column; } - header.site { flex-wrap: wrap; } + .feeds { grid-template-columns: minmax(0, 1fr); } + + /* + The theme control is the one thing in the bar that goes nowhere, so it is what the bar gives + up its words for first: three buttons become their initials' worth of room. + + Taken out of the drawing and left in the accessibility tree, because the form names itself + with `aria-labelledby="theme-label"` and this is that label. `display: none` removed it from + both, so below 900px a screen reader met three buttons in a group with no name at all — the + one width where the surrounding words that would have explained them are gone too. + */ + header.site form.theme .kick { + position: absolute; + width: 1px; height: 1px; + padding: 0; margin: -1px; + overflow: hidden; + clip-path: inset(50%); + white-space: nowrap; + } /* All 168 cells at 12px rather than a scrolling grid — the whole week at a glance is the reason @@ -933,7 +1827,22 @@ ul.sole-use-names { ul.sole-use-names li { color: var(--dim); } /* Wide content scrolls inside its own box; the page body never scrolls sideways. */ -.table-wrap { overflow-x: auto; margin: var(--cpad) 0; } +/* + A scroller contains its own absolutely positioned descendants — and until it did, the game page + scrolled sideways. + + `.sr-only` is `position: absolute`, and with no positioned ancestor its containing block was the + initial one: the text a screen reader reads out of the capability matrix was laid out at the + matrix's own width, 463px in German, *outside* this box and outside `.shell`'s `overflow-x: clip`. + So five spans nobody can see pushed the document 59px wider than a 360px phone, and the whole page + scrolled to reveal nothing. Visually-hidden is not the same as out of the layout, and one + `position: relative` is what makes the difference invisible in both directions. +*/ +.table-wrap { position: relative; overflow-x: auto; margin: var(--cpad) 0; } + +/* Inside a section that already spaces its children, the wrapper carries no margin of its own — + and it keeps the table's rounded frame from being clipped square by the scroll box. */ +.game-body .table-wrap { margin: 0; border-radius: var(--radius); } table.protocols, table.ranking { border-collapse: collapse; width: 100%; } table.protocols th, table.protocols td, @@ -981,13 +1890,12 @@ table.ranking tbody th { font-weight: 400; } is the only reason they are there. ═══════════════════════════════════════════════════════════════════════════ */ -form.facet-form { - border: 1px solid var(--line); - border-radius: 10px; - background: var(--surface); - padding: var(--cpad); - margin: 0 0 var(--cpad); -} +/* + No box. It was a panel on a page — border, radius, its own surface — and inside the card it became + a box within a box, fighting the hairline that already separates it from the rows. The column's + own edge is the separation; the form is just its contents. +*/ +form.facet-form { border: 0; background: none; padding: 0; margin: 0; } /* ── the bar ─────────────────────────────────────────────────────────────── */ @@ -995,7 +1903,58 @@ form.facet-form { The archive's own search box is the same control with a legend on it, so it is styled here rather than growing a second look for one question asked on two pages. */ -.filter-bar, fieldset.facets { +/* ── the panel, as one disclosure below 900px ────────────────────────────── + Above that width the summary is hidden and the content is forced open, so the same markup is a + column on a laptop and a disclosure on a phone with no second rendering and no script. + + Guarded on ::details-content: where a browser does not have it, forcing a closed <details> open + from CSS is not possible, so the summary stays visible at every width — a "filters" disclosure at + the top of the column rather than an unreachable panel behind a hidden control. */ + +.facet-collapse { min-width: 0; } +.facet-collapse > summary { + display: flex; align-items: center; gap: 8px; + cursor: pointer; list-style: none; + padding: 9px 8px; margin-bottom: 4px; + border: 1px solid var(--line); border-radius: var(--radius); + font: 10px/1 var(--kick); letter-spacing: 0.16em; text-transform: uppercase; + color: var(--dim); +} +.facet-collapse > summary::-webkit-details-marker { display: none; } +.facet-collapse > summary:hover { color: var(--text); border-color: var(--dim); } +.facet-collapse > summary::after { + content: "▾"; margin-left: auto; font-size: 11px; letter-spacing: normal; +} +.facet-collapse[open] > summary::after { content: "▴"; } +.facet-collapse .summary-count { + font-family: var(--mono); font-size: 11px; letter-spacing: normal; color: var(--accent); +} +.facet-body { display: flex; flex-direction: column; gap: 24px; } + +@supports selector(::details-content) { + @media (min-width: 901px) { + .facet-collapse > summary { display: none; } + .facet-collapse::details-content { content-visibility: visible; block-size: auto; } + } +} + +/* One field, and nothing else — the sort and the two inclusion switches that used to share this row + are a toolbar switch and two facet rows now. */ +.filter-bar { display: block; margin: 0; } +.filter-bar .search-field { padding: 0 8px 0 12px; } +.filter-bar .search-field input[type="search"] { padding: 7px 0; font-size: 13px; } + +/* The submit, inside the field. A 268px column has no room for a second box on that row, and a + submit that exists only as the return key is one a pointer-only reader cannot press. */ +.search-go { + flex: none; display: flex; align-items: center; justify-content: center; + width: 22px; height: 22px; padding: 0; + background: none; border: 0; border-radius: 6px; + color: var(--faint); font-size: 13px; cursor: pointer; +} +.search-go:hover { color: var(--text); background: var(--raised); } + +fieldset.facets { display: flex; gap: 10px; align-items: center; @@ -1004,7 +1963,7 @@ form.facet-form { fieldset.facets { border: 1px solid var(--line); - border-radius: 10px; + border-radius: var(--radius-lg); background: var(--surface); padding: var(--cpad); margin: 0 0 var(--cpad); @@ -1017,7 +1976,8 @@ fieldset.facets legend { color: var(--faint); } -.filter-bar input[type="search"], fieldset.facets input[type="search"] { flex: 1 1 16rem; min-width: 0; } +.filter-bar input[type="search"] { min-width: 0; width: 100%; } +fieldset.facets input[type="search"] { flex: 1 1 16rem; min-width: 0; } .bar-field { display: inline-flex; align-items: center; gap: 6px; } .bar-label { font: 10px/1 var(--kick); letter-spacing: 0.16em; text-transform: uppercase; color: var(--faint); } @@ -1030,39 +1990,125 @@ fieldset.facets legend { auto-fit at a narrow floor, so eight facets pack four to a row on a laptop, two on a tablet and one on a phone without a breakpoint being written for any of them. */ -.facet-grid { +/* ── the listing's two columns ───────────────────────────────────────────── + What you are asking on the left, what came back on the right. `stretch` so the filter column's + own edge runs the full height of the card: aligned to its content it stops under a short panel + and leaves a well beside the rows. */ + +.listing-grid { display: grid; - grid-template-columns: repeat(auto-fit, minmax(178px, 1fr)); - gap: 10px var(--cpad); - margin-top: var(--cpad); + grid-template-columns: minmax(0, 268px) minmax(0, 1fr); + align-items: stretch; + gap: 0; + margin: 0; } -/* The control sits at the bottom of its cell, so a label that wraps grows upward and every select in - the row stays on one line. Left to itself the grid aligns the tops, and one long facet name puts - one control half a row below its neighbours. */ +/* + Placed explicitly, and that is load-bearing: the panel renders TWO siblings into this grid — the + form, and the row of active-filter chips that sits outside it because a chip is a link and not a + control. Left to auto-placement the chips took the second column and the listing dropped to the + first, under a filter column a thousand pixels tall — so applying a filter looked like a page that + had lost its results. +*/ +/* + The filter column is a surface a step below the card, so it reads as a column even where its rows + run out — the border alone left it as an unmarked area of the same fill as the results beside it. +*/ +.listing-grid > .facet-form { + grid-column: 1; + grid-row: 1 / span 99; + background: var(--recessed); + border-right: 1px solid var(--line-soft); + + /* Less 8px than the gutter, because every row inside pads itself by that — which is what puts + a facet label on exactly the same left edge as the wordmark above it. */ + padding: 20px max(6px, calc(var(--gutter) - 8px)); + display: flex; + flex-direction: column; + gap: 24px; +} +.listing-grid > * { grid-column: 2; min-width: 0; } +.listing-side { min-width: 0; } +.listing-grid > .active-filters { padding: 12px var(--gutter) 0; margin: 0; } + +/* + ── the filter column, narrow ────────────────────────────────────────────── + A disclosure above the listing rather than eleven hundred pixels of open panel to scroll past + before the first game. Closed by default and open whenever the reader has actually asked + something, because a filter in force that nothing shows is the defect this control replaces. +*/ +@media (max-width: 900px) { + .listing-grid { grid-template-columns: minmax(0, 1fr); } + .listing-grid > * { grid-column: 1; } + .listing-grid > .facet-form { + grid-column: 1; grid-row: auto; + border-right: 0; + border-bottom: 1px solid var(--line-soft); + } + .listing-grid > .active-filters { padding: 12px var(--gutter) 0; } + + /* Two columns of groups where there is room for them, so the opened panel is a band rather + than a column a reader has to scroll the length of. */ + .facet-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(240px, 1fr)); gap: 24px; } +} + +/* In a 268px column the facets stack, one group per row. Twenty-four pixels between groups, which + is the panel's own rhythm and twice the gap between a group's header and its rows. */ +.facet-grid { + display: flex; + flex-direction: column; + gap: 24px; + margin: 0; +} + +/* A facet is a heading, a note and a list of rows. */ .facet { min-width: 0; - display: grid; - grid-template-rows: 1fr auto; - align-content: end; + display: flex; + flex-direction: column; + gap: 9px; + border: 0; + padding: 0; + margin: 0; } +/* + The header block sits at the rows' own left padding, so the group name, the note and every row + label share one left edge — which is the whole reason the rows are padded rather than the panel. +*/ .facet > label, .facet > legend { display: flex; - gap: 6px; - align-items: baseline; - flex-wrap: wrap; - margin-bottom: 3px; - padding: 0; + flex-direction: column; + gap: 3px; + margin: 0; + padding: 0 8px; + width: 100%; + box-sizing: border-box; +} + +.facet .facet-head { + display: flex; align-items: center; justify-content: space-between; gap: 8px; } .facet .facet-name { font: 10px/1.4 var(--kick); - letter-spacing: 0.14em; + letter-spacing: 0.16em; text-transform: uppercase; color: var(--dim); } +/* + The one sentence a group needs at the moment somebody uses it, under its own heading rather than + once at the foot of the panel — the three groups say three different things and the line that + used to serve all of them contradicted the first. +*/ +.facet-note { + margin: 0; + font-size: 12px; + line-height: 1.5; + color: var(--faint); +} + select { background: var(--recessed); border: 1px solid var(--line); @@ -1074,9 +2120,139 @@ select { .facet select { width: 100%; max-width: 100%; } -/* A facet that is doing something says so at rest, and not only in colour — the chip row above the - results names it in words, and the select's own text is the value it is set to. */ -.facet select.chosen { border-color: color-mix(in srgb, var(--accent) 45%, var(--line)); } +/* ── the three-state facet row ───────────────────────────────────────────── + Off, only, anything but — one row per value, and the state legible without opening anything. The + two radios are hidden and the glyph is drawn, but they are real radios: the browser's own group + behaviour is what makes this work with no script, and every state is a word in the accessible + name as well as a shape and a tint. */ + +.facet .rows { display: grid; gap: 2px; margin: 0; } + +/* + The row's geometry, and it is a grid rather than a flex run for one reason: every column has to + land in the same place on every row of every group. As a flex run the widest label in a group + pushed that group's count and exclude columns ten pixels right of every other group's — and past + the panel's own edge, which is what the audit measured as a 253px row inside a 243px box. + + 15px the state glyph + 1fr the value, which is the one cell allowed to give up width + auto the count, right-aligned against the 1fr's slack so every count shares an edge + 18px the exclusion, where a "remove" belongs +*/ +.facet-row { + display: grid; + grid-template-columns: minmax(0, 1fr) 18px; + align-items: center; + gap: 9px; + min-height: 30px; + padding: 0 8px; + border-radius: 9px; + font-size: 13.5px; + color: var(--dim); + border: 1px solid transparent; +} + +/* One ordered scale: no exclusion, so no column for one. */ +.facet-row.single { grid-template-columns: minmax(0, 1fr); } + +.facet-row .pick { + display: grid; + grid-template-columns: 15px minmax(0, 1fr) auto; + align-items: center; + gap: 9px; + min-width: 0; + cursor: pointer; +} +.facet-row .tick { text-align: center; color: var(--faint); font-family: var(--mono); font-size: 12px; } +.facet-row .row-name { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; } +/* + `--dim` rather than `--faint`, because the panel is not the page. + + `--faint` was raised to 4.8:1 once already, measured against the page background — and the facet + panel is a more recessed surface than that, where the same token falls to 4.09:1 in dark and + 4.37:1 in light. Both are under the 4.5:1 this site holds itself to, and both are carried by a + 12px number, which is the smallest text in the panel and the one a reader most needs to read. + Raising the token instead would have moved every age and provenance line on the site to fix a + contrast the page itself does not have. +*/ +.facet-row .count { + font-family: var(--mono); font-size: 12px; font-variant-numeric: tabular-nums; color: var(--dim); +} + +/* The exclusion affordance, at the far edge where a "remove" belongs. Quiet until it is the state + the row is in. */ +.facet-row .drop { + display: block; text-align: center; cursor: pointer; + color: var(--faint); font-family: var(--mono); font-size: 12.5px; +} +.facet-row .drop:hover { color: var(--text); } +/* Links, so a click applies the filter rather than arming a control that waits for a button. */ +.facet-row a { text-decoration: none; color: inherit; border-radius: var(--radius); } + +.facet-row:hover { background: var(--raised); } + +/* + A rung of a scale that this filter leaves empty. It stays — a bounded facet is four named + thresholds a reader picks between, and deleting the empty ones meant narrowing the codebase + silently removed two of activity's four rows and shifted the panel under the reader's pointer. It + is dimmed rather than disabled, because 0 is an answer: "no Evennia game was active this week" is + a fact about the catalogue, and clicking it lands on the listing's own empty state. +*/ +.facet-row.empty { opacity: 0.55; } +.facet-row.empty:hover { opacity: 1; } + +/* Included: the accent as a tint and a ring, and the count goes accent with the label — the number + is the part of the row that says what the filter will return, so it is the part that has to look + chosen. */ +.facet-row.on { + color: var(--accent-ink); + background: color-mix(in srgb, var(--accent) 12%, transparent); + border-color: color-mix(in srgb, var(--accent) 40%, transparent); +} +.facet-row.on .tick, .facet-row.on .count { color: var(--accent-ink); } +.facet-row.on:hover { background: color-mix(in srgb, var(--accent) 16%, transparent); } + +/* + Excluded: the danger tint, ring and strikethrough the handoff draws. + + Red is not a provenance colour here and never becomes one — it marks a state the reader put the + control into, not a state of the data. That is why nothing else on the site is red: the accent + means measured, amber means declared, and this means refused. +*/ +.facet-row.excluded { + color: var(--danger); + background: color-mix(in srgb, var(--danger) 10%, transparent); + border-color: color-mix(in srgb, var(--danger) 35%, transparent); +} +.facet-row.excluded .tick, .facet-row.excluded .count { color: var(--danger); } +.facet-row.excluded .row-name { + text-decoration: line-through; + text-decoration-color: color-mix(in srgb, var(--danger) 50%, transparent); +} +.facet-row.excluded .drop { color: var(--danger); } +.facet-row.excluded:hover { background: color-mix(in srgb, var(--danger) 14%, transparent); } + +/* The radios are hidden, so the focus ring belongs to the row that holds them. */ +.facet-row a:focus-visible { outline: 2px solid var(--accent); outline-offset: 2px; } + +/* The tail. A summary is a control, so it gets the row's own height and hit area. */ +.facet .facet-tail { margin-top: 2px; } +.facet .facet-tail summary { + cursor: pointer; padding: 4px 8px; font-size: 12px; color: var(--faint); border-radius: 9px; +} +.facet .facet-tail summary:hover { color: var(--text); background: var(--raised); } + +/* Said once, under the groups it applies to. */ +.facet-hint { margin: 12px 0 0; font-size: 11.5px; color: var(--dim); } + +/* The facets a reader goes looking for, rather than the three they arrive with. */ +.facet-more-groups { margin: 0; border-top: 1px solid var(--line-soft); padding-top: 14px; } +.facet-more-groups > summary { + cursor: pointer; font: 10px/1 var(--kick); letter-spacing: 0.16em; text-transform: uppercase; + color: var(--faint); padding: 4px 8px; border-radius: var(--radius); +} +.facet-more-groups > summary:hover { color: var(--text); background: var(--raised); } +.facet-more-groups .facet-grid { margin-top: 14px; } /* ── the presence facet ──────────────────────────────────────────────────── */ @@ -1088,11 +2264,15 @@ select { fieldset.facet.presence { border: 0; padding: 0; - margin: var(--cpad) 0 0; + margin: 0; min-width: 0; } -fieldset.facet.presence .checks { display: flex; flex-wrap: wrap; gap: 6px; } +fieldset.facet.presence .checks { + display: flex; flex-wrap: wrap; gap: 6px; min-width: 0; padding: 0 8px; +} +fieldset.facet.presence .check { max-width: 100%; } +fieldset.facet.presence .check .check-name { overflow-wrap: anywhere; min-width: 0; } fieldset.facet.presence .check { display: inline-flex; @@ -1110,9 +2290,6 @@ fieldset.facet.presence .check:hover { border-color: var(--dim); } fieldset.facet.presence .check:has(:checked) { border-color: color-mix(in srgb, var(--accent) 45%, var(--line)); } fieldset.facet.presence .check .count { color: var(--faint); font-variant-numeric: tabular-nums; } -/* Where the unticked-is-not-a-no sentence lives: inside the fieldset it is about, at the moment of - ticking, rather than in a key at the bottom of the panel. */ -fieldset.facet.presence .hint { margin: 6px 0 0; font-size: 11.5px; color: var(--faint); max-width: 62ch; } /* Measured, declared, and the one thing we concluded ourselves — three registers, never the only carrier of the difference, because the chip spells each out in words as well and colour is not a @@ -1137,25 +2314,28 @@ fieldset.facet.presence .hint { margin: 6px 0 0; font-size: 11.5px; color: var(- a title attribute: this is the difference the whole site exists to publish, and it stays in the document whether or not a pointer ever hovers anything. */ +/* + One line and one disclosure. The three-row provenance legend that used to stand here is behind the + disclosure now: every group wears its own evidence badge, which is where the word is actually + needed — before a filter is applied rather than after the panel has been read to the bottom. It + also wrapped its descriptions right-aligned, which is what a flex row does to a text node it did + not expect to break. +*/ .facet-key { display: flex; - flex-wrap: wrap; - gap: 4px 18px; - align-items: baseline; - margin-top: var(--cpad); - padding-top: 10px; - border-top: 1px solid var(--line); - font-size: 11.5px; + flex-direction: column; + gap: 8px; + margin: 0 8px; + padding-top: 14px; + border-top: 1px solid var(--line-soft); + font-size: 12px; color: var(--faint); + text-align: left; } -.facet-key .key-item { display: inline-flex; gap: 5px; align-items: baseline; } -.facet-key .facet-more { margin-left: auto; } -.facet-key summary { cursor: pointer; color: var(--dim); } - -.facet-key .facet-more[open] { flex: 1 0 100%; margin-left: 0; margin-top: 6px; } -.facet-key .facet-more ul { margin: 6px 0 0; padding-left: 1.2em; max-width: 72ch; } -.facet-key .facet-more li { margin-bottom: 5px; color: var(--dim); } +.facet-key summary { cursor: pointer; color: var(--dim); font-size: 11.5px; } +.facet-key .facet-more ul { margin: 8px 0 0; padding-left: 1.2em; } +.facet-key .facet-more li { margin-bottom: 6px; color: var(--dim); line-height: 1.5; } /* ── what the query is currently asking for ──────────────────────────────── */ @@ -1202,18 +2382,16 @@ fieldset.facet.presence .hint { margin: 6px 0 0; font-size: 11.5px; color: var(- /* ── the panel and the rows, narrow ──────────────────────────────────────── */ +/* + Narrow rows keep all three columns and all three stay aligned. They used to collapse into a flex + run under the name, which put the age beside the count on some rows and under it on others — the + same list drawn two ways down one screen. The name gives up width first, which is the one cell + that can spare it, and the two right-hand columns hold their edge. +*/ @media (max-width: 620px) { - /* The bar stacks: a search box sharing a row with a sort and a toggle has room for none of them. */ - .filter-bar input[type="search"] { flex: 1 0 100%; } - .filter-bar button { margin-left: auto; } - - /* The measured column goes under the name rather than fighting it for a width neither has — - under the name and not under the plate, so the row keeps the left edge the plate gives it and - the figure lines up with the text it belongs to. */ - .row-main { grid-template-columns: auto minmax(0, 1fr); } - .row-main .plate { grid-row: span 2; } - .row-figure { text-align: left; justify-items: start; margin-top: 4px; } - .row-figure { display: flex; gap: 12px; flex-wrap: wrap; align-items: baseline; } + .row-main { gap: 3px 12px; } + .row-count { font-size: 14px; } + .row-count.unknown { font-size: 12.5px; } } /* ── reference and orientation pages ─────────────────────────────────────── The hand-written section (spec §9). Two things it has to communicate that no @@ -1375,3 +2553,283 @@ ol.events .faint { margin-right: 8px; } details.resign form { margin-top: 6px; } details.resign input[type="text"] { display: block; margin: 6px 0; max-width: 16ch; } + +/* ── find a game ─────────────────────────────────────────────────────────── + The questions on the left, the count on the right, and the count still on + screen when the last question is answered — which is the whole premise of + this page. Until this block existed the page had no rule of its own at all: + it was the one surface left on user-agent form styling, drawn full-bleed + with 2px groove borders and 5px of padding. */ + +.find-grid { + display: grid; + grid-template-columns: minmax(0, 1fr) minmax(0, 310px); + align-items: stretch; + gap: 0; + margin: 0; + + /* + `clip`, never `hidden`. An ancestor with overflow: hidden is a scroll + container, and a sticky element can only travel inside its own — so the + panel would pin for a few hundred pixels and then scroll away for the + rest, leaving the count invisible while questions four to six were + answered. That is the exact failure this page was redrawn to fix, and + `clip` clips without establishing the container. + */ + overflow: clip; +} + +.find-questions { min-width: 0; grid-column: 1; } + +/* ── one question ───────────────────────────────────────────────────────── + 24 above the heading, 14 under it, 24 to the next rule. Symmetric outside, + tighter inside, so the heading binds to the options it labels and the + questions separate from each other. The numbers are on the elements + themselves rather than on a container: a <legend> renders on the border + edge and outside the padding box, which is why the drawing's own first + attempt produced 13px above the heading and 2px below it. */ + +.find-q { + padding: 24px var(--gutter); + border-top: 1px solid var(--line-soft); +} + +.find-q-head { + display: flex; + align-items: baseline; + justify-content: space-between; + gap: 12px; + margin: 0 0 14px; +} + +/* The question is a heading, so a screen reader can jump between the six and + the page has an outline. h2's own rhythm belongs to prose sections and + would fight the 24/14 above. */ +.find-q-head h2 { font-size: 16px; font-weight: 600; margin: 0; color: var(--text); } + +.find-opts { display: flex; flex-wrap: wrap; gap: 10px 8px; } + +/* + An option chip. 40px is the floor, not the height: a long gloss wraps and + the chip grows rather than clipping it. The row gap is deliberately larger + than the column gap — equal gaps make wrapped rows read as a grid instead of + as rows. +*/ +.find-opt { + display: inline-flex; + align-items: center; + gap: 9px; + min-height: 40px; + padding: 8px 14px; + border: 1px solid var(--line); + border-radius: var(--radius); + background: var(--raised); + color: var(--dim); + font-size: 13.5px; + text-decoration: none; + transition: background var(--dur) var(--ease), border-color var(--dur) var(--ease); +} + +.find-opt .tick { font-family: var(--mono); font-size: 12px; color: var(--faint); } +.find-opt .count { font-size: 12px; color: var(--faint); } +.find-opt:hover { background: color-mix(in srgb, var(--accent) 8%, var(--raised)); } +.find-opt:focus-visible { outline: 2px solid var(--accent); outline-offset: 2px; } + +/* Chosen: the tint, the ring and the count in the accent, because the number + is the part of the chip that says what answering will return. */ +.find-opt.on { + color: var(--accent); + background: color-mix(in srgb, var(--accent) 12%, transparent); + border-color: color-mix(in srgb, var(--accent) 45%, transparent); +} +.find-opt.on .tick, .find-opt.on .count { color: var(--accent); } + +/* The long tail. A summary is a control, so it gets a control's hit area. */ +.find-tail { margin-top: 10px; } +.find-tail > summary { + cursor: pointer; + display: inline-block; + padding: 6px 10px; + font-size: 12px; + color: var(--faint); + border-radius: var(--radius); +} +.find-tail > summary:hover { color: var(--text); background: var(--raised); } +.find-tail .find-opts { margin-top: 10px; } + +/* ── the name field ─────────────────────────────────────────────────────── + Label above the field, not beside it: beside it the field lost half the + column and a typed name could not be read back. */ + +.find-name { padding: 0 var(--gutter); margin: 0; } +.find-name label { display: block; margin-bottom: 8px; } +.find-name .search-field { max-width: 460px; } + +/* ── the count ──────────────────────────────────────────────────────────── + The outer cell carries the fill and the edge at full row height; the inner + wrapper is what sticks. Splitting the two is what lets the column read as a + column even where the panel is short. */ + +.find-panel { + grid-column: 2; + background: var(--recessed); + border-left: 1px solid var(--line-soft); + min-width: 0; +} + +.find-panel-inner { + position: sticky; + top: 20px; + display: flex; + flex-direction: column; + gap: 14px; + /* 24 at the top so the first line lands on the first question's heading. */ + padding: 24px 22px; +} + +.find-count { display: flex; align-items: baseline; gap: 8px; margin: 0; } + +.find-n { + font-size: 40px; + font-weight: 600; + line-height: 1; + color: var(--accent); + font-variant-numeric: tabular-nums; +} + +.find-noun { font-size: 13.5px; color: var(--dim); } +.find-basis { margin: 0; font-size: 12px; color: var(--faint); } + +.find-chips { display: flex; flex-wrap: wrap; gap: 6px; } + +.find-chip { + display: inline-flex; + align-items: center; + gap: 7px; + padding: 5px 11px; + border: 1px solid var(--line); + border-radius: var(--radius-pill); + background: var(--raised); + color: var(--dim); + font-size: 12px; + text-decoration: none; + max-width: 100%; +} +.find-chip .chip-value { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; } +.find-chip .chip-x { color: var(--faint); } +.find-chip:hover { color: var(--text); border-color: var(--dim); } + +/* + The way out of a combination that returned almost nothing. Quiet on purpose: + no amber, no warning box, no sentence about the result being narrow. The + reader can see the count; this is the one thing they cannot work out. +*/ +.find-loosen { + display: inline-flex; + align-items: center; + gap: 7px; + padding: 8px 12px; + border: 1px dashed var(--line); + border-radius: var(--radius); + color: var(--dim); + font-size: 12.5px; + text-decoration: none; +} +.find-loosen:hover { color: var(--text); border-color: var(--dim); background: var(--raised); } + +/* The one accented control on the page, and it is a link: it navigates to the + listing with this question asked, and nothing here is a form to fire. */ +.find-go { + display: block; + padding: 11px 16px; + border-radius: var(--radius); + border: 1px solid color-mix(in srgb, var(--accent) 55%, transparent); + background: color-mix(in srgb, var(--accent) 14%, transparent); + box-shadow: var(--glow); + color: var(--accent); + font-size: 14px; + font-weight: 600; + text-align: center; + text-decoration: none; +} +.find-go:hover { background: color-mix(in srgb, var(--accent) 22%, transparent); } +.find-go:focus-visible { outline: 2px solid var(--accent); outline-offset: 2px; } + +.find-clear { margin: 0; font-size: 12px; } +.find-clear a { color: var(--faint); } +.find-clear a:hover { color: var(--text); } + +/* + ── the panel, narrow ───────────────────────────────────────────────────── + The drawing has no responsive treatment and cannot be followed here: at + 430px its own grid crushes the question column to 139px while the panel + keeps all 310. So the panel stacks — above the questions, because the count + is the thing the page exists to show and putting it under six questions + would mean scrolling past every one of them to find out what they returned. + It stays sticky at the top of the viewport, which is the same promise the + side column makes at a width that has room for one. +*/ +@media (max-width: 860px) { + .find-grid { grid-template-columns: minmax(0, 1fr); } + .find-questions, .find-panel { grid-column: 1; } + + /* + Below the questions in the visual order because it is below them in the + DOM, and a column that disagrees with the tab order is a worse answer + than a long page. It sticks to the *bottom* instead of the top, which + keeps the same promise from the other end: the count and the submit are + on screen while the last question is being answered, without a reader + having to find them again afterwards. + */ + .find-panel { + border-left: 0; + border-top: 1px solid var(--line-soft); + position: sticky; + bottom: 0; + } + + /* + Laid across rather than down, because a bar pinned to the bottom of a + phone spends every pixel it takes: short controls share a line, so the + whole panel costs four rows with two answers given rather than seven. + + A wrapping row *in document order*, and that part is not cosmetic. This + was a two-column bar with the call to action pinned right and spanning + three rows, which put it first to the eye and fourth to the keyboard: + tabbing ran chips, loosen, then 114px back up the screen to the button. + Flex-wrap packs the same controls in the order they are written, so the + focus ring only ever travels forwards. + */ + .find-panel-inner { + position: static; + display: flex; + /* The base rule stacks; this is the one place the direction changes, and + leaving it out gives a centred column that reads as a broken card. */ + flex-direction: row; + flex-wrap: wrap; + align-items: center; + gap: 8px 12px; + padding: 12px var(--gutter); + } + + /* + The kicker labels a column, and this is a bar. The sub-line beside the + count says the same thing in more words, and the sentence a screen reader + is given — "2 games match every answer" — is untouched, so nothing is + lost that was only being carried here. + */ + .find-panel-inner > .kicker { display: none; } + + .find-chips { flex: 0 1 auto; } + .find-go { padding: 9px 14px; } + .find-n { font-size: 28px; } + + /* + The bar is pinned over the foot of the viewport, and a browser scrolling a + newly focused option into view does not know it is there — so tabbing down + the last question lands the focus ring behind the panel. `scroll-padding` + is the scriptless way to tell it, and `:has` is what keeps the rule on the + one page that has a bar rather than on every scroll on the site. + */ + html:has(.find-page) { scroll-padding-bottom: 200px; } +} diff --git a/tests/MUI.Catalog.Tests/AdultListingTests.cs b/tests/MUI.Catalog.Tests/AdultListingTests.cs index d8b76a0..0a0ed14 100644 --- a/tests/MUI.Catalog.Tests/AdultListingTests.cs +++ b/tests/MUI.Catalog.Tests/AdultListingTests.cs @@ -33,7 +33,13 @@ private static GameFacetRow Row(string slug, string? genre = null, bool adult = Codebase: "Evennia", Family: null, Genre: genre, - IsAdult: adult); + IsAdult: adult, + + // Every game here answered and was counted. The adult switch is what this suite is + // about, and a row that was also uncounted would put a second reason in front of the + // one being asserted. + Uncounted: false, + Unreachable: false); private static readonly GameFacetRow[] Catalogue = [ diff --git a/tests/MUI.Catalog.Tests/FacetPolarityTests.cs b/tests/MUI.Catalog.Tests/FacetPolarityTests.cs index d1988ce..fe6c4a3 100644 --- a/tests/MUI.Catalog.Tests/FacetPolarityTests.cs +++ b/tests/MUI.Catalog.Tests/FacetPolarityTests.cs @@ -173,7 +173,9 @@ private static GameListing Search(GameFilter filter) => Codebase: game.Codebase, Family: null, Genre: null, - IsAdult: false); + IsAdult: false, + Uncounted: false, + Unreachable: false); private static GameSummary Game(string slug, string? codebase) => new( Guid.NewGuid(), slug, slug, null, LifecycleState.Active, IsClaimed: false, diff --git a/tests/MUI.Catalog.Tests/FacetedSearchTests.cs b/tests/MUI.Catalog.Tests/FacetedSearchTests.cs index ea5e2ed..5a26de2 100644 --- a/tests/MUI.Catalog.Tests/FacetedSearchTests.cs +++ b/tests/MUI.Catalog.Tests/FacetedSearchTests.cs @@ -24,7 +24,9 @@ private static GameFacetRow Row( string? charset = null, bool tls = false, DateTimeOffset? lastReachableAt = null, - string[]? protocols = null) + string[]? protocols = null, + bool uncounted = false, + bool unreachable = false) { var summary = new GameSummary( Guid.NewGuid(), slug, slug, Tagline: null, LifecycleState.Active, IsClaimed: false, @@ -43,7 +45,12 @@ private static GameFacetRow Row( // Adult content has its own suite (AdultListingTests). Every row here declares none, so // these counts are taken over the whole set and are not quietly shaped by that default. - IsAdult: false); + IsAdult: false, + + // Both default to false, so a row is a game we reached and counted unless a test says + // otherwise — the ordinary case, and the one every count in this file is taken over. + uncounted, + unreachable); } private static FacetGroup Group(GameListing listing, string key) => @@ -213,7 +220,12 @@ public async Task NeverReachedIsItsOwnBandAndNotTheOldestOne() null), ActivityBand.Dark, FacetedSearch.LastSeenOf(null, Now), - false, null, null, null, null, null, false), + false, null, null, null, null, null, false, + + // Never once reached, so unreachable — and NOT uncounted, because we hold no + // presence row for it at all. Naming a cause for that is what rule 2 forbids. + Uncounted: false, + Unreachable: true), ]; await Assert.That(FacetedSearch.LastSeenOf(null, Now)).IsEqualTo(LastSeenBand.Never); @@ -371,10 +383,145 @@ public async Task OneGamesCapitalisationDoesNotNameAValue() await Assert.That(codebase.Count).IsEqualTo(3); } + // ── what we could measure ──────────────────────────────────────────────────────────────── + + /// <summary> + /// The set these four rows describe, once, so every assertion below is about the same catalogue. + /// </summary> + /// <remarks> + /// <b>The first two are the whole point.</b> <c>zero</c> is a game we got into and counted + /// nobody in, and <c>unreadable</c> is a game we got into and could not count at all. Both sit in + /// <see cref="ActivityBand.Quiet"/> — the band cannot tell them apart, which is why these facets + /// exist — and only the second is uncounted. <c>gone</c> is the third state twice over: never + /// reached, and with nothing measured to be uncounted about. + /// </remarks> + private static GameFacetRow[] Measured() => + [ + Row("zero", band: ActivityBand.Quiet, genre: "Fantasy"), + Row("unreadable", band: ActivityBand.Quiet, genre: "Fantasy", uncounted: true), + Row("busy", genre: "Historical"), + Row("gone", band: ActivityBand.Dark, genre: "Fantasy", + lastReachableAt: Now.AddDays(-90), unreachable: true), + ]; + + [Test] + public async Task AGameMeasuredAtZeroIsNotUncounted() + { + // The failure this facet was written to make impossible. A measured nought is a count — we + // got in and nobody was there (rule 2) — and it shares an activity band with a game whose + // every WHO was past our parser. A filter that returned both under a word meaning the second + // would publish our own parser's limits as somebody's empty game. + var rows = Measured(); + + var uncounted = FacetedSearch.Search(rows, new GameFilter { Uncounted = FacetChoice.Of(FacetTokens.Yes) }); + + await Assert.That(uncounted.Games.Select(g => g.Slug)).IsEquivalentTo(new[] { "unreadable" }); + + // And both are still in the band, which is the band being right rather than the facet being + // redundant with it. + var quiet = FacetedSearch.Search(rows, new GameFilter { Band = ActivityBand.Quiet }); + + await Assert.That(quiet.Games.Select(g => g.Slug)).IsEquivalentTo(new[] { "zero", "unreadable" }); + } + + [Test] + public async Task AGameWeHaveNotMeasuredIsNeitherUncountedNorCounted() + { + // §5.4's third state, which names no cause. `gone` has no presence rows at all, so it is not + // uncounted — the facet says "we tried and could not read", and claiming that of a game we + // never got into would be the same fabrication in the other direction. + var rows = Measured(); + + var uncounted = FacetedSearch.Search(rows, new GameFilter { Uncounted = FacetChoice.Of(FacetTokens.Yes) }); + var unreachable = FacetedSearch.Search(rows, new GameFilter { Unreachable = FacetChoice.Of(FacetTokens.Yes) }); + + await Assert.That(uncounted.Games.Any(g => g.Slug == "gone")).IsFalse(); + await Assert.That(unreachable.Games.Select(g => g.Slug)).IsEquivalentTo(new[] { "gone" }); + } + + [Test] + public async Task TheTwoSwitchesComposeWithEachOtherAndWithAnUnrelatedFacet() + { + // The reason they are two FacetChoices rather than two values of `band`: a reader narrowing + // by genre has to be able to drop both kinds of unmeasured game without spending the one + // selection `band` has. Three questions at once, and all three applied. + var rows = Measured(); + + var listing = FacetedSearch.Search(rows, new GameFilter + { + Genre = FacetChoice.Of("Fantasy"), + Uncounted = FacetChoice.Not(FacetTokens.Yes), + Unreachable = FacetChoice.Not(FacetTokens.Yes), + }); + + // Fantasy, minus the one we could not read and the one we could not reach — leaving the + // measured nought, which is a game we counted and must survive both exclusions. + await Assert.That(listing.Games.Select(g => g.Slug)).IsEquivalentTo(new[] { "zero" }); + } + + [Test] + public async Task ExcludingBothStillLeavesAListingThatExplainsItself() + { + // Hiding is a decision about the listing, so the controls that made it have to stay + // reachable — a selection whose only affordance has vanished is the defect the whole panel + // was rebuilt to remove. Both rows survive at the count their own selection returns. + var rows = Measured(); + + var listing = FacetedSearch.Search(rows, new GameFilter + { + Uncounted = FacetChoice.Not(FacetTokens.Yes), + Unreachable = FacetChoice.Not(FacetTokens.Yes), + }); + + await Assert.That(listing.Games.Select(g => g.Slug)).IsEquivalentTo(new[] { "zero", "busy" }); + + foreach (var key in new[] { FacetKeys.Uncounted, FacetKeys.Unreachable }) + { + var value = Value(listing, key, FacetTokens.Yes); + + await Assert.That(value.State).IsEqualTo(FacetState.Excluded); + await Assert.That(value.Count).IsEqualTo(1); + } + } + + [Test] + public async Task TheCountBesideEachSwitchIsWhatChoosingItReturns() + { + // The panel's own promise, made over the set that has both hard states in it. The generic + // walk above covers this too; this one names the facets, so a change that made the counts + // fall out of a wider denominator fails here with the right words on it. + var rows = Measured(); + var listing = FacetedSearch.Search(rows, new GameFilter()); + + foreach (var key in new[] { FacetKeys.Uncounted, FacetKeys.Unreachable }) + { + var value = Value(listing, key, FacetTokens.Yes); + + await Assert.That(value.Count).IsEqualTo(1); + await Assert.That(FacetedSearch.Search(rows, Choose(key, value.Token)).Games.Count) + .IsEqualTo(value.Count); + } + } + + [Test] + public async Task ASwitchNothingMatchesIsNotDrawnAtAll() + { + // A bounded facet keeps every rung of a scale, because a scale with a rung missing is not + // the same scale. This is not a scale — it is one fact, held or not — so a catalogue we + // could count and reach in full offers no control, which is the honest rendering of a + // measurement with nothing in it. + var listing = FacetedSearch.Search([Row("busy"), Row("also")], new GameFilter()); + + await Assert.That(listing.Facets.Any(f => f.Key == FacetKeys.Uncounted)).IsFalse(); + await Assert.That(listing.Facets.Any(f => f.Key == FacetKeys.Unreachable)).IsFalse(); + } + private static GameFilter Choose(string key, string token) => key switch { FacetKeys.Band => new GameFilter { Band = Band(token) }, FacetKeys.LastSeen => new GameFilter { LastSeen = Seen(token) }, + FacetKeys.Uncounted => new GameFilter { Uncounted = FacetChoice.Parse(token) }, + FacetKeys.Unreachable => new GameFilter { Unreachable = FacetChoice.Parse(token) }, FacetKeys.Protocol => new GameFilter { MeasuredProtocols = [token] }, FacetKeys.Tls => new GameFilter { Tls = true }, FacetKeys.Charset => new GameFilter { Charset = FacetChoice.Parse(token) }, diff --git a/tests/MUI.Catalog.Tests/Persistence/FacetQueriesPostgresTests.cs b/tests/MUI.Catalog.Tests/Persistence/FacetQueriesPostgresTests.cs index 3ebf947..53ea769 100644 --- a/tests/MUI.Catalog.Tests/Persistence/FacetQueriesPostgresTests.cs +++ b/tests/MUI.Catalog.Tests/Persistence/FacetQueriesPostgresTests.cs @@ -280,10 +280,116 @@ await Assert.That(games.Count) } } + [Test] + public async Task AMeasuredZeroIsNotUncountedAndTheBandCannotTellThemApart() + { + // The one this facet exists for, against the reader that actually computes it. + // + // Both games are reachable, both have no count above nought this week, and both therefore + // land in `quiet` — the band is one threshold and cannot say why. `empty` was probed and + // answered nought, which is a measurement of theirs; `unreadable` was probed and produced no + // number, which is a limit of ours. Returning the first under a word meaning the second is + // rules 2, 4 and 5 in one control, and the digest threw the distinction away until now. + await using var db = await PostgresFixture.MigratedAsync(); + var empty = await Seed.GameAsync(db, "empty", "Measured empty", lastReachableAt: Now); + var unreadable = await Seed.GameAsync(db, "unreadable", "Unreadable", lastReachableAt: Now); + var writer = new PresenceWriter(new NpgsqlPresenceStore(db.DataSource)); + + // Three probes each, over the same hours, differing only in what came back. + foreach (var hours in new[] { 1, 20, 60 }) + { + await writer.WriteAsync( + empty, PresenceReading.Counted(0, FieldSource.Who), Now.AddHours(-hours)); + await writer.WriteAsync( + unreadable, + PresenceReading.Unmeasurable(UnmeasurableReason.WhoUnparseable), + Now.AddHours(-hours)); + } + + var queries = QueriesOn(db); + + var quiet = await queries.ListAsync(new GameFilter { Band = ActivityBand.Quiet }); + await Assert.That(quiet.Select(g => g.Slug)).IsEquivalentTo(new[] { "empty", "unreadable" }); + + var uncounted = await queries.ListAsync( + new GameFilter { Uncounted = FacetChoice.Of(FacetTokens.Yes) }); + await Assert.That(uncounted.Select(g => g.Slug)).IsEquivalentTo(new[] { "unreadable" }); + + // And the count each game's row carries agrees: nought is a number, and the other is null. + var listed = await queries.ListAsync(new GameFilter()); + await Assert.That(listed.Single(g => g.Id == empty).PlayersNow).IsEqualTo(0); + await Assert.That(listed.Single(g => g.Id == unreadable).PlayersNow).IsNull(); + } + + [Test] + public async Task AGameWithNoPresenceRowsAtAllIsNotUncounted() + { + // §5.4's third state. A probe that failed writes no presence row (`PresenceWriter`), so a + // game with nothing stored is one we did not measure — and "we tried and could not read it" + // is a cause, which that state may not be given. It is unreachable instead, from the + // availability series, which can tell the two apart. + await using var db = await PostgresFixture.MigratedAsync(); + await Seed.GameAsync(db, "never", "Never answered", lastReachableAt: null); + var probed = await Seed.GameAsync(db, "probed", "Probed", lastReachableAt: Now); + var writer = new PresenceWriter(new NpgsqlPresenceStore(db.DataSource)); + + await writer.WriteAsync( + probed, PresenceReading.Unmeasurable(UnmeasurableReason.WhoLoginPrompt), Now.AddHours(-2)); + + var queries = QueriesOn(db); + + await Assert.That( + (await queries.ListAsync(new GameFilter { Uncounted = FacetChoice.Of(FacetTokens.Yes) })) + .Select(g => g.Slug)) + .IsEquivalentTo(new[] { "probed" }); + + await Assert.That( + (await queries.ListAsync(new GameFilter { Unreachable = FacetChoice.Of(FacetTokens.Yes) })) + .Select(g => g.Slug)) + .IsEquivalentTo(new[] { "never" }); + } + + [Test] + public async Task TheTwoSwitchesNarrowTogetherAndTheCountsSayWhatTheyReturn() + { + // Orthogonal, and orthogonal to the rest of the panel: excluding both leaves the games we + // measured, with the two controls still drawn so the reader can undo what they did. + await using var db = await PostgresFixture.MigratedAsync(); + var counted = await Seed.GameAsync(db, "counted", "Counted", lastReachableAt: Now); + var unreadable = await Seed.GameAsync(db, "unreadable", "Unreadable", lastReachableAt: Now); + await Seed.GameAsync(db, "gone", "Gone", lastReachableAt: Now.AddDays(-90)); + var writer = new PresenceWriter(new NpgsqlPresenceStore(db.DataSource)); + + await writer.WriteAsync(counted, PresenceReading.Counted(4, FieldSource.Who), Now.AddHours(-1)); + await writer.WriteAsync( + unreadable, PresenceReading.Unmeasurable(UnmeasurableReason.I3NoReply), Now.AddHours(-1)); + + var queries = QueriesOn(db); + + var kept = await queries.SearchAsync(new GameFilter + { + Uncounted = FacetChoice.Not(FacetTokens.Yes), + Unreachable = FacetChoice.Not(FacetTokens.Yes), + }); + + await Assert.That(kept.Games.Select(g => g.Slug)).IsEquivalentTo(new[] { "counted" }); + + foreach (var key in new[] { FacetKeys.Uncounted, FacetKeys.Unreachable }) + { + var value = Group(kept, key)!.Values.Single(v => v.Token == FacetTokens.Yes); + + await Assert.That(value.State).IsEqualTo(FacetState.Excluded); + await Assert.That((await queries.ListAsync(Choose(key, value.Token))).Count) + .IsEqualTo(value.Count); + } + } + private static GameFilter Choose(string key, string token) => key switch { FacetKeys.Band => new GameFilter { Band = Band(token) }, FacetKeys.LastSeen => new GameFilter { LastSeen = Seen(token) }, + FacetKeys.Uncounted => new GameFilter { Uncounted = FacetChoice.Parse(token) }, + FacetKeys.Unreachable => new GameFilter { Unreachable = FacetChoice.Parse(token) }, FacetKeys.Protocol => new GameFilter { MeasuredProtocols = [token] }, FacetKeys.Tls => new GameFilter { Tls = true }, FacetKeys.Charset => new GameFilter { Charset = FacetChoice.Parse(token) }, diff --git a/tests/MUI.Web.Tests/AboutPageTests.cs b/tests/MUI.Web.Tests/AboutPageTests.cs index 2f6d462..9e8b1b2 100644 --- a/tests/MUI.Web.Tests/AboutPageTests.cs +++ b/tests/MUI.Web.Tests/AboutPageTests.cs @@ -10,6 +10,7 @@ using MUI.Discovery; using MUI.Web.Api; using MUI.Web.Components; +using MUI.Web.Localization; namespace MUI.Web.Tests; @@ -34,6 +35,21 @@ public class AboutPageTests private static string Plain => PlainText.RenderAbout(Page); + /// <summary> + /// The English a message id carries, which is what this page is asserted against. + /// </summary> + /// <remarks> + /// The copy lives in <see cref="Messages"/> now, so a sentence pasted into a test would be a + /// third copy of it — and the one nothing checks. Asking the bundle asserts the fact this page + /// makes a claim about ("the archive-grace limitation is stated") rather than the spelling of + /// it, and still fails if the id stops reaching the page. Where a claim is a <em>rule</em> + /// rather than a sentence — the refusal to say "no automated opt-out" — the literal stays, + /// because there the wording is the rule. A rule about the site's <em>vocabulary</em> is the one + /// case where a literal on this page is wrong: it belongs over the whole bundle in every locale, + /// which is where <see cref="NoMessageOutsideTheseTwoRefusalsUsesTheWordUptime"/> puts it. + /// </remarks> + private static string Says(string id) => Messages.For(Locales.SourceTag, id); + [Test] public async Task EveryDirectoryTheBackfillReadIsCreditedByNameAndByAddress() { @@ -59,13 +75,17 @@ public async Task ASourceWeChoseNotToFetchIsCreditedAndSaidToBeUnread() var mudverse = Page.Sources.Single(s => s.Name == "MudVerse"); await Assert.That(mudverse.State).IsEqualTo(ImportSourceState.Withheld); - await Assert.That(Plain).Contains("not read — awaiting permission"); + await Assert.That(Plain).Contains(Says("about.source.withheld")); + + // And the badge for one we did read is a different string, not a negation of this one: a + // reader meets the difference between "we chose not to" and "we could not" only here. + await Assert.That(Says("about.source.read")).IsNotEqualTo(Says("about.source.withheld")); } [Test] public async Task TheAttributionSaysAddressesOnlyAndSaysWhy() { - await Assert.That(Render.Words(Plain)).Contains("We take addresses. Nothing else."); + await Assert.That(Render.Words(Plain)).Contains(Says("about.sources.addresses.lead")); await Assert.That(Render.Words(Plain)).Contains("No player counts"); await Assert.That(Render.Words(Plain)).Contains("no reachability history"); } @@ -131,12 +151,13 @@ public async Task AnUnconfiguredContactAddressIsMarkedAsThePlaceholderItIs() { // The built-in URL is on a domain nobody has chosen. Printed unmarked it would read as the // way to reach us, which is the one thing this section exists to provide. - await Assert.That(Render.Words(Plain)).Contains("is a placeholder and answers nobody"); + await Assert.That(Render.Words(Plain)).Contains(Says("about.identity.placeholder.plain")); var configured = PlainText.RenderAbout(AboutPage.Build( new ProbeOptions { InfoUrl = "https://example.test/crawler" }, new DatasetLicenceOptions())); - await Assert.That(Render.Words(configured)).DoesNotContain("is a placeholder and answers nobody"); + await Assert.That(Render.Words(configured)) + .DoesNotContain(Says("about.identity.placeholder.plain")); } [Test] @@ -182,7 +203,7 @@ public async Task ThePoliteAndSecurityFactsAboutAProbeSurvive() { var text = Render.Words(Plain); - await Assert.That(text).Contains("CRAWL DELAY wins."); + await Assert.That(text).Contains(Says("about.crawler.delay.lead")); await Assert.That(text).Contains("resolved before anything is dialled"); await Assert.That(text).Contains("globally routable"); } @@ -203,27 +224,87 @@ public async Task TheMeasuredSpineSurvivesInWords() { var text = Render.Words(Plain); - await Assert.That(text).Contains("Measured beats declared, and both are shown."); + await Assert.That(text).Contains(Says("about.measures.declared.lead")); await Assert.That(text).Contains("MSSP PLAYERS field"); await Assert.That(text).Contains("WHO or DOING read at the connect screen"); await Assert.That(text).Contains("unknown, never zero"); } + /// <summary> + /// The page explains what reachability is, in whatever language it is being read in. + /// </summary> + /// <remarks> + /// <para> + /// <b>This used to count the English word "uptime" and require exactly two of it.</b> That was a + /// reasonable guard while the page was a C# string and an unreasonable one the moment it became + /// a translation: a Japanese or Chinese rendering of the same two refusals contains the token + /// zero times and would fail, and a German one contains it twice by a coincidence of loanwords + /// rather than because the rule held. Worse, the assertion made the *presence* of the forbidden + /// word the thing under test, so the page's vocabulary rule was guarded by requiring the + /// vocabulary to be broken. + /// </para> + /// <para> + /// The rule survives, split from the spelling. Here: the two refusal ids reach the page, asked + /// of the bundle, so this holds in every locale. And in + /// <see cref="NoMessageOutsideTheseTwoRefusalsUsesTheWordUptime"/>: the word appears in no other + /// message, in no locale — which is the rule itself ("reachable, never uptime", in copy), + /// checked over the whole bundle rather than inferred from one page's word count. + /// </para> + /// </remarks> [Test] - public async Task ReachableIsExplainedAndNeverCalledUptimeExceptToRefuseTheWord() + public async Task ReachableIsExplainedInWhateverLanguageThePageIsRead() { var text = Render.Words(Plain); - await Assert.That(text).Contains("Reachable, never uptime."); + await Assert.That(text).Contains(Says("about.measures.reachable.lead")); + await Assert.That(text).Contains(Says("about.measures.reachable.body")); - // The word appears twice and both are refusals. Anything else would be the site's own - // vocabulary rule broken on the page that states it. - var uses = Regex.Matches(text, "uptime", RegexOptions.IgnoreCase).Count; - await Assert.That(uses).IsEqualTo(2); + // The substance of the refusal, which is what the rule is for: the measurement is of our + // socket from our host, and an unreachable game may be perfectly alive. await Assert.That(text).Contains("unreachable and perfectly alive"); await Assert.That(text).Contains("nothing here measured it"); } + /// <summary> + /// "Reachable, never uptime" — over the bundle, in every locale, rather than over one page. + /// </summary> + /// <remarks> + /// The two about-page ids are the whole exemption: they are the sentences that name the word in + /// order to refuse it, and they are the only place on the site allowed to. Every other id is + /// checked in every bundle a reader can be served, so a translator who reaches for the loanword + /// in a reachability string fails this rather than shipping it — which a rendered-English word + /// count could never have caught. + /// </remarks> + [Test] + public async Task NoMessageOutsideTheseTwoRefusalsUsesTheWordUptime() + { + string[] refusals = ["about.measures.reachable.lead", "about.measures.reachable.body"]; + + var tags = Locales.All + .Select(locale => locale.Tag) + .Append(Locales.SourceTag) + .Distinct(StringComparer.OrdinalIgnoreCase) + .ToArray(); + + await Assert.That(tags).IsNotEmpty(); + + foreach (var tag in tags) + { + foreach (var id in Messages.Ids.Except(refusals, StringComparer.Ordinal)) + { + var pattern = Messages.Pattern(tag, id) ?? string.Empty; + + await Assert.That(pattern.Contains("uptime", StringComparison.OrdinalIgnoreCase)) + .IsFalse() + .Because($"{id} says \"uptime\" in {tag}; the word here is reachable"); + } + } + + // And the exemption is real rather than vacuous: the English refusals do use the word, which + // is what makes them refusals and not silence. + await Assert.That(Says("about.measures.reachable.lead").ToLowerInvariant()).Contains("uptime"); + } + [Test] public async Task TheThingsThisSiteWillNotDoAreStatedRatherThanImplied() { @@ -231,10 +312,10 @@ public async Task TheThingsThisSiteWillNotDoAreStatedRatherThanImplied() // they are absent. PlainParityTests asserts the opposite about every other surface. var text = Render.Words(Plain); - await Assert.That(text).Contains("No votes, stars, ratings or recommendations"); - await Assert.That(text).Contains("No forums, reviews, wikis, comments or player profiles"); - await Assert.That(text).Contains("Player names are never persisted."); - await Assert.That(text).Contains("No absolute population figure is published."); + await Assert.That(text).Contains(Says("about.never.votes.lead")); + await Assert.That(text).Contains(Says("about.never.forums.lead")); + await Assert.That(text).Contains(Says("about.never.names.lead")); + await Assert.That(text).Contains(Says("about.never.population.lead")); } [Test] @@ -242,7 +323,7 @@ public async Task TheDataLicenceIsPresentedAsUndecidedRatherThanAsSettled() { var text = Render.Words(Plain); - await Assert.That(text).Contains("The code is MIT."); + await Assert.That(text).Contains(Says("about.licence.code.lead")); await Assert.That(text).Contains("licence for the data is an open question"); await Assert.That(text).Contains("not yet taken"); @@ -295,6 +376,58 @@ public async Task TheGraphicalPageCarriesEverySentenceThePlainOneDoes() } } + /// <summary> + /// Every sentence on this page comes out of the bundle, and the machine voice does not. + /// </summary> + /// <remarks> + /// <para> + /// The pseudolocale accents and brackets every string that reached a reader through + /// <see cref="Messages"/>, so anything still legible as English here is a sentence typed into a + /// page — which is what the whole of this page was until it was moved. This was the largest + /// untranslated surface on the site, and the one it would be worst to leave: it is where the + /// site explains what a measurement here proves, to a reader who by definition does not yet + /// trust it. + /// </para> + /// <para> + /// The directories' names and addresses go the other way. They are somebody else's name and + /// somebody else's URL, they are the credit §7.6 owes, and translating either would destroy the + /// acknowledgement rather than localize it — so they are asserted to be <em>unchanged</em>. + /// </para> + /// </remarks> + [Test] + public async Task EverySentenceComesFromTheBundleAndTheDirectoriesOwnNamesDoNot() + { + var page = AboutPage.Build(new ProbeOptions(), new DatasetLicenceOptions(), "qps-ploc"); + var pseudo = PlainText.RenderAbout(page, "qps-ploc"); + + await Assert.That(pseudo).Contains("⟦"); + + foreach (var section in Page.Sections) + { + await Assert.That(pseudo) + .DoesNotContain(section.Heading) + .Because($"the {section.Id} heading never went through the message pipeline"); + + foreach (var point in section.Points) + { + await Assert.That(pseudo) + .DoesNotContain(point.Lead) + .Because($"a point in {section.Id} is hard-coded English"); + } + } + + // The crawler's own name and the licence a deployment configured are machine voice too, and + // are read off the objects that own them rather than out of the bundle. + await Assert.That(pseudo).Contains(page.Sections.Single(s => s.Id == "crawler").Identity!.Name); + await Assert.That(pseudo).Contains(new DatasetLicenceOptions().LicenceName); + + foreach (var source in Page.Sources) + { + await Assert.That(pseudo).Contains(source.Name); + await Assert.That(pseudo).Contains(source.Url); + } + } + [Test] public async Task TheGraphicalPageIsReachableWithoutScriptingAndSaysHowToReadItPlainly() { diff --git a/tests/MUI.Web.Tests/AccountSurfaceTests.cs b/tests/MUI.Web.Tests/AccountSurfaceTests.cs index 173d0b8..c8df4ef 100644 --- a/tests/MUI.Web.Tests/AccountSurfaceTests.cs +++ b/tests/MUI.Web.Tests/AccountSurfaceTests.cs @@ -1,3 +1,4 @@ +using System.Globalization; using System.Security.Claims; using System.Text.RegularExpressions; @@ -15,8 +16,10 @@ using MUI.Catalog.Persistence; using MUI.Web; using MUI.Web.Accounts; +using MUI.Web.Components; using MUI.Web.Components.Pages; using MUI.Web.Fixtures; +using MUI.Web.Localization; namespace MUI.Web.Tests; @@ -64,11 +67,123 @@ public async Task WithNoDatabaseThePageSaysAccountsNeedOne() var body = Render.Words(await host.Client.GetStringAsync("/account")); - await Assert.That(body).Contains("Accounts need a database"); - await Assert.That(body).DoesNotContain("Sign in"); - await Assert.That(body).DoesNotContain("give up this claim"); + // The fact, through the bundle, rather than a pasted sentence: the claim is that this page + // says the one thing and offers neither the way in nor a write surface, and it goes on + // being that claim when somebody rewords the copy. + await Assert.That(body).Contains(En("account.noDatabase")); + await Assert.That(body).DoesNotContain(En("account.signInButton")); + await Assert.That(body).DoesNotContain(En("account.resign.summary")); } + /// <summary>One message in the source language, as it reads once rendered.</summary> + private static string En(string id) => Render.Words(Messages.For(Locales.SourceTag, id)); + + /// <summary> + /// A placed sentence in the source language, with its slots filled as the page fills them. + /// </summary> + /// <remarks> + /// <see cref="Sentence.Place"/> hands back runs and markers so the markup can choose an element + /// per slot; a test wants the sentence a reader ends up with. Reassembling it here means these + /// assertions read the same bundle the page does — the alternative is a pasted English string, + /// which is exactly what this pass exists to remove. + /// </remarks> + private static string EnPlaced( + string id, + IReadOnlyDictionary<string, string> fills, + params (string Key, object? Value)[] args) => + Render.Words(string.Concat(Sentence + .Place(Locales.SourceTag, id, [.. fills.Keys], args) + .Select(part => part.Slot is null ? part.Text : fills[part.Slot]))); + + /// <summary> + /// Every word of the sign-in page comes out of the message bundle. + /// </summary> + /// <remarks> + /// <para> + /// Both branches, because they are two different pages: over the demo fixture it is one sentence + /// saying there is nothing to sign in to, and behind a database it is the whole passkey + /// explanation — and the second was never rendered by any test at all, so it could have drifted + /// into English without anything noticing. + /// </para> + /// <para> + /// The pseudolocale is the instrument: it accents and brackets anything that reached a reader + /// through <see cref="Messages"/>, so an English sentence surviving here is one typed into the + /// markup. Asserted against the English render rather than against pasted strings, so this keeps + /// holding when the copy is edited. + /// </para> + /// </remarks> + [Test] + [Arguments(true)] + [Arguments(false)] + public async Task EveryWordOfSigningInComesFromTheBundle(bool withDatabase) + { + var english = Render.Words(await SignInAsync(Locales.SourceTag, withDatabase)); + var pseudo = Render.Words(await SignInAsync("qps-ploc", withDatabase)); + + await Assert.That(pseudo).Contains("⟦"); + + // Which page this is, asserted rather than assumed: a harness that failed to register + // identity would render the one-sentence branch twice and the loop below would pass on a + // page nobody had looked at. + await Assert.That(english.Contains( + Messages.For(Locales.SourceTag, "account.store.heading"), StringComparison.Ordinal)) + .IsEqualTo(withDatabase); + + await Assert.That(english.Contains( + Messages.For(Locales.SourceTag, "account.signIn.noDatabase"), StringComparison.Ordinal)) + .IsEqualTo(!withDatabase); + + // Every sentence of the English page, absent from the same page in another language. + // + // Argument-free ids only, and that costs this sweep nothing: the sign-in page says no + // message that takes one. The `account.` prefix now also covers the owner dashboard, whose + // sentences name a game, a date or a count — and a pattern cannot be rendered at all + // without its arguments, so including them here would throw rather than assert. + foreach (var id in Sayable("account.")) + { + var sentence = Render.Words(Messages.For(Locales.SourceTag, id)); + + if (!english.Contains(sentence, StringComparison.Ordinal)) + { + continue; + } + + await Assert.That(pseudo) + .DoesNotContain(sentence) + .Because($"{id} is rendered as English whatever language the page was asked for"); + } + } + + /// <summary> + /// The sign-in page, in one locale, with or without a database behind it. + /// </summary> + /// <remarks> + /// The locale arrives the way the middleware leaves it — in <c>HttpContext.Items</c> — because + /// that is what the page reads. Identity is registered only for the second case, which is + /// exactly the condition the page itself branches on. + /// </remarks> + private static Task<string> SignInAsync(string tag, bool withDatabase) => + Render.ComponentAsync<MUI.Web.Components.Pages.SignIn>([], services => + { + services.AddLogging(); + services.AddSingleton(new MUI.Web.Data.CatalogueSource(IsMeasured: withDatabase)); + + var context = new DefaultHttpContext(); + context.Items[LocaleRouting.ItemKey] = + new LocaleContext(Locales.Find(tag)!, FromPath: tag != Locales.SourceTag); + services.AddCascadingValue(_ => context); + + if (!withDatabase) + { + return; + } + + services.AddHttpContextAccessor(); + services.AddAuthentication(); + services.AddSingleton<IUserStore<MuiUser>>(new Accounts([], FixtureGameQueries.Now)); + services.AddIdentityCore<MuiUser>().AddSignInManager(); + }); + /// <summary>A signed-out visitor is offered the way in and nothing else.</summary> [Test] public async Task ASignedOutVisitorIsOfferedSignInAndNoWriteSurface() @@ -77,7 +192,7 @@ public async Task ASignedOutVisitorIsOfferedSignInAndNoWriteSurface() await Assert.That(markup).Contains("/account/sign-in"); await Assert.That(markup).DoesNotContain("<form"); - await Assert.That(Render.Words(markup)).DoesNotContain("Claimed"); + await Assert.That(Render.Words(markup)).DoesNotContain(En("account.claimed.heading")); } /// <summary>An account with nothing claimed is told where to start.</summary> @@ -87,9 +202,20 @@ public async Task AnAccountWithNoClaimsIsPointedAtTheListing() var markup = await World.New().SignedIn().RenderAsync(); var words = Render.Words(markup); - await Assert.That(words).Contains("You have not claimed anything yet"); + // The whole sentence, reassembled from the bundle including the two runs the markup turns + // into a link and an emphasis — so this holds on the words a reader gets rather than on + // the fragments the markup happens to be split into. Read off the visible text, because a + // placed sentence has elements inside it. + await Assert.That(Render.Text(markup)).Contains(EnPlaced( + "account.empty.body", + new Dictionary<string, string>(StringComparer.Ordinal) + { + ["listing"] = En("account.empty.listing"), + ["claimControl"] = En("account.empty.claimControl"), + })); + await Assert.That(words).Contains("/games"); - await Assert.That(words).DoesNotContain("Waiting on a token"); + await Assert.That(words).DoesNotContain(En("account.pending.heading")); await Assert.That(markup).DoesNotContain("resign"); } @@ -100,11 +226,11 @@ public async Task APendingClaimLinksToItsToken() var markup = await World.New().SignedIn().Pending(Mush).RenderAsync(); var words = Render.Words(markup); - await Assert.That(words).Contains("Waiting on a token"); + await Assert.That(words).Contains(En("account.pending.heading")); await Assert.That(markup).Contains("/g/m-u-s-h/claim"); // Pending is not owning: none of the owner surfaces appear for it. - await Assert.That(words).DoesNotContain("Claimed"); + await Assert.That(words).DoesNotContain(En("account.claimed.heading")); await Assert.That(markup).DoesNotContain("badge.svg"); } @@ -122,7 +248,7 @@ public async Task AVerifiedClaimShowsEverythingAClaimGrants() var markup = await World.New().SignedIn().Verified(Ashen).RenderAsync(); var words = Render.Words(markup); - await Assert.That(words).Contains("Claimed"); + await Assert.That(words).Contains(En("account.claimed.heading")); await Assert.That(markup).Contains("/g/ashen-court"); // §8.5's enrichment, through OwnerPanel. @@ -136,7 +262,7 @@ public async Task AVerifiedClaimShowsEverythingAClaimGrants() await Assert.That(markup).Contains("/g/ashen-court/mssp"); await Assert.That(markup).Contains("/g/ashen-court/badge.svg"); await Assert.That(markup).Contains("/g/ashen-court/badge.json"); - await Assert.That(words).Contains("history"); + await Assert.That(words).Contains(En("account.history.summary")); await Assert.That(markup).Contains("/resign"); } @@ -185,11 +311,19 @@ public async Task ACoOwnedGameNamesTheOtherOwners() var markup = await World.New().SignedIn().Verified(Ashen).CoOwnedBy("thistle").RenderAsync(); var words = Render.Words(markup); - await Assert.That(words).Contains("Also owned by thistle"); - await Assert.That(words).Contains("verified a token of their own"); + // One co-owner, so the message's `one` branch — which is a different sentence from the + // plural in English and in most languages, and naming the branch is the point. + await Assert.That(words).Contains( + Render.Words(Messages.Say( + Locales.SourceTag, "account.claim.coOwners", ("count", 1), ("names", "thistle")))); // The resign copy is the one that differs when somebody else holds the game too. - await Assert.That(words).Contains("the game stays claimed if anybody else owns it"); + await Assert.That(Render.Text(markup)).Contains(EnPlaced( + "account.resign.confirm", + new Dictionary<string, string>(StringComparer.Ordinal) + { + ["word"] = OwnershipWrites.ResignConfirmation, + })); } /// <summary>A sole owner sees no co-owner line at all.</summary> @@ -198,7 +332,10 @@ public async Task ASoleOwnerIsNotToldAboutOwnersWhoDoNotExist() { var words = Render.Words(await World.New().SignedIn().Verified(Ashen).RenderAsync()); - await Assert.That(words).DoesNotContain("Also owned by"); + // The whole rendered line for one co-owner, which cannot appear when there are none. + await Assert.That(words).DoesNotContain( + Render.Words(Messages.Say( + Locales.SourceTag, "account.claim.coOwners", ("count", 1), ("names", "thistle")))); } // ── the status banner ───────────────────────────────────────────────────── @@ -213,11 +350,15 @@ public async Task ASoleOwnerIsNotToldAboutOwnersWhoDoNotExist() /// branch — so every arm is driven here, by the querystring the redirect actually carries. /// </remarks> [Test] - [Arguments("?saved={game}&did=fields", "now shows it as owner-declared")] - [Arguments("?saved={game}&did=screen-hidden", "stopped republishing")] - [Arguments("?saved={game}&did=screen-shown", "connect screen is on its page again")] - [Arguments("?resigned=1", "Given up.")] - [Arguments("?refused=CODEBASE&because=NotEnrichable", "CODEBASE was not changed")] + [Arguments("?saved={game}&did=fields", "account.saved.fields")] + [Arguments("?saved={game}&did=screen-hidden", "account.saved.screenHidden")] + [Arguments("?saved={game}&did=screen-shown", "account.saved.screenShown")] + [Arguments("?saved={game}&did=crawl-stopped", "account.saved.crawlStopped")] + [Arguments("?saved={game}&did=crawl-resumed", "account.saved.crawlResumed")] + [Arguments("?saved={game}&did=unlisted", "account.saved.unlisted")] + [Arguments("?saved={game}&did=relisted", "account.saved.relisted")] + [Arguments("?resigned=1", "account.resigned.lead")] + [Arguments("?refused=CODEBASE&because=NotEnrichable", "account.refused.lead")] public async Task EveryOutcomeReportsTheActionThatHappened(string query, string expected) { var words = Render.Words(await World.New() @@ -225,9 +366,19 @@ public async Task EveryOutcomeReportsTheActionThatHappened(string query, string .Verified(Ashen) .RenderAsync(query.Replace("{game}", Ashen.ToString(), StringComparison.Ordinal))); - await Assert.That(words).Contains(expected); + // The id rather than a pasted fragment, so a reworded banner still has to be the banner for + // the action that happened. The four §11 and listing arms were added to OwnerWrites and + // never to this table, which is the exact omission the remark above describes — the switch + // had already reported the wrong branch once for the same reason. + // + // Both arguments are supplied to every arm; a pattern that names neither ignores them. + await Assert.That(words).Contains(Render.Words(Messages.Say( + Locales.SourceTag, expected, ("game", AshenName), ("field", "CODEBASE")))); } + /// <summary>The fixture game's own name, which the banner quotes and never translates.</summary> + private const string AshenName = "Ashen Court"; + /// <summary> /// Two outcomes at once is one banner, and it is the one the chain says it is. /// </summary> @@ -244,12 +395,154 @@ public async Task ACraftedUrlCarryingTwoOutcomesStillReportsOnlyOne() .Verified(Ashen) .RenderAsync($"?resigned=1&saved={Ashen}&did=fields&refused=CODEBASE")); - await Assert.That(words).Contains("Given up."); - await Assert.That(words).DoesNotContain("now shows it as owner-declared"); - await Assert.That(words).DoesNotContain("was not changed"); + await Assert.That(words).Contains(En("account.resigned.lead")); + await Assert.That(words).DoesNotContain(Render.Words( + Messages.Say(Locales.SourceTag, "account.saved.fields", ("game", AshenName)))); + await Assert.That(words).DoesNotContain(Render.Words( + Messages.Say(Locales.SourceTag, "account.refused.lead", ("field", "CODEBASE")))); + } + + // ── the language the dashboard is answered in ───────────────────────────── + + /// <summary> + /// Every word of the dashboard comes out of the bundle, on the fullest page it has. + /// </summary> + /// <remarks> + /// <para> + /// The pseudolocale is the instrument, as it is for the sign-in page: it accents and brackets + /// anything that reached a reader through <see cref="Messages"/>, so an English sentence + /// surviving here is one somebody typed into the markup. Driven on a verified claim with a + /// co-owner and a banner, because that is the state that renders the owner panel, the badge + /// block, the audit log and the resignation form — most of this page's words are in there. + /// </para> + /// <para> + /// What stays English is named rather than tolerated: a game's name, an operator's chosen + /// display name, a field name out of the registry, the confirmation word the form compares + /// against, the badge's own text and an ISO stamp. Every one of those is machine voice, and + /// translating any of them would break the thing it names. + /// </para> + /// </remarks> + [Test] + public async Task EveryWordOfTheDashboardComesFromTheBundle() + { + var english = Render.Text(await Full(Locales.SourceTag)); + var pseudo = Render.Text(await Full("qps-ploc")); + + await Assert.That(pseudo).Contains("⟦"); + + // The page really is the full one, rather than a guard branch rendered twice. + await Assert.That(english).Contains(En("account.claimed.heading")); + await Assert.That(english).Contains(En("owner.crawl.heading")); + + foreach (var id in Sayable("account.", "owner.")) + { + var sentence = Render.Words(Messages.For(Locales.SourceTag, id)); + + if (!english.Contains(sentence, StringComparison.Ordinal)) + { + continue; + } + + await Assert.That(pseudo) + .DoesNotContain(sentence) + .Because($"{id} is rendered as English whatever language the page was asked for"); + } } + /// <summary> + /// A German request gets German wherever German exists, and the machine voice survives it. + /// </summary> + /// <remarks> + /// <para> + /// <b>Gated on <see cref="Messages.HasOwn"/> rather than on a list of ids, and that is the + /// point.</b> This page's own ids are new and the four satellites are translated in one round + /// afterwards, so today most of them fall back to English — which is the designed behaviour and + /// not a failure. Naming ids here would either freeze that state in or fail the moment the + /// translations land. Asking the bundle instead means the assertion is "German where there is + /// German", which is true now and stays true as each id is translated. + /// </para> + /// <para> + /// The counter proves it is not vacuous: the owner panel already renders the provenance word, + /// which is translated, so this has real German to find today. + /// </para> + /// </remarks> + [Test] + public async Task AGermanRequestGetsGermanOnTheDashboard() + { + var english = Render.Text(await Full(Locales.SourceTag)); + var german = Render.Text(await Full("de")); + + var translated = 0; + + // The provenance family joins by the one id these pages render, not by prefix: the others + // carry the bare word "measured", which occurs inside half the sentences on this page and + // would match as a substring rather than as the chip the panel promises. + foreach (var id in Sayable("account.", "owner.").Append("provenance.game.ownerDeclared")) + { + var en = Render.Words(Messages.For(Locales.SourceTag, id)); + var de = Render.Words(Messages.For("de", id)); + + // An id that fell back has nothing to assert, and a word German spells the same way + // proves nothing either way. + if (!Messages.HasOwn("de", id) + || string.Equals(en, de, StringComparison.Ordinal) + || !english.Contains(en, StringComparison.Ordinal)) + { + continue; + } + + await Assert.That(german).Contains(de).Because($"{id} is not answered in German"); + + translated++; + } + + await Assert.That(translated) + .IsGreaterThan(0) + .Because("no id on this page has German yet, so this test asserted nothing"); + + // The page is answered in German rather than merely served under a German tag. + await Assert.That(german).IsNotEqualTo(english); + + // A fallback shows the English and never the id. That is the one failure mode a reader + // cannot recover from — English inside a German sentence tells them something true, and + // `account.title` on the page tells them the site is broken. + foreach (var id in Sayable("account.", "owner.").Where(i => !Messages.HasOwn("de", i))) + { + await Assert.That(german).DoesNotContain(id).Because($"{id} reached a reader as its id"); + } + + // Machine voice is untouched: the game's name and the confirmation word are not translated. + await Assert.That(german).Contains(AshenName); + await Assert.That(german).Contains(OwnershipWrites.ResignConfirmation); + } + + /// <summary>Ids under these prefixes that can be rendered without arguments.</summary> + /// <remarks> + /// A pattern cannot be formatted at all without the arguments it names, so a sweep that walks + /// whole sentences has to leave those out. It costs little: the parameterised ids on these + /// pages are the ones carrying a game's name, a date or a count, and each has its own test. + /// </remarks> + private static IEnumerable<string> Sayable(params string[] prefixes) => + Messages.Ids + .Where(i => prefixes.Any(p => i.StartsWith(p, StringComparison.Ordinal))) + .Where(i => !IcuMessage.Compile(Messages.Pattern(Locales.SourceTag, i)!).Arguments().Any()); + + /// <summary>The dashboard in one locale, in the state that renders the most of it.</summary> + private static Task<string> Full(string tag) => + World.New() + .In(tag) + .SignedIn() + .Verified(Ashen) + .CoOwnedBy("thistle") + .RenderAsync($"?saved={Ashen}&did=fields"); + /// <summary>An enrichment refusal names the field and says which rule refused it.</summary> + /// <remarks> + /// The two reasons are different sentences and must not be swapped: one says an answer was too + /// long, the other says the field is measured and that nobody edits a measurement, us included. + /// A refusal that gave the second reason for the first cause would be the site claiming a rule + /// it does not have. + /// </remarks> [Test] public async Task ARefusalOverLengthSaysSoRatherThanBlamingTheField() { @@ -258,9 +551,15 @@ public async Task ARefusalOverLengthSaysSoRatherThanBlamingTheField() .Verified(Ashen) .RenderAsync("?refused=FANDOM&because=TooLong")); - await Assert.That(words).Contains("FANDOM was not changed"); - await Assert.That(words).Contains($"{OwnerEnrichment.MaxValueLength} characters"); - await Assert.That(words).DoesNotContain("That field is measured"); + await Assert.That(words).Contains(Render.Words( + Messages.Say(Locales.SourceTag, "account.refused.lead", ("field", "FANDOM")))); + + await Assert.That(words).Contains(Render.Words(Messages.Say( + Locales.SourceTag, + "account.refused.tooLong", + ("max", OwnerEnrichment.MaxValueLength.ToString(CultureInfo.InvariantCulture))))); + + await Assert.That(words).DoesNotContain(En("account.refused.measured")); } // ── the routes the page posts to ────────────────────────────────────────── @@ -363,9 +662,23 @@ private sealed class World private readonly List<GameClaim> _claims = []; private bool _signedIn; + private string _tag = Locales.SourceTag; public static World New() => new(); + /// <summary> + /// The locale the request was answered in, as the middleware leaves it. + /// </summary> + /// <remarks> + /// In <c>HttpContext.Items</c> rather than on a thread's culture, because that is where the + /// page reads it from — every surface here is handed its locale rather than inferring one. + /// </remarks> + public World In(string tag) + { + _tag = tag; + return this; + } + public World SignedIn() { _signedIn = true; @@ -442,7 +755,7 @@ public Task<string> RenderAsync(string query = "") => services.AddSingleton(new OwnerEnrichment( claims, fields, new FieldReconciler(fields), FieldRegistry.Instance, new Frozen(Now))); - services.AddSingleton<IUserStore<MuiUser>>(new Accounts(_accounts)); + services.AddSingleton<IUserStore<MuiUser>>(new Accounts(_accounts, Now)); services.AddIdentityCore<MuiUser>(); }); @@ -456,10 +769,13 @@ public Task<string> RenderAsync(string query = "") => ExpiresAt = Now.AddDays(20), }; - private static HttpContext Context(MuiUser? user) + private HttpContext Context(MuiUser? user) { var context = new DefaultHttpContext(); + context.Items[LocaleRouting.ItemKey] = + new LocaleContext(Locales.Find(_tag)!, FromPath: _tag != Locales.SourceTag); + if (user is not null) { context.User = new ClaimsPrincipal(new ClaimsIdentity( @@ -600,78 +916,4 @@ public Task<IReadOnlyList<GameRecord>> UnarchivedAsync(CancellationToken ct = de CancellationToken ct = default) => Task.FromResult<string?>(null); } - - /// <summary> - /// Enough of a user store to find an account and list its passkeys. - /// </summary> - /// <remarks> - /// Identity's <c>UserManager</c> is a concrete type over a store interface, so a page that calls - /// it needs one. This is persistence rather than authorisation: which account the page is for - /// comes from the cascaded principal, and what that account may see comes from the claim store. - /// </remarks> - private sealed class Accounts(List<MuiUser> users) : IUserStore<MuiUser>, IUserPasskeyStore<MuiUser> - { - public Task<MuiUser?> FindByIdAsync(string id, CancellationToken ct) => - Task.FromResult(users.FirstOrDefault(u => u.Id.ToString() == id)); - - public Task<string> GetUserIdAsync(MuiUser user, CancellationToken ct) => - Task.FromResult(user.Id.ToString()); - - public Task<string?> GetUserNameAsync(MuiUser user, CancellationToken ct) => - Task.FromResult<string?>(user.DisplayName); - - public Task<string?> GetNormalizedUserNameAsync(MuiUser user, CancellationToken ct) => - Task.FromResult<string?>(user.NormalisedName); - - public Task<MuiUser?> FindByNameAsync(string name, CancellationToken ct) => - Task.FromResult(users.FirstOrDefault(u => u.NormalisedName == name)); - - public Task SetUserNameAsync(MuiUser user, string? name, CancellationToken ct) => Task.CompletedTask; - - public Task SetNormalizedUserNameAsync(MuiUser user, string? name, CancellationToken ct) => - Task.CompletedTask; - - public Task<IdentityResult> CreateAsync(MuiUser user, CancellationToken ct) => - Task.FromResult(IdentityResult.Success); - - public Task<IdentityResult> UpdateAsync(MuiUser user, CancellationToken ct) => - Task.FromResult(IdentityResult.Success); - - public Task<IdentityResult> DeleteAsync(MuiUser user, CancellationToken ct) => - Task.FromResult(IdentityResult.Success); - - public Task AddOrUpdatePasskeyAsync(MuiUser user, UserPasskeyInfo passkey, CancellationToken ct) => - Task.CompletedTask; - - public Task<IList<UserPasskeyInfo>> GetPasskeysAsync(MuiUser user, CancellationToken ct) => - Task.FromResult<IList<UserPasskeyInfo>>( - [ - new UserPasskeyInfo( - [1, 2, 3], - [4, 5, 6], - Now.AddYears(-1), - 0u, - ["internal"], - true, - true, - true, - [], - []) - { - Name = "the yubikey in the drawer", - }, - ]); - - public Task<MuiUser?> FindByPasskeyIdAsync(byte[] id, CancellationToken ct) => - Task.FromResult<MuiUser?>(null); - - public Task<UserPasskeyInfo?> FindPasskeyAsync(MuiUser user, byte[] id, CancellationToken ct) => - Task.FromResult<UserPasskeyInfo?>(null); - - public Task RemovePasskeyAsync(MuiUser user, byte[] id, CancellationToken ct) => Task.CompletedTask; - - public void Dispose() - { - } - } } diff --git a/tests/MUI.Web.Tests/Accounts.cs b/tests/MUI.Web.Tests/Accounts.cs new file mode 100644 index 0000000..08bf9f8 --- /dev/null +++ b/tests/MUI.Web.Tests/Accounts.cs @@ -0,0 +1,88 @@ +using Microsoft.AspNetCore.Identity; + +using MUI.Web.Accounts; + +namespace MUI.Web.Tests; + +/// <summary> +/// Enough of a user store to find an account and list its passkeys. +/// </summary> +/// <remarks> +/// <para> +/// Identity's <c>UserManager</c> is a concrete type over a store interface, so a page that calls it +/// needs one. This is persistence rather than authorisation: which account a page is for comes from +/// the cascaded principal, and what that account may see comes from the claim store. +/// </para> +/// <para> +/// Its own file because two surfaces need it. The dashboard and the claim page both go through +/// <c>UserManager.GetUserAsync</c> before they render anything an owner can act on, and the second +/// one could not be rendered at all while this was private to the first — so the claim page's +/// signed-in states had no test, which is the same gap the dashboard was in before it got one. +/// </para> +/// </remarks> +internal sealed class Accounts(List<MuiUser> users, DateTimeOffset now) + : IUserStore<MuiUser>, IUserPasskeyStore<MuiUser> +{ + public Task<MuiUser?> FindByIdAsync(string id, CancellationToken ct) => + Task.FromResult(users.FirstOrDefault(u => u.Id.ToString() == id)); + + public Task<string> GetUserIdAsync(MuiUser user, CancellationToken ct) => + Task.FromResult(user.Id.ToString()); + + public Task<string?> GetUserNameAsync(MuiUser user, CancellationToken ct) => + Task.FromResult<string?>(user.DisplayName); + + public Task<string?> GetNormalizedUserNameAsync(MuiUser user, CancellationToken ct) => + Task.FromResult<string?>(user.NormalisedName); + + public Task<MuiUser?> FindByNameAsync(string name, CancellationToken ct) => + Task.FromResult(users.FirstOrDefault(u => u.NormalisedName == name)); + + public Task SetUserNameAsync(MuiUser user, string? name, CancellationToken ct) => Task.CompletedTask; + + public Task SetNormalizedUserNameAsync(MuiUser user, string? name, CancellationToken ct) => + Task.CompletedTask; + + public Task<IdentityResult> CreateAsync(MuiUser user, CancellationToken ct) => + Task.FromResult(IdentityResult.Success); + + public Task<IdentityResult> UpdateAsync(MuiUser user, CancellationToken ct) => + Task.FromResult(IdentityResult.Success); + + public Task<IdentityResult> DeleteAsync(MuiUser user, CancellationToken ct) => + Task.FromResult(IdentityResult.Success); + + public Task AddOrUpdatePasskeyAsync(MuiUser user, UserPasskeyInfo passkey, CancellationToken ct) => + Task.CompletedTask; + + public Task<IList<UserPasskeyInfo>> GetPasskeysAsync(MuiUser user, CancellationToken ct) => + Task.FromResult<IList<UserPasskeyInfo>>( + [ + new UserPasskeyInfo( + [1, 2, 3], + [4, 5, 6], + now.AddYears(-1), + 0u, + ["internal"], + true, + true, + true, + [], + []) + { + Name = "the yubikey in the drawer", + }, + ]); + + public Task<MuiUser?> FindByPasskeyIdAsync(byte[] id, CancellationToken ct) => + Task.FromResult<MuiUser?>(null); + + public Task<UserPasskeyInfo?> FindPasskeyAsync(MuiUser user, byte[] id, CancellationToken ct) => + Task.FromResult<UserPasskeyInfo?>(null); + + public Task RemovePasskeyAsync(MuiUser user, byte[] id, CancellationToken ct) => Task.CompletedTask; + + public void Dispose() + { + } +} diff --git a/tests/MUI.Web.Tests/AdultSurfaceTests.cs b/tests/MUI.Web.Tests/AdultSurfaceTests.cs index 4042fb5..b3b4124 100644 --- a/tests/MUI.Web.Tests/AdultSurfaceTests.cs +++ b/tests/MUI.Web.Tests/AdultSurfaceTests.cs @@ -1,3 +1,4 @@ +using MUI.Web.Localization; using MUI.Catalog; using MUI.Web.Api; using MUI.Web.Components; @@ -70,23 +71,37 @@ public async Task TheBarCarriesTheControlWhetherOrNotItIsTicked() { // Drawn on every request, ticked or not. A default whose only undo appears once you have // already undone it is a default a reader cannot find, and this one hides games silently. + // + // A link now rather than a checkbox waiting on a submit button: the panel's "show" button + // is gone, so a control that only armed itself would be one nothing could fire. foreach (var filter in new[] { Listing(), Listing($"?{FacetKeys.Adult}=true") }) { var html = await PanelAsync(filter); - await Assert.That(html).Contains($"name=\"{FacetKeys.Adult}\""); - await Assert.That(Render.Words(html)).Contains("include adult"); + // The control, whichever way it is set. Its href is the *other* position, so asserting + // on a fixed URL would only ever find one of the two states — which is how a control + // that vanished once it had been used would pass a test. + await Assert.That(html).Contains("adult content,"); + await Assert.That(Render.Words(html)).Contains("adult"); } } [Test] - public async Task TheTickedBoxIsCheckedWhenTheUrlAsksForThem() + public async Task TheSwitchSaysWhichWayItIsSetAndLinksToTheOther() { - // The URL is the whole of this page's state, so a shared link has to come back with the box - // in the position that produced it. - await Assert.That(await PanelAsync(Listing())).DoesNotContain($"name=\"{FacetKeys.Adult}\" value=\"true\" checked"); - await Assert.That(await PanelAsync(Listing($"?{FacetKeys.Adult}=1"))) - .Contains($"name=\"{FacetKeys.Adult}\" value=\"true\" checked"); + // The URL is the whole of this page's state, so a shared link has to come back with the + // switch in the position that produced it — and the way out has to be the other position. + var off = await PanelAsync(Listing()); + var on = await PanelAsync(Listing($"?{FacetKeys.Adult}=1")); + + // Off: says so, and its link turns them on. + await Assert.That(off).Contains("adult content, hidden"); + await Assert.That(off).Contains($"href=\"/games?{FacetKeys.Adult}=true\""); + + // On: says so, and its link is the one that clears the key rather than setting it false — + // the address a reader copies says only what they asked for. + await Assert.That(on).Contains("adult content, shown"); + await Assert.That(on).DoesNotContain($"href=\"/games?{FacetKeys.Adult}=true\""); } [Test] @@ -96,9 +111,16 @@ public async Task IncludingThemIsAChipThatCanBeTakenBackOff() var filter = Listing(Query); var listing = await Queries.SearchAsync(filter); - var chip = ActiveFilters.For(listing.Facets, filter, Query).Single(c => c.Facet is "adult"); - await Assert.That(chip.Value).IsEqualTo("included"); + // Both halves of the chip come out of the bundle now, so this asks the bundle what they say + // rather than repeating the English. The fact under test is unchanged and is not wording: + // the chip for this key exists, it says the key is included, and its link takes it back off. + var chips = ActiveFilters.For(Locales.SourceTag, listing.Facets, filter, Query); + var chip = chips.Single( + c => c.Facet == FacetWords.Group(Locales.SourceTag, FacetKeys.Adult)); + + await Assert.That(chip.Value) + .IsEqualTo(Messages.For(Locales.SourceTag, "facet.value.included")); await Assert.That(chip.RemoveHref).DoesNotContain(FacetKeys.Adult); } diff --git a/tests/MUI.Web.Tests/AnsiTests.cs b/tests/MUI.Web.Tests/AnsiTests.cs index 6531733..324d8e3 100644 --- a/tests/MUI.Web.Tests/AnsiTests.cs +++ b/tests/MUI.Web.Tests/AnsiTests.cs @@ -92,23 +92,135 @@ public async Task NothingCapturedIsDistinctFromTooSmall() } [Test] - public async Task AScreenPastTwentyFourRowsIsCroppedAndSaysHowManyThereAre() + public async Task ALongScreenIsParsedWholeRatherThanCropped() { - var screen = Ansi.Parse(Screen(47), suppressedByOwner: false); + // There is no crop any more. The frame used to hold the first twenty-four rows, offer the + // whole screen again under "show all N rows" and its text a third time under "read as text" + // — three copies of one piece of box-drawing, and three passes through it for anybody + // listening. One region, every row, and it scrolls. + var screen = Ansi.Parse(Screen(214), suppressedByOwner: false); - await Assert.That(screen.RowCount).IsEqualTo(47); - await Assert.That(screen.IsCropped).IsTrue(); - await Assert.That(screen.IsOversized).IsFalse(); - await Assert.That(screen.Visible.Count()).IsEqualTo(Ansi.CropRows); + await Assert.That(screen.RowCount).IsEqualTo(214); + await Assert.That(screen.Rows.Count).IsEqualTo(214); } [Test] - public async Task AScreenPastTwoHundredRowsIsFlaggedAsOversizedAndStillCropsAtTwentyFour() + public async Task AWidthIsCountedInTerminalCellsAndPerRowRatherThanPerScreen() { - var screen = Ansi.Parse(Screen(214), suppressedByOwner: false); + // The row that made a screen-wide flag wrong: seventy-eight ASCII characters and one Han + // glyph. Seventy-nine characters, eighty cells — and the caption used to halve the whole + // screen the moment any wide rune appeared anywhere, and report forty for this. + var mixed = new string('x', 78) + "漢"; + var screen = Ansi.Parse($"{mixed}\nplain\nplain", suppressedByOwner: false); + + await Assert.That(screen.Rows[0].Text.Length).IsEqualTo(79); + await Assert.That(screen.Rows[0].Cells).IsEqualTo(80); + await Assert.That(screen.CellColumns).IsEqualTo(80); + await Assert.That(screen.HasWideRunes).IsTrue(); + + // And eighty-one cells cannot be one row of an eighty-column terminal. A double-width glyph + // that would straddle the right margin is moved whole to the next line rather than split + // across it, which is what a terminal does — so seventy-nine ASCII plus one Han glyph is two + // rows, not one over-wide one. The layout counts cells and the caption reads them; before + // this the layout counted UTF-16 units, so a screen of wide glyphs wrapped after eighty + // runes, which is a hundred and sixty cells. + var straddling = Ansi.Parse(new string('x', 79) + "漢\nplain", suppressedByOwner: false); + + await Assert.That(straddling.Rows[0].Cells).IsEqualTo(79); + await Assert.That(straddling.Rows[1].Text).IsEqualTo("漢"); + + // And a screen drawn entirely out of wide glyphs is twice its character count, which is the + // case the halving was written for and the only one it got right. + var wide = Ansi.Parse($"{new string('漢', 40)}\n{new string('漢', 40)}\n{new string('漢', 40)}", + suppressedByOwner: false); + + await Assert.That(wide.CellColumns).IsEqualTo(80); + } + + [Test] + public async Task AWideRuneOnOneRowDoesNotWidenTheRowsAroundIt() + { + // The width reported is the widest row, not the widest row's arithmetic applied to all of + // them. A banner with one Japanese line in it is as wide as that line and no wider. + var screen = Ansi.Parse("ascii\n漢字\nascii", suppressedByOwner: false); + + await Assert.That(screen.Rows[0].Cells).IsEqualTo(5); + await Assert.That(screen.Rows[1].Cells).IsEqualTo(4); + await Assert.That(screen.CellColumns).IsEqualTo(5); + } + + [Test] + public async Task ACombiningMarkCostsNoCellOfItsOwn() + { + // It is drawn onto the cell before it. Counted as a character, an accented Greek or + // Devanagari banner would be reported wider than it is drawn. + // + // Composed here rather than written as a literal, so the decomposition is this test's and + // not whatever normalisation the file was saved under: three letters, each carrying a + // combining acute of its own. + var acute = (char)0x0301; + var decomposed = string.Concat(Enumerable.Repeat($"e{acute}", 3)); + var screen = Ansi.Parse($"{decomposed}\nplain\nplain", suppressedByOwner: false); + + await Assert.That(screen.Rows[0].Text.Length).IsEqualTo(6); + await Assert.That(screen.Rows[0].Cells).IsEqualTo(3); + await Assert.That(screen.HasWideRunes).IsFalse(); + } + + [Test] + public async Task AnEmptyScreenHasNoWidthRatherThanTheGridsWidth() + { + await Assert.That(Ansi.Parse(null, false).CellColumns).IsEqualTo(0); + } - await Assert.That(screen.IsOversized).IsTrue(); - await Assert.That(screen.Visible.Count()).IsEqualTo(Ansi.CropRows); + /// <summary> + /// The whole accessible alternative to the picture is outside the picture. + /// </summary> + /// <remarks> + /// <c>role="img"</c> makes every descendant presentational, so a disclosure inside + /// <c>div.quote</c> is announced as nothing at all and the one-line <c>aria-label</c> becomes + /// the only alternative there is — a label saying the screen exists, in place of the screen. + /// The disclosure therefore sits beside the quoted region and inside the figure. + /// </remarks> + [Test] + public async Task TheReadAsTextDisclosureIsOutsideTheRoleImgSubtree() + { + var html = await Render.ComponentAsync<AnsiQuote>(new() + { + ["Screen"] = Ansi.Parse(Screen(6), suppressedByOwner: false), + }); + + await Assert.That(html).Contains("role=\"img\""); + await Assert.That(html).Contains("aria-label="); + await Assert.That(html).Contains("class=\"screen-text\""); + + // The quoted region holds one <pre> and no other element that closes with </div>, so the + // first </div> after it is its own — and the disclosure has to come after that. + var quote = html.IndexOf("class=\"quote\"", StringComparison.Ordinal); + var closes = html.IndexOf("</div>", quote, StringComparison.Ordinal); + var disclosure = html.IndexOf("class=\"screen-text\"", StringComparison.Ordinal); + + await Assert.That(quote).IsGreaterThanOrEqualTo(0); + await Assert.That(disclosure).IsGreaterThan(closes); + + // And it is still inside the figure, which is what makes the two one block. + var figure = html.IndexOf("</figure>", StringComparison.Ordinal); + await Assert.That(disclosure).IsLessThan(figure); + } + + [Test] + public async Task TheCaptionStatesTheWidestRowInCellsRatherThanAHalvedGrid() + { + // Seventy-eight ASCII characters and one Han glyph: eighty cells, the widest a row of an + // eighty-column terminal can be. The caption said forty, because one wide rune anywhere + // halved the whole screen. + var html = Render.Words(await Render.ComponentAsync<AnsiQuote>(new() + { + ["Screen"] = Ansi.Parse(new string('x', 78) + "漢\nplain\nplain", suppressedByOwner: false), + })); + + await Assert.That(html).Contains("80×"); + await Assert.That(html).DoesNotContain("40×"); } [Test] diff --git a/tests/MUI.Web.Tests/CapabilityMatrixTests.cs b/tests/MUI.Web.Tests/CapabilityMatrixTests.cs index 6a9180f..3b36606 100644 --- a/tests/MUI.Web.Tests/CapabilityMatrixTests.cs +++ b/tests/MUI.Web.Tests/CapabilityMatrixTests.cs @@ -42,13 +42,29 @@ public async Task ADisagreementIsMarkedInTheRowAndNotOnlyByATint() } [Test] - public async Task TheCountIsInTheSectionHeadSoItSurvivesCollapse() + public async Task TheTallyIsTheTablesCaptionAndIsSaidExactlyOnce() { + // It used to be the section's heading text and, verbatim, the table's sr-only caption — so a + // screen reader heard the same sentence twice on the way to the first row. As the caption it + // is the table's own description, it is on screen for everybody, and it is there once. + // The wording is the short form the handoff's copy table asks for. "capabilities" was the + // word the heading directly above already says, so the caption no longer repeats it. var html = await MatrixAsync(); var head = html[..html.IndexOf("<table", StringComparison.Ordinal)]; - await Assert.That(head).Contains("1 of 4 capabilities"); - await Assert.That(head).Contains("disagrees with what the game declares"); + await Assert.That(html).Contains("<caption class=\"count"); + + // "disagrees" and not "disagree": the caption is an ICU message with a real plural clause, + // so one disagreement agrees with its verb. It read "1 of 4 disagree" for as long as the + // sentence was assembled by hand. + await Assert.That(Render.Words(html)).Contains("1 of 4 disagrees with what the game declares."); + await Assert.That(head).DoesNotContain("1 of 4"); + + var occurrences = Render.Words(html).Split("1 of 4").Length - 1; + await Assert.That(occurrences).IsEqualTo(1); + + // The heading is just the noun, which is the other half of saying it once. + await Assert.That(Render.Words(head)).Contains("Capabilities"); } [Test] diff --git a/tests/MUI.Web.Tests/ClaimSurfaceTests.cs b/tests/MUI.Web.Tests/ClaimSurfaceTests.cs index 89e46a4..390c04a 100644 --- a/tests/MUI.Web.Tests/ClaimSurfaceTests.cs +++ b/tests/MUI.Web.Tests/ClaimSurfaceTests.cs @@ -1,8 +1,17 @@ +using System.Security.Claims; + +using Microsoft.AspNetCore.Components.Forms; +using Microsoft.AspNetCore.Http; +using Microsoft.AspNetCore.Identity; +using Microsoft.Extensions.DependencyInjection; + using MUI.Catalog; using MUI.Catalog.Persistence; +using MUI.Discovery; using MUI.Web.Accounts; using MUI.Web.Components.Pages; using MUI.Web.Fixtures; +using MUI.Web.Localization; namespace MUI.Web.Tests; @@ -30,7 +39,9 @@ public async Task AGamePageOverTheFixtureDoesNotOfferToBeClaimed() { var page = await Render.PageAsync<Game>(new() { ["Slug"] = "m-u-s-h" }); - await Assert.That(page).Contains("Everything here was measured, not entered by an owner"); + // One sentence, where the badge and a paragraph three blocks below used to say the same + // thing twice. The invitation is the half that depends on there being anywhere to sign in. + await Assert.That(Render.Words(page)).Contains("Unclaimed — everything here was measured."); await Assert.That(page).DoesNotContain("Claim this game"); } @@ -95,4 +106,311 @@ public async Task OnlyChannelsAProbeCanReadAreClaimChannels() { await Assert.That(Enum.GetNames<ClaimChannel>()).IsEquivalentTo(new[] { "Mssp", "ConnectScreen" }); } + + // ── the language the claim page is answered in ──────────────────────────── + + /// <summary> + /// Every word of the claim page comes out of the message bundle. + /// </summary> + /// <remarks> + /// <para> + /// Driven on the state that renders the most of it: a signed-in operator with a pending token, + /// which is the page an owner actually works from — the instructions, both channels, the + /// expiry and the recheck button. The degraded states are covered below, because those are the + /// ones a reader of the demo site meets. + /// </para> + /// <para> + /// The pseudolocale is the instrument: it brackets anything that reached a reader through + /// <see cref="Messages"/>, so an English sentence surviving here is one typed into the markup. + /// </para> + /// </remarks> + [Test] + public async Task EveryWordOfClaimingComesFromTheBundle() + { + var english = Render.Text(await ClaimWorld.Pending(Locales.SourceTag)); + var pseudo = Render.Text(await ClaimWorld.Pending("qps-ploc")); + + await Assert.That(pseudo).Contains("⟦"); + + // The page really is the token-bearing one rather than a guard branch rendered twice. + await Assert.That(english).Contains(Render.Words( + Messages.For(Locales.SourceTag, "claim.either.heading"))); + + foreach (var id in Sayable("claim.")) + { + var sentence = Render.Words(Messages.For(Locales.SourceTag, id)); + + if (!english.Contains(sentence, StringComparison.Ordinal)) + { + continue; + } + + await Assert.That(pseudo) + .DoesNotContain(sentence) + .Because($"{id} is rendered as English whatever language the page was asked for"); + } + } + + /// <summary> + /// A German request gets German wherever German exists, and the token survives it. + /// </summary> + /// <remarks> + /// Gated on <see cref="Messages.HasOwn"/> rather than on a list of ids: this page's own ids are + /// new and the satellites are translated in one round afterwards, so most of them fall back to + /// English today — the designed behaviour. The parts that must never move are asserted + /// directly, because every one of them is something an operator pastes into a config file. + /// </remarks> + [Test] + public async Task AGermanRequestGetsGermanOnTheClaimPage() + { + var english = Render.Text(await ClaimWorld.Pending(Locales.SourceTag)); + var german = Render.Text(await ClaimWorld.Pending("de")); + + foreach (var id in Sayable("claim.").Where(i => Messages.HasOwn("de", i))) + { + var de = Render.Words(Messages.For("de", id)); + var en = Render.Words(Messages.For(Locales.SourceTag, id)); + + if (string.Equals(de, en, StringComparison.Ordinal) + || !english.Contains(en, StringComparison.Ordinal)) + { + continue; + } + + await Assert.That(german).Contains(de).Because($"{id} is not answered in German"); + } + + // A fallback shows the English and never the id. + foreach (var id in Sayable("claim.").Where(i => !Messages.HasOwn("de", i))) + { + await Assert.That(german).DoesNotContain(id).Because($"{id} reached a reader as its id"); + } + + // The machine voice, which is the half of this page that must be byte-identical in every + // language: the token itself, the MSSP variable and the connect-screen prefix are what a + // probe looks for, and a translated one is a claim that could never verify. + await Assert.That(german).Contains(ClaimWorld.Token); + await Assert.That(german).Contains(ClaimTokenBeacon.MsspVariable); + await Assert.That(german).Contains(ClaimTokenBeacon.ConnectScreenPrefix); + + // And the accepted spellings are read from the parser rather than retyped into the page. + foreach (var accepted in ClaimTokenBeacon.AcceptedMsspVariables) + { + await Assert.That(german).Contains(accepted); + } + } + + /// <summary> + /// The states a reader of the demo site can actually reach, in the language they asked for. + /// </summary> + /// <remarks> + /// There is no database behind the fixture, so claiming is absent rather than present and + /// broken — and "absent" is itself a sentence, which has to be in the reader's language like + /// any other. Both branches, because a slug that names nothing and a slug that names a game we + /// cannot claim are different answers. + /// </remarks> + [Test] + [Arguments(Locales.SourceTag)] + [Arguments("qps-ploc")] + [Arguments("de")] + public async Task TheDegradedClaimPageAnswersInTheReadersLanguage(string tag) + { + var missing = Render.Text(await ClaimWorld.NoGame(tag)); + + await Assert.That(missing).Contains(Render.Words(Messages.For(tag, "claim.noGame"))); + + var unclaimable = Render.Text(await ClaimWorld.NoDatabase(tag)); + + await Assert.That(unclaimable).Contains(Render.Words(Messages.For(tag, "claim.noDatabase"))); + + // The heading names the game, and the game's name is its own bytes in every language. + await Assert.That(unclaimable).Contains(Render.Words( + Messages.Say(tag, "claim.title", ("game", ClaimWorld.GameName)))); + } + + /// <summary>Ids under a prefix that can be rendered without arguments.</summary> + private static IEnumerable<string> Sayable(string prefix) => + Messages.Ids + .Where(i => i.StartsWith(prefix, StringComparison.Ordinal)) + .Where(i => !IcuMessage.Compile(Messages.Pattern(Locales.SourceTag, i)!).Arguments().Any()); + + /// <summary> + /// The claim page, in one locale, in each state it can be reached in. + /// </summary> + /// <remarks> + /// At component level with an <see cref="HttpContext"/> cascaded in, for the reason the + /// dashboard's harness is: §8.2 makes passkeys the only way in, so a loopback host cannot + /// produce an authenticated session without an authenticator. The page's own guards still run — + /// which game, which account, and whether there is a claim — against a real + /// <see cref="ClaimService"/> over in-memory stores. + /// </remarks> + private static class ClaimWorld + { + public const string Slug = "ashen-court"; + + public const string GameName = "Ashen Court"; + + /// <summary>A token of the right shape. Machine voice, and identical in every language.</summary> + public const string Token = "muidx-t3kn2wxy7q4m8dgh6prs"; + + private static readonly DateTimeOffset Now = FixtureGameQueries.Now; + + private static readonly Guid GameId = Guid.Parse("aaaaaaaa-0000-0000-0000-000000000007"); + + /// <summary>A signed-in operator with a token outstanding: the page an owner works from.</summary> + public static Task<string> Pending(string tag) => RenderAsync(tag, withGame: true, withClaims: true); + + /// <summary>A slug that names nothing.</summary> + public static Task<string> NoGame(string tag) => RenderAsync(tag, withGame: false, withClaims: true); + + /// <summary>A real game on a site with no database behind it — the demo fixture's state.</summary> + public static Task<string> NoDatabase(string tag) => + RenderAsync(tag, withGame: true, withClaims: false); + + private static Task<string> RenderAsync(string tag, bool withGame, bool withClaims) + { + var user = new MuiUser { DisplayName = "corvid-admin", CreatedAt = Now }; + + var claim = new GameClaim + { + Id = Guid.CreateVersion7(), + GameId = GameId, + UserId = user.Id, + Token = Token, + IssuedAt = Now.AddDays(-2), + ExpiresAt = Now.AddDays(12), + }; + + return Render.ComponentAsync<MUI.Web.Components.Pages.Claim>( + new Dictionary<string, object?> { ["Slug"] = Slug }, + services => + { + var games = new Games(withGame + ? new GameRecord(GameId, Slug, GameName, null, LifecycleState.Active, false, Now) + : null); + + var claims = new Claims([claim]); + + services.AddLogging(); + services.AddSingleton<TimeProvider>(new Frozen(Now)); + services.AddSingleton(new MUI.Web.Data.CatalogueSource(IsMeasured: withClaims)); + services.AddSingleton<AntiforgeryStateProvider, NoAntiforgery>(); + services.AddSingleton<IGameStore>(games); + + // Registered together, because that is how the site registers them: claiming + // exists only when a connection string does, and the page's "no database" + // branch is exactly the absence of this service. + if (withClaims) + { + services.AddSingleton<IClaimStore>(claims); + services.AddSingleton(new ClaimService(claims, games, new Frozen(Now))); + } + + services.AddSingleton<IUserStore<MuiUser>>(new Accounts([user], Now)); + services.AddIdentityCore<MuiUser>(); + + var context = new DefaultHttpContext + { + User = new ClaimsPrincipal(new ClaimsIdentity( + [new System.Security.Claims.Claim( + ClaimTypes.NameIdentifier, user.Id.ToString())], + "Test")), + }; + + context.Items[LocaleRouting.ItemKey] = + new LocaleContext(Locales.Find(tag)!, FromPath: tag != Locales.SourceTag); + + services.AddCascadingValue(_ => context); + }); + } + + private sealed class Games(GameRecord? game) : IGameStore + { + public Task<GameRecord?> ByIdAsync(Guid id, CancellationToken ct = default) => + Task.FromResult(game?.Id == id ? game : null); + + public Task<GameRecord?> BySlugAsync(string slug, CancellationToken ct = default) => + Task.FromResult(game?.Slug == slug ? game : null); + + public Task InsertAsync(GameRecord g, CancellationToken ct = default) => + throw new NotSupportedException(); + + public Task ExcludeAsync(Guid id, string reason, DateTimeOffset at, CancellationToken ct = default) => + throw new NotSupportedException(); + + public Task IncludeAsync(Guid id, DateTimeOffset at, CancellationToken ct = default) => + throw new NotSupportedException(); + + public Task UnlistAsync(Guid id, Guid by, DateTimeOffset at, CancellationToken ct = default) => + throw new NotSupportedException(); + + public Task RelistAsync(Guid id, DateTimeOffset at, CancellationToken ct = default) => + throw new NotSupportedException(); + + public Task SetStateAsync(Guid id, LifecycleState s, DateTimeOffset at, CancellationToken ct = default) => + throw new NotSupportedException(); + + public Task MarkReachableAsync(Guid id, DateTimeOffset at, CancellationToken ct = default) => + throw new NotSupportedException(); + + public Task<string?> RenameAsync( + Guid id, + string name, + string slug, + DateTimeOffset at, + CancellationToken ct = default) => + throw new NotSupportedException(); + + public Task SetClaimedAsync(Guid id, bool isClaimed, CancellationToken ct = default) => + throw new NotSupportedException(); + + public Task CorroborateAsync( + Guid id, + DateTimeOffset at, + IReadOnlyList<string> signals, + CancellationToken ct = default) => + throw new NotSupportedException(); + + public Task<IReadOnlyList<GameRecord>> UnarchivedAsync(CancellationToken ct = default) => + throw new NotSupportedException(); + } + + private sealed class Claims(List<GameClaim> claims) : IClaimStore + { + public Task<GameClaim?> FindAsync(Guid id, CancellationToken ct = default) => + Task.FromResult(claims.FirstOrDefault(c => c.Id == id)); + + public Task<IReadOnlyList<GameClaim>> ForGameAsync(Guid game, CancellationToken ct = default) => + Task.FromResult<IReadOnlyList<GameClaim>>([.. claims.Where(c => c.GameId == game)]); + + public Task<IReadOnlyList<GameClaim>> ForUserAsync(Guid user, CancellationToken ct = default) => + Task.FromResult<IReadOnlyList<GameClaim>>([.. claims.Where(c => c.UserId == user)]); + + public Task<GameClaim?> FindPendingByTokenAsync(Guid g, string t, CancellationToken ct = default) => + Task.FromResult<GameClaim?>(null); + + public Task InsertAsync(GameClaim claim, CancellationToken ct = default) + { + claims.Add(claim); + return Task.CompletedTask; + } + + public Task UpdateAsync(GameClaim claim, CancellationToken ct = default) => Task.CompletedTask; + + public Task RecordEventAsync(ClaimEvent e, CancellationToken ct = default) => Task.CompletedTask; + + public Task<IReadOnlyList<ClaimEvent>> EventsAsync(Guid claim, CancellationToken ct = default) => + Task.FromResult<IReadOnlyList<ClaimEvent>>([]); + } + + private sealed class Frozen(DateTimeOffset at) : TimeProvider + { + public override DateTimeOffset GetUtcNow() => at; + } + + private sealed class NoAntiforgery : AntiforgeryStateProvider + { + public override AntiforgeryRequestToken? GetAntiforgeryToken() => null; + } + } } diff --git a/tests/MUI.Web.Tests/CrawlerStripTests.cs b/tests/MUI.Web.Tests/CrawlerStripTests.cs index 2d8a571..5337a44 100644 --- a/tests/MUI.Web.Tests/CrawlerStripTests.cs +++ b/tests/MUI.Web.Tests/CrawlerStripTests.cs @@ -1,3 +1,5 @@ +using MUI.Web.Localization; + using MUI.Catalog; using MUI.Web.Components; @@ -29,7 +31,8 @@ public async Task ARecentProbeReadsAsWorking() var pulse = Pulse(TimeSpan.FromSeconds(40)); await Assert.That(pulse.State(Now)).IsEqualTo(CrawlState.Working); - await Assert.That(CrawlerCopy.State(pulse, Now)).IsEqualTo("crawler working — last probe just now"); + await Assert.That(CrawlerCopy.State(Locales.SourceTag, pulse, Now)) + .IsEqualTo("crawler live · last probe " + Messages.For(Locales.SourceTag, "age.ago.now")); } /// <summary> @@ -46,10 +49,11 @@ public async Task ARecentProbeReadsAsWorking() public async Task AStalePulseIsQuietAndNamesNoCause() { var pulse = Pulse(TimeSpan.FromHours(4)); - var copy = CrawlerCopy.State(pulse, Now); + var copy = CrawlerCopy.State(Locales.SourceTag, pulse, Now); await Assert.That(pulse.State(Now)).IsEqualTo(CrawlState.Quiet); - await Assert.That(copy).IsEqualTo("crawler quiet — last probe 4h ago"); + await Assert.That(copy).IsEqualTo( + "crawler quiet · last probe " + Relative.Ago(Locales.SourceTag, TimeSpan.FromHours(4))); foreach (var diagnosis in new[] { "stopped", "down", "crashed", "stalled", "failed", "error", "offline" }) { @@ -65,10 +69,10 @@ public async Task TheStripNeverSaysUptimeAndNeverDescribesAGame() { var rendered = string.Join( "\n", - CrawlerCopy.State(Pulse(TimeSpan.FromSeconds(10)), Now), - CrawlerCopy.State(Pulse(TimeSpan.FromDays(2)), Now), - CrawlerCopy.LastCycle(Pulse(TimeSpan.Zero, Cycle(8, 6, 2))) ?? string.Empty, - CrawlerCopy.Registry(Pulse(TimeSpan.Zero))); + CrawlerCopy.State(Locales.SourceTag, Pulse(TimeSpan.FromSeconds(10)), Now), + CrawlerCopy.State(Locales.SourceTag, Pulse(TimeSpan.FromDays(2)), Now), + CrawlerCopy.LastCycle(Locales.SourceTag, Pulse(TimeSpan.Zero, Cycle(8, 6, 2))) ?? string.Empty, + CrawlerCopy.Registry(Locales.SourceTag, Pulse(TimeSpan.Zero))); foreach (var word in new[] { "uptime", "unreachable", "reachable" }) { @@ -85,10 +89,10 @@ public async Task TheStripNeverSaysUptimeAndNeverDescribesAGame() public async Task AnUnmeasuredPulseRendersNothing() { await Assert.That(CrawlerPulse.Unknown.State(Now)).IsEqualTo(CrawlState.NotYet); - await Assert.That(CrawlerCopy.LastCycle(CrawlerPulse.Unknown)).IsNull(); + await Assert.That(CrawlerCopy.LastCycle(Locales.SourceTag, CrawlerPulse.Unknown)).IsNull(); var html = await Render.PageAsync<Components.Pages.Home>([]); - await Assert.That(html).DoesNotContain("crawler working"); + await Assert.That(html).DoesNotContain("crawler live"); await Assert.That(html).DoesNotContain("crawler quiet"); } @@ -103,11 +107,11 @@ public async Task AnUnmeasuredPulseRendersNothing() [Test] public async Task ACycleWithNothingDueSaysSoRatherThanPrintingZeroes() { - await Assert.That(CrawlerCopy.LastCycle(Pulse(TimeSpan.Zero, Cycle(0, 0, 0)))) - .IsEqualTo("last cycle: nothing was due"); + await Assert.That(CrawlerCopy.LastCycle(Locales.SourceTag, Pulse(TimeSpan.Zero, Cycle(0, 0, 0)))) + .IsEqualTo("nothing due this cycle"); - await Assert.That(CrawlerCopy.LastCycle(Pulse(TimeSpan.Zero, Cycle(8, 6, 2)))) - .IsEqualTo("last cycle: 8 due · 6 answered · 2 failed"); + await Assert.That(CrawlerCopy.LastCycle(Locales.SourceTag, Pulse(TimeSpan.Zero, Cycle(8, 6, 2)))) + .IsEqualTo("8 due · 6 answered · 2 failed"); } /// <summary> diff --git a/tests/MUI.Web.Tests/EcosystemSurfaceTests.cs b/tests/MUI.Web.Tests/EcosystemSurfaceTests.cs index 7790ef9..ab610f6 100644 --- a/tests/MUI.Web.Tests/EcosystemSurfaceTests.cs +++ b/tests/MUI.Web.Tests/EcosystemSurfaceTests.cs @@ -1,6 +1,7 @@ using MUI.Catalog; using MUI.Web.Components; using MUI.Web.Fixtures; +using MUI.Web.Localization; namespace MUI.Web.Tests; @@ -24,6 +25,18 @@ private static async Task<string> EcosystemAsync() => private static async Task<string> RankingsAsync() => PlainText.RenderRankings(await Queries.RankingsAsync(), Now); + /// <summary> + /// One message, as the source locale renders it. + /// </summary> + /// <remarks> + /// These assertions are about what the two surfaces <em>claim</em>, not about the English they + /// happen to claim it in. Reading the claim out of the bundle keeps the guard exactly as strong + /// — a page that stopped saying it fails here — while leaving the wording free to be translated, + /// which is the whole reason it moved into the bundle. + /// </remarks> + private static string Say(string id, params (string Key, object? Value)[] args) => + Messages.For("en", id, args.ToDictionary(a => a.Key, a => a.Value, StringComparer.Ordinal)); + [Test] public async Task NoAbsolutePlayerFigureIsEmittedByEitherSurface() { @@ -43,7 +56,7 @@ public async Task NoAbsolutePlayerFigureIsEmittedByEitherSurface() await Assert.That(text).DoesNotContain("across all games"); // And it says out loud that the omission is deliberate rather than an oversight. - await Assert.That(Render.Words(text)).Contains("Shares, never totals"); + await Assert.That(Render.Words(text)).Contains(Say("ecosystem.noTotals")); } [Test] @@ -73,9 +86,14 @@ public async Task BothDenominatorsAreNamedRatherThanImplied() // talkative and calling the difference adoption. var text = Render.Words(await EcosystemAsync()); - await Assert.That(text).Contains("whose handshake we completed"); - await Assert.That(text).Contains("whose MSSP report we hold"); - await Assert.That(text).Contains("Two sets of games, so two denominators"); + var dashboard = await Queries.EcosystemAsync(); + + await Assert.That(text).Contains(EcosystemCopy.Handshakes("en", dashboard.Handshakes)); + await Assert.That(text).Contains(EcosystemCopy.MsspReports("en", dashboard.MsspReports)); + await Assert.That(text).Contains(Say( + "ecosystem.plain.denominators", + ("measured", EcosystemCopy.Handshakes("en", dashboard.Handshakes)), + ("declared", EcosystemCopy.MsspReports("en", dashboard.MsspReports)))); } [Test] @@ -85,12 +103,15 @@ public async Task AProtocolWithNoMeasurementSaysSoRatherThanShowingNoughtPerCent // this, which is a fact about our reach; "0.0%" is a claim about everybody else's servers. var never = new ProtocolAdoption("TLS", Offered: null, Declined: 0, Handshakes: 400, Declared: 12, MsspReports: 300); - await Assert.That(EcosystemCopy.Measured(never)).Contains("not measured"); - await Assert.That(EcosystemCopy.Measured(never)).DoesNotContain("0.0%"); - await Assert.That(EcosystemCopy.Measured(never)).DoesNotContain("0 of 400"); + await Assert.That(EcosystemCopy.Measured("en", never)) + .IsEqualTo(Say("ecosystem.measured.never")); + await Assert.That(EcosystemCopy.Measured("en", never)).DoesNotContain("0.0%"); + await Assert.That(EcosystemCopy.Measured("en", never)).DoesNotContain("0 of 400"); // The declared side is unaffected and still carries its own set. - await Assert.That(EcosystemCopy.Declared(never)).IsEqualTo("12 of 300 (4.0%)"); + await Assert.That(EcosystemCopy.Declared("en", never)).IsEqualTo( + Say("ecosystem.share", ("count", 12), ("total", 300), ("fraction", 12d / 300))); + await Assert.That(EcosystemCopy.Declared("en", never)).IsEqualTo("12 of 300 (4.0%)"); } [Test] @@ -100,8 +121,9 @@ public async Task AnEmptyDenominatorIsNothingMeasuredAndNotNoughtPerCent() var nothing = new MeasuredShare("GMCP", 0, 0); await Assert.That(nothing.Fraction).IsNull(); - await Assert.That(EcosystemCopy.Share(nothing)).Contains("nothing measured yet"); - await Assert.That(EcosystemCopy.Share(nothing)).DoesNotContain("%"); + await Assert.That(EcosystemCopy.Share("en", nothing)) + .IsEqualTo(Say("ecosystem.share.nothing", ("count", 0), ("total", 0))); + await Assert.That(EcosystemCopy.Share("en", nothing)).DoesNotContain("%"); } [Test] @@ -112,8 +134,7 @@ public async Task TheMeasuredColumnIsSaidToBeAFloor() // saying so publishes our own instrumentation as a fact about somebody's game. var text = Render.Words(await EcosystemAsync()); - await Assert.That(text).Contains("may support a protocol without ever offering it"); - await Assert.That(text).Contains("as a floor"); + await Assert.That(text).Contains(Say("ecosystem.protocols.floor")); } [Test] @@ -124,8 +145,8 @@ public async Task TheDashboardCallsItselfASnapshotAndNotATrend() // crawl reaching more games and nothing about anybody adopting anything. var text = Render.Words(await EcosystemAsync()); - await Assert.That(text).Contains("A snapshot of what we can measure now"); - await Assert.That(text).Contains("nothing to plot"); + await Assert.That(text).Contains(Say("ecosystem.snapshot")); + await Assert.That(text).Contains(Say("ecosystem.transitions.none")); await Assert.That(text).DoesNotContain("growth"); } @@ -138,7 +159,10 @@ public async Task AGameWithNoCodebaseIsOutsideTheDenominatorAndSaidToBe() await Assert.That(dashboard.Codebases.NotIdentified).IsGreaterThan(0); await Assert.That(dashboard.Codebases.Families.Sum(f => f.Count)) .IsEqualTo(dashboard.Codebases.Identified); - await Assert.That(text).Contains("left out of the denominator, never counted as something else"); + await Assert.That(text).Contains(Say( + "ecosystem.codebases.basis", + ("listed", dashboard.Codebases.Identified + dashboard.Codebases.NotIdentified), + ("identified", dashboard.Codebases.Identified))); } [Test] @@ -155,8 +179,13 @@ public async Task TheCodebasePanelNamesTheListingBesideTheGamesThatAnswered() await Assert.That(listed).IsEqualTo(dashboard.ListedGames); await Assert.That(dashboard.Codebases.Identified).IsNotEqualTo(listed); - await Assert.That(text).Contains($"Of the {listed} games listed, {dashboard.Codebases.Identified} told us what they run"); - await Assert.That(text).Contains($"every share below is over those {dashboard.Codebases.Identified}"); + // Both numbers in one sentence, and each unmistakable for the other. + await Assert.That(text).Contains(Say( + "ecosystem.codebases.basis", + ("listed", listed), + ("identified", dashboard.Codebases.Identified))); + await Assert.That(text).Contains($"{listed} games listed"); + await Assert.That(text).Contains($"over those {dashboard.Codebases.Identified}"); } /// <summary>The one-game codebases are folded out of the chart and listed under it.</summary> @@ -177,7 +206,8 @@ public async Task ACodebaseOnlyOneGameRunsIsFoldedOutOfTheChartAndStillPrinted() await Assert.That(text).Contains( $"{codebases.SoleUseTotal.Count} of {codebases.Identified}"); - await Assert.That(text).Contains("no other listed game runs"); + await Assert.That(text).Contains( + Say("ecosystem.soleUse", ("share", EcosystemCopy.Share("en", codebases.SoleUseTotal)))); foreach (var alone in codebases.SoleUse) { @@ -201,7 +231,8 @@ public async Task TheMsspRowStaysBecauseItIsTheOnlyMeasurementThatIsNotAFloor() await Assert.That(mssp.Measured).IsNotNull(); await Assert.That(mssp.Declined).IsGreaterThan(0); await Assert.That(text).Contains("MSSP"); - await Assert.That(text).Contains("is the one row below that is not a floor"); + await Assert.That(text).Contains( + Say("ecosystem.mssp.instrument", ("instrument", EcosystemProtocols.Instrument))); } [Test] @@ -218,9 +249,9 @@ public async Task OnlyMsspHasNoDeclaredFigureAndTheReasonIsItsDenominator() var blank = dashboard.Protocols.Where(p => p.DeclaredShare is null).Select(p => p.Protocol); await Assert.That(blank).IsEquivalentTo(new[] { "MSSP" }); - await Assert.That(EcosystemCopy.Declared(dashboard.Protocols.Single(p => p.Protocol == "MSSP"))) + await Assert.That(EcosystemCopy.Declared("en", dashboard.Protocols.Single(p => p.Protocol == "MSSP"))) .DoesNotContain("%"); - await Assert.That(text).Contains("every report here is the answer"); + await Assert.That(text).Contains(Say("ecosystem.declared.none")); } [Test] @@ -236,13 +267,14 @@ public async Task TwoCountsOfMsspAreReconciledRatherThanLeftToSubtract() var withGap = new ProtocolAdoption("MSSP", Offered: 123, Declined: 295, Handshakes: 418, Declared: 1, MsspReports: 131); - await Assert.That(EcosystemCopy.MsspBasis(withGap, 131)).Contains("We hold 131 reports"); - await Assert.That(EcosystemCopy.MsspBasis(withGap, 131)).Contains("the other 8"); + await Assert.That(EcosystemCopy.MsspBasis("en", withGap, 131)).Contains( + Say("ecosystem.mssp.gap", ("reports", 131), ("offered", 123), ("gap", 8))); // And no gap means no sentence about one, rather than "the other 0". var level = withGap with { Offered = 131 }; - await Assert.That(EcosystemCopy.MsspBasis(level, 131)).DoesNotContain("the other"); + await Assert.That(EcosystemCopy.MsspBasis("en", level, 131)) + .IsEqualTo(Say("ecosystem.mssp.instrument", ("instrument", EcosystemProtocols.Instrument))); } [Test] @@ -250,9 +282,15 @@ public async Task TheRankingsStateWhatTheyRankOnAndOverWhatWindow() { var text = Render.Words(await RankingsAsync()); - await Assert.That(text).Contains("Median of the player counts we measured over the last 7 days"); - await Assert.That(text).Contains("counted samples a median needs"); - await Assert.That(text).Contains("A measured zero counts; an unreadable count does not"); + await Assert.That(text).Contains(Say("rankings.basis.median", ("days", 7))); + + // The threshold, as a sentence rather than as arithmetic. Where nothing qualifies the page + // said "0 of 519 games listed produced the 24 counted samples a median needs, on at least 4 + // days of the window", which is a subtraction the reader was left to do. + await Assert.That(text).Contains("24 samples across 4 days"); + + // Rule 4 on the surface that most invites a zero to be read as an absence. + await Assert.That(text).Contains(Say("rankings.basis.zero")); } [Test] @@ -261,7 +299,7 @@ public async Task TheRankingsOfferNoVoteAndClaimNoBest() // §2's permanent non-goal, said on the surface a reader would look for it on. var text = Render.Words(await RankingsAsync()); - await Assert.That(text).Contains("No votes, stars or ratings, ever"); + await Assert.That(text).Contains(Say("rankings.noVote")); await Assert.That(text.ToLowerInvariant()).DoesNotContain("rate this"); await Assert.That(text.ToLowerInvariant()).DoesNotContain("top rated"); } diff --git a/tests/MUI.Web.Tests/FacetSurfaceTests.cs b/tests/MUI.Web.Tests/FacetSurfaceTests.cs index 6cf11d6..1f6e01c 100644 --- a/tests/MUI.Web.Tests/FacetSurfaceTests.cs +++ b/tests/MUI.Web.Tests/FacetSurfaceTests.cs @@ -1,3 +1,4 @@ +using MUI.Web.Localization; using System.Reflection; using MUI.Catalog; @@ -39,6 +40,12 @@ .. typeof(FacetKeys) FacetKeys.Tls => "true", FacetKeys.Band => "quiet", FacetKeys.LastSeen => "week", + + // One word each, like the two bands above and unlike the open-ended facets: their + // vocabularies are a single value, so the binding refuses anything else rather than + // narrowing a listing to nothing on a typo. + FacetKeys.Uncounted => "yes", + FacetKeys.Unreachable => "yes", FacetKeys.Protocol => "GMCP", // Not the default. The point of the check below is that the parameter changed something, // and asking for the order the filter already arrives in changes nothing by construction. @@ -216,9 +223,16 @@ public async Task ThePanelIsAPlainGetFormWithAControlPerFacet() await Assert.That(html).Contains("action=\"/games\""); await Assert.That(html).DoesNotContain("<script"); + // Every facet reaches the same querystring, whichever shape its control has: the presence + // facets are checkboxes the form submits, and the choice facets are links that carry the + // key themselves — a control that waited for a "show" button was a filter that did nothing + // when a reader clicked it. foreach (var group in (await Queries.SearchAsync(new GameFilter())).Facets) { - await Assert.That(html).Contains($"name=\"{group.Key}\""); + var named = html.Contains($"name=\"{group.Key}\"", StringComparison.Ordinal) + || html.Contains($"/games?{group.Key}=", StringComparison.Ordinal); + + await Assert.That(named).IsTrue().Because($"{group.Key} reaches no querystring"); } } @@ -228,12 +242,72 @@ public async Task EveryValueOnThePanelCarriesTheCountChoosingItReturns() var listing = await Queries.SearchAsync(new GameFilter()); var html = Render.Words(await PanelAsync(new GameFilter())); + // A row per value now, rather than an option per value twice over: the count is its own cell + // beside the name, and it is also in both radios' accessible names — the one that includes + // the value carries what including it returns, the one that excludes it carries what + // excluding it returns. A control offering a number the listing would not produce is the + // failure this guards against, in either direction. foreach (var group in listing.Facets.Where(g => g.Kind is FacetKind.Choice)) { + var single = FacetWords.IsSingleChoice(group.Key); + foreach (var value in group.Values) { - await Assert.That(html) - .Contains($"{FacetWords.Value(group.Key, value)} ({value.Count})"); + var name = FacetWords.Value(Locales.SourceTag, group.Key, value); + + // "only" is on the tri-state groups alone. Activity and last-seen are one ordered + // scale — a radio group — so their rows say what choosing returns and nothing about + // a second state they do not have. + await Assert.That(html).Contains(single + ? $"{name}, {Plural(value.Count)}" + : $"{name}, {Plural(value.Count)}, only"); + + if (!single) + { + await Assert.That(html) + .Contains($"{name}, {Plural(group.Total - value.Count)}, excluded"); + } + } + } + } + + /// <summary> + /// A count and its noun, agreeing — because the panel says it that way. + /// </summary> + /// <remarks> + /// Every accessible name on the panel read "1 games" and "0 games" until this pass. English has + /// two forms and this is the one place the panel says a number out loud, so it says it + /// correctly; the test spells the rule out rather than accepting whatever the panel produced. + /// </remarks> + private static string Plural(int count) => count == 1 ? "1 game" : $"{count} games"; + + [Test] + public async Task ExclusionIsOfferedOnlyWhereExcludingMeansSomething() + { + // Activity and last-seen are nested thresholds on one ordered scale: a game reached an hour + // ago is also in the last seven days and the last thirty, and "connected now" is a narrower + // window than "active this week" rather than a different kind of thing. "Everything but + // games with somebody connected" is not a question anybody has — so those groups are radios + // with no exclude affordance at all, which is one control and one tab stop per value instead + // of two. + var listing = await Queries.SearchAsync(new GameFilter()); + var html = await PanelAsync(new GameFilter()); + + foreach (var group in listing.Facets.Where(g => g.Kind is FacetKind.Choice)) + { + foreach (var value in group.Values) + { + var excluded = $"{FacetWords.Value(Locales.SourceTag, group.Key, value)}, {Plural(group.Total - value.Count)}, excluded"; + + if (FacetWords.IsSingleChoice(group.Key)) + { + await Assert.That(html).DoesNotContain(excluded) + .Because($"{group.Key} is one ordered scale and cannot be excluded from"); + } + else + { + await Assert.That(html).Contains(excluded); + } } } } @@ -241,19 +315,19 @@ await Assert.That(html) [Test] public async Task ThePanelSaysInWordsThatAnUnknownIsNotANo() { - // Said in the markup, not only in a comment. A reader ticking boxes is exactly the person who - // would otherwise read an unticked box as the game declining a protocol. + // Said in the markup, not only in a comment. A reader who reads an unticked box as the game + // declining a protocol has been told something the site never measured. // - // The prose these used to sit in is gone — the panel explained itself at more length than it - // took to operate — so each of them now has a place of its own: the tick-box reading is a - // line inside the fieldset it is about, and the rest is one disclosure. What may not change - // is that they are all still in the document, which is what this asserts. + // The three lines that used to sit under each group header are gone at the user's direction, + // so the reading now has one home rather than several: the disclosure at the foot of the + // panel. What may not change is that it is still in the document — a <details> keeps its + // contents in the accessibility tree and in what a text browser is served, which is what + // makes it a fair place to put the long form of a rule and not a place to hide one. var words = Render.Words(await PanelAsync(new GameFilter())); - await Assert.That(words).Contains("Unticked is not a no"); await Assert.That(words).Contains("A blank is a gap in our measurement, not a no"); await Assert.That(words).Contains("not identified"); - await Assert.That(words).Contains("from the same query as the list below"); + await Assert.That(words).Contains("Counts are games we measured, never estimates"); await Assert.That(words).Contains("An unknown count is not a zero"); } @@ -267,7 +341,7 @@ public async Task TheDisclosureIsAnAffordanceRatherThanAPlaceToHideThings() var html = await PanelAsync(new GameFilter()); await Assert.That(html).Contains("<summary>"); - await Assert.That(Render.Words(html)).Contains("what a blank means"); + await Assert.That(Render.Words(html)).Contains("what the badges and the blanks mean"); } [Test] @@ -282,9 +356,9 @@ public async Task AFacetWithNoValueForAGameSpellsThatOutInItsOwnWords() await Assert.That(words).Contains("not declared"); await Assert.That(words).Contains("nothing negotiated"); - await Assert.That(FacetWords.Unknown(FacetKeys.Codebase)).IsNotEqualTo("no"); - await Assert.That(FacetWords.Unknown(FacetKeys.Genre)) - .IsNotEqualTo(FacetWords.Unknown(FacetKeys.Charset)); + await Assert.That(FacetWords.Unknown(Locales.SourceTag, FacetKeys.Codebase)).IsNotEqualTo("no"); + await Assert.That(FacetWords.Unknown(Locales.SourceTag, FacetKeys.Genre)) + .IsNotEqualTo(FacetWords.Unknown(Locales.SourceTag, FacetKeys.Charset)); } [Test] @@ -303,16 +377,16 @@ public async Task EachFacetSaysWhetherItIsAMeasurementOrTheGamesOwnClaim() // likely to guess at and the one it would matter most to leave unexplained. foreach (var evidence in Enum.GetValues<FacetEvidence>()) { - await Assert.That(words).Contains(FacetWords.Evidence(evidence)); - await Assert.That(words).Contains(FacetWords.EvidenceMeaning(evidence)); + await Assert.That(words).Contains(FacetWords.Evidence(Locales.SourceTag, evidence)); + await Assert.That(words).Contains(FacetWords.EvidenceMeaning(Locales.SourceTag, evidence)); } // And no two of them say the same thing, or the panel has a distinction it cannot draw. var registers = Enum.GetValues<FacetEvidence>().Length; - await Assert.That(Enum.GetValues<FacetEvidence>().Select(FacetWords.Evidence).Distinct().Count()) + await Assert.That(Enum.GetValues<FacetEvidence>().Select(e => FacetWords.Evidence(Locales.SourceTag, e)).Distinct().Count()) .IsEqualTo(registers); await Assert.That( - Enum.GetValues<FacetEvidence>().Select(FacetWords.EvidenceMeaning).Distinct().Count()) + Enum.GetValues<FacetEvidence>().Select(e => FacetWords.EvidenceMeaning(Locales.SourceTag, e)).Distinct().Count()) .IsEqualTo(registers); } @@ -330,7 +404,7 @@ public async Task AGroupsEvidenceIsSaidOnTheGroupAndNotOnlyInTheKey() // Read off the label element itself rather than off an offset into the page: the facet // names are ordinary English words and several of them occur in the option text of other // facets, so anything positional here measures the wrong thing. - var marker = $"<span class=\"facet-name\">{FacetWords.Group(group.Key)}</span>"; + var marker = $"<span class=\"facet-name\">{DrawnUnder(group.Key)}</span>"; var at = html.IndexOf(marker, StringComparison.Ordinal); await Assert.That(at).IsGreaterThanOrEqualTo(0).Because($"{group.Key} has no name of its own"); @@ -345,19 +419,39 @@ public async Task AGroupsEvidenceIsSaidOnTheGroupAndNotOnlyInTheKey() // The class and the word are the same string on purpose: a second copy of the mapping // here is a place for the test and the panel to drift apart, and it did — a register // added to the enum arrived in this helper as "declared". - await Assert.That(label).Contains($"evidence {FacetWords.Evidence(group.Evidence)}") + await Assert.That(label).Contains($"evidence {FacetWords.Evidence(Locales.SourceTag, group.Evidence)}") .Because($"{group.Key} has no evidence chip beside its own name"); } } + /// <summary> + /// The heading a facet's rows are actually drawn under, which is its own name for all but two. + /// </summary> + /// <remarks> + /// <c>uncounted</c> and <c>unreachable</c> share one legend, because they are one question with + /// two independent answers rather than two facets that happen to be adjacent — see the panel. + /// The guarantee this test exists for is unweakened by that: the evidence chip is on the legend + /// both rows sit under, so a reader still cannot reach either count without having been told + /// what kind of statement it is. What would weaken it is a group drawn with no heading at all, + /// and that is still what this fails on. + /// </remarks> + private static string DrawnUnder(string key) => + key is FacetKeys.Uncounted or FacetKeys.Unreachable + ? Messages.For(Locales.SourceTag, "facet.group.measure") + : FacetWords.Group(Locales.SourceTag, key); + [Test] public async Task AChosenValueIsMarkedSoTheFormShowsWhatTheUrlAsked() { + // No <select> and no checkbox left on this panel: the state is the row's own class and its + // aria-current, and the way out is the row's own link. A control that showed nothing at rest + // until it was opened is the defect the rows replace. var filter = new GameFilter { Band = ActivityBand.Archived, IncludeArchived = true }; var html = await PanelAsync(filter); - await Assert.That(html).Contains("selected"); - await Assert.That(html).Contains("checked"); + await Assert.That(html).Contains("aria-current=\"true\""); + await Assert.That(html).Contains("facet-row on"); + await Assert.That(html).DoesNotContain("<select"); } [Test] @@ -409,7 +503,7 @@ public async Task WhatTheQueryIsAskingForIsRepeatedAsChipsThatRemoveThemselves() await Assert.That(GameFilterBinding.TryRead(Url, out var query, out _)).IsTrue(); var listing = await Queries.SearchAsync(query.Filter); - var chips = ActiveFilters.For(listing.Facets, query.Filter, Url); + var chips = ActiveFilters.For(Locales.SourceTag, listing.Facets, query.Filter, Url); await Assert.That(chips.Select(c => c.Value)).Contains("not Evennia"); await Assert.That(chips.Select(c => c.Value)).Contains("sun"); @@ -421,6 +515,50 @@ public async Task WhatTheQueryIsAskingForIsRepeatedAsChipsThatRemoveThemselves() await Assert.That(gmcp.RemoveHref).DoesNotContain("GMCP"); } + /// <summary>Every chip is a translated word, including the four the panel does not supply.</summary> + /// <remarks> + /// Three chips are built by <see cref="ActiveFilters"/> itself rather than read off a facet + /// group — a typed name, and the two widenings — and all three, plus the word "included", were + /// still literal English after the rest of the site was localized. A translated listing rendered + /// them beside translated chips, so one row mixed two languages. Asserted by asking the bundle + /// what each says rather than by repeating the English, which is the whole point of the fix. + /// </remarks> + [Test] + public async Task EveryChipIsAWordFromTheBundleAndNotALiteral() + { + const string Url = $"?q=sun&{FacetKeys.Archived}=true&{FacetKeys.Adult}=true"; + var en = Locales.SourceTag; + + await Assert.That(GameFilterBinding.TryRead(Url, out var query, out _)).IsTrue(); + + var listing = await Queries.SearchAsync(query.Filter); + var chips = ActiveFilters.For(en, listing.Facets, query.Filter, Url); + var facets = chips.Select(c => c.Facet).ToList(); + + foreach (var key in (string[])[FacetKeys.Text, FacetKeys.Archived, FacetKeys.Adult]) + { + await Assert.That(facets) + .Contains(FacetWords.Group(en, key)) + .Because($"the {key} chip names itself from the bundle"); + } + + // "included" is the only chip value that is a state of ours rather than a token a game gave + // us, so it is the only one that has to be translated rather than passed through. + var included = Messages.For(en, "facet.value.included"); + + await Assert.That(chips.Count(c => c.Value == included)).IsEqualTo(2); + + // And none of the four is a bare key leaking through FacetWords.Group's fallback, which + // cannot be told from the English by comparing strings — "archived" is both the facet key + // and the word. So the bundle is asked whether it owns the id at all: an id the bundle has + // is an id a translator can reach, and that is the thing being asserted. + foreach (var id in (string[]) + ["facet.group.search", "facet.group.archived", "facet.group.adult", "facet.value.included"]) + { + await Assert.That(Messages.Ids).Contains(id); + } + } + [Test] public async Task NothingSelectedIsNoChipsAtAll() { @@ -433,7 +571,7 @@ public async Task NothingSelectedIsNoChipsAtAll() var listing = await Queries.SearchAsync(query.Filter); - await Assert.That(ActiveFilters.For(listing.Facets, query.Filter, string.Empty)).IsEmpty(); + await Assert.That(ActiveFilters.For(Locales.SourceTag, listing.Facets, query.Filter, string.Empty)).IsEmpty(); } [Test] @@ -448,13 +586,20 @@ public async Task AnUnreadableSortIsRefusedRatherThanQuietlyIgnored() [Test] public async Task TheSortIsAControlOnThePanelAndAParameterInTheUrl() { + // The order moved off this panel and into the listing's own toolbar, over the column whose + // numbers it changes — a pressed-state switch of links rather than a <select> that armed + // itself and waited for a "show" button. What the panel may not do is keep a second, stale + // copy of the control. var html = await PanelAsync(new GameFilter { Sort = GameSort.Players }); - await Assert.That(html).Contains($"name=\"{FacetKeys.Sort}\""); + await Assert.That(html).DoesNotContain($"name=\"{FacetKeys.Sort}\""); + await Assert.That(html).DoesNotContain("<select"); + // Every order is still a parameter, and still named, wherever it is drawn. foreach (var sort in Enum.GetValues<GameSort>()) { - await Assert.That(Render.Words(html)).Contains(FacetWords.Sort(sort)); + await Assert.That(FacetWords.Sort(Locales.SourceTag, sort)).IsNotEmpty(); + await Assert.That(FacetTokens.Of(sort)).IsNotEmpty(); } } @@ -466,11 +611,241 @@ public async Task NoSortCallsItselfBusiestBecauseTheRankingsPageAlreadyMeansSome // answering to one name on one site is how a reader ends up comparing them. foreach (var sort in Enum.GetValues<GameSort>()) { - await Assert.That(FacetWords.Sort(sort)).DoesNotContain("busiest"); - await Assert.That(FacetWords.Sort(sort)).DoesNotContain("popular"); + await Assert.That(FacetWords.Sort(Locales.SourceTag, sort)).DoesNotContain("busiest"); + await Assert.That(FacetWords.Sort(Locales.SourceTag, sort)).DoesNotContain("popular"); } } + [Test] + public async Task AValueIsOneRowWithThreeStatesRatherThanTwoOptionsInTwoLists() + { + // Finding B3. Every value used to appear twice in one select — once under "only", once under + // "anything but" — so thirteen codebases were twenty-seven options, read out as near-identical + // pairs, and the state showed nothing at rest: a select sitting in its second group looks + // exactly like one sitting on "any" until it is opened. + // + // Two radios per row now, sharing the facet's key. No script: the browser's own group + // behaviour is what clears the other rows, and the querystring is the one the binding and the + // read API already parse. + var html = await PanelAsync(new GameFilter()); + + var grid = html[html.IndexOf("facet-grid", StringComparison.Ordinal)..]; + + // The sort control keeps its optgroups — grouping nine orders by what each one reads is a + // different job from listing one facet's values twice. + await Assert.That(grid).DoesNotContain("<optgroup"); + // Links, not controls: a filter that needs a second click on a "show" button before it does + // anything is a filter panel that does not work, which is what radios made these. + await Assert.That(html).Contains("href=\"/games?codebase=Evennia\""); + await Assert.That(html).Contains("href=\"/games?codebase=%21Evennia\""); + + // And the whole facet is still one tab stop, as the select was: one radio group, arrow keys + // within it. + // And no prose under the group headers. The three notes that lived there — "tick to + // include", "pick one", "unticked means not measured" — are gone at the user's direction: + // the control's shape says what it does, and a panel explaining itself once per group is a + // panel nobody reads once. + await Assert.That(Render.Words(html)).DoesNotContain("Tick to include"); + await Assert.That(Render.Words(html)).DoesNotContain("Pick one."); + await Assert.That(Render.Words(html)).DoesNotContain("Unticked means not measured"); + } + + [Test] + public async Task AnExcludedValueSaysSoInTheRowAndInTheControlsName() + { + // "PennMUSH, 23 games, excluded" — the value, the count excluding it returns, and the state, + // in the accessible name, because a reader arrowing through a radio group hears the control + // and not the row around it. The strike-through and the × are the drawing of the same fact, + // and neither of them is a colour. + var html = await PanelAsync(new GameFilter { Codebase = FacetChoice.Not("Evennia") }); + + await Assert.That(html).Contains("class=\"facet-row excluded\""); + await Assert.That(Render.Words(html)).Contains("games, excluded\""); + // And the applied one links to clearing itself, so a row unticks where it was ticked. + await Assert.That(html).Contains("aria-current=\"true\""); + await Assert.That(html).Contains("href=\"/games\""); + } + + // ── what we could measure ──────────────────────────────────────────────────────────────── + + [Test] + public async Task TheDemoTellsAMeasuredZeroFromAnUnreadableCountFromAGameWeNeverReached() + { + // The fixture's own three-way split, asserted before anything renders. All three of these + // games are on the listing and none of them is "a game with players on"; Eldertale was + // counted and found empty, Midnight Sun answered and could not be counted, and Hollow Bell + // did not answer. A demo that could not tell them apart would be a demo of the wrong site. + var listing = await Queries.SearchAsync(new GameFilter()); + + var uncounted = await Queries.ListAsync( + new GameFilter { Uncounted = FacetChoice.Of(FacetTokens.Yes) }); + var unreachable = await Queries.ListAsync( + new GameFilter { Unreachable = FacetChoice.Of(FacetTokens.Yes) }); + + await Assert.That(uncounted.Select(g => g.Slug)).IsEquivalentTo(new[] { "midnight-sun" }); + await Assert.That(unreachable.Select(g => g.Slug)).IsEquivalentTo(new[] { "hollow-bell" }); + + // Eldertale is the trap: a measured nought, in the same activity band as Midnight Sun. + var eldertale = listing.Games.Single(g => g.Slug == "eldertale"); + + await Assert.That(eldertale.PlayersNow).IsEqualTo(0); + await Assert.That(uncounted.Any(g => g.Slug == "eldertale")).IsFalse(); + + // And Hollow Bell is the other one: no number, and not because we failed to read one. + await Assert.That(uncounted.Any(g => g.Slug == "hollow-bell")).IsFalse(); + } + + [Test] + public async Task TheGroupDrawsBothSwitchesUnderOneHeadingWithTheirRealCounts() + { + var html = Render.Words(await PanelAsync(new GameFilter())); + var listing = await Queries.SearchAsync(new GameFilter()); + + await Assert.That(html).Contains(Messages.For(Locales.SourceTag, "facet.group.measure")); + + foreach (var key in new[] { FacetKeys.Uncounted, FacetKeys.Unreachable }) + { + var group = listing.Facets.Single(f => f.Key == key); + var value = group.Values.Single(); + + await Assert.That(value.Count).IsGreaterThan(0); + await Assert.That(html) + .Contains(FacetWords.Value(Locales.SourceTag, key, value)) + .Because($"{key} has no row on the panel"); + + // The count beside it is the one the listing keeps, which is the panel's whole promise. + await Assert.That((await Queries.ListAsync(Choose(key))).Count).IsEqualTo(value.Count); + } + } + + [Test] + public async Task HidingThemIsSaidToBeOurFilterAndNotAClaimAboutTheGames() + { + // Rule 5 on the one control most likely to be read the other way. A reader who unticks these + // has changed their listing, and the panel has to say that in words rather than leave a + // shorter listing to be read as a shorter hobby. + var html = Render.Words(await PanelAsync(new GameFilter())); + + await Assert.That(html).Contains(Messages.For(Locales.SourceTag, "facet.measure.note")); + + // And the same sentence survives on the surface that has no styling to carry a tone. Read + // with the whitespace collapsed, because the plain renderer wraps at 80 columns and the + // sentence is longer than that — a literal comparison here would be asserting where the line + // breaks fall rather than that the words are present. + var listing = await Queries.SearchAsync(new GameFilter()); + var text = PlainText.RenderListing(listing, new GameFilter(), FixtureGameQueries.Now); + + await Assert.That(Flowed(text)) + .Contains(Flowed(Messages.For(Locales.SourceTag, "facet.measure.note"))); + } + + /// <summary>One line of text, whatever column the renderer broke it at.</summary> + private static string Flowed(string text) => + string.Join(' ', text.Split((char[]?)null, StringSplitOptions.RemoveEmptyEntries)); + + [Test] + public async Task ThePlainSurfaceDrawsIncludedAndExcludedDifferently() + { + // "Only these" and "anything but these" are opposite filters, and one star for both drew + // them identically on the surface where a reader has nothing else to go on. It matters most + // here, because excluding is what these two switches are mostly for. + var included = new GameFilter { Uncounted = FacetChoice.Of(FacetTokens.Yes) }; + var excluded = new GameFilter { Uncounted = FacetChoice.Not(FacetTokens.Yes) }; + + var onText = PlainText.RenderListing( + await Queries.SearchAsync(included), included, FixtureGameQueries.Now); + var offText = PlainText.RenderListing( + await Queries.SearchAsync(excluded), excluded, FixtureGameQueries.Now); + + await Assert.That(onText).Contains($"* {FacetTokens.Yes}"); + await Assert.That(offText).Contains($"- {FacetTokens.Yes}"); + await Assert.That(offText).DoesNotContain($"* {FacetTokens.Yes}"); + + // And the column has a key, because a mark nobody explains is a mark nobody reads. + await Assert.That(Flowed(offText)) + .Contains(Flowed(Messages.For(Locales.SourceTag, "facet.plain.marks"))); + } + + [Test] + [Arguments(FacetKeys.Uncounted)] + [Arguments(FacetKeys.Unreachable)] + public async Task EachSwitchRoundTripsThroughTheQuerystringInBothPolarities(string key) + { + // Three states and a URL for each, read back by the one parser /games and /api/games share. + foreach (var token in new[] { FacetTokens.Yes, FacetChoice.ExcludeToken + FacetTokens.Yes }) + { + var read = GameFilterBinding.TryRead($"?{key}={token}", out var query, out var error); + + await Assert.That(read).IsTrue().Because($"?{key}={token}: {error}"); + + var choice = key == FacetKeys.Uncounted ? query.Filter.Uncounted : query.Filter.Unreachable; + + await Assert.That(choice).IsNotNull(); + await Assert.That(choice!.Token).IsEqualTo(token); + + // The panel's own link for that state is in the markup, so the round trip is a click and + // not only a hand-typed URL. + var html = await PanelAsync(query.Filter); + await Assert.That(html).Contains("aria-current=\"true\""); + } + + // And absent is the third state: not asked, and so not narrowed. + GameFilterBinding.TryRead(string.Empty, out var bare, out _); + await Assert.That(key == FacetKeys.Uncounted ? bare.Filter.Uncounted : bare.Filter.Unreachable) + .IsNull(); + } + + [Test] + [Arguments(FacetKeys.Uncounted)] + [Arguments(FacetKeys.Unreachable)] + public async Task AValueTheseSwitchesDoNotHaveIsRefusedRatherThanQuietlyEmptying(string key) + { + // Their vocabulary is one word, so anything else is a typo — and a typo that narrowed the + // listing to nothing would hand a reader an empty page to read as "no game is like that", + // which is our own parser published as a measurement of the hobby. + var read = GameFilterBinding.TryRead($"?{key}=maybe", out _, out var error); + + await Assert.That(read).IsFalse(); + await Assert.That(error).IsNotNull(); + await Assert.That(error!).Contains(FacetTokens.Yes); + } + + [Test] + public async Task ExcludingBothLeavesAListingThatStillOffersTheWayBack() + { + // The listing shrinks and the two controls that shrank it stay drawn, at the count that + // undoing them returns. A selection whose only affordance has gone is the defect the rows + // replaced. + var filter = new GameFilter + { + Uncounted = FacetChoice.Not(FacetTokens.Yes), + Unreachable = FacetChoice.Not(FacetTokens.Yes), + }; + + var listing = await Queries.SearchAsync(filter); + var html = await PanelAsync(filter); + + await Assert.That(listing.Games.Any(g => g.Slug == "midnight-sun")).IsFalse(); + await Assert.That(listing.Games.Any(g => g.Slug == "hollow-bell")).IsFalse(); + + // Eldertale is a measured nought and survives both exclusions, which is the point of them + // being two facets rather than one word for "no number". + await Assert.That(listing.Games.Any(g => g.Slug == "eldertale")).IsTrue(); + + foreach (var key in new[] { FacetKeys.Uncounted, FacetKeys.Unreachable }) + { + await Assert.That(listing.Facets.Single(f => f.Key == key).Values.Single().State) + .IsEqualTo(FacetState.Excluded); + } + + await Assert.That(Render.Words(html)) + .Contains(Messages.For(Locales.SourceTag, "facet.excluded.uncounted")); + } + + private static GameFilter Choose(string key) => key == FacetKeys.Uncounted + ? new GameFilter { Uncounted = FacetChoice.Of(FacetTokens.Yes) } + : new GameFilter { Unreachable = FacetChoice.Of(FacetTokens.Yes) }; + private static async Task<string> PanelAsync(GameFilter filter) { var listing = await Queries.SearchAsync(filter); @@ -483,28 +858,28 @@ private static async Task<string> PanelAsync(GameFilter filter) } /// <summary> - /// A filter as one comparable string. + /// A filter as one comparable string, so two of them can be compared for having read anything. /// </summary> /// <remarks> + /// <para> /// Record equality would compare <see cref="GameFilter.MeasuredProtocols"/> by reference and so /// call every parsed filter different from every other — which would make the test above pass /// whatever the parser did with a key. + /// </para> + /// <para> + /// <b>Read off the type rather than listed here, and that is the fix rather than tidying.</b> + /// This was a hand-written roll-call of sixteen members, in a test whose entire job is to catch a + /// facet that was added in one place and forgotten in another — so a new member reached it as + /// silence: the binding read the parameter correctly, the fingerprint could not see it, and the + /// failure said "nothing reads it" about the one thing that did. A list maintained by hand + /// cannot be the check on a list maintained by hand. + /// </para> /// </remarks> private static string Describe(GameFilter f) => string.Join( '|', - f.Text, - f.IncludeArchived, - f.IncludeAdult, - f.Tls, - f.Band, - f.LastSeen, - f.Charset?.Token, - f.Codebase?.Token, - f.CodebaseVersion?.Token, - f.Lineage?.Token, - f.Family?.Token, - f.Genre?.Token, - f.Language?.Token, - f.Sort, - string.Join(',', f.MeasuredProtocols)); + typeof(GameFilter) + .GetProperties(BindingFlags.Public | BindingFlags.Instance) + .OrderBy(p => p.Name, StringComparer.Ordinal) + .Select(p => p.GetValue(f)) + .Select(v => v is IEnumerable<string> many ? string.Join(',', many) : v?.ToString())); } diff --git a/tests/MUI.Web.Tests/FeedAndArchiveTests.cs b/tests/MUI.Web.Tests/FeedAndArchiveTests.cs index 96f2027..e82dd8e 100644 --- a/tests/MUI.Web.Tests/FeedAndArchiveTests.cs +++ b/tests/MUI.Web.Tests/FeedAndArchiveTests.cs @@ -1,3 +1,5 @@ +using MUI.Web.Localization; + using MUI.Catalog; using MUI.Web.Components; using MUI.Web.Fixtures; @@ -35,25 +37,43 @@ public async Task TheThreeRegistersAreOneShapeWithThreeHeadings() foreach (var html in new[] { discovered, dark, back }) { - await Assert.That(html).Contains("<article class=\"feed-card"); + // A row rather than a card: three columns of boxes gave a name and an age the furniture + // of a section, on a page whose only other framed thing is somebody else's connect + // screen. The three registers are still three, and still one shape. + await Assert.That(html).Contains("<article class=\"feed-row"); await Assert.That(html).Contains("href=\"/g/x\""); } } [Test] - public async Task TheReturnCardGetsTheFullSentenceAtBodySizeAndTheOthersDoNot() + public async Task ARowSaysWhatHappenedAndWhenAndNothingTheHeadingAlreadySaid() { - // The one place the site raises its voice, and it earns it: a game dark for two years - // answering is the thing nobody else can tell you. - var entry = new FeedEntry(Guid.NewGuid(), "x", "The Long Sleep", Now, "Answered again after 26 months dark."); + // Three lists of five rows, and every row used to carry a prose line under it — "first + // seen", "answered again", "we keep knocking", and on the discovery feed the referral that + // found the game and the codebase it answered with. The column heading above says which + // register this is, so each of those was the same fact announced twice: twenty extra lines + // on the front page for a screen reader to wade through. + // + // What survives is a *cause*, which is not a repetition of the heading — the socket was + // refused, or the name did not resolve. It rides in the one right-hand cell beside the age + // rather than on a second line: "refused · 16h". + var entry = new FeedEntry(Guid.NewGuid(), "x", "The Long Sleep", Now, "connection refused"); var back = await CardAsync(entry, FeedKind.CameBack); var dark = await CardAsync(entry, FeedKind.WentDark); + var found = await CardAsync(entry, FeedKind.NewlyDiscovered); - await Assert.That(back).Contains("class=\"return-line\""); - await Assert.That(back).Contains("● live"); - await Assert.That(dark).Contains("class=\"mono detail\""); - await Assert.That(dark).DoesNotContain("class=\"return-line\""); + // No second line on any of the three. + foreach (var html in new[] { back, dark, found }) + { + await Assert.That(html).DoesNotContain("class=\"return-line\""); + await Assert.That(html).DoesNotContain("class=\"mono detail\""); + } + + // A return says it is back; a cause appears only where there is one to give. + await Assert.That(Render.Words(back)).Contains("live"); + await Assert.That(Render.Words(dark)).Contains("connection refused"); + await Assert.That(Render.Words(found)).DoesNotContain("connection refused"); } [Test] @@ -110,20 +130,28 @@ public async Task AnArchiveEntryCarriesWhenItWasLastReachableAndHowLongItWasKnow await Assert.That(entry.LastReachableAt).IsNotNull(); await Assert.That(entry.KnownLive).IsGreaterThan(TimeSpan.FromDays(365 * 10)); - await Assert.That(entry.LastAnswered).Contains("2023"); - await Assert.That(entry.Run).IsNotNull(); + await Assert.That(entry.LastAnswered("en")).Contains("2023"); + await Assert.That(entry.Run("en")).IsNotNull(); } [Test] public async Task AGameWeCouldNeverReachHasNoRunToState() { // Inventing a run from the dates we happen to hold would be asserting rather than measuring. + // Asserted through the message rather than against its English, because the claim is that + // the entry says *this* — never reached at all, and no reachable time measured — rather than + // that it says it in these words. A locale that dropped either would fail here too. var game = (await Queries.ListAsync(new GameFilter { IncludeArchived = true })).First(); var entry = ArchiveEntry.For(game, [], Now); - await Assert.That(entry.Run).IsNull(); - await Assert.That(entry.LastAnswered).Contains("never"); - await Assert.That(entry.KnownLiveWording).IsEqualTo("no reachable time measured"); + await Assert.That(entry.Run("en")).IsNull(); + await Assert.That(entry.LastAnswered("en")) + .IsEqualTo(Messages.For("en", "archive.neverReachable")); + await Assert.That(entry.KnownLiveWording("en")) + .IsEqualTo(Messages.For("en", "archive.noReachableTime")); + + // And a zero here is an absence of measurement, never a measured zero. + await Assert.That(entry.KnownLiveWording("en")).DoesNotContain("0"); } [Test] diff --git a/tests/MUI.Web.Tests/FindAGameTests.cs b/tests/MUI.Web.Tests/FindAGameTests.cs index ad58347..f5ce246 100644 --- a/tests/MUI.Web.Tests/FindAGameTests.cs +++ b/tests/MUI.Web.Tests/FindAGameTests.cs @@ -1,31 +1,180 @@ using System.Text.RegularExpressions; using MUI.Catalog; +using MUI.Web.Api; +using MUI.Web.Components; using MUI.Web.Components.Pages; +using MUI.Web.Fixtures; +using MUI.Web.Localization; namespace MUI.Web.Tests; /// <summary> -/// §9's find-a-game wizard, and the one property that makes it safe to have. +/// §9's find-a-game wizard, and the properties that make a page of counts safe to have. /// </summary> /// <remarks> -/// The wizard's whole design is that it does not translate. It is a GET form aimed at the listing, -/// so the querystring it produces is parsed by the listing's own binding — which means the failure -/// mode to guard is a control whose name or value the binding would refuse. A wizard offering a -/// choice that comes back as a 400, or worse as a silently ignored filter, teaches a reader that -/// the site does not work. +/// <para> +/// Two things are being guarded. The first is the old one: the page does not translate, so a control +/// whose name or value the listing's binding would refuse teaches a reader that the site does not +/// work. The second is new and larger — this page now publishes a number for a combination of +/// answers, and the whole product is that a number here came from a query rather than from +/// arithmetic. The prototype it was drawn from multiplied marginal ratios; these tests are what +/// stops that arriving by any route. +/// </para> /// </remarks> public class FindAGameTests { + private static Task<string> FindAsync(string query = "") => + Render.PageAsync<FindAGame>([], query); + + private static Task<FindScreen> ScreenAsync(string query = "") => + FindScreen.BuildAsync(new FixtureGameQueries(), query); + + /// <summary>The querystring an address on this page carries, which is empty on "ask nothing".</summary> + private static string QueryOf(string href) + { + var mark = href.IndexOf('?', StringComparison.Ordinal); + + return mark < 0 ? string.Empty : href[mark..]; + } + + /// <summary> + /// The unlock: an answered Find page is a page, not a moment between two form submissions. + /// </summary> + /// <remarks> + /// It rendered every option unselected whatever the URL said, because it read no querystring at + /// all — so an answered page could not be linked, did not survive reload, and, the reason it had + /// to change, could not be counted: there was no server-side instant at which a set of answers + /// existed. + /// </remarks> + [Test] + public async Task AnAnsweredPageIsLinkable() + { + var html = await FindAsync("?genre=Fantasy"); + + await Assert.That(html).Contains("aria-current=\"true\""); + await Assert.That(Render.Words(html)).Contains("Fantasy"); + + var screen = await ScreenAsync("?genre=Fantasy"); + var genre = screen.Questions.Single(q => q.Key == FacetKeys.Genre); + + await Assert.That(genre.Answer).IsNotNull(); + await Assert.That(genre.Answer!.Label).IsEqualTo("Fantasy"); + } + + /// <summary> + /// The count is a count of games, not a product of the numbers beside the options. + /// </summary> + /// <remarks> + /// Asserted against the listing the same answers produce, because that is the only definition of + /// "right" that matters: the button says "show these N games" and the page it opens has to hold + /// N of them. Multiplying marginal ratios — what the handoff's prototype does — gives 2 here and + /// would give a plausible wrong number on every combination where two answers correlate. + /// </remarks> + [Test] + public async Task TheCountIsTheListingTheAnswersProduce() + { + foreach (var query in (string[])["", "?genre=Fantasy", "?band=playersNow&language=English", "?genre=~unknown"]) + { + GameFilterBinding.TryRead(query, out var bound, out _); + + var listing = await new FixtureGameQueries().SearchAsync(bound.Filter); + var screen = await ScreenAsync(query); + + await Assert.That(screen.Matching) + .IsEqualTo(listing.Games.Count) + .Because($"{query} must count the games it would list"); + } + } + + /// <summary> + /// Every option's number is what choosing it returns, with the other answers still applied. + /// </summary> + /// <remarks> + /// <para> + /// The failure this prevents is the page's original one in a subtler dress: a marginal count + /// beside an option in a form that already has three other answers is a promise about a listing + /// nobody will ever see. Checked by following the option's own link and counting what comes + /// back — the same route a reader takes. + /// </para> + /// <para> + /// A chosen option is the one case where the number and the link point different ways, and + /// deliberately: its link <em>clears</em> the answer, because a control a reader cannot undo is + /// a trap, while its number is still what the answer returns — which is the count in the panel. + /// </para> + /// </remarks> + [Test] + public async Task AnOptionPromisesWhatItsOwnLinkReturns() + { + foreach (var query in (string[])["?band=playersNow", "?genre=Fantasy&protocol=MSSP", ""]) + { + var screen = await ScreenAsync(query); + + foreach (var question in screen.Questions) + { + var options = question.Options.Concat(question.Tail); + + foreach (var option in question.Any is null ? options : options.Append(question.Any)) + { + if (option.IsChosen) + { + await Assert.That(option.Count) + .IsEqualTo(screen.Matching) + .Because($"{question.Text} / {option.Label} is the answer in force"); + continue; + } + + GameFilterBinding.TryRead(QueryOf(option.Href), out var bound, out _); + + var listing = await new FixtureGameQueries().SearchAsync(bound.Filter); + + await Assert.That(option.Count) + .IsEqualTo(listing.Games.Count) + .Because($"{question.Text} / {option.Label} promises {option.Count} at {option.Href}"); + } + } + } + } + + /// <summary>The figure on the loosen button is the listing that dropping the answer returns.</summary> + /// <remarks> + /// The handoff picks the answer with the smallest marginal count and shows what it thinks + /// dropping it returns. Both halves are estimates; both are replaced here by a set the query + /// already counted, and this is what proves it. + /// </remarks> [Test] - public async Task TheWizardAsksTheListingForItsAnswer() + public async Task TheLoosenButtonCarriesACountedNumber() { - var html = await Render.PageAsync<FindAGame>([]); + var screen = await ScreenAsync("?genre=Historical&language=English"); + + await Assert.That(screen.Loosen).IsNotNull(); + + GameFilterBinding.TryRead(QueryOf(screen.Loosen!.Href), out var bound, out _); + + var listing = await new FixtureGameQueries().SearchAsync(bound.Filter); - // A GET at the listing, so the answer is a bookmarkable listing URL and not a page of its - // own that would have to re-render the rows. - await Assert.That(html).Contains("method=\"get\""); - await Assert.That(html).Contains("action=\"/games\""); + await Assert.That(screen.Loosen.Count).IsEqualTo(listing.Games.Count); + await Assert.That(screen.Loosen.Count).IsGreaterThan(screen.Matching); + } + + /// <summary>Nothing offers a way to see nothing.</summary> + /// <remarks> + /// A control that cannot do what it offers is worse than one that is not there, and at zero the + /// affordance the reader needs is the answer responsible rather than a button onto an empty + /// listing. + /// </remarks> + [Test] + public async Task AtZeroThePageOffersTheWayOutAndNotTheEmptyListing() + { + var screen = await ScreenAsync("?genre=Historical&language=Swedish"); + + await Assert.That(screen.Matching).IsEqualTo(0); + await Assert.That(screen.Loosen).IsNotNull(); + + var html = await FindAsync("?genre=Historical&language=Swedish"); + + await Assert.That(html).DoesNotContain("find-go"); + await Assert.That(Render.Words(html)).Contains("clear all answers"); } /// <summary> @@ -35,12 +184,20 @@ public async Task TheWizardAsksTheListingForItsAnswer() /// Read off the rendered markup rather than off the source, because what matters is the name /// that reaches the browser. A control named for a key <see cref="FacetKeys"/> does not define /// would be dropped on the floor by the listing, and the reader would see a filter they set - /// having no effect at all — the silent no-op this codebase refuses everywhere else. + /// having no effect at all — the silent no-op this codebase refuses everywhere else. The one + /// form left on this page is the name field, and the answers already given ride with it as + /// hidden inputs, so this is also what stops a typed name silently discarding the other five. /// </remarks> [Test] public async Task EveryControlIsNamedForAFacetTheListingReads() { - var html = await Render.PageAsync<FindAGame>([]); + var html = await FindAsync("?genre=Fantasy&band=playersNow"); + + var start = html.IndexOf("<form class=\"find-name\"", StringComparison.Ordinal); + + await Assert.That(start).IsGreaterThan(-1); + + var form = html[start..html.IndexOf("</form>", start, StringComparison.Ordinal)]; var known = typeof(FacetKeys) .GetFields() @@ -48,45 +205,181 @@ public async Task EveryControlIsNamedForAFacetTheListingReads() .Select(f => (string)f.GetRawConstantValue()!) .ToHashSet(StringComparer.Ordinal); - var named = Regex.Matches(html, @"name=""(?<name>[^""]+)""") + var named = Regex.Matches(form, @"name=""(?<name>[^""]+)""") .Select(m => m.Groups["name"].Value) .Distinct() .ToList(); - await Assert.That(named).IsNotEmpty(); + await Assert.That(named).Contains(FacetKeys.Text); + await Assert.That(named).Contains(FacetKeys.Genre); + await Assert.That(named).Contains(FacetKeys.Band); foreach (var name in named) { - await Assert.That(known.Contains(name)).IsTrue(); + await Assert.That(known.Contains(name)).IsTrue().Because($"{name} is not a facet"); } } /// <summary> - /// The activity bands it offers are spelled by the enum, so none can be unaskable. + /// No answer is offered that the listing cannot apply. /// </summary> /// <remarks> - /// The first draft of this page wrote the three tokens out by hand, which is exactly the drift - /// its own design comment says it avoids: a band renamed in the enum would leave the wizard - /// offering a value the binding refuses, and nothing would have failed to say so. + /// Every link on the page is walked through the listing's own binding. A refused querystring is + /// what a reader would meet as a 400 or, worse, as a filter that silently did nothing — and the + /// long tail's disclosure makes this bigger than it looks, because a folded option that could + /// not be applied would be invisible until somebody opened it. /// </remarks> [Test] - public async Task TheBandsItOffersAreTheOnesTheBindingAccepts() + public async Task NoAnswerIsOfferedThatTheListingCannotApply() { - var html = await Render.PageAsync<FindAGame>([]); + var screen = await ScreenAsync("?band=quiet"); - var offered = Regex.Matches(html, @"name=""band"" value=""(?<token>[^""]*)""") - .Select(m => m.Groups["token"].Value) - .Where(t => t.Length > 0) - .ToList(); + foreach (var question in screen.Questions) + { + foreach (var option in question.Options.Concat(question.Tail)) + { + await Assert.That(GameFilterBinding.TryRead(QueryOf(option.Href), out _, out var error)) + .IsTrue() + .Because($"{option.Label} produces {option.Href}: {error}"); + } + } + } - await Assert.That(offered).IsNotEmpty(); + /// <summary> + /// The silent bucket is an option, and it keeps the word its own facet spells absence with. + /// </summary> + /// <remarks> + /// The page filtered it out while the query layer answered it and the plain surface offered it, + /// so two surfaces of one page disagreed about what could be asked. The handoff wants every one + /// of them labelled <em>unknown</em>; they stay three sentences, because a genre nobody declared + /// and a codebase we could not identify are a fact about the game and a fact about our reach, and + /// that difference is the thing the site is for. + /// </remarks> + [Test] + public async Task SilenceIsSelectableAndKeepsItsOwnWord() + { + var screen = await ScreenAsync(); + var genre = screen.Questions.Single(q => q.Key == FacetKeys.Genre); + + var silent = genre.Options.Single(o => o.Href.Contains(FacetChoice.UnknownToken, StringComparison.Ordinal)); + + await Assert.That(silent.Label).IsEqualTo("not declared"); + await Assert.That(silent.Count).IsGreaterThan(0); + await Assert.That(Render.Words(await FindAsync())).Contains("not declared"); + } + + /// <summary> + /// Archiving removes a game from the default listing and from nothing else — including here. + /// </summary> + /// <remarks> + /// The handoff asks for this question to default to <em>include them</em> so that "none of these + /// questions are required" becomes true. Inverting it would give one reader two different result + /// sets from two doors into one query. What was taken instead is the branch the handoff offers + /// itself: keep the default, delete the claim, and say what is applied — which this page does by + /// putting the number each answer returns on both of them. + /// </remarks> + [Test] + public async Task TheDarkQuestionDefaultsTheSameWayTheListingDoes() + { + var screen = await ScreenAsync(); + var dark = screen.Questions.Single(q => q.Key == FacetKeys.Archived); + + var live = dark.Options[0]; + var all = dark.Options[1]; + + await Assert.That(live.IsChosen).IsTrue(); + await Assert.That(all.IsChosen).IsFalse(); + + // Both answers carry the number they return, which is how the page says a filter is applied + // without a sentence that can go stale. + await Assert.That(all.Count).IsGreaterThan(live.Count); - foreach (var token in offered) + var listing = await new FixtureGameQueries().SearchAsync( + new GameFilter { IncludeArchived = true, IncludeAdult = false }); + + await Assert.That(all.Count).IsEqualTo(listing.Games.Count); + } + + /// <summary>TLS is one row, and the acronyms all read the same shape.</summary> + /// <remarks> + /// It reached the page twice — the dedicated <c>tls</c> facet and a <c>protocol=TLS</c> value + /// falling through to the generic gloss — so one acronym named two controls with two meanings. + /// And Razor ate the space after the conditional that wrote the name, which shipped + /// <c>MSSP— server self-description</c> to a screen reader as one word. + /// </remarks> + [Test] + public async Task TheClientQuestionNamesTlsOnceAndGlossesEveryAcronym() + { + var screen = await ScreenAsync(); + var client = screen.Questions.Single(q => q.Key == FacetKeys.Protocol); + + var labels = client.Options.Concat(client.Tail).Select(o => o.Label).ToList(); + + await Assert.That(labels.Count(l => l.StartsWith("TLS", StringComparison.Ordinal))).IsEqualTo(1); + + foreach (var label in labels) { - await Assert.That(FacetTokens.Bands.Contains(token)).IsTrue(); + await Assert.That(label).Contains(" — ").Because($"{label} has no gloss"); + await Assert.That(label).DoesNotContain("measured in the handshake"); } } + /// <summary>Six questions, one answer at a time, and each one a labelled group with a heading.</summary> + /// <remarks> + /// The drawing asks for six <c>fieldset</c>/<c>legend</c> pairs. Our options are links, and a + /// legend is announced when focus enters a form control in its group — with no controls to + /// enter it would name the group for nobody. A heading is announced, is navigable by a screen + /// reader's own heading key, and is the substitution the handoff explicitly allows. + /// </remarks> + [Test] + public async Task EveryQuestionIsALabelledGroupWithAHeading() + { + var screen = await ScreenAsync(); + + await Assert.That(screen.Questions.Count).IsEqualTo(6); + + foreach (var question in screen.Questions) + { + var chosen = question.Options.Concat(question.Tail).Count(o => o.IsChosen); + + await Assert.That(chosen).IsLessThanOrEqualTo(1).Because($"{question.Text} is a single choice"); + } + + var html = await FindAsync(); + + await Assert.That(Regex.Matches(html, @"role=""group""").Count).IsEqualTo(6); + await Assert.That(Regex.Matches(html, @"aria-labelledby=""find-q\d""").Count).IsEqualTo(6); + await Assert.That(Regex.Matches(html, @"<h2 id=""find-q\d""").Count).IsEqualTo(6); + } + + /// <summary>Every question says what kind of statement its answers are.</summary> + /// <remarks> + /// "What kind of game?" is the load-bearing one: it asks the derived lineage facet rather than + /// the declared <c>family</c> string, so the option a reader picks is a grouping of ours — and + /// rule 5 is what the badge exists to satisfy, not decoration. The alternative the handoff + /// proposes is a raw-string-to-group map authored in the web layer, which would be a second copy + /// of a vocabulary the catalogue owns. + /// </remarks> + [Test] + public async Task TheGroupedQuestionSaysTheGroupingIsOurs() + { + var screen = await ScreenAsync(); + + // Selected by the facet key, not by its English. The question is identified by the facet it + // asks — that is the fact this test is about — so an edit to the copy or a translated locale + // must not make it fail, and must not make it fail pointing at lineage evidence. + var kind = screen.Questions.Single(q => q.Key == FacetKeys.Lineage); + + await Assert.That(kind.Text).IsEqualTo(Messages.For(Locales.SourceTag, "find.q.lineage")); + await Assert.That(kind.Evidence).IsEqualTo(FacetEvidence.Derived); + + var html = await FindAsync(); + + await Assert.That(html).Contains("evidence derived"); + await Assert.That(html).Contains("evidence measured"); + await Assert.That(html).Contains("evidence declared"); + } + /// <summary>No rating, no score, no recommendation — here least of all.</summary> /// <remarks> /// A page that asks somebody what they want is the most natural place on this site for a @@ -97,11 +390,480 @@ public async Task TheBandsItOffersAreTheOnesTheBindingAccepts() [Test] public async Task TheWizardRecommendsNothing() { - var words = Render.Words(await Render.PageAsync<FindAGame>([])); + var words = Render.Words(await FindAsync("?genre=Fantasy")); foreach (var forbidden in (string[])["recommend", "best match", "top pick", "rating", "score"]) { await Assert.That(words.Contains(forbidden, StringComparison.OrdinalIgnoreCase)).IsFalse(); } } + + /// <summary>A querystring we cannot read is refused, on both surfaces.</summary> + /// <remarks> + /// The listing already refuses one. This page used to ignore its URL entirely, so it could not + /// refuse anything — and now that it reads one, answering <c>?band=nonsense</c> with the + /// unfiltered catalogue would present our own parse failure as somebody's answer. + /// </remarks> + [Test] + public async Task AQueryWeCannotReadIsRefusedRatherThanIgnored() + { + var screen = await ScreenAsync("?band=nonsense"); + + await Assert.That(screen.Error).IsNotNull(); + await Assert.That(screen.Questions).IsEmpty(); + + await Assert.That(Render.Words(await FindAsync("?band=nonsense"))) + .Contains("is not an activity band"); + await Assert.That(PlainText.RenderFind(screen)).Contains("REFUSED"); + } + + /// <summary> + /// The plain surface is the same page: same questions, same options, same counts, same words. + /// </summary> + /// <remarks> + /// It was a different page. Plain dumped ten facet groups as querystring recipes while the + /// rendered page asked six questions, and the two disagreed about what could be asked at all — + /// plain offered the silent bucket the rendered page hid. Both are now one construction with two + /// renderers, and this walks the model to prove the text carries every option and every number. + /// </remarks> + [Test] + public async Task ThePlainSurfaceCarriesEveryQuestionEveryOptionAndTheCount() + { + var screen = await ScreenAsync("?genre=Fantasy&plain=1"); + var plain = PlainText.RenderFind(screen); + + await Assert.That(plain).Contains("FIND A GAME"); + await Assert.That(plain).Contains("MATCHING ALL ANSWERS"); + await Assert.That(plain).Contains("/games?plain=1"); + + foreach (var question in screen.Questions) + { + await Assert.That(plain).Contains(question.Text.ToUpperInvariant()); + + foreach (var option in question.Options.Concat(question.Tail)) + { + await Assert.That(plain).Contains($"{option.Label} ({option.Count})"); + await Assert.That(plain).Contains(option.Href); + } + } + + // Nothing here is wider than a text browser. + foreach (var line in plain.Split('\n')) + { + await Assert.That(line.TrimEnd().Length) + .IsLessThanOrEqualTo(PlainText.Columns) + .Because($"'{line}' is wider than {PlainText.Columns} columns"); + } + } + + /// <summary>Following a link on the plain surface stays on the plain surface.</summary> + /// <remarks> + /// It falls out of the construction rather than being arranged — every address on both surfaces + /// is this page's own URL with one parameter changed — and it is worth asserting because a + /// reader who lands back on the rendered page after answering one question has lost the surface + /// they chose. + /// </remarks> + [Test] + public async Task ThePlainSurfaceLinksStayPlain() + { + var screen = await ScreenAsync("?plain=1"); + + foreach (var question in screen.Questions) + { + foreach (var option in question.Options.Concat(question.Tail)) + { + await Assert.That(option.Href).Contains("plain=1"); + } + } + + await Assert.That(screen.ShowHref).Contains("plain=1"); + + // Including the one control that clears everything: emptying the form is about the answers, + // and throwing a reader out of the surface they chose is not something they asked for. + var answered = await ScreenAsync("?genre=Fantasy&plain=1"); + + await Assert.That(answered.ClearHref).IsEqualTo("/find?plain=1"); + await Assert.That(answered.Answers[0].ClearHref).Contains("plain=1"); + } + + /// <summary> + /// The long tail folds, and every option in it is still a real answer. + /// </summary> + /// <remarks> + /// <para> + /// The catalogue this is drawn from has nine of twelve genres matching two games or fewer, and an + /// option that returns one result is a piece of trivia in a list somebody has to read. The + /// fixture is six games and cannot produce that shape, so the tail is exercised over a catalogue + /// made for it — which is also the only way to prove the thing that matters: what is behind the + /// disclosure is the values themselves, never a "3 more genres" bucket of its own. A submittable + /// bucket would be Find offering a choice the listing cannot express. + /// </para> + /// <para> + /// The reader's own answer is never in the tail. A selection folded out of sight is the defect + /// the disclosure would introduce, and it is the one option they need to be able to undo. + /// </para> + /// </remarks> + [Test] + public async Task TheLongTailFoldsAndHoldsRealAnswers() + { + var wide = new WideCatalogue(); + + var screen = await FindScreen.BuildAsync(wide, string.Empty); + var genre = screen.Questions.Single(q => q.Key == FacetKeys.Genre); + + await Assert.That(genre.Options.Count).IsLessThan(WideCatalogue.Genres.Length); + await Assert.That(genre.Tail).IsNotEmpty(); + + foreach (var option in genre.Tail) + { + GameFilterBinding.TryRead(QueryOf(option.Href), out var bound, out _); + + var listing = await wide.SearchAsync(bound.Filter); + + await Assert.That(option.Count).IsEqualTo(listing.Games.Count); + await Assert.That(option.Count).IsGreaterThan(0); + } + + // The silent bucket stays in the open however little it weighs: it is the option that makes + // "show me the games nobody has classified" askable at all. + await Assert.That(genre.Options.Any(o => o.Label == "not declared")).IsTrue(); + + var chosen = genre.Tail[^1]; + + var answered = await FindScreen.BuildAsync(wide, QueryOf(chosen.Href)); + + await Assert.That(answered.Questions.Single(q => q.Key == FacetKeys.Genre).Options + .Any(o => o.IsChosen)).IsTrue(); + } + + /// <summary> + /// A chosen capability outside the commonest six is still on the page, and can still be undone. + /// </summary> + /// <remarks> + /// <para> + /// The client question does not go through <see cref="FindScreen"/>'s <c>Split</c> — its options + /// are two facets welded into one control — so the rule that a reader's own answer is never + /// folded away had to be carried across by hand, and was not. The shown list was the first six + /// by popularity and the tail was the remainder with every chosen option filtered out, so a + /// capability ranking seventh or lower was in neither: the answer in force was invisible and the + /// only affordance that clears it went with it. A single-choice control that can enter a state + /// it cannot leave is the worst shape a question on this page can have. + /// </para> + /// <para> + /// Exercised over a catalogue built to rank the chosen capability last, because the six-game + /// fixture measures one protocol and cannot produce a seventh option at all. + /// </para> + /// </remarks> + [Test] + public async Task AChosenCapabilityOutsideTheCommonestSixIsStillShownAndStillClearable() + { + var many = new ManyCapabilities(); + + // The rarest, which is what the popularity cut pushes furthest out of sight. + var rare = ManyCapabilities.Protocols[^1]; + + var before = await FindScreen.BuildAsync(many, string.Empty); + var offered = before.Questions.Single(q => q.Key == FacetKeys.Protocol); + + // The premise: it really is in the tail before anybody chooses it. + await Assert.That(offered.Options.Any(o => o.Label.StartsWith(rare, StringComparison.Ordinal))) + .IsFalse(); + await Assert.That(offered.Tail.Any(o => o.Label.StartsWith(rare, StringComparison.Ordinal))) + .IsTrue(); + + var screen = await FindScreen.BuildAsync(many, $"?{FacetKeys.Protocol}={rare}"); + var client = screen.Questions.Single(q => q.Key == FacetKeys.Protocol); + + // Shown, not folded: promoted into the open list exactly as Split promotes one elsewhere. + var chosen = client.Options.Single(o => o.IsChosen); + + await Assert.That(chosen.Label).StartsWith(rare); + await Assert.That(client.Tail.Any(o => o.IsChosen)).IsFalse(); + + // And clearable: its own link drops the answer rather than setting it again, so the control + // is reachable in both directions with no second affordance. + await Assert.That(chosen.Href).DoesNotContain($"{FacetKeys.Protocol}={rare}"); + + GameFilterBinding.TryRead(QueryOf(chosen.Href), out var cleared, out _); + + await Assert.That(cleared.Filter.MeasuredProtocols).IsEmpty(); + + // The plain surface carries it too, or the graphical fix is half a fix (§9). + await Assert.That(PlainText.RenderFind(screen)).Contains($"[x] {rare}"); + } + + /// <summary> + /// A catalogue measuring more capabilities than the client question shows, ranked so the last is + /// well outside the cut. + /// </summary> + private sealed class ManyCapabilities : IGameQueries + { + internal static readonly string[] Protocols = + [ + "MSSP", "MCCP", "GMCP", "MXP", "MSDP", "TTYPE", "ATCP", "MSP", "EOR", + ]; + + // Nine games offer the first, one offers the last: a strict popularity order with no ties, + // so which options fall outside the shown six is a fact rather than a sort artefact. + private static readonly IReadOnlyList<GameFacetRow> Rows = + [ + .. Protocols.SelectMany((protocol, rank) => Enumerable + .Range(0, Protocols.Length - rank) + .Select(n => Row($"{protocol}-{n}", protocol))), + ]; + + public Task<GameListing> SearchAsync(GameFilter filter, CancellationToken ct = default) => + Task.FromResult(FacetedSearch.Search(Rows, filter)); + + public Task<IReadOnlyList<GameSummary>> ListAsync(GameFilter filter, CancellationToken ct = default) => + throw new NotSupportedException(); + + public Task<GamePage?> FindAsync(string slug, CancellationToken ct = default) => + throw new NotSupportedException(); + + public Task<GamePage?> FindAsync(Guid id, CancellationToken ct = default) => + throw new NotSupportedException(); + + public Task<GameSummary?> FindByIdAsync(Guid id, CancellationToken ct = default) => + throw new NotSupportedException(); + + public Task<LivenessFeeds> FeedsAsync(CancellationToken ct = default) => + throw new NotSupportedException(); + + public Task<EcosystemDashboard> EcosystemAsync(CancellationToken ct = default) => + throw new NotSupportedException(); + + public Task<Rankings> RankingsAsync(RankingSpan span, CancellationToken ct = default) => + throw new NotSupportedException(); + + private static GameFacetRow Row(string slug, string protocol) => new( + new GameSummary( + Guid.NewGuid(), slug, slug, null, LifecycleState.Active, IsClaimed: false, + PlayersNow: 1, Codebase: "PennMUSH", MeasuredProtocols: [protocol]), + ActivityBand.PlayersNow, + LastSeenBand.Day, + TlsMeasured: false, + Charset: "UTF-8", + Language: "English", + Codebase: "PennMUSH", + Family: "TinyMUD", + Genre: "Fantasy", + IsAdult: false, + Uncounted: false, + Unreachable: false); + } + + /// <summary> + /// A catalogue with a long tail, which the six-game fixture has no way to have. + /// </summary> + /// <remarks> + /// Built out of <see cref="GameFacetRow"/> and answered through <see cref="FacetedSearch"/> — + /// the same arithmetic the database and the fixture both go through — so this exercises the real + /// counting rather than a hand-written listing that could agree with nothing. + /// </remarks> + private sealed class WideCatalogue : IGameQueries + { + internal static readonly string[] Genres = + [ + "Fantasy", "Science Fiction", "Adventure", "Horror", "Historical", + "Social", "Multitheme", "Cyberpunk", "Western", "Noir", + ]; + + private static readonly IReadOnlyList<GameFacetRow> Rows = + [ + .. Genres.SelectMany((genre, rank) => Enumerable + .Range(0, Genres.Length - rank) + .Select(n => Row($"{genre}-{n}", genre))), + + // One game nobody classified, so the silent bucket has something in it. + Row("silent", null), + ]; + + public Task<GameListing> SearchAsync(GameFilter filter, CancellationToken ct = default) => + Task.FromResult(FacetedSearch.Search(Rows, filter)); + + public Task<IReadOnlyList<GameSummary>> ListAsync(GameFilter filter, CancellationToken ct = default) => + throw new NotSupportedException(); + + public Task<GamePage?> FindAsync(string slug, CancellationToken ct = default) => + throw new NotSupportedException(); + + public Task<GamePage?> FindAsync(Guid id, CancellationToken ct = default) => + throw new NotSupportedException(); + + public Task<GameSummary?> FindByIdAsync(Guid id, CancellationToken ct = default) => + throw new NotSupportedException(); + + public Task<LivenessFeeds> FeedsAsync(CancellationToken ct = default) => + throw new NotSupportedException(); + + public Task<EcosystemDashboard> EcosystemAsync(CancellationToken ct = default) => + throw new NotSupportedException(); + + public Task<Rankings> RankingsAsync(RankingSpan span, CancellationToken ct = default) => + throw new NotSupportedException(); + + private static GameFacetRow Row(string slug, string? genre) => new( + new GameSummary( + Guid.NewGuid(), slug, slug, null, LifecycleState.Active, IsClaimed: false, + PlayersNow: 1, Codebase: "PennMUSH", MeasuredProtocols: ["MSSP"]), + ActivityBand.PlayersNow, + LastSeenBand.Day, + TlsMeasured: false, + Charset: "UTF-8", + Language: "English", + Codebase: "PennMUSH", + Family: "TinyMUD", + Genre: genre, + IsAdult: false, + Uncounted: false, + Unreachable: false); + } + + /// <summary>The count and the noun it agrees with are one message, never two strings.</summary> + /// <remarks> + /// The page these replace read "1 games" in the client question, on every protocol whose count + /// happened to be one. English is nearly the only language that would have survived even that, + /// and a number glued to an English fragment in English word order is exactly what the i18n + /// review named. "0 games" is not the same fault and is correct English — zero takes the plural + /// here and the singular in French — which is the reason the branch is a message and not an + /// <c>if</c>. + /// </remarks> + [Test] + public async Task NoCountIsGluedToAnEnglishNoun() + { + foreach (var query in (string[])["", "?genre=Historical", "?protocol=MSDP"]) + { + var words = Render.Words(await FindAsync(query)); + + await Assert.That(words).DoesNotContain("1 games"); + await Assert.That(words).DoesNotContain("1 listed games"); + await Assert.That(words).DoesNotContain("1 answers given"); + } + } + + /// <summary> + /// Nothing here needs script, which is the constraint the whole design bends around. + /// </summary> + /// <remarks> + /// The drawing this page comes from is a debounced <c>aria-live</c> region recomputing a count + /// as answers change. There is no script on this site, so the count is computed on the server + /// and every answer is an address: a link applies on click with nothing listening, and the one + /// form left is the name field, which a browser submits as a GET on its own. Asserted rather + /// than assumed because "it happens to work without JS today" and "it cannot stop working + /// without JS" are different properties, and only the second one is the design. + /// </remarks> + [Test] + public async Task NothingOnThisPageNeedsScript() + { + foreach (var query in (string[])["?genre=Fantasy&band=playersNow", "?plain=1"]) + { + var html = await FindAsync(query); + + await Assert.That(html).DoesNotContain("<script"); + await Assert.That(html).DoesNotContain("onclick"); + await Assert.That(html).DoesNotContain("javascript:"); + } + + var rendered = await FindAsync("?genre=Fantasy"); + + // Every form this page owns is a GET, and every answer is an anchor: a POST would be a + // change of state with no address, which is the one thing this page has never had. The + // shared language switcher is deliberately not one of them — choosing a language writes a + // cookie rather than asking the catalogue a question, and it belongs to the chrome. + var forms = Regex.Matches(rendered, "<form[^>]*>") + .Select(m => m.Value) + .Where(f => !f.Contains("class=\"locale\"", StringComparison.Ordinal)) + .ToList(); + + await Assert.That(forms).IsNotEmpty(); + + foreach (var form in forms) + { + await Assert.That(form).Contains("method=\"get\"").Because($"{form} is not a GET"); + await Assert.That(form).Contains("action=\"/find\"").Because($"{form} leaves the page"); + } + } + + /// <summary>Every word this page owns is in the bundle, questions included.</summary> + /// <remarks> + /// <para> + /// This is the one surface written in a reader's language rather than in the catalogue's — six + /// questions, the answer that un-asks each one, and a three-word gloss per capability — so it is + /// the page with the most prose and the least of it reachable by a translator if it is spelled + /// in C#. The facet <em>values</em> are deliberately not checked here: those come from + /// <see cref="FacetWords"/>, which the listing shares, and a second vocabulary for them on this + /// page is the drift the page's own header comment warns about. + /// </para> + /// <para> + /// Asserted by identity against the bundle rather than against English text, so the test says + /// "this string came from that id" and keeps saying it after somebody edits the English. + /// </para> + /// </remarks> + [Test] + public async Task EveryWordThisPageOwnsComesFromTheMessageBundle() + { + var screen = await ScreenAsync(); + var en = Locales.SourceTag; + + string[] questions = + [ + "find.q.band", "find.q.genre", "find.q.lineage", + "find.q.language", "find.q.client", "find.q.dark", + ]; + + await Assert.That(screen.Questions.Select(q => q.Text)) + .IsEquivalentTo(questions.Select(id => Messages.For(en, id)).ToArray()); + + string[] anys = ["find.any.band", "find.any.genre", "find.any.lineage", "find.any.language"]; + + await Assert.That(screen.Questions.Where(q => q.Any is not null).Select(q => q.Any!.Label)) + .Contains(Messages.For(en, "find.any.client")); + + foreach (var id in anys) + { + await Assert.That(screen.Questions.Select(q => q.Any?.Label)) + .Contains(Messages.For(en, id)) + .Because($"{id} is what un-asks its question"); + } + + // The acronym and its gloss are one message and not a name with three words glued to it: + // "MSSP— server self-description" shipped from exactly that concatenation, and a language + // that puts the gloss first has nowhere to say so if the two are joined in C#. + var client = screen.Questions.Single(q => q.Key == FacetKeys.Protocol); + + await Assert.That(client.Options.Concat(client.Tail).Select(o => o.Label)) + .Contains(Messages.For(en, "find.protocol.mssp")); + + await Assert.That(client.Options.Concat(client.Tail).Select(o => o.Label)) + .Contains(Messages.For(en, "find.protocol.tls")); + } + + /// <summary> + /// One locale reaches the words and the mirror alike, because it is built into the screen. + /// </summary> + /// <remarks> + /// The locale is a parameter of the construction rather than something applied to the result: + /// the plain surface reads its question texts and its option labels straight off the screen, so + /// a translation applied after the fact would reach the rendered page and not this one — the + /// same split, in the same place, that this page was rebuilt to close. + /// </remarks> + [Test] + public async Task TheTextMirrorSpeaksTheLocaleTheScreenWasBuiltIn() + { + foreach (var tag in (string[])[Locales.SourceTag, "de", "ja"]) + { + var screen = await FindScreen.BuildAsync(new FixtureGameQueries(), "?plain=1", tag); + var plain = PlainText.RenderFind(screen, tag); + + await Assert.That(plain).Contains(Messages.For(tag, "find.title").ToUpperInvariant()); + + foreach (var question in screen.Questions) + { + await Assert.That(plain) + .Contains(question.Text.ToUpperInvariant()) + .Because($"{tag} asks its questions in one language on both surfaces"); + } + } + } } diff --git a/tests/MUI.Web.Tests/GameAnchorsTests.cs b/tests/MUI.Web.Tests/GameAnchorsTests.cs new file mode 100644 index 0000000..a86d07e --- /dev/null +++ b/tests/MUI.Web.Tests/GameAnchorsTests.cs @@ -0,0 +1,135 @@ +using MUI.Catalog; +using MUI.Catalog.Persistence; +using MUI.Web.Components.Pages; +using MUI.Web.Data; +using MUI.Web.Fixtures; + +using Microsoft.AspNetCore.Components; +using Microsoft.Extensions.DependencyInjection; + +namespace MUI.Web.Tests; + +/// <summary> +/// The game page's own in-page links, and the sections they are supposed to land on. +/// </summary> +/// <remarks> +/// A footer link to <c>#changed</c> is not a broken link a browser reports: it scrolls nowhere and +/// says nothing, and to a screen reader following it the page simply does not move. The change list +/// renders only for a game with a recorded change, so the link has to be conditioned on the same +/// thing the heading is — the fixture gives every game two changes, which is why nothing had ever +/// rendered this page without one. +/// </remarks> +public class GameAnchorsTests +{ + [Test] + public async Task TheFooterLinksToTheChangeListOnlyWhereThereIsOne() + { + var withChanges = await RenderAsync(strip: false); + + await Assert.That(withChanges).Contains("id=\"changed\""); + await Assert.That(withChanges).Contains("href=\"#changed\""); + + var without = await RenderAsync(strip: true); + + await Assert.That(without).DoesNotContain("id=\"changed\""); + await Assert.That(without).DoesNotContain("href=\"#changed\""); + + // The rest of the footer is untouched, so what went is the link and not the row it sat in. + await Assert.That(without).Contains("href=\"#declared\""); + await Assert.That(without).Contains("id=\"declared\""); + await Assert.That(without).Contains("?plain=1"); + } + + /// <summary> + /// Every anchor the page links to is an id the page rendered. + /// </summary> + /// <remarks> + /// Stated as the general rule rather than about <c>#changed</c> alone, so a section that becomes + /// conditional later is caught by the test that already exists. + /// </remarks> + [Test] + [Arguments(false)] + [Arguments(true)] + public async Task EveryInPageLinkLandsOnSomething(bool strip) + { + var html = await RenderAsync(strip); + + var targets = System.Text.RegularExpressions.Regex + .Matches(html, "href=\"#([^\"]+)\"") + .Select(m => m.Groups[1].Value) + .Distinct(StringComparer.Ordinal) + .ToList(); + + // A sweep over "every in-page link" asserts nothing when the page renders none, and passes + // anyway. The page under test has them; if it stops having them this should fail rather + // than quietly become a test of nothing. + await Assert.That(targets).IsNotEmpty() + .Because("the game page carries in-page links, and a sweep over none proves none of them"); + + foreach (var target in targets) + { + await Assert.That(html) + .Contains($"id=\"{target}\"") + .Because($"the page links to #{target} and renders no such id"); + } + } + + private static Task<string> RenderAsync(bool strip) => + Render.ComponentAsync<Game>( + new() { ["Slug"] = "m-u-s-h" }, + services => + { + var fixture = new FixtureGameQueries(); + + services.AddSingleton<IGameQueries>(strip ? new WithoutChanges(fixture) : fixture); + services.AddSingleton<IAvailabilityHistory>(fixture); + services.AddSingleton(TimeProvider.System); + services.AddSingleton<NavigationManager>(new Nowhere()); + services.AddSingleton(new CatalogueSource(IsMeasured: false)); + }); + + /// <summary>The fixture, with the change history taken off the page it answers with.</summary> + /// <remarks> + /// Every fixture game carries two changes, so this is the only way to see the page a game with a + /// quiet record actually gets. It delegates rather than reimplements: what is under test is one + /// conditional in the markup, and a second fixture would drift from the first. + /// </remarks> + private sealed class WithoutChanges(IGameQueries inner) : IGameQueries + { + public Task<GameListing> SearchAsync(GameFilter filter, CancellationToken cancellationToken = default) => + inner.SearchAsync(filter, cancellationToken); + + public Task<IReadOnlyList<GameSummary>> ListAsync(GameFilter filter, CancellationToken cancellationToken = default) => + inner.ListAsync(filter, cancellationToken); + + public async Task<GamePage?> FindAsync(string slug, CancellationToken cancellationToken = default) => + await inner.FindAsync(slug, cancellationToken) is { } page ? page with { Changes = [] } : null; + + public async Task<GamePage?> FindAsync(Guid id, CancellationToken cancellationToken = default) => + await inner.FindAsync(id, cancellationToken) is { } page ? page with { Changes = [] } : null; + + public Task<GameSummary?> FindByIdAsync(Guid id, CancellationToken cancellationToken = default) => + inner.FindByIdAsync(id, cancellationToken); + + public Task<LivenessFeeds> FeedsAsync(CancellationToken cancellationToken = default) => + inner.FeedsAsync(cancellationToken); + + public Task<EcosystemDashboard> EcosystemAsync(CancellationToken cancellationToken = default) => + inner.EcosystemAsync(cancellationToken); + + public Task<Rankings> RankingsAsync( + RankingSpan span = RankingSpan.Week, + CancellationToken cancellationToken = default) => + inner.RankingsAsync(span, cancellationToken); + } + + /// <summary>A navigation manager for a component rendered outside a request.</summary> + private sealed class Nowhere : NavigationManager + { + public Nowhere() => Initialize("http://localhost/", "http://localhost/g/m-u-s-h"); + + protected override void NavigateToCore(string uri, bool forceLoad) + { + } + } +} diff --git a/tests/MUI.Web.Tests/GamePlateTests.cs b/tests/MUI.Web.Tests/GamePlateTests.cs index bbfbf56..d083367 100644 --- a/tests/MUI.Web.Tests/GamePlateTests.cs +++ b/tests/MUI.Web.Tests/GamePlateTests.cs @@ -37,16 +37,18 @@ public async Task APlateIsNeverEmpty() } [Test] - public async Task EveryRowHasAPlateAndNoneOfThemPointsOffThisOrigin() + public async Task NoRowDrawsAPlateAndNoIconPointsOffThisOrigin() { - // The fixture holds no icon bytes, so every row is the monogram — which is exactly the state - // a deployment with an empty cache renders, and it has to be a plate rather than a hole. + // The handoff's listing row is identity, measurement and freshness and nothing else: a 36px + // square per row is a fourth column of furniture down a list five hundred long, and the face + // a game published is on its own page at a size that shows it. The component is unchanged + // and the game page still draws it. var html = await Render.PageAsync<Games>([]); var rows = html.Split("class=\"game-row").Length - 1; var plates = html.Split("class=\"plate").Length - 1; await Assert.That(rows).IsGreaterThan(0); - await Assert.That(plates).IsEqualTo(rows); + await Assert.That(plates).IsEqualTo(0); // §11. An icon is served from this origin or not at all: every src is the site's own route. foreach (var src in html.Split("<img").Skip(1)) @@ -61,13 +63,16 @@ public async Task AMissingIconAndAnUnreachableOneAreDrawnIdentically() // The one thing the plate may not do. A placeholder, a broken image or a "logo unavailable" // would publish our failed fetch as a fact about somebody's game (rule 5) — and the second // and third of those states are indistinguishable from the first anywhere in the markup. - var html = await Render.PageAsync<Games>([]); + var html = await Render.PageAsync<Game>(new() { ["Slug"] = "m-u-s-h" }); await Assert.That(html).DoesNotContain("no icon"); await Assert.That(html).DoesNotContain("icon unavailable"); - // The name is beside it either way, so the picture is never the thing announced. - await Assert.That(html).Contains("class=\"plate mono\" aria-hidden=\"true\""); + // And no element at all where there is no icon. "When absent, render no element: no + // monogram, no grey square, no initial in a circle" — an empty frame on five hundred pages + // is noise, and a generated monogram invents a brand the game never supplied, which on a + // site that publishes only what it measured is the one decoration that costs something. + await Assert.That(html).DoesNotContain("class=\"plate"); } [Test] @@ -98,15 +103,29 @@ public async Task AnIconIsServedFromThisOriginAndReservesItsSpaceBeforeItArrives } [Test] - public async Task TheGamePageAndTheListingDrawOneVocabularyAtTwoSizes() + public async Task NoSurfaceInventsAFaceForAGameThatPublishedNone() { - // Two spellings of "the first letters of the name" is how a game comes to be MU on one page - // and M* on the next. Both surfaces render the same component. + // Neither the listing nor the game page draws a monogram now. The component still knows how + // — a surface that needs a fixed left edge down a list of rows is a different argument — but + // nothing passes Fallback, so a game with no icon gets no element on either surface and the + // title simply starts at the left edge. var page = await Render.PageAsync<Game>(new() { ["Slug"] = "m-u-s-h" }); var listing = await Render.PageAsync<Games>([]); - await Assert.That(page).Contains("class=\"plate mono\""); - await Assert.That(Render.Words(page)).Contains(Monogram.Of("M*U*S*H")); - await Assert.That(listing).Contains("class=\"plate mono\""); + await Assert.That(page).DoesNotContain("class=\"plate"); + await Assert.That(listing).DoesNotContain("class=\"plate"); + + // And the one implementation is still there, behind the parameter, so the two surfaces + // cannot grow two spellings of "the first letters of the name". + var withFallback = await Render.ComponentAsync<GamePlate>(new() + { + ["Slug"] = "m-u-s-h", + ["Name"] = "M*U*S*H", + ["HasIcon"] = false, + ["Fallback"] = true, + }); + + await Assert.That(withFallback).Contains("class=\"plate mono\" aria-hidden=\"true\""); + await Assert.That(Render.Words(withFallback)).Contains(Monogram.Of("M*U*S*H")); } } diff --git a/tests/MUI.Web.Tests/IcuMessageTests.cs b/tests/MUI.Web.Tests/IcuMessageTests.cs new file mode 100644 index 0000000..bdf3291 --- /dev/null +++ b/tests/MUI.Web.Tests/IcuMessageTests.cs @@ -0,0 +1,372 @@ +using MUI.Web.Localization; + +namespace MUI.Web.Tests; + +/// <summary> +/// MessageFormat 1.0, against the cases that catch the usual mistakes. +/// </summary> +/// <remarks> +/// Most of these are the examples ICU's own documentation uses, because they are the ones chosen to +/// break a naive implementation: the apostrophe that is not a quote, the plural offset that changes +/// <c>#</c> but not <c>=0</c>, the ordinal categories English has and its cardinal rule does not, +/// and the fraction that makes 1 and 1.0 different words. +/// </remarks> +public class IcuMessageTests +{ + private static string Format(string pattern, string tag = "en", params (string Key, object? Value)[] args) => + IcuMessage.Format(pattern, tag, args.ToDictionary(a => a.Key, a => a.Value, StringComparer.Ordinal)); + + // ── quoting ────────────────────────────────────────────────────────────────────────────── + + [Test] + [Arguments("doesn't", "doesn't")] // a lone apostrophe is an apostrophe + [Arguments("it''s", "it's")] // doubled is always one + [Arguments("'{'literal'}'", "{literal}")] // quotes a brace + [Arguments("'{0}'", "{0}")] // and everything up to the closing quote + [Arguments("O'Brien's MUSH", "O'Brien's MUSH")] + [Arguments("5 o''clock", "5 o'clock")] + public async Task ApostrophesFollowIcusDefaultMode(string pattern, string expected) + { + // DOUBLE_OPTIONAL: an apostrophe only starts a quote when it immediately precedes { } | or, + // inside a plural, #. Anywhere else it is a literal — which is what makes English possessives + // and contractions safe to type without thinking about it. + await Assert.That(Format(pattern)).IsEqualTo(expected); + } + + [Test] + public async Task AQuotedHashInsideAPluralIsALiteral() + { + // And an unquoted one is the number. Both matter: a game called "#1 MUSH" would otherwise + // print its own count in the middle of its name. + await Assert.That(Format("{n, plural, other {'#' is # }}", "en", ("n", 3))).IsEqualTo("# is 3 "); + await Assert.That(Format("channel #general")).IsEqualTo("channel #general"); + } + + [Test] + public async Task ABraceInsideABranchIsQuotedTheSameWay() + { + // The doubled-brace escape an earlier version carried could not do this: a branch ending + // "...}}" is indistinguishable from a literal brace followed by the argument's own close. + await Assert.That(Format("{n, plural, other {'{'#'}'}}", "en", ("n", 2))).IsEqualTo("{2}"); + } + + // ── plural ─────────────────────────────────────────────────────────────────────────────── + + [Test] + [Arguments(0, "0 games")] + [Arguments(1, "1 game")] + [Arguments(2, "2 games")] + public async Task EnglishCardinalHasTwoForms(int count, string expected) + { + await Assert.That(Format("{n, plural, one {# game} other {# games}}", "en", ("n", count))) + .IsEqualTo(expected); + } + + [Test] + public async Task AVisibleFractionIsNotOneEvenWhenTheValueIsOne() + { + // "1.0 stars", never "1.0 star" — and the two quantities are equal, so nothing but the + // operands can tell them apart. This is the case an integer-only implementation cannot get + // right, and the reason PluralOperands exists. + const string Pattern = "{n, plural, one {# star} other {# stars}}"; + + await Assert.That(Format(Pattern, "en", ("n", 1))).IsEqualTo("1 star"); + await Assert.That(Format(Pattern, "en", ("n", 1.0m))).IsEqualTo("1.0 stars"); + } + + [Test] + [Arguments(1, "1 игра")] + [Arguments(2, "2 игры")] + [Arguments(5, "5 игр")] + [Arguments(11, "11 игр")] // ends in 1 and is not `one` + [Arguments(12, "12 игр")] // ends in 2 and is not `few` + [Arguments(21, "21 игра")] + [Arguments(22, "22 игры")] + public async Task RussianCardinalHasThreeFormsAndTheTeensAreTheTrap(int count, string expected) + { + // A rule written from the first three examples anybody tries is wrong for 11 and 12, and + // wrong in a way no English-speaking reviewer notices. + await Assert.That(Format( + "{n, plural, one {# игра} few {# игры} many {# игр} other {# игры}}", "ru", ("n", count))) + .IsEqualTo(expected); + } + + [Test] + [Arguments(1, "1st")] + [Arguments(2, "2nd")] + [Arguments(3, "3rd")] + [Arguments(4, "4th")] + [Arguments(11, "11th")] + [Arguments(12, "12th")] + [Arguments(13, "13th")] + [Arguments(21, "21st")] + [Arguments(102, "102nd")] + public async Task EnglishOrdinalHasFourFormsAndTheCardinalRuleCannotProduceThem(int n, string expected) + { + // selectordinal is a different rule set, not a different spelling of plural. English's + // cardinal rule has two categories and this needs four. + await Assert.That(Format( + "{n, selectordinal, one {#st} two {#nd} few {#rd} other {#th}}", "en", ("n", n))) + .IsEqualTo(expected); + } + + [Test] + public async Task AnExactMatchBeatsACategory() + { + const string Pattern = "{n, plural, =0 {nobody} one {# person} other {# people}}"; + + await Assert.That(Format(Pattern, "en", ("n", 0))).IsEqualTo("nobody"); + await Assert.That(Format(Pattern, "en", ("n", 1))).IsEqualTo("1 person"); + await Assert.That(Format(Pattern, "en", ("n", 4))).IsEqualTo("4 people"); + } + + [Test] + public async Task OffsetChangesTheHashAndTheCategoryButNotTheExactMatch() + { + // ICU's own example. `=` matches the number as written; `#` and the category are both taken + // after the offset is subtracted — which is what makes "Bob and 2 others" come out of a + // party of three. + const string Pattern = + "{n, plural, offset:1 =0 {nobody} =1 {just them} one {them and # other} other {them and # others}}"; + + await Assert.That(Format(Pattern, "en", ("n", 0))).IsEqualTo("nobody"); + await Assert.That(Format(Pattern, "en", ("n", 1))).IsEqualTo("just them"); + await Assert.That(Format(Pattern, "en", ("n", 2))).IsEqualTo("them and 1 other"); + await Assert.That(Format(Pattern, "en", ("n", 3))).IsEqualTo("them and 2 others"); + } + + [Test] + public async Task AHashPrintsANumberTheWayANumberArgumentPrintsIt() + { + // One bundle may not print one quantity two ways. `#` was the raw integer digits and + // `{n, number}` was the culture's grouped form, so a listing past a thousand said "1234 + // games" in a sentence and "1,234" in the column beside it. The separator is the culture's: + // en groups with a comma and de with a full stop. + await Assert.That(Format("{n, plural, other {# games}}", "en", ("n", 1234))).IsEqualTo("1,234 games"); + await Assert.That(Format("{n, plural, other {# Spiele}}", "de", ("n", 1234))).IsEqualTo("1.234 Spiele"); + + await Assert.That(Format("{n, plural, other {#}}", "en", ("n", 1_234_567))) + .IsEqualTo(Format("{n, number, integer}", "en", ("n", 1_234_567))); + } + + [Test] + public async Task ANegativeCountKeepsItsSign() + { + // CLDR takes the absolute value to choose a category and never to print the number. The + // operands are absolute because the chart says so; the rendering is not, and printing "3 + // games" for minus three is a measurement stated backwards. + const string Pattern = "{n, plural, one {# game} other {# games}}"; + + await Assert.That(Format(Pattern, "en", ("n", -1))).IsEqualTo("-1 game"); + await Assert.That(Format(Pattern, "en", ("n", -3))).IsEqualTo("-3 games"); + await Assert.That(Format(Pattern, "en", ("n", -1234))).IsEqualTo("-1,234 games"); + } + + [Test] + public async Task ChineseHasOneFormAndSoAgreesWithAnyShape() + { + // Which is exactly why it cannot be the locale a string architecture is validated against. + foreach (var count in new[] { 0, 1, 2, 5, 11 }) + { + await Assert.That(Format("{n, plural, other {#个游戏}}", "zh-Hans", ("n", count))) + .IsEqualTo($"{count}个游戏"); + } + } + + // ── select and nesting ─────────────────────────────────────────────────────────────────── + + [Test] + public async Task SelectMatchesAKeywordAndFallsBackToOther() + { + const string Pattern = "{state, select, measured {we watched it} declared {they said so} other {unknown}}"; + + await Assert.That(Format(Pattern, "en", ("state", "measured"))).IsEqualTo("we watched it"); + await Assert.That(Format(Pattern, "en", ("state", "declared"))).IsEqualTo("they said so"); + await Assert.That(Format(Pattern, "en", ("state", "derived"))).IsEqualTo("unknown"); + } + + [Test] + public async Task ASelectorMayHoldAnotherSelector() + { + // The case that breaks a parser which stops at the first closing brace: a branch containing + // an argument ends with two of them, and only a counted scan gets the boundary right. + const string Pattern = + "{kind, select, game {{n, plural, one {# game} other {# games}}} other {{n} things}}"; + + await Assert.That(Format(Pattern, "en", ("kind", "game"), ("n", 1))).IsEqualTo("1 game"); + await Assert.That(Format(Pattern, "en", ("kind", "game"), ("n", 7))).IsEqualTo("7 games"); + await Assert.That(Format(Pattern, "en", ("kind", "other"), ("n", 7))).IsEqualTo("7 things"); + } + + [Test] + public async Task AHashIsNotSpecialInsideANestedArgumentsSubMessage() + { + // ICU's rule, and a genuinely surprising one: # is a placeholder in the plural argument's + // own sub-messages and nowhere else. Inside a select nested in that plural it is a literal + // hash, and a message that wants the number there has to name the argument. + await Assert.That(Format( + "{n, plural, other {{k, select, a {# apples} other {# other}}}}", + "en", ("n", 4), ("k", "a"))) + .IsEqualTo("# apples"); + + await Assert.That(Format( + "{n, plural, other {{k, select, a {{n} apples} other {other}}}}", + "en", ("n", 4), ("k", "a"))) + .IsEqualTo("4 apples"); + } + + // ── number, date and time ──────────────────────────────────────────────────────────────── + + [Test] + public async Task NumberCarriesItsStyles() + { + await Assert.That(Format("{n, number}", "en", ("n", 1234.5m))).IsEqualTo("1,234.5"); + await Assert.That(Format("{n, number, integer}", "en", ("n", 1234.6m))).IsEqualTo("1,235"); + await Assert.That(Format("{n, number, percent}", "en", ("n", 0.42m))).IsEqualTo("42%"); + await Assert.That(Format("{n, number, ::.00}", "en", ("n", 3.14159m))).IsEqualTo("3.14"); + } + + [Test] + public async Task DateAndTimeAreAcceptedRatherThanRefused() + { + // Nothing on this site calls them — every date goes through Dates, which states UTC and + // never prints a numeric month. They are here so the grammar is supported rather than the + // half of it we happen to use. + var when = new DateTimeOffset(2026, 8, 17, 14, 2, 0, TimeSpan.Zero); + + await Assert.That(Format("{d, date}", "en", ("d", when))).IsEqualTo("17 Aug 2026"); + await Assert.That(Format("{d, date, short}", "en-GB", ("d", when))).Contains("2026"); + await Assert.That(Format("{d, time}", "en", ("d", when))).IsEqualTo("14:02:00"); + } + + // ── refusals ───────────────────────────────────────────────────────────────────────────── + + [Test] + public async Task ASelectorWithNoOtherBranchIsRefusedWhenItIsParsed() + { + // Not when a reader's count happens to reach the gap. Every bundle is parsed by a test, so + // this fails a build. + await Assert.That(() => MessagePattern.Parse("{n, plural, one {# game}}")) + .Throws<FormatException>(); + + await Assert.That(() => MessagePattern.Parse("{x, select, a {A}}")) + .Throws<FormatException>(); + } + + [Test] + public async Task ABranchKeywordNoCategoryUsesIsRefused() + { + // "much" is not a CLDR category, so nothing would ever select it. It is almost always a typo + // for "many", and silently rendering `other` instead is how that typo survives review. + await Assert.That(() => MessagePattern.Parse("{n, plural, much {#} other {#}}")) + .Throws<FormatException>(); + } + + [Test] + public async Task DeprecatedAndUnknownTypesAreRefusedRatherThanGuessed() + { + await Assert.That(() => MessagePattern.Parse("{n, choice, 0#none|1#one}")) + .Throws<FormatException>(); + + await Assert.That(() => MessagePattern.Parse("{n, spellout}")) + .Throws<FormatException>(); + } + + [Test] + public async Task AMissingArgumentIsAnErrorAndNotAnEmptyString() + { + // A message that silently rendered nothing for a value nobody passed would be a fact + // quietly missing from a page whose whole claim is that its facts are there. + await Assert.That(() => Format("{missing}")).Throws<FormatException>(); + await Assert.That(() => Format("{n, plural, other {#}}", "en", ("n", "not a number"))) + .Throws<FormatException>(); + } + + [Test] + public async Task AnUnmatchedBraceIsRefused() + { + await Assert.That(() => MessagePattern.Parse("a } b")).Throws<FormatException>(); + await Assert.That(() => MessagePattern.Parse("{n, plural, other {#}")).Throws<FormatException>(); + } + + [Test] + [Arguments("{n, plural, = {none} other {#}}")] // a bare '=' matched nothing at all + [Arguments("{n, plural, =x {none} other {#}}")] // and neither does a word after it + [Arguments("{n, plural, =- {none} other {#}}")] + [Arguments("{n, plural, =. {none} other {#}}")] + public async Task AnExplicitMatchWithNoNumberAfterItIsRefused(string pattern) + { + // An `=` selector is stored under a key compared against the number as written, so `=` on + // its own is a branch nothing can ever select. The category check at the line above skips + // anything starting with `=`, so this was the one dead branch the parser let through — and + // a dead branch is precisely what this parser refuses rather than guesses at. + await Assert.That(() => MessagePattern.Parse(pattern)).Throws<FormatException>(); + } + + [Test] + public async Task AnExplicitMatchStillTakesEveryNumberIcuWritesOneWith() + { + // Refusing the empty case must not also refuse the legal ones: ICU parses an explicit value + // as a number, which may carry a sign and a fraction. + await Assert.That(Format("{n, plural, =0 {none} other {#}}", "en", ("n", 0))).IsEqualTo("none"); + await Assert.That(Format("{n, plural, =-1 {owed} other {#}}", "en", ("n", -1))).IsEqualTo("owed"); + await Assert.That(Format("{n, plural, =1.5 {half} other {#}}", "en", ("n", 1.5m))).IsEqualTo("half"); + } + + [Test] + public async Task ADateWithNoZoneIsReadAsUtcAndNotAsTheServersOwnClock() + { + // This site states UTC on every date it prints, and `new DateTimeOffset(dt)` applies the + // machine's local offset to an Unspecified kind — so the same message rendered on two + // hosts said two different times, and neither said which. + var unspecified = new DateTime(2026, 8, 17, 14, 2, 0, DateTimeKind.Unspecified); + + await Assert.That(Format("{d, time, medium}", "en", ("d", unspecified))).IsEqualTo("14:02:00"); + await Assert.That(Format("{d, date, zzz}", "en", ("d", unspecified))).IsEqualTo("+00:00"); + } + + [Test] + public async Task ANumberArgumentThatIsNotANumberNamesItselfInTheRefusal() + { + // The documented contract is FormatException. Convert.ToDecimal raises InvalidCastException + // for a value with no conversion and OverflowException for one out of range, and neither + // says which argument in a forty-message page was the one that failed. + await Assert.That(() => Format("{n, number}", "en", ("n", new object()))) + .Throws<FormatException>(); + + await Assert.That(() => Format("{n, number, integer}", "en", ("n", double.MaxValue))) + .Throws<FormatException>(); + } + + // ── the parse, as a thing callers can read ─────────────────────────────────────────────── + + [Test] + public async Task APatternCanBeAskedWhatArgumentsItReads() + { + // Which is what lets a test check a bundle against the values the site actually supplies, + // without rendering every message against every plausible count. + var parsed = MessagePattern.Parse( + "{value}, {count, plural, one {# game} other {# games}}, {state, select, a {A} other {B}}"); + + var names = parsed.Arguments().Select(a => a.Name).ToList(); + + await Assert.That(names).Contains("value"); + await Assert.That(names).Contains("count"); + await Assert.That(names).Contains("state"); + + var plural = parsed.Arguments().Single(a => a.Kind is ArgumentKind.Plural); + + await Assert.That(plural.Branches.Keys).Contains("one"); + await Assert.That(plural.Branches.Keys).Contains("other"); + } + + [Test] + public async Task ThePatternCacheReturnsTheSameParseForTheSameText() + { + // Forty messages render per facet panel, and re-parsing a string that has not changed since + // startup is work nobody asked for. + const string Pattern = "{n, plural, one {#} other {#}}"; + + await Assert.That(IcuMessage.Compile(Pattern)).IsSameReferenceAs(IcuMessage.Compile(Pattern)); + } +} diff --git a/tests/MUI.Web.Tests/LocalizationTests.cs b/tests/MUI.Web.Tests/LocalizationTests.cs new file mode 100644 index 0000000..a2d1daa --- /dev/null +++ b/tests/MUI.Web.Tests/LocalizationTests.cs @@ -0,0 +1,1350 @@ +using Microsoft.AspNetCore.Http; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.FileProviders; +using Microsoft.Extensions.Hosting; +using MUI.Web.Localization; + +namespace MUI.Web.Tests; + +/// <summary> +/// The localization pipeline: plural rules, ICU messages, the locked glossary, and the routing. +/// </summary> +/// <remarks> +/// Nothing here asserts that a translation is <em>good</em> — no test can, and the handoff is +/// explicit that Han glyph correctness and register both need review by somebody who reads the +/// language. What these hold is the part a machine can: that a message reaches every form its locale +/// needs, that a locked string cannot quietly become a paraphrase, and that a locale nobody has +/// translated is never offered to a reader. +/// </remarks> +public class LocalizationTests +{ + // ── plural rules ───────────────────────────────────────────────────────────────────────── + + [Test] + [Arguments(0, "other")] + [Arguments(1, "one")] + [Arguments(2, "other")] + [Arguments(21, "other")] + public async Task EnglishHasTwoForms(int count, string expected) + { + await Assert.That(PluralRules.Keyword(PluralRules.Of("en", count))).IsEqualTo(expected); + } + + [Test] + [Arguments(1, "one")] + [Arguments(21, "one")] + [Arguments(2, "few")] + [Arguments(23, "few")] + [Arguments(5, "many")] + [Arguments(11, "many")] // the exception that catches a naive n % 10 rule + [Arguments(12, "many")] + [Arguments(0, "many")] + public async Task RussianHasThreeAndTheyAreNotObvious(int count, string expected) + { + // 11 and 12 end in 1 and 2 and take neither `one` nor `few`. A rule written from the first + // three examples anybody tries is wrong for both, which is why the canary exists. + await Assert.That(PluralRules.Keyword(PluralRules.Of("ru", count))).IsEqualTo(expected); + } + + [Test] + [Arguments(0)] + [Arguments(1)] + [Arguments(5)] + public async Task ChineseHasOneFormAndSoCannotFailAnAgreementBug(int count) + { + // The reason Chinese ships first and Russian goes in CI. Chinese agrees with any string + // architecture, including one that is wrong for every inflected language. + await Assert.That(PluralRules.Of("zh-Hans", count)).IsEqualTo(PluralCategory.Other); + await Assert.That(PluralRules.CategoriesOf("zh-Hans").Count).IsEqualTo(1); + } + + [Test] + public async Task AScriptOrPrivateSubtagDoesNotChangeHowANumberAgrees() + { + // zh-Hans and zh-Hant draw different glyphs; ru and the canary's ru-x-canary read different + // bundles. Neither changes the arithmetic. + await Assert.That(PluralRules.Of("zh-Hant", 5)).IsEqualTo(PluralRules.Of("zh", 5)); + await Assert.That(PluralRules.Of("ru-x-canary", 2)).IsEqualTo(PluralRules.Of("ru", 2)); + } + + // ── plural rules, checked against the CLDR 46 chart rather than against memory ──────────── + + [Test] + public async Task TurkishSaysOneForOneAndForNothingElse() + { + // CLDR 46 tr — one: n = 1. The table said `n = 0..1`, which is a real rule in CLDR and + // belongs to Akan and Punjabi, not to Turkish. It put zero in the form Turkish reserves + // for exactly one thing. + await Assert.That(PluralRules.Keyword(PluralRules.Of("tr", 0))).IsEqualTo("other"); + await Assert.That(PluralRules.Keyword(PluralRules.Of("tr", 1))).IsEqualTo("one"); + await Assert.That(PluralRules.Keyword(PluralRules.Of("tr", 2))).IsEqualTo("other"); + } + + [Test] + [Arguments("el", "one")] // one: n = 1 + [Arguments("no", "one")] // one: n = 1 + [Arguments("es", "one")] // one: n = 1 + [Arguments("tr", "one")] // one: n = 1 + [Arguments("da", "one")] // one: n = 1 or t != 0 and i = 0,1 + [Arguments("be", "one")] // one: n % 10 = 1 and n % 100 != 11 — stated on n, no v guard + [Arguments("en", "other")] // one: i = 1 and v = 0 + [Arguments("de", "other")] // one: i = 1 and v = 0 + [Arguments("it", "other")] // one: i = 1 and v = 0 + [Arguments("ru", "other")] // one: v = 0 and i % 10 = 1 and i % 100 != 11 + public async Task OnePointZeroIsWhatSeparatesARuleStatedOnNFromOneStatedOnI(string tag, string expected) + { + // 1.0 is the only value that tells the two shapes apart, and transcribing every language + // into `i = 1 and v = 0` because English is written that way is wrong for six of the + // thirty-one here. It is also the exact error the operands in this file exist to catch. + var oneDotZero = PluralOperands.Of(1.0m, visibleFractionDigits: 1); + + await Assert.That(PluralRules.Keyword(PluralRules.Of(tag, oneDotZero))).IsEqualTo(expected); + } + + [Test] + public async Task DanishSaysOneForAFractionBelowTwo() + { + // CLDR 46 da — one: n = 1 or t != 0 and i = 0,1. Danish is the only language in this table + // whose `one` reaches a value that is not 1, and a rule copied from Swedish loses it. + await Assert.That(PluralRules.Keyword(PluralRules.Of("da", PluralOperands.Of(0.5m)))).IsEqualTo("one"); + await Assert.That(PluralRules.Keyword(PluralRules.Of("da", PluralOperands.Of(1.5m)))).IsEqualTo("one"); + await Assert.That(PluralRules.Keyword(PluralRules.Of("da", PluralOperands.Of(2.5m)))).IsEqualTo("other"); + await Assert.That(PluralRules.Keyword(PluralRules.Of("da", 0))).IsEqualTo("other"); + } + + [Test] + [Arguments("fr")] + [Arguments("pt")] + [Arguments("es")] + [Arguments("it")] + public async Task AMillionTakesItsOwnFormInEveryRomanceLanguageCldrStatesOneFor(string tag) + { + // many: e = 0 and i != 0 and i % 1000000 = 0 and v = 0 — "un millón de juegos" takes a + // preposition the other forms do not. fr and pt had it; es and it were given English's + // rule and so had no `many` at all. + await Assert.That(PluralRules.Keyword(PluralRules.Of(tag, 1_000_000))).IsEqualTo("many"); + await Assert.That(PluralRules.Keyword(PluralRules.Of(tag, 2_000_000))).IsEqualTo("many"); + await Assert.That(PluralRules.Keyword(PluralRules.Of(tag, 1_000_001))).IsEqualTo("other"); + } + + [Test] + public async Task HebrewLostItsManyFormAndAllOfItsOrdinalsBeforeCldr46() + { + // Both were removed upstream, and a table still carrying them selects a branch no + // translator was asked to write — the failure this file's `other` fallback cannot catch, + // because the branch exists and is simply wrong. + await Assert.That(PluralRules.Keyword(PluralRules.Of("he", 20))).IsEqualTo("other"); + await Assert.That(PluralRules.Keyword(PluralRules.Of("he", 100))).IsEqualTo("other"); + + await Assert.That(PluralRules.CategoriesOf("he", PluralKind.Ordinal)) + .IsEquivalentTo(new[] { PluralCategory.Other }); + + // one: i = 1 and v = 0 or i = 0 and v != 0 — the second clause was missing entirely. + await Assert.That(PluralRules.Keyword(PluralRules.Of("he", PluralOperands.Of(0.5m)))).IsEqualTo("one"); + } + + [Test] + [Arguments("sv", 1, "one")] // one: n % 10 = 1,2 and n % 100 != 11,12 + [Arguments("sv", 2, "one")] + [Arguments("sv", 3, "other")] + [Arguments("sv", 11, "other")] + [Arguments("sv", 12, "other")] + [Arguments("sv", 21, "one")] + [Arguments("be", 2, "few")] // few: n % 10 = 2,3 and n % 100 != 12,13 + [Arguments("be", 3, "few")] + [Arguments("be", 12, "other")] + [Arguments("be", 13, "other")] + [Arguments("vi", 1, "one")] // one: n = 1 + [Arguments("vi", 2, "other")] + [Arguments("ms", 1, "one")] // one: n = 1 + public async Task TheOrdinalTableStatesARuleForEveryLanguageCldrStatesOneFor(string tag, int n, string expected) + { + // An ordinal rule missing from the table is not a missing translation — it is every rank + // rendered in the `other` form, silently, in a language that inflects them. + await Assert.That(PluralRules.Keyword(PluralRules.Of(tag, n, PluralKind.Ordinal))).IsEqualTo(expected); + } + + [Test] + public async Task ACldrRangeMatchesAWholeNumberAndNothingElse() + { + // `n % 100 = 3..10` is a range over integers: 3.5 is not in it. Reading it as `i % 100` + // makes every fraction take the category of its integer part. + await Assert.That(PluralRules.Keyword(PluralRules.Of("ar", PluralOperands.Of(3.5m)))).IsEqualTo("other"); + await Assert.That(PluralRules.Keyword(PluralRules.Of("ar", 3))).IsEqualTo("few"); + await Assert.That(PluralRules.Keyword(PluralRules.Of("ar", 11))).IsEqualTo("many"); + } + + // ── ICU messages ───────────────────────────────────────────────────────────────────────── + + [Test] + [Arguments(0, "0 games")] + [Arguments(1, "1 game")] + [Arguments(2, "2 games")] + public async Task ACountAndItsNounAgree(int count, string expected) + { + // The panel shipped "1 games" and "0 games" on every accessible name until this existed. + await Assert.That(Messages.Count("en", count)).IsEqualTo(expected); + } + + [Test] + public async Task TheSameMessageReachesADifferentFormInADifferentLocale() + { + // One message, one argument, three answers — which is the whole point of the message being + // a message rather than a number glued to a word. + await Assert.That(Messages.Count("ru-x-canary", 1)).IsEqualTo("1 игра"); + await Assert.That(Messages.Count("ru-x-canary", 2)).IsEqualTo("2 игры"); + await Assert.That(Messages.Count("ru-x-canary", 5)).IsEqualTo("5 игр"); + } + + [Test] + public async Task AnExactMatchWinsOverACategory() + { + // `=0` is how a message says "no games" rather than "0 games" without inventing a plural + // category that CLDR does not give English. + var listing = Messages.For("en", "listing.total", new Dictionary<string, object?> { ["count"] = 0 }); + + await Assert.That(listing).StartsWith("No games"); + } + + [Test] + public async Task ABranchMayHoldAnotherArgument() + { + // "1 of 6 disagree" nests {total} inside a plural branch. A parser that stopped at the first + // closing brace would cut the branch in half and read the rest as a key. + var args = new Dictionary<string, object?> { ["disagreeing"] = 1, ["total"] = 6 }; + + await Assert.That(Messages.For("en", "capabilities.agree", args)) + .IsEqualTo("1 of 6 disagrees with what the game declares."); + + args["disagreeing"] = 0; + + await Assert.That(Messages.For("en", "capabilities.agree", args)) + .IsEqualTo("None of the 6 disagree."); + } + + [Test] + public async Task SyntaxThisFormatterDoesNotImplementIsRefusedRatherThanGuessed() + { + // A formatter that accepts what it cannot do fails as a wrong string rather than as a build + // error, and a wrong string on this site is a wrong claim. + await Assert.That(() => IcuMessage.Format("{n, date, short}", "en", new Dictionary<string, object?> { ["n"] = 1 })) + .Throws<FormatException>(); + + await Assert.That(() => IcuMessage.Format("{missing}", "en")) + .Throws<FormatException>(); + } + + [Test] + public async Task AHashOutsideAPluralBranchIsALiteral() + { + // ICU says so, and a game called "#1 MUSH" would otherwise render its own count. + await Assert.That(IcuMessage.Format("channel #general", "en")).IsEqualTo("channel #general"); + } + + // ── the locked glossary ────────────────────────────────────────────────────────────────── + + [Test] + public async Task EveryLockedIdIsAMessageTheSiteActuallySays() + { + // A glossary entry with no message behind it is a promise to translators about a string + // that does not exist, and it would go on being translated for ever. + foreach (var locked in Glossary.Locked) + { + await Assert.That(Messages.Pattern(Locales.SourceTag, locked.Id)) + .IsEqualTo(locked.English) + .Because($"{locked.Id} is locked but the English bundle disagrees"); + } + } + + [Test] + public async Task TheFourKindsOfAbsenceAreFourDifferentStrings() + { + // The finding this whole file exists for. "not measured", "uncounted", "unreachable" and + // "not counted" are four claims, and a translation engine treats them as stylistic variants + // of *unavailable* — after which a reader cannot tell a game that answered from one that did + // not, which is the one thing this site is for. + string[] ids = ["state.notMeasured", "state.uncounted", "state.unreachable", "state.notCounted"]; + + var english = ids.Select(id => Messages.For("en", id)).ToList(); + + await Assert.That(english.Distinct().Count()).IsEqualTo(ids.Length); + + foreach (var id in ids) + { + await Assert.That(Glossary.IsLocked(id)).IsTrue().Because($"{id} must not be paraphrasable"); + } + } + + [Test] + public async Task OneEnglishWordWithSeveralSubjectsIsSeveralIds() + { + // "measured" is one string in English and four in Russian, chosen by what it describes. The + // ids have to be granular enough for a translator to reach each case at all — collapsing + // them because the source language cannot tell them apart is how three cases out of four end + // up ungrammatical. + var measured = Glossary.Locked.Where(l => l.English == "measured").ToList(); + + await Assert.That(measured.Count).IsGreaterThanOrEqualTo(4); + await Assert.That(measured.Select(m => m.Id).Distinct().Count()).IsEqualTo(measured.Count); + await Assert.That(measured.Select(m => m.Subject).Distinct().Count()).IsGreaterThanOrEqualTo(4); + + // And the bare column header is one of them, because it modifies nothing and so takes a form + // none of the others do. + await Assert.That(Glossary.Of("kicker.measured")!.Subject).IsEqualTo(Subject.Standalone); + } + + [Test] + public async Task EveryLockedStringShipsWithTheReasonItIsLocked() + { + // The lock reads as distrust without it, and a well-meaning "improvement" arrives as a pull + // request nobody knows how to refuse. + foreach (var locked in Glossary.Locked) + { + await Assert.That(string.IsNullOrWhiteSpace(locked.Rationale)).IsFalse(); + await Assert.That(locked.Rationale.Length).IsGreaterThan(40); + } + + await Assert.That(Glossary.Brief()).Contains("provenance.count.measured"); + await Assert.That(Glossary.Brief()).Contains("the English will show"); + } + + // ── completeness, and the canary ───────────────────────────────────────────────────────── + + [Test] + public async Task AnUntranslatedStringFallsBackToTheEnglishRatherThanToNothing() + { + // A reader meeting one English phrase inside another language learns something true. A + // smoothed-over approximation of a locked string teaches them something false and gives them + // no way to tell. + await Assert.That(Messages.HasOwn("ru-x-canary", "term.connected")).IsFalse(); + await Assert.That(Messages.For("ru-x-canary", "term.connected")).IsEqualTo("connected"); + + // And where it has been translated, the translation wins. + await Assert.That(Messages.For("ru-x-canary", "kicker.measured")).IsEqualTo("ИЗМЕРЕНО"); + } + + [Test] + public async Task TheCanaryFailsOnAMissingPluralFormRatherThanRenderingOne() + { + // The whole reason Russian is wired into CI while Chinese ships first. `listing.total` in + // the canary bundle declares `one` and `other` — complete in English, and silently missing + // the `few` form that a count of two takes in Russian. + var incomplete = Missing("ru-x-canary", "listing.total"); + + // Reported per argument, because a message with two counts in it can be complete for one + // and not the other. + await Assert.That(incomplete).Contains("count:few"); + await Assert.That(incomplete).Contains("count:many"); + + // Where the message is complete, nothing is reported. + await Assert.That(Missing("ru-x-canary", "facet.count")).IsEmpty(); + } + + [Test] + public async Task EveryOfferedLocaleIsCompleteInEveryPluralFormItNeeds() + { + // The gate. A locale reaches LocaleStatus.Shipped only when this holds for it — which is why + // the canary above is TestOnly and is not walked here. + foreach (var locale in Locales.Offered) + { + foreach (var id in Messages.Ids) + { + await Assert.That(Missing(locale.Tag, id)) + .IsEmpty() + .Because($"{locale.Tag} / {id} is missing a plural form it needs"); + } + } + } + + [Test] + public async Task NoLocaleIsOfferedBeforeItsLockedStringsAreTranslated() + { + // Nothing ships to a reader before the glossary exists. Today that means English alone, and + // this test is what stops somebody moving a status enum and shipping a mostly-English page + // under a Chinese flag. + foreach (var locale in Locales.Offered.Where(l => l.Tag != Locales.SourceTag)) + { + foreach (var locked in Glossary.Locked) + { + await Assert.That(Messages.HasOwn(locale.Tag, locked.Id)) + .IsTrue() + .Because($"{locale.Tag} is offered without a translation for {locked.Id}"); + } + } + } + + [Test] + public async Task ThePseudolocaleExercisesTheMachineryAndTheWidthBudget() + { + // Accented and expanded, so a string that never went through the pipeline is visible at a + // glance and every string is reviewed at the 1.4x width German and Russian actually need. + var pseudo = Messages.Count("qps-ploc", 3); + + await Assert.That(pseudo).Contains("⟦"); + await Assert.That(pseudo).Contains("3"); + await Assert.That(pseudo.Length).IsGreaterThan(Messages.Count("en", 3).Length); + + // And the ICU syntax survived: a pseudolocale that mangled a branch keyword would prove + // nothing, because the message would not parse. + await Assert.That(Messages.Count("qps-ploc", 1)).Contains("1"); + } + + // ── routing ────────────────────────────────────────────────────────────────────────────── + + [Test] + [Arguments("de", "de")] + [Arguments("de-AT,de;q=0.9,en;q=0.8", "de")] + [Arguments("zh-CN,zh;q=0.9", "zh-Hans")] + [Arguments("en-GB,en;q=0.9", null)] // already where they are + [Arguments("de;q=0", null)] // explicitly refused + [Arguments("*", null)] + [Arguments("", null)] + [Arguments("kl,fo", null)] // nothing offered answers + public async Task AcceptLanguageIsReadForTheFirstVisitOnly(string header, string? expected) + { + // A header is a standing preference about content in general, not a choice about this site — + // worth one redirect and no more. The parse honours q-values because a browser sends them + // meaning something, and matches on the language subtag so zh-CN reaches zh-Hans. + // + // Note every case answers null today, because English is the only offered locale and English + // is where the reader already is. The rule is asserted against the offered set rather than + // against a hard-coded answer, so this starts biting the day a locale ships. + var chosen = LocaleRouting.Preferred(header); + + if (expected is null || Locales.Find(expected) is not { IsOffered: true }) + { + await Assert.That(chosen).IsNull(); + return; + } + + await Assert.That(chosen!.Tag).IsEqualTo(expected); + } + + [Test] + [Arguments("/games", "/games")] + [Arguments("/de/games", "/games")] + [Arguments("//elsewhere.example", "/")] + [Arguments("/\\elsewhere.example", "/")] + [Arguments("/games\nLocation: /evil", "/")] + [Arguments("", "/")] + public async Task TheReturnPathIsAPathOnThisSiteAndNothingElse(string posted, string expected) + { + // It arrives in a form field and is written into a Location header. A protocol-relative URL + // is a different host wearing a path's clothes and walks straight through a StartsWith('/') + // check; several browsers read /\host the same way; a CR here is response splitting. + // Any locale prefix comes off, because the endpoint decides which language the page is in. + await Assert.That(LocaleRouting.Back(posted)).IsEqualTo(expected); + } + + /// <summary> + /// The document states the language it is written in, and it is the one the reader asked for. + /// </summary> + /// <remarks> + /// <para> + /// <c>lang</c> was the constant <c>"en"</c> while the whole page below it came back translated, + /// so a reader on <c>/ja/games</c> was handed a fully Japanese document that told the browser it + /// was English. That is not a tidiness point on the two locales this site shipped first: Unicode + /// unified thousands of Han characters across Chinese and Japanese, the correct drawn form + /// differs, and <c>lang</c> is the only thing that selects between the two font families. The + /// wrong one renders at exactly the same width, so nothing in the overflow audit could see it. + /// </para> + /// <para> + /// It is also what a screen reader switches voice on, and what the <c>hreflang</c> links in the + /// head are claiming about this document — three separate promises that were all being made in + /// the wrong language. + /// </para> + /// </remarks> + [Test] + [Arguments("/games", "en")] + [Arguments("/de/games", "de")] + [Arguments("/nl/games", "nl")] + [Arguments("/ja/games", "ja")] + [Arguments("/zh-Hans/games", "zh-Hans")] + public async Task TheDocumentDeclaresTheLanguageItIsAnsweredIn(string path, string expected) + { + await using var site = await SiteHost.StartAsync(); + + var markup = await site.Client.GetStringAsync(path); + + await Assert.That(markup).Contains($"<html lang=\"{expected}\""); + } + + /// <summary> + /// A locale is a property of a document, so nothing else is ever moved to reach one. + /// </summary> + /// <remarks> + /// <para> + /// <b>The locale was a one-way door, and the switcher out of it was the thing it shut.</b> The + /// middleware answered any unprefixed request from a reader with <c>mui_locale=de</c> with a + /// redirect to <c>/de/...</c> — including a POST. A browser follows a 302 as a GET and drops the + /// body, and <c>/de/theme</c> is served by nothing, so a German reader could not change the + /// theme; <c>POST /locale</c> went the same way, so they could not change the language back + /// either. Every control on this site is a form, which is what made one redirect reach all of + /// them. + /// </para> + /// <para> + /// The API and the crawler's own files are excluded for a different reason: they are not + /// documents in a language. <c>/api/…</c> answers the same JSON to everybody and + /// <c>robots.txt</c> has one canonical address, which is where a crawler looks for it. + /// </para> + /// </remarks> + [Test] + public async Task AChoiceOfLocaleNeverMovesARequestThatIsNotADocument() + { + await using var site = await SiteHost.StartAsync(); + + // The theme is written, rather than the request being bounced to a URL nothing serves. + var theme = new HttpRequestMessage(HttpMethod.Post, "/theme") + { + Content = new FormUrlEncodedContent([ + new KeyValuePair<string, string>("theme", "light"), + new KeyValuePair<string, string>("return", "/games"), + ]), + }; + theme.Headers.Add("Cookie", $"{Locales.CookieName}=de"); + + var themed = await site.Client.SendAsync(theme); + + await Assert.That(themed.Headers.TryGetValues("Set-Cookie", out var themeCookies)).IsTrue(); + await Assert.That(string.Join(' ', themeCookies!)).Contains("mui_theme=light"); + + // And the way out of German is still open from inside German. + var switched = new HttpRequestMessage(HttpMethod.Post, Locales.Path) + { + Content = new FormUrlEncodedContent([ + new KeyValuePair<string, string>(Locales.Field, "nl"), + new KeyValuePair<string, string>(Locales.ReturnField, "/games"), + ]), + }; + switched.Headers.Add("Cookie", $"{Locales.CookieName}=de"); + + var moved = await site.Client.SendAsync(switched); + + await Assert.That(moved.Headers.TryGetValues("Set-Cookie", out var localeCookies)).IsTrue(); + await Assert.That(string.Join(' ', localeCookies!)).Contains($"{Locales.CookieName}=nl"); + await Assert.That(moved.Headers.Location?.OriginalString).IsEqualTo("/nl/games"); + } + + /// <summary>A document still follows the reader's choice, which is the rule the guard protects.</summary> + [Test] + public async Task AChoiceOfLocaleStillMovesADocument() + { + await using var site = await SiteHost.StartAsync(); + + var asked = new HttpRequestMessage(HttpMethod.Get, "/games"); + asked.Headers.Add("Cookie", $"{Locales.CookieName}=de"); + + var answered = await site.Client.SendAsync(asked); + + await Assert.That((int)answered.StatusCode).IsEqualTo(302); + await Assert.That(answered.Headers.Location?.OriginalString).IsEqualTo("/de/games"); + } + + /// <summary> + /// A redirect re-emits the address that was asked for, and not a decoded reading of it. + /// </summary> + /// <remarks> + /// <c>Request.Path.Value</c> is decoded, so writing it back into a <c>Location</c> header + /// changes what the URL means: <c>%2F</c> comes back as a separator and makes one segment into + /// two, <c>%23</c> comes back as a <c>#</c> and truncates everything after it, and a non-ASCII + /// character comes back raw into a header field that cannot carry one. A game whose slug + /// contains any of them is a game a reader cannot reach in any language but English. + /// </remarks> + [Test] + [Arguments("/g/a%2Fb")] + [Arguments("/g/caf%C3%A9")] + [Arguments("/g/one%23two")] + [Arguments("/g/what%3Fnow")] + public async Task AnEscapedPathSurvivesTheRedirectItIsSentThrough(string path) + { + await using var site = await SiteHost.StartAsync(); + + var asked = new HttpRequestMessage(HttpMethod.Get, path); + asked.Headers.Add("Cookie", $"{Locales.CookieName}=de"); + + var answered = await site.Client.SendAsync(asked); + + await Assert.That((int)answered.StatusCode).IsEqualTo(302); + await Assert.That(answered.Headers.Location?.OriginalString).IsEqualTo("/de" + path); + } + + /// <summary>And the same going the other way, off the /en prefix that redirects to no prefix.</summary> + [Test] + [Arguments("/en/g/a%2Fb", "/g/a%2Fb")] + [Arguments("/en/g/caf%C3%A9", "/g/caf%C3%A9")] + public async Task AnEscapedPathSurvivesTheRedirectOffTheEnglishPrefix(string asked, string expected) + { + await using var site = await SiteHost.StartAsync(); + + var answered = await site.Client.GetAsync(asked); + + await Assert.That((int)answered.StatusCode).IsEqualTo(301); + await Assert.That(answered.Headers.Location?.OriginalString).IsEqualTo(expected); + } + + /// <summary> + /// A file is the same file in every language, including the ones whose names we cannot know. + /// </summary> + /// <remarks> + /// The stylesheet carries a content fingerprint, so no list of paths can name it — and a reader + /// with a locale cookie was paying a redirect for the stylesheet, the script and the touch icon + /// on every page load. Recognised by extension rather than by "the last segment has a dot", + /// because <c>{Slug}</c> is a route parameter and a game's slug is not this rule's to constrain. + /// </remarks> + [Test] + [Arguments("/app.gt0hup1p9v.css")] + [Arguments("/passkey.js")] + [Arguments("/apple-touch-icon.png")] + [Arguments("/favicon.svg")] + [Arguments("/site.webmanifest")] + [Arguments("/robots.txt")] + [Arguments("/sitemap.xml")] + public async Task AFingerprintedFileIsNeverGivenALocalePrefix(string path) + { + await Assert.That(LocaleRouting.IsUnlocalized(path)).IsTrue(); + } + + /// <summary>And a document is still a document, whatever is in its slug.</summary> + [Test] + [Arguments("/games")] + [Arguments("/g/m-u-s-h")] + [Arguments("/reference/protocols/mssp")] + [Arguments("/g/a-game-with.no-extension")] + public async Task ADocumentIsNeverMistakenForAFile(string path) + { + await Assert.That(LocaleRouting.IsUnlocalized(path)).IsFalse(); + } + + /// <summary>The read API and the crawler's files have one address each, in every language.</summary> + [Test] + [Arguments("/api/games")] + [Arguments("/robots.txt")] + [Arguments("/sitemap.xml")] + public async Task AFileThatIsTheSameInEveryLanguageIsNotGivenALocalePrefix(string path) + { + await using var site = await SiteHost.StartAsync(); + + var asked = new HttpRequestMessage(HttpMethod.Get, path); + asked.Headers.Add("Cookie", $"{Locales.CookieName}=de"); + + var answered = await site.Client.SendAsync(asked); + + await Assert.That((int)answered.StatusCode).IsNotEqualTo(302); + } + + // ── links out of a locale ──────────────────────────────────────────────────────────────── + + /// <summary> + /// One address, in the locale the page carrying it is read in. + /// </summary> + /// <remarks> + /// The table is the whole rule: an app path takes the prefix, the source locale takes none, and + /// four shapes are left exactly as they arrived — a query-only address, which means <em>this + /// page, asked differently</em>; a file that has one canonical address in every language; an + /// absolute URL; and a protocol-relative one, which is another host wearing a path's clothes. + /// </remarks> + [Test] + [Arguments("en", "/games", "/games")] + [Arguments("de", "/games", "/de/games")] + [Arguments("de", "/", "/de/")] + [Arguments("de", "/g/ashen-court", "/de/g/ashen-court")] + [Arguments("de", "/games?sort=busiest", "/de/games?sort=busiest")] + [Arguments("zh-Hans", "/rankings", "/zh-Hans/rankings")] + [Arguments("de", "?plain=1", "?plain=1")] + [Arguments("de", "?window=30d&plain=1", "?window=30d&plain=1")] + [Arguments("de", "#content", "#content")] + [Arguments("de", "/api/games", "/api/games")] + [Arguments("de", "/robots.txt", "/robots.txt")] + [Arguments("de", "/sitemap.xml", "/sitemap.xml")] + [Arguments("de", "/favicon.svg", "/favicon.svg")] + [Arguments("de", "/site.webmanifest", "/site.webmanifest")] + [Arguments("de", "/api/games?limit=5", "/api/games?limit=5")] + [Arguments("de", "https://example.com/games", "https://example.com/games")] + [Arguments("de", "mailto:someone@example.com", "mailto:someone@example.com")] + [Arguments("de", "//elsewhere.example/games", "//elsewhere.example/games")] + [Arguments("de", "", "")] + public async Task AnAddressIsWrittenInTheLocaleThePageIsReadIn(string tag, string given, string expected) + { + await Assert.That(LocaleRouting.Link(tag, given)).IsEqualTo(expected); + } + + /// <summary> + /// Every link on a localized page stays inside that locale. + /// </summary> + /// <remarks> + /// <para> + /// <b>Every internal link was an absolute path emitted verbatim, so a German page's links all + /// pointed out of German.</b> <c>/de/games</c> rendered <c>href="/games"</c>, + /// <c>href="/about"</c> and <c>href="/find"</c>, and a reader who followed a shared + /// <c>/de/…</c> link carries no cookie — so nothing could send them back and their first click + /// landed in English. Putting the locale in the path is what makes it linkable, shareable, + /// cacheable and indexable, and a page that discards it on every link has the property in its + /// own address and nowhere else. + /// </para> + /// <para> + /// Swept rather than spot-checked, over every anchor and every form on the page, because the + /// bug was fifty separate link sites and any one of them left behind is the same bug for + /// whichever reader clicks it. Nothing here is asked with a cookie: this is the reader who was + /// sent a link. + /// </para> + /// </remarks> + [Test] + [Arguments("/de/")] + [Arguments("/de/games")] + [Arguments("/de/games?sort=busiest")] + [Arguments("/de/archive")] + [Arguments("/de/find")] + [Arguments("/de/rankings")] + [Arguments("/de/ecosystem")] + [Arguments("/de/about")] + [Arguments("/de/reference")] + [Arguments("/de/reference/codebases/pennmush")] + [Arguments("/de/submit")] + [Arguments("/de/g/ashen-court")] + public async Task EveryLinkOnALocalizedPageStaysInThatLocale(string path) + { + await using var site = await SiteHost.StartAsync(); + + var markup = await site.Client.GetStringAsync(path); + var addresses = Addresses(markup); + + // The page was read, rather than a 404 body with nothing on it being swept clean. + await Assert.That(addresses.Count).IsGreaterThan(3); + + foreach (var address in addresses) + { + if (LeavesThisSite(address) || LocaleRouting.IsUnlocalized(PathOf(address))) + { + continue; + } + + await Assert.That(address) + .StartsWith("/de/") + .Because($"{path} offers {address}, which leads out of German"); + } + } + + /// <summary>And the source locale is the absence of a prefix, on the same pages.</summary> + /// <remarks> + /// <c>/games</c> is the canonical English address and <c>/en/games</c> redirects to it, so a + /// prefix written here would be a second URL for a document that already has one — and every + /// bookmark and inbound link already spells the unprefixed one. + /// </remarks> + [Test] + [Arguments("/")] + [Arguments("/games")] + [Arguments("/archive")] + [Arguments("/find")] + [Arguments("/rankings")] + [Arguments("/g/ashen-court")] + public async Task TheSourceLocaleIsTheAbsenceOfAPrefix(string path) + { + await using var site = await SiteHost.StartAsync(); + + var markup = await site.Client.GetStringAsync(path); + + foreach (var address in Addresses(markup)) + { + foreach (var locale in Locales.All) + { + await Assert.That(address.StartsWith($"/{locale.Tag}/", StringComparison.Ordinal)) + .IsFalse() + .Because($"{path} offers {address}, a second address for a page that has one"); + } + } + } + + /// <summary> + /// A query-only address means <em>this page, asked differently</em>, in every language. + /// </summary> + /// <remarks> + /// The plain-text link and all five trend range links are written as a bare querystring so they + /// resolve against the page they are on — which is what removing <c><base href="/"></c> + /// from <c>App.razor</c> made true, and which giving one a prefix would undo just as + /// thoroughly: <c>/de/?plain=1</c> is the home page, not the listing the reader was reading. + /// </remarks> + [Test] + [Arguments("/de/games")] + [Arguments("/de/g/ashen-court")] + [Arguments("/de/rankings")] + public async Task AQueryOnlyAddressIsLeftExactlyAsItWasWritten(string path) + { + await using var site = await SiteHost.StartAsync(); + + var markup = await site.Client.GetStringAsync(path); + var queries = Addresses(markup).Where(a => a.StartsWith('?')).ToList(); + + await Assert.That(queries.Count).IsGreaterThan(0); + + foreach (var query in queries) + { + await Assert.That(query).DoesNotContain("/de"); + } + } + + /// <summary> + /// A file with one canonical address never gets a prefix, whatever language the page is in. + /// </summary> + /// <remarks> + /// The head's own links are not swept above — a stylesheet is not a document in a language — + /// so the list the middleware refuses to redirect is asserted here directly against the markup + /// that carries it. + /// </remarks> + [Test] + public async Task AFileWithOneAddressIsNeverPrefixedInTheMarkupEither() + { + await using var site = await SiteHost.StartAsync(); + + var markup = await site.Client.GetStringAsync("/de/games"); + + foreach (var file in new[] { "/favicon.svg", "/favicon.ico", "/site.webmanifest" }) + { + await Assert.That(markup).Contains($"href=\"{file}\""); + await Assert.That(markup).DoesNotContain($"href=\"/de{file}\""); + } + } + + /// <summary> + /// A control that answers with a <c>Location</c> header keeps the reader's language too. + /// </summary> + /// <remarks> + /// <para> + /// <b>These are the links a sweep of the markup cannot see</b>, and the walk found them where + /// the sweep could not: "surprise me" is in the nav of every page, and from <c>/de/games</c> it + /// answered with <c>Location: /g/eldertale</c> — a reader two clicks into German, put back into + /// English by the one destination that is a header rather than an attribute. The theme control + /// did the same for the reader who preferred a light background. + /// </para> + /// <para> + /// No cookie on any of these, deliberately. A reader who followed a shared <c>/de/…</c> link has + /// none, so the path is the only thing that knows what language they are reading in — which is + /// the whole reason the locale is in the path. + /// </para> + /// </remarks> + [Test] + public async Task AControlThatAnswersWithARedirectKeepsTheReadersLanguage() + { + await using var site = await SiteHost.StartAsync(); + + var random = await site.Client.GetAsync("/de/games/random"); + + await Assert.That((int)random.StatusCode).IsEqualTo(302); + await Assert.That(Where(random)).StartsWith("/de/g/"); + + var theme = new HttpRequestMessage(HttpMethod.Post, "/de/theme") + { + Content = new FormUrlEncodedContent([ + new KeyValuePair<string, string>("theme", "light"), + new KeyValuePair<string, string>("return", "/games"), + ]), + }; + + var themed = await site.Client.SendAsync(theme); + + await Assert.That((int)themed.StatusCode).IsEqualTo(303); + await Assert.That(themed.Headers.Location?.OriginalString).IsEqualTo("/de/games"); + + // And the crawler's own short URL, which lands on a page and so is a document in a language. + var crawler = await site.Client.GetAsync("/de/crawler"); + + await Assert.That(Where(crawler)).StartsWith("/de/about"); + + // The source locale keeps the address it always had. + var english = await site.Client.GetAsync("/games/random"); + + await Assert.That(Where(english)).StartsWith("/g/"); + await Assert.That(Where(english)).DoesNotContain("/de/"); + } + + /// <summary> + /// The plain surface prints its addresses in the locale it is printing. + /// </summary> + /// <remarks> + /// <para> + /// <b>They are links, whatever they look like.</b> There are no anchors on this surface, so a + /// path is printed for a reader to type, to follow in a text browser, or to paste to somebody — + /// and a German reader who copies <c>/g/ashen-court</c> off <c>/de/games?plain=1</c> arriving in + /// English is the same defect as the fifty in the markup, on the surface whose whole promise is + /// that it mirrors the page. + /// </para> + /// <para> + /// The trend's seek link stays a bare querystring here for the reason it does in the markup: it + /// means <em>this page, asked differently</em>, and the page it is on is already the German one. + /// </para> + /// </remarks> + [Test] + public async Task ThePlainSurfacePrintsItsAddressesInTheLocaleItIsPrintingIn() + { + await using var site = await SiteHost.StartAsync(); + + var listing = await site.Client.GetStringAsync("/de/games?plain=1"); + var game = await site.Client.GetStringAsync("/de/g/ashen-court?plain=1"); + var english = await site.Client.GetStringAsync("/games?plain=1"); + + await Assert.That(listing).Contains("/de/g/ashen-court"); + await Assert.That(english).Contains("/g/ashen-court"); + await Assert.That(english).DoesNotContain("/de/g/ashen-court"); + + // The seek link is relative to the page and is not given a prefix it would break under. + await Assert.That(game).Contains("?from="); + await Assert.That(game).DoesNotContain("/de?from="); + } + + /// <summary> + /// A reference article is the article in every locale, and not the section's empty state. + /// </summary> + /// <remarks> + /// The page looked itself up by <c>NavigationManager.Uri</c>, whose local path still carries + /// the prefix the middleware moved into <c>PathBase</c> — so <c>/de/reference/codebases/pennmush</c> + /// asked the library for a document filed under <c>/reference/codebases/pennmush</c>, was told + /// there is none, and answered every non-English reader with "no reference page here" for all + /// thirty-odd articles. It is the request's own path that names the document, in every language. + /// </remarks> + [Test] + [Arguments("/reference/codebases/pennmush")] + [Arguments("/de/reference/codebases/pennmush")] + [Arguments("/ja/reference/codebases/pennmush")] + public async Task AReferenceArticleIsFoundInEveryLocale(string path) + { + await using var site = await SiteHost.StartAsync(); + + var markup = await site.Client.GetStringAsync(path); + + await Assert.That(markup).Contains("PennMUSH"); + await Assert.That(Render.Words(markup)).DoesNotContain("No reference page here"); + } + + /// <summary>Every anchor and every form on a rendered page, as the browser receives them.</summary> + /// <remarks> + /// Read off the frame rather than the source, because that is where the bug was: the components + /// held the right paths all along and the markup is what pointed out of the locale. + /// </remarks> + private static IReadOnlyList<string> Addresses(string markup) => + [ + .. System.Text.RegularExpressions.Regex + .Matches(markup, "<a\\s[^>]*?href=\"([^\"]*)\"|<form\\s[^>]*?action=\"([^\"]*)\"") + .Select(m => m.Groups[1].Success ? m.Groups[1].Value : m.Groups[2].Value) + .Select(a => System.Net.WebUtility.HtmlDecode(a) ?? string.Empty) + .Where(a => a.Length > 0), + ]; + + /// <summary> + /// Where a redirect sends the reader, as a path. + /// </summary> + /// <remarks> + /// The two shapes are both correct and both shipped: an endpoint writes a relative + /// <c>Location</c>, and a page redirecting through <c>NavigationManager</c> gets an absolute one + /// built off the request's own base. What a test is asking about is where the reader lands. + /// </remarks> + private static string Where(HttpResponseMessage response) => + response.Headers.Location is not { } location ? string.Empty + : location.IsAbsoluteUri ? location.AbsolutePath + : location.OriginalString; + + /// <summary>Whether an address names somewhere that is not a page of this site.</summary> + private static bool LeavesThisSite(string address) => + address[0] != '/' || (address.Length > 1 && address[1] is '/' or '\\'); + + private static string PathOf(string address) + { + var cut = address.AsSpan().IndexOfAny('?', '#'); + + return cut < 0 ? address : address[..cut]; + } + + /// <summary> + /// A sentence with links in it is one message, and what a translator writes is never markup. + /// </summary> + /// <remarks> + /// The random-game empty state is "No game matches that filter. Try {listing}, or {archive}." — + /// two anchors inside one sentence. Gluing English round the anchors would give a language that + /// wants the archive named first, or a different preposition before each, nowhere to say so; but + /// formatting the anchors *into* the string and trusting the result through a + /// <c>MarkupString</c> would make every bundle a place a tag could be put. The message places + /// two private-use markers and the page walks them, so the bundle holds text either way. + /// </remarks> + [Test] + public async Task ASentenceWithLinksInItPlacesThemWithoutCarryingMarkup() + { + foreach (var id in new[] { "random.empty.title", "random.empty.body", "random.empty.listing", "random.empty.archive" }) + { + await Assert.That(Messages.Ids).Contains(id); + } + + // The body places both links and holds no markup of its own, in every locale. + foreach (var locale in Locales.All.Where(l => l.IsChoosable)) + { + var body = Messages.Pattern(locale.Tag, "random.empty.body"); + + await Assert.That(body).Contains("{listing}").Because($"{locale.Tag} must place the listing link"); + await Assert.That(body).Contains("{archive}").Because($"{locale.Tag} must place the archive link"); + await Assert.That(body).DoesNotContain("<").Because($"{locale.Tag} must carry no markup"); + } + } + + [Test] + public async Task TheAlternatesNameEveryOfferedLocaleAndAnXDefault() + { + var alternates = LocaleRouting.Alternates("/games").ToList(); + + await Assert.That(alternates.Select(a => a.HrefLang)).Contains("x-default"); + + // x-default is the unprefixed address: the one to show a reader whose language nothing here + // matches, rather than leaving a crawler to pick among them. + await Assert.That(alternates.Single(a => a.HrefLang == "x-default").Path).IsEqualTo("/games"); + + foreach (var locale in Locales.Offered) + { + var mine = alternates.Single(a => a.HrefLang == locale.Tag); + + await Assert.That(mine.Path).IsEqualTo( + locale.Tag == Locales.SourceTag ? "/games" : $"/{locale.Tag}/games"); + } + } + + [Test] + public async Task ARenderOnlyScriptIsNeverAnInterfaceLanguage() + { + // An Arabic game name inside an English page is correct permanently — that is <bdi> and a + // per-element lang, and it needs nothing further. An entire Arabic interface still flowing + // left-to-right is not, so it is not offered. The boundary is data rather than a comment, so + // it is publishable and so this can hold it. + foreach (var script in Locales.RenderOnlyScripts) + { + await Assert.That(Locales.Offered.Any(l => l.Tag.StartsWith(script, StringComparison.Ordinal))) + .IsFalse() + .Because($"{script} is render-only and must not be an interface language"); + } + } + + /// <summary> + /// The plural forms a locale needs for a message and does not declare. + /// </summary> + /// <remarks> + /// <para> + /// Read off the parsed message rather than off the string, so a branch inside a nested selector + /// counts exactly as one at the top level does. + /// </para> + /// <para> + /// An <c>other</c> branch does not excuse a missing form, and that is the point: ICU will + /// happily route a Russian 2 through <c>other</c> and render a word no native speaker would + /// write, silently. A form the language distinguishes has to be declared rather than fallen + /// into. + /// </para> + /// <para> + /// Only what the locale itself carries is checked. A locale that has translated nothing reports + /// nothing missing here, which is correct: an untranslated string is a fallback and a + /// half-translated plural is a bug, and only the second is this test's business. + /// </para> + /// </remarks> + private static IReadOnlyList<string> Missing(string tag, string id) + { + if (!Messages.HasOwn(tag, id)) + { + return []; + } + + var pattern = IcuMessage.Compile(Messages.Pattern(tag, id)!); + + return + [ + .. pattern.Arguments() + .Where(a => a.Kind is ArgumentKind.Plural or ArgumentKind.SelectOrdinal) + .SelectMany(a => PluralRules + .CategoriesOf(tag, a.Kind is ArgumentKind.SelectOrdinal + ? PluralKind.Ordinal + : PluralKind.Cardinal) + .Select(PluralRules.Keyword) + .Where(form => form != "other" && !a.Branches.ContainsKey(form)) + .Select(form => $"{a.Name}:{form}")), + ]; + } + + [Test] + public async Task EveryPatternInEveryBundleParses() + { + // The whole reason the pattern is parsed rather than interpreted: a message with a missing + // `other`, an unbalanced brace or a branch keyword no category uses is broken for exactly + // one reader — whichever one's count reaches it. Parsing every bundle here turns all three + // into a build failure. + foreach (var locale in Locales.All) + { + foreach (var id in Messages.Ids) + { + if (!Messages.HasOwn(locale.Tag, id)) + { + continue; + } + + var pattern = Messages.Pattern(locale.Tag, id)!; + + await Assert.That(() => IcuMessage.Compile(pattern)) + .ThrowsNothing() + .Because($"{locale.Tag} / {id} does not parse: {pattern}"); + } + } + } + + [Test] + public async Task EveryTranslationReadsTheSameArgumentsTheEnglishDoes() + { + // A translator who drops {total} from a sentence leaves a fact off the page, and one who + // invents {name} writes a message the site will refuse to render at all. Both are caught + // here rather than by whoever opens that page in that language. + foreach (var locale in Locales.All.Where(l => l.Tag != Locales.SourceTag)) + { + foreach (var id in Messages.Ids.Where(i => Messages.HasOwn(locale.Tag, i))) + { + var source = Names(Messages.Pattern(Locales.SourceTag, id)!); + var mine = Names(Messages.Pattern(locale.Tag, id)!); + + await Assert.That(mine.Except(source)) + .IsEmpty() + .Because($"{locale.Tag} / {id} names an argument the English does not supply"); + } + } + + static IReadOnlyList<string> Names(string pattern) => + [.. IcuMessage.Compile(pattern).Arguments().Select(a => a.Name).Distinct()]; + } + + [Test] + public async Task EveryLocaleTheSiteNamesHasAPluralRuleWrittenForIt() + { + // An unlisted language answers `other` for every count — right for Chinese, wrong for + // German, and silent either way. This is the gate on adding one. + foreach (var locale in Locales.All) + { + await Assert.That(PluralRules.Covers(locale.Tag)) + .IsTrue() + .Because($"{locale.Tag} has no plural rule transcribed from CLDR {PluralRules.CldrVersion}"); + } + } + + [Test] + public async Task TheResxAndTheCompiledInSourceSayTheSameThing() + { + // Two copies of the English exist on purpose — resx is where a translation lives and where + // every translation tool looks, and the compiled-in bundle is the fallback that must not + // depend on a satellite assembly having loaded. Two copies with no test between them is how + // a message gets fixed in one and not the other, and the reader who finds out is whichever + // one is served by the copy nobody updated. + var resx = ResxMessages(); + + await Assert.That(resx).IsNotEmpty(); + + foreach (var id in Messages.Ids) + { + await Assert.That(resx.ContainsKey(id)) + .IsTrue() + .Because($"{id} is in the source bundle and not in Messages.resx"); + + await Assert.That(resx[id]) + .IsEqualTo(Messages.Source(id)) + .Because($"{id} differs between Messages.resx and the compiled-in source"); + } + + foreach (var id in resx.Keys) + { + await Assert.That(Messages.Ids) + .Contains(id) + .Because($"{id} is in Messages.resx and nothing on the site says it"); + } + } + + /// <summary> + /// The English resx, read as XML rather than through the resource manager. + /// </summary> + /// <remarks> + /// Deliberately not through <see cref="Microsoft.Extensions.Localization.IStringLocalizer"/>: + /// that would read whatever the build embedded, which is the thing being checked. Reading the + /// file compares what a translator would edit against what the site compiles. + /// <para> + /// The file is copied beside the test binary by the project — see the comment on that item for + /// why, which is that counting <c>..</c> segments up from <see cref="AppContext.BaseDirectory"/> + /// only reaches the repository root at one exact output depth, and failed as a missing file in + /// a test whose subject is message content. + /// </para> + /// </remarks> + private static IReadOnlyDictionary<string, string> ResxMessages() + { + var path = System.IO.Path.Combine(System.AppContext.BaseDirectory, "Messages.resx"); + + var document = System.Xml.Linq.XDocument.Load(path); + + return document.Root! + .Elements("data") + .Where(e => e.Attribute("name") is not null) + .ToDictionary( + e => e.Attribute("name")!.Value, + e => e.Element("value")?.Value ?? string.Empty, + StringComparer.Ordinal); + } + + [Test] + public async Task ALocaleIsOfferedWhenItHasTheWordsAndNotBefore() + { + // The gate, and now the only one. `Offered` is what a default may reach — Accept-Language, a + // remembered cookie, an hreflang alternate — and what opens it is the bundle carrying the + // locked glossary, not somebody's claim to have read it. There used to be a second tier that + // was translated and deliberately unreachable; it made four languages undiscoverable in + // exchange for a promise the site made only to itself. + foreach (var locale in Locales.Offered.Where(l => l.Tag != Locales.SourceTag)) + { + foreach (var locked in Glossary.Locked) + { + await Assert.That(Messages.HasOwn(locale.Tag, locked.Id)) + .IsTrue() + .Because($"{locale.Tag} is offered without a translation for {locked.Id}"); + } + } + + // A locale with nothing translated is never offered, whatever else changes. + foreach (var locale in Locales.All.Where(l => l.Status is LocaleStatus.Planned)) + { + await Assert.That(locale.IsOffered) + .IsFalse() + .Because($"{locale.Tag} is planned and has no words yet"); + } + + // And a review locale is reachable by choice and never by default: it exists to be tested + // against, and a reader must not be sent to a pseudolocale by their browser's settings. + foreach (var locale in Locales.All.Where(l => l.Status is LocaleStatus.TestOnly)) + { + await Assert.That(locale.IsOffered) + .IsFalse() + .Because($"{locale.Tag} is a review locale and must not be offered"); + } + + // And no default reaches a review locale, whatever a browser asks for. + await Assert.That(LocaleRouting.Preferred("qps-ploc,ru;q=0.9")).IsNull(); + + // The alternates name only what is offered: an hreflang pointing at a pseudolocale would + // invite a search engine to index accented English as a language. + var alternates = LocaleRouting.Alternates("/games").Select(a => a.HrefLang).ToList(); + + await Assert.That(alternates).DoesNotContain("qps-ploc"); + await Assert.That(alternates).DoesNotContain("ru-x-canary"); + } + + [Test] + public async Task AReviewBuildListsTheLocalesThatAreNotLanguages() + { + // Without this the switcher has one option, draws nothing, and cannot be reviewed at all — + // which is how it shipped invisible. + var production = Locales.Switchable(preview: false); + var review = Locales.Switchable(preview: true); + + // A machine-translated locale is in both — it has real words and it says on every page that + // a machine wrote them. The pseudolocale and the canary are in neither, because they are not + // languages and nothing but a review build should list them. + await Assert.That(production.Select(l => l.Tag)).Contains("de"); + await Assert.That(production.Select(l => l.Tag)).DoesNotContain("qps-ploc"); + await Assert.That(review.Select(l => l.Tag)).Contains("qps-ploc"); + await Assert.That(review.Count).IsGreaterThan(production.Count); + + // A planned locale is in neither: nothing is translated, so listing it would offer a page + // that is still English under a name saying it is not. + await Assert.That(review.Select(l => l.Tag)).DoesNotContain("ru"); + } + + [Test] + public async Task WhetherTheReviewLocalesAreListedIsAskedOfTheRequestAndNotOfTheProcess() + { + // It was a static flag that every host start wrote, and this suite starts hosts in both + // Development and Production inside one process — so the switcher listed whatever the last + // host to start had decided, on every request served by any of them. Two requests, two + // answers, and no dependency on which host began first. + var review = Request(Environments.Development); + var production = Request(Environments.Production); + + await Assert.That(review.IsReviewBuild()).IsTrue(); + await Assert.That(production.IsReviewBuild()).IsFalse(); + + await Assert.That(Locales.Switchable(review.IsReviewBuild()).Select(l => l.Tag)).Contains("qps-ploc"); + await Assert.That(Locales.Switchable(production.IsReviewBuild()).Select(l => l.Tag)).DoesNotContain("qps-ploc"); + + // And a component rendered with no request behind it at all — which is every headless + // component test in this suite — is not a review build. That is the case that made taking + // IWebHostEnvironment as a dependency impossible, and it is why this is asked of the + // request rather than injected. + await Assert.That(((HttpContext?)null).IsReviewBuild()).IsFalse(); + } + + /// <summary>A request served by a host running in one named environment.</summary> + private static HttpContext Request(string environment) + { + var services = new ServiceCollection(); + + services.AddSingleton<IHostEnvironment>(new StubEnvironment { EnvironmentName = environment }); + + return new DefaultHttpContext { RequestServices = services.BuildServiceProvider() }; + } + + private sealed class StubEnvironment : IHostEnvironment + { + public string EnvironmentName { get; set; } = string.Empty; + + public string ApplicationName { get; set; } = "MUI.Web.Tests"; + + public string ContentRootPath { get; set; } = AppContext.BaseDirectory; + + public IFileProvider ContentRootFileProvider { get; set; } = new NullFileProvider(); + } + + [Test] + public async Task AChosenReviewLocaleIsHonouredEvenThoughItIsNeverOffered() + { + // The difference between offering a locale and honouring a choice. Nothing sends a reader to + // the pseudolocale; having picked it, they stay in it across an unprefixed URL, or the + // switcher would appear to do nothing on the next page. + await Assert.That(Locales.Find("qps-ploc")!.IsOffered).IsFalse(); + await Assert.That(Locales.Find("qps-ploc")!.IsChoosable).IsTrue(); + + // A translated locale is both: it can be chosen, and a browser asking for it is answered. + // That is the tier collapse — there is no longer a state that has the words and withholds + // them. + await Assert.That(Locales.Find("de")!.IsOffered).IsTrue(); + await Assert.That(Locales.Find("de")!.IsChoosable).IsTrue(); + + // A planned locale is neither. There is nothing to choose. + await Assert.That(Locales.Find("ru")!.IsChoosable).IsFalse(); + await Assert.That(Locales.Find("ru")!.IsOffered).IsFalse(); + } + + [Test] + public async Task EveryOfferedLocaleTranslatedTheWholeGlossary() + { + // Not the review gate — that is a person reading them. This is the weaker thing worth + // asserting: a bundle that stopped halfway would leave a page in two languages, with the + // English half being exactly the provenance words a reader most needs to trust. + foreach (var locale in Locales.All.Where(l => l.IsOffered && l.Tag != Locales.SourceTag)) + { + foreach (var locked in Glossary.Locked) + { + await Assert.That(Messages.HasOwn(locale.Tag, locked.Id)) + .IsTrue() + .Because($"{locale.Tag} has no {locked.Id}"); + } + } + } + + [Test] + public async Task TheFourKindsOfAbsenceStayFourInEveryTranslation() + { + // The finding the glossary exists for, checked against what the translators actually wrote. + // A machine translating "not measured", "uncounted", "unreachable" and "not counted" will + // reach for the same target phrase for at least two of them if nothing stops it — and a + // reader then cannot tell a game that answered from one that did not. + string[] ids = ["state.notMeasured", "state.uncounted", "state.unreachable", "state.notCounted"]; + + foreach (var locale in Locales.All.Where(l => l.IsOffered && l.Tag != Locales.SourceTag)) + { + var rendered = ids.Select(id => Messages.For(locale.Tag, id)).ToList(); + + await Assert.That(rendered.Distinct().Count()) + .IsEqualTo(ids.Length) + .Because($"{locale.Tag} collapsed two of the four kinds of absence: {string.Join(" / ", rendered)}"); + } + } +} diff --git a/tests/MUI.Web.Tests/MUI.Web.Tests.csproj b/tests/MUI.Web.Tests/MUI.Web.Tests.csproj index 0bc31d4..f9a612a 100644 --- a/tests/MUI.Web.Tests/MUI.Web.Tests.csproj +++ b/tests/MUI.Web.Tests/MUI.Web.Tests.csproj @@ -27,4 +27,25 @@ <ProjectReference Include="..\..\src\MUI.Web\MUI.Web.csproj" /> </ItemGroup> + <!-- + The English bundle as a translator edits it, copied beside the test binary. + + A test here compares Messages.resx against the compiled-in source dictionary, and it has to read + the *file* to do it: going through the resource manager would read whatever the build embedded, + which is the thing under test. It used to find the file by counting five ".." segments up from + AppContext.BaseDirectory, which is only the repository root when the output sits at exactly + bin/<config>/<tfm> — so a redirected output path, an artifacts layout, a second target framework + or a different configuration nesting each turned a message-content test into a + FileNotFoundException naming a path nobody recognised. + + MSBuild resolves this relative to the project file, which is a fixed relationship rather than a + guess about where the output landed, and the copy is the same bytes. Searching upward for the + repository root would have worked too and still assumes the output is inside the repository. + --> + <ItemGroup> + <None Include="..\..\src\MUI.Web\Resources\Messages.resx" + Link="Messages.resx" + CopyToOutputDirectory="PreserveNewest" /> + </ItemGroup> + </Project> diff --git a/tests/MUI.Web.Tests/PlainParityTests.cs b/tests/MUI.Web.Tests/PlainParityTests.cs index 488c54e..15188c9 100644 --- a/tests/MUI.Web.Tests/PlainParityTests.cs +++ b/tests/MUI.Web.Tests/PlainParityTests.cs @@ -2,6 +2,7 @@ using MUI.Web.Components; using MUI.Web.Components.Pages; using MUI.Web.Fixtures; +using MUI.Web.Localization; namespace MUI.Web.Tests; @@ -15,6 +16,65 @@ namespace MUI.Web.Tests; /// </remarks> public class PlainParityTests { + /// <summary> + /// The longest unbroken spell is first, on the page as well as in its text mirror. + /// </summary> + /// <remarks> + /// <b>The page and its own <c>?plain=1</c> alternative disagreed about a ranking.</b> The table + /// ranked by <c>Since.Ticks</c> and the place goes to the greatest value, but an earlier date is + /// a *smaller* number of ticks — so the longest spell on the site was printed as last of seven + /// under a heading that says longest, while the mirror numbered the same rows from a counter and + /// got them right. Ranking by the span the section is named for is what makes the two agree, and + /// this asserts the property rather than the arithmetic: whoever the plain renderer prints first + /// is whoever the table gives place 1. + /// </remarks> + [Test] + public async Task TheLongestSpellIsFirstOnThePageAndInTheMirror() + { + var rankings = await Queries.RankingsAsync(RankingSpan.Week); + var spells = rankings.LongestUnbroken; + + await Assert.That(spells.Count).IsGreaterThan(1); + + // The one the section is about: the longest span, not the earliest start. + var longest = spells.MaxBy(s => s.LengthAt(Now))!; + + // The plain mirror numbers the rows from a counter, in the order the query returned them, + // so its first row is the first spell. Asserted against the list rather than by searching + // the rendered text: a game's name appears in the busiest table higher up the same page, + // and an index search finds that one instead. + await Assert.That(spells[0].Slug).IsEqualTo(longest.Slug); + + // The mirror does print it first, which is the half of the parity that was already right. + var text = PlainText.RenderRankings(rankings, Now, Locales.SourceTag); + var section = text[text.LastIndexOf(spells[0].Name, StringComparison.Ordinal)..]; + + await Assert.That(section).StartsWith(spells[0].Name); + + // And a shorter spell never outranks a longer one. The page's rule, on the page's value: + // the start date, which is the measurement, rather than the duration, which is that date + // read against a clock that moves between one comparison and the next. + var places = spells.Select(s => s.Since).ToList(); + + await Assert.That(PlaceEarliest(places, longest.Since)).IsEqualTo(1); + + foreach (var spell in spells.Where(s => s.Since > longest.Since)) + { + await Assert.That(PlaceEarliest(places, spell.Since)).IsGreaterThan(1); + } + + // Ties share a place, which is the rule the column exists for: no row is numbered past the + // number of rows. + foreach (var spell in spells) + { + await Assert.That(PlaceEarliest(places, spell.Since)).IsLessThanOrEqualTo(spells.Count); + } + } + + /// <summary>The page's own rule for a place where the earliest value wins.</summary> + private static int PlaceEarliest<T>(IEnumerable<T> values, T value) where T : IComparable<T> => + 1 + values.Count(v => v.CompareTo(value) < 0); + private static readonly DateTimeOffset Now = FixtureGameQueries.Now; private static readonly FixtureGameQueries Queries = new(); @@ -53,6 +113,33 @@ public async Task TheHeatmapSurvivesAsASentenceAndALinePerDay() await Assert.That(text).Contains("Wed —"); } + /// <summary> + /// The mirror answers in the language the reader asked in, day names included. + /// </summary> + /// <remarks> + /// Over HTTP rather than through the renderer, because the thing being checked is that the + /// locale reaches this surface at all: the plain page is composed by a different code path from + /// the rendered one, and the heatmap's words were the last on the site to be answered in English + /// whatever the address said. A German reader's per-day lines start "Mo", not "Mon". + /// </remarks> + [Test] + public async Task ThePlainMirrorIsAnsweredInTheLanguageTheAddressAsksFor() + { + await using var site = await SiteHost.StartAsync(); + + var english = Render.Words(await site.Client.GetStringAsync("/g/m-u-s-h?plain=1")); + var german = Render.Words(await site.Client.GetStringAsync("/de/g/m-u-s-h?plain=1")); + + await Assert.That(english).Contains("Mon —"); + await Assert.That(german).Contains("Mo —"); + await Assert.That(german).DoesNotContain("Mon —"); + + // The same three states, and still three. The words for two of them are the glossary's, so + // in German they are German — and they are still two different words. + await Assert.That(german).Contains(Messages.For("de", "state.notMeasured")); + await Assert.That(german).Contains(Messages.For("de", "state.uncounted")); + } + [Test] public async Task TheTrendSurvivesAsASentenceALinePerWeekAndAWayToSeek() { @@ -62,10 +149,14 @@ public async Task TheTrendSurvivesAsASentenceALinePerWeekAndAWayToSeek() // change it would have the navigation and none of its function. var text = await GameAsync("m-u-s-h"); - await Assert.That(text).Contains("HOW MANY, OVER TIME"); + // The heading through the bundle rather than shouted in English. It used to be upper-cased + // here with ToUpperInvariant, which is an English typographic habit applied to a string a + // translator writes — and one that mangles ß and Turkish i on the way past. + await Assert.That(text).Contains(Messages.For(Locales.SourceTag, "trend.plain.heading")); await Assert.That(text).Contains("typically"); await Assert.That(text).Contains("peak"); - await Assert.That(text).Contains("earlier: ?from="); + await Assert.That(text) + .Contains($"{Messages.For(Locales.SourceTag, "trend.plain.earlier")}: ?from="); } [Test] @@ -83,10 +174,13 @@ public async Task TheTrendSaysWhichKindOfNothingAQuietWeekWas() // And no cause is named for either: a failed probe writes no presence row, so silence // cannot tell an outage of theirs from a gap of ours. - var trend = text[text.IndexOf("HOW MANY, OVER TIME", StringComparison.Ordinal)..]; - var reachable = trend.IndexOf("Reachable (", StringComparison.Ordinal); + var trend = text[text.IndexOf( + Messages.For(Locales.SourceTag, "trend.plain.heading"), StringComparison.Ordinal)..]; + var reachable = trend.IndexOf( + Messages.For(Locales.SourceTag, "reach.plain.heading") + " (", StringComparison.Ordinal); - await Assert.That(reachable > 0 ? trend[..reachable] : trend).DoesNotContain("unreachable"); + await Assert.That(reachable > 0 ? trend[..reachable] : trend) + .DoesNotContain(Messages.For(Locales.SourceTag, "state.unreachable")); } [Test] @@ -122,7 +216,9 @@ public async Task TheCapabilityMatrixSurvivesWithBothColumnsAndTheCount() { var text = await GameAsync("m-u-s-h"); - await Assert.That(text).Contains("Capabilities (1 of 6 disagree)"); + // One disagreement takes a singular verb here exactly as it does in the caption over the + // graphical matrix. The two surfaces are one fact and had two grammars. + await Assert.That(text).Contains("Capabilities (1 of 6 disagrees)"); await Assert.That(text).Contains("measured: NO declared: yes ** disagree"); } @@ -140,16 +236,25 @@ public async Task AScreenTooSmallToFrameSaysHowSmallItWas() { var text = await GameAsync("midnight-sun"); - await Assert.That(text).Contains("Only 2 row(s) came back"); + // Through the bundle, which is also how it stopped saying "row(s)": a parenthesised s is a + // fact about English written where a plural rule belongs, and the graphical frame and this + // surface now render the one ICU message rather than two spellings of it. + await Assert.That(text).Contains(Messages.For( + Locales.SourceTag, + "ansi.tooSmall", + new Dictionary<string, object?>(StringComparer.Ordinal) { ["count"] = 2 })); } [Test] - public async Task AnOversizedScreenSaysHowLongItIs() + public async Task ALongScreenSaysHowLongItIsAndPrintsAllOfIt() { + // No crop on either surface any more, so no note about one. The graphical page scrolls the + // whole screen in one frame rather than showing the first twenty-four rows and offering the + // rest twice more; this surface prints every row, as it always did. var text = await GameAsync("batmud"); await Assert.That(text).Contains("connect screen: 214 lines"); - await Assert.That(text).Contains("Unusually long"); + await Assert.That(text).DoesNotContain("Unusually long"); } [Test] @@ -167,7 +272,7 @@ public async Task TheThreeFeedsAreThreeNamedSectionsInWords() { // The register the cards carry is a tone, and a tone is not a fact. In text the words do // all of the work. - var text = PlainText.RenderFeeds(await Queries.FeedsAsync(), Now); + var text = PlainText.RenderFeeds(Locales.SourceTag, await Queries.FeedsAsync(), Now); await Assert.That(text).Contains("NEWLY DISCOVERED"); await Assert.That(text).Contains("WENT DARK"); @@ -175,6 +280,57 @@ public async Task TheThreeFeedsAreThreeNamedSectionsInWords() await Assert.That(text).Contains("Aardwolf MUD"); } + /// <summary> + /// The three feeds are three sections in the reader's language, not three English headings. + /// </summary> + /// <remarks> + /// <para> + /// <b>They were literals in the renderer, and a <c>tag</c> that reached only the ages.</b> + /// Passing a locale to <c>RenderFeeds</c> and asserting the result therefore proved nothing: + /// every locale printed "NEWLY DISCOVERED" and "Nothing new." and the test that passed + /// <c>Locales.SourceTag</c> was asserting English against English. + /// </para> + /// <para> + /// So this asks in two languages at once. The pseudolocale is the discriminating half — it is + /// generated from the source bundle, so a string that reaches it came through <c>Messages</c> + /// and a string that did not is still plain English on the page. German is the half that proves + /// the tag threads all the way down to a real satellite: the empty states are translated there + /// already, so a German render has to print German sentences and not the fallback. + /// </para> + /// </remarks> + [Test] + public async Task TheFeedHeadingsAndEmptyStatesComeFromTheBundleAndNotFromTheRenderer() + { + var feeds = await Queries.FeedsAsync(); + var empty = new LivenessFeeds([], [], []); + + // Through the bundle: the pseudolocale accents and brackets every source string, and only a + // string that went through Messages can come back accented. + var pseudo = PlainText.RenderFeeds("qps-ploc", empty, Now); + + await Assert.That(pseudo).DoesNotContain("NEWLY DISCOVERED"); + await Assert.That(pseudo).Contains( + Messages.For("qps-ploc", "feed.plain.newlyDiscovered").ToUpperInvariant()); + await Assert.That(pseudo).Contains(Messages.For("qps-ploc", "feed.nothingNew")); + + // And in German, where the empty states are translated: the sentences the satellite carries, + // not the English they fall back from. + var german = PlainText.RenderFeeds("de", empty, Now); + + await Assert.That(german).Contains("Nichts Neues."); + await Assert.That(german).Contains("Nichts ist verstummt."); + await Assert.That(german).Contains("Nichts ist zurückgekehrt. Wir klopfen weiter."); + await Assert.That(german).DoesNotContain("Nothing new."); + + // The headings are asked of the bundle rather than spelled here, so this keeps holding on + // the day feed.plain.* is translated and stops being the English fallback. + foreach (var id in new[] { "feed.plain.newlyDiscovered", "feed.plain.wentDark", "feed.plain.cameBack" }) + { + await Assert.That(PlainText.RenderFeeds("de", feeds, Now)) + .Contains(Messages.For("de", id).ToUpperInvariant()); + } + } + [Test] public async Task TheArchiveSaysWhenEachGameWasLastReachableAndHowLongItWasKnownLive() { @@ -185,10 +341,12 @@ public async Task TheArchiveSaysWhenEachGameWasLastReachableAndHowLongItWasKnown entries.Add(ArchiveEntry.For(game, await Queries.ForGameAsync(game.Id), Now)); } - var text = PlainText.RenderArchive(entries, null, Now); + var text = PlainText.RenderArchive(entries, null, Now, Locales.SourceTag); - await Assert.That(text).Contains("Last reachable:"); - await Assert.That(text).Contains("Known live:"); + // The labels, asked of the bundle rather than spelled again here: the mirror has to carry + // the same two facts as the page, and which words say them is the bundle's business. + await Assert.That(text).Contains(Messages.For(Locales.SourceTag, "archive.plain.lastReachable")); + await Assert.That(text).Contains(Messages.For(Locales.SourceTag, "archive.plain.knownLive")); await Assert.That(text).Contains("Gaslight Row"); } @@ -203,7 +361,7 @@ public async Task TheArchiveUsesTheWordArchivedAndNeverDead() entries.Add(ArchiveEntry.For(game, await Queries.ForGameAsync(game.Id), Now)); } - var text = PlainText.RenderArchive(entries, null, Now).ToLowerInvariant(); + var text = PlainText.RenderArchive(entries, null, Now, Locales.SourceTag).ToLowerInvariant(); await Assert.That(text).Contains("[archived]"); await Assert.That(text).DoesNotContain("dead"); @@ -218,18 +376,48 @@ public async Task NoPlainLineIsWiderThanEightyColumns() { await GameAsync("m-u-s-h"), await GameAsync("midnight-sun"), - PlainText.RenderFeeds(await Queries.FeedsAsync(), Now), + PlainText.RenderFeeds(Locales.SourceTag, await Queries.FeedsAsync(), Now), PlainText.RenderListing(await Queries.SearchAsync(new GameFilter()), new GameFilter(), Now), // The archive too, because its lines are the ones a label lengthens most: an archived // game's codebase carries the oldest age on the site. - PlainText.RenderArchive(await ArchiveAsync(), query: null, Now), + PlainText.RenderArchive(await ArchiveAsync(), query: null, Now, Locales.SourceTag), }; + // These five hold to the cap on every line, addresses included, and that is not relaxed: + // the exemption below belongs to one surface and must not spread to the others by being + // written as a blanket rule. foreach (var line in surfaces.SelectMany(s => s.Split('\n'))) { await Assert.That(line.TrimEnd().Length).IsLessThanOrEqualTo(PlainText.Columns); } + + // Find was the one surface the cap was never checked on. It is checked on the prose only, + // because its addresses genuinely cannot hold to it — a query carrying six answers is past + // eighty columns before any wrapping decision is made, and a wrapped address is not + // clickable in the browsers this surface exists for. See the note on PlainText.Columns. + // German as well as English: a translated option label is the longest thing this renderer + // writes and the one no fixed vocabulary bounds. And loaded rather than empty, so the long + // addresses are actually present and the prose is measured beside them. + const string Loaded = "?plain=1&genre=Fantasy&language=English&lineage=MUSH&archived=true"; + + string[] find = + [ + PlainText.RenderFind(await FindScreen.BuildAsync(Queries, "?plain=1")), + PlainText.RenderFind(await FindScreen.BuildAsync(Queries, "?plain=1", "de"), "de"), + PlainText.RenderFind(await FindScreen.BuildAsync(Queries, Loaded)), + PlainText.RenderFind(await FindScreen.BuildAsync(Queries, Loaded, "de"), "de"), + ]; + + foreach (var line in find.SelectMany(s => s.Split('\n'))) + { + if (line.TrimStart().StartsWith('/')) + { + continue; + } + + await Assert.That(line.TrimEnd().Length).IsLessThanOrEqualTo(PlainText.Columns); + } } [Test] @@ -282,39 +470,72 @@ await Queries.SearchAsync(new GameFilter { IncludeArchived = true }), await Assert.That(text).Contains("Players now: 9 (declared, 9m)"); // And a value nobody has confirmed in years says so in the word, not in an amber colour. - await Assert.That(text).Contains("PennMUSH 1.8.5 (declared, 3y, stale)"); + // Asserted through the bundle rather than as a literal: the label is four messages now + // — the shape, the word, the rung and its plural — and a literal here would pass while the + // German page said something else entirely. + var label = Messages.For( + Locales.SourceTag, + "chip.plain.stale", + new Dictionary<string, object?>(StringComparer.Ordinal) + { + ["how"] = Messages.For(Locales.SourceTag, "provenance.game.declared"), + ["age"] = Relative.Format(Locales.SourceTag, TimeSpan.FromDays(365 * 3)), + }); + + await Assert.That(text).Contains($"PennMUSH 1.8.5 {label}"); } [Test] public async Task TheRenderedListingRowCarriesTheSameLabelThePlainOneSpells() { - // The rendered row and the plain row have to be two renderings of one fact. The chip is the - // vocabulary the game page already uses — glyph, relative age, amber when it has aged out — - // and the row reuses it rather than inventing a second way of saying "we read this off a - // banner forty minutes ago". + // The rendered row and the plain row have to be two renderings of one fact. The fields on + // the meta line keep the chip the game page uses — glyph, relative age, amber when it has + // aged out — rather than inventing a second way of saying "nobody has confirmed this since + // 2023". var html = await Render.PageAsync<Games>([]); - await Assert.That(html).Contains("class=\"chip measured"); await Assert.That(html).Contains("class=\"chip declared"); - // Never colour or glyph alone: the word is in the accessibility tree either as the chip's - // own title or as text only a screen reader reads. - await Assert.That(Render.Words(html)).Contains("declared"); - await Assert.That(Render.Words(html)).Contains("measured"); + // The count is the exception, and finding S1 took it all the way: no glyph and no word + // beside a number on a listing row at all. Where a number came from is what a reader weighs + // when choosing between two games, not while scanning five hundred, so it lives on the game + // page and on the facet groups' own badges — which is where it tells them whether a filter + // is trustworthy *before* they apply it. Rule 1 is intact one surface along. + await Assert.That(html).DoesNotContain("class=\"declared-note\""); + await Assert.That(html).DoesNotContain("class=\"pip"); + + // And the chip that stays — the codebase — prints no age, because the row has a freshness + // column of its own and every row used to state one age twice, four characters apart. + var meta = html[html.IndexOf("class=\"meta", StringComparison.Ordinal)..]; + await Assert.That(meta[..meta.IndexOf("</p>", StringComparison.Ordinal)]) + .DoesNotContain("<time"); } [Test] - public async Task TheRowsGlyphAgreesWithTheChipBesideIt() + public async Task TheCountColumnCarriesANumberAndNothingElse() { - // The chip was added to the row and the glyph in front of it was left hard-coded measured, - // so a declared count rendered a green ● beside a ◇ chip — one number described two ways in - // the same breath, which is the disagreement the chip exists to end. The game page was fixed - // and the listing that points at it was not. + // Finding S1, and the localization win with it. The cell used to read "●545 on" — a + // provenance glyph whose legend lived elsewhere on the page, then the number, then one + // English word repeated on all 515 rows. The column is named once, above the rows, and the + // cells hold the bare figure. var html = await Render.PageAsync<Games>([]); + var counts = html.Split("class=\"row-count").Skip(1).ToList(); + + await Assert.That(counts).IsNotEmpty(); + + foreach (var cell in counts) + { + var text = Render.Words(cell[..cell.IndexOf("</p>", StringComparison.Ordinal)]); - // Razor encodes both glyphs, so the assertion reads them as the markup carries them. - await Assert.That(html).Contains("class=\"pip state-declared\" aria-hidden=\"true\">◇"); - await Assert.That(html).Contains("class=\"pip state-present\" aria-hidden=\"true\">●"); + // Either a bare number, or the words that say there is no number. Never a zero standing + // in for an unknown, and never a unit. + await Assert.That(text).DoesNotContain(" on"); + await Assert.That(text).DoesNotContain("●"); + await Assert.That(text).DoesNotContain("◇"); + } + + // The column head is where the noun went, once. + await Assert.That(Render.Words(html)).Contains("connected · reached"); } [Test] @@ -356,13 +577,25 @@ public async Task TheGamePagesLiveCountWearsTheSameChipTheListingRowDoes() var declared = await Render.PageAsync<Game>(new() { ["Slug"] = "ashen-court" }); var measured = await Render.PageAsync<Game>(new() { ["Slug"] = "m-u-s-h" }); - await Assert.That(declared).Contains("class=\"chip declared"); + // The chip became the figure's own kicker: the count over the word and the age that + // produced it, which is one fact read as one block rather than a number with a label + // trailing it at metadata size. await Assert.That(Render.Words(declared)).Contains("declared"); - await Assert.That(measured).Contains("class=\"chip measured"); - - // A count nobody could take gets no chip, because there is nothing to label. + await Assert.That(declared).Contains("figure-count mono declared"); + await Assert.That(Render.Words(measured)).Contains("measured"); + await Assert.That(measured).Contains("figure-count mono"); + await Assert.That(measured).DoesNotContain("figure-count mono declared"); + + // A count the page does not have says so in words, and never as a zero. Read off the id, + // and off the figure rather than the whole document: what the hero may not do is pick one of + // rule 2's three states when the null it was handed covers all of them, so the word here is + // the absence itself and the assertion is that it is present and legible. var none = await Render.PageAsync<Game>(new() { ["Slug"] = "midnight-sun" }); - await Assert.That(none).Contains("count unknown"); + var figure = none[none.IndexOf("class=\"game-figure\"", StringComparison.Ordinal)..]; + var words = Render.Words(figure[..figure.IndexOf("</div>", StringComparison.Ordinal)]); + + await Assert.That(words).Contains(Messages.For(Locales.SourceTag, "game.count.none")); + await Assert.That(words).DoesNotContain("0"); } [Test] @@ -372,9 +605,21 @@ public async Task TheArchiveLabelsACodebaseExactlyAsTheListingDoes() // "Codebase: PennMUSH 1.8.5" on /archive — the same value, one surface saying nobody has // confirmed it since 2023 and the other not. The archive is where a value is oldest and // where the label matters most. - var text = PlainText.RenderArchive(await ArchiveAsync(), query: null, Now); + var text = PlainText.RenderArchive(await ArchiveAsync(), query: null, now: Now, tag: Locales.SourceTag); + + // Asserted through the bundle rather than as a literal: the label is four messages now + // — the shape, the word, the rung and its plural — and a literal here would pass while the + // German page said something else entirely. + var label = Messages.For( + Locales.SourceTag, + "chip.plain.stale", + new Dictionary<string, object?>(StringComparer.Ordinal) + { + ["how"] = Messages.For(Locales.SourceTag, "provenance.game.declared"), + ["age"] = Relative.Format(Locales.SourceTag, TimeSpan.FromDays(365 * 3)), + }); - await Assert.That(text).Contains("PennMUSH 1.8.5 (declared, 3y, stale)"); + await Assert.That(text).Contains($"PennMUSH 1.8.5 {label}"); // And the rendered page wears the same chip the listing row does. var html = await Render.PageAsync<Archive>([]); @@ -385,11 +630,87 @@ public async Task TheArchiveLabelsACodebaseExactlyAsTheListingDoes() public async Task TheHomePageCountsOnlyWhatWasMeasured() { var counts = SiteCounts.From(await Queries.ListAsync(new GameFilter { IncludeArchived = true })); - var text = PlainText.RenderHome(counts, await Queries.FeedsAsync(), CrawlerPulse.Unknown, Now); + var text = PlainText.RenderHome(Locales.SourceTag, counts, await Queries.FeedsAsync(), CrawlerPulse.Unknown, Now); await Assert.That(text).Contains("games known"); - await Assert.That(text).Contains("with players on now (measured)"); - await Assert.That(text).Contains("answering, count unknown"); + await Assert.That(text).Contains("connected now (measured)"); + await Assert.That(text).Contains("answering, uncounted"); + } + + /// <summary> + /// The four front-page figures, and the crawler's own line, in the reader's language. + /// </summary> + /// <remarks> + /// <b>The count labels and the crawler strip were the last English on a localized page.</b> + /// The strip is the worst of the two: it is the provenance of the four figures above it, so a + /// reader who cannot read it is a reader with no way to discount them — and it printed + /// "crawler live · last probe" in English around an age that had been carefully localized. + /// The wordmark is exempt and stays: a site's name is machine voice, like a hostname. + /// </remarks> + [Test] + public async Task TheHomeCountsAndTheCrawlerLineComeFromTheBundle() + { + var counts = SiteCounts.From(await Queries.ListAsync(new GameFilter { IncludeArchived = true })); + var cycle = new CrawlCycleRecord( + Now.AddMinutes(-2), Now.AddMinutes(-1), 8, 8, 6, 2, 0, 0, 0, 0, 0, 6, 0, 0, 0); + var pulse = new CrawlerPulse(Now.AddMinutes(-1), Now.AddMinutes(3), 4, 710, cycle); + + var pseudo = PlainText.RenderHome("qps-ploc", counts, await Queries.FeedsAsync(), pulse, Now); + + // The wordmark is the one line that must not have gone through the bundle. + await Assert.That(pseudo).Contains("MU*INDEX"); + + // Everything else did. "crawler live" carries no plural branch, so the pseudolocale accents + // it end to end and its English spelling cannot survive a trip through the bundle. + await Assert.That(pseudo).DoesNotContain("crawler live"); + + // The counts do carry plural branches, and the pseudolocale steps over anything inside + // braces — accenting a branch keyword would make the message unparseable. So the signal + // there is the ⟦⟧ the transform wraps the whole message in, which is what asking the bundle + // for the expected string tests: a renderer that interpolated its own line would print the + // same words with no brackets round them. + await Assert.That(pseudo) + .Contains(Messages.For("qps-ploc", "home.plain.known", Count(counts.Known))); + await Assert.That(pseudo) + .Contains(Messages.For("qps-ploc", "home.plain.archived", Count(counts.Archived))); + await Assert.That(pseudo).DoesNotContain($"\n{counts.Known} games known"); + await Assert.That(pseudo) + .Contains(CrawlerCopy.Registry("qps-ploc", pulse)) + .And.DoesNotContain($"\n{pulse.TargetsKnown} addresses in the registry"); + + // And the whole surface threads one tag: the German render says what the German bundle says + // for every id, whether that is a translation or the English it still falls back to. + var german = PlainText.RenderHome("de", counts, await Queries.FeedsAsync(), pulse, Now); + + foreach (var id in new[] + { + "home.plain.known", "home.plain.connectedNow", + "home.plain.uncounted", "home.plain.archived", + }) + { + await Assert.That(german).Contains(Messages.For("de", id, Count(CountFor(id, counts)))); + } + + await Assert.That(german).Contains(CrawlerCopy.State("de", pulse, Now)); + await Assert.That(german).Contains(CrawlerCopy.LastCycle("de", pulse)!); + await Assert.That(german).Contains(CrawlerCopy.Registry("de", pulse)); + + // The feeds it appends carry German ages, which is the one part of a feed row that was + // already localized and so the one that proves the tag survived the call into RenderFeeds. + var first = (await Queries.FeedsAsync()).NewlyDiscovered[0]; + + await Assert.That(german).Contains(Relative.Ago("de", Now - first.At)); + + static Dictionary<string, object?> Count(int count) => + new(StringComparer.Ordinal) { ["count"] = count }; + + static int CountFor(string id, SiteCounts counts) => id switch + { + "home.plain.known" => counts.Known, + "home.plain.connectedNow" => counts.WithPlayersOn, + "home.plain.uncounted" => counts.CountUnknown, + _ => counts.Archived, + }; } [Test] @@ -401,7 +722,7 @@ public async Task NoSurfaceOffersAVoteStarRatingOrRecommendation() var surfaces = new[] { await GameAsync("m-u-s-h"), - PlainText.RenderHome(counts, await Queries.FeedsAsync(), CrawlerPulse.Unknown, Now), + PlainText.RenderHome(Locales.SourceTag, counts, await Queries.FeedsAsync(), CrawlerPulse.Unknown, Now), PlainText.RenderListing(await Queries.SearchAsync(new GameFilter()), new GameFilter(), Now), }; diff --git a/tests/MUI.Web.Tests/PlainSurfaceTests.cs b/tests/MUI.Web.Tests/PlainSurfaceTests.cs index 137b860..9835190 100644 --- a/tests/MUI.Web.Tests/PlainSurfaceTests.cs +++ b/tests/MUI.Web.Tests/PlainSurfaceTests.cs @@ -1,6 +1,7 @@ using MUI.Catalog; using MUI.Web.Components; using MUI.Web.Fixtures; +using MUI.Web.Localization; namespace MUI.Web.Tests; @@ -56,25 +57,28 @@ public async Task EachWayOutOfTheListingIsMarkedAsItself(LifecycleState state, s } [Test] - public async Task AnUnknownCountSaysSoInWordsRatherThanBeingBlank() + public async Task AMissingCountSaysSoInWordsRatherThanBeingBlank() { // A blank reads as zero to a human exactly as it does to a parser. Midnight Sun answers, // offers no MSSP and no pre-login WHO, so there is genuinely nothing to count. + // + // Read off the id rather than the English: what this guards is that the absence is written + // out at all, not that it is written out in any particular words. var text = await RenderAsync("midnight-sun"); - await Assert.That(text).Contains("Players now: unknown"); + await Assert.That(text).Contains(Messages.For(Locales.SourceTag, "game.plain.playersNoCount")); await Assert.That(text).DoesNotContain("Players now: 0"); } [Test] - public async Task AMeasuredZeroIsPrintedAsZeroAndNotAsUnknown() + public async Task AMeasuredZeroIsPrintedAsZeroAndNotAsAnAbsence() { // Eldertale really has nobody on. That is a measurement and must not be softened into a // shrug — the two are different facts and the plain surface has to keep them apart. var text = await RenderAsync("eldertale"); await Assert.That(text).Contains("Players now: 0"); - await Assert.That(text).DoesNotContain("unknown"); + await Assert.That(text).DoesNotContain(Messages.For(Locales.SourceTag, "game.plain.playersNoCount")); } [Test] @@ -89,18 +93,30 @@ public async Task TheGamePagesOwnCountSaysHowItWasObtainedJustAsTheListingDoes() await Assert.That(declared).Contains("Players now: 9 (declared, 9m)"); await Assert.That(measured).Contains("Players now: 15 (measured, 4m)"); - // A count nobody could take keeps its sentence and gains no label. + // A count that does not exist keeps its sentence and gains no label — a provenance chip over + // nothing would attest to a measurement nobody took. await Assert.That(await RenderAsync("midnight-sun")) - .Contains("Players now: unknown (no count could be measured)"); + .Contains(Messages.For(Locales.SourceTag, "game.plain.playersNoCount")); } [Test] public async Task ADisagreementIsFlaggedInWordsNotByColour() { var text = await RenderAsync("m-u-s-h"); + var page = await Queries.FindAsync("m-u-s-h"); + // The mark on the row, and the tally in the heading — the latter read off the id, so the + // assertion is that the count reached the heading rather than that English inflects the + // verb one particular way. await Assert.That(text).Contains("** disagree"); - await Assert.That(text).Contains("disagree)"); + await Assert.That(text).Contains(Messages.For( + Locales.SourceTag, + "game.plain.capabilities", + new Dictionary<string, object?>(StringComparer.Ordinal) + { + ["disagreeing"] = page!.DisagreementCount, + ["total"] = page.Capabilities.Count, + })); } [Test] diff --git a/tests/MUI.Web.Tests/PresenceTrendTests.cs b/tests/MUI.Web.Tests/PresenceTrendTests.cs index bf3c0ac..bde58f2 100644 --- a/tests/MUI.Web.Tests/PresenceTrendTests.cs +++ b/tests/MUI.Web.Tests/PresenceTrendTests.cs @@ -1,5 +1,6 @@ using MUI.Catalog; using MUI.Web.Components; +using MUI.Web.Localization; namespace MUI.Web.Tests; @@ -17,6 +18,9 @@ public class PresenceTrendTests { private static readonly DateOnly Start = new(2026, 5, 1); + /// <summary>The locale these assertions read in. The source bundle is what they are written against.</summary> + private const string English = Locales.SourceTag; + [Test] public async Task ADayNobodyMeasuredGetsNoInkAtAll() { @@ -54,7 +58,7 @@ public async Task ASingleMeasuredDayIsAWholeBarRatherThanASpeck() var bars = TrendGeometry.Bars(series); await Assert.That(bars).Count().IsEqualTo(1); - await Assert.That(bars[0].Day.Label).Contains("14"); + await Assert.That(bars[0].Day.Label(English)).Contains("14"); await Assert.That(TrendGeometry.Zero - bars[0].MeanTop) .IsGreaterThan(100d) .Because("the only measurement in the range is also the ceiling, so its bar is the plot"); @@ -71,10 +75,16 @@ public async Task AnUncountableDayIsNotDrawnOnTheZeroLine() Uncountable(2), Counted(3, 5), Counted(4, 4)); - var ticks = TrendGeometry.Ticks(series); + var ticks = TrendGeometry.Ticks(English, series); await Assert.That(ticks).Count().IsEqualTo(1); - await Assert.That(ticks[0].Label).Contains("no count could be read"); + // The gutter mark carries the "probed, no count could be read" sentence and never the + // "no measurement" one — the middle state of §5.4 said as itself, in whatever language the + // reader asked for. + var uncountableDay = Start.AddDays(2); + + await Assert.That(ticks[0].Label).IsEqualTo(Say("trend.day.notCounted", uncountableDay)); + await Assert.That(ticks[0].Label).IsNotEqualTo(Say("trend.day.notMeasured", uncountableDay)); await Assert.That(TrendGeometry.Bars(series)).Count().IsEqualTo(4); await Assert.That(TrendGeometry.Bars(series).Any(b => b.Day.IsUncountable)).IsFalse(); @@ -92,8 +102,8 @@ public async Task AMeasuredZeroIsAMeasurementAndKeepsItsInk() await Assert.That(TrendGeometry.Zero - zero.MeanTop) .IsGreaterThanOrEqualTo(TrendGeometry.MinimumInk); - await Assert.That(TrendGeometry.Ticks(series)).IsEmpty(); - await Assert.That(series.Days[1].Label).Contains("0 players"); + await Assert.That(TrendGeometry.Ticks(English, series)).IsEmpty(); + await Assert.That(series.Days[1].Label(English)).Contains("0 players"); } [Test] @@ -158,11 +168,11 @@ public async Task TheCalendarIsLabelledWhereAMonthStartsAndIsNeverCrowded() // an axis, so they thin instead of overprinting. var quarter = TrendSeries.Over(new DateOnly(2026, 5, 19), new DateOnly(2026, 8, 16), []); - await Assert.That(TrendGeometry.Months(quarter).Select(m => m.Label)) + await Assert.That(TrendGeometry.Months(English, quarter).Select(m => m.Label)) .IsEquivalentTo(new[] { "Jun", "Jul", "Aug" }); var years = TrendSeries.Over(new DateOnly(2021, 1, 1), new DateOnly(2025, 12, 31), []); - var months = TrendGeometry.Months(years); + var months = TrendGeometry.Months(English, years); await Assert.That(months.Count).IsLessThanOrEqualTo(9); await Assert.That(months.Zip(months.Skip(1)).All(p => p.Second.X > p.First.X)).IsTrue(); @@ -197,12 +207,12 @@ public async Task APlayerCountIsNeverReportedWithADecimal() // rather than nearest, so the figure is one we are sure of. var series = Series(Counted(0, 601, 731, 666.1m), Counted(1, 590, 640, 620.4m)); - await Assert.That(series.Sentence).Contains("Typically 666 on"); - await Assert.That(series.Sentence).DoesNotContain("666.1"); - await Assert.That(series.Days[0].Label).Contains("666 on average"); - await Assert.That(series.Days[0].Label).DoesNotContain("666.1"); - await Assert.That(series.PerWeek().Single()).Contains("typically 666"); - await Assert.That(series.PerWeek().Single()).DoesNotContain("666.1"); + await Assert.That(series.Sentence(English)).Contains("Typically 666 on"); + await Assert.That(series.Sentence(English)).DoesNotContain("666.1"); + await Assert.That(series.Days[0].Label(English)).Contains("666 on average"); + await Assert.That(series.Days[0].Label(English)).DoesNotContain("666.1"); + await Assert.That(series.PerWeek(English).Single()).Contains("typically 666"); + await Assert.That(series.PerWeek(English).Single()).DoesNotContain("666.1"); // The wording is floored; the geometry is not, or the bar would be shortened by a sentence. await Assert.That(series.Days[0].Average).IsEqualTo(666.1d); @@ -218,14 +228,20 @@ public async Task TheSentenceNamesTheThreeStatesApart() var probed = Series(Uncountable(0), Uncountable(1)); var measured = Series(Counted(0, 6), Counted(1, 6), Counted(2, 8)); - await Assert.That(nothing.Sentence).IsEqualTo("No measurement in this range."); - await Assert.That(probed.Sentence).Contains("no player count could be read"); - await Assert.That(measured.Sentence).Contains("Typically 6"); - await Assert.That(measured.Sentence).Contains("peaking at 8"); + // The fact, through the bundle: a range with nothing in it says exactly the "no measurement" + // message and never the "probed and uncountable" one. Written this way the assertion still + // holds after a translation, which is the point — the two must stay two in every locale. + await Assert.That(nothing.Sentence(English)) + .IsEqualTo(Messages.For(English, "trend.none.notMeasured")); + await Assert.That(nothing.Sentence(English)) + .IsNotEqualTo(Messages.For(English, "trend.none.probed")); + await Assert.That(probed.Sentence(English)).Contains("no player count could be read"); + await Assert.That(measured.Sentence(English)).Contains("Typically 6"); + await Assert.That(measured.Sentence(English)).Contains("peaking at 8"); // And none of them names a cause: a failed probe writes no presence row, so silence here // cannot tell an outage of theirs from a gap of ours. - foreach (var sentence in new[] { nothing.Sentence, probed.Sentence }) + foreach (var sentence in new[] { nothing.Sentence(English), probed.Sentence(English) }) { await Assert.That(sentence).DoesNotContain("unreachable"); await Assert.That(sentence).DoesNotContain("down"); @@ -241,14 +257,18 @@ public async Task ADirectionIsOnlyClaimedWhenBothEndsWereMeasured() Counted(0, 20), Counted(1, 20), Counted(2, 20), Gap(3), Gap(4), Gap(5), Gap(6), Gap(7)); - await Assert.That(lopsided.Sentence).DoesNotContain("Down"); - await Assert.That(lopsided.Sentence).DoesNotContain("Up about"); + await Assert.That(lopsided.Sentence(English)).DoesNotContain("Down"); + await Assert.That(lopsided.Sentence(English)).DoesNotContain("Up about"); var falling = Series( Counted(0, 30), Counted(1, 30), Counted(2, 28), Counted(3, 20), Counted(4, 12), Counted(5, 10)); - await Assert.That(falling.Sentence).Contains("Down about"); + // And the change is a percentage a person reads, not the fraction behind it: the sign and + // its spacing come off the locale's number format rather than being a literal in a template. + await Assert.That(falling.Sentence(English)).Contains("Down about"); + await Assert.That(falling.Sentence(English)).Contains("63%"); + await Assert.That(falling.Sentence(English)).DoesNotContain("0.63"); } [Test] @@ -265,12 +285,25 @@ public async Task PerWeekSaysWhichOfTheThreeStatesAWeekWas() }) .ToArray()); - var lines = series.PerWeek().ToList(); + var lines = series.PerWeek(English).ToList(); await Assert.That(lines).Count().IsEqualTo(3); await Assert.That(lines[0]).Contains("typically 5"); await Assert.That(lines[0]).Contains("7 days counted"); - await Assert.That(lines[1]).IsEqualTo($"{Start.AddDays(7):d MMM}–{Start.AddDays(13):d MMM}: not measured"); + await Assert.That(lines[1]).IsEqualTo(Messages.For( + English, + "trend.week.notMeasured", + new Dictionary<string, object?>(StringComparer.Ordinal) + { + ["span"] = Messages.For( + English, + "trend.week.span", + new Dictionary<string, object?>(StringComparer.Ordinal) + { + ["from"] = Start.AddDays(7), + ["to"] = Start.AddDays(13), + }), + })); await Assert.That(lines[2]).Contains("probed, no count could be read"); } @@ -285,13 +318,86 @@ public async Task AWeekWithAllThreeStatesInItKeepsThemApart() Uncountable(4), Uncountable(5), Gap(6)); - var line = series.PerWeek().Single(); + var line = series.PerWeek(English).Single(); await Assert.That(line).Contains("4 days counted"); await Assert.That(line).Contains("2 days probed without a count"); await Assert.That(line).Contains("1 day not measured"); } + /// <summary> + /// A German request gets German month names, from CLDR rather than from an array in a component. + /// </summary> + /// <remarks> + /// This is the whole reason the date became a <c>{d, date}</c> argument instead of a + /// <c>ToString("d MMM yyyy")</c> at the call site. The old spelling read the month name off + /// whatever culture the thread happened to carry — the request's in one place and the invariant + /// one in the headless renderer — so a German page said "21 May 2026" in the middle of a German + /// sentence, and no translator could have fixed it because the word was not in a file they are + /// ever sent. + /// </remarks> + [Test] + public async Task ADateIsNamedInTheLanguageThePageWasAskedFor() + { + var day = Counted(20, 12); // 21 May 2026 + var may = new System.Globalization.CultureInfo("de") + .DateTimeFormat.AbbreviatedMonthNames[4]; + + await Assert.That(day.Label("de")).Contains(may); + await Assert.That(day.Label(English)) + .Contains(System.Globalization.CultureInfo + .GetCultureInfo("en").DateTimeFormat.AbbreviatedMonthNames[4]); + + // And the axis label under the chart, which is the same data through a different message. + var year = TrendSeries.Over(new DateOnly(2026, 4, 20), new DateOnly(2026, 6, 10), []); + + await Assert.That(TrendGeometry.Months("de", year).Select(m => m.Label)) + .Contains(may); + } + + /// <summary> + /// The two absences stay two, in every locale this site offers. + /// </summary> + /// <remarks> + /// A day probed all through that produced no count is a measurement of a game that was + /// answering; a day with no measurement is a statement about our crawl. Collapsing them is the + /// worst bug §5.4 can carry, and it is a collapse a translator makes silently — both English + /// sentences begin with a date and end in a negative — so it is asserted per locale rather than + /// once against the source bundle. Neither may reach for a cause: a failed probe writes no + /// presence row at all, so an empty day cannot tell an outage of theirs from a gap of ours. + /// </remarks> + [Test] + public async Task NoMeasurementAndNoReadableCountStayTwoDifferentStringsInEveryLocale() + { + var gap = Gap(0); + var uncountable = Uncountable(1); + + foreach (var locale in Locales.All) + { + await Assert.That(gap.Label(locale.Tag)) + .IsNotEqualTo(uncountable.Label(locale.Tag)) + .Because($"{locale.Tag} renders both absences as one sentence"); + + await Assert.That(Messages.Pattern(locale.Tag, "trend.day.notMeasured")) + .IsNotEqualTo(Messages.Pattern(locale.Tag, "trend.day.notCounted")) + .Because($"{locale.Tag} translated the two absences to one pattern"); + + // And neither names a cause, in any of them. "unreachable" is a locked id with its own + // translation in every bundle, and a day with no presence row is not one. + foreach (var absence in new[] { gap.Label(locale.Tag), uncountable.Label(locale.Tag) }) + { + await Assert.That(absence) + .DoesNotContain(Messages.For(locale.Tag, "state.unreachable")); + } + } + } + + private static string Say(string id, DateOnly date) => + Messages.For( + English, + id, + new Dictionary<string, object?>(StringComparer.Ordinal) { ["d"] = date }); + private static TrendSeries Series(params TrendDay[] days) => new(days[0].Date, days[^1].Date, days); diff --git a/tests/MUI.Web.Tests/ReachSeriesTests.cs b/tests/MUI.Web.Tests/ReachSeriesTests.cs index 4f8bcee..f790f82 100644 --- a/tests/MUI.Web.Tests/ReachSeriesTests.cs +++ b/tests/MUI.Web.Tests/ReachSeriesTests.cs @@ -1,5 +1,6 @@ using MUI.Catalog; using MUI.Web.Components; +using MUI.Web.Localization; namespace MUI.Web.Tests; @@ -11,6 +12,9 @@ public class ReachSeriesTests { private static readonly DateTimeOffset Now = new(2026, 7, 30, 20, 0, 0, TimeSpan.Zero); + /// <summary>The locale these assertions read in — the source bundle they are written against.</summary> + private const string English = Locales.SourceTag; + private static AvailabilityInterval Span(double from, double? to, AvailabilityState state, FailureCause cause) => new() { @@ -39,7 +43,7 @@ public async Task ADayWeWereNotWatchingIsItsOwnStateAndNotAnOutage() await Assert.That(summary.Days.Count(d => d.State is ReachState.Unmeasured)).IsGreaterThan(70); await Assert.That(summary.Days.Any(d => d.State is ReachState.Unreachable)).IsFalse(); - await Assert.That(summary.Sentence).Contains("predate anything we measured"); + await Assert.That(summary.Sentence(English)).Contains("predate anything we measured"); } [Test] @@ -55,8 +59,8 @@ public async Task DegradedIsItsOwnStateBetweenReachableAndUnreachable() ], Now); await Assert.That(summary.Days.Any(d => d.State is ReachState.Degraded)).IsTrue(); - await Assert.That(summary.Sentence).Contains("degraded"); - await Assert.That(summary.Sentence).Contains("could not finish"); + await Assert.That(summary.Sentence(English)).Contains("degraded"); + await Assert.That(summary.Sentence(English)).Contains("could not finish"); } [Test] @@ -89,7 +93,12 @@ public async Task TheLongestOutageCarriesItsOwnCauseAndNotTheMostRecentOne() await Assert.That(summary.LongestOutageCause).IsEqualTo(FailureCause.Refused); await Assert.That(summary.LastCause).IsEqualTo(FailureCause.Timeout); - await Assert.That(summary.Sentence).Contains("connection refused"); + // The cause named through the bundle rather than spelled here, so the assertion is about + // which FailureCause reached the sentence and survives its being translated. + await Assert.That(summary.Sentence(English)) + .Contains(Wording.Cause(English, FailureCause.Refused)); + await Assert.That(summary.Sentence(English)) + .DoesNotContain(Wording.Cause(English, FailureCause.Timeout)); } [Test] @@ -104,9 +113,11 @@ public async Task EverySpellThatWasNotReachableIsAvailableAsWords() Span(37, null, AvailabilityState.Reachable, FailureCause.None), ], Now); - await Assert.That(summary.Spells.Count()).IsEqualTo(1); - await Assert.That(summary.Spells[0]).Contains("unreachable"); - await Assert.That(summary.Spells[0]).Contains("dns did not resolve"); + await Assert.That(summary.Spells(English).Count).IsEqualTo(1); + await Assert.That(summary.Spells(English)[0]) + .Contains(Messages.For(English, "reach.word.unreachable")); + await Assert.That(summary.Spells(English)[0]) + .Contains(Wording.Cause(English, FailureCause.Dns)); } [Test] diff --git a/tests/MUI.Web.Tests/ReferenceContentTests.cs b/tests/MUI.Web.Tests/ReferenceContentTests.cs index 88f3c44..ae8bd75 100644 --- a/tests/MUI.Web.Tests/ReferenceContentTests.cs +++ b/tests/MUI.Web.Tests/ReferenceContentTests.cs @@ -1,5 +1,6 @@ using MUI.Catalog; using MUI.Web.Components; +using MUI.Web.Localization; using MUI.Web.Reference; namespace MUI.Web.Tests; @@ -194,16 +195,27 @@ public async Task ABodyHeadingNeverCompetesWithThePageTitle() /// The plain rendering of every reference page, which is the test of whether the section is /// communicating anything at all. /// </summary> +/// <remarks> +/// Rendered in the source locale here and asserted through <see cref="Messages"/> rather than +/// against English literals: what these guard is that the state survives as a word at all, and a +/// test spelling the word itself would have to be edited every time a translator is allowed to +/// choose a better one. <see cref="ReferenceLocalizationTests"/> is where the language is the +/// subject. +/// </remarks> public class ReferencePlainTests { private static readonly ReferenceLibrary Library = ReferenceLibrary.Shipped; + private const string Tag = Locales.SourceTag; + + private static string Word(CapabilityState state) => ClientCapabilities.Word(Tag, state); + [Test] public async Task EveryReferencePageHasAPlainRendering() { foreach (var document in Library.Documents) { - var text = ReferencePlainText.Render(document, related: Library.Related(document)); + var text = ReferencePlainText.Render(Tag, document, related: Library.Related(document)); await Assert.That(text).Contains(document.Title.ToUpperInvariant()); await Assert.That(text.Length).IsGreaterThan(document.Summary.Length); @@ -214,11 +226,14 @@ public async Task EveryReferencePageHasAPlainRendering() public async Task AClientMatrixSurvivesInWordsWithUnknownSpelledOut() { var mudlet = Library.Find(ReferenceKind.Client, "mudlet")!; - var text = ReferencePlainText.Render(mudlet); + var text = ReferencePlainText.Render(Tag, mudlet); - await Assert.That(text).Contains("screen reader yes"); - await Assert.That(text).Contains("MCCP unknown"); - await Assert.That(text).Contains("It never means no."); + await Assert.That(text).Contains($"screen reader {Word(CapabilityState.Present)}"); + await Assert.That(text).Contains($"MCCP {Word(CapabilityState.Unknown)}"); + + // The caveat quotes the same word the cells use, and says what it does not mean. + await Assert.That(Render.Words(text)) + .Contains(Render.Words(ReferencePlainText.ClientMatrixCaveat(Tag))); } [Test] @@ -228,11 +243,11 @@ public async Task ThePlainClientMatrixNeverLeavesAnUnknownCellBlank() // reason this surface exists. foreach (var document in Library.OfKind(ReferenceKind.Client)) { - var text = ReferencePlainText.Render(document); + var text = ReferencePlainText.Render(Tag, document); foreach (var claim in ClientCapabilities.For(document).Where(c => c.State is CapabilityState.Unknown)) { - await Assert.That(text).Contains($"{claim.Name,-16} unknown"); + await Assert.That(text).Contains($"{claim.Name,-16} {Word(CapabilityState.Unknown)}"); } } } @@ -241,23 +256,32 @@ public async Task ThePlainClientMatrixNeverLeavesAnUnknownCellBlank() public async Task ThePlainProtocolPageSaysWhatTheRemainderIsNot() { var gmcp = Library.Find(ReferenceKind.Protocol, "gmcp")!; - var text = ReferencePlainText.Render(gmcp, protocol: new ProtocolFigures(3, 10, [])); - - await Assert.That(text).Contains("3 of 10 listed games were observed offering it"); - await Assert.That(Render.Words(text)).Contains("not games without the protocol"); + var text = ReferencePlainText.Render(Tag, gmcp, protocol: new ProtocolFigures(3, 10, [])); + + await Assert.That(Render.Words(text)).Contains(Render.Words(Messages.Say( + Tag, + "reference.plain.protocol.share", + ("offering", 3), + ("listed", 10), + ("percent", Wording.Percent(0.3))))); + + // Rule 5: the games not counted are not games without the protocol. + await Assert.That(Render.Words(text)) + .Contains(Render.Words(ReferencePlainText.ProtocolRemainderCaveat(Tag))); } [Test] public async Task ThePlainIndexListsEverySectionItHas() { - var text = ReferencePlainText.RenderIndex(Library); + var text = ReferencePlainText.RenderIndex(Tag, Library); - foreach (var heading in new[] { "START HERE", "CODEBASES", "CLIENTS", "PROTOCOLS" }) + foreach (var kind in Enum.GetValues<ReferenceKind>()) { - await Assert.That(text).Contains(heading); + await Assert.That(text).Contains(ReferencePlainText.Heading(Tag, kind).ToUpperInvariant()); } - await Assert.That(Render.Words(text)).Contains("This is not a wiki"); + await Assert.That(Render.Words(text)) + .Contains(Render.Words(Messages.For(Tag, "reference.plain.lede"))); } [Test] @@ -268,7 +292,7 @@ public async Task NoPlainReferenceLineIsWiderThanEightyColumnsUnlessItIsOneUnbre // has to fit. foreach (var document in Library.Documents) { - var text = ReferencePlainText.Render(document, related: Library.Related(document)); + var text = ReferencePlainText.Render(Tag, document, related: Library.Related(document)); foreach (var line in text.Split('\n').Select(l => l.TrimEnd())) { diff --git a/tests/MUI.Web.Tests/ReferenceFiguresTests.cs b/tests/MUI.Web.Tests/ReferenceFiguresTests.cs index ce2f0cf..1e1f7a2 100644 --- a/tests/MUI.Web.Tests/ReferenceFiguresTests.cs +++ b/tests/MUI.Web.Tests/ReferenceFiguresTests.cs @@ -68,10 +68,12 @@ public async Task AFamilyWithNothingIdentifiedIsNotAZeroLeftToSpeakForItself() await Assert.That(figures.Known).IsEqualTo(0); var page = Library.Find(ReferenceKind.Codebase, "pennmush")!; - var text = MUI.Web.Components.ReferencePlainText.Render(page, codebase: figures); + var text = MUI.Web.Components.ReferencePlainText.Render( + MUI.Web.Localization.Locales.SourceTag, page, codebase: figures); - await Assert.That(Render.Words(text)).Contains("None yet"); - await Assert.That(Render.Words(text)).Contains("not about what exists"); + await Assert.That(Render.Words(text)).Contains(Render.Words( + MUI.Web.Localization.Messages.For( + MUI.Web.Localization.Locales.SourceTag, "reference.plain.codebase.none"))); } [Test] diff --git a/tests/MUI.Web.Tests/ReferenceLocalizationTests.cs b/tests/MUI.Web.Tests/ReferenceLocalizationTests.cs new file mode 100644 index 0000000..cfa6b79 --- /dev/null +++ b/tests/MUI.Web.Tests/ReferenceLocalizationTests.cs @@ -0,0 +1,357 @@ +using MUI.Catalog; +using MUI.Web.Components; +using MUI.Web.Localization; +using MUI.Web.Reference; + +namespace MUI.Web.Tests; + +/// <summary> +/// The reference section's chrome, answered in the language the reader asked for. +/// </summary> +/// <remarks> +/// <para> +/// <b>The chrome and the articles are localized by two different routes, and this is about the +/// first.</b> An article is a document, translated as a document by the content layer; the furniture +/// round it is strings in a bundle. So the boundary is the subject in both directions: every word +/// the site writes has to come from the bundle, and no word an article owns — nor any machine voice +/// inside one — may pass through it. +/// </para> +/// <para> +/// The pseudo-locale is what proves the first half. A string rendered through the bundle comes back +/// wrapped in <c>⟦ ⟧</c> and with its vowels accented, so a heading that is still bare came from a +/// template rather than from a message — which is a claim no German render can make today, because +/// a locale that has not translated an id yet falls back to the English and is byte-identical to a +/// hard-coded one. +/// </para> +/// </remarks> +public class ReferenceLocalizationTests +{ + private const string Pseudo = "qps-ploc"; + + private static readonly ReferenceLibrary Library = ReferenceLibrary.Shipped; + + /// <summary>Every id the section's chrome says, whichever surface says it.</summary> + private static IReadOnlyList<string> ChromeIds => + [.. Messages.Ids.Where(id => id.StartsWith("reference.", StringComparison.Ordinal))]; + + [Test] + public async Task AGermanRequestIsAnsweredWithGermanChrome() + { + // "Textfassung" is the German for the plain-text link, and it is on the reference pages + // because they ask the bundle for it now. Before this change both pages spelled the link + // "plain text" in every language on the site. + await using var site = await SiteHost.StartAsync(); + + foreach (var path in new[] { "/de/reference", "/de/reference/protocols/mssp" }) + { + var markup = await site.Client.GetStringAsync(path); + + await Assert.That(markup).Contains(Messages.For("de", "a11y.plainText")); + await Assert.That(Render.Words(markup)) + .DoesNotContain("plain text") + .Because($"{path} still writes an English link into a German page"); + } + } + + [Test] + public async Task EveryWordTheSectionWritesComesFromTheBundle() + { + // The pseudo-locale's brackets are the proof. Each of these is a different kind of chrome — + // the heading, the lede, a section label, a measured panel's heading, a table's column, the + // plain-text link — and a bare one is a string that never met a translator. + await using var site = await SiteHost.StartAsync(); + + var index = await site.Client.GetStringAsync($"/{Pseudo}/reference"); + + foreach (var id in new[] + { + "reference.title", "reference.plain.lede", "reference.section.codebase", + "reference.section.protocol", + }) + { + var expected = id == "reference.plain.lede" + ? Messages.For(Pseudo, "reference.lede.number") + : Messages.For(Pseudo, id); + + await Assert.That(Render.Words(index)) + .Contains(Render.Words(expected)) + .Because($"{id} did not reach the page through the bundle"); + } + + var entry = await site.Client.GetStringAsync($"/{Pseudo}/reference/protocols/mssp"); + + foreach (var id in new[] + { + "reference.kind.protocol", "reference.protocol.heading", "reference.protocol.remainder", + "reference.seeAlso", + }) + { + await Assert.That(Render.Words(entry)) + .Contains(Render.Words(Messages.For(Pseudo, id))) + .Because($"{id} did not reach the page through the bundle"); + } + } + + [Test] + public async Task AnArticlesOwnTextNeverPassesThroughTheBundle() + { + // The boundary, from the other side, and asked of the one locale that can answer it. The + // pseudo-locale accents and brackets everything the message pipeline touches, so an article + // body coming back plain is the evidence that it is a document rather than a string. What + // language that document is in is the content layer's business and not asserted here. + await using var site = await SiteHost.StartAsync(); + + var words = Render.Words( + await site.Client.GetStringAsync($"/{Pseudo}/reference/protocols/mssp")); + + await Assert.That(words).Contains("MSSP is telnet option 70"); + } + + [Test] + public async Task AProtocolAcronymIsNeverATranslatableString() + { + // A locale that translated TTYPE would be destroying evidence rather than localizing a + // string, so no acronym is in the bundle to be translated: they reach a message as an + // argument or sit in the markup. Checked against the source text of every id this section + // owns, in every bundle a reader can be answered from. + string[] machineVoice = + [ + "MSSP", "GMCP", "MSDP", "ATCP", "MCCP", "MXP", "MSP", "TTYPE", "CHARSET", "EOR", + "PennMUSH", "Evennia", "TinyMUX", "Mudlet", "telnet", + ]; + + foreach (var id in ChromeIds) + { + foreach (var locale in Locales.All.Where(l => l.IsChoosable)) + { + var pattern = Messages.Pattern(locale.Tag, id)!; + + foreach (var token in machineVoice) + { + await Assert.That(pattern.Contains(token, StringComparison.OrdinalIgnoreCase)) + .IsFalse() + .Because($"{locale.Tag}/{id} carries {token}, which is machine voice"); + } + } + } + } + + [Test] + public async Task AnAcronymOnTheRenderedPageIsUntouchedByTheLocale() + { + // And the same claim about the frame rather than about the bundle. The pseudo-locale accents + // every vowel it is given, so TTYPE coming back as TTYPE is the evidence that no locale is + // between the catalogue and the page. MSSP has no vowel to accent and would prove nothing. + await using var site = await SiteHost.StartAsync(); + + var markup = await site.Client.GetStringAsync($"/{Pseudo}/reference/protocols/ttype"); + + await Assert.That(markup).Contains("TTYPE"); + await Assert.That(markup).DoesNotContain("TTYPÉ"); + } + + [Test] + public async Task ThePlainMirrorIsWrittenInThePagesLanguage() + { + // Same rule as the rest of the plain surface: it says what the page says, in the language + // the page was asked for. Its own wording, because it has no panel round the sentences — + // but its own wording out of the same bundle. + var plain = ReferencePlainText.RenderIndex(Pseudo, Library); + + await Assert.That(Render.Words(plain)) + .Contains(Render.Words(Messages.For(Pseudo, "reference.plain.lede"))); + + foreach (var kind in Enum.GetValues<ReferenceKind>()) + { + await Assert.That(plain).Contains(ReferencePlainText.Heading(Pseudo, kind).ToUpperInvariant()); + } + } + + [Test] + public async Task TheThreeCapabilityWordsStayThreeWordsInEveryLocale() + { + // The finding the whole localization file exists for, in this table's own vocabulary. An + // unknown is what we looked for and did not establish; a locale that let it collapse into + // the no beside it would publish our own failure to find a page as the client lacking the + // feature. + foreach (var locale in Locales.All.Where(l => l.IsChoosable)) + { + var words = new[] + { + CapabilityState.Present, CapabilityState.Absent, CapabilityState.Unknown, + }.Select(s => ClientCapabilities.Word(locale.Tag, s)).ToList(); + + await Assert.That(words.Distinct().Count()) + .IsEqualTo(3) + .Because($"{locale.Tag} says the same word for two different states"); + } + } + + [Test] + public async Task TheCaveatQuotesTheWordTheCellsUse() + { + // One sentence explaining one word, and they cannot drift apart: the word is an argument to + // the sentence rather than written into it a second time. + foreach (var locale in Locales.All.Where(l => l.IsChoosable)) + { + await Assert.That(ReferencePlainText.ClientMatrixCaveat(locale.Tag)) + .Contains(ClientCapabilities.Word(locale.Tag, CapabilityState.Unknown)); + } + } + + /// <summary> + /// A translated article is the same article: same slug, same kind, same related pages. + /// </summary> + /// <remarks> + /// <para> + /// <b>Enforced by the loader and asserted here anyway.</b> <c>ReferenceLibrary.For</c> hands out + /// the English record with only the prose replaced, so a translator cannot move a slug even by + /// writing a different one — but the file on disk is what a person edits next, and a front + /// matter that disagrees with the English is a trap set for whoever reads it later. This walks + /// the files rather than the loaded documents, which is the only place the difference shows. + /// </para> + /// <para> + /// The structural keys are the routing and the see-also graph: <c>kind</c> and <c>slug</c> make + /// the URL, <c>see-also</c> makes the related-pages links, and <c>codebase</c>, <c>protocol</c>, + /// <c>home</c>, <c>platform</c> and <c>capability</c> are read as machine voice. Only + /// <c>title</c> and <c>summary</c> are prose. + /// </para> + /// </remarks> + [Test] + public async Task ATranslatedArticleKeepsTheEnglishStructure() + { + var root = ArticleRoot(); + var english = root.GetFiles("*.md").ToDictionary(f => f.Name, StringComparer.Ordinal); + + await Assert.That(english).IsNotEmpty().Because("the English articles are the source"); + + var checkedFiles = 0; + + foreach (var directory in root.GetDirectories()) + { + foreach (var translated in directory.GetFiles("*.md")) + { + await Assert.That(english.ContainsKey(translated.Name)) + .IsTrue() + .Because($"{directory.Name}/{translated.Name} translates an article that does not exist"); + + var source = Structure(File.ReadAllText(english[translated.Name].FullName)); + var target = Structure(File.ReadAllText(translated.FullName)); + + await Assert.That(target) + .IsEquivalentTo(source) + .Because($"{directory.Name}/{translated.Name} changed a structural front-matter key"); + + checkedFiles++; + } + } + + await Assert.That(checkedFiles) + .IsGreaterThan(0) + .Because("a sweep over no translations proves nothing about translations"); + } + + /// <summary>Every front-matter line that is not prose, in the order the file gives them.</summary> + private static List<string> Structure(string document) + { + var parts = document.Split("---", 3); + var front = parts.Length > 1 ? parts[1] : string.Empty; + + return + [ + .. front.Split('\n') + .Select(l => l.TrimEnd('\r')) + .Where(l => l.Length > 0 && !l.StartsWith("title:", StringComparison.Ordinal) + && !l.StartsWith("summary:", StringComparison.Ordinal)), + ]; + } + + /// <summary> + /// The articles on disk, which is where a front matter can disagree with the English. + /// </summary> + /// <remarks> + /// Walked up from the test binary to the repository root rather than assumed at a fixed depth: + /// the output layout moves with the configuration, the framework and any <c>--output</c>, and a + /// content test that fails as a missing directory says nothing about content. + /// </remarks> + private static DirectoryInfo ArticleRoot() + { + var directory = new DirectoryInfo(AppContext.BaseDirectory); + + while (directory is not null) + { + var articles = new DirectoryInfo(Path.Combine(directory.FullName, "content", "reference")); + + if (articles.Exists) + { + return articles; + } + + directory = directory.Parent; + } + + throw new InvalidOperationException("content/reference was not found above the test binary."); + } + + /// <summary> + /// Every offered locale gets its own articles, including the one whose tag carries a dash. + /// </summary> + /// <remarks> + /// <b>Chinese was the locale that silently did not work.</b> MSBuild builds a manifest resource + /// name out of the file's path and replaces what cannot appear in an identifier, so + /// <c>content/reference/zh-Hans/</c> is embedded as <c>…reference.zh_Hans.…</c> and a lookup + /// spelled with the dash matched nothing. German, Dutch and Japanese all worked, which is + /// exactly the evidence that hides it — so this names <c>zh-Hans</c> rather than iterating and + /// hoping the interesting case is in the list. + /// </remarks> + [Test] + [Arguments("de")] + [Arguments("nl")] + [Arguments("ja")] + [Arguments("zh-Hans")] + public async Task ALocaleWithArticlesServesItsOwnProse(string tag) + { + var english = ReferenceLibrary.Shipped.Find("/reference/protocols/mssp"); + var translated = ReferenceLibrary.For(tag).Find("/reference/protocols/mssp"); + + await Assert.That(english).IsNotNull(); + await Assert.That(translated).IsNotNull(); + + await Assert.That(translated!.Body) + .IsNotEqualTo(english!.Body) + .Because($"{tag} has a translation of this article and should be reading it"); + + // The prose changed and nothing else did: a translation supplies words, not structure. + await Assert.That(translated.Slug).IsEqualTo(english.Slug); + await Assert.That(translated.Kind).IsEqualTo(english.Kind); + await Assert.That(translated.SeeAlso).IsEquivalentTo(english.SeeAlso); + await Assert.That(translated.Home).IsEqualTo(english.Home); + } + + /// <summary>And every article is translated in every offered locale, not merely most of them.</summary> + /// <remarks> + /// The loader falls back per article so a gap is invisible on the page, which is right for a + /// reader and wrong for us: without this, one file failing to be written would look exactly like + /// a file that was never meant to exist. + /// </remarks> + [Test] + [Arguments("de")] + [Arguments("nl")] + [Arguments("ja")] + [Arguments("zh-Hans")] + public async Task NoArticleQuietlyFallsBackToEnglish(string tag) + { + var english = ReferenceLibrary.Shipped; + var localized = ReferenceLibrary.For(tag); + + foreach (var article in english.Documents) + { + var translated = localized.Find(article.Path); + + await Assert.That(translated).IsNotNull(); + await Assert.That(translated!.Body) + .IsNotEqualTo(article.Body) + .Because($"{tag}{article.Path} is being served in English"); + } + } +} diff --git a/tests/MUI.Web.Tests/Render.cs b/tests/MUI.Web.Tests/Render.cs index d165cab..0c8a121 100644 --- a/tests/MUI.Web.Tests/Render.cs +++ b/tests/MUI.Web.Tests/Render.cs @@ -1,3 +1,5 @@ +using System.Text.RegularExpressions; + using MUI.Catalog; using MUI.Catalog.Persistence; using MUI.Web.Data; @@ -192,4 +194,24 @@ public static async Task<string> ComponentAsync<TComponent>( public static string Words(string markupOrText) => string.Join(' ', System.Net.WebUtility.HtmlDecode(markupOrText) .Split((char[]?)null, StringSplitOptions.RemoveEmptyEntries)); + + /// <summary> + /// What a reader actually sees: the elements removed, then decoded and collapsed. + /// </summary> + /// <remarks> + /// <para> + /// <see cref="Words"/> keeps the tags, which is right for most assertions here and wrong for one + /// kind: a sentence that places its own link or code span is broken up by elements, so asserting + /// it against <c>Words</c> asserts the markup as well as the sentence. It is also why a + /// class name — <c><details class="history"></c> — reads as the word "history" and can + /// satisfy a check that was about the copy. + /// </para> + /// <para> + /// Tags are stripped <em>before</em> decoding, on purpose. The owner dashboard prints a badge + /// snippet as escaped markup for an operator to copy; decoding first would turn it into + /// something this regex then ate, and the snippet is text a reader is meant to see. + /// </para> + /// </remarks> + public static string Text(string markup) => + Words(Regex.Replace(markup, "<[^>]*>", " ", RegexOptions.None, TimeSpan.FromSeconds(5))); } diff --git a/tests/MUI.Web.Tests/ScriptAndDirectionTests.cs b/tests/MUI.Web.Tests/ScriptAndDirectionTests.cs new file mode 100644 index 0000000..68314a9 --- /dev/null +++ b/tests/MUI.Web.Tests/ScriptAndDirectionTests.cs @@ -0,0 +1,136 @@ +using MUI.Web.Components; +using MUI.Web.Components.Pages; + +namespace MUI.Web.Tests; + +/// <summary> +/// Game-supplied names, tagged with the script they are actually in. +/// </summary> +/// <remarks> +/// <para> +/// The listing has always contained 北大侠客行 inside a page declared <c>lang="en"</c>. A screen +/// reader picks its voice and its pronunciation rules from that attribute, so it attempts Chinese +/// characters with English phonetics — which is not an accent, it is noise. The same attribute is +/// what selects between the regional Han forms a font draws. +/// </para> +/// <para> +/// The rule these tests exist to hold is the site's own: <b>say what you measured and nothing +/// else.</b> A script settles a language only where it is used for essentially one, and where it is +/// shared the tag is left off rather than filled in with whichever language is commonest. +/// </para> +/// </remarks> +public class ScriptAndDirectionTests +{ + [Test] + [Arguments("Shangrila", null)] + [Arguments("Tapestries MUCK", null)] + [Arguments("3Kingdoms", null)] + public async Task PlainAsciiGetsNoAttributesAtAll(string name, string? expected) + { + // Most of the catalogue, and the page's own lang already describes it. Five hundred rows + // repeating that is the duplication this whole pass exists to remove. + await Assert.That(NameScript.IsPlainAscii(name)).IsTrue(); + await Assert.That(NameScript.LanguageOf(name)).IsEqualTo(expected); + } + + [Test] + [Arguments("ドラゴンクエスト", "ja")] // katakana + [Arguments("剣と魔法の世界", "ja")] // Han with one hiragana particle + [Arguments("바람의나라", "ko")] // Hangul + [Arguments("เมืองแห่งเงา", "th")] // Thai + [Arguments("Δίκτυο", "el")] // Greek + [Arguments("Ἑλλάς", "el")] // opens in Greek Extended, continues in Greek + [Arguments("מבוך", "he")] // Hebrew + [Arguments("مدينة الأحلام", "ar")] // Arabic + public async Task AScriptUsedForOneLanguageSettlesIt(string name, string expected) + { + // Kana settle Japanese wherever they appear, and one is enough: a Japanese title is + // routinely mostly Han with a single particle in it. + await Assert.That(NameScript.LanguageOf(name)).IsEqualTo(expected); + } + + /// <summary> + /// Greek Extended is Greek, and the widening stops at its edges. + /// </summary> + /// <remarks> + /// Polytonic Greek lives at U+1F00–U+1FFF and nothing else is written there, so the block + /// settles a language exactly as the basic Greek block does. Unlisted, it fell to + /// <c>Script.Other</c> — which meant whether a Greek name was tagged at all depended on which of + /// its letters happened to carry a breathing mark. Asserted from the codepoints rather than from + /// a word, because no natural Greek word is written entirely out of this block. + /// </remarks> + [Test] + [Arguments(0x1f00, "el")] // the first letter in the block + [Arguments(0x1ffe, "el")] // the last assigned character in it + [Arguments(0x1efd, null)] // Latin Extended Additional, one below — shared by many languages + [Arguments(0x2010, null)] // general punctuation, above — a script at all only by courtesy + public async Task GreekExtendedSettlesGreekAndTheBlocksAroundItStillSettleNothing( + int codepoint, string? expected) + { + await Assert.That(NameScript.LanguageOf(char.ConvertFromUtf32(codepoint))).IsEqualTo(expected); + } + + [Test] + [Arguments("北大侠客行")] // Han, no kana — Chinese or Japanese, nothing says which + [Arguments("Сумеречная Империя")] // Cyrillic — Russian, Ukrainian, Bulgarian, a dozen more + [Arguments("मापा गया")] // Devanagari — Hindi, Marathi, Nepali + public async Task AScriptSharedByManyLanguagesSettlesNothing(string name) + { + // The important half. Unicode unified Han across Chinese and Japanese, and the correct drawn + // form differs between them — so guessing "zh" for a Japanese game's name is not a harmless + // default, it is the site asserting something about somebody's game that no probe measured. + // An absent lang costs a glyph variant; a wrong one costs the claim the site is built on. + await Assert.That(NameScript.IsPlainAscii(name)).IsFalse(); + await Assert.That(NameScript.LanguageOf(name)).IsNull(); + } + + [Test] + [Arguments("مدينة الأحلام", "rtl")] + [Arguments("מבוך", "rtl")] + [Arguments("北大侠客行", null)] + [Arguments("Shangrila", null)] + public async Task DirectionIsAnsweredFromTheFirstStrongCharacter(string name, string? expected) + { + // Which is what the Unicode bidirectional algorithm itself uses to type a paragraph, so a + // name opening with a Latin bracket around Arabic text is still an Arabic run. + await Assert.That(NameScript.DirectionOf(name)).IsEqualTo(expected); + } + + [Test] + public async Task ANonLatinNameIsIsolatedFromTheRowAroundIt() + { + // Without <bdi> the name, the neutral characters beside it and the count in the next cell + // renegotiate order as one bidirectional run, and the number lands on the wrong side of the + // row. With it, the name reads right-to-left inside its own box while the row stays + // left-to-right — which is the whole of "RTL text, LTR layout" and needs no mirrored + // stylesheet. + var arabic = await Render.ComponentAsync<GameName>(new() { ["Name"] = "مدينة الأحلام" }); + var chinese = await Render.ComponentAsync<GameName>(new() { ["Name"] = "北大侠客行" }); + var latin = await Render.ComponentAsync<GameName>(new() { ["Name"] = "Shangrila" }); + + await Assert.That(arabic).Contains("<bdi"); + await Assert.That(arabic).Contains("dir=\"rtl\""); + await Assert.That(arabic).Contains("lang=\"ar\""); + + // Isolated, but not tagged: nothing in the codepoints says which language this Han is. + await Assert.That(chinese).Contains("<bdi"); + await Assert.That(chinese).DoesNotContain("lang="); + + // And no element at all where the page's own lang already describes the name. + await Assert.That(latin).DoesNotContain("<bdi"); + } + + [Test] + public async Task TheListingWrapsEveryGameNameAndLeavesTheMachineVoiceAlone() + { + // Two halves of tier three. A game's name is isolated so the layout survives it; the + // machine voice — codebase strings, versions, protocol acronyms, hostnames — carries + // translate="no", because translating `PennMUSH 1.8.8p0` destroys evidence rather than + // localizing anything. + var listing = await Render.PageAsync<Games>([]); + var game = await Render.PageAsync<Game>(new() { ["Slug"] = "m-u-s-h" }); + + await Assert.That(listing).Contains("class=\"meta mono\" translate=\"no\""); + await Assert.That(game).Contains("translate=\"no\""); + } +} diff --git a/tests/MUI.Web.Tests/SilenceIsNotEvidenceTests.cs b/tests/MUI.Web.Tests/SilenceIsNotEvidenceTests.cs index 81741cf..e3a33a3 100644 --- a/tests/MUI.Web.Tests/SilenceIsNotEvidenceTests.cs +++ b/tests/MUI.Web.Tests/SilenceIsNotEvidenceTests.cs @@ -1,6 +1,9 @@ using MUI.Catalog; using MUI.Catalog.Persistence; using MUI.Web.Components; +using MUI.Web.Components.Pages; +using MUI.Web.Fixtures; +using MUI.Web.Localization; namespace MUI.Web.Tests; @@ -36,9 +39,14 @@ public async Task AFractionOverAPartlyMeasuredWindowNamesTheMeasuredDenominator( // The number itself was always right — FractionReachable divides by observed time. It was // the sentence that widened it to the window. - await Assert.That(summary.Sentence).Contains("we have measured"); - await Assert.That(summary.Sentence).DoesNotContain("of the last 90 days"); - await Assert.That(summary.Sentence).Contains("89 days predate anything we measured"); + // + // Asserted through the bundle rather than against the English, so the rule holds in every + // locale: the two denominators are two different ids and a translation cannot merge them. + var sentence = summary.Sentence(Locales.SourceTag); + + await Assert.That(sentence).Contains(Say("reach.fraction.measured", ("percent", "100.0%"), ("days", 1))); + await Assert.That(sentence).DoesNotContain(Say("reach.fraction.window", ("percent", "100.0%"), ("days", 90))); + await Assert.That(sentence).Contains(Say("reach.predate", ("count", 89))); } /// <summary>A window we watched all of may say so, and says it the short way.</summary> @@ -49,10 +57,19 @@ public async Task AFractionOverAFullyMeasuredWindowStillNamesTheWindow() [Reachable(from: Now.AddDays(-120), to: null)], Now); - await Assert.That(summary.Sentence).Contains("Reachable 100.0% of the last 90 days."); - await Assert.That(summary.Sentence).DoesNotContain("predate"); + // The whole sentence, assembled from the ids it is supposed to use and no others: the window + // phrasing because the window was fully observed, and nothing about days that predate us. + await Assert.That(summary.Sentence(Locales.SourceTag)).IsEqualTo( + Say("reach.fraction.window", ("percent", "100.0%"), ("days", 90)) + + " " + Messages.For(Locales.SourceTag, "reach.unreachable.noneInWindow")); } + private static string Say(string id, params (string Key, object? Value)[] args) => + Messages.For( + Locales.SourceTag, + id, + args.ToDictionary(a => a.Key, a => a.Value, StringComparer.Ordinal)); + /// <summary> /// An hour with no presence row is not an hour the game was down. /// </summary> @@ -77,16 +94,30 @@ public async Task AnHourWithNoSampleIsNotReportedAsUnreachable() } } - var sentence = ActivitySummary.Sentence(week); + var sentence = ActivitySummary.Sentence(Locales.SourceTag, week); await Assert.That(sentence).Contains("have no measurement yet"); await Assert.That(sentence).DoesNotContain("not reachable"); await Assert.That(sentence).DoesNotContain("unreachable"); var cell = new ActivityCell(3, 4, null, Probed: false); - await Assert.That(ActivitySummary.CellLabel(cell)).DoesNotContain("reachable"); - await Assert.That(ActivitySummary.CellValue(cell)).IsEqualTo("not measured"); - await Assert.That(ActivitySummary.PerDay(week).First()).Contains("not measured"); + await Assert.That(ActivitySummary.CellLabel(Locales.SourceTag, cell)).DoesNotContain("reachable"); + + // The locked id, not the English spelling of it: what this test guards is that the hour is + // called not-measured rather than given a cause, in whatever language the reader asked for. + await Assert.That(ActivitySummary.CellValue(Locales.SourceTag, cell)) + .IsEqualTo(Messages.For(Locales.SourceTag, "state.notMeasured")); + + await Assert.That(ActivitySummary.PerDay(Locales.SourceTag, week).First()).Contains("not measured"); + + // And no locale names a cause for it either. "unreachable" is a different locked id with a + // different translation in every bundle, and an hour with no presence row is not one. + foreach (var locale in Locales.All) + { + await Assert.That(ActivitySummary.CellValue(locale.Tag, cell)) + .IsNotEqualTo(Messages.For(locale.Tag, "state.unreachable")) + .Because($"{locale.Tag} calls an unmeasured hour unreachable"); + } } /// <summary> @@ -111,6 +142,61 @@ public async Task InternalFieldsAreNotThingsAGameSaidAboutItself() await Assert.That(FieldRegistry.Instance.Find(InternalFields.BannerHash)).IsNull(); } + /// <summary> + /// A missing count is not a count somebody failed to read. + /// </summary> + /// <remarks> + /// <para> + /// The game page's hero said <c>state.notCounted</c> whenever <c>PlayersNow</c> was null, and the + /// glossary reserves that string for the middle of rule 2's three states: an hour we reached and + /// could not read a number out of. A null count is not that state. It is that state, an hour + /// nobody measured, and a count older than the window this figure covers, and nothing on the page + /// separates them — so Gaslight Row, archived and unreached since 2018, was described as a game + /// we had probed and failed to count. + /// </para> + /// <para> + /// Asserted through the locked ids rather than the English, and on both surfaces, because + /// <c>?plain=1</c> carried the same claim in its own words ("no count could be measured"). + /// </para> + /// </remarks> + [Test] + public async Task AGamePageWithNoCountNamesNoCauseForNotHavingOne() + { + var page = await new FixtureGameQueries().FindAsync("gaslight-row"); + + await Assert.That(page!.Summary.PlayersNow).IsNull(); + + // The hero itself, sliced out: the strip and the grid below it are entitled to the words + // "unreachable" and "uncounted", because they are derived from intervals and from presence + // rows and can tell those states apart. This figure cannot, so this figure may not say them. + var raw = await Render.PageAsync<Game>(new() { ["Slug"] = "gaslight-row" }); + var opens = raw.IndexOf("class=\"game-figure\"", StringComparison.Ordinal); + + await Assert.That(opens).IsGreaterThanOrEqualTo(0); + + var figure = Render.Words(raw[opens..raw.IndexOf("</div>", opens, StringComparison.Ordinal)]); + + var count = PlainText.Render(page, Now) + .ReplaceLineEndings("\n") + .Split('\n') + .First(line => line.StartsWith("Players now:", StringComparison.Ordinal)); + + foreach (var text in new[] { figure, count }) + { + // The three locked words that would each name a cause nobody measured. + await Assert.That(text).DoesNotContain(Messages.For(Locales.SourceTag, "state.notCounted")); + await Assert.That(text).DoesNotContain(Messages.For(Locales.SourceTag, "state.uncounted")); + await Assert.That(text).DoesNotContain(Messages.For(Locales.SourceTag, "state.unreachable")); + + // And never a nought, which is the other direction of the same mistake. + await Assert.That(text).DoesNotContain("0"); + } + + await Assert.That(figure).Contains(Messages.For(Locales.SourceTag, "game.count.none")); + await Assert.That(figure).Contains(Messages.For(Locales.SourceTag, "game.count.none.why")); + await Assert.That(count).IsEqualTo(Messages.For(Locales.SourceTag, "game.plain.playersNoCount")); + } + private static AvailabilityInterval Reachable(DateTimeOffset from, DateTimeOffset? to) => new() { GameId = Guid.NewGuid(), diff --git a/tests/MUI.Web.Tests/SiteHeaderTests.cs b/tests/MUI.Web.Tests/SiteHeaderTests.cs index fb17e21..77234d4 100644 --- a/tests/MUI.Web.Tests/SiteHeaderTests.cs +++ b/tests/MUI.Web.Tests/SiteHeaderTests.cs @@ -64,11 +64,76 @@ public async Task TheHeaderReadsNothingButWhetherThereIsAPrincipal() await Assert.That(await HeaderAsync(signedIn: true)).IsNotNull(); } - private static Task<string> HeaderAsync(bool signedIn) => + [Test] + public async Task TheCatalogueLinksAreTwoLabelledGroupsAndTheActionsAreNotInThem() + { + // Nine links in one flat row, in no order anybody could name. They are two ideas — places to + // browse, and things to read about the hobby — and two odd ones out: submit is an action + // rather than a category, and about is site meta. Both moved to the far end, beside sign in. + var markup = await HeaderAsync(signedIn: false); + + await Assert.That(markup).Contains("aria-label=\"browse\""); + await Assert.That(markup).Contains("aria-label=\"learn\""); + + var catalogues = markup[markup.IndexOf("site-nav", StringComparison.Ordinal).. + markup.IndexOf("nav class=\"account", StringComparison.Ordinal)]; + + await Assert.That(catalogues).Contains("/games"); + await Assert.That(catalogues).Contains("/rankings"); + await Assert.That(catalogues).DoesNotContain("/about"); + + // Submit is in the nav's markup, and it is not in either group: it lives in `menu-tail`, + // which the bar shows only at the width where the right-hand cluster has run out of room + // for it. A destination the bar cannot fit moves; it is never dropped. + var groups = catalogues[..catalogues.IndexOf("menu-tail", StringComparison.Ordinal)]; + + await Assert.That(groups).DoesNotContain("/submit"); + await Assert.That(catalogues).Contains("/submit"); + } + + [Test] + public async Task EveryCatalogueLinkIsInTheDocumentExactlyOnce() + { + // The bar collapses into a disclosure on a narrow window, and the obvious way to build that + // is a second copy of the links inside the menu. It is also wrong: two copies put two + // `aria-current="page"` markers in one document and hand a screen reader the catalogue + // twice. The disclosure wraps the same two groups instead, and CSS decides whether it is a + // menu or a row. + var markup = await HeaderAsync(signedIn: false, path: "/games"); + + foreach (var href in new[] { "/games", "/find", "/games/random", "/archive", "/reference", "/ecosystem", "/rankings" }) + { + await Assert.That(markup.Split($"href=\"{href}\"").Length - 1).IsEqualTo(1); + } + } + + [Test] + public async Task TheCurrentPageIsMarkedAndTheMarkerIsDrawnInsideTheItem() + { + // aria-current is the fact. The drawing of it is an inset box-shadow in the stylesheet, not + // a border or a padding change: either of those adds a pixel to the current item's box and + // shifts every link beside it on arrival, which is the reported defect. + var markup = await HeaderAsync(signedIn: false, path: "/reference/protocols/mssp"); + + await Assert.That(markup).Contains("href=\"/reference\" class=\"on\" aria-current=\"page\""); + await Assert.That(markup.Split("aria-current").Length - 1).IsEqualTo(1); + } + + [Test] + public async Task TheHomePageDoesNotMarkEverySectionAsCurrent() + { + // "/" is a prefix of every path on the site, so a section match that reached it would mark + // the whole bar on the one page that has no item in it. + var markup = await HeaderAsync(signedIn: false, path: "/"); + + await Assert.That(markup).DoesNotContain("aria-current"); + } + + private static Task<string> HeaderAsync(bool signedIn, string path = "/games") => Render.ComponentAsync<MainLayout>(new Dictionary<string, object?>(), services => { services.AddSingleton(new CatalogueSource(IsMeasured: true)); - services.AddCascadingValue(_ => Context(signedIn)); + services.AddCascadingValue(_ => Context(signedIn, path)); }); /// <summary> @@ -80,10 +145,14 @@ private static Task<string> HeaderAsync(bool signedIn) => /// has no way to produce a real session without an authenticator. The guard under test is the /// layout's own read of <c>Identity.IsAuthenticated</c>, and that runs either way. /// </remarks> - private static HttpContext Context(bool signedIn) + private static HttpContext Context(bool signedIn, string path = "/games") { var context = new DefaultHttpContext(); + // The header asks it one other thing now: which page this is, so the item for it can be + // marked. A path and nothing else — no route data, no endpoint. + context.Request.Path = path; + if (signedIn) { context.User = new ClaimsPrincipal(new ClaimsIdentity( @@ -93,4 +162,30 @@ [new Claim(ClaimTypes.NameIdentifier, Guid.CreateVersion7().ToString())], return context; } + + /// <summary> + /// One page is current, so one item is marked — even where two destinations nest. + /// </summary> + /// <remarks> + /// A section matches its own root and everything under it, which is what makes a reference + /// article mark "reference". But <c>/games/random</c> is its own destination in the same bar, so + /// standing on it matched <c>/games</c> as well and a screen reader was handed two + /// <c>aria-current="page"</c> markers in one document. The most specific match wins now. + /// </remarks> + [Test] + [Arguments("/games/random", "/games/random")] + [Arguments("/games", "/games")] + [Arguments("/reference/protocols/mssp", "/reference")] + [Arguments("/archive", "/archive")] + public async Task ExactlyOneNavigationItemIsMarkedCurrent(string path, string expected) + { + var markup = await HeaderAsync(signedIn: false, path: path); + + var marked = System.Text.RegularExpressions.Regex + .Matches(markup, "<a href=\"([^\"]+)\"[^>]*aria-current=\"page\"") + .Select(m => m.Groups[1].Value) + .ToList(); + + await Assert.That(marked).IsEquivalentTo(new[] { expected }); + } } diff --git a/tests/MUI.Web.Tests/SortingTests.cs b/tests/MUI.Web.Tests/SortingTests.cs index b8e0468..ce4ba00 100644 --- a/tests/MUI.Web.Tests/SortingTests.cs +++ b/tests/MUI.Web.Tests/SortingTests.cs @@ -1,3 +1,4 @@ +using MUI.Web.Localization; using MUI.Catalog; using MUI.Web.Api; using MUI.Web.Components; @@ -115,8 +116,12 @@ await Assert.That(await Render.PageAsync<Games>([], "?sort=name")) await Assert.That(sorted).Contains("unranked-break"); await Assert.That(Render.Words(sorted)).Contains("from here"); - await Assert.That(Render.Words(sorted)).Contains(FacetWords.Unranked(GameSort.Players)); - await Assert.That(FacetWords.Unranked(GameSort.Players)).Contains("not zero"); + await Assert.That(Render.Words(sorted)).Contains(FacetWords.Unranked(Locales.SourceTag, GameSort.Players)); + // The break names the state rather than arguing with a reading of it. It said "reachable, + // count unreadable — not zero", which spends most of its words denying something nobody had + // thought yet; the state has a name, the site uses that name everywhere else, and the rows + // under the break say "not counted" in their own cells. + await Assert.That(FacetWords.Unranked(Locales.SourceTag, GameSort.Players)).IsEqualTo("Unknown count"); } [Test] @@ -128,8 +133,8 @@ public async Task ARowNeverPrintsAnAgeAsNowAgo() var html = Render.Words(await Render.PageAsync<Games>([])); await Assert.That(html).DoesNotContain("now ago"); - await Assert.That(Relative.Ago(TimeSpan.FromSeconds(10))).IsEqualTo("just now"); - await Assert.That(Relative.Ago(TimeSpan.FromMinutes(20))).IsEqualTo("20m ago"); + await Assert.That(Relative.Ago(Locales.SourceTag, TimeSpan.FromSeconds(10))).IsEqualTo("just now"); + await Assert.That(Relative.Ago(Locales.SourceTag, TimeSpan.FromMinutes(20))).IsEqualTo("20m ago"); } [Test] @@ -143,8 +148,8 @@ public async Task ThePlainSurfaceSaysWhatOrderItIsInAndWhereTheBreakFell() var text = PlainText.RenderListing( await Queries.SearchAsync(query.Filter), query.Filter, FixtureGameQueries.Now); - await Assert.That(Render.Words(text)).Contains($"Sorted by {FacetWords.Sort(GameSort.Players)}"); - await Assert.That(Render.Words(text)).Contains(FacetWords.Unranked(GameSort.Players)); + await Assert.That(Render.Words(text)).Contains($"Sorted by {FacetWords.Sort(Locales.SourceTag, GameSort.Players)}"); + await Assert.That(Render.Words(text)).Contains(FacetWords.Unranked(Locales.SourceTag, GameSort.Players)); // And the parameter that changes it, because a text browser cannot operate a <select>. await Assert.That(text).Contains($"?{FacetKeys.Sort}="); @@ -220,8 +225,8 @@ public async Task AGameWithNoWindowSortsBelowTheBreakAndNeverAsAZero() await Assert.That(order[0].Name).IsEqualTo("counted"); await Assert.That(GameSorting.IsUnranked(uncountable, GameSort.MedianMonth)).IsTrue(); - await Assert.That(FacetWords.Unranked(GameSort.MedianMonth)).Contains("not a typical count of zero"); - await Assert.That(FacetWords.Unranked(GameSort.PeakMonth)).Contains("not a game nobody was on"); + await Assert.That(FacetWords.Unranked(Locales.SourceTag, GameSort.MedianMonth)).Contains("not a typical count of zero"); + await Assert.That(FacetWords.Unranked(Locales.SourceTag, GameSort.PeakMonth)).Contains("not a game nobody was on"); } [Test] @@ -255,19 +260,19 @@ public async Task EverySortHasWordsAndAGroupToBeOfferedUnder() // "name" — which is an order the reader did not choose, silently. foreach (var sort in Enum.GetValues<GameSort>()) { - await Assert.That(FacetWords.Sort(sort)).IsNotEmpty(); - await Assert.That(FacetWords.SortGroup(sort)).IsNotEmpty(); + await Assert.That(FacetWords.Sort(Locales.SourceTag, sort)).IsNotEmpty(); + await Assert.That(FacetWords.SortGroup(Locales.SourceTag, sort)).IsNotEmpty(); if (sort is not GameSort.Name) { - await Assert.That(FacetWords.Unranked(sort)) + await Assert.That(FacetWords.Unranked(Locales.SourceTag, sort)) .IsNotEmpty() .Because($"{sort} can leave games unranked and has to say what they have in common"); } } // Distinct labels, or two options in the control are one choice wearing two rows. - await Assert.That(Enum.GetValues<GameSort>().Select(FacetWords.Sort).Distinct().Count()) + await Assert.That(Enum.GetValues<GameSort>().Select(s => FacetWords.Sort(Locales.SourceTag, s)).Distinct().Count()) .IsEqualTo(Enum.GetValues<GameSort>().Length); } diff --git a/tests/MUI.Web.Tests/SubmitSurfaceTests.cs b/tests/MUI.Web.Tests/SubmitSurfaceTests.cs index cd2c019..fc73c0e 100644 --- a/tests/MUI.Web.Tests/SubmitSurfaceTests.cs +++ b/tests/MUI.Web.Tests/SubmitSurfaceTests.cs @@ -3,6 +3,7 @@ using MUI.Discovery; using MUI.Web.Components; using MUI.Web.Components.Pages; +using MUI.Web.Localization; namespace MUI.Web.Tests; @@ -77,6 +78,48 @@ public async Task TheFormSaysASubmissionIsNotAListing() await Assert.That(page).Contains("Nothing appears on the site until somebody proves they run it"); } + /// <summary> + /// Every word this form says comes out of the message bundle. + /// </summary> + /// <remarks> + /// The pseudolocale brackets and accents anything that reached a reader through + /// <see cref="Messages"/>, so an English sentence surviving here is one typed into the page or + /// into <see cref="SubmitCopy"/>. The address is the exception and is asserted to survive + /// intact: it is what a stranger typed, it is machine voice, and a form that handed back a + /// translated version of somebody's hostname would be answering about a different address. + /// </remarks> + [Test] + public async Task EveryAnswerComesFromTheBundleAndTheAddressComesBackUntouched() + { + foreach (var outcome in Enum.GetValues<SubmissionOutcome>()) + { + var english = SubmitCopy.Answer(outcome, "mud.example.org 4201")!; + var pseudo = PlainText.RenderSubmit( + SubmitCopy.Answer(outcome, "mud.example.org 4201", null, "qps-ploc"), + hasCatalogue: true, + "qps-ploc"); + + await Assert.That(pseudo).Contains("⟦"); + await Assert.That(Render.Words(pseudo)) + .DoesNotContain(Render.Words(english.Heading)) + .Because($"the {outcome} heading never went through the message pipeline"); + } + + // The lede, the five points and the address, in one render. + var form = Render.Words(PlainText.RenderSubmit( + SubmitCopy.Answer(SubmissionOutcome.Accepted, "mud.example.org 4201", null, "qps-ploc"), + hasCatalogue: true, + "qps-ploc")); + + await Assert.That(form).Contains("mud.example.org 4201"); + await Assert.That(form).DoesNotContain(Render.Words(SubmitCopy.Lede())); + + foreach (var point in SubmitCopy.Points()) + { + await Assert.That(form).DoesNotContain(Render.Words(point)); + } + } + /// <summary>Over the demo fixture the form is absent rather than present and doing nothing.</summary> [Test] public async Task OverTheFixtureThereIsNoFormAtAll() diff --git a/tests/MUI.Web.Tests/ThreeStatesTests.cs b/tests/MUI.Web.Tests/ThreeStatesTests.cs index 6fd1df7..89286ff 100644 --- a/tests/MUI.Web.Tests/ThreeStatesTests.cs +++ b/tests/MUI.Web.Tests/ThreeStatesTests.cs @@ -1,6 +1,7 @@ using MUI.Catalog; using MUI.Web.Components; using MUI.Web.Fixtures; +using MUI.Web.Localization; namespace MUI.Web.Tests; @@ -17,32 +18,179 @@ namespace MUI.Web.Tests; /// </remarks> public class ThreeStatesTests { + /// <summary> + /// The listing's absent count says the count is absent, and does not name a cause. + /// </summary> + /// <remarks> + /// <b>Three cases were wearing one word, and the word named a cause.</b> The count column + /// printed <c>state.notCounted</c> — the glossary's phrase for a probe that answered without a + /// number — whenever the window had no measurement, which also covers a window we never probed + /// in and a game with no rows at all. Two of the three are our crawl schedule, and rule 5 says + /// our schedule is never published as a fact about somebody's game. The same conflation was + /// found and fixed on the game page's hero; this is the listing's half of it. + /// </remarks> + [Test] + public async Task TheListingSaysACountIsAbsentWithoutSayingWhy() + { + var absent = Messages.For(Locales.SourceTag, "listing.count.none"); + var probed = Messages.For(Locales.SourceTag, "state.notCounted"); + + // Two different facts, so two different strings — in every language, not just this one. + // + // Walked over every locale the site has a bundle for, not the choosable ones. The filtered + // set can shrink to English alone — a locale that is not yet complete is not offered — and + // then this loop proves nothing while still passing, which is the failure mode a + // cross-locale claim is most prone to. The count is asserted so it cannot go quiet. + var locales = Locales.All.Where(l => l.Tag != Locales.SourceTag).ToList(); + + await Assert.That(locales.Count).IsGreaterThan(1) + .Because("a claim about every language needs more than one language to be a claim"); + + foreach (var locale in locales.Append(Locales.Source)) + { + await Assert.That(Messages.For(locale.Tag, "listing.count.none")) + .IsNotEqualTo(Messages.For(locale.Tag, "state.notCounted")) + .Because($"{locale.Tag} must not print a probed-but-unreadable count for an unmeasured window"); + } + + // And it names nothing: no cause, no zero. + await Assert.That(absent).DoesNotContain("0"); + await Assert.That(absent).IsNotEqualTo(probed); + } + + /// <summary>The plain listing marks and its break line are the bundle's words, not English.</summary> + /// <remarks> + /// The rendered listing was localized and its <c>?plain=1</c> mirror was not: "-- from here:", + /// "[archived]" and "[claimed]" were literals, so a German reader's text alternative carried + /// three English words the page beside it does not. A mirror that answers in a different + /// language from the page is not a mirror. + /// </remarks> + [Test] + public async Task ThePlainListingMarksAreTranslatedLikeTheRestOfIt() + { + foreach (var id in new[] + { + "listing.plain.fromHere", "listing.plain.archived", "listing.plain.claimed", + }) + { + await Assert.That(Messages.Ids).Contains(id); + await Assert.That(Messages.For(Locales.SourceTag, id)).IsNotEmpty(); + } + } + private static readonly DateTimeOffset Now = FixtureGameQueries.Now; + /// <summary>The language these assertions are written in, named rather than assumed.</summary> + private const string English = Locales.SourceTag; + + /// <summary> + /// The four states on one day — and, because the grid is only drawn once every day of the week + /// carries a measurement, a measured hour on each of the other six so there is a grid to look at. + /// </summary> private static ActivityCell[] OneOfEach() => [ new(0, 0, 4, Probed: true), new(0, 1, 0, Probed: true), new(0, 2, null, Probed: true), new(0, 3, null, Probed: false), + .. Enumerable.Range(1, 6).Select(day => new ActivityCell(day, 20, 3, Probed: true)), ]; private static Task<string> GridAsync(IReadOnlyList<ActivityCell> cells) => Render.ComponentAsync<ActivityHeatmap>(new() { ["Cells"] = cells }); [Test] - public async Task TheGridIsARealTableWithRowAndColumnHeaders() + public async Task TheGridIsDrawnWithHeadersAndIsNotWhatAScreenReaderIsGiven() { - // Not a compromise for accessibility — a real table is what makes arrow-key navigation work - // at all, and it costs the visual design nothing. + // The drawing keeps its row and column headers — they are what make the picture legible and + // what the mouse tooltips hang off — but it is hidden from assistive tech, because announced + // cell by cell it is 168 utterances that deliver one shape. The seven rows below it are the + // text alternative, and they are a real table with a caption and headers of their own. var html = await GridAsync(OneOfEach()); + await Assert.That(html).Contains("<div class=\"heat-wrap\" aria-hidden=\"true\""); await Assert.That(html).Contains("<table class=\"heat\""); + await Assert.That(html).Contains("<table class=\"perday\""); await Assert.That(html).Contains("scope=\"col\""); await Assert.That(html).Contains("scope=\"row\""); await Assert.That(html).Contains("<caption"); } + [Test] + public async Task ACellCarriesNoAnnouncedTextOfItsOwn() + { + // 168 cells with a word in each is the whole of finding B2: on a sparsely measured game a + // screen reader was made to hear "not measured" 167 times before reaching the one number + // that existed. The words stay in the tooltip, where a mouse reader gets them, and the facts + // stay in the table below, where a listener gets them in seven rows. + var html = Render.Words(await GridAsync(OneOfEach())); + + await Assert.That(html).Contains("title=\"Mon 03:00 — no measurement in this hour\"></td>"); + + // Nothing announced anywhere in the grid's body — no cell text, and no sr-only span smuggling + // one back in. The words are in the table below, seven rows of them. + var body = html[html.IndexOf("<tbody", StringComparison.Ordinal)..]; + var grid = body[..body.IndexOf("</table>", StringComparison.Ordinal)]; + + await Assert.That(grid).DoesNotContain("sr-only"); + await Assert.That(grid).DoesNotContain("</td>not"); + } + + [Test] + public async Task BelowSevenMeasuredDaysThereIsNoGridAtAll() + { + // A 7×24 grid holding one probe is 167 empty cells, and it reads as a broken page to a + // sighted reader and as a wall to a listening one. What we have, and what has to arrive + // before there is a week to draw. + var html = Render.Words(await GridAsync( + [ + new(0, 0, 42, Probed: true), + ])); + + await Assert.That(html).Contains("not enough measurements yet"); + await Assert.That(html).Contains("the busiest 42 on Monday at 00:00 UTC"); + await Assert.That(html).DoesNotContain("<table"); + + // And no sentence about a week: "busiest Monday, small hours" off one Monday morning is a + // claim about a shape one measurement cannot have. + await Assert.That(html).DoesNotContain("Busiest"); + } + + /// <summary> + /// The threshold itself, from both sides. + /// </summary> + /// <remarks> + /// The test above uses one measured day, which passes whether the comparison is <c>>=</c>, + /// <c>></c> or off by one. Six against seven is the only pair that pins + /// <see cref="ActivitySummary.MeasuredDaysForGrid"/> down, and two surfaces read it — the grid's + /// own gate and the plain surface's. + /// </remarks> + [Test] + public async Task SixMeasuredDaysIsNotAWeekAndTheSeventhIsWhatDrawsTheGrid() + { + var six = Enumerable.Range(0, ActivitySummary.MeasuredDaysForGrid - 1) + .Select(day => new ActivityCell(day, 20, 3, Probed: true)) + .ToList(); + + var withoutGrid = Render.Words(await GridAsync(six)); + + await Assert.That(withoutGrid).Contains("not enough measurements yet"); + await Assert.That(withoutGrid).DoesNotContain("<table"); + + var seven = six + .Append(new ActivityCell(ActivitySummary.MeasuredDaysForGrid - 1, 20, 3, Probed: true)) + .ToList(); + + await Assert.That(Render.Words(await GridAsync(seven))).Contains("<table class=\"perday\""); + + // And the plain surface turns on the same day, or the two disagree about how much was + // measured — which is the failure mode a shared constant with one caller invites. + await Assert.That(ActivitySummary.MeasuredDays(six)) + .IsLessThan(ActivitySummary.MeasuredDaysForGrid); + await Assert.That(ActivitySummary.MeasuredDays(seven)) + .IsEqualTo(ActivitySummary.MeasuredDaysForGrid); + } + [Test] public async Task TheThreeStatesAreThreeDifferentCellsInTheMarkup() { @@ -57,16 +205,16 @@ public async Task TheThreeStatesAreThreeDifferentCellsInTheMarkup() [Test] public async Task AMeasuredZeroSaysMeasuredAndAnUnmeasuredHourSaysSo() { - // The distinction has to survive with no cell shape and no colour at all, so it is in the - // cell's own text as well as its class — the value a reader arrows onto, and the whole - // sentence in the tooltip. + // The distinction has to survive with no cell shape and no colour at all, so it is in words + // as well as in the cell's class: the whole sentence in the tooltip, and a column each in + // the table below, where "not measured" and "no count" are two headings and never one. var html = await GridAsync(OneOfEach()); await Assert.That(html).Contains("0 players, measured"); await Assert.That(html).Contains("no measurement in this hour"); await Assert.That(html).Contains("probed, no count could be read"); - await Assert.That(html).Contains(">not measured<"); - await Assert.That(html).Contains(">not counted<"); + await Assert.That(html).Contains(">not measured</th>"); + await Assert.That(html).Contains(">no count</th>"); } [Test] @@ -75,10 +223,194 @@ public async Task AnAnnouncedCellIsAValueRatherThanARepeatedSentence() // The headers already say which hour of which day a cell is. Repeating that in every cell // turns 168 cells into 168 paragraphs, which is what the summary and the disclosure exist // to prevent. - await Assert.That(ActivitySummary.CellValue(new ActivityCell(0, 0, 4, true))).IsEqualTo("4"); - await Assert.That(ActivitySummary.CellValue(new ActivityCell(0, 1, 0, true))).IsEqualTo("0"); - await Assert.That(ActivitySummary.CellValue(new ActivityCell(0, 2, null, true))).IsEqualTo("not counted"); - await Assert.That(ActivitySummary.CellValue(new ActivityCell(0, 3, null, false))).IsEqualTo("not measured"); + // + // The two words are read from the glossary rather than written out here: they are locked ids + // and this test's business is that the cell says the right *state*, not that English spells + // it a particular way. A number is a number in every locale and stays written out. + await Assert.That(ActivitySummary.CellValue(English, new ActivityCell(0, 0, 4, true))).IsEqualTo("4"); + await Assert.That(ActivitySummary.CellValue(English, new ActivityCell(0, 1, 0, true))).IsEqualTo("0"); + + await Assert.That(ActivitySummary.CellValue(English, new ActivityCell(0, 2, null, true))) + .IsEqualTo(Messages.For(English, "state.notCounted")); + + await Assert.That(ActivitySummary.CellValue(English, new ActivityCell(0, 3, null, false))) + .IsEqualTo(Messages.For(English, "state.notMeasured")); + } + + /// <summary> + /// The worst bug this codebase can ship, checked in every language the site answers in. + /// </summary> + /// <remarks> + /// An hour that answered and could not be counted and an hour nobody has a measurement for are + /// two facts, and a translation engine reaches for one phrase — <em>nicht verfügbar</em> — for + /// both. A reader who cannot tell them apart cannot tell a game that answered from one that did + /// not, which is the single thing this site exists to say. Asserted through the cell rather than + /// through the glossary, because the cell is where a reader meets them. + /// </remarks> + [Test] + public async Task NotMeasuredAndNotCountedAreTwoDifferentWordsInEveryLocale() + { + var gap = new ActivityCell(0, 3, null, Probed: false); + var uncountable = new ActivityCell(0, 2, null, Probed: true); + + foreach (var locale in Locales.All) + { + var notMeasured = ActivitySummary.CellValue(locale.Tag, gap); + var notCounted = ActivitySummary.CellValue(locale.Tag, uncountable); + + await Assert.That(notMeasured) + .IsNotEqualTo(notCounted) + .Because($"{locale.Tag} says the same thing about two different hours"); + + // And neither is a nought. A zero is a count we took, and both of these are the absence + // of one — in every language, including the ones that have not been translated yet. + await Assert.That(notMeasured).IsNotEqualTo("0"); + await Assert.That(notCounted).IsNotEqualTo("0"); + } + } + + /// <summary> + /// A German page names the days in German, and it does not get them from us. + /// </summary> + /// <remarks> + /// Seven weekday strings compiled into a component are seven strings no translator is ever sent, + /// and the symptom was a fully German sentence with "Monday" in the middle of it. They come from + /// CLDR now, so the mapping is what can break: Monday is 0 in this codebase because that is how + /// the store keys a week, and .NET's arrays start at Sunday. + /// </remarks> + [Test] + [Arguments("en", 0, "Monday", "Mon")] + [Arguments("en", 6, "Sunday", "Sun")] + [Arguments("de", 0, "Montag", "Mo")] + [Arguments("de", 4, "Freitag", "Fr")] + [Arguments("de", 6, "Sonntag", "So")] + [Arguments("nl", 0, "maandag", "ma")] + public async Task ADayIsNamedInTheReadersLanguageAndTheWeekStartsOnMonday( + string tag, int day, string expected, string expectedShort) + { + await Assert.That(ActivitySummary.DayName(tag, day)).IsEqualTo(expected); + await Assert.That(ActivitySummary.ShortDayName(tag, day)).IsEqualTo(expectedShort); + } + + /// <summary> + /// The sentence about a week reaches a reader in their own language, day names and all. + /// </summary> + [Test] + public async Task TheSummarySentenceIsAnsweredInTheLocaleItWasAskedIn() + { + var cells = FixtureActivity(); + + var english = ActivitySummary.Sentence(English, cells); + var german = ActivitySummary.Sentence("de", cells); + + // Every id here is untranslated today, so the German sentence is the English one — with the + // day names, which are CLDR's rather than ours, already in German. That is the fallback + // behaving: an English phrase in a German page says truthfully that this claim has not been + // translated, and a day name has no excuse, because nobody had to translate it. + await Assert.That(german).IsNotEqualTo(english); + + var named = 0; + + foreach (var day in Enumerable.Range(0, 7)) + { + if (!english.Contains(ActivitySummary.DayName(English, day), StringComparison.Ordinal)) + { + continue; + } + + named++; + + await Assert.That(german).Contains(ActivitySummary.DayName("de", day)); + await Assert.That(german).DoesNotContain(ActivitySummary.DayName(English, day)); + } + + await Assert.That(named).IsGreaterThan(0).Because("the sentence named no day at all"); + } + + /// <summary> + /// No count is ever said in a plural form the reader's language does not have. + /// </summary> + /// <remarks> + /// <para> + /// The whole reason the counts are ICU arguments rather than numbers glued to English nouns. + /// English distinguishes one hour from two and Chinese distinguishes nothing, so an English + /// message with a <c>one</c> branch must not hand that branch to a Chinese reader merely because + /// it is there — which is precisely what a fallback does if the formatter picks branches by the + /// source language rather than by the target. + /// </para> + /// <para> + /// Counted as shapes rather than compared to expected strings: with the number blanked out, the + /// number of distinct renderings a message can produce is the number of forms it emits, and that + /// may never exceed the count of categories CLDR gives the language. + /// </para> + /// </remarks> + [Test] + public async Task ACountIsSaidInAFormItsOwnLanguageHas() + { + string[] counted = ["activity.gap.week", "activity.day.notMeasured", "activity.sparse.uncounted"]; + + foreach (var locale in Locales.All) + { + var forms = PluralRules.CategoriesOf(locale.Tag).Count; + + foreach (var id in counted) + { + var shapes = Enumerable.Range(1, 25) + .Select(n => Messages + .For(locale.Tag, id, new Dictionary<string, object?> { ["count"] = n }) + .Replace(n.ToString(), "#", StringComparison.Ordinal)) + .Distinct(StringComparer.Ordinal) + .ToList(); + + await Assert.That(shapes.Count) + .IsLessThanOrEqualTo(forms) + .Because($"{locale.Tag} / {id} says {shapes.Count} things and the language has " + + $"{forms} plural {(forms == 1 ? "form" : "forms")}"); + } + } + + // And English, where a bug of this kind is invisible, still says both of its two. + await Assert.That(Messages.For(English, "activity.gap.week", new Dictionary<string, object?> { ["count"] = 1 })) + .Contains("1 hour across"); + await Assert.That(Messages.For(English, "activity.gap.week", new Dictionary<string, object?> { ["count"] = 2 })) + .Contains("2 hours across"); + } + + /// <summary> + /// Every sentence the panel can write renders in every locale, with no argument left unsupplied. + /// </summary> + /// <remarks> + /// A message that names <c>{day}</c> where the caller passes none is a <c>FormatException</c> on + /// somebody's page rather than a wrong word, and the branch it hides in is the one that only a + /// particular week reaches. This walks the shapes: a week measured at zero, a week nobody + /// counted, a week of gaps, and a week with one hour in it. + /// </remarks> + [Test] + public async Task EverySentenceShapeRendersInEveryLocale() + { + IReadOnlyList<ActivityCell>[] weeks = + [ + FixtureActivity(), + OneOfEach(), + [.. Week((d, h) => new ActivityCell(d, h, 0, Probed: true))], + [.. Week((d, h) => new ActivityCell(d, h, null, Probed: true))], + [.. Week((d, h) => new ActivityCell(d, h, null, Probed: false))], + [new ActivityCell(0, 0, 42, Probed: true)], + [], + ]; + + foreach (var locale in Locales.All) + { + foreach (var week in weeks) + { + await Assert.That(() => ActivitySummary.Sentence(locale.Tag, week)).ThrowsNothing(); + await Assert.That(() => ActivitySummary.Sparse(locale.Tag, week)).ThrowsNothing(); + await Assert.That(() => ActivitySummary.PerDay(locale.Tag, week)).ThrowsNothing(); + } + } + + static IEnumerable<ActivityCell> Week(Func<int, int, ActivityCell> cell) => + Enumerable.Range(0, 7).SelectMany(d => Enumerable.Range(0, 24).Select(h => cell(d, h))); } [Test] @@ -94,9 +426,9 @@ public async Task AnArchivedGamesGridIsEmptyRatherThanHatched() var page = await new FixtureGameQueries().FindAsync("gaslight-row"); await Assert.That(page!.Activity.All(c => c.IsGap)).IsTrue(); - await Assert.That(ActivitySummary.Sentence(page.Activity)).Contains("no measurement yet"); - await Assert.That(ActivitySummary.Sentence(page.Activity)).DoesNotContain("reachable"); - await Assert.That(ActivitySummary.Sentence(page.Activity)).DoesNotContain("answered but produced"); + await Assert.That(ActivitySummary.Sentence(English, page.Activity)).Contains("no measurement yet"); + await Assert.That(ActivitySummary.Sentence(English, page.Activity)).DoesNotContain("reachable"); + await Assert.That(ActivitySummary.Sentence(English, page.Activity)).DoesNotContain("answered but produced"); } [Test] @@ -114,13 +446,28 @@ public async Task TheSummarySentenceArrivesBeforeTheGrid() } [Test] - public async Task AReadAsTextDisclosureGivesOneLinePerDayRatherThanAHundredAndSixtyEightCells() + public async Task AReadAsTextDisclosureGivesOneRowPerDayRatherThanAHundredAndSixtyEightCells() { + // Seven rows — day, quietest, busiest, the hour the peak was in, and the two kinds of hour + // that produced no number — behind one keystroke rather than a wall to scroll past. var html = Render.Words(await GridAsync(FixtureActivity())); - await Assert.That(html).Contains("read as text"); - await Assert.That(html).Contains("Mon —"); - await Assert.That(html).Contains("Sun —"); + await Assert.That(html).Contains("read as text — 7 rows"); + await Assert.That(html).Contains("<th scope=\"row\">Mon</th>"); + await Assert.That(html).Contains("<th scope=\"row\">Sun</th>"); + await Assert.That(html).Contains("Players on by day, in UTC."); + } + + [Test] + public async Task ThePlainSurfaceSaysTheSameThingAboutASparselyMeasuredGame() + { + // Plain mode is the mirror people actually rely on, so a change that removes a graphic has + // to reach it too — otherwise the two surfaces disagree about how much was measured. + var page = await new FixtureGameQueries().FindAsync("gaslight-row"); + var text = Render.Words(PlainText.Render(page!, Now)); + + await Assert.That(text).Contains("The grid appears once every day of the week has one."); + await Assert.That(text).DoesNotContain("Mon —"); } [Test] @@ -129,7 +476,7 @@ public async Task TheSentenceNamesUnmeasuredAndUncountableHoursSeparately() // The design's own specimen sentence says only "could not be measured", which covers both. // They are different facts about a game and the summary keeps them apart — an hour nobody // has a measurement for, and an hour we reached and could not count. - var sentence = ActivitySummary.Sentence(FixtureActivity()); + var sentence = ActivitySummary.Sentence(English, FixtureActivity()); await Assert.That(sentence).Contains("have no measurement yet"); await Assert.That(sentence).Contains("answered but produced no count"); @@ -143,7 +490,7 @@ public async Task AGameCountedAtZeroAllWeekIsNotDescribedAsUnmeasured() .SelectMany(d => Enumerable.Range(0, 24).Select(h => new ActivityCell(d, h, 0, Probed: true))) .ToList(); - var sentence = ActivitySummary.Sentence(cells); + var sentence = ActivitySummary.Sentence(English, cells); await Assert.That(sentence).Contains("Measured every hour"); await Assert.That(sentence).DoesNotContain("not reachable"); diff --git a/tests/MUI.Web.Tests/TimeSurfaceTests.cs b/tests/MUI.Web.Tests/TimeSurfaceTests.cs new file mode 100644 index 0000000..32c7407 --- /dev/null +++ b/tests/MUI.Web.Tests/TimeSurfaceTests.cs @@ -0,0 +1,436 @@ +using System.Globalization; + +using MUI.Catalog; +using MUI.Web.Components; +using WebProvenance = MUI.Web.Components.Provenance; +using MUI.Web.Localization; + +namespace MUI.Web.Tests; + +/// <summary> +/// One date format, one age ladder, and an age a reader can resolve to a time — in any language. +/// </summary> +/// <remarks> +/// <para> +/// The site printed three absolute formats — <c>2026-08-17</c> on a game page, <c>31 July 2026</c> +/// in the rankings, <c>Aug 2026</c> beside an address — and its relative ages carried no absolute +/// value at all, so a reader arriving from a cached page or a search result could not tell what +/// "19m ago" was 19 minutes before. +/// </para> +/// <para> +/// Then it printed the one format under <see cref="CultureInfo.InvariantCulture"/>, which is the +/// same defect wearing a different hat: a German page said <c>30 Jul 2026</c>, and the month name +/// was not in any file a translator is ever sent. These now assert the fact through the bundle +/// rather than the English literal, because a literal passes on the day the German is wrong. +/// </para> +/// </remarks> +public class TimeSurfaceTests +{ + private static readonly DateTimeOffset Now = new(2026, 8, 17, 14, 21, 0, TimeSpan.Zero); + + private const string English = Locales.SourceTag; + private const string German = "de"; + + /// <summary> + /// The locales that claim to be languages. + /// </summary> + /// <remarks> + /// The pseudolocale accents every letter it is handed, so it renders UTC as ÚTÇ and MSSP inside + /// brackets. That is the pseudolocale doing its one job — proving a string came through the + /// pipeline — and it is never offered to a reader, so it is not the thing these two assert on. + /// </remarks> + private static IEnumerable<Locale> Languages => + Locales.All.Where(l => l.Status is not LocaleStatus.TestOnly); + + [Test] + public async Task ThereIsOneAbsoluteFormatAndItNamesItsZone() + { + var at = new DateTimeOffset(2026, 8, 17, 14, 2, 0, TimeSpan.Zero); + + await Assert.That(Dates.Absolute(English, at)).IsEqualTo("17 Aug 2026"); + await Assert.That(Dates.Stamp(English, at)).IsEqualTo("17 Aug 2026 14:02 UTC"); + await Assert.That(Dates.Machine(at)).IsEqualTo("2026-08-17T14:02:00Z"); + } + + /// <summary> + /// The month is CLDR's, not an array here and not the invariant culture's. + /// </summary> + /// <remarks> + /// The same finding as the heatmap's seven English day names, one file over: no translator could + /// have fixed <c>Jul</c> on a German page, because the word was never in a file they are sent. + /// July is the case worth pinning — German writes <c>Juli</c> in a date and .NET's *standalone* + /// abbreviation is the legacy <c>Jul</c>, so a plausible-looking call to + /// <c>GetAbbreviatedMonthName</c> would leave this passing in English and wrong in German. + /// </remarks> + [Test] + public async Task AGermanPageNamesTheMonthInGerman() + { + var july = new DateTimeOffset(2026, 7, 30, 18, 0, 0, TimeSpan.Zero); + + // The word, not the whole string: the order of the three parts is `date.absolute`'s to + // decide, and German's translation of it supplies the ordinal point that English has no use + // for — "30. Juli 2026". Pinning the assembled sentence here would have made a correct + // translation fail, which is the test asserting its own English word order as if it were a + // fact about dates. + await Assert.That(Dates.Absolute(German, july)).Contains("Juli"); + await Assert.That(Dates.Absolute(German, july)).Contains("30"); + await Assert.That(Dates.Absolute(German, july)).Contains("2026"); + await Assert.That(Dates.Absolute(German, july)).DoesNotContain("Jul "); + + // The stamp is the date with the clock on it, in whatever order that locale puts them. + await Assert.That(Dates.Stamp(German, july)).Contains(Dates.Absolute(German, july)); + await Assert.That(Dates.Stamp(German, july)).Contains("18:00"); + await Assert.That(Dates.Stamp(German, july)).Contains("UTC"); + + await Assert.That(Dates.Absolute(German, july)).IsNotEqualTo(Dates.Absolute(English, july)); + } + + /// <summary>Every month of the year, and not one of them still in English.</summary> + /// <remarks> + /// One month passing is a coincidence — <c>Feb</c>, <c>Aug</c> and <c>Sep</c> are nearly the + /// same word in both languages, and the sweep that found this was run against a fixture whose + /// dates are all in July. Walking twelve is what proves the name came out of CLDR rather than + /// out of a lucky abbreviation. + /// </remarks> + [Test] + public async Task NoMonthOfTheGermanYearComesBackInEnglish() + { + for (var month = 1; month <= 12; month++) + { + var at = new DateTimeOffset(2026, month, 15, 9, 0, 0, TimeSpan.Zero); + + await Assert.That(Dates.Absolute(German, at)) + .IsNotEqualTo(Dates.Absolute(English, at)) + .Because($"month {month} reads the same in German as in English"); + } + } + + /// <summary> + /// UTC is a zone and not a word, and the clock is the site's rather than the locale's. + /// </summary> + /// <remarks> + /// Every time here is UTC because a crawler's clock is the only one it has. A locale that + /// rendered <c>2:02 PM</c>, or one that translated the suffix, would be describing a different + /// instant to a reader who has no way to tell. + /// </remarks> + [Test] + public async Task TheZoneIsNamedInEveryLanguageAndTheClockDoesNotMove() + { + var at = new DateTimeOffset(2026, 8, 17, 14, 2, 0, TimeSpan.Zero); + + foreach (var locale in Languages) + { + var stamp = Dates.Stamp(locale.Tag, at); + + await Assert.That(stamp).Contains("14:02").Because($"{locale.Tag} moved the clock"); + await Assert.That(stamp).Contains("UTC").Because($"{locale.Tag} lost the zone"); + } + } + + [Test] + public async Task TheAgeLadderRunsMinutesToNinetyThenHoursToFortyEight() + { + await Assert.That(Relative.Format(English, TimeSpan.FromSeconds(30))).IsEqualTo("now"); + await Assert.That(Relative.Format(English, TimeSpan.FromMinutes(84))).IsEqualTo("84m"); + await Assert.That(Relative.Format(English, TimeSpan.FromMinutes(95))).IsEqualTo("1h"); + await Assert.That(Relative.Format(English, TimeSpan.FromHours(47))).IsEqualTo("47h"); + await Assert.That(Relative.Format(English, TimeSpan.FromHours(49))).IsEqualTo("2d"); + } + + /// <summary> + /// Every rung of every family is a real ICU plural, with the branches its language has. + /// </summary> + /// <remarks> + /// <para> + /// <c>n + "w ago"</c> is a sentence assembled in English word order with nowhere for a + /// translator to stand. The rungs are patterns instead, so a language selects its own category + /// — and this walks every locale the site names against the CLDR rules it transcribes, because + /// a pattern that parses in English can still be missing the branch Russian needs. + /// </para> + /// <para> + /// <c>other</c> is mandatory everywhere, including in Japanese and Chinese, which have nothing + /// else. A branch keyword a language does not have is rejected rather than ignored. + /// </para> + /// </remarks> + [Test] + public async Task EveryRungIsAPluralWithTheCategoriesItsLanguageActuallyHas() + { + string[] families = ["age.short", "age.ago", "age.dark"]; + string[] rungs = ["now", "minutes", "hours", "days", "weeks", "months", "years"]; + + foreach (var family in families) + { + foreach (var rung in rungs) + { + var id = family + "." + rung; + + await Assert.That(Messages.Source(id)) + .IsNotNull() + .Because($"{id} is not in the English bundle"); + + foreach (var locale in Locales.All) + { + foreach (var count in new[] { 0, 1, 2, 5, 11, 21, 101 }) + { + var said = Messages.For( + locale.Tag, + id, + new Dictionary<string, object?>(StringComparer.Ordinal) { ["count"] = count }); + + await Assert.That(string.IsNullOrWhiteSpace(said)) + .IsFalse() + .Because($"{locale.Tag} said nothing for {id} at {count}"); + } + } + } + } + } + + /// <summary> + /// The number reaches the pattern, so a language can put it where it belongs. + /// </summary> + [Test] + public async Task ThePluralPrintsTheNumberItWasGiven() + { + await Assert.That(Relative.Format(English, TimeSpan.FromDays(21))).IsEqualTo("3w"); + await Assert.That(Relative.Ago(English, TimeSpan.FromDays(21))).IsEqualTo("3w ago"); + await Assert.That(Relative.Format(English, TimeSpan.FromDays(400))).IsEqualTo("13mo"); + await Assert.That(Relative.Ago(English, TimeSpan.FromDays(1200))).IsEqualTo("3y ago"); + } + + /// <summary> + /// "How fresh is this measurement" and "how long has this game been dark" are two questions. + /// </summary> + /// <remarks> + /// English answers both with "2w ago" and several languages will not. The ids are separate so a + /// translator can reach each one at all — collapsing them because the source language cannot + /// tell them apart is how three cases in four end up ungrammatical. + /// </remarks> + [Test] + public async Task AFreshMeasurementAndADarkGameAreTwoIdsEvenWhereTheEnglishIsOne() + { + var age = TimeSpan.FromDays(14); + + await Assert.That(Relative.Ago(English, age, AgeSense.Confirmed)) + .IsEqualTo(Relative.Ago(English, age, AgeSense.Reached)); + + string[] rungs = ["now", "minutes", "hours", "days", "weeks", "months", "years"]; + + foreach (var rung in rungs) + { + await Assert.That(Messages.Source("age.ago." + rung)).IsNotNull(); + await Assert.That(Messages.Source("age.dark." + rung)).IsNotNull(); + } + } + + /// <summary> + /// The dark register never names a cause, in any language. + /// </summary> + /// <remarks> + /// We measured a socket from one vantage point at intervals. A game with a routing problem to + /// our host is unreachable and perfectly alive, and "offline" would file our vantage point as a + /// fact about their game (rule 5). + /// </remarks> + [Test] + public async Task ADarkGameIsNeverCalledOfflineOrDown() + { + foreach (var locale in Locales.All) + { + foreach (var rung in new[] { "now", "hours", "weeks", "years" }) + { + var said = Messages.For( + locale.Tag, + "age.dark." + rung, + new Dictionary<string, object?>(StringComparer.Ordinal) { ["count"] = 3 }) + .ToLowerInvariant(); + + foreach (var cause in new[] { "offline", "down", "uptime", "crashed", "dead" }) + { + await Assert.That(said).DoesNotContain(cause); + } + } + } + } + + [Test] + public async Task AnAgeCarriesTheInstantItIsRelativeTo() + { + var html = await Render.ComponentAsync<Moment>(new() + { + ["At"] = new DateTimeOffset(2026, 8, 17, 14, 2, 0, TimeSpan.Zero), + ["Now"] = Now, + }); + + await Assert.That(html).Contains("<time datetime=\"2026-08-17T14:02:00Z\""); + await Assert.That(html).Contains("title=\"19m ago, 17 Aug 2026 14:02 UTC\""); + await Assert.That(Render.Words(html)).Contains(">19m</time>"); + } + + [Test] + public async Task TheAbsoluteTimeIsSpokenWhereAReaderIsWeighingOneFactAndNotWhereTheyAreScanning() + { + // A listing row that announced the absolute time of every age would be the wall of + // repetition this whole pass exists to remove; a game page's field, where the age is the + // fact being weighed, is exactly where it belongs. + var parameters = new Dictionary<string, object?> + { + ["At"] = new DateTimeOffset(2026, 8, 17, 14, 2, 0, TimeSpan.Zero), + ["Now"] = Now, + }; + + var scanning = await Render.ComponentAsync<Moment>(parameters); + var weighing = await Render.ComponentAsync<Moment>( + new(parameters) { ["Spoken"] = true }); + + await Assert.That(scanning).DoesNotContain("sr-only"); + await Assert.That(Render.Words(weighing)).Contains("17 Aug 2026 14:02 UTC"); + } + + /// <summary> + /// Which of the age and the instant comes first is a language's decision. + /// </summary> + /// <remarks> + /// It was a comma in an interpolated string, which is a word order chosen for English and + /// offered to nobody else. + /// </remarks> + [Test] + public async Task TheTitleIsAMessageAndNotAComma() + { + await Assert.That(Messages.Source("time.title")).IsEqualTo("{age}, {stamp}"); + + var said = Messages.For( + English, + "time.title", + new Dictionary<string, object?>(StringComparer.Ordinal) + { + ["age"] = Relative.Ago(English, TimeSpan.FromMinutes(19)), + ["stamp"] = Dates.Stamp(English, new DateTimeOffset(2026, 8, 17, 14, 2, 0, TimeSpan.Zero)), + }); + + await Assert.That(said).IsEqualTo("19m ago, 17 Aug 2026 14:02 UTC"); + } + + /// <summary> + /// <b>MSSP, not <c>Mssp</c>.</b> + /// </summary> + /// <remarks> + /// The chip's tooltip interpolated <see cref="FieldSource"/> straight into a sentence and told + /// readers a value arrived "via Mssp" — an acronym mis-cased by C#'s naming convention, in a + /// string no translator could reach. Upper-casing at the call site would have fixed four letters + /// and left the next member to leak the same way, which is what the exhaustive map prevents. + /// </remarks> + [Test] + public async Task AProtocolAcronymIsSpeltAsTheProtocolSpellsIt() + { + await Assert.That(WebProvenance.Via(English, FieldSource.Mssp)).IsEqualTo("MSSP"); + await Assert.That(WebProvenance.Via(English, FieldSource.Who)).IsEqualTo("WHO"); + await Assert.That(WebProvenance.Via(English, FieldSource.Info)).IsEqualTo("INFO"); + await Assert.That(WebProvenance.Via(English, FieldSource.I3)).IsEqualTo("I3"); + + // And an acronym is the same acronym in every language: it is evidence, not a word. + foreach (var locale in Languages) + { + await Assert.That(WebProvenance.Via(locale.Tag, FieldSource.Mssp)) + .IsEqualTo("MSSP") + .Because($"{locale.Tag} translated a protocol name"); + } + } + + /// <summary>Every source has a display name, and none of them is the enum member.</summary> + [Test] + public async Task NoFieldSourceReachesAReaderAsItsEnumMember() + { + foreach (var source in Enum.GetValues<FieldSource>()) + { + var shown = WebProvenance.Via(English, source); + + await Assert.That(string.IsNullOrWhiteSpace(shown)) + .IsFalse() + .Because($"{source} has no display name"); + + // I3 is the one member whose C# spelling is already the reader's — an initial and a + // digit, with no casing for PascalCase to get wrong. Every other member's ToString + // would be a defect on the page: Mssp for an acronym, Who for a command, I3Mudlist for + // two words and a missing space. + if (source is FieldSource.I3) + { + continue; + } + + await Assert.That(shown) + .IsNotEqualTo(source.ToString()) + .Because($"{source} is reaching the page as its own C# spelling"); + } + } + + /// <summary> + /// The chip's tooltip, whole: machine voice through, our words from the bundle. + /// </summary> + /// <remarks> + /// "last confirmed" is the load-bearing phrase and it is a fact about our crawl. It is the day + /// <em>we</em> last saw the value, and it must never be read as a day the game did anything. + /// </remarks> + [Test] + public async Task TheChipTooltipSaysTheSourceTheDateAndWhoseFactTheDateIs() + { + var confirmed = new DateTimeOffset(2026, 7, 30, 18, 0, 0, TimeSpan.Zero); + + var english = Messages.For( + English, + "chip.title", + new Dictionary<string, object?>(StringComparer.Ordinal) + { + ["value"] = "PennMUSH 1.8.8p0", + ["how"] = Messages.For(English, "provenance.game.declared"), + ["source"] = WebProvenance.Via(English, FieldSource.Mssp), + ["date"] = Dates.Stamp(English, confirmed), + }); + + await Assert.That(english) + .IsEqualTo("PennMUSH 1.8.8p0 — declared via MSSP, last confirmed 30 Jul 2026 18:00 UTC"); + + // The same tooltip asked for in German is not the same string. It was, and that is the + // defect this pass exists to close. + var german = Messages.For( + German, + "chip.title", + new Dictionary<string, object?>(StringComparer.Ordinal) + { + ["value"] = "PennMUSH 1.8.8p0", + ["how"] = Messages.For(German, "provenance.game.declared"), + ["source"] = WebProvenance.Via(German, FieldSource.Mssp), + ["date"] = Dates.Stamp(German, confirmed), + }); + + await Assert.That(german).IsNotEqualTo(english); + await Assert.That(german).Contains("MSSP"); + await Assert.That(german).Contains("PennMUSH 1.8.8p0"); + } + + /// <summary> + /// Measured, declared and owner-declared stay three words in every locale. + /// </summary> + /// <remarks> + /// The provenance tooltip is the string that says which of the two a reader is looking at, so + /// collapsing them into one word is the one failure that makes this site say something false. + /// </remarks> + [Test] + public async Task TheChipNeverCollapsesMeasuredAndDeclaredIntoOneWord() + { + string[] ids = + [ + "provenance.game.measured", + "provenance.game.declared", + "provenance.game.ownerDeclared", + ]; + + foreach (var locale in Locales.All) + { + var said = ids.Select(id => Messages.For(locale.Tag, id)).ToList(); + + await Assert.That(said.Distinct(StringComparer.Ordinal).Count()) + .IsEqualTo(ids.Length) + .Because($"{locale.Tag} said the same word for two different claims"); + } + } +}