@homie-rocks/studio 0.14.2 → 0.14.4

package/README.md

@@ -83,8 +83,10 @@ featured game, live rooms, the latest posts), Games, Music, Videos, Rooms (every
 joinable) and Posts (`posts/*.md`, with Atom and JSON feeds). A section with nothing in it has no tab, and its
 page answers 404. Every game gets a landing at `/<game>/`: a full-bleed hero from its own footage or art, the
 pitch, a big Play button into a public room, how to play on a phone, a computer and a TV (with the join code),
-live rooms, credits (the original and its licence for a port), and "Make a game like this". Every page ends with
-"Made with Homie". Anything the studio puts in `site/` wins: a whole page, a partial, its tokens, its CSS, its
+live rooms, credits (the original and its licence for a port; "Remix of <game> by <studio>", linked, for a
+remix), and "Make a game like this". A game's shared source (`/games/<id>/source.json`) says who made it and the
+licence its owner picked in game.json `"license"`: `"remix-with-credit"` (the default), `"remix-freely"` or
+`"no-remix"`, which `game remix` refuses. Every page ends with "Made with Homie". Anything the studio puts in `site/` wins: a whole page, a partial, its tokens, its CSS, its
 files. `site/SITE.md` says all of it.
 
 The play page writes its room into the address, and a small room button at the edge shares it: Invite, Big
@@ -100,8 +102,8 @@ site. A game made with Homie's arcade controls that knocks for a Homie box (`/__
 A studio pins one version, so nothing changes until it asks. To take a newer one:
 
 ```sh
-npx -y @homie-rocks/studio@0.14.2 upgrade          # the plan; changes nothing
-npx -y @homie-rocks/studio@0.14.2 upgrade --apply  # after the person agrees
+npx -y @homie-rocks/studio@0.14.4 upgrade          # the plan; changes nothing
+npx -y @homie-rocks/studio@0.14.4 upgrade --apply  # after the person agrees
 npm install && npm run build
 ```
 
@@ -232,7 +234,7 @@ device; the owner's own passkey account (`homie-studio players owner`) counts as
 ## Setup status
 
 ```sh
-npx -y @homie-rocks/studio@0.14.2 setup status --connector yes   # before a studio exists
+npx -y @homie-rocks/studio@0.14.4 setup status --connector yes   # before a studio exists
 npx homie-studio setup status                                    # in a studio (also: homie-studio doctor)
 ```
 

package/bin/homie-studio.mjs

@@ -164,7 +164,7 @@ function print(result) {
       lines.push(`${result.name} is a studio now: ${result.dir}`, '', 'Wrote:', ...result.wrote.map((f) => `  ${f}`), '', `Dependencies: ${result.installed}`, '', 'Next:', ...result.next.map((n) => `  ${n}`), '', result.online);
       break;
     case 'game remix':
-      lines.push(`games/${result.id} is a remix of ${result.from} (${result.files.length} files). Make it yours in games/${result.id}/src/, then: npx homie-studio dev`);
+      lines.push(`games/${result.id} is a remix of ${result.from} (${result.files.length} files). Its game.json credits the original: "${result.credit}"${result.page ? ` (${result.page})` : ''}, on its landing and in its credits. Make it yours in games/${result.id}/src/, then: npx homie-studio dev`);
       break;
     case 'game new':
       lines.push(`games/${result.id} is a new game from the ${result.from} starter. Change it in games/${result.id}/src/, then: npx homie-studio dev`);

package/lib/build.mjs

@@ -33,6 +33,7 @@ import { buildSiteFiles, landingOf, readPosts, readTheme } from './site.mjs';
 import { PACKAGE_ROOT, listGames, readStudio } from './studio.mjs';
 import { SEAT_MAX } from '../worker/seats.mjs';
 import { STUDIO_VERSION } from './version.mjs';
+import { licenseOf, remixRow } from '../worker/license.mjs';
 
 const SOURCE_SKIP = new Set(['node_modules', 'dist', '.git', '.wrangler', '.port']);
 /** Never copied into a static game's served folder. */
@@ -64,8 +65,12 @@ function dirBytes(dir) {
   return n;
 }
 const TEXT = /\.(ts|tsx|js|mjs|jsx|json|html|css|md|txt|svg|glsl|wgsl|frag|vert)$/i;
-/** Text files of a game folder, capped (2 MB total, 512 KB each): what `homie-studio game remix` takes. */
-export function sourceOf(dir, id) {
+/**
+ * Text files of a game folder, capped (2 MB total, 512 KB each): what `homie-studio game remix` takes; with who made
+ * it (`credit`: the studio and the game; the live site adds the page, worker/index.mjs) and its licence (game.json
+ * "license", worker/license.mjs).
+ */
+export function sourceOf(dir, id, { studio = null, game = null, license } = {}) {
   const files = {};
   let total = 0;
   const walk = (rel) => {
@@ -82,7 +87,7 @@ export function sourceOf(dir, id) {
     }
   };
   walk('');
-  return { v: 1, kind: 'homie-game-source', id, files };
+  return { v: 1, kind: 'homie-game-source', id, credit: { studio, game: game ?? id }, license: licenseOf(license), files };
 }
 
 /*
@@ -193,7 +198,7 @@ export async function build(root, { only = null, log = () => {} } = {}) {
     if (mode !== 'static' && existsSync(join(g.dir, 'public'))) cpSync(join(g.dir, 'public'), out, { recursive: true });
     if (!existsSync(join(out, 'index.html'))) throw new Error(`games/${g.id}/index.html is missing`);
     // The game's own source, for other studios to remix (game.json "share": { "source": false } keeps it private).
-    if (g.share?.source !== false) writeFileSync(join(out, 'source.json'), `${JSON.stringify(sourceOf(g.dir, g.id))}\n`);
+    if (g.share?.source !== false) writeFileSync(join(out, 'source.json'), `${JSON.stringify(sourceOf(g.dir, g.id, { studio: studio.name ?? null, game: g.name ?? g.id, license: g.license }))}\n`);
     const main = join(out, 'assets', 'main.js');
     const bytes = existsSync(main) ? statSync(main).size : dirBytes(out);
     const seats = seatsFor(g, netplayOf(g, out));
@@ -225,6 +230,9 @@ export async function build(root, { only = null, log = () => {} } = {}) {
       ...(g.saves === true || (g.saves && typeof g.saves === 'object') ? { saves: true } : {}),
       // game.json `"launch": "private" | "invite"`: the game's launch state until its owner sets one live (the office).
       ...(g.launch === 'private' || g.launch === 'invite' ? { launch: g.launch } : {}),
+      // Its source licence (worker/license.mjs), and, for a remix, what it is a remix of (shown on its landing).
+      license: licenseOf(g.license),
+      ...(remixRow(g.remixOf) ? { remixOf: remixRow(g.remixOf) } : {}),
       landing: landingOf(g, join(dist, 'games', g.id), { videos: media.videos, songs: media.songs, log }),
     };
   });

package/lib/files.mjs

@@ -7,9 +7,11 @@
  */
 import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, realpathSync, statSync, writeFileSync } from 'node:fs';
 import { dirname, extname, join, relative, resolve, sep } from 'node:path';
+import { PICTURE_MAX, PICTURE_TYPES, pictureFor } from './pictures.mjs';
 
-export const FILE_LIMITS = Object.freeze({ write: 2 * 1024 * 1024, read: 400 * 1024, image: 1536 * 1024, lines: 2000, list: 600, matches: 200 });
-const IMAGES = { '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.webp': 'image/webp', '.gif': 'image/gif' };
+// A picture is at most PICTURE_MAX raw in an answer (lib/pictures.mjs): a bigger one goes as a smaller JPEG copy.
+export const FILE_LIMITS = Object.freeze({ write: 2 * 1024 * 1024, read: 400 * 1024, image: PICTURE_MAX, lines: 2000, list: 600, matches: 200 });
+const IMAGES = PICTURE_TYPES;
 const SKIP_DIRS = new Set(['node_modules', '.git', '.wrangler', '.studio', 'dist']);
 
 const inside = (base, p) => p === base || p.startsWith(base.endsWith(sep) ? base : `${base}${sep}`);
@@ -79,8 +81,9 @@ export function readStudioFile(root, path, { offset = 1, limit = FILE_LIMITS.lin
   if (st.isDirectory()) throw new Error(`${rel} is a folder (file_list lists it)`);
   const mime = IMAGES[extname(abs).toLowerCase()];
   if (mime) {
-    if (st.size > FILE_LIMITS.image) throw new Error(`${rel} is ${Math.round(st.size / 1024)} KB, over the ${FILE_LIMITS.image / 1024} KB a picture may be here`);
-    return { rel, image: { mimeType: mime, data: readFileSync(abs).toString('base64') }, bytes: st.size };
+    // Small enough for one answer (the Claude desktop app refuses one over 1 MB): a big picture goes as a smaller copy.
+    const pic = pictureFor(abs, { label: rel });
+    return { rel, image: { mimeType: pic.mimeType, data: pic.data }, bytes: pic.bytes, shrunk: pic.shrunk, from: pic.from ?? st.size };
   }
   if (st.size > FILE_LIMITS.read * 8) throw new Error(`${rel} is ${Math.round(st.size / 1024)} KB: too big to read here`);
   const buf = readFileSync(abs);

package/lib/mcp-tools.mjs

@@ -13,7 +13,7 @@
  * file tools never leave it (lib/files.mjs).
  */
 import { spawnSync } from 'node:child_process';
-import { existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, rmSync, statSync } from 'node:fs';
+import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { basename, dirname, extname, isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { renderCodex, newCodex } from './codex.mjs';
@@ -399,6 +399,80 @@ async function startDev(ctx, root, port) {
   return { url: `http://127.0.0.1:${at}`, job, slow: true };
 }
 
+/* ------------------------------------------------------------------ an earlier attempt, folded in */
+
+/** Where a person keeps projects, looked at two levels deep for an earlier folder of a studio's name. */
+const PROJECT_ROOTS = ['dev', 'Developer', 'code', 'Code', 'src', 'projects', 'Projects', 'repos', 'git', 'work', 'Documents', 'Desktop'];
+const TEXT_NOTES = new Set(['.md', '.markdown', '.txt', '.json', '.yaml', '.yml', '.toml', '.csv', '.html', '.css', '.js', '.mjs', '.ts', '.tsx']);
+const SKIP = new Set(['node_modules', '.git', 'Library', 'dist', '.studio', '.wrangler']);
+
+/** Folders named like the studio that are not studios: [{ path, files }] (at most 3). */
+export function earlierFolders(ctx, names, own, home = homedir()) {
+  const want = new Set(names.filter(Boolean).map((n) => String(n).toLowerCase()));
+  const roots = [ctx.studiosDir, home, ...PROJECT_ROOTS.map((r) => join(home, r))].filter((r) => r && existsSync(r));
+  const found = new Map();
+  const look = (dir, depth) => {
+    let entries = [];
+    try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    for (const e of entries) {
+      if (found.size >= 3) return;
+      if (!e.isDirectory() || e.name.startsWith('.') || SKIP.has(e.name)) continue;
+      const p = join(dir, e.name);
+      if (want.has(e.name.toLowerCase()) && realOr(p) !== realOr(own) && !existsSync(join(p, 'studio.json'))) {
+        let files = [];
+        try { files = readdirSync(p).filter((f) => !f.startsWith('.')).slice(0, 12); } catch { files = []; }
+        found.set(realOr(p), { path: realOr(p), files });
+      } else if (depth > 1 && entries.length < 400) look(p, depth - 1);
+    }
+  };
+  for (const r of [...new Set(roots.map(realOr))]) look(r, r === realOr(home) ? 1 : 2);
+  return [...found.values()];
+}
+
+/** studio_fold: the earlier folder's notes into notes/earlier/, or (remove) the folder into the Trash. */
+async function foldEarlier(ctx, root, a) {
+  const from = realOr(expandHome(a.from) ?? '');
+  const known = ctx.note(root).earlier ?? earlierFolders(ctx, [readStudio(root).name, readStudio(root).slug, basename(root)], root).map((e) => e.path);
+  if (!known.includes(from)) return fail(`${a.from} is not an earlier folder found for this studio (${known.join(', ') || 'none was found'}); nothing was touched`);
+  if (!existsSync(from)) return fail(`${from} is not there any more`);
+  if (a.remove === true) {
+    const trash = join(homedir(), '.Trash');
+    if (process.platform !== 'darwin' || !existsSync(trash)) return fail(`Moving a folder to the Trash works on a Mac only: the person can remove ${from} themselves.`);
+    const to = join(trash, `${basename(from)} ${new Date().toISOString().slice(0, 19).replace(/:/g, '.')}`);
+    try { renameSync(from, to); } catch (error) { return fail(`${from} could not be moved to the Trash (${error.code ?? error.message}): the person can remove it themselves`); }
+    ctx.note(root).earlier = known.filter((p) => p !== from);
+    return ok(`Moved ${from} to the Trash (as "${basename(to)}"); the person can put it back from there.`);
+  }
+  const dest = join(root, 'notes', 'earlier', basename(from));
+  const copied = [];
+  let total = 0;
+  const walk = (dir, rel) => {
+    let entries = [];
+    try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    for (const e of entries) {
+      if (copied.length >= 60 || total > 2 * 1024 * 1024) return;
+      if (e.name.startsWith('.') || SKIP.has(e.name)) continue;
+      const p = join(dir, e.name);
+      const r = rel ? `${rel}/${e.name}` : e.name;
+      if (e.isDirectory()) { walk(p, r); continue; }
+      if (!e.isFile() || !TEXT_NOTES.has(extname(e.name).toLowerCase())) continue;
+      const size = statSync(p).size;
+      if (size > 200 * 1024) continue;
+      mkdirSync(dirname(join(dest, r)), { recursive: true });
+      copyFileSync(p, join(dest, r));
+      copied.push(r); total += size;
+    }
+  };
+  walk(from, '');
+  let shown = '';
+  for (const r of copied.filter((f) => /\.(md|markdown|txt)$/i.test(f))) {
+    if (shown.length > 30_000) break;
+    shown += `\n--- ${r}\n${readFileSync(join(dest, r), 'utf8').split('\n').slice(0, 80).join('\n')}\n`;
+  }
+  ctx.note(root).changed = true;
+  return ok(`Copied ${copied.length} note file${copied.length === 1 ? '' : 's'} from ${from} into notes/earlier/${basename(from)}/ (the old folder is unchanged). Fold its premise into the plan with the person (the game's CODEX.md), then ask whether to remove the old folder (studio_fold with remove: true moves it to the Trash).${shown ? `\n${shown}` : ''}`, { kind: 'fold', from, to: `notes/earlier/${basename(from)}`, files: copied });
+}
+
 /* ------------------------------------------------------------------ a studio from GitHub */
 
 /** owner/name of a checkout's origin remote, lowercased, or null. */
@@ -517,19 +591,34 @@ export function toolDefs(ctx, avail = {}) {
         // Compared on real paths (a temporary or linked folder may have two names).
         const dir = join(realOr(dirname(asked)), basename(asked));
         if (!inside(base, dir) || dir === base) return fail(`a studio goes in its own folder inside ${ctx.studiosDir}`);
+        // An earlier attempt for this name (a folder that is not a studio: notes, a plan, a charter), here or in the
+        // usual project folders: the person is offered to fold its premise in (studio_fold), never surprised by it.
+        const earlier = earlierFolders(ctx, [name, slugify(name), basename(dir)], dir);
+        let at = dir;
+        if (existsSync(at) && readdirSync(at).some((f) => !['.DS_Store', '.git'].includes(f)) && !existsSync(join(at, 'studio.json'))) at = `${dir}-studio`;
         let made;
-        try { made = newStudio(dir, { name, install: false, ...(ctx.directory ? { homie: ctx.directory } : {}) }); } catch (error) { return fail(error.message); }
+        try { made = newStudio(at, { name, install: false, ...(ctx.directory ? { homie: ctx.directory } : {}) }); } catch (error) { return fail(error.message); }
         ctx.current = made.dir;
+        ctx.note(made.dir).earlier = earlier.map((e) => e.path);
         let install = null;
         if (ctx.install) {
           try { install = installJob(made.dir); } catch (error) { return fail(`${name} is made at ${made.dir}, but ${error.message}`); }
           await waitJob(install, Math.min(ctx.waitMs, 35_000));
         }
         const r = await setupCard(ctx, made.dir, { install, made: { dir: made.dir, wrote: made.wrote } });
-        r.content[0].text = `Made ${name} at ${made.dir} (no game yet: its home page says "First game coming soon").\nWrote: ${made.wrote.join(', ')}\n${!install ? '' : install.endedAt ? (install.code === 0 ? 'Its toolkit is installed.' : `npm install failed: ${whyOf(install)}`) : `Its toolkit is installing (job ${install.id}).`}\n\n${r.content[0].text}`;
+        const fold = earlier.length ? `\n\nAn earlier folder for this name is on this computer, and it is not a studio: ${earlier.map((e) => `${e.path} (${e.files.join(', ') || 'empty'})`).join('; ')}. ASK the person: fold its premise into ${name}? With their yes, studio_fold { "from": "<that folder>" } copies its notes into the studio (notes/earlier/) and shows them to you, so the plan can use them. Then, only with another yes, studio_fold { "from": "<that folder>", "remove": true } moves the old folder to the Trash.` : '';
+        r.content[0].text = `Made ${name} at ${made.dir} (no game yet: its home page says "First game coming soon").\nWrote: ${made.wrote.join(', ')}\n${!install ? '' : install.endedAt ? (install.code === 0 ? 'Its toolkit is installed.' : `npm install failed: ${whyOf(install)}`) : `Its toolkit is installing (job ${install.id}).`}${fold}\n\n${r.content[0].text}`;
+        if (r.structuredContent) r.structuredContent.earlier = earlier;
         return r;
       },
     },
+    {
+      name: 'studio_fold', title: 'Fold an earlier folder into the studio',
+      description: 'An earlier folder for this studio\'s name that is not a studio (one studio_scaffold found and named): copy its notes into the studio (notes/earlier/<folder>/, text files only) and read them, so its premise goes into the plan; or, with remove: true, move the old folder to the Trash. Only with the person\'s yes for each; it never touches any other folder.',
+      inputSchema: { type: 'object', properties: { from: str('The earlier folder studio_scaffold named'), remove: { type: 'boolean', description: 'Move the earlier folder to the Trash (only with the person\'s yes)' }, ...STUDIO_ARG }, required: ['from'] },
+      annotations: { title: 'Fold an earlier folder in', readOnlyHint: false, destructiveHint: true, openWorldHint: false },
+      run: async (a) => foldEarlier(ctx, ctx.root(a.studio), a),
+    },
     {
       name: 'studio_install', title: 'Install the studio\'s dependencies',
       description: 'npm install in the studio: its pinned toolkit and Wrangler, and anything its package.json gained (after an upgrade, a new pin, or a library a game needs). Runs in the background; studio_job follows it.',
@@ -569,14 +658,14 @@ export function toolDefs(ctx, avail = {}) {
     },
     {
       name: 'game_demo', title: 'See a working game',
-      description: 'Step 2: a live multiplayer game on Homie Arcade to play right now, made with this same toolkit, with NOTHING copied into the studio. Give the person the Play link: two browser tabs (or a phone and a computer) are two players in the same room; bots fill the empty seats. Copy a starter into the studio (game_make) only if they ask.',
+      description: 'Step 2: a live multiplayer game on Homie Arcade to play right now, made with this same toolkit, with NOTHING copied into the studio. Give the person the Play link: THEY open it (the link in your reply, or Play on a card); never open a browser or run a command to open it yourself. Two browser tabs (or a phone and a computer) are two players in the same room; bots fill the empty seats. Copy a starter into the studio (game_make) only if they ask.',
       inputSchema: { type: 'object', properties: { ...STUDIO_ARG } },
       annotations: { title: 'See a working game', ...RO, openWorldHint: true },
       run: async (a) => {
         const root = ctx.root(a.studio, { need: false });
         const r = await demoGames();
         if (root) ctx.note(root).demo = true;
-        return ok(formatDemo(r), { kind: 'demo', ...r });
+        return ok(`${formatDemo(r)}\n\nFor you, the AI: give the person this Play link in your reply; they open it themselves. Do not open a browser or run any command to open it.`, { kind: 'demo', ...r });
       },
     },
     {
@@ -595,7 +684,7 @@ export function toolDefs(ctx, avail = {}) {
     },
     {
       name: 'game_remix', title: 'Remix a shared game',
-      description: 'Bring a game another studio shared in the Homie directory into this studio as a new game of its own (the original stays credited in game.json).',
+      description: 'Bring a game another studio shared in the Homie directory into this studio as a new game of its own. The original stays credited: game.json remixOf says "Remix of <game> by <studio>" with a link back, shown on the new game\'s landing and in its credits. A game whose owner\'s licence says no remix is refused.',
       inputSchema: { type: 'object', properties: { game: str('The directory game: "<studio site>/<game id>" or its play URL'), id: str('The new game id in this studio'), name: str('Optional: its new name'), ...STUDIO_ARG }, required: ['game', 'id'] },
       annotations: { title: 'Remix a game', ...RW, openWorldHint: true },
       run: async (a) => {
@@ -607,7 +696,8 @@ export function toolDefs(ctx, avail = {}) {
         const r = await cli(ctx, root, `game remix ${a.id}`, ['game', 'remix', source, '--id', a.id, ...(a.name ? ['--name', String(a.name).slice(0, 60)] : [])]);
         if (!r.ended) return stillRunning(r.job, 'The remix');
         if (r.job.code !== 0) return fail(`Not remixed: ${whyOf(r.job)}`);
-        return ok(`games/${a.id} is a remix of ${site}/${gameId} (${(r.result?.files ?? []).length} files).`, { kind: 'game', ...r.result });
+        const credit = r.result?.credit ? ` Its game.json credits the original: "${r.result.credit}"${r.result.page ? ` (${r.result.page})` : ''}, on its landing and in its credits; keep it.` : '';
+        return ok(`games/${a.id} is a remix of ${site}/${gameId} (${(r.result?.files ?? []).length} files).${credit}`, { kind: 'game', ...r.result });
       },
     },
     {
@@ -705,7 +795,7 @@ export function toolDefs(ctx, avail = {}) {
         return ok([
           `${slow ? 'Starting' : 'Running'} here: ${url}/${games.length ? '' : ' (the home page: "First game coming soon")'}`,
           ...games.map((x) => `  ${x.name ?? x.id}: ${url}/${x.id}/play`),
-          g ? `Open ${url}/${g.id}/play in two browser tabs: two players, one room.` : '',
+          g ? `The person opens ${url}/${g.id}/play in two browser tabs: two players, one room. Give them the address; do not open a browser for them.` : 'Give the person the address; do not open a browser for them.',
         ].filter(Boolean).join('\n'), { kind: 'preview', url, games: games.map((x) => ({ id: x.id, play: `${url}/${x.id}/play` })) });
       },
     },
@@ -901,7 +991,7 @@ export function toolDefs(ctx, avail = {}) {
       annotations: { title: 'Read a file', ...RO },
       run: async (a) => {
         const r = readStudioFile(ctx.root(a.studio), a.path, { offset: a.offset, limit: a.limit });
-        if (r.image) return { content: [{ type: 'image', data: r.image.data, mimeType: r.image.mimeType }, { type: 'text', text: `${r.rel} (${Math.round(r.bytes / 1024)} KB)` }] };
+        if (r.image) return { content: [{ type: 'image', data: r.image.data, mimeType: r.image.mimeType }, { type: 'text', text: `${r.rel} (${r.shrunk ? `a smaller JPEG copy, ${Math.round(r.bytes / 1024)} KB, of a ${Math.round(r.from / 1024)} KB picture; the file is unchanged` : `${Math.round(r.bytes / 1024)} KB`})` }] };
         return ok(`${r.rel} (lines ${r.from}-${r.to} of ${r.lines}${r.more ? '; more with offset' : ''})\n${r.text}`);
       },
     },

package/lib/mcp.mjs

@@ -22,6 +22,7 @@ import { join } from 'node:path';
 import { PACKAGE_ROOT } from './studio.mjs';
 import { StudioContext, UI, availability, toolDefs } from './mcp-tools.mjs';
 import { stopAllJobs, toolPath } from './jobs.mjs';
+import { shrinkPictureData } from './pictures.mjs';
 import { STUDIO_VERSION } from './version.mjs';
 
 export const PROTOCOLS = ['2025-11-25', '2025-06-18', '2025-03-26', '2024-11-05'];
@@ -39,8 +40,12 @@ A new studio follows one checklist, in order and never ahead. Show it in your fi
 6. Playtest it (playtest), then put it online: studio_deploy with plan: true first (say what it creates and costs, free), cloudflare_login when not signed in (they approve once in their browser), studio_deploy, then studio_publish.
 If they ask for everything at once, show the list, make your own choices for steps 2 to 4 in one line each, and go on.
 
+If studio_scaffold finds an earlier folder of the studio's name that is not a studio, ask the person whether to fold its premise in (studio_fold), and remove it only with a second yes.
+
 A studio made elsewhere (on a phone, with Deploy to Cloudflare, so it lives on GitHub): studio_open with its repo clones it into the studios folder with this computer's own GitHub sign-in; github_login signs the computer in with GitHub's one-time code. Never ask for a token.
 
+Links are the person's to open: give them in your reply (the cards have their own buttons). Never open a browser or run a command such as open to open one yourself.
+
 Long work (npm install, check, playtest, deploy, renders) runs in the background: the tool answers at once with a card that follows it, and build_progress or studio_job reads where it is. studio_guide has Homie's full guide for each job (game, plan, port, playtest, publish, music, sound, art, video). Never put a key or password in a file or the chat. If Homie's homie.rocks connector is connected too, its tools of the same names say what to run; these run it.`;
 
 const CARD_FILES = { [UI.setup]: 'setup.js', [UI.build]: 'build.js', [UI.studio]: 'studio.js', [UI.codex]: 'codex.js' };
@@ -64,6 +69,52 @@ export function cardCsp(uri) {
   return { connectDomains: [], resourceDomains: [] };
 }
 
+/*
+ * ONE ANSWER, AT MOST RESULT_MAX. The Claude desktop app refuses a tool result over 1 MB. Every tools/call answer goes
+ * through fitResult on its way out: pictures first (a smaller copy, else left out), then the card's pictures, then the
+ * text (cut, and saying so), and last the card's data itself. What was left out is said in the answer's text.
+ */
+export const RESULT_MAX = 900_000;
+const sizeOf = (r) => JSON.stringify(r).length;
+
+/** Every data: URL in a card's data (a feed's preview, a codex's art, a studio's covers) taken out. */
+function withoutDataUrls(v) {
+  if (typeof v === 'string') return v.startsWith('data:') && v.length > 1024 ? null : v;
+  if (Array.isArray(v)) return v.map(withoutDataUrls);
+  if (v && typeof v === 'object') return Object.fromEntries(Object.entries(v).map(([k, x]) => [k, withoutDataUrls(x)]));
+  return v;
+}
+
+export function fitResult(result, { max = RESULT_MAX, shrink = shrinkPictureData } = {}) {
+  if (!result || typeof result !== 'object' || sizeOf(result) <= max) return result;
+  const r = JSON.parse(JSON.stringify(result));
+  const said = [];
+  const content = Array.isArray(r.content) ? r.content : (r.content = []);
+  for (let i = 0; i < content.length && sizeOf(r) > max; i++) {
+    const c = content[i];
+    if (c?.type !== 'image') continue;
+    const small = shrink(c.data, c.mimeType);
+    if (small && small.data.length < c.data.length) { content[i] = { ...c, ...small }; said.push('a picture went as a smaller copy'); }
+    else { content[i] = { type: 'text', text: '(A picture was left out: too big for one answer.)' }; said.push('a picture was left out'); }
+  }
+  if (sizeOf(r) > max && r.structuredContent) { r.structuredContent = withoutDataUrls(r.structuredContent); said.push('the card shows no pictures this time'); }
+  if (sizeOf(r) > max) {
+    // The longest text goes down to what fits, cut at a line's end.
+    const texts = content.filter((c) => c?.type === 'text' && typeof c.text === 'string').sort((a, b) => b.text.length - a.text.length);
+    for (const t of texts) {
+      const over = sizeOf(r) - max;
+      if (over <= 0) break;
+      const keep = Math.max(0, t.text.length - over - 400);
+      const cut = t.text.slice(0, keep);
+      t.text = `${cut.slice(0, Math.max(cut.lastIndexOf('\n'), Math.floor(keep * 0.9)))}\n…`;
+      said.push('the text was cut');
+    }
+  }
+  if (sizeOf(r) > max && r.structuredContent) { delete r.structuredContent; said.push('the card had no room for its data'); }
+  if (said.length) content.push({ type: 'text', text: `(This answer was over ${Math.round(max / 1000)} KB, the most one answer may be here: ${[...new Set(said)].join('; ')}.)` });
+  return r;
+}
+
 export const PROMPTS = [
   { name: 'new-studio', title: 'Set up a game studio', description: 'Make a game studio on this computer and go through Homie\'s new-studio checklist.', arguments: [{ name: 'name', description: 'The studio\'s name', required: false }] },
   { name: 'make-multiplayer', title: 'Make my game multiplayer', description: 'Port an existing single-player web game on this computer into a studio.', arguments: [{ name: 'folder', description: 'The game\'s folder', required: true }] },
@@ -122,7 +173,7 @@ export async function serveMcp({ studios = null, skills = null, cwd = process.cw
           let result;
           try { result = await tool.run(params?.arguments ?? {}); } catch (e) { result = { content: [{ type: 'text', text: e instanceof Error ? e.message : String(e) }], isError: true }; }
           log(`${name} ${result?.isError ? 'failed' : 'ok'} in ${Date.now() - t0} ms`);
-          reply(result);
+          reply(fitResult(result));
           // A media provider set up meanwhile adds its tool.
           const before = names;
           avail = availability();

package/lib/pictures.mjs

@@ -0,0 +1,67 @@
+/**
+ * PICTURES SMALL ENOUGH FOR ONE ANSWER. The Claude desktop app refuses a tool result over 1 MB, and a picture travels
+ * as base64 (a third bigger). So a picture a tool hands back is at most PICTURE_MAX raw: a bigger one becomes a
+ * smaller JPEG copy (ffmpeg, else macOS's own sips), stepping down in width until it fits; with neither, it is
+ * refused, naming the file, so the person can open it themselves. The original file is never changed.
+ */
+import { spawnSync } from 'node:child_process';
+import { existsSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { extname, join } from 'node:path';
+import { which } from './jobs.mjs';
+
+export const PICTURE_MAX = 600 * 1024;
+const SOURCE_MAX = 40 * 1024 * 1024;
+export const PICTURE_TYPES = { '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.webp': 'image/webp', '.gif': 'image/gif' };
+const WIDTHS = [1600, 1200, 900, 640, 480];
+
+/** Which shrinker this computer has: { kind, bin } or null. */
+export function shrinker() {
+  const ff = which(process.platform === 'win32' ? 'ffmpeg.exe' : 'ffmpeg');
+  if (ff) return { kind: 'ffmpeg', bin: ff };
+  if (process.platform === 'darwin' && existsSync('/usr/bin/sips')) return { kind: 'sips', bin: '/usr/bin/sips' };
+  return null;
+}
+
+function shrinkTo(tool, src, out, width) {
+  const args = tool.kind === 'ffmpeg'
+    ? ['-v', 'error', '-y', '-i', src, '-frames:v', '1', '-vf', `scale='min(${width},iw)':-2`, '-q:v', '6', out]
+    : ['-s', 'format', 'jpeg', '-s', 'formatOptions', '70', '-Z', String(width), src, '--out', out];
+  const r = spawnSync(tool.bin, args, { encoding: 'utf8', timeout: 30_000 });
+  return r.status === 0 && existsSync(out);
+}
+
+/**
+ * A picture file as MCP image content: { mimeType, data (base64), bytes, shrunk, width? }. Throws, naming `label`,
+ * when it cannot be made small enough here.
+ */
+export function pictureFor(path, { label = path, max = PICTURE_MAX, tool = shrinker() } = {}) {
+  const size = statSync(path).size;
+  const mime = PICTURE_TYPES[extname(path).toLowerCase()] ?? 'image/png';
+  if (size <= max) return { mimeType: mime, data: readFileSync(path).toString('base64'), bytes: size, shrunk: false };
+  if (size > SOURCE_MAX) throw new Error(`${label} is ${Math.round(size / 1024 / 1024)} MB: too big to look at here; the person can open it themselves`);
+  if (!tool) throw new Error(`${label} is ${Math.round(size / 1024)} KB, more than the ${Math.round(max / 1024)} KB a picture may be in one answer, and this computer has no ffmpeg (or sips) to make a smaller copy. The person can open it themselves: ${label}`);
+  const tmp = mkdtempSync(join(tmpdir(), 'homie-picture-'));
+  try {
+    for (const width of WIDTHS) {
+      const out = join(tmp, `w${width}.jpg`);
+      if (!shrinkTo(tool, path, out, width)) break;
+      const bytes = statSync(out).size;
+      if (bytes <= max) return { mimeType: 'image/jpeg', data: readFileSync(out).toString('base64'), bytes, shrunk: true, width, from: size };
+    }
+  } finally { rmSync(tmp, { recursive: true, force: true }); }
+  throw new Error(`${label} could not be made smaller than ${Math.round(max / 1024)} KB here; the person can open it themselves: ${label}`);
+}
+
+/** A picture already in an answer (base64): a smaller copy that fits, or null when there is none to be had. */
+export function shrinkPictureData(data, mimeType, { max = PICTURE_MAX, tool = shrinker() } = {}) {
+  if (!tool || typeof data !== 'string') return null;
+  const ext = Object.entries(PICTURE_TYPES).find(([, m]) => m === mimeType)?.[0] ?? '.png';
+  const tmp = mkdtempSync(join(tmpdir(), 'homie-picture-'));
+  try {
+    const src = join(tmp, `in${ext}`);
+    writeFileSync(src, Buffer.from(data, 'base64'));
+    const pic = pictureFor(src, { max, tool });
+    return { mimeType: pic.mimeType, data: pic.data };
+  } catch { return null; } finally { rmSync(tmp, { recursive: true, force: true }); }
+}

package/lib/progress.mjs

@@ -83,6 +83,17 @@ const IMAGE_TYPES = { '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image
 
 const now = () => new Date().toISOString();
 /** Plain text of at most `max` characters: no control characters, trimmed. */
+/**
+ * Plain text of at most `max` characters, cut at the end of a word with "…" when it is longer: never mid-word, and
+ * never mid-number (a log line said "bots, up to)" once, its "6" cut off).
+ */
+export function clip(value, max) {
+  const t = plain(value, Number.MAX_SAFE_INTEGER);
+  if (t.length <= max) return t;
+  const cut = t.slice(0, max - 1);
+  const space = cut.lastIndexOf(' ');
+  return `${(space > max * 0.5 ? cut.slice(0, space) : cut).replace(/[\s,;:(\u2013\u2014-]+$/u, '')}…`;
+}
 export const plain = (value, max) => String(value ?? '').replace(/[\u0000-\u001f\u007f-\u009f\u2028\u2029]+/g, ' ').replace(/\s+/g, ' ').trim().slice(0, max);
 const dir = (root) => join(root, PROGRESS_DIR);
 const docPath = (root, id) => join(dir(root), `${id}.json`);
@@ -219,7 +230,7 @@ export async function flushProgress(ms = 6000) {
 /* ------------------------------------------------------------------ the document */
 
 function pushLog(d, text) {
-  d.log = [...(d.log ?? []), { at: now(), text: plain(text, LIMITS.logLine) }].slice(-LIMITS.logLines);
+  d.log = [...(d.log ?? []), { at: now(), text: clip(text, LIMITS.logLine) }].slice(-LIMITS.logLines);
 }
 
 function mutateDoc(root, id, fn) {
@@ -268,7 +279,8 @@ export class Feed {
       if (note !== undefined) s.note = plain(note, LIMITS.note);
       if (state === 'failed' && note) doc.error = plain(note, LIMITS.note);
       if (state === 'running' || state === 'done') doc.error = null;
-      pushLog(doc, `${s.label}: ${state}${note ? ` (${plain(note, 100)})` : ''}`);
+      // The note is cut at a word's end, inside its own brackets, so the line keeps its closing ")".
+      pushLog(doc, `${s.label}: ${state}${note ? ` (${clip(note, LIMITS.logLine - s.label.length - state.length - 5)})` : ''}`);
     }, { soon: true });
     heartbeat(this.root, this.id, d?.stages?.some((s) => s.state === 'running') && d.state === 'running');
     return d;

package/lib/scaffold.mjs

@@ -202,6 +202,12 @@ studio's pinned copy, never a registry lookup of the bare name.
   a small icon (\`node_modules/@homie-rocks/studio/site/SITE.md\`). Look at it on a phone and a computer.
 - Change a game in small steps, build, and look at it (\`dev\`, then \`check\`).
 - A game's id is its URL (\`/<id>/\`); keep it once published.
+- **Remixing.** A public game shares its source at \`/games/<id>/source.json\`, with who made it (the studio, the
+  game, its page) and the licence its owner picks in game.json \`"license"\`: \`"remix-with-credit"\` (the
+  default), \`"remix-freely"\` or \`"no-remix"\`, and \`{ "kind": "…", "spdx": "MIT" }\` to name a licence too.
+  \`npx --no-install homie-studio game remix <source.json> --id <new id>\` brings another studio's game in as a new
+  game here: its game.json \`remixOf\` says "Remix of <game> by <studio>" with a link back, and its landing and
+  credits show it; keep that credit. A game whose licence says no remix is refused.
 - **Progress that lasts** (a character, unlocks, a collection, days of play) goes in **saves**, never in the room:
   a room forgets everything 60 s after its last player leaves. game.json \`"saves": true\` and
   \`createSaves\` from \`@homie-rocks/studio/saves\` (\`node_modules/@homie-rocks/studio/saves/SAVES.md\`): per

package/lib/studio.mjs

@@ -5,6 +5,7 @@
 import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { httpsPage, licenseOf, pageOfSource, remixAllowed, remixCredit, remixRow } from '../worker/license.mjs';
 
 export const PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
 export const GAME_ID = /^[a-z0-9][a-z0-9-]{0,39}$/;
@@ -125,7 +126,11 @@ export function newGame(root, id, { from = 'gem-rush', name } = {}) {
   return { ok: true, command: 'game new', id, from, dir: dest, files: readdirSync(dest, { recursive: true }).map(String) };
 }
 
-/** `homie-studio game remix <source.json url> --id <new id>`: a shared game brought in as this studio's own. */
+/**
+ * `homie-studio game remix <source.json url> --id <new id>`: a shared game brought in as this studio's own. Its
+ * game.json `remixOf` credits the original ("Remix of <game> by <studio>", with a link back to its page), and its
+ * landing and credits show it. A game whose owner's licence says no remix is refused (worker/license.mjs).
+ */
 export async function remixGame(root, source, id, { name } = {}) {
   if (!GAME_ID.test(String(id ?? '')) || RESERVED_IDS.has(id)) throw new Error('give the new game an id: --id <lowercase-id>');
   const dest = join(root, 'games', id);
@@ -137,6 +142,14 @@ export async function remixGame(root, source, id, { name } = {}) {
   if (!res.ok) throw new Error(`${url} answered ${res.status}`);
   const body = await res.json();
   if (body?.kind !== 'homie-game-source' || !body.files || typeof body.files !== 'object') throw new Error('that address is not a shared Homie game source');
+  // Who made it and what they allow: the source's credit and licence (a studio before 0.14.4 sends neither, so the
+  // default licence, and the page from the address).
+  const credit = body.credit && typeof body.credit === 'object' ? body.credit : {};
+  const license = licenseOf(body.license);
+  if (!remixAllowed(license)) {
+    const who = remixRow({ name: credit.game ?? body.id, studio: credit.studio });
+    throw new Error(`${who?.name ?? 'That game'}${who?.studio ? ` by ${who.studio}` : ''} is not open to remixing: its owner's licence says no remix. Make a game of your own like it instead.`);
+  }
   const wrote = [];
   for (const [rel, text] of Object.entries(body.files)) {
     if (typeof text !== 'string' || rel.includes('..') || rel.startsWith('/') || !/^[A-Za-z0-9._/-]+$/.test(rel)) continue;
@@ -148,11 +161,18 @@ export async function remixGame(root, source, id, { name } = {}) {
   if (!existsSync(join(dest, 'game.json'))) throw new Error('the shared source has no game.json');
   const meta = JSON.parse(readFileSync(join(dest, 'game.json'), 'utf8'));
   const from = meta.id;
-  meta.remixOf = { source: String(url), id: from, name: meta.name };
+  // The credit, in the remix's own game.json: the original's name, studio, page and licence, the line its landing and
+  // credits show, and, when the original was itself a remix, what that was a remix of.
+  const row = remixRow({ name: credit.game ?? meta.name ?? from, studio: credit.studio, page: httpsPage(credit.page) ?? pageOfSource(url) });
+  const before = remixRow(meta.remixOf);
+  meta.remixOf = {
+    credit: remixCredit(row), name: row?.name ?? null, studio: row?.studio ?? null, page: row?.page ?? null,
+    source: String(url), id: from, license, ...(before ? { of: before } : {}),
+  };
   meta.id = id;
   if (name) meta.name = String(name).slice(0, 60);
   writeFileSync(join(dest, 'game.json'), `${JSON.stringify(meta, null, 2)}\n`);
   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}'`));
-  return { ok: true, command: 'game remix', id, from: String(url), files: wrote };
+  return { ok: true, command: 'game remix', id, from: String(url), credit: meta.remixOf.credit, page: meta.remixOf.page, license, files: wrote };
 }

package/lib/template-history.json

@@ -353,6 +353,60 @@
      "## Beta": "9d02638207a26e73"
     }
    }
+  },
+  "0.14.3": {
+   "files": {
+    "CLAUDE.md": "ddf2b2a0376202f6",
+    "README.md": "684b3cca8001673c",
+    "HANDOFF.md": "ce7a8fd91c6bbee2",
+    "games/README.md": "5ad32fe80c61f117",
+    "music/README.md": "b8a828de9311bd28",
+    "videos/README.md": "70614388cbb203c7",
+    "posts/README.md": "37841aae476bd540",
+    "site/README.md": "ca131cd0472464fb",
+    "site/src/worker.mjs": "ca3f1630f2420ad3"
+   },
+   "sections": {
+    "AGENTS.md": {
+     "(intro)": "214aa46eb3a895d5",
+     "## Layout": "f14d641159480e6c",
+     "## Commands (all through the pinned CLI in node_modules)": "e579cd6ce3ce342a",
+     "## The site": "7c1618431bae6324",
+     "## Making games": "63069b31c87a2aa2",
+     "## The Game Codex and progress": "0738ef719cef3a4c",
+     "## Running live games (the back office)": "f0566f07cff04113",
+     "## Continuing a build from the Claude app": "0d68081e924ca419",
+     "## Rules": "969318425c99f5a5",
+     "## Beta": "9d02638207a26e73"
+    }
+   }
+  },
+  "0.14.4": {
+   "files": {
+    "CLAUDE.md": "ddf2b2a0376202f6",
+    "README.md": "684b3cca8001673c",
+    "HANDOFF.md": "ce7a8fd91c6bbee2",
+    "games/README.md": "5ad32fe80c61f117",
+    "music/README.md": "b8a828de9311bd28",
+    "videos/README.md": "70614388cbb203c7",
+    "posts/README.md": "37841aae476bd540",
+    "site/README.md": "ca131cd0472464fb",
+    "site/src/worker.mjs": "ca3f1630f2420ad3"
+   },
+   "sections": {
+    "AGENTS.md": {
+     "(intro)": "214aa46eb3a895d5",
+     "## Layout": "f14d641159480e6c",
+     "## Commands (all through the pinned CLI in node_modules)": "e579cd6ce3ce342a",
+     "## The site": "7c1618431bae6324",
+     "## Making games": "ce87c4dde1894c26",
+     "## The Game Codex and progress": "0738ef719cef3a4c",
+     "## Running live games (the back office)": "f0566f07cff04113",
+     "## Continuing a build from the Claude app": "0d68081e924ca419",
+     "## Rules": "969318425c99f5a5",
+     "## Beta": "9d02638207a26e73"
+    }
+   }
   }
  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@homie-rocks/studio",
-  "version": "0.14.2",
+  "version": "0.14.4",
   "description": "A studio for games, music and video on its own Cloudflare: scaffold, multiplayer starters on the netplay contract, a port toolkit that makes existing single-player web games multiplayer, the site Worker with public rooms (Table/Lobby Durable Objects and D1, all on the free Workers plan, no payment method), a site with the hub's sections (Home, Games, Music, Videos, Rooms, Posts with feeds) in the studio's own look, an epic landing page for every game, optional R2 storage for large media, deploy, and the homie.rocks directory.",
   "type": "module",
   "license": "Apache-2.0",

package/site/SITE.md

@@ -48,12 +48,20 @@ Made from the game's own files, nothing invented:
   phone scans to play, and how to put the game on a TV (`/<id>/tv` shows the room with its own join code).
 - **Live rooms**, each with Join. When studio.json shares its stats (`stats.share`), also "played this week".
 - **How to play**: `landing.about`, `landing.howToPlay` (a few lines), the controls, the room facts.
-- **Credits**: the studio and `landing.credits` (`[{ "role", "name", "url" }]`); for a port, the original, its
-  author and licence and every part inside it (`credits.json`, as the port skill writes it), with the full
-  licence texts on `/<id>/credits`; and Homie's open engine.
+- **Credits**: the studio and `landing.credits` (`[{ "role", "name", "url" }]`); for a remix, "Remix of
+  <game> by <studio>" linked to the original's page (game.json `remixOf`, which `game remix` writes; it is also
+  under the game's name in the hero); for a port, the original, its author and licence and every part inside it
+  (`credits.json`, as the port skill writes it), with the full licence texts on `/<id>/credits`; Homie's open
+  engine; and the source's licence.
 - **Make a game like this**: the two commands that install the Homie plugin and the words to say. When the game
-  shares its source (the default; `"share": { "source": false }` keeps it closed) the words remix it from
-  `/games/<id>/source.json`, and the button goes to `https://homie.rocks/studio/?remix=<that address>`.
+  shares its source (the default; `"share": { "source": false }` keeps it closed, and the owner's Remixable
+  switch withdraws it) and its licence allows remixing, the words remix it from `/games/<id>/source.json`, and
+  the button goes to `https://homie.rocks/studio/?remix=<that address>`.
+
+A game's licence is game.json `"license"`, the owner's pick: `"remix-with-credit"` (the default: a remix says
+"Remix of <game> by <studio>" with a link back), `"remix-freely"` (the credit is welcome, not asked for) or
+`"no-remix"` (the source can be read; `game remix` refuses it), and `{ "kind": "<one of those>", "spdx": "MIT" }`
+names a licence too. The source.json carries it, with `credit`: the studio's name, the game's name and its page.
 
 game.json's `landing` block, every key optional:
 

package/worker/index.mjs

@@ -25,6 +25,7 @@
  *   /__homie/..., /<game>/__homie/...   `not-a-homie`: the answer a game with Homie's arcade controls gets when it
  *                              knocks for a Homie box, so it stops knocking (a studio site is not a box)
  *   /.well-known/homie-studio.json   what the homie.rocks directory reads
+ *   /games/<id>/source.json    a public game's source for remixing, with its credit and licence (worker/license.mjs)
  *   /media/<key>               the studio's large media, from R2 (once `storage add` bound it), with byte ranges
  *   /api/stats                 the studio's numbers, for its owner only (a read key, or the owner's page session)
  *   /_studio/stats             the owner's private stats page (one-time sign-in link from `homie-studio stats link`)
@@ -74,6 +75,7 @@ import {
 // every device, and the owner's own account (`homie-studio players owner`) counts as the owner.
 usePlayers(playerAccounts);
 import { STUDIO_VERSION_TAG } from './version.mjs';
+import { licenseOf, remixAllowed, remixRow } from './license.mjs';
 
 export { SEAT_MAX } from './seats.mjs';
 /** For a studio whose Worker has player accounts: hand their server API to the back office once (worker/office.mjs). */
@@ -463,12 +465,17 @@ async function route(request, env, ctx) {
       games: await Promise.all((cat.games ?? []).map(async (g) => {
         // The card picture is the landing's hero still (what the landing leads with), else the game's cover.
         const cover = gameCover(g);
-        const remix = remixOf(g, await settingsOf(env));
+        // Open to remix: the owner's switch is on and the licence the owner picked allows it (worker/license.mjs).
+        const license = licenseOf(g.license);
+        const remix = remixOf(g, await settingsOf(env)) && remixAllowed(license);
+        const lineage = remixRow(g.remixOf);
         return {
           id: g.id, name: g.name, blurb: g.blurb ?? '', players: g.players ?? null, roundSeconds: g.roundSeconds ?? null,
           page: `${url.origin}/${g.id}/`, play: `${url.origin}/${g.id}/play`, cover: cover ? (cover.startsWith('/') ? `${url.origin}${cover}` : cover) : null,
           // The owner's remix switch (0.13.0): whether the source is open for other studios to remix, and where.
-          remix, ...(remix ? { source: `${url.origin}/games/${g.id}/source.json` } : {}),
+          remix, ...(remix ? { source: `${url.origin}/games/${g.id}/source.json` } : {}), license,
+          // A remix names what it is a remix of (its game.json `remixOf`): "Remix of <name> by <studio>", linked.
+          ...(lineage ? { remixOf: lineage } : {}),
           // Shared only with `stats.share`: this game's own Play presses and rounds with people, this week.
           ...(byGame ? { played: byGame[g.id] ?? { days: 7, plays: 0, rounds: 0 } } : {}),
         };
@@ -507,7 +514,9 @@ async function route(request, env, ctx) {
     return path.endsWith('.xml') ? atomFeed(cat, posts, url.origin) : jsonFeed(cat, posts, url.origin);
   }
 
-  // A game's remix source is served while the game is public and its owner has not withdrawn it (the remix switch).
+  // A game's remix source is served while the game is public and its owner has not withdrawn it (the remix switch),
+  // with who made it as this site says it (the studio's name, the game's name and page here) and the owner's licence
+  // (worker/license.mjs): the remix flow credits the first and refuses a game whose licence says no remix.
   const src = /^\/games\/([a-z0-9][a-z0-9-]{0,39})\/source\.json$/.exec(path);
   if (src) {
     const all = await getAll();
@@ -515,6 +524,16 @@ async function route(request, env, ctx) {
     if (meta) {
       const settings = await settingsOf(env, { fresh: true });
       if (launchOf(meta, settings, env) !== 'public' || !remixOf(meta, settings)) return json({ ok: false, error: 'not-shared', message: 'This game\'s source is not shared for remixing.' }, 404);
+      if (request.method === 'GET') {
+        const res = await env.ASSETS.fetch(new Request(`${url.origin}${path}`));
+        let body = null;
+        if (res.ok) { try { body = await res.json(); } catch { body = null; } }
+        if (body?.kind === 'homie-game-source' && body.files && typeof body.files === 'object') {
+          const credit = { studio: all.studio?.name ?? body.credit?.studio ?? null, game: meta.name ?? body.credit?.game ?? meta.id, page: `${url.origin}/${meta.id}/` };
+          const { files, ...head } = body;
+          return json({ ...head, credit, license: licenseOf(body.license ?? meta.license), files }, 200, { 'access-control-allow-origin': '*' });
+        }
+      }
     }
   }
 
@@ -608,7 +627,7 @@ async function route(request, env, ctx) {
       shareDaily(cat, url, ctx);
       const { rooms, live } = await roomsOf(env, [meta]);
       const week = cat.studio?.stats?.share ? await weekOf(env, game) : null;
-      return gameLanding(cat, meta, { origin: url.origin, rooms, playing: live[game] ?? 0, week });
+      return gameLanding(cat, meta, { origin: url.origin, rooms, playing: live[game] ?? 0, week, remix: launch === 'public' && remixOf(meta, settings) });
     }
     if (sub === 'live') {
       if (!door.ok) return json({ ok: false, error: 'not-found' }, 404);

package/worker/license.mjs

@@ -0,0 +1,74 @@
+/**
+ * A GAME'S SOURCE LICENCE AND LINEAGE, shared by the site Worker (worker/index.mjs, worker/site.mjs) and the CLI
+ * (lib/build.mjs, lib/studio.mjs).
+ *
+ * The licence is the owner's pick (game.json `"license"`), carried in the game's source.json beside who made it
+ * (`credit`: studio, game, page), so a remix knows what it may do and whom to credit:
+ *
+ *   "remix-with-credit"  the default: remix it, and the remix says "Remix of <game> by <studio>" with a link back
+ *   "remix-freely"       remix it; the credit is welcome, not asked for (the remix flow still writes it)
+ *   "no-remix"           the source can be read, not remixed: the remix flow refuses
+ *
+ * Either the word, or { "kind": "<word>", "spdx": "<SPDX id>" } to name a licence too (e.g. "MIT", "CC-BY-4.0"); a
+ * bare SPDX id ("MIT") is the default kind with that id. Anything else is the default.
+ *
+ * A remix's game.json `remixOf` (written by `homie-studio game remix`) is its lineage: the original's name, studio
+ * and page, shown on the remix's landing ("Remix of <game> by <studio>") and in its credits.
+ */
+export const LICENSE_KINDS = Object.freeze({
+  'remix-with-credit': 'Remix with credit',
+  'remix-freely': 'Remix freely',
+  'no-remix': 'Not for remixing',
+});
+export const DEFAULT_LICENSE = 'remix-with-credit';
+const SPDX = /^[A-Za-z0-9][A-Za-z0-9.+-]{0,63}$/;
+
+/** { kind, spdx } from what game.json (or a source.json) says. */
+export function licenseOf(value) {
+  const v = typeof value === 'string'
+    ? (Object.hasOwn(LICENSE_KINDS, value.trim()) ? { kind: value.trim() } : { spdx: value })
+    : value && typeof value === 'object' ? value : {};
+  const kind = Object.hasOwn(LICENSE_KINDS, v.kind) ? v.kind : DEFAULT_LICENSE;
+  const spdx = typeof v.spdx === 'string' && SPDX.test(v.spdx.trim()) ? v.spdx.trim() : null;
+  return { kind, spdx };
+}
+
+/** "Remix with credit (MIT)". */
+export function licenseLabel(value) {
+  const l = licenseOf(value);
+  return `${LICENSE_KINDS[l.kind]}${l.spdx ? ` (${l.spdx})` : ''}`;
+}
+
+/** Whether the owner lets the game be remixed. */
+export const remixAllowed = (value) => licenseOf(value).kind !== 'no-remix';
+
+const line = (v, max) => (typeof v === 'string' && v.trim() ? v.replace(/[\x00-\x1f\x7f]+/g, ' ').trim().slice(0, max) : null);
+/** An https address, else null. */
+export function httpsPage(v) {
+  try { const u = new URL(String(v ?? '')); return u.protocol === 'https:' ? u.href : null; } catch { return null; }
+}
+
+/** A game's page from its source address: https://<site>/games/<id>/source.json is https://<site>/<id>/. */
+export function pageOfSource(source) {
+  try {
+    const u = new URL(String(source ?? ''));
+    const m = /^\/games\/([a-z0-9][a-z0-9-]{0,39})\/source\.json$/.exec(u.pathname);
+    return u.protocol === 'https:' && m ? `${u.origin}/${m[1]}/` : null;
+  } catch { return null; }
+}
+
+/**
+ * What a game.json `remixOf` may show: the original's name, studio and page (an https link; a remix made before
+ * 0.14.4 has only its source address, which names the page too), plain text only.
+ */
+export function remixRow(r) {
+  if (!r || typeof r !== 'object') return null;
+  const name = line(r.name, 80);
+  return name ? { name, studio: line(r.studio, 80), page: httpsPage(r.page) ?? pageOfSource(r.source) } : null;
+}
+
+/** "Remix of Gem Rush by Night Owl Games" (the studio left out when the source named none). */
+export function remixCredit(r) {
+  const row = remixRow(r);
+  return row ? `Remix of ${row.name}${row.studio ? ` by ${row.studio}` : ''}` : null;
+}

package/worker/office-page.mjs

@@ -157,7 +157,7 @@ export const OFFICE_SCRIPT = String.raw`(function () {
       act('/_studio/api/game', { game: g.id, maxPlayers: n >= g.seats ? null : n }, 'Rooms of ' + g.name + ' now hold ' + Math.min(n, g.seats) + '.');
     });
     add(box, st,
-      add(el('label'), remix, el('span', '', g.remixBuilt ? 'Remixable' : 'Remixable (not in the build)')),
+      add(el('label'), remix, el('span', '', !g.remixBuilt ? 'Remixable (not in the build)' : g.license === 'no-remix' ? 'Source shared (its licence: not for remixing)' : 'Remixable')),
       add(el('label'), el('span', 'dim', 'Players per room'), max, el('span', 'faint', 'of ' + g.seats), setMax),
       add(el('span', 'faint'), document.createTextNode(g.launchFrom === 'game.json' ? 'state from game.json' : '')));
     return box;

package/worker/office.mjs

@@ -41,6 +41,7 @@ import { SEAT_MAX, seatsOf } from './seats.mjs';
 import { OWNER_COOKIE, cookieValues, ownerAllowed, ownerSession } from './stats.mjs';
 import { esc, layout, notFoundPage } from './site.mjs';
 import { confirmPage, lockedPage, officePage } from './office-page.mjs';
+import { licenseOf } from './license.mjs';
 
 export { OFFICE_MIGRATION, OFFICE_MIGRATION_FILE } from './office-schema.mjs';
 
@@ -455,7 +456,7 @@ export async function officeView(env, cat, origin) {
     rooms.sort((a, b) => b.players - a.players || a.room.localeCompare(b.room));
     return {
       id: g.id, name: g.name, launch, launchFrom: row?.launch ? 'office' : g.launch ? 'game.json' : 'default',
-      remix: remixOf(g, settings), remixBuilt: g.landing?.source !== false,
+      remix: remixOf(g, settings), remixBuilt: g.landing?.source !== false, license: licenseOf(g.license).kind,
       seats: seatsOf(g), maxPlayers: max, maxSet: Number(row?.max_players) >= 1 ? Number(row.max_players) : null,
       play: `${origin}/${g.id}/play`, page: `${origin}/${g.id}/`,
       invites: launch === 'invite' || (await hasInvites(env, g.id)) ? await invitesOf(env, g.id, origin) : [],

package/worker/site.mjs

@@ -11,6 +11,7 @@
  */
 import { qrSvg } from './qr.mjs';
 import { STUDIO_VERSION_TAG } from './version.mjs';
+import { licenseLabel, licenseOf, remixRow } from './license.mjs';
 
 export const esc = (value) => String(value ?? '').replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[c]);
 const jsonScript = (v) => JSON.stringify(v).replace(/</g, '\\u003c');
@@ -122,6 +123,8 @@ img,video{display:block;max-width:100%}
   text-shadow:0 0 38px color-mix(in srgb,var(--hot) 50%,transparent),0 2px 0 color-mix(in srgb,var(--bg) 60%,transparent)}
 .title.t-long{font-size:clamp(44px,12vw,64px)}
 .title.t-xlong{font-size:clamp(38px,10vw,54px)}
+.remix-of{margin:12px 0 0;font:600 14px/1.4 var(--text);color:var(--soft)}
+.remix-of a{color:inherit;text-decoration:underline;text-underline-offset:3px}
 .line{margin:14px 0 22px;max-width:36ch;font:500 17px/1.45 var(--text);color:var(--soft);text-wrap:pretty}
 .play{display:flex;width:100%;align-items:center;justify-content:center;gap:12px;min-height:62px;padding:0 30px;border-radius:18px;
   background:var(--hot);color:var(--hot-ink);text-decoration:none;font:800 20px/1 var(--display);letter-spacing:-.01em;
@@ -908,9 +911,15 @@ export function jsonFeed(cat, posts, origin) {
  * public room, phone / computer / TV (with the join code), live rooms, how to play, credits, and "Make a game like
  * this". A studio's site/pages/<id>/index.html replaces it; site/partials/game.html and game-<id>.html add a band.
  */
-export function gameLanding(cat, g, { origin = '', rooms = [], playing = 0, week = null } = {}) {
+export function gameLanding(cat, g, { origin = '', rooms = [], playing = 0, week = null, remix = true } = {}) {
   const name = studioName(cat);
   const L = g.landing ?? {};
+  // A remix says what it is a remix of, linked, under its name and in its credits (game.json `remixOf`).
+  const lineage = remixRow(g.remixOf);
+  const ofWhat = lineage ? `${lineage.page ? `<a href="${esc(lineage.page)}" rel="noopener">${esc(lineage.name)}</a>` : `<strong>${esc(lineage.name)}</strong>`}${lineage.studio ? ` by ${esc(lineage.studio)}` : ''}` : '';
+  // Open to remix: the source is in the build, the owner's switch is on, and the licence they picked allows it.
+  const license = licenseOf(g.license);
+  const remixable = Boolean(L.source) && remix !== false && license.kind !== 'no-remix';
   const h = L.hero ?? {};
   const host = origin.replace(/^https?:\/\//, '');
   const playUrl = `${origin}/${g.id}/play`;
@@ -929,6 +938,7 @@ export function gameLanding(cat, g, { origin = '', rooms = [], playing = 0, week
   <div class="hero-copy">
     <p class="kicker">${kickerHtml}</p>
     <h1 class="title ${titleClass(g.name)}" id="game-title">${esc(g.name)}</h1>
+    ${lineage ? `<p class="remix-of">Remix of ${ofWhat}</p>` : ''}
     <p class="line">${esc(L.pitch ?? g.blurb)}</p>
     <div class="row">
       <a class="play" href="/${esc(g.id)}/play" data-play>${PLAY_ICON}<span>Play now — free</span></a>
@@ -979,27 +989,28 @@ export function gameLanding(cat, g, { origin = '', rooms = [], playing = 0, week
   const o = C.original;
   const creditCards = [
     `<div class="credit"><h3>Made by</h3><p><strong><a href="/">${esc(name)}</a></strong>${cat.studio?.tagline ? ` · ${esc(cat.studio.tagline)}` : ''}</p>${(C.people ?? []).length ? `<ul>${C.people.map((c) => `<li>${c.role ? `${esc(c.role)}: ` : ''}${c.url ? `<a href="${esc(c.url)}" rel="noopener">${esc(c.name)}</a>` : `<strong>${esc(c.name)}</strong>`}</li>`).join('')}</ul>` : ''}</div>`,
+    lineage ? `<div class="credit"><h3>Remix of</h3><p>${ofWhat}.</p>${lineage.page ? `<p><a href="${esc(lineage.page)}" rel="noopener">${esc(lineage.page.replace(/^https:\/\//, ''))}</a></p>` : ''}</div>` : '',
     o && !o.house ? `<div class="credit"><h3>Based on</h3><p><strong>${esc(o.title)}</strong>${o.author ? ` by <strong>${esc(o.author)}</strong>` : ''}${o.year ? ` (${esc(o.year)})` : ''}${o.licence ? `, ${esc(o.licence)} licence` : ''}.</p>${o.url ? `<p><a href="${esc(o.url)}" rel="noopener">${esc(o.url.replace(/^https:\/\//, ''))}</a></p>` : ''}<p>Made multiplayer with Homie: public rooms, bots, join-in-progress, a new host when one leaves, touch controls and the big screen.</p></div>` : '',
     (C.parts ?? []).length ? `<div class="credit"><h3>Also inside</h3><ul>${C.parts.map((p) => `<li>${esc(p.what)}${p.author ? `: ${esc(p.author)}` : ''}${p.url ? ` (<a href="${esc(p.url)}" rel="noopener">source</a>)` : ''}${p.licence ? `, ${p.licenceUrl ? `<a href="${esc(p.licenceUrl)}" rel="noopener">${esc(p.licence)}</a>` : esc(p.licence)}` : ''}</li>`).join('')}</ul></div>` : '',
-    `<div class="credit"><h3>Built with</h3><p>Homie’s open engine: <a href="https://github.com/homie-rocks/homie" rel="noopener">@homie-rocks/studio</a> (rooms, netplay, the big screen), Apache-2.0.</p>${C.texts ? `<p><a href="/${esc(g.id)}/credits">Licences and full credits</a></p>` : ''}</div>`,
+    `<div class="credit"><h3>Built with</h3><p>Homie’s open engine: <a href="https://github.com/homie-rocks/homie" rel="noopener">@homie-rocks/studio</a> (rooms, netplay, the big screen), Apache-2.0.</p>${L.source ? `<p>Its source: ${esc(licenseLabel(license))}.</p>` : ''}${C.texts ? `<p><a href="/${esc(g.id)}/credits">Licences and full credits</a></p>` : ''}</div>`,
   ].filter(Boolean).join('');
   const creditsBand = `<section class="band tight" aria-labelledby="credits-title"><div class="band-in"><p class="kicker reveal">Credits</p><h2 class="small-h reveal" id="credits-title">Who made ${esc(g.name)}</h2><div class="credits reveal">${creditCards}</div></div></section>`;
 
   const source = `${origin}/games/${g.id}/source.json`;
-  const say = L.source
+  const say = remixable
     ? `Remix ${g.name} from ${source} into a game of my own in my Homie studio`
     : `Make a multiplayer game like ${g.name} in my Homie studio`;
-  const makeHref = L.source ? `https://homie.rocks/studio/?remix=${encodeURIComponent(source)}` : 'https://homie.rocks/studio/';
+  const makeHref = remixable ? `https://homie.rocks/studio/?remix=${encodeURIComponent(source)}` : 'https://homie.rocks/studio/';
   const makeBand = `<section class="band" aria-labelledby="make-title"><div class="band-in"><div class="make reveal">
-  <p class="kicker">${L.source ? 'Open to remix' : 'Your turn'}</p>
+  <p class="kicker">${remixable ? 'Open to remix' : 'Your turn'}</p>
   <h2 id="make-title">Make a game like this</h2>
-  <p class="lead">${L.source ? `${esc(g.name)}’s source is shared. Homie is a plugin for Claude Code and Codex: your AI copies this game into a studio of your own, makes it yours, and puts it online with public rooms like these, on your own free Cloudflare account.` : `Homie is a plugin for Claude Code and Codex: your AI sets up a studio of your own and makes a multiplayer game like ${esc(g.name)}, with public rooms like these, on your own free Cloudflare account.`}</p>
+  <p class="lead">${remixable ? `${esc(g.name)}’s source is shared. Homie is a plugin for Claude Code and Codex: your AI copies this game into a studio of your own, makes it yours, and puts it online with public rooms like these, on your own free Cloudflare account.` : `Homie is a plugin for Claude Code and Codex: your AI sets up a studio of your own and makes a multiplayer game like ${esc(g.name)}, with public rooms like these, on your own free Cloudflare account.`}</p>
   <ol class="say">
     <li><div><span class="label">1 · In Claude Code</span><code>/plugin marketplace add homie-rocks/homie</code></div><button class="copy" type="button" data-copy="/plugin marketplace add homie-rocks/homie">${icon('copy')}<span data-copy-word>Copy</span></button></li>
     <li><div><span class="label">2</span><code>/plugin install homie@homie</code></div><button class="copy" type="button" data-copy="/plugin install homie@homie">${icon('copy')}<span data-copy-word>Copy</span></button></li>
     <li><div><span class="label">3 · Then say</span><code>${esc(say)}</code></div><button class="copy" type="button" data-copy="${esc(say)}">${icon('copy')}<span data-copy-word>Copy</span></button></li>
   </ol>
-  <div class="keys"><a class="btn" href="${esc(makeHref)}">${icon('spark')}<span>Make a game like this</span></a>${L.source ? `<a class="ghost" href="/games/${esc(g.id)}/source.json">See the source</a>` : ''}</div>
+  <div class="keys"><a class="btn" href="${esc(makeHref)}">${icon('spark')}<span>Make a game like this</span></a>${remixable ? `<a class="ghost" href="/games/${esc(g.id)}/source.json">See the source</a>` : ''}</div>
 </div></div></section>`;
 
   // A partial that is its own <section> stands as it is; anything else sits in one of the page's bands.
@@ -1018,10 +1029,12 @@ export function gameLanding(cat, g, { origin = '', rooms = [], playing = 0, week
 /** /<game>/credits: the licence texts the game ships with (CREDITS.md and every licence file credits.json names). */
 export function creditsPage(cat, g, texts, { origin = '' } = {}) {
   const name = studioName(cat);
+  const lineage = remixRow(g.remixOf);
+  const of = lineage ? `<p class="sec">Remix of</p><p>${lineage.page ? `<a href="${esc(lineage.page)}" rel="noopener">${esc(lineage.name)}</a>` : esc(lineage.name)}${lineage.studio ? ` by ${esc(lineage.studio)}` : ''}</p>` : '';
   return layout(cat, {
     title: `Credits · ${g.name} · ${name}`, description: `Credits and licences for ${g.name}.`, origin, path: `/${g.id}/credits`, page: 'credits', active: 'games',
     main: `${pageHead(g.name, 'Credits and licences', null, `<div class="keys"><a class="ghost" href="/${esc(g.id)}/">${icon('arrow')}<span>Back to ${esc(g.name)}</span></a></div>`)}
-<div class="wrap">${texts.map(({ file, text }) => `<p class="sec">${esc(file)}</p><pre class="licence">${esc(text)}</pre>`).join('')}</div>`,
+<div class="wrap">${of}${texts.map(({ file, text }) => `<p class="sec">${esc(file)}</p><pre class="licence">${esc(text)}</pre>`).join('')}</div>`,
   });
 }
 

package/worker/version.mjs

@@ -1,2 +1,2 @@
 /** The @homie-rocks/studio version this Worker code is (package.json's; a test keeps them equal). Cache-busts /_homie/site.js. */
-export const STUDIO_VERSION_TAG = '0.14.2';
+export const STUDIO_VERSION_TAG = '0.14.4';