@homie-rocks/studio 0.14.3 → 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.3 upgrade          # the plan; changes nothing
-npx -y @homie-rocks/studio@0.14.3 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.3 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/mcp-tools.mjs

@@ -684,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) => {
@@ -696,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 });
       },
     },
     {

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

@@ -380,6 +380,33 @@
      "## 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.3",
+  "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.3';
+export const STUDIO_VERSION_TAG = '0.14.4';