@moood/check 0.0.0-stage → 0.1.0

package/README.md

@@ -1,3 +1,55 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+# @moood/check
+
+A moood repository checked. A repository is a folder: every folder in it — at any depth, the root too — with
+`world.json` is a world, with `game.json` a game, with `article.json` an article; a folder that is one is not searched
+further, and one with two of these files is wrong. Each says the languages it is in (`"languages": ["en", "ru"]`, of
+moood's: `i18n/languages.json`) and is checked in those, and only those. A game names its world (`"world"`) by a
+path from its own folder (`"../usher"`), or as `owner/repo@ref:path` in another repository (only the form is checked:
+nothing is fetched); it is in a language only if its world is. An article names the worlds, games and scenes it is about (`"about"`) the same way.
+
+Every text a person reads or hears is written in the code as a literal (`tr`, `tr.n`, `tr.c`, `tr.line`, `tr.thought`;
+a line someone says — `say`, `think`) or in a read JSON field (scene.json `title`, `description`, `caption`,
+`captions[].text`; world.json `title`, `description`; game.json `title`, `description`, `line`,
+`source`; `bespoke/people.json` `*.short`), and translated into each language it is in (English is the source). A
+line's manner (`how`: a person's in people.json, a line's own in `say`, `think`, `tr.line`, `tr.thought`) is a
+direction to its voice, in English, a literal — never shown, never translated; `--json`'s lines carry it as the page
+asks for it (the person's, then the line's: `play/voices.js`).
+
+    npm i -g @moood/check
+    moood-check <repo> --write   # each language's file laid out anew from what the code says (translations kept)
+    moood-check <repo>           # checked: "all right", or what is wrong — exits 1
+    moood-check <repo> --json    # the whole report: every text; every line heard, in each language, as its voice is asked for
+
+Where the translations lie (from the world's or the game's folder): a scene's — `scenes/<folder>/lang/<lang>.json`; a
+module's — `modules/<name>.<lang>.json`; the world's — `lang/<lang>.json`; a game's — `bespoke/lang/<lang>/strings.json`
+(its data by language beside it: `bespoke/lang/<lang>/<name>.json`, the same files in every language). One entry a
+line: `{text, translation, where}` (`plural` — its forms in the language; `context`, `who` — what tells it apart).
+Translate `translation`; nothing else changes by hand. An entry twice (a merge leaves it so) is wrong: `--write` keeps
+one. An article is translated whole, by hand: `article.json` (`title`, `date`, `summary`) and `story.md`; beside them
+`article.<lang>.json` (`title`, `summary`) and `story.<lang>.md`.
+
+What it finds wrong in the code: a text that is not a literal (`tr(x)`; a bare text in a line, `say('who', a ? 'x' : 'y')`
+— each written whole, or marked where it is written: `tr.line`, `tr.thought`), `tr` made a value or a tag (`T = tr`,
+`f(tr)`, ``tr`…` ``), `tr`, `say`, `think` declared or set by the code, a line's voice not in literals (a scene's
+`{voice, how}`; a game's line its own manner only, `{how}` — of `say`, `think`, `tr.line`, `tr.thought`; a kept line said
+with one; `who` is not heard). In a game's people (`bespoke/people.json`: `{who: {voice, how, short}}`) anything else; in a
+line's translation, other inline tags than the line's (`<sigh>`, `<short pause>` — heard as written, in English). A
+scene's `"engine"` other than 3 or none (engine 1) — engine 2 is gone. In a scene's music, what a host making it with
+Lyria does not take (`engines/1/music.js`: `MooodMusic.LIMITS` — `bpm` 60–200, `density` and `brightness` 0–1, one of
+Lyria's scales, at most 20 descriptions that sound, 500 characters each).
+
+It reads a repository through a source of its files (`repository.js`: `folder(root)` — a folder on disk, read as git
+reads it: a symbolic link is not followed nor written through, nothing outside it is read; a host's own — the studio
+reads a git tree so): `check(source, {write})`, `lines(source, report)`. What it finds wrong is data —
+`{at, code, values}` —, said in words by `problems/problems.js`: `say(problem, tr)` in the language of the translator
+it is given (English on the command line; a page in its own — the translations beside it, `problems/lang/`; it
+imports nothing of Node's: a browser's page says them too). The hosts read a repository by the same rules
+(`repository.js`): `units` (what it holds), `languagesOf` (the languages one says — a value that is not moood's makes
+it in none), `reference` (how they name each other), `blobId` (a file's content's id: git's blob sha).
+
+A folder with no world, game or article in it is a folder of moood's own pages (`engines/1`, `play`, …): its code and
+pages, translated beside them (`lang/<lang>.json`) into every language moood has.
+
+`npm run build` copies what it shares with the runtime into the package: `i18n/`, the play's `voices.js` and words,
+and `engines/1/music.js`.
+moood's CI publishes it to npm from a tag `check-v<version>` — the version `package.json` says (bump it there first).

package/cli.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+// moood-check <folder> [--write] [--json] — a repository of worlds, games and articles (or a folder of moood's own
+// pages): it checked, its texts translated (index.js); --write lays out each language's file anew from what the code says; --json — the whole
+// report (every text; every line heard, in every language, as its voice is asked for: lines.js; each problem with its
+// text). What is wrong is said in English (problems/problems.js). Exits 1 when something is wrong.
+import { check } from './index.js';
+import { lines } from './lines.js';
+import { say } from './problems/problems.js';
+import { folder } from './repository.js';
+import './i18n/i18n.js';
+
+const args = process.argv.slice(2);
+const source = folder(args.find(a => !a.startsWith('--')) || '.');
+// (laid out, then checked: what is left to translate is said)
+if (args.includes('--write')) await check(source, { write: true });
+const report = await check(source), en = globalThis.MooodI18n.translator(globalThis.MooodI18n.source);
+const said = report.problems.map(p => ({ ...p, text: say(p, en) }));
+if (args.includes('--json')) console.log(JSON.stringify({ ...report, problems: said, lines: await lines(source, report) }, null, 1));
+else {
+  for (const p of said) console.log(`${p.at}: ${p.text}`);
+  const n = report.scopes.reduce((k, s) => k + s.entries.length, 0);
+  console.log(`${report.problems.length ? `${report.problems.length} wrong` : 'all right'} — ${n} texts in ${report.scopes.length} scopes`);
+}
+process.exitCode = report.problems.length ? 1 : 0;  // (not exit(): a long report to a pipe is written out first)

package/engines/1/music.js

@@ -0,0 +1,273 @@
+// A scene's music (spec.music: weighted text descriptions and settings — instrumental, made by the host's music, as
+// Lyria RealTime makes it), heard from its recording: made once, kept — everyone hears the same, whoever came first
+// had it made. It starts at once where the browser lets sound begin, else at the first gesture on the page, and
+// follows the open scene.
+//   Its recording, the host's (docs/host.md): POST <host>music {music} → {key} — its recording begun there, unless it is
+// recorded or being made; GET <host>music?key=… only listens — frames [type:1][length:4 LE][payload], 3 = a second as
+// it is kept (a byte — 1: a new encoder begins there —, then its Opus packets, each [length:2 LE][packet]), 2 = a JSON
+// event; sent up to a minute ahead (a slow or a broken connection is not heard), held here as they came and decoded
+// (WebCodecs, one decoder throughout) only AHEAD seconds before they sound. A whole recording is heard round and round:
+// a stream that ends has heard a making that failed or was lost — the music is asked for again (its POST begins it
+// anew), TRIES times at most while nothing more is heard. Weight 0 means "not now" and is never sent.
+//   One music gives way to another (another scene's) crossfading over FADE seconds; the same music — the same
+// descriptions, weights, settings — goes on as it was. What goes wrong lands in window.__mooodErrors, and is said
+// (silent): a host's refusal in the page's words — one that makes no music is asked no more, the scenes go silent; the
+// quota spent, that music is asked no more.
+//   MooodMusic.init({ track, listen, silent }) — once (a page with a stage, or without: with i18n.js and volume.js
+// before it, its words said — words.js speak): track(music, signal) → a promise of its key (POST music),
+// listen(key, signal) → of its stream (GET music: a Response) — a refusal an Error in the page's language, its code
+// with it (scene/host.js); silent(why) — the music could not be heard (why: in the page's language); show(music) — the
+// open scene's (or none); pause(on) — the play paused; asked(music) — a scene's music as the host is asked for it (the
+// body of POST music: {prompts, config}), or null — none sounds: what a host that makes the music ahead makes; LIMITS —
+// what a host making it with Lyria takes (beyond it, a request refused: check says it of a scene). A classic script:
+// it sets globalThis.MooodMusic (a page's script; a module's import — check and the host's side read asked() and
+// LIMITS so).
+globalThis.MooodMusic = (() => {
+  const RATE = 48000, LEAD = 0.25, FADE = 4, AHEAD = 8; // seconds of audio queued ahead; of a crossfade; of a recording decoded ahead
+  const TRIES = 3, AGAIN = 5; // a music asked for again while nothing more is heard, and seconds between
+  const OPUS = { codec: 'opus', sampleRate: RATE, numberOfChannels: 2 };
+  // (Lyria RealTime's: its settings' ranges — bpm a whole number —, its scales — a major and its relative minor —, the
+  // descriptions that sound at most, and their characters)
+  const LIMITS = { prompts: 20, text: 500, ranges: { bpm: [60, 200], density: [0, 1], brightness: [0, 1] },
+    scales: ['C_MAJOR_A_MINOR', 'D_FLAT_MAJOR_B_FLAT_MINOR', 'D_MAJOR_B_MINOR', 'E_FLAT_MAJOR_C_MINOR', 'E_MAJOR_D_FLAT_MINOR', 'F_MAJOR_D_MINOR',
+      'G_FLAT_MAJOR_E_FLAT_MINOR', 'G_MAJOR_E_MINOR', 'A_FLAT_MAJOR_F_MINOR', 'A_MAJOR_G_FLAT_MINOR', 'B_FLAT_MAJOR_G_MINOR', 'B_MAJOR_A_FLAT_MINOR'] };
+  let track = null, listen = null, silent = null, music = null;  // (music: asked(the open scene's))
+  let ctx = null, out = null;
+  let playing = false, pushTimer = null;
+  let deck = null; // what sounds now: { what, gain, nextT, stop() }
+  let standing = false; // an engine 3 scene stands now (Moood.onPause): what starts meanwhile waits with it
+  let mute = false; // the host makes no music
+  const refused = new Set(); // the musics refused (the quota spent): not asked for again
+
+  const tr = MooodI18n.part('engine1');  // (the engine's words, as the page said its language: words.js speak)
+  // what went wrong: noted, and said — a host's refusal in the page's words, anything else as music not heard
+  const failed = e => {
+    const detail = e?.detail || e?.message || String(e);
+    (window.__mooodErrors ||= []).push(`music: ${detail}`);
+    globalThis.MooodSeen?.say('music', { failed: String(detail).slice(0, 200) });
+    silent?.(e?.code ? e.message : tr('the music could not be heard'));
+  };
+  // What music sounds: its descriptions that have weight (trimmed) and its settings — the same, the same music
+  function asked(m) {
+    const prompts = (Array.isArray(m?.prompts) ? m.prompts : []).map(p => ({ text: String(p?.text || '').trim(), weight: Number(p?.weight) || 0 }))
+      .filter(p => p.text && p.weight > 0);
+    if (!prompts.length) return null;
+    const config = {};
+    for (const k of ['density', 'brightness']) if (typeof m[k] === 'number') config[k] = m[k];
+    if (typeof m.bpm === 'number') config.bpm = Math.round(m.bpm);
+    if (typeof m.scale === 'string') config.scale = m.scale; // the world's key (Lyria's name: C_MAJOR_A_MINOR…)
+    return { prompts, config };
+  }
+
+  // ── a deck: one music, into its own gain ─────────────────────────────────
+  function deckOf(whatNow) {
+    const gain = ctx.createGain();
+    gain.gain.value = 0;
+    gain.connect(out);
+    const d = { what: whatNow, gain, nextT: 0, aborted: false, abort: new AbortController(), held: [], heard: 0, dec: null, feeding: false, timer: 0,
+      pcm: [], frames: 0, used: 0 };
+    d.stop = () => {
+      d.aborted = true; d.abort.abort(); clearInterval(d.timer);
+      if (d.dec?.state === 'configured') d.dec.close();
+      d.pcm.forEach(a => a.close()); d.pcm = [];
+      setTimeout(() => gain.disconnect(), 200);
+    };
+    return d;
+  }
+  // a recording's second, as it came: held till it is near its time
+  function hold(d, bytes) {
+    window.__mooodMusicChunks = (window.__mooodMusicChunks || 0) + 1; // for checking the stream
+    if (d.aborted) return;
+    d.heard++;
+    d.held.push(bytes);
+    d.timer ||= setInterval(() => feed(d), 1000);
+    feed(d);
+  }
+  // what is held decoded and queued, while what is queued (and in the decoder) sounds for less than AHEAD seconds more —
+  // one decoder for the whole recording, never flushed between its seconds (Opus carries its state from packet to packet:
+  // a decoder started anew each second clicks at every second's edge); anew only where a new encoder began
+  async function feed(d) {
+    if (d.feeding) return;
+    d.feeding = true;
+    try {
+      while (!d.aborted && d.held.length && ahead(d) < AHEAD) {
+        const bytes = d.held.shift();
+        if (bytes[0] === 1 || !d.dec) await anew(d);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.length);
+        for (let i = 1; i < bytes.length;) {
+          const n = view.getUint16(i, true);
+          d.dec.decode(new EncodedAudioChunk({ type: 'key', timestamp: (d.ts += 20000), data: bytes.subarray(i + 2, i + 2 + n) }));
+          i += 2 + n;
+        }
+      }
+    } catch (e) { if (!d.aborted && deck === d) failed(e); } finally { d.feeding = false; }
+  }
+  // seconds the deck has ahead of now: queued to sound, decoded and not yet queued, still in the decoder (20 ms a packet)
+  const ahead = d => Math.max(0, d.nextT - ctx.currentTime) + d.frames / RATE + (d.dec ? d.dec.decodeQueueSize * 0.02 : 0);
+  // a decoder for what a new encoder made: the one before let out to its end first (its last part sounded as it is)
+  async function anew(d) {
+    if (d.dec?.state === 'configured') {
+      await d.dec.flush();
+      if (d.frames) sound(d, take(d, d.frames));
+      d.dec.close();
+    }
+    d.dec = new AudioDecoder({ output: a => gather(d, a), error: () => {} });
+    d.dec.configure(OPUS);
+    d.ts = 0;
+  }
+  // what the decoder lets out, gathered into seconds: each whole one queued to sound
+  function gather(d, a) {
+    if (d.aborted) { a.close(); return; }
+    d.pcm.push(a);
+    d.frames += a.numberOfFrames;
+    while (d.frames >= RATE) sound(d, take(d, RATE));
+  }
+  // n frames of what is gathered, as a buffer (from the oldest, a piece of one at its edge)
+  function take(d, n) {
+    const buf = ctx.createBuffer(2, n, RATE);
+    for (let at = 0; at < n;) {
+      const a = d.pcm[0], k = Math.min(n - at, a.numberOfFrames - d.used);
+      for (let c = 0; c < 2; c++) a.copyTo(buf.getChannelData(c).subarray(at, at + k), { planeIndex: c, frameOffset: d.used, frameCount: k, format: 'f32-planar' });
+      at += k; d.used += k;
+      if (d.used === a.numberOfFrames) { d.pcm.shift().close(); d.used = 0; }
+    }
+    d.frames -= n;
+    return buf;
+  }
+  // a buffer after what the deck has queued
+  function sound(d, buf) {
+    if (d.aborted) return;
+    const src = ctx.createBufferSource();
+    src.buffer = buf;
+    src.connect(d.gain);
+    const at = Math.max(d.nextT, ctx.currentTime + LEAD);
+    src.start(at);
+    d.nextT = at + buf.duration;
+  }
+  // a stream of frames (a Response) into the deck: ev(event) for its events; → once it has ended — whether it ended
+  // there (event ended: nothing is being made of it)
+  async function read(d, r, ev) {
+    if (!r.body) throw new Error('the music stream did not open');
+    const reader = r.body.getReader();
+    let buf = new Uint8Array(0);
+    for (;;) {
+      const { value, done } = await reader.read();
+      if (done) return;
+      const joined = new Uint8Array(buf.length + value.length);
+      joined.set(buf); joined.set(value, buf.length);
+      buf = joined;
+      while (buf.length >= 5) {
+        const len = buf[1] | (buf[2] << 8) | (buf[3] << 16) | (buf[4] << 24);
+        if (buf.length < 5 + len) break;
+        const type = buf[0], payload = buf.slice(5, 5 + len);
+        buf = buf.slice(5 + len);
+        if (type === 3) hold(d, payload);
+        else if (type === 2) ev(JSON.parse(new TextDecoder().decode(payload)));
+      }
+    }
+  }
+  // the deck that sounds now gives way to d over `fade` seconds (nothing sounded: d comes in quickly)
+  function swap(d, fade = FADE) {
+    const was = deck, t = ctx.currentTime;
+    deck = d;
+    if (was) {
+      was.gain.gain.cancelScheduledValues(t);
+      was.gain.gain.setValueAtTime(was.gain.gain.value, t);
+      was.gain.gain.linearRampToValueAtTime(0, t + fade);
+      setTimeout(() => was.stop(), fade * 1000 + 300);
+    }
+    if (d) {
+      d.gain.gain.setValueAtTime(0, t);
+      d.gain.gain.linearRampToValueAtTime(1, t + (was ? fade : 0.3));
+    }
+  }
+
+  // the music's recording: asked for (its making begun, if it is neither recorded nor being made) and heard. A stream
+  // that ends, or breaks (the connection's TypeError), before the recording is whole — its making failed or was lost, the
+  // host went — is asked for again, TRIES times while nothing more is heard. A refusal ends it: no music made here — none
+  // asked for again; the quota spent — not this music
+  function recorded(whatNow, m) {
+    const d = deckOf(whatNow);
+    (async () => {
+      for (let tries = 0, heard = 0; ; tries = d.heard > heard ? 0 : tries + 1, heard = d.heard) {
+        if (tries === TRIES) throw new Error(`the music's stream ended ${TRIES} times with nothing more heard`);
+        if (tries) await new Promise(ok => setTimeout(ok, AGAIN * 1000));
+        if (d.aborted) return;
+        try {
+          const key = await track(m, d.abort.signal);
+          await read(d, await listen(key, d.abort.signal), e => {
+            if (e.ready && deck === d) globalThis.MooodSeen?.say('music', { playing: true });
+          });
+        } catch (e) {
+          if (d.aborted) return;
+          if (e?.code || !(e instanceof TypeError)) throw e;
+        }
+      }
+    })().catch(e => {
+      if (e?.code === 'no-music') mute = true;
+      if (e?.code === 'quota') refused.add(whatNow);
+      if (!d.aborted && deck === d) failed(e);
+    });
+    return d;
+  }
+
+  // what should sound now, sounding: nothing (no weights, no music), or its recording
+  function push() {
+    if (!playing) return;
+    const now = music && JSON.stringify(music);
+    if (!music || mute || refused.has(now)) { swap(null); return; }
+    if (deck && deck.what === now) return;
+    swap(recorded(now, music));
+  }
+  function pushSoon() { clearTimeout(pushTimer); pushTimer = setTimeout(push, 200); }
+
+  // It may be asked again while it is starting: a browser that does not let sound begin yet leaves the context's
+  // resume() unanswered — for ever, if nothing asks it again —, and the first gesture's asking is what it answers. Of
+  // the askings then answered the first one plays; the others find it playing
+  async function start() {
+    if (playing) return;
+    try {
+      ctx = ctx || new AudioContext({ sampleRate: RATE });
+      // (an engine 3 scene standing: the music begins as the scene goes on — stands)
+      await (standing ? ctx.suspend() : ctx.resume());
+      if (playing) return; // begun by another asking meanwhile
+      if (!out) { out = ctx.createGain(); out.connect(ctx.destination); }
+      out.gain.setTargetAtTime(MooodVolume.get('music'), ctx.currentTime, 0.3);
+      playing = true;
+      push();
+    } catch (e) { playing = false; failed(e); }
+  }
+
+  // ── the page's side ──────────────────────────────────────────────────────
+  function init(opts) {
+    ({ track, listen, silent } = opts);
+    MooodVolume.on((kind, v) => { if (kind === 'music' && out) out.gain.setTargetAtTime(v, ctx.currentTime, 0.1); });
+    // it starts at once, as far as the browser lets sound begin; where it does not, the first gesture of any kind
+    // starts it
+    const first = () => { removeEventListener('pointerdown', first, true); removeEventListener('keydown', first, true); start(); };
+    addEventListener('pointerdown', first, true);
+    addEventListener('keydown', first, true);
+    start();
+    // (an engine 3 scene standing — the play paused, nobody watching it: the music stands with it; of any stage of the
+    // page, mounted before this or after — a page without a stage, none: a host's page where music is tuned)
+    globalThis.Moood?.onPause(stands);
+  }
+
+  // the open scene's music (from its spec), or none
+  function show(m) {
+    music = asked(m);
+    if (playing) pushSoon();
+  }
+
+  // the play paused — or an engine 3 scene standing: the music stands where it is, and goes on when it isn't (it is the
+  // sound's clock that stands, not what plays; going on, it ends an engine 3 scene's standing too — of one the stage
+  // left for another engine's while the play was paused)
+  function pause(on) {
+    if (!on) standing = false;
+    if (ctx) (on ? ctx.suspend() : ctx.resume()).catch(() => {});
+  }
+  // an engine 3 scene stands (the play paused, nobody watching it, a layer of the page over it), and goes on
+  function stands(on) { standing = on; pause(on); }
+
+  return { init, show, pause, asked, LIMITS };
+})();

package/extract.js

@@ -0,0 +1,192 @@
+// What a file says to a person: the texts of its code (tr, tr.n, tr.c, say, think — their literals), of a widget's
+// markup (its text), of a JSON file's fields that are read or heard (FIELDS). Each found is an entry —
+//   {text, plural?, context?, who?, voice?, how?, where}
+// (who: a line said — say/think; voice: how it is heard, when the code says it: a scene's say(who, text, {voice,
+// how}); how: a game's line's own manner — its say(who, text, {how}), think's, tr.line's, tr.thought's: its voice is
+// its person's) — and what is wrong is a problem: a text that is not a literal (nothing could find it), a name of the
+// language's own (tr, say, think) made the code's own (problems/problems.js).
+import * as acorn from 'acorn';
+import * as walk from 'acorn-walk';
+import { problem } from './problems/problems.js';
+import './i18n/i18n.js';
+
+// a JSON file's fields that are read: by its name — [path] (the language's own list: what a page shows translated)
+export const { FIELDS } = globalThis.MooodI18n;
+const OWN = new Set(['tr', 'say', 'think']);
+// (a text a page shows as it is — a field, markup — is given nothing to put in: a {name} in it is an error)
+const BRACED = /\{\w+\}/;
+
+const literal = node => {
+  if (node?.type === 'Literal' && typeof node.value === 'string') return node.value;
+  if (node?.type === 'TemplateLiteral' && node.expressions.length === 0) return node.quasis[0].value.cooked;
+  return null;
+};
+
+// a line's text that is not a literal: whether a text is in it bare (cond ? 'a' : 'b', 'a' + b) — not a line marked
+// where it is written (tr.line, tr.thought) — nothing could find it
+function bareText(arg) {
+  let bare = false;
+  walk.recursive(arg, null, {
+    Literal(n) { if (typeof n.value === 'string') bare = true; },
+    TemplateLiteral() { bare = true; },
+    CallExpression(n, st, c) {
+      if (n.callee.type === 'MemberExpression' && n.callee.object.type === 'Identifier' && n.callee.object.name === 'tr') return;
+      c(n.callee, st);
+      for (const a of n.arguments) c(a, st);
+    },
+    // (what chooses the text is not it: a condition, a comparison, a key)
+    ConditionalExpression(n, st, c) { c(n.consequent, st); c(n.alternate, st); },
+    BinaryExpression(n, st, c) { if (n.operator === '+') { c(n.left, st); c(n.right, st); } },
+    MemberExpression(n, st, c) { c(n.object, st); },
+  });
+  return bare;
+}
+
+function parse(code) {
+  const opts = { ecmaVersion: 'latest', locations: true, allowReturnOutsideFunction: true, allowAwaitOutsideFunction: true,
+    allowImportExportEverywhere: true, allowHashBang: true };
+  try { return acorn.parse(code, { ...opts, sourceType: 'module' }); } catch {
+    return acorn.parse(code, { ...opts, sourceType: 'script' });
+  }
+}
+
+// The code's texts. file — its path (what an entry and a problem say where); own — the language's own names are the
+// language's (a world's, a game's code: tr, say, think none of its own); moood's own pages make their translator
+// themselves; game — a game's code (its lines are b.say's, never a scene's act(who, 'say', …)).
+export function fromCode(code, file, own = true, game = false) {
+  const entries = [], problems = [];
+  let ast;
+  try { ast = parse(code); } catch (e) { return { entries, problems: [problem(file, 'not-javascript', { error: e.message })] }; }
+  const wrong = (node, code, values) => problems.push(problem(`${file}:${node.loc.start.line}`, code, values));
+  const add = (node, e) => entries.push({ ...e, where: file, line: node.loc.start.line });
+  // a line's voice, as it is asked for (the options it is said with): a scene's — {voice, how}; a game's — {how}, the
+  // line's own manner (its voice is its person's: people.json); literals, written whole; who no longer (the voice says
+  // it is someone; the manner, how)
+  const voiceOf = (arg, node, name) => {
+    const o = arg?.type === 'ObjectExpression' ? arg : null;
+    const voice = o && Object.fromEntries(o.properties.filter(p => p.type === 'Property' && ['voice', 'how'].includes(p.key?.name))
+      .map(p => [p.key.name, literal(p.value)]));
+    if (voice && Object.values(voice).some(v => v == null)) wrong(node, game ? 'how-not-literal' : 'voice-not-literal', { name });
+    if (o?.properties.some(p => p.type === 'Property' && p.key?.name === 'who')) wrong(node, 'voice-who', { name });
+    if (o?.properties.some(p => p.type === 'SpreadElement')) wrong(node, 'voice-spread', { name });
+    if (game && voice && 'voice' in voice) wrong(node, 'voice-game', { name });
+    if (game) return voice?.how ? { how: voice.how } : {};
+    return voice?.voice ? { voice } : {};
+  };
+  walk.ancestor(ast, {
+    CallExpression(node) {
+      const c = node.callee, args = node.arguments;
+      const name = c.type === 'Identifier' ? c.name : c.type === 'MemberExpression' && !c.computed ? c.property.name : null;
+      const obj = c.type === 'MemberExpression' && c.object.type === 'Identifier' ? c.object.name : null;
+      if (c.type === 'Identifier' && name === 'tr') {
+        const text = literal(args[0]);
+        if (text == null) wrong(node, 'tr-not-literal');
+        else add(node, { text });
+      } else if (obj === 'tr' && name === 'n') {
+        const one = literal(args[1]), other = literal(args[2]);
+        if (one == null || other == null) wrong(node, 'tr-n-not-literal');
+        else add(node, { text: one, plural: other });
+      } else if (obj === 'tr' && name === 'c') {
+        const context = literal(args[0]), text = literal(args[1]);
+        if (context == null || text == null) wrong(node, 'tr-c-not-literal');
+        else add(node, { context, text });
+      } else if (obj === 'tr' && (name === 'line' || name === 'thought')) {
+        const who = literal(args[0]), text = literal(args[1]);
+        if (who == null || text == null) wrong(node, 'tr-line-not-literal', { name });
+        else add(node, { who, text, said: name === 'line' ? 'say' : 'think', ...voiceOf(args[2], node, `tr.${name}`) });
+      } else if (obj === 'tr' && own) {
+        wrong(node, 'tr-not-own', { name });
+      } else if (own && (name === 'say' || name === 'think') && c.type === 'MemberExpression' && c.object.type === 'CallExpression'
+        && c.object.callee.type === 'MemberExpression' && c.object.callee.property.name === 'person') {
+        // (a person's own verb: s.person('who').say('…', {voice, how, who}) — their line)
+        const who = literal(c.object.arguments[0]), text = literal(args[0]);
+        if (who == null || text == null) wrong(node, 'person-line-not-literal', { name });
+        else add(node, { who, text, said: name, ...voiceOf(args[1], node, name) });
+      } else if (own && name === 'act' && literal(args[1]) === 'say') {
+        // (an action: act('who', 'say', '…') — a scene's: the scene translates it; a game's line is b.say)
+        const who = literal(args[0]), text = literal(args[2]);
+        if (game) wrong(node, 'act-say-game');
+        else if (who == null || text == null) wrong(node, 'act-say-not-literal');
+        else add(node, { who, text, said: 'say' });
+      } else if (own && (name === 'say' || name === 'think')) {
+        // (a line written where it is said; else it was marked where it is kept: tr.line, tr.thought)
+        const who = literal(args[0]), text = literal(args[1]);
+        if (who != null && text != null) {
+          add(node, { who, text, said: name, ...voiceOf(args[2], node, name) });
+        } else if (literal(args[1]) != null || args[1]?.type === 'TemplateLiteral') {
+          wrong(node, 'line-speaker', { name });
+        } else if (c.type === 'MemberExpression' && (literal(args[0]) != null || args[0]?.type === 'TemplateLiteral') && (!args[1] || args[1].type === 'ObjectExpression')) {
+          // (a person's verb on a name of the code's own: who says it is not written beside it)
+          wrong(node, 'line-whose', { name });
+        } else if (text == null && args[1] && bareText(args[1])) {
+          wrong(node, 'line-bare', { name });
+        } else if (game && text == null && args[2]?.type === 'ObjectExpression' && args[2].properties.some(p => p.type === 'Property' && p.key?.name === 'how')) {
+          // (a line kept is said as it was kept: its own manner with it)
+          wrong(node, 'line-kept-how', { name });
+        }
+      }
+    },
+    // the language's own names are the language's: tr, say, think made a variable, a function, a parameter of the code's
+    // (a name inside a pattern too: [tr] = …, { say } = …, (a = tr) => …)
+    VariableDeclarator(node) { if (own) for (const n of bound(node.id)) if (OWN.has(n)) wrong(node, 'own-variable', { name: n }); },
+    FunctionDeclaration(node) { if (own && OWN.has(node.id?.name)) wrong(node, 'own-function', { name: node.id.name }); },
+    AssignmentExpression(node) { if (own) for (const n of bound(node.left)) if (OWN.has(n)) wrong(node, 'own-set', { name: n }); },
+    // tr is called where its text is written: never made another name (T = tr), handed on (f(tr)), a tag (tr`…`)
+    TaggedTemplateExpression(node) { if (own && node.tag.type === 'Identifier' && node.tag.name === 'tr') wrong(node, 'tr-tag'); },
+    Identifier(node, ancestors) {
+      const up = ancestors[ancestors.length - 2];
+      if (!own || node.name !== 'tr' || (up?.type === 'CallExpression' && up.callee === node) || (up?.type === 'MemberExpression' && up.object === node)
+        || up?.type === 'TaggedTemplateExpression') return;
+      wrong(node, 'tr-value');
+    },
+    Function(node) { if (own) for (const p of node.params) for (const n of bound(p)) if (OWN.has(n)) wrong(node, 'own-parameter', { name: n }); },
+  });
+  return { entries, problems };
+}
+
+// the names a pattern binds (a declarator's, a parameter's)
+function bound(p) {
+  if (!p) return [];
+  if (p.type === 'Identifier') return [p.name];
+  if (p.type === 'ArrayPattern') return p.elements.flatMap(bound);
+  if (p.type === 'ObjectPattern') return p.properties.flatMap(q => bound(q.type === 'RestElement' ? q.argument : q.value));
+  if (p.type === 'AssignmentPattern') return bound(p.left);
+  if (p.type === 'RestElement') return bound(p.argument);
+  return [];
+}
+
+// A widget's markup: its texts (the language's own reading of markup: what a page translates), and its scripts'.
+export function fromMarkup(html, file, own = true, game = false) {
+  const entries = [], problems = [];
+  for (const m of html.matchAll(/<script[^>]*>([\s\S]*?)<\/script>/gi)) {
+    const r = fromCode(m[1], file, own, game);
+    entries.push(...r.entries); problems.push(...r.problems);
+  }
+  for (const text of globalThis.MooodI18n.markupTexts(html)) {
+    if (BRACED.test(text)) problems.push(problem(file, 'braced', { text }));
+    else entries.push({ text, where: file });
+  }
+  return { entries, problems };
+}
+
+// A JSON file's texts: its FIELDS.
+export function fromJson(json, file, fields) {
+  const entries = [], problems = [];
+  let data;
+  try { data = JSON.parse(json); } catch (e) { return { entries, problems: [problem(file, 'json', { error: e.message })] }; }
+  const take = (value, path, where) => {
+    if (!path.length) {
+      if (typeof value === 'string' && BRACED.test(value)) problems.push(problem(file, 'braced', { text: value }));
+      else if (typeof value === 'string' && value.trim()) entries.push({ text: value, where });
+      else if (value != null && typeof value !== 'string') problems.push(problem(file, 'not-text', { field: where.slice(file.length).trim() }));
+      return;
+    }
+    const [head, ...rest] = path;
+    if (value == null || typeof value !== 'object') return;
+    if (head === '*') for (const [k, v] of Object.entries(value)) take(v, rest, `${where}.${k}`);
+    else if (head.endsWith('[]')) (value[head.slice(0, -2)] || []).forEach((v, i) => take(v, rest, `${where} ${head.slice(0, -2)}[${i}]`));
+    else take(value[head], rest, path.length === 1 ? `${where} ${head}` : where);
+  };
+  for (const f of fields) take(data, f.split('.'), file);
+  return { entries, problems };
+}