@homie-rocks/studio 0.21.0 → 0.23.0

package/lib/site.mjs

@@ -417,7 +417,12 @@ export function landingOf(g, out, { videos = [], songs = [], log = () => {} } =
 
   const words = L.players && typeof L.players === 'object' ? { one: str(L.players.one, 24), many: str(L.players.many, 24) } : null;
   // The landing's own colours (landing.theme): only colours, and the ink on its own accent worked out like the studio's.
-  const theme = L.theme && typeof L.theme === 'object' ? Object.fromEntries(['accent', 'glow', 'bg', 'fg'].filter((k) => COLOR.test(String(L.theme[k] ?? ''))).map((k) => [k, L.theme[k]])) : null;
+  // Else the game's own palette (games/<id>/style.json, its art-direction decisions): one look from the game to its page.
+  const style = !L.theme ? readJson(join(g.dir, 'style.json'))?.palette : null;
+  // Its accents only: the page keeps the studio's light or dark scheme, so its text always reads.
+  const fromStyle = style && typeof style === 'object' ? { accent: style.accent, glow: style.accent2 } : null;
+  const raw = L.theme && typeof L.theme === 'object' ? L.theme : fromStyle;
+  const theme = raw ? Object.fromEntries(['accent', 'glow', 'bg', 'fg'].filter((k) => COLOR.test(String(raw[k] ?? ''))).map((k) => [k, raw[k]])) : null;
   if (theme?.accent) { const l = luminance(theme.accent); if (l !== null) theme.accentInk = l > 0.4 ? '#0b0b10' : '#ffffff'; }
   // landing.scheme: "light" for a white or cream game (its hero is tinted light and its words dark), "dark" for a
   // dark game in a light studio. Anything else follows the studio's look.

package/lib/studio.mjs

@@ -3,7 +3,7 @@
  * current directory, and its games.
  */
 import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
+import { dirname, join, resolve, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { httpsPage, licenseOf, pageOfSource, remixAllowed, remixCredit, remixRow } from '../worker/license.mjs';
 
@@ -115,17 +115,24 @@ function renameTakeSaves(dir, from, id) {
   if (next !== text) writeFileSync(file, next);
 }
 
-/** `homie-studio game new <id> --from <starter> --name "<Name>"`: a starter copied in as this studio's own game. */
-export function newGame(root, id, { from = 'gem-rush', name } = {}) {
+/**
+ * `homie-studio game new <id> --from <starter> --name "<Name>"`: a starter copied in as this studio's own game. A starter
+ * whose game.json says `"assets": "library"` gets its models from the starter library here (fetchStarterModels).
+ */
+export async function newGame(root, id, { from = 'gem-rush', name } = {}) {
   if (!GAME_ID.test(String(id ?? '')) || RESERVED_IDS.has(id)) throw new Error(`a game id is lowercase letters, digits and hyphens, up to 40, and not one of ${[...RESERVED_IDS].join(', ')} (got ${JSON.stringify(id)})`);
   const src = join(PACKAGE_ROOT, 'starters', from);
   if (!existsSync(join(src, 'game.json'))) throw new Error(`no starter "${from}"; starters: ${starters().map((s) => s.id).join(', ')}`);
   const dest = join(root, 'games', id);
   if (existsSync(join(dest, 'game.json'))) throw new Error(`games/${id} already exists; pick another id or change that game`);
-  // A planned game (its folder holds the Game Codex, maybe art, and no game.json yet): the starter goes in around
-  // what is there, and nothing of the plan is overwritten.
-  if (existsSync(dest) && readdirSync(dest).some((f) => existsSync(join(src, f)))) throw new Error(`games/${id} holds files of its own that a starter would overwrite; pick another id`);
-  cpSync(src, dest, { recursive: true });
+  // A planned game (its folder holds the Game Codex, maybe its art direction and models, and no game.json yet): the
+  // starter goes in around what is there, and nothing of the plan is overwritten. Its style.json (from its own
+  // decisions) and credits.json stay; the starter's models join its assets/manifest.json beside the game's own.
+  const ADOPT = ['style.json', 'credits.json', 'assets'];
+  const planned = existsSync(dest) ? readdirSync(dest).filter((f) => existsSync(join(src, f))) : [];
+  const clash = planned.filter((f) => !ADOPT.includes(f));
+  if (clash.length) throw new Error(`games/${id} holds files of its own that a starter would overwrite (${clash.join(', ')}); pick another id`);
+  cpSync(src, dest, { recursive: true, filter: (from) => !planned.some((f) => from === join(src, f) || from.startsWith(join(src, f) + sep)) });
   const meta = JSON.parse(readFileSync(join(dest, 'game.json'), 'utf8'));
   meta.id = id;
   if (name) meta.name = String(name).slice(0, 60);
@@ -136,7 +143,113 @@ export function newGame(root, id, { from = 'gem-rush', name } = {}) {
   renameTakeSaves(dest, from, id);
   const html = join(dest, 'index.html');
   if (name && existsSync(html)) writeFileSync(html, readFileSync(html, 'utf8').replace(/<title>[^<]*<\/title>/, `<title>${String(name).replace(/[<&]/g, '')}</title>`));
-  return { ok: true, command: 'game new', id, from, dir: dest, files: readdirSync(dest, { recursive: true }).map(String) };
+  const merged = planned.includes('assets') && existsSync(join(src, 'assets', 'manifest.json')) ? await adoptStarterAssets(root, id, src) : null;
+  const needs = addNeeds(root, meta.needs);
+  const models = meta.assets === 'library' ? await fetchStarterModels(dest, merged) : null;
+  // A starter with models carries their rights: assets/RIGHTS.md and the credits, written again for this game.
+  if (existsSync(join(dest, 'assets', 'manifest.json'))) {
+    const { readManifest, syncCredits, writeRights } = await import('./asset-manifest.mjs');
+    const manifest = readManifest(root, id);
+    writeRights(root, id, manifest);
+    syncCredits(root, id, manifest);
+  }
+  return { ok: true, command: 'game new', id, from, dir: dest, files: readdirSync(dest, { recursive: true }).map(String), ...needs, ...(models ? { models } : {}) };
+}
+
+/**
+ * A planned game that already has models: the starter's entries join its assets/manifest.json (an id the game
+ * already uses keeps the game's own). The game's code draws them under the game's current decisions (it reads
+ * style.json), so each adopted entry is recorded as made under those revisions, not the starter's. Returns the
+ * adopted ids (the only ones fetched).
+ */
+async function adoptStarterAssets(root, id, src) {
+  const { readManifest, writeManifest } = await import('./asset-manifest.mjs');
+  const { readDecisions, revisionsFor, setDecision } = await import('./decisions.mjs');
+  const mine = readManifest(root, id);
+  const theirs = JSON.parse(readFileSync(join(src, 'assets', 'manifest.json'), 'utf8'));
+  // The starter is dressed from one library family: an automatic pick follows it (one family a game); one the person
+  // chose stays, and the lineup flags the starter's models until they are swapped.
+  const family = (theirs.assets ?? []).map((a) => String(a.from?.pack ?? '').split('-')[0]).find(Boolean);
+  const before = readDecisions(root, id)?.decisions?.['cast.family'];
+  if (family && before && before.value !== family && before.state === 'auto') {
+    setDecision(root, id, 'cast.family', family, { by: 'ai', why: `the starter's models are ${family}; one family a game, so every piece fits` });
+  }
+  const doc = readDecisions(root, id);
+  const adopted = [];
+  for (const a of theirs.assets ?? []) {
+    if (mine.assets.some((x) => x.id === a.id)) continue;
+    if (doc && a.made?.under) a.made.under = revisionsFor(doc, Object.keys(a.made.under));
+    mine.assets.push(a);
+    adopted.push(a.id);
+  }
+  writeManifest(root, id, mine);
+  return adopted;
+}
+
+/**
+ * A STARTER'S MODELS COME FROM THE STARTER LIBRARY: the repository keeps no binaries, so such a starter ships only its
+ * assets/manifest.json, each model a library item (`from.item`) and the file it goes to. Each is fetched from the
+ * library (HOMIE_LIBRARY: a folder or an address; homie.rocks by default), checked by the index's SHA-256 and the GLB
+ * safety rules (lib/library.mjs fetchItemFile), and written there; the manifest keeps the SHA-256 of what was written.
+ * When the library cannot be reached the models stay out, `why` says so, and the game draws its stand-ins until they
+ * come (`homie-studio assets add <game> <item> --as <asset>`). Returns { fetched, missing: [{ asset, item, why }], from }.
+ */
+async function fetchStarterModels(dest, only = null) {
+  const file = join(dest, 'assets', 'manifest.json');
+  let manifest;
+  try { manifest = JSON.parse(readFileSync(file, 'utf8')); } catch { return null; }
+  const wanted = (manifest.assets ?? []).filter((a) => (!only || only.includes(a.id)) && a.route === 'library' && a.from?.item && (a.files ?? []).some((f) => f.role === 'model' && /^public\/models\/[a-z0-9][a-z0-9-]{0,47}\.glb$/.test(String(f.path))));
+  if (!wanted.length) return null;
+  const { fetchItemFile, libraryBase, loadIndex } = await import('./library.mjs');
+  const lib = libraryBase();
+  let index;
+  try { index = (await loadIndex({ lib })).index; } catch (error) {
+    return { fetched: 0, missing: wanted.map((a) => ({ asset: a.id, item: a.from.item, why: 'no library' })), why: error.message, from: lib.base };
+  }
+  const missing = [];
+  let fetched = 0;
+  for (const a of wanted) {
+    const item = index.items.find((x) => x.id === a.from.item);
+    const f = a.files.find((x) => x.role === 'model');
+    if (!item) { missing.push({ asset: a.id, item: a.from.item, why: `the library has no ${a.from.item}` }); continue; }
+    try {
+      const { bytes, sha256 } = await fetchItemFile(lib, item);
+      mkdirSync(dirname(join(dest, f.path)), { recursive: true });
+      writeFileSync(join(dest, f.path), bytes);
+      Object.assign(f, { bytes: bytes.byteLength, sha256 });
+      a.from.sha256 = sha256;
+      fetched += 1;
+    } catch (error) { missing.push({ asset: a.id, item: a.from.item, why: error.message }); }
+  }
+  writeFileSync(file, `${JSON.stringify(manifest, null, 2)}\n`);
+  return { fetched, missing, from: lib.base };
+}
+
+/**
+ * WHAT A STARTER NEEDS FROM NPM. A starter's game.json may say `"needs": { "three": "0.185.1" }`: libraries its code
+ * imports that a studio does not have yet. Each one the studio's package.json lacks (in dependencies or
+ * devDependencies) goes into devDependencies at that exact version, so the game bundles one copy of it (a second
+ * three.js beside the one @homie-rocks/studio/assets imports would be two engines). A version the studio already
+ * pins is left as it is and named in `needsHeld`. `needs` stays in the game's game.json: it is what the game was
+ * written against. Returns { needs, needsAdded, needsHeld, installNeeded }.
+ */
+export function addNeeds(root, needs) {
+  const want = needs && typeof needs === 'object' && !Array.isArray(needs) ? Object.entries(needs).filter(([n, v]) => /^(@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]{0,213}$/.test(n) && /^\d+\.\d+\.\d+(-[0-9A-Za-z.-]+)?$/.test(String(v))) : [];
+  if (!want.length) return {};
+  const file = join(root, 'package.json');
+  const pkg = JSON.parse(readFileSync(file, 'utf8'));
+  const added = []; const held = [];
+  for (const [n, v] of want) {
+    const have = pkg.dependencies?.[n] ?? pkg.devDependencies?.[n];
+    if (have) { if (have !== v) held.push({ name: n, want: v, have }); continue; }
+    pkg.devDependencies = { ...(pkg.devDependencies ?? {}), [n]: String(v) };
+    added.push({ name: n, version: String(v) });
+  }
+  if (added.length) {
+    pkg.devDependencies = Object.fromEntries(Object.entries(pkg.devDependencies).sort(([a], [b]) => a.localeCompare(b)));
+    writeFileSync(file, `${JSON.stringify(pkg, null, 2)}\n`);
+  }
+  return { needs: Object.fromEntries(want), needsAdded: added, needsHeld: held, installNeeded: added.length > 0 };
 }
 
 /**
@@ -188,5 +301,19 @@ export async function remixGame(root, source, id, { name } = {}) {
   const main = join(dest, meta.entry ?? 'src/main.ts');
   if (existsSync(main) && from) writeFileSync(main, readFileSync(main, 'utf8').replace(new RegExp(`game: '${from}'`, 'g'), `game: '${id}'`));
   if (from) renameTakeSaves(dest, from, id);
-  return { ok: true, command: 'game remix', id, from: String(url), credit: meta.remixOf.credit, page: meta.remixOf.page, license, files: wrote };
+  // Its models and pictures (0.22.0): fetched from the original site and checked by SHA-256 where their licence lets a
+  // remix carry them; a grey placeholder of the same size where it does not (lib/remix-assets.mjs).
+  let assets = null;
+  if (existsSync(join(dest, 'assets', 'manifest.json'))) {
+    const { fetchRemixAssets } = await import('./remix-assets.mjs');
+    assets = await fetchRemixAssets(root, id, url, { credit: { studio: credit.studio ?? null, game: credit.game ?? meta.name ?? from } });
+  }
+  // What its code imports beyond the toolkit (a 3D game: three.js). A remix source is someone else's text, so only the
+  // libraries the toolkit's own starters use are added; anything else is named for the person to decide.
+  const asked = meta.needs && typeof meta.needs === 'object' && !Array.isArray(meta.needs) ? meta.needs : {};
+  const refusedNeeds = Object.keys(asked).filter((n) => !REMIX_NEEDS.has(n));
+  const needs = addNeeds(root, Object.fromEntries(Object.entries(asked).filter(([n]) => REMIX_NEEDS.has(n))));
+  return { ok: true, command: 'game remix', id, from: String(url), credit: meta.remixOf.credit, page: meta.remixOf.page, license, files: wrote, ...(assets ? { assets } : {}), ...needs, ...(refusedNeeds.length ? { needsNotAdded: refusedNeeds } : {}) };
 }
+/** The libraries a remix may add to a studio's package.json by itself (the ones the toolkit's starters use). */
+const REMIX_NEEDS = new Set(['three']);

package/lib/style-board.mjs

@@ -0,0 +1,227 @@
+/**
+ * THE STYLE BOARD AND THE LINEUP: pictures the engine draws for free (lib/render3d.mjs).
+ *
+ *   styleBoard(root, id)      three coherent directions (lib/decisions.mjs directionsFor), each drawn as the game would
+ *                             draw it: its palette, light, camera, material model, fonts and proportions, with the
+ *                             starter library family's own pieces re-tinted into its palette. Saved as
+ *                             games/<id>/codex/board/<a|b|c>-swatch.jpg (private, under 300 KB each), the board in
+ *                             decisions.json. A painted mood image per direction is optional and paid: the art skill
+ *                             makes it on the creator's own fal account and `style mood` records it, labelled a target.
+ *   assetsLineup(root, id)    every made asset at true scale on a 1 m grid under the game's light (front and
+ *                             three-quarter), silhouettes black on white at 64 px tall, and flags: over budget, palette
+ *                             drift (CIEDE2000 from the locked palette), an unreadable silhouette, another library family,
+ *                             stale. .studio/art/<id>/lineup-*.jpg and lineup.json.
+ */
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { extname, join, relative } from 'node:path';
+import { readManifest } from './asset-manifest.mjs';
+import { assetsCheck } from './asset-check.mjs';
+import { mix, nearest } from './colour.mjs';
+import { directionsFor, initDecisions, labelOf, lightColours, readDecisions, staleAssets, styleTokens, writeDecisions, addLatestLine } from './decisions.mjs';
+import { PALETTE_KEYS } from './style-presets.mjs';
+import { loadIndex, searchLibrary, fetchItemFile, libraryBase } from './library.mjs';
+import { modelIn, saveDataUrl, withRenderer, dataUrlBytes } from './render3d.mjs';
+
+const BOARD_DIR = join('codex', 'board');
+const PICTURE_MAX = 300 * 1024;
+
+/** A direction's (or a game's) style values as the render page's tokens. */
+export function tokensOf(values) {
+  const ui = values['style.ui'] ?? {};
+  return {
+    palette: values['style.palette'], light: values['style.light'], camera: values['style.camera'], render: values['style.render'],
+    materials: values['style.materials'], fonts: { display: ui.display, body: ui.body }, shape: values['style.shape'], proportions: values['style.proportions'],
+  };
+}
+
+/** Up to `n` library pieces of a family that suit the game's words, as model inputs (empty when no library is reachable). */
+async function libraryPieces(family, query, n, log) {
+  try {
+    const { index, lib } = await loadIndex({ lib: libraryBase() });
+    const picks = [];
+    const seen = new Set();
+    for (const q of [query, 'tree', 'rock', 'bush plant', 'crate barrel']) {
+      for (const hit of searchLibrary(index, q, { family, limit: 6 })) {
+        if (picks.length >= n) break;
+        const it = hit.item;
+        if (seen.has(it.id) || it.kind === 'texture' || it.kind === 'sky' || it.rigged) continue;
+        seen.add(it.id);
+        try { const { bytes } = await fetchItemFile(lib, it); picks.push(modelIn(it.id, bytes, { label: it.name })); } catch (error) { log(`library ${it.id}: ${error.message}`); }
+      }
+    }
+    return picks;
+  } catch (error) { log(`no library pieces: ${error.message}`); return []; }
+}
+
+/** Save a data: URL picture under `max` bytes (re-encoding JPEG quality down if it is over). */
+async function savePicture(url, file, max = PICTURE_MAX) {
+  let bytes = saveDataUrl(url, file);
+  if (bytes <= max) return bytes;
+  try {
+    const sharp = (await import('sharp')).default;
+    for (const q of [78, 68, 58]) {
+      const out = await sharp(dataUrlBytes(url).bytes).jpeg({ quality: q, mozjpeg: true }).toBuffer();
+      writeFileSync(file, out);
+      bytes = out.byteLength;
+      if (bytes <= max) break;
+    }
+  } catch { /* kept as it is */ }
+  return bytes;
+}
+
+export async function styleBoard(root, id, { prompt = '', log = () => {}, library = true } = {}) {
+  let doc = readDecisions(root, id);
+  if (!doc) { initDecisions(root, id, { prompt, path: 'hands-on' }); doc = readDecisions(root, id); }
+  const { directions } = directionsFor(root, id, { prompt: prompt || doc.prompt });
+  let game = {};
+  try { game = JSON.parse(readFileSync(join(root, 'games', id, 'game.json'), 'utf8')); } catch { game = {}; }
+  const title = game.name ?? id.split('-').map((w) => w[0].toUpperCase() + w.slice(1)).join(' ');
+  const words = [prompt, doc.prompt, (doc.decisions['cast.list']?.value ?? []).map((c) => c.id).join(' ')].join(' ');
+  const dir = join(root, 'games', id, BOARD_DIR);
+  mkdirSync(dir, { recursive: true });
+  const pieces = {};
+  if (library) for (const d of directions) if (!pieces[d.family]) pieces[d.family] = await libraryPieces(d.family, words, 4, log);
+  const out = [];
+  const renderer = await withRenderer(async (r) => {
+    for (const d of directions) {
+      const url = await r.swatch(tokensOf(d.values), pieces[d.family] ?? [], { title });
+      const file = join(dir, `${d.id}-swatch.jpg`);
+      const bytes = await savePicture(url, file);
+      out.push({ ...d, swatch: relative(join(root, 'games', id), file), bytes, library: (pieces[d.family] ?? []).map((m) => m.id) });
+    }
+    return r.renderer;
+  }, { log });
+  const prev = doc.board?.directions ?? [];
+  doc = readDecisions(root, id);
+  // A pick survives a redraw only while its letter still names the same direction.
+  const was = prev.find((p) => p.id === doc.board?.chosen);
+  const still = was && out.some((d) => d.id === was.id && d.label === was.label);
+  doc.board = {
+    at: new Date().toISOString(), renderer, chosen: still ? was.id : null,
+    directions: out.map((d) => ({ id: d.id, label: d.label, family: d.family, values: d.values, swatch: d.swatch.split('\\').join('/'), library: d.library, mood: prev.find((p) => p.id === d.id && p.label === d.label)?.mood ?? null })),
+  };
+  writeDecisions(root, id, doc);
+  return { ok: true, command: 'style board', id, title, renderer, directions: boardView(root, id, doc) };
+}
+
+/** The board as cards and the CLI show it: per direction its rows (decision, label), swatch path and mood. */
+export function boardView(root, id, doc = readDecisions(root, id)) {
+  return (doc?.board?.directions ?? []).map((d) => ({
+    id: d.id, label: d.label, family: d.family, swatch: d.swatch, mood: d.mood,
+    chosen: doc.board.chosen === d.id,
+    colours: PALETTE_KEYS.map((k) => d.values['style.palette']?.[k]).filter(Boolean),
+    fonts: { display: d.values['style.ui']?.display, body: d.values['style.ui']?.body },
+    rows: Object.entries(d.values).map(([k, v]) => ({ decision: k, label: labelOf(k, v), same: JSON.stringify(doc.decisions[k]?.value) === JSON.stringify(v), state: doc.decisions[k]?.state ?? null })),
+  }));
+}
+
+/** `style mood <id> <dir> --image <file>`: a painted mood image for one direction (made and paid for by the art skill). */
+export async function recordMood(root, id, dirId, image, { usd = null, receipt = null, model = null } = {}) {
+  const doc = readDecisions(root, id);
+  const d = doc?.board?.directions?.find((x) => x.id === dirId);
+  if (!d) throw new Error(`no direction "${dirId}" on the style board (style board ${id} draws it first)`);
+  if (!existsSync(image)) throw new Error(`no picture at ${image}`);
+  const file = join(root, 'games', id, BOARD_DIR, `${dirId}-mood.jpg`);
+  const sharp = (await import('sharp')).default;
+  let q = 82;
+  let out = await sharp(readFileSync(image)).resize(960, 540, { fit: 'cover' }).jpeg({ quality: q, mozjpeg: true }).toBuffer();
+  while (out.byteLength > PICTURE_MAX && q > 50) { q -= 10; out = await sharp(readFileSync(image)).resize(960, 540, { fit: 'cover' }).jpeg({ quality: q, mozjpeg: true }).toBuffer(); }
+  writeFileSync(file, out);
+  d.mood = { path: relative(join(root, 'games', id), file).split('\\').join('/'), usd: usd === null ? null : Number(usd), receipt, model, label: 'target (painted, not what the game draws)', at: new Date().toISOString() };
+  writeDecisions(root, id, doc);
+  return { ok: true, command: 'style mood', id, direction: dirId, mood: d.mood };
+}
+
+/** `style golden <id> add <image>`: one of two to six golden images (references for every concept call). */
+export async function addGolden(root, id, image, { from = null } = {}) {
+  const doc = readDecisions(root, id);
+  if (!doc) throw new Error(`games/${id} has no decisions yet`);
+  if (!existsSync(image)) throw new Error(`no picture at ${image}`);
+  doc.golden = doc.golden ?? [];
+  if (doc.golden.length >= 6) throw new Error('six golden images already: remove one first (style golden <id> remove <n>)');
+  const n = doc.golden.reduce((m, g) => Math.max(m, Number(/(\d+)\.jpg$/.exec(g.path)?.[1] ?? 0)), 0) + 1;
+  const dir = join(root, 'games', id, BOARD_DIR, 'golden');
+  mkdirSync(dir, { recursive: true });
+  const file = join(dir, `${n}.jpg`);
+  try {
+    const sharp = (await import('sharp')).default;
+    writeFileSync(file, await sharp(readFileSync(image)).resize(1024, 1024, { fit: 'inside' }).jpeg({ quality: 84, mozjpeg: true }).toBuffer());
+  } catch { if (/\.jpe?g$/i.test(extname(image))) copyFileSync(image, file); else throw new Error('sharp could not read that picture'); }
+  doc.golden.push({ path: relative(join(root, 'games', id), file).split('\\').join('/'), from: from ?? relative(root, image), approvedBy: 'person', at: new Date().toISOString() });
+  writeDecisions(root, id, doc);
+  addLatestLine(root, id, `Added golden image ${n} (from ${from ?? relative(root, image)}): every concept is made with it as a reference.`);
+  return { ok: true, command: 'style golden', id, golden: doc.golden };
+}
+
+/* ------------------------------------------------------------------ the lineup */
+
+const DRIFT = 18; // mean CIEDE2000 (area-weighted) from the palette above which an asset is flagged
+
+export async function assetsLineup(root, id, { log = () => {} } = {}) {
+  const manifest = readManifest(root, id);
+  const doc = readDecisions(root, id);
+  const tokens = styleTokens(doc) ?? { palette: { bg: '#20242c', ink: '#f2f2f2', accent: '#ffcf5a', accent2: '#7dffb0', danger: '#ff5d5d', good: '#5fdc8b', gold: '#f2c14e', ramp: [] } };
+  const models = [];
+  for (const a of manifest.assets) {
+    const f = (a.files ?? []).find((x) => x.role === 'model');
+    if (!f) continue;
+    const abs = join(root, 'games', id, f.path);
+    if (!existsSync(abs)) continue;
+    // `inGame`: what the game's code does to it at runtime (drawn at another height, repainted from style.json): the
+    // lineup draws it the same way (the repaint as the board's re-tint, the nearest the game's own swap can be shown).
+    const scale = a.inGame?.heightM && a.measured?.heightM ? a.inGame.heightM / a.measured.heightM : null;
+    models.push({ a, input: modelIn(a.id, readFileSync(abs), { label: a.card ? String(a.card).split('/').pop() : a.id, ...(scale ? { scale } : {}), ...(a.inGame?.tint ? { tint: lightColours({ sky: a.inGame.tint, ground: a.inGame.tint }, tokens.palette).sky } : a.inGame?.repaint ? { retint: true } : Number(a.inGame?.pull) > 0 ? { pull: Number(a.inGame.pull) } : {}) }), abs });
+  }
+  if (!models.length) return { ok: false, command: 'assets lineup', id, why: `games/${id} has no recorded models yet (assets add, or the models skill)` };
+  const dir = join(root, '.studio', 'art', id);
+  mkdirSync(dir, { recursive: true });
+  const shot = await withRenderer(async (r) => ({ renderer: r.renderer, ...(await r.lineup(models.map((m) => m.input), tokens)) }), { log });
+  const images = { front: join(dir, 'lineup-front.jpg'), quarter: join(dir, 'lineup-quarter.jpg'), silhouettes: join(dir, 'lineup-silhouettes.png') };
+  saveDataUrl(shot.front, images.front); saveDataUrl(shot.quarter, images.quarter); saveDataUrl(shot.silhouettes, images.silhouettes);
+  const palette = [...PALETTE_KEYS.map((k) => tokens.palette[k]), ...(tokens.palette.ramp ?? [])].filter(Boolean);
+  const family = doc?.decisions?.['cast.family']?.value ?? null;
+  const check = await assetsCheck(root, id, { validate: false, write: true }).catch(() => null);
+  const stale = doc ? staleAssets(doc, manifest) : [];
+  const { albedoOf } = await import('./optimise.mjs');
+  const rows = [];
+  for (const m of models) {
+    const flags = [];
+    let drift = null;
+    try {
+      const colours = await albedoOf(m.abs);
+      // A model the game pulls toward the palette (inGame.pull) is scored on the colours it is drawn in.
+      const pull = Math.max(0, Math.min(1, Number(m.a.inGame?.pull) || 0));
+      const drawn = colours.map((c) => (pull ? { ...c, hex: mix(c.hex, nearest(c.hex, palette).hex, pull) } : c));
+      const scored = drawn.map((c) => { const n = nearest(c.hex, palette); return { hex: c.hex, share: c.share, palette: n.hex, delta: +n.delta.toFixed(1) }; });
+      const mean = scored.reduce((n, c) => n + c.delta * c.share, 0) / Math.max(0.0001, scored.reduce((n, c) => n + c.share, 0));
+      drift = { mean: +mean.toFixed(1), colours: scored };
+      if (m.a.inGame?.repaint) drift.repaint = m.a.inGame.repaint;
+      else if (mean > DRIFT) flags.push(`palette drift: its colours sit ${drift.mean} from the palette (over ${DRIFT}); a re-tint (free) or a remake`);
+    } catch (error) { log(`${m.a.id}: colours not read (${error.message})`); }
+    const row = shot.rows.find((x) => x.id === m.a.id);
+    if (row && ['character', 'creature'].includes(m.a.kind) && (row.silhouette.widthPx < 6 || row.silhouette.fill > 0.92)) flags.push(`silhouette: ${row.silhouette.widthPx < 6 ? 'too thin to read at 64 px' : 'a blob at 64 px (no limbs, ears or tail break the outline)'}`);
+    const c = check?.rows?.find((x) => x.id === m.a.id);
+    if (c && !c.ok) flags.push(`over budget: ${c.problems[0]}`);
+    if (family && m.a.route === 'library' && m.a.from?.pack && !String(m.a.from.pack).startsWith(family)) flags.push(`another library family (${m.a.from.pack}; the game's is ${family}): mixing families shows`);
+    if (stale.some((s) => s.id === m.a.id)) flags.push('stale: made under an older decision');
+    rows.push({ id: m.a.id, label: m.input.label, kind: m.a.kind, route: m.a.route, size: row?.size ?? null, silhouette: row?.silhouette ?? null, drift, flags });
+  }
+  const result = { ok: true, command: 'assets lineup', id, renderer: shot.renderer, images: Object.fromEntries(Object.entries(images).map(([k, v]) => [k, relative(root, v)])), rows, palette: palette.slice(0, 7), family, at: new Date().toISOString(), flagged: rows.filter((r) => r.flags.length).length };
+  writeFileSync(join(dir, 'lineup.json'), `${JSON.stringify(result, null, 2)}\n`);
+  return result;
+}
+
+/** `assets review <id> --score n --outliers a,b`: a fresh reviewer's "one game?" score, and the assets it named. */
+export function recordReview(root, id, { score, outliers = [], note = null, by = 'reviewer' } = {}) {
+  const s = Number(score);
+  if (!(s >= 1 && s <= 10)) throw new Error('--score 1 to 10 ("does it look like one game?")');
+  const dir = join(root, '.studio', 'art', id);
+  mkdirSync(dir, { recursive: true });
+  const manifest = readManifest(root, id);
+  const needs = new Set(outliers.filter(Boolean));
+  if (s < 7) for (const a of manifest.assets) if (a.route !== 'procedural') needs.add(a.id);
+  const review = { score: s, outliers: [...needs], note, by, at: new Date().toISOString(), verdict: s >= 7 && !outliers.length ? 'one game' : 'needs review' };
+  writeFileSync(join(dir, 'review.json'), `${JSON.stringify(review, null, 2)}\n`);
+  return { ok: true, command: 'assets review', id, review };
+}
+

package/lib/style-presets.mjs

@@ -0,0 +1,121 @@
+/**
+ * THE STYLE VOCABULARY the decisions pick from (lib/decisions.mjs): render styles, named palettes, light and camera
+ * set-ups, fonts and the starter library's families, each with the words in a prompt that point at it. Taste, kept
+ * as data: the automatic path reads it, the style board mixes it, and a person steers past it with their own values.
+ */
+
+/** How the world is drawn. `family`: the starter library family that fits; `materials`: the material model. */
+export const RENDERS = Object.freeze({
+  'lowpoly-flat': { label: 'Flat low-poly', words: /\b(low[- ]?poly|cozy|cosy|cute|toy|minimal|clean|simple|wholesome|chill)\b/i, materials: 'flat', outline: false, family: 'kenney', fonts: { display: 'Fredoka', body: 'Nunito' }, vfx: 'soft', note: 'faceted shapes in flat palette colours: the cheapest look on a phone, the most coherent, and the richest free library' },
+  toon: { label: 'Toon / cel', words: /\b(toon|cel|cartoon|anime|comic|neon|cyber|synth|arcade)\b/i, materials: 'toon', outline: true, family: 'kaykit', fonts: { display: 'Lilita One', body: 'Nunito' }, vfx: 'toon', note: 'banded light and ink outlines: reads at any size, loud on a TV' },
+  painted: { label: 'Stylised hand-painted', words: /\b(painterly|painted|storybook|watercolou?r|ghibli-like|fairy ?tale|whimsical|hand[- ]painted)\b/i, materials: 'hand-painted', outline: false, family: 'kaykit', fonts: { display: 'Fraunces', body: 'Lora' }, vfx: 'soft', note: 'soft painted albedo with the light baked gently in: warm and storybook' },
+  'stylised-pbr': { label: 'Stylised PBR', words: /\b(realistic|real|photo|gritty|grounded|military|pbr)\b/i, materials: 'pbr', outline: false, family: 'polyhaven', fonts: { display: 'Rajdhani', body: 'Inter' }, vfx: 'soft', note: 'metal and roughness under real light: the most expensive look on a phone (textures and memory)' },
+  'pixel-hd2d': { label: 'Pixel / HD-2D', words: /\b(pixel|8[- ]?bit|16[- ]?bit|retro|hd[- ]?2d|sprite)\b/i, materials: 'pixel', outline: false, family: 'kenney', fonts: { display: 'Press Start 2P', body: 'Silkscreen' }, vfx: 'pixel', note: 'pixel sprites in a low-poly world with tilt-shift and bloom (the sprite branch is phase 3; the board shows the world)' },
+  voxel: { label: 'Voxel', words: /\b(voxel|blocky|blocks|cube|minecraft-like)\b/i, materials: 'flat', outline: false, family: 'kenney', fonts: { display: 'Silkscreen', body: 'Nunito' }, vfx: 'pixel', note: 'everything built of cubes: crisp, cheap, playful' },
+});
+
+/** The codex keys every palette fills (frontmatter `palette`), plus `ramp`: 12 to 16 colours for textures. */
+export const PALETTE_KEYS = Object.freeze(['bg', 'ink', 'accent', 'accent2', 'danger', 'good', 'gold']);
+
+export const PALETTES = Object.freeze({
+  'autumn-grove': { label: 'Autumn grove: rust, moss and cream', words: /\b(forest|woods?|grove|autumn|fall|fox(es)?|berr(y|ies)|mushroom|acorn|leaf|leaves)\b/i,
+    bg: '#1f2a24', ink: '#f6ecd9', accent: '#e9893a', accent2: '#8fbf5a', danger: '#e2553f', good: '#7fcf6a', gold: '#f2c14e',
+    ramp: ['#2c3b31', '#3f5640', '#5d7a4a', '#8fbf5a', '#c9d98a', '#6b4a2f', '#9a6a3d', '#c98a4b', '#e9893a', '#b8442e', '#f6ecd9', '#d9c7a3', '#f2c14e', '#7a5a8c'] },
+  'meadow-morning': { label: 'Meadow morning: sky blue, grass and butter', words: /\b(meadow|farm|garden|spring|sunny|bright|happy|picnic|village)\b/i,
+    bg: '#cfe8f5', ink: '#1d2b3a', accent: '#ff8a5b', accent2: '#5cbf8a', danger: '#e2553f', good: '#45b36b', gold: '#ffd25a',
+    ramp: ['#9fd3ef', '#cfe8f5', '#f8f3e6', '#8fd06a', '#5cbf8a', '#3f8f5a', '#ffd25a', '#ffb347', '#ff8a5b', '#e86a6a', '#b07ad9', '#8a6a4a', '#5a4a3a', '#ffffff'] },
+  'embers-night': { label: 'Embers at night: warm golds on soot', words: /\b(fire|ember|lava|volcano|forge|torch|lantern|burning|ash(en)?)\b/i,
+    bg: '#120c0a', ink: '#f6e7d3', accent: '#f4b23c', accent2: '#7ad38a', danger: '#ff5a4e', good: '#5fdc8b', gold: '#f2c14e',
+    ramp: ['#120c0a', '#2b1d16', '#4a2e20', '#6e3b22', '#a4512a', '#e0702f', '#f4b23c', '#ffd98a', '#f6e7d3', '#7ad38a', '#3f6b4a', '#5a4a6e'] },
+  'neon-dusk': { label: 'Neon dusk: magenta and cyan on ink', words: /\b(neon|cyber|synth(wave)?|city|night ?club|future|retro[- ]future|laser)\b/i,
+    bg: '#0b0a1a', ink: '#eef0ff', accent: '#ff3fa4', accent2: '#2ee6f2', danger: '#ff4d4d', good: '#4dff9a', gold: '#ffd84a',
+    ramp: ['#0b0a1a', '#1a1438', '#2c1f5e', '#4b2a8c', '#7a35c4', '#ff3fa4', '#ff7ac8', '#2ee6f2', '#7af3ff', '#ffd84a', '#eef0ff', '#3a3a5e'] },
+  'candy-pop': { label: 'Candy pop: bubblegum and mint', words: /\b(candy|sweet|sugar|pastel|toy|kawaii|party|bubble|jelly)\b/i,
+    bg: '#fff2f7', ink: '#2a1f3d', accent: '#ff5fa2', accent2: '#4fd1c5', danger: '#ff4f64', good: '#40c07a', gold: '#ffc94d',
+    ramp: ['#fff2f7', '#ffd6e8', '#ff9ec7', '#ff5fa2', '#c45fd1', '#8a7cff', '#4fd1c5', '#a6f0d9', '#ffc94d', '#ff9a5a', '#2a1f3d', '#ffffff'] },
+  'frost-blue': { label: 'Frost: ice blue and snow', words: /\b(snow|ice|icy|winter|frost|frozen|arctic|polar|penguin)\b/i,
+    bg: '#eaf3fb', ink: '#14243a', accent: '#3d8bff', accent2: '#8fe3ff', danger: '#ff5a6a', good: '#41c08a', gold: '#ffcc4d',
+    ramp: ['#ffffff', '#eaf3fb', '#cfe2f5', '#a9cbee', '#7fb0e6', '#3d8bff', '#2a5fb0', '#14243a', '#8fe3ff', '#c7f3ff', '#ffcc4d', '#b4a3d9'] },
+  'desert-noon': { label: 'Desert noon: sand, terracotta and turquoise', words: /\b(desert|sand|dune|canyon|western|cowboy|egypt|pyramid|savanna)\b/i,
+    bg: '#f5e2c0', ink: '#3a2412', accent: '#d9653b', accent2: '#2bb3a8', danger: '#c8322a', good: '#5aa84a', gold: '#f2b632',
+    ramp: ['#fff3dc', '#f5e2c0', '#e8c48f', '#d9a35f', '#c47a3f', '#d9653b', '#a8452a', '#6e2e1a', '#3a2412', '#2bb3a8', '#7ad3c8', '#f2b632'] },
+  'deep-sea': { label: 'Deep sea: teal dark with coral', words: /\b(ocean|sea|under ?water|reef|coral|fish|submarine|diver?|pirate|island|beach)\b/i,
+    bg: '#06222e', ink: '#e6fbff', accent: '#ff7a59', accent2: '#3fe0c5', danger: '#ff5a6a', good: '#5fe08a', gold: '#ffd166',
+    ramp: ['#03141b', '#06222e', '#0b3a4a', '#11566a', '#1a7a8c', '#3fe0c5', '#a6f5e6', '#ff7a59', '#ffb08a', '#ffd166', '#e6fbff', '#5a4a8c'] },
+  'moonlit-grove': { label: 'Moonlit grove: indigo, silver and firefly', words: /\b(night|moon(lit)?|dark|spooky|haunted|ghost|witch|owl|halloween|grave)\b/i,
+    bg: '#0e1430', ink: '#e8ecff', accent: '#c9a8ff', accent2: '#b8f26a', danger: '#ff5e7a', good: '#6fe0a0', gold: '#ffe08a',
+    ramp: ['#070a1c', '#0e1430', '#1b2350', '#2c3770', '#47509a', '#7c84c9', '#c9a8ff', '#e8ecff', '#b8f26a', '#ffe08a', '#3a5a4a', '#5e3a5a'] },
+  'heroic-dawn': { label: 'Heroic dawn: steel blue and gold', words: /\b(hero(ic)?|epic|fantasy|kingdom|castle|knight|quest|rpg|dungeon|sword|dragon|adventure)\b/i,
+    bg: '#1a2238', ink: '#f3efe6', accent: '#e8b84a', accent2: '#6aa8e0', danger: '#e04a3a', good: '#5ac07a', gold: '#f2c14e',
+    ramp: ['#0f1526', '#1a2238', '#2c3a5c', '#4a5f8c', '#6aa8e0', '#b8d4f0', '#f3efe6', '#d9c49a', '#e8b84a', '#a8742a', '#8c3a2a', '#4a6a3a'] },
+  'space-ink': { label: 'Space: ink black with signal orange', words: /\b(space|galaxy|planet|star(ship)?|rocket|alien|asteroid|sci[- ]?fi|moon ?base|orbit)\b/i,
+    bg: '#07080f', ink: '#eef2ff', accent: '#ff8a3d', accent2: '#5ad1ff', danger: '#ff4d5e', good: '#59e08a', gold: '#ffd24d',
+    ramp: ['#07080f', '#11142a', '#1e2447', '#2f3a6e', '#4a5aa0', '#5ad1ff', '#b8ecff', '#eef2ff', '#ff8a3d', '#ffb87a', '#ffd24d', '#8c5ad9'] },
+  'ash-dawn': { label: 'Ash dawn: muted greys with rose', words: /\b(ruin(s|ed)?|post[- ]?apocalyp\w*|grim|bleak|ash|ashen|wasteland|mist(y)?|fog(gy)?|quiet|melanchol\w*)\b/i,
+    bg: '#2a2a2e', ink: '#ece6e0', accent: '#e8927c', accent2: '#9cb8b0', danger: '#d9584a', good: '#86b886', gold: '#d9b86a',
+    ramp: ['#1a1a1e', '#2a2a2e', '#3e3d42', '#57555c', '#7a7680', '#a49ea6', '#ece6e0', '#e8927c', '#c26a5a', '#9cb8b0', '#6a8a84', '#d9b86a'] },
+});
+
+/** Light set-ups (the style.light decision). `key`: the sun's direction (from the light toward the scene). */
+export const LIGHTS = Object.freeze({
+  morning: { label: 'Soft morning', words: /\b(morning|dawn|spring|fresh)\b/i, key: [-0.5, -1, -0.35], intensity: 2.2, hardness: 0.35, sky: 'mix:bg>#ffffff:0.35', ground: 'mix:accent2>bg:0.25', fog: 0.35, shadows: 'blob', toonSteps: 3, bloom: 0.1, tiltShift: false },
+  noon: { label: 'Bright noon', words: /\b(noon|midday|sunny|bright|desert|beach)\b/i, key: [-0.2, -1, -0.15], intensity: 2.8, hardness: 0.75, sky: 'mix:bg>#ffffff:0.5', ground: 'mix:gold>accent2:0.45', fog: 0.2, shadows: 'blob', toonSteps: 2, bloom: 0.05, tiltShift: false },
+  golden: { label: 'Golden hour', words: /\b(golden|sunset|dusk|evening|warm|autumn|fall)\b/i, key: [-0.85, -0.55, -0.25], intensity: 2.4, hardness: 0.55, sky: 'mix:accent>#ffffff:0.45', ground: 'mix:accent2>accent:0.3', fog: 0.45, shadows: 'blob', toonSteps: 3, bloom: 0.25, tiltShift: false },
+  night: { label: 'Moonlight and lamps', words: /\b(night|moon(lit)?|dark|spooky|neon|stars?|lantern|ember|fire)\b/i, key: [0.4, -1, 0.3], intensity: 1.1, hardness: 0.4, sky: 'bg', ground: 'mix:accent2>bg:0.6', fog: 0.6, shadows: 'blob', toonSteps: 3, bloom: 0.5, tiltShift: false },
+  overcast: { label: 'Soft overcast', words: /\b(overcast|cloudy|grey|gray|misty|fog(gy)?|ash|quiet)\b/i, key: [-0.3, -1, -0.2], intensity: 1.6, hardness: 0.15, sky: 'mix:bg>#ffffff:0.25', ground: 'mix:accent2>bg:0.5', fog: 0.7, shadows: 'blob', toonSteps: 2, bloom: 0.05, tiltShift: false },
+});
+
+/** Camera set-ups (the style.camera decision): distance in metres, field of view in degrees, the angle above the ground. */
+export const CAMERAS = Object.freeze({
+  'high-3/4': { label: 'High three-quarter', projection: 'perspective', pitch: 52, distance: 22, fov: 38, note: 'the whole arena and every player readable on a phone' },
+  'low-3/4': { label: 'Low three-quarter', projection: 'perspective', pitch: 34, distance: 20, fov: 42, note: 'down among the players, the woods beyond the clearing in view: a place, not a board' },
+  'close-3/4': { label: 'Close three-quarter', projection: 'perspective', pitch: 40, distance: 11, fov: 42, note: 'nearer the characters: more detail on screen, less of the world' },
+  iso: { label: 'Isometric', projection: 'orthographic', pitch: 35.264, distance: 20, fov: 30, note: 'a diorama: tidy and readable, the HD-2D and tactics look' },
+  'top-down': { label: 'Top-down', projection: 'perspective', pitch: 80, distance: 24, fov: 35, note: 'the map is the screen: best for a crowd and for aiming' },
+  chase: { label: 'Chase', projection: 'perspective', pitch: 18, distance: 7, fov: 60, note: 'behind the player: speed and scale, one body at a time' },
+  side: { label: 'Side', projection: 'perspective', pitch: 6, distance: 14, fov: 35, note: 'a platformer\'s view: jumps read exactly' },
+});
+
+/** Genres (from the prompt and the codex), with the defaults they bring. */
+export const GENRES = Object.freeze({
+  gather: { words: /\b(gather|collect|harvest|forag\w*|berr(y|ies)|gems?|coins?|pick ?up|treasure|loot|farm)\b/i, camera: 'low-3/4', heads: 2.5, heightM: 0.9, clips: ['idle', 'walk', 'run', 'pick-up', 'emote'] },
+  brawl: { words: /\b(brawl|fight|arena|knock|bump|smash|wrestl\w*|sumo|battle royale)\b/i, camera: 'high-3/4', heads: 2.5, heightM: 1.0, clips: ['idle', 'run', 'jump', 'attack', 'hit', 'die'] },
+  race: { words: /\b(race|racing|kart|car|drive|driving|drift|speed)\b/i, camera: 'chase', heads: 3, heightM: 1.0, clips: ['idle', 'drive', 'boost', 'crash'] },
+  rpg: { words: /\b(rpg|quest|dungeon|adventure|mmo|wow|zones?|class(es)?|loot|level up)\b/i, camera: 'iso', heads: 4.5, heightM: 1.7, clips: ['idle', 'walk', 'run', 'attack', 'cast', 'hit', 'die', 'interact'] },
+  platformer: { words: /\b(platform(er)?|jump(ing)?|parkour|climb)\b/i, camera: 'side', heads: 3, heightM: 1.1, clips: ['idle', 'run', 'jump', 'fall', 'land'] },
+  shooter: { words: /\b(shoot(er|ing)?|blaster|gun|laser|tank|twin[- ]stick)\b/i, camera: 'top-down', heads: 5, heightM: 1.8, clips: ['idle', 'run', 'aim', 'shoot', 'hit', 'die'] },
+  party: { words: /\b(party|mini[- ]?games?|silly|chaos|couch)\b/i, camera: 'high-3/4', heads: 2.5, heightM: 1.0, clips: ['idle', 'run', 'jump', 'emote', 'win'] },
+  puzzle: { words: /\b(puzzle|match|tiles?|board game|cards?|chess)\b/i, camera: 'top-down', heads: 3, heightM: 1.0, clips: ['idle', 'emote', 'win'] },
+  sports: { words: /\b(soccer|football|golf|basketball|hockey|ball|sports?)\b/i, camera: 'high-3/4', heads: 3, heightM: 1.2, clips: ['idle', 'run', 'kick', 'jump', 'win'] },
+});
+
+/** Starter library families: which look each belongs to. */
+export const FAMILIES = Object.freeze({
+  kenney: { label: 'Kenney (CC0)', renders: ['lowpoly-flat', 'voxel', 'pixel-hd2d'], note: 'clean flat-colour low-poly kits: nature, food, pets, dungeons, cars' },
+  kaykit: { label: 'KayKit (CC0)', renders: ['toon', 'painted'], note: 'stylised gradient-atlas low-poly: adventurers, dungeons, props' },
+  polyhaven: { label: 'Poly Haven (CC0)', renders: ['stylised-pbr'], note: 'photo-scanned props, materials and skies' },
+});
+
+/** Shape language words. */
+export const SHAPES = Object.freeze({
+  round: { label: 'Round and soft', words: /\b(cozy|cosy|cute|soft|friendly|gentle|bubbly|kids?|round)\b/i, bevel: 0.6, note: 'round silhouettes and big soft bevels: friendly at a glance' },
+  angular: { label: 'Angular and sharp', words: /\b(tense|dark|grim|aggressive|sharp|edgy|horror|cyber|military)\b/i, bevel: 0.1, note: 'pointed silhouettes and crisp edges: tension and speed' },
+  blocky: { label: 'Blocky', words: /\b(blocky|voxel|cube|lego|toy|robot)\b/i, bevel: 0.25, note: 'boxes with small bevels: toy-like and readable' },
+});
+
+/** Google Fonts (OFL) by mood, for style.ui. */
+export const FONT_SETS = Object.freeze({
+  friendly: { display: 'Fredoka', body: 'Nunito' },
+  bold: { display: 'Lilita One', body: 'Nunito' },
+  storybook: { display: 'Fraunces', body: 'Lora' },
+  clean: { display: 'Rajdhani', body: 'Inter' },
+  pixel: { display: 'Press Start 2P', body: 'Silkscreen' },
+  future: { display: 'Orbitron', body: 'Inter' },
+});
+
+/** Which words mean which mood (palette, light and shape read them). */
+export const MOODS = Object.freeze({
+  cozy: /\b(cozy|cosy|cute|warm|gentle|calm|chill|relax\w*|wholesome|soft|friendly|sweet)\b/i,
+  tense: /\b(tense|dark|grim|horror|scary|creepy|spooky|survival|hardcore)\b/i,
+  loud: /\b(neon|loud|wild|chaos|crazy|party|arcade|electric)\b/i,
+});