@moood/check 0.0.0-stage → 0.1.0

package/i18n/i18n.js

@@ -0,0 +1,148 @@
+// Languages: one rule for every text a person reads or hears. The source
+// language is English (MooodI18n.source — languages.json's first, as the services and check read it); the text is
+// written where it is used, as a literal —
+//   tr('The sea is still asleep.')                 a text
+//   tr('Hello, {name}', { name })                  with what goes into it ({name}: from the object)
+//   tr.n(count, '{n} hour', '{n} hours')           as many as count ({n} — count): the forms are the source
+//                                                  language's one and other; a translation has its own language's
+//                                                  (Intl.PluralRules: one, few, many, other…)
+//   tr.c('the toy, not the real one', 'Ship')      the same text meaning another thing (its context — to the
+//                                                  translator too)
+//   tr.said(who, text)                             a line someone says (say, think) in the language: who tells apart
+//                                                  what is the same text in the source but not in another (the
+//                                                  runtime's: say and think say it so)
+//   tr.line(who, text, {how}), tr.thought(…)     a line kept to be said later (a list of answers, an ending's
+//                                                  lines) — aloud (say) or thought (think): {text — it as written,
+//                                                  how — its own manner (English, never translated), or ''} — say/think
+//                                                  translate it; marked so that it is found, and how it is heard
+//                                                  (gettext's N_)
+// — and a translation of it, in a language's file, is found by it: no translation is an error (fail-fast), never
+// the source shown instead. The source language itself needs no file. A file's entries (check writes them):
+//   {"text": "…", "plural"?: "…", "context"?: "…", "who"?: "…", "translation": "…" | {"one": "…", "few": "…", …},
+//    "where"?: "…", "note"?: "…"}
+// The pseudo-language (PSEUDO) is every text of the source made strange but readable: a page in it shows at once
+// what is not through tr — it reads as plain English.
+// A classic script: it sets globalThis.MooodI18n (a page's script, a worker's importScripts, a module's import).
+(() => {
+  const PSEUDO = 'qps';
+  // (gettext's: context, then the text; a line's — whose it is, then the text, apart from any context)
+  const SEP = '\u0004', WHO = '\u0005';
+  const keyOf = (context, text, who) => (who ? `${who}${WHO}${text}` : context ? `${context}${SEP}${text}` : text);
+  // (a line kept: tr.line, tr.thought — said later, by say/think)
+  const kept = (who, text, { how = '' } = {}) => ({ text, how });
+
+  // what goes into a text: {name} — params.name (none given — an error: a text says what it needs)
+  function fill(text, params, where) {
+    return text.replace(/\{(\w+)\}/g, (_, name) => {
+      if (!params || !(name in params)) throw new Error(`${where}: "${text}" needs {${name}}`);
+      return String(params[name]);
+    });
+  }
+
+  const ACCENTS = { a: 'á', b: 'ƀ', c: 'ç', d: 'ð', e: 'é', f: 'ƒ', g: 'ĝ', h: 'ĥ', i: 'î', j: 'ĵ', k: 'ķ', l: 'ļ', m: 'ɱ',
+    n: 'ñ', o: 'ö', p: 'þ', q: 'ǫ', r: 'ŕ', s: 'š', t: 'ţ', u: 'û', v: 'ṽ', w: 'ŵ', x: 'ẋ', y: 'ý', z: 'ž', A: 'Å', B: 'Ɓ',
+    C: 'Ç', D: 'Ð', E: 'É', F: 'Ƒ', G: 'Ĝ', H: 'Ĥ', I: 'Î', J: 'Ĵ', K: 'Ķ', L: 'Ļ', M: 'Ṁ', N: 'Ñ', O: 'Ö', P: 'Þ', Q: 'Ǫ',
+    R: 'Ŕ', S: 'Š', T: 'Ţ', U: 'Û', V: 'Ṽ', W: 'Ŵ', X: 'Ẋ', Y: 'Ý', Z: 'Ž' };
+  // a source text made strange: its letters accented (not what goes into it, {name}), a third longer, in brackets
+  function pseudo(text) {
+    const strange = text.split(/(\{\w+\})/).map((part, i) => (i % 2 ? part : part.replace(/[A-Za-z]/g, c => ACCENTS[c]))).join('');
+    return `⟦${strange}${'~'.repeat(Math.ceil(text.length / 3))}⟧`;
+  }
+
+  // A language's translator: lang — its code; entries — its files' entries, all of what the text comes from (a scene's
+  // with its modules'); where — what is translated (said in an error). The source language and the pseudo-language
+  // need no entries.
+  function translator(lang, entries = [], where = 'text') {
+    const source = lang === MooodI18n.source, strange = lang === PSEUDO;
+    const found = new Map();
+    for (const e of entries) {
+      const key = keyOf(e.context, e.text, e.who);
+      if (found.has(key)) throw new Error(`${where}: "${e.text}" is translated twice`);
+      found.set(key, e.translation);
+    }
+    const rules = new Intl.PluralRules(source || strange ? MooodI18n.source : lang);
+    const lookup = (context, text, who) => {
+      const t = found.get(keyOf(context, text, who));
+      if (t == null || t === '') throw new Error(`${where}: no ${lang} translation of "${text}"${who || context ? ` (${who || context})` : ''}`);
+      return t;
+    };
+    const one = (context, text, params, who) => {
+      if (source) return fill(text, params, where);
+      if (strange) return fill(pseudo(text), params, where);
+      const t = lookup(context, text, who);
+      if (typeof t !== 'string') throw new Error(`${where}: the ${lang} translation of "${text}" is not one text`);
+      return fill(t, params, where);
+    };
+    const tr = (text, params) => one(null, text, params);
+    tr.c = (context, text, params) => one(context, text, params);
+    tr.said = (who, text) => one(null, text, null, who);
+    tr.line = tr.thought = kept;
+    tr.n = (count, singular, plural, params) => {
+      const all = { n: count, ...params }, form = rules.select(count);
+      if (source) return fill(form === 'one' ? singular : plural, all, where);
+      if (strange) return fill(pseudo(form === 'one' ? singular : plural), all, where);
+      const t = lookup(null, singular);
+      if (typeof t !== 'object' || !t[form]) throw new Error(`${where}: no ${lang} "${form}" form of "${singular}"`);
+      return fill(t[form], all, where);
+    };
+    tr.lang = lang;
+    return tr;
+  }
+
+  // What of a JSON file is read or heard — translated (check finds them; a page shows them translated): by the file's
+  // name, [path] (a.b: b of a; a[].b: b of each of a's; *.b: b of each of an object's values)
+  const FIELDS = {
+    'scene.json': ['title', 'description', 'caption', 'captions[].text'],
+    'world.json': ['title', 'description'],
+    'game.json': ['title', 'description', 'line', 'source'],
+    'people.json': ['*.short'],
+  };
+
+  // A widget's markup (or a page's): its texts — between tags (not a script's or a style's: a script is code; not a
+  // page's head: what a page is called its code says), and the attributes that are read (TEXTUAL) — each said once,
+  // its spaces as one; and the markup with each text translated (tr).
+  const TEXTUAL = /(\s(?:title|alt|placeholder|aria-label)=)("[^"]*"|'[^']*')/g;
+  // (each stretch of markup as if between two tags: a text it begins or ends with is one too)
+  function walkMarkup(html, fn) {
+    return html.split(/(<script\b[\s\S]*?<\/script>|<style\b[\s\S]*?<\/style>|<head\b[\s\S]*?<\/head>|<!--[\s\S]*?-->)/i).map((part, i) => (i % 2 ? part
+      : `>${part}<`.replace(/(>)([^<]+)(<)/g, (m, a, text, b) => (/\p{L}/u.test(text) ? a + fn(text) + b : m))
+        .replace(TEXTUAL, (m, a, quoted) => (/\p{L}/u.test(quoted) ? a + quoted[0] + fn(quoted.slice(1, -1)) + quoted[0] : m)).slice(1, -1))).join('');
+  }
+  const clean = text => text.replace(/\s+/g, ' ').trim();
+  function markupTexts(html) {
+    const out = [];
+    walkMarkup(html, text => { out.push(clean(text)); return text; });
+    return out;
+  }
+  // (the spaces round a text kept: it is laid out as it was)
+  const markup = (html, tr) => walkMarkup(html, text => text.replace(/^(\s*)[\s\S]*?(\s*)$/, (m, a, b) => a + tr(clean(text)) + b));
+
+  // A scene's spec as a page shows it: what of it is read translated (FIELDS: its title, caption, captions; its
+  // widgets' markup) — for the page only: the engine is given the spec as it is written. (Its elements' names are the
+  // artist's: written in the source language, not translated.)
+  function shown(spec, tr) {
+    if (!spec || typeof spec !== 'object') return spec;
+    const t = v => (typeof v === 'string' && v.trim() ? tr(v) : v), list = v => (Array.isArray(v) ? v : null);
+    return { ...spec, title: t(spec.title), description: t(spec.description), caption: t(spec.caption),
+      captions: list(spec.captions)?.map(c => (c && typeof c === 'object' ? { ...c, text: t(c.text) } : c)) ?? spec.captions,
+      widgets: list(spec.widgets)?.map(w => (w && typeof w.html === 'string' ? { ...w, html: markup(w.html, tr) } : w)) ?? spec.widgets };
+  }
+
+  // A scene's code (its lib, an element's, a script, a widget's — a text) made into a function of params with `tr` — the
+  // translator of its texts — in reach: tr is the language's, not a parameter the code is called with.
+  const bind = (tr, params, body) => new Function('tr', `return function (${params}) {\n${body}\n};`)(tr);
+
+  // The words of a part of moood's pages that a page loads as plain scripts (an engine: engine1, engine3): part(name)
+  // — its tr, the language the page said (said(name, tr) — words.js speak; tr.lang: that language); a text asked before
+  // that is an error.
+  const parts = {};
+  const part = name => {
+    const said = () => parts[name] ?? (() => { throw new Error(`${name}: its words asked before the page said its language`); })();
+    const tr = Object.assign((...a) => said()(...a), { n: (...a) => said().n(...a), c: (...a) => said().c(...a), line: kept, thought: kept });
+    return Object.defineProperty(tr, 'lang', { get: () => said().lang });
+  };
+  const said = (name, tr) => { parts[name] = tr; };
+
+  const MooodI18n = { source: 'en', PSEUDO, keyOf, translator, FIELDS, markupTexts, markup, shown, bind, part, said };
+  globalThis.MooodI18n ??= MooodI18n;  // (loaded twice — a page's script and a module's import: one, the first)
+})();

package/i18n/languages.json

@@ -0,0 +1,4 @@
+{
+  "en": { "name": "English", "locale": "en_US" },
+  "ru": { "name": "Русский", "locale": "ru_RU" }
+}

package/i18n/words.js

@@ -0,0 +1,33 @@
+// A part of moood's pages (a folder of them: play/, scene/, an engine) in a language: its texts' translations lie beside
+// its code (lang/<lang>.json — check lays them out), read once a page.
+//   words(base, lang) → its translator (i18n.js: tr, tr.n, tr.c) — base: the part's folder (a URL: new URL('./',
+//   import.meta.url) of a module in it); the source language and the pseudo-language need no file.
+import './i18n.js';
+
+const { MooodI18n } = globalThis;
+
+export async function words(base, lang) {
+  if (lang === MooodI18n.source || lang === MooodI18n.PSEUDO) return MooodI18n.translator(lang, [], String(base));
+  const r = await fetch(new URL(`lang/${lang}.json`, base));
+  if (!r.ok) throw new Error(`${base}: no ${lang} translation (${r.status})`);
+  return MooodI18n.translator(lang, (await r.json()).strings || [], String(base));
+}
+
+// The engines' words (MooodI18n.part('engine1'), part('engine3') — each its folder's lang/: engines/1, engines/3) in the
+// page's language, before they are asked for.
+export async function speak(lang) {
+  for (const n of [1, 3]) MooodI18n.said(`engine${n}`, await words(new URL(`../engines/${n}/`, import.meta.url), lang));
+}
+
+// The languages moood speaks ({code: {name — in itself, locale}}, the source language first: languages.json).
+export const languages = async () => (await fetch(new URL('./languages.json', import.meta.url))).json();
+
+// The language a page without one in its address is shown in, as this browser has it: the person's choice (the cookie
+// a switch of language sets — their profile's, once they sign in; the pseudo-language too, set by hand), else what the
+// browser asks for, else the source.
+export function chosen(list) {
+  const cookie = /(?:^|;\s*)lang=([^;]+)/.exec(document.cookie)?.[1];
+  if (cookie in list || cookie === MooodI18n.PSEUDO) return cookie;
+  for (const l of navigator.languages || []) if (l.toLowerCase().split('-')[0] in list) return l.toLowerCase().split('-')[0];
+  return MooodI18n.source;
+}

package/index.js

@@ -0,0 +1,181 @@
+// A repository checked (scopes.js — its worlds, games and articles, where their texts come from, where their
+// translations lie; extract.js — what a file says): what the repository says of itself (scopes.js), and every text
+// found translated into every language its world, game or article says it is in but the source (i18n/languages.json:
+// the first) — the forms its plural needs in each, the same {names} in a translation as in its text, nothing translated
+// that the code no longer says; a game's data the same files in every language; an article's whole text in each. write:
+// each language's file laid out anew from what the code says now — in the code's order, one entry a line, what was
+// translated kept (by its text), what is new to translate empty, what the code no longer says gone (git diff shows it,
+// to carry over by hand); an article is translated by hand. A scene's engine one there is (3, or 1); its music as a
+// host makes it (engines/1/music.js: within LIMITS).
+import { problem } from './problems/problems.js';
+import { LANGUAGES, scopes } from './scopes.js';
+import './i18n/i18n.js';
+import './engines/1/music.js';
+
+const { keyOf } = globalThis.MooodI18n;
+export { LANGUAGES };
+const SOURCE = LANGUAGES[0];
+
+const names = text => [...text.matchAll(/\{(\w+)\}/g)].map(m => m[1]).sort().join(',');
+// (a line's inline tags — <sigh>, <short pause> —: how its voice says it there, in English, the same in every language)
+const tags = text => [...text.matchAll(/<[^<>\n]*>/g)].map(m => m[0]).sort().join(' ');
+const PERSON = new Set(['voice', 'how', 'short']);
+const others = text => [...new Set(names(text).split(',').filter(k => k && k !== 'n'))].join(',');  // (a plural's: all but its {n})
+const formsOf = lang => new Intl.PluralRules(lang).resolvedOptions().pluralCategories;
+
+// the scope's entries, each text once (its first place), in the code's order
+function unique(entries) {
+  const seen = new Map();
+  for (const e of entries) {
+    const key = keyOf(e.context, e.text, e.who);
+    if (!seen.has(key)) seen.set(key, e);
+  }
+  return seen;
+}
+
+// a language's file: its entries by key (null: there is none; undefined: it is not a translation's file — its problem
+// said, and it is left as it is: never laid out anew over what is in it)
+async function readLang(source, path, problems) {
+  const text = await source.read(path);
+  if (text === null) return null;
+  try {
+    const data = JSON.parse(text);
+    if (!Array.isArray(data?.strings ?? [])) { problems.push(problem(path, 'not-strings')); return undefined; }
+    const had = new Map();
+    for (const e of data.strings || []) {
+      const key = keyOf(e.context, e.text, e.who);
+      // (twice — a merge's, as a rule: the page's translator refuses the whole file; --write keeps one)
+      if (had.has(key)) problems.push(problem(path, 'translated-twice', { text: e.text }));
+      had.set(key, e);
+    }
+    return had;
+  } catch (e) {
+    problems.push(problem(path, 'json', { error: e.message }));
+    return undefined;
+  }
+}
+
+// one entry a line: a translator's change, an author's new text — a line each in a diff, and no two branches touch the same
+function writeLang(source, path, entries) {
+  return source.write(path, entries.length ? `{"strings": [\n${entries.map(e => `  ${JSON.stringify(e)}`).join(',\n')}\n]}\n` : '{"strings": []}\n');
+}
+
+// An article (article.json — its title, its date, its summary —, story.md beside it): in each language it is in but the
+// source, article.<lang>.json with its title (and its summary, if it has one) and story.<lang>.md
+async function article(source, a, problems) {
+  const name = `${a.base}article.json`, text = p => source.read(p);
+  if (!a.json) return;
+  if (!a.json.title || !a.json.date) problems.push(problem(name, 'article-title'));
+  if (!(await text(`${a.base}story.md`))?.trim()) problems.push(problem(`${a.base}story.md`, 'article-story'));
+  for (const lang of (a.languages || []).filter(l => l !== SOURCE)) {
+    const path = `${a.base}article.${lang}.json`, t = await text(path);
+    let m = null;
+    try { m = t === null ? null : JSON.parse(t); } catch (e) { problems.push(problem(path, 'json', { error: e.message })); continue; }
+    if (!m?.title) problems.push(problem(path, t === null ? 'article-none' : 'article-no-title', { lang }));
+    else if (a.json.summary && !m.summary) problems.push(problem(path, 'article-no-summary'));
+    if (!(await text(`${a.base}story.${lang}.md`))?.trim()) problems.push(problem(`${a.base}story.${lang}.md`, 'article-story-lang', { lang }));
+  }
+}
+
+// The engine a scene says (scene.json's "engine"): 3 — every new scene's; none (or 1) — the old one's. Engine 2 is gone.
+function engine(spec, at) {
+  const e = spec?.engine;
+  if (e === undefined || e === 1 || e === 3) return [];
+  return [problem(at, e === 2 ? 'engine-gone' : 'engine', { engine: JSON.stringify(e) })];
+}
+
+// A scene's music (scene.json's "music") as its page asks a host for it (MooodMusic.asked: the descriptions that sound,
+// the settings) — what a host making it with Lyria takes (LIMITS), or the problems of what it does not
+function music(spec, at) {
+  const { LIMITS } = globalThis.MooodMusic, m = globalThis.MooodMusic.asked(spec?.music), out = [];
+  if (!m) return out;
+  if (m.prompts.length > LIMITS.prompts) out.push(problem(at, 'music-prompts', { count: m.prompts.length, most: LIMITS.prompts }));
+  m.prompts.forEach((p, i) => { if (p.text.length > LIMITS.text) out.push(problem(at, 'music-text', { n: i + 1, length: p.text.length, most: LIMITS.text })); });
+  for (const [field, [least, most]] of Object.entries(LIMITS.ranges)) {
+    if (field in m.config && !(m.config[field] >= least && m.config[field] <= most)) out.push(problem(at, 'music-range', { field, value: m.config[field], least, most }));
+  }
+  if ('scale' in m.config && !LIMITS.scales.includes(m.config.scale)) out.push(problem(at, 'music-scale', { scale: m.config.scale, scales: LIMITS.scales.join(', ') }));
+  return out;
+}
+
+// A repository read through its source (repository.js) → {problems: [{at, code, values}] (problems/problems.js), scopes: [{name, kind, languages, entries,
+// said}]} — said: the lines heard (who, text, said: 'say' | 'think', voice? — a scene's, how? — a game's line's own); write — each language's file laid out
+// anew (a source that writes: a folder)
+export async function check(source, { write = false } = {}) {
+  const all = await scopes(source), problems = [...all.problems], out = [];
+  for (const a of all.articles) await article(source, a, problems);
+  for (const s of all.scopes) {
+    problems.push(...s.problems);
+    if (s.kind === 'scene') {
+      const at = `${s.name}/scene.json`;
+      let spec = null;
+      try { spec = JSON.parse(await source.read(at)); } catch { /* (none, or not JSON: said by its fields) */ }
+      problems.push(...engine(spec, at), ...music(spec, at));
+    }
+    const targets = s.languages.filter(l => l !== SOURCE);
+    const found = unique(s.entries);
+    // (the lines heard: each way it is heard once — a text said aloud and thought is one to translate, two to voice)
+    const heard = new Map(s.entries.filter(e => e.said).map(e => [JSON.stringify([e.who, e.text, e.said, e.voice ?? null, e.how ?? '']), e]));
+    out.push({ name: s.name, kind: s.kind, languages: s.languages, entries: [...found.values()], said: [...heard.values()] });
+    for (const lang of targets) {
+      const path = s.file(lang), had = await readLang(source, path, problems);
+      if (had === undefined) continue;
+      if (write) {
+        if (!found.size && !had) continue;
+        await writeLang(source, path, [...found.entries()].map(([key, e]) => {
+          const was = had?.get(key);
+          const empty = e.plural ? Object.fromEntries(formsOf(lang).map(f => [f, ''])) : '';
+          return { text: e.text, ...(e.plural ? { plural: e.plural } : {}), ...(e.context ? { context: e.context } : {}),
+            ...(e.who ? { who: e.who } : {}), translation: was?.translation ?? empty, where: e.where, ...(was?.note ? { note: was.note } : {}) };
+        }));
+        continue;
+      }
+      if (!found.size && !had) continue;
+      if (!had) { problems.push(problem(path, 'no-translations', { count: found.size, lang })); continue; }
+      for (const [key, e] of found) {
+        // (what: the text, and whose it is or its context — what tells it apart)
+        const t = had.get(key)?.translation, what = { text: e.text, ...(e.who ? { who: e.who } : e.context ? { context: e.context } : {}) };
+        if (e.plural) {
+          if (!t || typeof t !== 'object') { problems.push(problem(path, 'untranslated-forms', { ...what, forms: formsOf(lang).join(', ') })); continue; }
+          for (const f of formsOf(lang)) {
+            if (!t[f]) problems.push(problem(path, 'no-form', { ...what, form: f }));
+            // (a form says {n} or not, as its language counts — 21 час, an hour: the others, as the text's forms do)
+            else if (others(t[f]) !== others(`${e.text} ${e.plural}`)) problems.push(problem(path, 'form-names', { ...what, form: f, names: others(t[f]), wanted: others(`${e.text} ${e.plural}`) }));
+          }
+        } else if (!t || typeof t !== 'string') problems.push(problem(path, 'untranslated', what));
+        else if (names(t) !== names(e.text)) problems.push(problem(path, 'names', { ...what, names: names(t), wanted: names(e.text) }));
+        else if (e.said && tags(t) !== tags(e.text)) problems.push(problem(path, 'tags', { ...what, tags: tags(t) || '—', wanted: tags(e.text) || '—' }));
+      }
+      for (const [key, e] of had) if (!found.has(key)) problems.push(problem(path, 'unsaid', { text: e.text }));
+    }
+    // a game's people (bespoke/people.json: {who: {voice — its name, how — the manner it lasts, short — what the player
+    // reads them as}}) and its lines: each said by one of them, a thought by one with a short name (it is shown with it)
+    if (s.people) {
+      let people = {};
+      try { people = JSON.parse(await source.read(s.people)) ?? {}; } catch { /* (none, or not JSON: said by its field) */ }
+      for (const [who, p] of Object.entries(people)) {
+        if (!p || typeof p !== 'object' || Array.isArray(p)) { problems.push(problem(s.people, 'person-not-object', { who })); continue; }
+        for (const [k, v] of Object.entries(p)) {
+          if (!PERSON.has(k)) problems.push(k === 'name' ? problem(s.people, 'person-name', { who }) : problem(s.people, 'person-field', { who, field: k }));
+          else if (typeof v !== 'string') problems.push(problem(s.people, 'person-not-text', { who, field: k }));
+        }
+      }
+      for (const e of found.values()) {
+        if (!e.said) continue;
+        const at = `${e.where}:${e.line}`;
+        if (!people[e.who]) problems.push(problem(at, 'line-no-person', { text: e.text, who: e.who, people: s.people }));
+        else if (e.said === 'think' && !people[e.who].short) problems.push(problem(at, 'thought-no-short', { text: e.text, who: e.who, people: s.people }));
+      }
+    }
+    // a game's data: the same files in every language, the source's
+    if (s.data) {
+      const list = async lang => ((await source.list(`${s.data(lang)}/`)) ?? []).filter(e => e.name !== 'strings.json').map(e => e.name).sort().join(', ');
+      const own = await list(SOURCE);
+      for (const lang of targets) {
+        const theirs = await list(lang);
+        if (theirs !== own) problems.push(problem(s.data(lang), 'data', { files: theirs || '—', wanted: own || '—' }));
+      }
+    }
+  }
+  return { problems, scopes: out };
+}

package/lines.js

@@ -0,0 +1,48 @@
+// The lines heard, as they are heard in each language their world or game is in — what their voices are made of (a
+// check of a repository asks which are missing): [{scope, lang, who, said, text, voice, how}] — scope: whose line it
+// is (a game's, a scene's, a module's: check's name of it); text: what the voice says, its inline tags with it
+// (<sigh>). A game's: said by its people, in the manner they last in and the line's own (play/voices.js — the
+// runtime's own rule); a scene's or a module's: said with
+// their voice ({voice, how} — speech.js asks for it so), a line with none is not heard. A line with no translation is
+// left out (check says so). The repository is read through its source (repository.js).
+import { heard } from './play/voices.js';
+import './i18n/i18n.js';
+import { scopes } from './scopes.js';
+
+const { translator } = globalThis.MooodI18n;
+
+// a JSON file of the source (none, or not JSON: empty — check says what is wrong with it)
+async function json(source, path, empty) {
+  try { return JSON.parse(await source.read(path) ?? 'null') ?? empty; } catch { return empty; }
+}
+
+export async function lines(source, report) {
+  const found = new Map((await scopes(source)).scopes.map(s => [s.name, s])), out = [];
+  for (const r of report.scopes) {
+    const s = found.get(r.name);
+    if (s.kind === 'game') out.push(...await gameLines(source, s, r));
+    else for (const lang of s.languages) {
+      const tr = translator(lang, (await json(source, s.file(lang), {})).strings || [], s.name);
+      for (const e of r.said.filter(x => x.voice)) {
+        try { out.push({ scope: s.name, lang, who: e.who, said: e.said, text: tr.said(e.who, e.text), voice: e.voice.voice, how: e.voice.how ?? '' }); }
+        catch { /* (untranslated: check says so) */ }
+      }
+    }
+  }
+  return out;
+}
+
+async function gameLines(source, s, r) {
+  if (!r.said.length) return [];
+  const people = await json(source, s.people, {}), out = [];
+  for (const lang of s.languages) {
+    const tr = translator(lang, (await json(source, s.file(lang), {})).strings || [], 'the game');
+    for (const e of r.said) {
+      const p = people[e.who];
+      if (!p?.voice) continue;  // (no one so, or one with no voice: check says the first)
+      try { out.push({ scope: s.name, lang, who: e.who, said: e.said, ...heard(p, e.said, tr.said(e.who, e.text), e.how) }); }
+      catch { /* (untranslated: check says so) */ }
+    }
+  }
+  return out;
+}

package/package.json

@@ -1,6 +1,40 @@
-{
-  "name": "@moood/check",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+{
+  "name": "@moood/check",
+  "version": "0.1.0",
+  "description": "A moood repository checked: its worlds, games and articles (any number, at any depth), what they say of themselves and of each other, and every text a person reads or hears written as tr()/say()/think() with a literal and translated into each language they say they are in; check --write lays out the languages' files.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/moood-me/moood.git",
+    "directory": "packages/check"
+  },
+  "homepage": "https://github.com/moood-me/moood/tree/main/packages/check",
+  "type": "module",
+  "main": "index.js",
+  "bin": {
+    "moood-check": "cli.js"
+  },
+  "files": [
+    "index.js",
+    "cli.js",
+    "extract.js",
+    "scopes.js",
+    "repository.js",
+    "lines.js",
+    "problems/",
+    "i18n/",
+    "play/",
+    "engines/",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "acorn": "^8.15.0",
+    "acorn-walk": "^8.3.4"
+  },
+  "scripts": {
+    "build": "node build.js"
+  }
+}

package/play/lang/ru.json

@@ -0,0 +1,23 @@
+{"strings": [
+  {"text":"Turn your phone","translation":"Поверните телефон","where":"landscape.js"},
+  {"text":"The game is played across.","translation":"Игра идёт горизонтально.","where":"landscape.js"},
+  {"text":"The whole play from the start","translation":"Вся партия с начала","where":"play.js"},
+  {"text":"Continue on the new commit","translation":"Продолжить на новом коммите","where":"play.js"},
+  {"text":"Pause","translation":"Пауза","where":"play.js"},
+  {"text":"Fast forward (Space)","translation":"Перемотка (пробел)","where":"play.js"},
+  {"text":"Chapters","translation":"Главы","where":"play.js"},
+  {"text":"Volume","translation":"Громкость","where":"play.js"},
+  {"text":"The whole screen","translation":"Во весь экран","where":"play.js"},
+  {"text":"No game is asked for (?game=).","translation":"Игра не указана (?game=).","where":"play.js"},
+  {"text":"Begin the whole play again?","translation":"Начать всю партию заново?","where":"play.js"},
+  {"text":"Continue the play on the new commit? What the game kept goes on with it, but it may not fit the new code, and something may break — then begin the play again (↺). There is no going back.","translation":"Продолжить партию на новом коммите? Сохранённое игрой перейдёт с ней, но может не подойти новому коду, и что-то может сломаться — тогда начните партию заново (↺). Вернуться назад будет нельзя.","where":"play.js"},
+  {"text":"The play could not continue on the new commit: {why}","translation":"Партию не удалось продолжить на новом коммите: {why}","where":"play.js"},
+  {"text":"Go on","translation":"Дальше","where":"play.js"},
+  {"text":"The play could not be opened: {why}","translation":"Партию не удалось открыть: {why}","where":"play.js"},
+  {"text":"no voice: {why}","translation":"нет голоса: {why}","where":"runtime.js"},
+  {"text":"no music: {why}","translation":"нет музыки: {why}","where":"runtime.js"},
+  {"text":"mini-game: {why}","translation":"мини-игра: {why}","where":"runtime.js"},
+  {"text":"“{text}” — {who}","translation":"«{text}» — {who}","where":"runtime.js"},
+  {"text":"not kept: {why}","translation":"не сохранилось: {why}","where":"runtime.js"},
+  {"text":"the game broke: {why}","translation":"игра сломалась: {why}","where":"runtime.js"}
+]}

package/play/voices.js

@@ -0,0 +1,12 @@
+// How a game's line is heard (runtime.js speaks it; moood's check lists every line of every language so — the voices
+// a game needs): its text as written, inline tags and all (<sigh>, <short pause> — heard, never shown), in the voice of
+// whoever says it (people.json: voice — its name; how — the manner it lasts, in English) — and the line's own manner
+// after it (say's, think's, tr.line's how: this line only, in English); a thought — the same line, whispered in the
+// mind (shown as the play's words frame it: «text» — the short name).
+export const THOUGHT = 'without a sound, in the mind: a whisper, as if right inside the head';
+
+// p — the person (people.json's); said — 'say' | 'think'; text — the line in the play's language; how — its own manner
+// (or '') → {text, voice, how}: what the voice is asked for — its how the person's, the line's, a thought's, joined by '; '
+export function heard(p, said, text, how) {
+  return { text, voice: p.voice, how: [p.how, how, said === 'think' && THOUGHT].filter(Boolean).join('; ') };
+}

package/problems/lang/ru.json

@@ -0,0 +1,74 @@
+{"strings": [
+  {"text":"{files} in one folder — a folder is one world, one game or one article","translation":"{files} в одной папке — папка — это один мир, одна игра или одна статья","where":"problems.js"},
+  {"text":"not JSON: {error}","translation":"не JSON: {error}","where":"problems.js"},
+  {"text":"not an object","translation":"не объект","where":"problems.js"},
+  {"text":"\"languages\" — the languages it is in: a list of moood's ({known})","translation":"\"languages\" — на каких языках: список языков moood ({known})","where":"problems.js"},
+  {"text":"\"languages\" — {languages}: not moood's ({known})","translation":"\"languages\" — {languages}: таких у moood нет ({known})","where":"problems.js"},
+  {"text":"\"languages\" — {languages} twice","translation":"\"languages\" — {languages} дважды","where":"problems.js"},
+  {"text":"\"{field}\" {ref} — not a path","translation":"\"{field}\" {ref} — не путь","where":"problems.js"},
+  {"text":"\"{field}\" {ref} — {name}: not a repository (owner/name)","translation":"\"{field}\" {ref} — {name}: не репозиторий (владелец/имя)","where":"problems.js"},
+  {"text":"\"{field}\" {ref} — {version}: not a branch, a tag or a commit","translation":"\"{field}\" {ref} — {version}: не ветка, не тег и не коммит","where":"problems.js"},
+  {"text":"\"{field}\" {ref} — {path}: not a path in the repository (. — its root)","translation":"\"{field}\" {ref} — {path}: не путь в репозитории (. — его корень)","where":"problems.js"},
+  {"text":"\"{field}\" {ref} — neither a path from here nor repo@ref:path","translation":"\"{field}\" {ref} — ни путь отсюда, ни repo@ref:path","where":"problems.js"},
+  {"text":"\"{field}\" {ref} — out of the repository","translation":"\"{field}\" {ref} — за пределами репозитория","where":"problems.js"},
+  {"text":"\"world\" — the world it is played on: a path from here, or repo@ref:path","translation":"\"world\" — мир, на котором она играется: путь отсюда или repo@ref:path","where":"problems.js"},
+  {"text":"\"{field}\" {ref} — no world there ({file})","translation":"\"{field}\" {ref} — там нет мира ({file})","where":"problems.js"},
+  {"text":"\"{field}\" {ref} — its world is not in {languages}: a game is in a language only if its world is","translation":"\"{field}\" {ref} — её мира нет на {languages}: игра есть на языке, только если на нём есть её мир","where":"problems.js"},
+  {"text":"\"about\" — a list of the worlds, games and scenes it is about (paths from here, or repo@ref:path)","translation":"\"about\" — список миров, игр и сцен, о которых она (пути отсюда или repo@ref:path)","where":"problems.js"},
+  {"text":"\"about\" {ref} — no world, game or scene there","translation":"\"about\" {ref} — там нет ни мира, ни игры, ни сцены","where":"problems.js"},
+  {"text":"\"engine\" {engine} — there is engine 3 (every new scene), and engine 1 (a scene that says none)","translation":"\"engine\" {engine} — есть движок 3 (каждая новая сцена) и движок 1 (сцена без \"engine\")","where":"problems.js"},
+  {"text":"\"engine\" 2 — engine 2 is gone: the scene is written anew for engine 3 (\"engine\": 3)","translation":"\"engine\" 2 — движка 2 больше нет: сцена пишется заново для движка 3 (\"engine\": 3)","where":"problems.js"},
+  {"text":"\"music\" — {count} descriptions that sound: {most} at most","translation":"\"music\" — звучащих описаний {count}: не больше {most}","where":"problems.js"},
+  {"text":"\"music\" — the description {n} that sounds: {length} characters, {most} at most","translation":"\"music\" — звучащее описание {n}: {length} символов, не больше {most}","where":"problems.js"},
+  {"text":"\"music\".{field} {value} — {least} to {most}","translation":"\"music\".{field} {value} — от {least} до {most}","where":"problems.js"},
+  {"text":"\"music\".scale \"{scale}\" — one of {scales}","translation":"\"music\".scale \"{scale}\" — одна из {scales}","where":"problems.js"},
+  {"text":"does not read as JavaScript: {error}","translation":"не читается как JavaScript: {error}","where":"problems.js"},
+  {"text":"tr(…) — its text is not a literal","translation":"tr(…) — его текст не литерал","where":"problems.js"},
+  {"text":"tr.n(count, one, other) — its forms are not literals","translation":"tr.n(count, one, other) — его формы не литералы","where":"problems.js"},
+  {"text":"tr.c(context, text) — not literals","translation":"tr.c(context, text) — не литералы","where":"problems.js"},
+  {"text":"tr.{name}(who, text) — not literals","translation":"tr.{name}(who, text) — не литералы","where":"problems.js"},
+  {"text":"tr.{name} — not for a world's or a game's code (tr, tr.n, tr.c, tr.line, tr.thought)","translation":"tr.{name} — не для кода мира или игры (tr, tr.n, tr.c, tr.line, tr.thought)","where":"problems.js"},
+  {"text":"tr`…` — call it: tr('…')","translation":"tr`…` — вызывайте его: tr('…')","where":"problems.js"},
+  {"text":"tr — not a value (T = tr, f(tr)): call it where its text is written","translation":"tr — не значение (T = tr, f(tr)): вызывайте его там, где написан текст","where":"problems.js"},
+  {"text":"{name} is the language's own name — not a variable","translation":"{name} — имя самого языка, не переменная","where":"problems.js"},
+  {"text":"{name} is the language's own name — not a function","translation":"{name} — имя самого языка, не функция","where":"problems.js"},
+  {"text":"{name} is the language's own name — not to be set","translation":"{name} — имя самого языка, его не присваивают","where":"problems.js"},
+  {"text":"{name} is the language's own name — not a parameter","translation":"{name} — имя самого языка, не параметр","where":"problems.js"},
+  {"text":"person(who).{name}(text) — not literals","translation":"person(who).{name}(text) — не литералы","where":"problems.js"},
+  {"text":"act(who, 'say', text) — a game's line is b.say(who, text)","translation":"act(who, 'say', text) — реплика игры — это b.say(who, text)","where":"problems.js"},
+  {"text":"act(who, 'say', text) — not literals","translation":"act(who, 'say', text) — не литералы","where":"problems.js"},
+  {"text":"{name}(who, text) — the text written here, its speaker not: a line is said by someone written beside it ({name}('who', '…'))","translation":"{name}(who, text) — текст написан здесь, а кто говорит — нет: реплику говорит тот, кто написан рядом с ней ({name}('who', '…'))","where":"problems.js"},
+  {"text":".{name}('…') — whose line it is is not written beside it: s.person('who').{name}('…'), or s.{name}('who', '…')","translation":".{name}('…') — чья это реплика, рядом не написано: s.person('who').{name}('…') или s.{name}('who', '…')","where":"problems.js"},
+  {"text":"{name}(who, text) — a text in it is not a line: write it whole here, or mark each where it is written (tr.line, tr.thought)","translation":"{name}(who, text) — текст в нём не реплика: напишите её здесь целиком или отметьте каждую там, где она написана (tr.line, tr.thought)","where":"problems.js"},
+  {"text":"{name}(who, line, { how }) — a kept line's own manner is kept with it: tr.line(who, text, { how })","translation":"{name}(who, line, { how }) — собственная манера отложенной реплики хранится вместе с ней: tr.line(who, text, { how })","where":"problems.js"},
+  {"text":"{name} — its voice, how are not literals","translation":"{name} — его voice, how не литералы","where":"problems.js"},
+  {"text":"{name} — its how is not a literal","translation":"{name} — его how не литерал","where":"problems.js"},
+  {"text":"{name} — \"who\" is not heard: a voice is {voice, how}","translation":"{name} — \"who\" не слышно: голос — это {voice, how}","where":"problems.js"},
+  {"text":"{name} — its voice is spread (…): say it whole, in literals","translation":"{name} — голос разложен (…): напишите его целиком, литералами","where":"problems.js"},
+  {"text":"{name} — a game's line is heard in its person's voice (people.json): its own is { how }","translation":"{name} — реплика игры звучит голосом своего человека (people.json): своё у неё — только { how }","where":"problems.js"},
+  {"text":"\"{text}\" — a { name } in a text shown as it is (nothing goes into it)","translation":"\"{text}\" — { name } в тексте, который показывается как есть (в него ничего не подставляется)","where":"problems.js"},
+  {"text":"{field} — not a text","translation":"{field} — не текст","where":"problems.js"},
+  {"text":"not {\"strings\": [entries]}","translation":"не {\"strings\": [записи]}","where":"problems.js"},
+  {"text":"\"{text}\" — translated twice","translation":"\"{text}\" — переведено дважды","where":"problems.js"},
+  {"text":"none — {n} text to translate into {lang}","plural":"none — {n} texts to translate into {lang}","translation":{"one":"нет — {n} текст для перевода на {lang}","few":"нет — {n} текста для перевода на {lang}","many":"нет — {n} текстов для перевода на {lang}","other":"нет — {n} текста для перевода на {lang}"},"where":"problems.js"},
+  {"text":"\"{text}\" — not translated","translation":"\"{text}\" — не переведено","where":"problems.js"},
+  {"text":"\"{text}\" — not translated (its forms: {forms})","translation":"\"{text}\" — не переведено (его формы: {forms})","where":"problems.js"},
+  {"text":"\"{text}\" — no \"{form}\" form","translation":"\"{text}\" — нет формы \"{form}\"","where":"problems.js"},
+  {"text":"\"{text}\" — its \"{form}\" form says {{names}}, the text {{wanted}} (and { n }, or not)","translation":"\"{text}\" — его форма \"{form}\" говорит {{names}}, а текст — {{wanted}} (и { n } или нет)","where":"problems.js"},
+  {"text":"\"{text}\" — the translation says {{names}}, the text {{wanted}}","translation":"\"{text}\" — перевод говорит {{names}}, а текст — {{wanted}}","where":"problems.js"},
+  {"text":"\"{text}\" — the translation's tags are {tags}, the line's {wanted} (heard as written, in English)","translation":"\"{text}\" — теги перевода — {tags}, а реплики — {wanted} (звучат как написаны, по-английски)","where":"problems.js"},
+  {"text":"\"{text}\" — the code no longer says it (check --write lays the file out anew)","translation":"\"{text}\" — код больше этого не говорит (check --write разложит файл заново)","where":"problems.js"},
+  {"text":"its data ({files}) is not the source's ({wanted})","translation":"его данные ({files}) не те же, что у исходного языка ({wanted})","where":"problems.js"},
+  {"text":"\"{who}\" — not {voice, how, short}","translation":"\"{who}\" — не {voice, how, short}","where":"problems.js"},
+  {"text":"\"{who}\".{field} — a person is {voice, how, short}","translation":"\"{who}\".{field} — человек — это {voice, how, short}","where":"problems.js"},
+  {"text":"\"{who}\".name — a person is {voice, how, short} (who they are is their voice and their manner)","translation":"\"{who}\".name — человек — это {voice, how, short} (кто он — это его голос и манера)","where":"problems.js"},
+  {"text":"\"{who}\".{field} — not a text","translation":"\"{who}\".{field} — не текст","where":"problems.js"},
+  {"text":"\"{text}\" — said by \"{who}\", no one of {people}","translation":"\"{text}\" — говорит \"{who}\", которого нет в {people}","where":"problems.js"},
+  {"text":"\"{text}\" — thought by \"{who}\", who has no short name ({people})","translation":"\"{text}\" — думает \"{who}\", у которого нет короткого имени ({people})","where":"problems.js"},
+  {"text":"no \"title\" and \"date\"","translation":"нет \"title\" и \"date\"","where":"problems.js"},
+  {"text":"none — the article's text","translation":"нет — текст статьи","where":"problems.js"},
+  {"text":"none — the article in {lang}","translation":"нет — статья на {lang}","where":"problems.js"},
+  {"text":"no \"title\" — the article in {lang}","translation":"нет \"title\" — статья на {lang}","where":"problems.js"},
+  {"text":"no \"summary\"","translation":"нет \"summary\"","where":"problems.js"},
+  {"text":"none — the article's text in {lang}","translation":"нет — текст статьи на {lang}","where":"problems.js"}
+]}