@gtanczyk/diorama 0.3.0 → 0.4.1

package/app/src/actions/story.ts

@@ -82,6 +82,33 @@ defineAction({
   },
 });
 
+defineAction({
+  name: 'story_look',
+  description: 'Set what the hero says looking at one thing (a sign, a prop, a car), adding the look line where the story has none and rewording it where it has one. '
+    + 'Nothing else in the story changes (story_redo would write it all again). Kept across rebuilds. A spoken line needs run_step voices afterwards.',
+  input: z.object({ slug: Slug, place: Slug, thing: Slug, text: z.string().trim().min(1).max(400) }),
+  async run({ slug, place, thing, text }, ctx) {
+    const files = open(slug, ctx);
+    const blocked = agentBlocked(files.dir, ctx.by);
+    if (blocked) throw new ActionError(423, blocked);
+    const story = readStory(files);
+    if (!story) throw new ActionError(409, `${slug} has no story yet: run_step story first`);
+    const spot = files.world().places.find((p) => p.key === place);
+    if (!spot) throw new ActionError(400, `${place} is not a place of ${slug}`);
+    if (!spot.things.some((t) => t.key === thing)) throw new ActionError(400, `${thing} is not a thing in ${place}: ${spot.things.map((t) => t.key).join(', ')}`);
+    const busy = ctx.jobs.busy(slug);
+    if (busy) throw new ActionError(409, `${busy.label} is ${busy.state}; wait before editing story text`);
+    new History(files.dir).snapshot(`story look ${place}/${thing}`, ctx.by);
+    const fixes = readStoryFixes(files);
+    const look = { text, at: new Date().toISOString() };
+    fixes.looks = { ...fixes.looks, [`${place}/${thing}`]: look };
+    files.write(storyFixesFile(files), StoryFixes.parse(fixes));
+    const now = applyTexts(story, { texts: {}, looks: { [`${place}/${thing}`]: look } }).story;
+    files.write(files.path('story.json'), now);
+    return { place, thing, text, spoken: storyLines(files.world(), now).some((l) => l.text === text) };
+  },
+});
+
 defineAction({
   name: 'story_redo',
   description: 'Have Spark write the story again to a wish ("the ferrywoman should want something in return", "after receiving the key she goes to the garden and thanks me there"); '
@@ -95,7 +122,7 @@ defineAction({
     const blocked = agentBlocked(files.dir, ctx.by);
     if (blocked) throw new ActionError(423, blocked);
     return ctx.jobs.start(slug, ['story', slug], wish ? 'rewrite story' : 'first story', ctx.by, () => {
-      files.write(storyFixesFile(files), StoryFixes.parse({ ...(wish && { wish }), texts: {} }));
+      files.write(storyFixesFile(files), StoryFixes.parse({ ...(wish && { wish }), texts: {}, looks: readStoryFixes(files).looks }));
     });
   },
 });

package/app/src/actions/studio.ts

@@ -8,6 +8,8 @@ import { soundQuality } from '../sound/cost.ts';
 import { writeSoundQuality } from '../sound/settings.ts';
 import { blenderEnv, blenderState, writeBlenderSettings } from '../model/blender.ts';
 import { facesState, writeFacesSettings } from '../scene/faces-settings.ts';
+import { installChromium } from '../commands/browsers.ts';
+import { cli } from '../cli.ts';
 
 const audioState = () => ({ quality: soundQuality(), env: process.env.DIORAMA_SOUND ?? null });
 
@@ -87,6 +89,29 @@ defineAction({
   },
 });
 
+defineAction({
+  name: 'setup_cli',
+  reads: true,
+  description: 'The command that runs diorama in a terminal on this machine (diorama, npx @gtanczyk/diorama or npm run diorama --), for hints to the person.',
+  input: z.object({}),
+  async run() {
+    return { command: cli(), setup: cli('setup') };
+  },
+});
+
+let downloading: Promise<unknown> | null = null;
+
+defineAction({
+  name: 'setup_browsers',
+  description: 'Download Chromium for Explore, the playthrough bot and sprites (Playwright, ~150 MB, once), then check the machine again. Ask the person first.',
+  input: z.object({}),
+  async run(_input, ctx) {
+    downloading ??= installChromium([], (line) => /\d%/.test(line) && !/100%/.test(line) ? undefined : ctx.events.publish('log', { stream: 'out', line: `chromium: ${line}` })).finally(() => (downloading = null));
+    await downloading;
+    return runChecks();
+  },
+});
+
 defineAction({
   name: 'ui_focus',
   description: 'Point the Studio view at a world, a screen or a place, so the person sees what the agent is talking about (when they follow the agent).',

package/app/src/actions/style.ts

@@ -4,6 +4,7 @@ import { z } from 'zod';
 import { readCastFixes } from '../scene/cast-fixes.ts';
 import { readCorrections } from '../scene/corrections.ts';
 import { agentBlocked } from '../studio/locks.ts';
+import { kidsWorld } from '../world/drawings.ts';
 import { WorldFiles } from '../world/files.ts';
 import { Slug } from '../world/schema.ts';
 import { castKeys, planLine, SCOPES, stylePlan } from '../world/style-plan.ts';
@@ -22,7 +23,7 @@ defineAction({
     const fixes = readCastFixes(files);
     return {
       style: world.style,
-      kids: world.audience === 'kids' || fs.existsSync(files.path('drawings')),
+      kids: kidsWorld(files, world),
       places: Object.fromEntries(world.places.map((p) => [p.key, readCorrections(files.place(p.key)).style ?? null])),
       cast: Object.fromEntries(castKeys(world, files).map((k) => [k, fixes[k]?.style ?? null])),
       painted: readStyled(files),
@@ -53,7 +54,7 @@ defineAction({
     if (scope === 'cast' && key && !castKeys(world, files).includes(key)) throw new ActionError(404, `${slug} has no character ${key}: ${castKeys(world, files).join(', ')}`);
     if (scope === 'world' && key) throw new ActionError(400, 'scope world takes no key');
     const plan = stylePlan(files, world, scope, key);
-    const kids = world.audience === 'kids' || fs.existsSync(files.path('drawings'));
+    const kids = kidsWorld(files, world);
     if (!go) {
       return {
         estimate: plan,

package/app/src/cli.ts

@@ -0,0 +1,53 @@
+// How to run diorama again from this shell, so every hint (setup fixes, errors, the Studio's Setup cards, the
+// agent's prompt) shows a command that works: `npx @gtanczyk/diorama` when it was started through npx, `diorama`
+// when the global install is on PATH, `npm run diorama --` from a checkout.
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
+const BIN = path.join(ROOT, 'app', 'bin', 'diorama.mjs');
+const PACKAGE = '@gtanczyk/diorama';
+
+const real = (p: string) => {
+  try {
+    return fs.realpathSync(p);
+  } catch {
+    return null;
+  }
+};
+
+/** A `diorama` on PATH that is this very package (npx and npm scripts put their own node_modules/.bin first: not those). */
+function globalOnPath(): boolean {
+  const mine = real(BIN);
+  for (const dir of (process.env.PATH ?? '').split(path.delimiter)) {
+    if (!dir || dir.split(/[\\/]/).slice(-2).join('/') === 'node_modules/.bin') continue;
+    if (real(path.join(dir, 'diorama')) === mine) return true;
+    // Windows: npm's global shim sits next to the package's node_modules folder, not as a link.
+    if (process.platform === 'win32' && fs.existsSync(path.join(dir, 'diorama.cmd')) && real(path.join(dir, 'node_modules', '@gtanczyk', 'diorama')) === real(ROOT)) return true;
+  }
+  return false;
+}
+
+function detect(): string {
+  if (process.env.DIORAMA_CLI) return process.env.DIORAMA_CLI;
+  const parts = ROOT.split(/[\\/]/);
+  if (parts.includes('_npx')) return `npx ${PACKAGE}`;
+  if (globalOnPath()) return 'diorama';
+  if (!parts.includes('node_modules') && fs.existsSync(path.join(ROOT, '.git'))) return 'npm run diorama --';
+  return `npx ${PACKAGE}`;
+}
+
+let prefix: string | null = null;
+
+/** The command to type for `diorama <rest>` here, e.g. cli('browsers') → `npx @gtanczyk/diorama browsers`. */
+export function cli(rest = ''): string {
+  prefix ??= detect();
+  return rest ? `${prefix} ${rest}` : prefix;
+}
+
+/** Rewrites the `diorama <command>` a message names (a usage line, an error) into the command that works here. */
+export function cliText(text: string): string {
+  if (cli() === 'diorama') return text;
+  return text.replace(/(^|usage: |`|run )diorama (?=[a-z])/g, (_, lead: string) => `${lead}${cli()} `);
+}

package/app/src/commands/browsers.ts

@@ -1,21 +1,37 @@
 // diorama browsers: downloads Chromium for the Playwright that ships with diorama, so explore, playthrough and
 // sprites work the same from a checkout, a global install or npx (a bare `npx playwright` may fetch another version).
+// `diorama setup` and the Studio's Setup page offer the same download, so nobody has to find this command.
 import { spawn } from 'node:child_process';
 import { createRequire } from 'node:module';
 import path from 'node:path';
 import { defineCommand } from '../registry.ts';
 
+/** Runs Playwright's installer for Chromium; `onLine` gets its output (the terminal gets it as is when absent). */
+export async function installChromium(args: string[] = [], onLine?: (line: string) => void): Promise<void> {
+  const cli = path.join(path.dirname(createRequire(import.meta.url).resolve('playwright/package.json')), 'cli.js');
+  const code = await new Promise<number>((resolve) => {
+    // Loaded through -e so argv[1] is not the npx cache path, which makes Playwright warn about missing project dependencies.
+    const child = spawn(process.execPath, ['-e', `require(${JSON.stringify(cli)})`, 'diorama-browsers', 'install', 'chromium', ...args], { stdio: onLine ? ['ignore', 'pipe', 'pipe'] : 'inherit' });
+    if (onLine) {
+      for (const stream of [child.stdout, child.stderr]) {
+        let rest = '';
+        stream?.setEncoding('utf8').on('data', (chunk: string) => {
+          const lines = (rest + chunk).split(/\r?\n|\r/);
+          rest = lines.pop() ?? '';
+          for (const line of lines) if (line.trim()) onLine(line);
+        });
+      }
+    }
+    child.on('error', () => resolve(1));
+    child.on('close', (c) => resolve(c ?? 1));
+  });
+  if (code !== 0) throw new Error(`playwright install chromium exited with ${code}`);
+}
+
 defineCommand({
   name: 'browsers',
   usage: 'browsers                download Chromium for explore, playthrough and sprites (Playwright, ~150 MB, once)',
   async run(args) {
-    const cli = path.join(path.dirname(createRequire(import.meta.url).resolve('playwright/package.json')), 'cli.js');
-    const code = await new Promise<number>((resolve) => {
-      // Loaded through -e so argv[1] is not the npx cache path, which makes Playwright warn about missing project dependencies.
-      const child = spawn(process.execPath, ['-e', `require(${JSON.stringify(cli)})`, 'diorama-browsers', 'install', 'chromium', ...args], { stdio: 'inherit' });
-      child.on('error', () => resolve(1));
-      child.on('close', (c) => resolve(c ?? 1));
-    });
-    if (code !== 0) throw new Error(`playwright install chromium exited with ${code}`);
+    await installChromium(args);
   },
 });

package/app/src/commands/clip.ts

@@ -149,6 +149,13 @@ async function gameTake(port: number, work: string, actions: Action[], zoom: boo
         clicks.push({ wall: await rec.click(at.x, at.y, { ms: 450, dwell: 150 }), ...at, place: here, action: a });
         continue;
       }
+      if (a.kind === 'go' && a.to) {
+        // A car's destination is picked on the board the page shows over it.
+        const at = await page.evaluate(`window.diorama.destinationPoint(${JSON.stringify(a.to)})`) as { x: number; y: number } | null;
+        if (!at) throw new Error(`no destination ${a.to} on the board`);
+        clicks.push({ wall: await rec.click(at.x, at.y, { ms: 650 }), ...at, place: here, action: a });
+        continue;
+      }
       const step: { use: string; verb?: string; with?: string } = a.kind === 'go' ? { use: a.via } : a.kind === 'talk' ? { use: a.npc } : { use: a.thing, verb: a.verb, ...(a.with ? { with: a.with } : {}) };
       // The bag is hidden in the clip: the item is lifted from it unseen and rides the cursor to its target.
       const pick = async () => {

package/app/src/commands/derive.ts

@@ -156,6 +156,15 @@ defineCommand({
         });
         console.log(`  ${place.key}: closed ${faced.closed} walk cells on an upright face (feet over thin air)${faced.beyond ? ` and ${faced.beyond} only they led to` : ''}`);
       }
+      if (place.kind === 'drive') {
+        // A drive's scenery streams past, so everything one clicks stays put as a card of its own (a road sign
+        // left in the scenery would slide away from where it is clicked).
+        const carded = new Set(geometry.occluders.map((o) => o.thing ?? o.key));
+        for (const t of geometry.things) {
+          if (carded.has(t.key) || !t.mask || t.role === 'npc') continue;
+          geometry.occluders.push({ key: `${t.key}#1`, thing: t.key, box: t.box, mask: t.mask, baseY: t.box[3] });
+        }
+      }
       files.write(at('geometry.json'), geometry);
       files.write(at('walk.png'), await walkPicture(painting, geometry, out.footprint));
       ran(at(), 'derive', carry?.old ?? painting);

package/app/src/commands/explore.ts

@@ -9,6 +9,7 @@ import { CROP_JS, PROBE_JS, type ProbeHit } from '../qa/probe.ts';
 import { defineCommand, takeOption } from '../registry.ts';
 import { WorldFiles } from '../world/files.ts';
 import { serveWorld } from './play.ts';
+import { cli } from '../cli.ts';
 
 export type Browser = { newPage(o?: object): Promise<Page>; close(): Promise<void> };
 export type Page = {
@@ -26,7 +27,7 @@ export async function chromium(): Promise<{ launch(o?: object): Promise<Browser>
     try {
       return (createRequire(import.meta.url)('playwright') as { chromium: never }).chromium;
     } catch {
-      throw new Error('this command needs Playwright with Chromium: diorama browsers');
+      throw new Error(`this command needs Playwright with Chromium: ${cli('browsers')}`);
     }
   }
 }

package/app/src/commands/language.ts

@@ -8,6 +8,7 @@ import { castFixesFile, readCastFixes } from '../scene/cast-fixes.ts';
 import { SoundPlan } from '../sound/plan.ts';
 import { readStoryFixes, StoryFixes, storyFixesFile, textAt } from '../story/fixes.ts';
 import { Story } from '../story/schema.ts';
+import { kidsWorld } from '../world/drawings.ts';
 import { WorldFiles } from '../world/files.ts';
 import { applyWorldTexts, languagePlan, planLine, relanguage, translateTexts, worldTexts } from '../world/language.ts';
 import { placeSources, soundPlanFrom } from './sound.ts';
@@ -32,7 +33,7 @@ defineCommand({
 
     if (!plan.same) {
       const texts = worldTexts(world, story);
-      const kids = world.audience === 'kids' || fs.existsSync(files.path('drawings'));
+      const kids = kidsWorld(files, world);
       console.log(`translating ${Object.keys(texts).length} texts from ${plan.from} to ${plan.to}`);
       const translated = await translateTexts(files.memo, texts, plan.from, plan.to, kids);
       const now = applyWorldTexts(world, story, translated, plan.to);

package/app/src/commands/layout.ts

@@ -3,8 +3,10 @@ import fs from 'node:fs';
 import { renderBlockin, renderPlan } from '../scene/blockin.ts';
 import { readCorrections } from '../scene/corrections.ts';
 import { layOut } from '../scene/layout.ts';
+import { framePhoto, placePicture } from '../scene/photo.ts';
 import { defineCommand } from '../registry.ts';
 import { WorldFiles } from '../world/files.ts';
+import { placeSketch } from '../world/drawings.ts';
 import { approvedConcept } from '../world/sketch.ts';
 
 defineCommand({
@@ -16,10 +18,13 @@ defineCommand({
     const world = files.world();
     const places = world.places.filter((p) => only.length === 0 || only.includes(p.key));
     await Promise.all(places.map(async (place) => {
-      // A place made from a photo is measured from it, and the photo stands in for the block-in.
-      const photoFile = files.place(place.key, 'photo.png');
-      const photo = fs.existsSync(photoFile) ? fs.readFileSync(photoFile) : undefined;
-      const layout = await layOut(files.memo, world, place, photo, readCorrections(files.place(place.key)).layout?.guidance, approvedConcept(files, 'place', place.key));
+      // A place made from a photo is measured from it, and the photo stands in for the block-in. So does a
+      // grown-up's sketch of the place: drawn in perspective, it is the camera Muse would paint anyway.
+      const sketch = !fs.existsSync(files.place(place.key, 'photo.png')) && !fs.existsSync(files.place(place.key, 'sketch.png')) ? placeSketch(files, place.key) : undefined;
+      if (sketch) files.write(files.place(place.key, 'sketch.png'), (await framePhoto(sketch)).image);
+      const picture = placePicture(files.place(place.key));
+      const photo = picture && fs.readFileSync(picture.file);
+      const layout = await layOut(files.memo, world, place, photo, readCorrections(files.place(place.key)).layout?.guidance, approvedConcept(files, 'place', place.key), picture?.kind);
       files.write(files.place(place.key, 'layout.json'), layout);
       const blockin = photo ?? await renderBlockin(layout, place);
       files.write(files.place(place.key, 'blockin.png'), blockin);

package/app/src/commands/masks.ts

@@ -11,6 +11,7 @@ import { locateThings, markFloors } from '../scene/locate.ts';
 import { checkMasks, type MaskCheck } from '../scene/maskcheck.ts';
 import { maskFloors, maskThings } from '../scene/masks.ts';
 import { paintingLayoutHash } from '../scene/paint-layout.ts';
+import { placePicture } from '../scene/photo.ts';
 import { maskBox, type Rect } from '../image/raster.ts';
 import { WorldFiles } from '../world/files.ts';
 
@@ -30,7 +31,7 @@ defineCommand({
       const painting = fs.readFileSync(at('painting.png'));
       // A rejected/stale checked painting must not be rescued by masks and invented floor strokes.
       // Legacy worlds without a report remain editable; rebuilding from paint checks them too.
-      if (!fs.existsSync(at('photo.png')) && fs.existsSync(at('painting-layout.json'))) {
+      if (!placePicture(at()) && fs.existsSync(at('painting-layout.json'))) {
         const report = files.readJson(at('painting-layout.json')) as { ok?: boolean; inputs?: string };
         if (!report.ok || report.inputs !== paintingLayoutHash(place, layout, fs.readFileSync(at('blockin.png')), painting)) {
           throw new Error(`PAINT_LAYOUT_MISMATCH ${place.key}: painting/layout changed or its composition check failed; rebuild this place from paint to inspect and repair it before masks`);

package/app/src/commands/paint.ts

@@ -8,8 +8,9 @@ import { addsPerson, critique, paintedPeople, repaint } from '../scene/critic.ts
 import { readCorrections, writeCorrections } from '../scene/corrections.ts';
 import { Layout } from '../scene/layout.ts';
 import { paintPlace } from '../scene/paint.ts';
+import { heroVehicle } from '../scene/vehicle.ts';
 import { alignPainting, PaintingLayoutError, paintingLayoutHash } from '../scene/paint-layout.ts';
-import { paintPhoto } from '../scene/photo.ts';
+import { paintPhoto, placePicture } from '../scene/photo.ts';
 import { restylePlace } from '../scene/restyle.ts';
 import { refusedByFilter, reword, withWords, worded, type Words } from '../scene/words.ts';
 import { defineCommand, takeOption } from '../registry.ts';
@@ -21,6 +22,9 @@ import { markStyled, placeStyle, readStyled } from '../world/styled.ts';
 /** Rewords Spark may try after the image safety filter refuses a painting, before the place is set aside. */
 const REWORDS = 2;
 
+/** From this new take on, a place is painted without its approved concept (see paint below). */
+const CONCEPT_TAKES = 2;
+
 defineCommand({
   name: 'paint',
   usage: 'paint <slug> [place...]  brief, paint, critique and repaint laid-out places [--take N]',
@@ -39,8 +43,12 @@ defineCommand({
       const world = { ...base, style };
       const layout = Layout.parse(files.readJson(files.place(place.key, 'layout.json')));
       const blockin = fs.readFileSync(files.place(place.key, 'blockin.png'));
-      const fromPhoto = fs.existsSync(files.place(place.key, 'photo.png'));
-      const concept = approvedConcept(files, 'place', place.key);
+      const picture = placePicture(files.place(place.key));
+      const fromPhoto = !!picture;
+      // An approved concept steers Muse's camera toward its own; when it keeps pulling the painting off the plan
+      // (a second new take was asked for), the place is painted from the block-in alone.
+      const concept = take >= CONCEPT_TAKES ? undefined : approvedConcept(files, 'place', place.key);
+      if (take >= CONCEPT_TAKES && approvedConcept(files, 'place', place.key)) console.log(`  ${place.key}: take ${take}, painted from the block-in without its concept`);
       const styleReference = worldStyleReference(files, style);
       // The first painting is kept while its block-in, layout and take stay the same, even without the model
       // cache (a world copied without memo/): a person's region repaint must not repaint the whole place.
@@ -90,7 +98,7 @@ defineCommand({
         const again = await critique(files.memo, worded(place, words), brief, first);
         // People are looked for on the painting as the game shows it, with every fix in, not only the first one.
         const shown = fs.existsSync(files.place(place.key, 'painting.png')) ? fs.readFileSync(files.place(place.key, 'painting.png')) : first;
-        for (const p of shown === first ? [] : await paintedPeople(files.memo, place.key, shown)) {
+        for (const p of shown === first || place.kind === 'drive' ? [] : await paintedPeople(files.memo, place.key, shown)) {
           again.issues.push({ key: 'person', problem: 'unwanted', region: p.box, fix: `Paint out the ${p.what}: continue what is behind them (planks, water, wall), add nothing new` });
         }
         const had = new Set(found.issues.map((i) => JSON.stringify([i.region, i.fix])));
@@ -110,9 +118,9 @@ defineCommand({
           brief = withWords(await writeBrief(files.memo, world, told, layout), words);
           files.write(files.place(place.key, 'brief.json'), brief);
           try {
-            first = fromPhoto
-              ? await paintPhoto(files.memo, world, told, blockin, brief, take, concept, styleReference)
-              : await paintPlace(files.memo, world, told, layout, blockin, brief, take, drawingsIn(files, place), concept, styleReference);
+            first = picture
+              ? await paintPhoto(files.memo, world, told, blockin, brief, take, concept, styleReference, picture.kind)
+              : await paintPlace(files.memo, world, told, layout, blockin, brief, take, drawingsIn(files, place), concept, styleReference, await heroVehicle(files, world, place));
             break;
           } catch (error) {
             if (!refusedByFilter(error)) throw error;

package/app/src/commands/playthrough.ts

@@ -13,12 +13,12 @@ import { WorldFiles } from '../world/files.ts';
 import { chromium } from './explore.ts';
 import { serveWorld } from './play.ts';
 
-type Step = { use: string; verb?: string; with?: string } | { act: Action } | { wait: number };
+type Step = { use: string; verb?: string; with?: string; to?: string } | { act: Action } | { wait: number };
 
 /** A story action as what a player does on the page: click the thing, or pick an answer. */
 export function toStep(action: Action): Step {
   switch (action.kind) {
-    case 'go': return { use: action.via };
+    case 'go': return { use: action.via, ...(action.to && { to: action.to }) };
     case 'talk': return { use: action.npc };
     case 'do': return { use: action.thing, verb: action.verb, ...(action.with ? { with: action.with } : {}) };
     default: return { act: action };

package/app/src/commands/setup.ts

@@ -2,6 +2,8 @@
 import { defineCommand, takeOption } from '../registry.ts';
 import { findVault, NO_VAULT, SECRET_NAMES, SECRETS, SecretStore, type SecretName } from '../secrets.ts';
 import { runChecks, type Check } from '../setup/checks.ts';
+import { installChromium } from './browsers.ts';
+import { cli } from '../cli.ts';
 
 const MARK: Record<Check['state'], string> = { ok: '  ok      ', missing: '  MISSING ', optional: '  -       ', fail: '  FAIL    ' };
 
@@ -15,7 +17,7 @@ export function printChecks(checks: Check[]) {
 /** Reads a line without echoing it. Only from a terminal: a pasted key never lands in shell history or argv. */
 function askHidden(question: string): Promise<string> {
   const stdin = process.stdin;
-  if (!stdin.isTTY) throw new Error('diorama setup reads keys from a terminal only; or set them as environment variables');
+  if (!stdin.isTTY) throw new Error(`${cli('setup')} reads keys from a terminal only; or set them as environment variables`);
   process.stdout.write(question);
   return new Promise((resolve, reject) => {
     let value = '';
@@ -42,6 +44,17 @@ function askHidden(question: string): Promise<string> {
   });
 }
 
+/** A yes/no question in the terminal; Enter means yes. */
+async function askYes(question: string): Promise<boolean> {
+  const { createInterface } = await import('node:readline/promises');
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    return !/^n/i.test((await rl.question(question)).trim());
+  } finally {
+    rl.close();
+  }
+}
+
 async function storeKey(name: SecretName, remove: boolean) {
   const vault = await findVault();
   if (!vault) throw new Error(NO_VAULT);
@@ -79,6 +92,17 @@ defineCommand({
       console.log('');
       printChecks(checks);
     }
+    // Chromium is one download: offer it here instead of sending the person off to find another command.
+    if (process.stdin.isTTY && checks.some((c) => c.id === 'chromium' && c.state === 'missing') && (await askYes('\nDownload Chromium for Explore and Playthrough now (~150 MB, once)? [Y/n] '))) {
+      try {
+        await installChromium();
+      } catch (error) {
+        console.log(`Chromium download failed (${error instanceof Error ? error.message : error}); try again with ${cli('browsers')}`);
+      }
+      checks = await runChecks({ live });
+      console.log('');
+      printChecks(checks);
+    }
     const blocking = checks.filter((c) => c.state === 'missing' || c.state === 'fail');
     console.log(blocking.length ? `\n${blocking.length} to fix before a full build: ${blocking.map((c) => c.label).join(', ')}` : '\nready to build');
   },

package/app/src/commands/world.ts

@@ -3,7 +3,7 @@ import fs from 'node:fs';
 import { defineCommand, takeOption } from '../registry.ts';
 import { describePerson, describePhoto, framePhoto, normalisePhoto } from '../scene/photo.ts';
 import { designWorld, type Extra } from '../world/design.ts';
-import { drawingFiles, drawingsBrief, drawnIssues, fitPlaces, keepDrawings, KIDS_STYLE, oneHero, readDrawings, readKinds } from '../world/drawings.ts';
+import { drawingFiles, drawingsBrief, drawnIssues, fitPlaces, grownUpDrawings, keepDrawings, KIDS_STYLE, oneHero, readDrawings, readKinds, sketchStyle } from '../world/drawings.ts';
 import { WorldFiles } from '../world/files.ts';
 import { hearAll, Idea, ideaFromTold, keepTold } from '../world/told.ts';
 import { CreativeChoices } from '../world/idea-review.ts';
@@ -11,7 +11,7 @@ import { CreativeChoices } from '../world/idea-review.ts';
 defineCommand({
   name: 'world',
   usage: 'world <slug> "<idea>"   design a world (world.json) with Muse Spark [--places N] [--photo room.jpg: a real room is the first place] [--hero-photo me.jpg: a real person is the hero] '
-    + '[--drawings DIR: photos of children\'s drawings become the hero, NPCs, items and places] [--told DIR: recordings of them telling the story; without an idea, the idea is written from them] [--kids: a game for 5-7 year olds; on with drawings or recordings] [--language Polish: the game\'s text and voices; with recordings, the language spoken]',
+    + '[--drawings DIR: photos of drawings (children\'s, or a grown-up\'s sketches, which keep their own medium and make no kids\' game) become the hero, NPCs, items and places] [--told DIR: recordings of them telling the story; without an idea, the idea is written from them] [--kids: a game for 5-7 year olds; on with drawings or recordings] [--language Polish: the game\'s text and voices; with recordings, the language spoken]',
   async run(args) {
     const places = Number(takeOption(args, 'places', '4'));
     const photoFile = takeOption(args, 'photo', '');
@@ -41,7 +41,10 @@ export async function designInitialWorld(files: WorldFiles, { places, photoFile
   // A drawn place over the places asked for goes into a place as a prop: places are what makes a build long.
   const drawn = fitPlaces(await readDrawings(files.memo, files), places);
   for (const d of drawn) console.log(`drawing ${d.file}: ${d.kind} ${d.key}, ${d.looks}`);
-  const kids = kidsFlag || drawn.length > 0 || said.length > 0;
+  // A grown-up's sketches make a world in their own medium, not a kids' game.
+  const sketched = grownUpDrawings(drawn);
+  const drawnStyle = sketched ? sketchStyle(drawn) : KIDS_STYLE;
+  const kids = kidsFlag || (drawn.length > 0 && !sketched) || said.length > 0;
 
   let idea = given;
   // The story says who leads, unless the grown-up already picked a drawing as the hero.
@@ -83,11 +86,11 @@ export async function designInitialWorld(files: WorldFiles, { places, photoFile
   const characters = drawn.filter(d => d.kind === 'hero' || d.kind === 'npc').map(d => d.key);
   const chooseHero = !!(choices?.answers.length || choices?.note) && characters.length > 1 && !drawn.some(d => readKinds(files)[d.file] === 'hero');
   const asks = [
-    drawn.length ? drawingsBrief(drawn, chosenStyle ?? KIDS_STYLE, chooseHero) : '',
+    drawn.length ? drawingsBrief(drawn, chosenStyle ?? drawnStyle, chooseHero) : '',
     chosenStyle ? `The creator explicitly chose this visual style: ${chosenStyle}. Preserve recognizable shapes and identities from all source drawings.` : '',
     other ? `Write the title and pitch in ${other}, the language of the players; everything else (style, shows, mood, looks, keys) stays in English for the painters.` : '',
     // The game shows a name over each speaker: in the players' language, as they call them.
-    other || kids ? `Add "names": {"<key>": "name"} for the hero and every npc: a short name ${other ? `in ${other} ` : ''}the players would call them by (the name the children gave them, if they gave one; else a short friendly name a child would give).${drawn.length ? ` Name every drawn item and place too, as a child would say it${other ? ` in ${other}` : ''} ("the blue hat", "the mushroom forest").` : ''}` : '',
+    other || kids ? `Add "names": {"<key>": "name"} for the hero and every npc: a short name ${other ? `in ${other} ` : ''}the players would call them by (the name ${kids ? 'the children' : 'the creator'} gave them, if they gave one; else a short ${kids ? 'friendly name a child would give' : 'name that fits the world'}).${drawn.length ? ` Name every drawn item and place too, as ${kids ? 'a child' : 'a player'} would say it${other ? ` in ${other}` : ''} ("the blue hat", "the mushroom forest").` : ''}` : '',
   ].filter(Boolean);
   const extra: Extra | undefined = asks.length ? { brief: asks.join('\n\n'), issues: (w) => {
     if (!chooseHero) return drawnIssues(w, drawn);
@@ -96,7 +99,7 @@ export async function designInitialWorld(files: WorldFiles, { places, photoFile
   } } : undefined;
   const designed = await designWorld(files.memo, hero ? `${idea}\nThe hero is ${hero.looks}` : idea, places, room, extra);
   if (chooseHero) oneHero(drawn, designed.hero.key);
-  const world = { ...designed, ...(drawn.length && { style: KIDS_STYLE }), ...(chosenStyle && { style: chosenStyle }), ...(hero && { hero }), ...(other && { language: other }), ...(kids && { audience: 'kids' as const }) };
+  const world = { ...designed, ...(drawn.length && { style: drawnStyle }), ...(chosenStyle && { style: chosenStyle }), ...(hero && { hero }), ...(other && { language: other }), ...(kids && { audience: 'kids' as const }) };
   files.write(files.path('world.json'), world);
   if (drawingFiles(files).length) files.write(files.path('drawings.json'), drawn);
   console.log(`${world.title}: ${world.places.map((p) => p.key).join(' · ')}`);

package/app/src/main.ts

@@ -1,11 +1,12 @@
 import './commands/index.ts';
 import { registry } from './registry.ts';
 import { loadSecrets, redact } from './secrets.ts';
+import { cli, cliText } from './cli.ts';
 
 function help() {
-  console.log('diorama: a story prompt becomes painted scenes you can walk in\n\nusage: diorama <command> [args]\n');
+  console.log(`diorama: a story prompt becomes painted scenes you can walk in\n\nusage: ${cli('<command> [args]')}\n`);
   for (const cmd of registry.values()) console.log(`  ${cmd.usage}`);
-  console.log('\nfirst time: diorama setup (keys, what is missing), then diorama studio. Worlds are written to ./worlds here.');
+  console.log(`\nfirst time: ${cli('setup')} (keys, what is missing), then ${cli('studio')}. Worlds are written to ./worlds here.`);
 }
 
 const [name, ...args] = process.argv.slice(2);
@@ -15,7 +16,7 @@ if (!cmd) {
   process.exit(!name || name === 'help' ? 0 : 2);
 }
 if (args.includes('--help') || args.includes('-h')) {
-  console.log(`usage: diorama ${cmd.usage}`);
+  console.log(`usage: ${cli(cmd.usage)}`);
   process.exit(0);
 }
 try {
@@ -23,6 +24,6 @@ try {
   if (name !== 'setup') await loadSecrets();
   await cmd.run(args);
 } catch (error) {
-  console.error(redact(`diorama ${name}: ${error instanceof Error ? error.message : error}`));
+  console.error(redact(`diorama ${name}: ${cliText(error instanceof Error ? error.message : String(error))}`));
   process.exit(1);
 }

package/app/src/play/car.ts

@@ -0,0 +1,2 @@
+/** What a drive place's car is called: the build clears the road under it and the page bobs it. */
+export const CAR = /\b(car|cars|convertible|cab|taxi|truck|van|jeep|pickup|bus|coupe|sedan|wagon|buggy)\b/i;

package/app/src/qa/route.ts

@@ -1,7 +1,7 @@
 import type { Page } from 'playwright';
 import type { Action } from '../story/engine.ts';
 
-type Step = { use: string; verb?: string; with?: string } | { act: Action } | { wait: number };
+type Step = { use: string; verb?: string; with?: string; to?: string } | { act: Action } | { wait: number };
 
 /** Follow a route through the same pointer targets, inventory and answers as a person. */
 export async function playRoute(page: Page, steps: Step[]): Promise<{ ending: string | null; frames: number; time: number }> {
@@ -20,6 +20,14 @@ export async function playRoute(page: Page, steps: Step[]): Promise<{ ending: st
       await page.locator(`#talk button[data-action=${JSON.stringify(action)}]`).click();
     } else {
       if (step.with) await page.locator(`#inventory button[data-item=${JSON.stringify(step.with)}]`).click();
+      if (step.to) {
+        // One thing that leads to several places (a car): its destination is picked on the board the page shows.
+        const at = await page.evaluate(`window.diorama.destinationPoint(${JSON.stringify(step.to)})`) as { x: number; y: number } | null;
+        if (!at) throw new Error(`No destination ${step.to} on the board for ${step.use}`);
+        await page.mouse.click(at.x, at.y);
+        await settled();
+        continue;
+      }
       const point = await aimPoint(page, step);
       if (!point) throw new Error(`No clickable pixel for ${step.use}: its pointer target is hidden or covered`);
       await page.mouse.click(point.x, point.y, { button: step.verb === 'look' ? 'right' : 'left' });
@@ -83,7 +91,9 @@ export function aimPoint(page: Page, step: { use: string; verb?: string; with?:
     const rect = canvas.getBoundingClientRect();
     const box = game.pageRect(step.use) ?? rect;
     const hits = (x, y) => {
-      const at = game.unzoom((x - rect.left) / rect.width * canvas.width, (y - rect.top) / rect.height * canvas.height);
+      // In frame pixels: the canvas holds fewer when the page lowers its resolution on a slow machine.
+      const frame = game.place.g.frame;
+      const at = game.unzoom((x - rect.left) / rect.width * frame.width, (y - rect.top) / rect.height * frame.height);
       return game.thingAt(...at)?.thing.key === step.use && document.elementFromPoint(x, y) === canvas;
     };
     const cx = box.left + box.width / 2, cy = box.top + box.height / 2;

package/app/src/scene/cast.ts

@@ -1,4 +1,5 @@
 import { STYLE_REFERENCE_PROMPT } from '../world/style-reference.ts';
+import { drawers } from '../world/drawings.ts';
 // The hero and every NPC as one painted figure each: Muse paints them alone on a plain ground, SAM cuts them out.
 import sharp from 'sharp';
 import type { Mask } from '../image/mask.ts';
@@ -76,9 +77,10 @@ Style: ${world.style}
 Nothing they sat or lay on: no bed, headboard, pillow, chair or blanket. Plain flat light grey background, no floor, no shadow, no other people, no props around, no text.`;
 }
 
-/** For a child's drawing: the character they drew, as they drew it, made whole enough to walk. */
+/** For a drawing (a child's, or an artist's sketch): the character as drawn, made whole enough to walk. */
 export function drawingPrompt(world: World, who: Who): string {
-  return `This is a child's drawing on paper. Paint the character in it as a single full-body character for a 2D point-and-click adventure game, so the child who drew it knows it at once: the same colours, the same clothes and features, the same shapes and proportions (a big head stays big), only cleaner and whole: every part coloured in solidly, with clear outlines and no white paper showing through, a finished character, not a sketch. Standing in a relaxed walking-ready pose, seen from the side in three-quarter view, facing to the right, the whole figure visible from the top of the head down to both feet (or paws), centred, about two thirds of the image tall.
+  const drawn = drawers(world);
+  return `This is ${drawn.one} on paper. Paint the character in it as a single full-body character for a 2D point-and-click adventure game, so ${drawn.who} knows it at once: the same colours, the same clothes and features, the same shapes and proportions (a big head stays big), only cleaner and whole: every part coloured in solidly, with clear outlines and no white paper showing through, a finished character, not a sketch. Standing in a relaxed walking-ready pose, seen from the side in three-quarter view, facing to the right, the whole figure visible from the top of the head down to both feet (or paws), centred, about two thirds of the image tall.
 
 Character: ${who.looks}
 Style: ${world.style}

package/app/src/scene/critic.ts

@@ -32,7 +32,7 @@ List at most 4 problems a player would notice, worst first:
 - missing: a listed thing is not there, or a big part of the scene above is (a tall tower, a castle with two towers, a house on top): key "scene" for that
 - wrong: it is there but does not look like its description
 - flat: it is a plain block or smear instead of a painted object
-- unwanted: people (any person or figure at all${cast.length ? `, even one that looks like ${cast.join(' or ')}: they are added over the picture later, so a painted one would be a double` : ''}), ${paintedAnimals(brief).length ? 'animals other than the listed ones' : 'animals'}, text, letters or a border that should not be there
+- unwanted: people (any person or figure at all${place.kind === 'drive' ? ' other than the hero at the wheel of the car, who belongs there' : ''}${cast.length ? `, even one that looks like ${cast.join(' or ')}: they are added over the picture later, so a painted one would be a double` : ''}), ${paintedAnimals(brief).length ? 'animals other than the listed ones' : 'animals'}, text, letters or a border that should not be there
 For each give the region to repaint as [x0, y0, x1, y1] in pixels and one sentence on what to paint there. Never ask for text or letters. If the painting is fine, give no issues.
 
 Never ask to paint a person in: the game adds its people over the picture.
@@ -42,7 +42,8 @@ Reply with JSON only: {"issues": [{"key": "...", "problem": "missing | wrong | f
   const found = { issues: parsed.issues.filter((i) => !addsPerson(i)) };
   // The critic weighs the whole picture and lets a figure pass when the place's words name one ("a child floats
   // candle boats"); people are asked about on their own, as every one of them is a double or a stranger.
-  const people = await paintedPeople(memo, place.key, painting);
+  // A drive's hero is painted at the wheel on purpose: no one is looked for there.
+  const people = place.kind === 'drive' ? [] : await paintedPeople(memo, place.key, painting);
   const near = (a: number[], b: number[]) => Math.abs(a[0] - b[0]) + Math.abs(a[1] - b[1]) < 120;
   const extra = people.filter((p) => !found.issues.some((i) => i.problem === 'unwanted' && near(i.region, p.box))).map((p) => ({
     key: 'person', problem: 'unwanted' as const, region: pad(p.box, 24),