@homie-rocks/studio 0.37.2 → 0.39.0

package/lib/scaffold.mjs

@@ -1,3 +1,4 @@
+import { MCP_MIGRATION, MCP_MIGRATION_FILE } from '../worker/mcp-store.mjs';
 import { APPS_MIGRATION, APPS_MIGRATION_FILE } from '../worker/app-records.mjs';
 import { PURCHASE_MIGRATION, PURCHASE_MIGRATION_FILE, PURCHASE_STATE, PURCHASE_STATE_FILE } from '../worker/purchase-schema.mjs';
 /**
@@ -67,8 +68,8 @@ export function slugify(name) {
  * the binding names and keep it linked.
  */
 export function wranglerConfig({ worker, name, d1, d1Id = null, r2 = null, layout = 'root', ai = false, routes = null, paidParts = false, partsRateLimit = null, triggers = null }) {
-  const at = layout === 'site' ? { schema: '../node_modules', main: 'src/worker.mjs', dist: './dist', migrations: 'migrations' }
-    : { schema: 'node_modules', main: 'site/src/worker.mjs', dist: './site/dist', migrations: 'site/migrations' };
+  const at = layout === 'site' ? { schema: '../node_modules', main: 'src/runtime/worker.js', dist: './dist', migrations: 'migrations' }
+    : { schema: 'node_modules', main: 'site/src/runtime/worker.js', dist: './site/dist', migrations: 'site/migrations' };
   const rooms = [{ name: 'TABLE', class_name: 'Table' }, { name: 'LOBBY', class_name: 'Lobby' }];
   const config = {
     $schema: `${at.schema}/wrangler/config-schema.json`,
@@ -80,7 +81,8 @@ export function wranglerConfig({ worker, name, d1, d1Id = null, r2 = null, layou
     // subdomain) reaches it instead of failing with 1042.
     // `disallow_eval_during_startup`: no code is made from a string while the Worker loads (Cloudflare never allows it
     // later). A game's rules run in this Worker (NETPLAY.md section 29), and nothing in them is ever made from text.
-    compatibility_flags: ['global_fetch_strictly_public', 'disallow_eval_during_startup', ...(paidParts ? ['nodejs_compat'] : [])],
+    no_bundle: true, find_additional_modules: true, rules: [{ type: 'ESModule', globs: ['**/*.js'], fallthrough: true }],
+    compatibility_flags: ['nodejs_compat', 'global_fetch_strictly_public', 'disallow_eval_during_startup'],
     ...(paidParts ? { alias: { '@homie-rocks/studio/worker': '@homie-rocks/studio/worker/selling' }, triggers: { crons: ['*/5 * * * *'] }, ratelimits: [partsRateLimit ?? { name: 'PURCHASE_RATE_LIMITER', namespace_id: '1001', simple: { limit: 60, period: 60 } }] } : {}),
     workers_dev: true,
     preview_urls: true,
@@ -152,6 +154,8 @@ An app is ONE screen that morphs with context: camera moves, panels unfold, its
 
 Declare roles, surfaces, words and lasting record collections in app.json. Netplay's host is not a staff permission. Use \`@homie-rocks/studio/apps\` for authorized lasting records and \`@homie-rocks/studio/links\` for ticket links, QR and HTTP-safe IDs. Staff use private role links plus existing account grants; keep private records out of public collections. Look for engine mechanisms and shared parts before writing a component. Credit licences; sharing is optional and separate from selling.
 
+Your studio also serves MCP at \`/mcp\`. Staff connect their own AI with their existing account and one browser approval; never ask them for a key. Add business actions with \`homie-studio tool new <name> --app <id>\`, keep their declared role narrow, and reuse the app's existing record IDs, field formats and versions. Test owner, staff and public calls locally. Read \`node_modules/@homie-rocks/studio/tools/TOOLS.md\` and the Homie plugin's \`tools\` skill.
+
 Build normally, run \`homie-studio dev --lan\`, then \`homie-studio check <id> --url <origin>\`: the app check proves an actual action across a wall and two phones plus reconnect. The public screen is \`/<id>/open\`, the wall \`/<id>/tv\`. Customer apps use the same \`standalone\` build for desktop/iOS/Android; its existing sign-in and store limitations still apply. See \`node_modules/@homie-rocks/studio/apps/APPS.md\`.
 
 ## Commands (all through the pinned CLI in node_modules)
@@ -645,6 +649,8 @@ anything here wins. The whole list is in \`node_modules/@homie-rocks/studio/site
 `;
 
 const GITIGNORE = `node_modules/
+site/src/runtime/
+site/src/tools/
 # This computer's own state: the site's workers.dev address (it names the Cloudflare account, often after its owner).
 .studio/
 # This person's own Claude Code settings for this studio (the status line, for one).
@@ -734,11 +740,12 @@ export function studioFiles({ name, slug, homie, template = false }) {
     'site/README.md': SITE_README,
     'site/src/worker.mjs': `// This studio's site: pages, public rooms (Table + Lobby Durable Objects), D1, and R2 once storage is added.
 // The code is @homie-rocks/studio's, pinned in package.json, so an update never changes a published game by surprise.
-import { hostRules } from '@homie-rocks/studio/worker';
+import { hostRules, useTools } from '@homie-rocks/studio/worker';
 // The rules of this studio's games that run on the server (written by homie-studio build; empty until a game has some).
 import rules from './rules/index.mjs';
 
 hostRules(rules);
+useTools(async () => (await import('./tools/index.mjs')).default);
 export { default, Table, Lobby } from '@homie-rocks/studio/worker';
 `,
     'site/src/rules/index.mjs': rulesIndex([]),
@@ -755,6 +762,7 @@ export { default, Table, Lobby } from '@homie-rocks/studio/worker';
     [`site/migrations/${SHOP_STATEMENTS_FILE}`]: SHOP_STATEMENTS,
     [`site/migrations/${SHOP_LINES_FILE}`]: SHOP_LINES,
     [`site/migrations/${APPS_MIGRATION_FILE}`]: APPS_MIGRATION,
+    [`site/migrations/${MCP_MIGRATION_FILE}`]: MCP_MIGRATION,
     [`site/migrations/${LOUNGE_MIGRATION_FILE}`]: LOUNGE_MIGRATION,
     'wrangler.jsonc': wranglerConfig({ worker, name, d1: studio.cloudflare.d1, r2: studio.cloudflare.r2, layout: 'root' }),
     '.claude/skills/.gitkeep': '',
@@ -926,13 +934,18 @@ function ensurePartsStateMigration(root) {
   return `site/migrations/${PURCHASE_STATE_FILE}`;
 }
 
+function ensureMcpMigration(root) {
+  const file=join(root,'site','migrations',MCP_MIGRATION_FILE);
+  if(existsSync(file))return null;
+  mkdirSync(dirname(file),{recursive:true});writeFileSync(file,MCP_MIGRATION);return `site/migrations/${MCP_MIGRATION_FILE}`;
+}
 export function ensureMigrations(root) {
-  return [ensureStatsMigration(root), ensurePlayersMigration(root), ensureOfficeMigration(root), ensureServersMigration(root), ensureChatMigration(root), ensureShopMigration(root), ensureLoungeMigration(root), ensureShopReservations(root), ensureShopStatements(root), ensureShopLines(root), ensureAppsMigration(root), ensurePartsMigration(root), ensurePartsStateMigration(root)].filter(Boolean);
+  return [ensureStatsMigration(root), ensurePlayersMigration(root), ensureOfficeMigration(root), ensureServersMigration(root), ensureChatMigration(root), ensureShopMigration(root), ensureLoungeMigration(root), ensureShopReservations(root), ensureShopStatements(root), ensureShopLines(root), ensureAppsMigration(root), ensurePartsMigration(root), ensurePartsStateMigration(root), ensureMcpMigration(root)].filter(Boolean);
 }
 
 /** What a migration file the template added is for, in a few words (deploy and dev say it). */
 export function migrationWord(file) {
-  return /studio_apps/.test(file) ? 'apps: lasting records and signed-in role grants' : /lounge/.test(file) ? 'the Lounge and kept chat: play nights, moderators, and what was said only where an owner turns history on' : /shop/.test(file) ? 'the shop: orders, what players own, refunds and referral books (paid sales wait until shop.json and the studio\'s Stripe connection are ready)' : /players/.test(file) ? 'player accounts and cloud saves' : /chat/.test(file) ? 'room chat: the owner\'s chat rules and players\' reports (never the chat itself)' : /servers/.test(file) ? 'servers and agent seats: room pools with their own rules, AI passes' : /office/.test(file) ? 'the back office: launch states, invites, the owner\'s controls' : 'the studio\'s own stats: counts, never tracks';
+  return /studio_mcp/.test(file) ? 'AI connections and tool call history' : /studio_apps/.test(file) ? 'apps: lasting records and signed-in role grants' : /lounge/.test(file) ? 'the Lounge and kept chat: play nights, moderators, and what was said only where an owner turns history on' : /shop/.test(file) ? 'the shop: orders, what players own, refunds and referral books (paid sales wait until shop.json and the studio\'s Stripe connection are ready)' : /players/.test(file) ? 'player accounts and cloud saves' : /chat/.test(file) ? 'room chat: the owner\'s chat rules and players\' reports (never the chat itself)' : /servers/.test(file) ? 'servers and agent seats: room pools with their own rules, AI passes' : /office/.test(file) ? 'the back office: launch states, invites, the owner\'s controls' : 'the studio\'s own stats: counts, never tracks';
 }
 
 /**

package/lib/shoot.mjs

@@ -27,7 +27,7 @@
  *
  * `--preview` (no --url): THE FRAMES HALF WITHOUT THE WHOLE SITE. It starts the light preview server itself
  * (lib/preview.mjs: the one built game's files on 127.0.0.1, no Wrangler, no rooms), opens the game's own page there
- * and shoots it. The game plays alone, offline, with its bots, which is what pictures of the game itself want. The
+ * and shoots it. A game with offline play enabled plays alone, with its bots, which is what pictures of the game itself want. The
  * smoke is NOT RUN (there is no room to meet in: that half needs `dev`), and there is no loading cover to wait for.
  * The result says which build the frames are of (`build`: its hash, the one `build` printed) and that the page
  * really loaded that build's hashed bundle (`bundle`: lib/build.mjs bundleOf, never a guess at assets/main.js).
@@ -274,7 +274,11 @@ export async function shoot({ url, game, frames = 60, fps = 30, device = 'comput
     const inAll = (fn, arg) => Promise.all(all().map((f) => T(f.evaluate(fn, arg), 20_000)));
     const frozen = await inAll(() => (window.__homieClock ? (window.__homieClock.freeze(), true) : false));
     if (!frozen.some(Boolean)) { result.why = 'the virtual clock is not in the page (it was opened before the script could be injected)'; return result; }
-    if (hold) await first.page.keyboard.down(hold).catch(() => {});
+    if (hold) {
+      // The play page owns the top-level focus; the game's key listener lives in its iframe.
+      if (gf) await T(gf.evaluate(() => window.focus()), 5000);
+      await first.page.keyboard.down(hold).catch(() => {});
+    }
     const rows = [];
     for (let n = 1; n <= frames; n++) {
       if (left() < 3000) { result.partial = `stopped at frame ${n - 1} of ${frames}: the ${Math.round(timeoutMs / 1000)} s bound was reached (a slow renderer; ask for fewer frames or a longer --timeout)`; break; }
@@ -287,6 +291,7 @@ export async function shoot({ url, game, frames = 60, fps = 30, device = 'comput
       rows.push({ n, file, virtualMs: +(n * (1000 / fps)).toFixed(3), clockMs: nows.find((v) => Number.isFinite(v)) ?? null, realMs: Date.now() - t, ...(await frameFacts(first) ?? {}) });
     }
     if (hold) await first.page.keyboard.up(hold).catch(() => {});
+    result.rules = gf ? await T(gf.evaluate(() => { const p = window.__homieNet?.probe; return typeof p?.hosted === 'function' ? { hosted: p.hosted(), status: p.status?.(), tick: p.tick?.() } : null; }), 5000) : null;
     result.frames = rows.length;
     result.realSeconds = +((Date.now() - started) / 1000).toFixed(1);
     result.virtualSeconds = +((rows.length * 1000) / fps / 1000).toFixed(3);
@@ -294,10 +299,11 @@ export async function shoot({ url, game, frames = 60, fps = 30, device = 'comput
     result.limits = 'Stepped: requestAnimationFrame, performance.now, Date, setTimeout, setInterval, CSS and Web animations, in the page and the game\'s frame. NOT stepped: the room\'s socket and its server clock (other players and the round arrive in real time), Web Audio\'s clock, <video>, workers. These frames show what was drawn; they are not a frame rate.';
     const probed = rows.some((r) => r.phase !== undefined);
     if (!probed) result.note = [result.note, 'the game exposes no port probe (exposePort): the frames carry no round phase or position'].filter(Boolean).join('; ');
-    writeFileSync(join(out, 'shoot.json'), `${JSON.stringify({ v: 1, kind: 'homie-shoot', ...result, rows }, null, 1)}\n`);
     const smokeOk = result.smoke.ok !== false;
-    result.ok = rows.length === frames && smokeOk;
-    if (!result.ok) result.why = !smokeOk ? `smoke: ${result.smoke.why}` : result.partial;
+    const rulesOk = !result.rules || (result.rules.status === 'playing' && result.rules.tick > 0);
+    result.ok = rows.length === frames && smokeOk && rulesOk && !result.errors.length;
+    if (!result.ok) result.why = !smokeOk ? `smoke: ${result.smoke.why}` : !rulesOk ? 'The rules game is not playing. A server-only build needs its room: run homie-studio dev and shoot with --url (or explicitly enable room.offline for offline play).' : result.errors.length ? `game errors: ${result.errors.join('; ')}` : result.partial;
+    writeFileSync(join(out, 'shoot.json'), `${JSON.stringify({ v: 1, kind: 'homie-shoot', ...result, rows }, null, 1)}\n`);
     return result;
   } finally {
     if (served?.server) { served.server.closeAllConnections?.(); served.server.close(); }

package/lib/studio.mjs

@@ -8,7 +8,7 @@ import { fileURLToPath } from 'node:url';
 
 export const PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
 export const GAME_ID = /^[a-z0-9][a-z0-9-]{0,39}$/;
-const RESERVED_IDS = new Set(['api', 'media', 'games', 'apps', 'assets', '_homie', '_site', '_studio', 'well-known', 'index', 'play', 'studio', 'studios', 'music', 'videos', 'posts', 'rooms', 'feed', 'account']);
+const RESERVED_IDS = new Set(['mcp', 'oauth', 'hooks', 'api', 'media', 'games', 'apps', 'assets', '_homie', '_site', '_studio', 'well-known', 'index', 'play', 'studio', 'studios', 'music', 'videos', 'posts', 'rooms', 'feed', 'account']);
 
 export function findStudio(from = process.cwd()) {
   let at = resolve(from);

package/lib/template-history.json

@@ -2112,6 +2112,91 @@
      }
     }
    }
+  },
+  "0.38.0": {
+   "files": {
+    "CLAUDE.md": "ddf2b2a0376202f6",
+    "README.md": "684b3cca8001673c",
+    "HANDOFF.md": "29337e2ace95b2e7",
+    "games/README.md": "5ad32fe80c61f117",
+    "music/README.md": "a3dc042dadd39df8",
+    "videos/README.md": "16babc3437d5545b",
+    "posts/README.md": "37841aae476bd540",
+    "site/README.md": "732894273a32dc3f",
+    "site/src/worker.mjs": "fc90f3609cad18ba"
+   },
+   "sections": {
+    "AGENTS.md": {
+     "(intro)": "214aa46eb3a895d5",
+     "## Layout": [
+      "8baf49e4291e7e88",
+      "c18362ed28975d81"
+     ],
+     "## Apps: one screen, roles and parts": "4db0abe4cdfac09f",
+     "## Commands (all through the pinned CLI in node_modules)": "a7f290579585368c",
+     "## The site": "0cb8dd9a6f8a0096",
+     "## Making games": "2da7fa74c8884834",
+     "## The Game Codex and progress": "0738ef719cef3a4c",
+     "## Art direction and models": "a48fff7bf0a5f2fc",
+     "## Running live games (the back office)": "51ebf2ab756f6e4d",
+     "## Servers and AI seats": "98d08705087a33ec",
+     "## Selling things (the shop)": "9e020d69dd6a954e",
+     "## Continuing a build from the Claude app": "0d68081e924ca419",
+     "## Rules": "2e6b29afb85dcf7e",
+     "## Telling Homie": "80b46fdd9e578db8",
+     "## Beta": "9d02638207a26e73"
+    }
+   },
+   "named": {
+    "Homie Arcade": {
+     "sections": {
+      "AGENTS.md": {
+       "## Commands (all through the pinned CLI in node_modules)": "7cad8fd10f62fef1"
+      }
+     }
+    }
+   }
+  },
+  "0.39.0": {
+   "files": {
+    "CLAUDE.md": "ddf2b2a0376202f6",
+    "README.md": "684b3cca8001673c",
+    "HANDOFF.md": "29337e2ace95b2e7",
+    "games/README.md": "5ad32fe80c61f117",
+    "music/README.md": "a3dc042dadd39df8",
+    "videos/README.md": "16babc3437d5545b",
+    "posts/README.md": "37841aae476bd540",
+    "site/README.md": "732894273a32dc3f",
+    "site/src/worker.mjs": "34444a6ca4b14437"
+   },
+   "sections": {
+    "AGENTS.md": {
+     "(intro)": "214aa46eb3a895d5",
+     "## Layout": "c18362ed28975d81",
+     "## Apps: one screen, roles and parts": "be6f8fa45f93211a",
+     "## Commands (all through the pinned CLI in node_modules)": "a7f290579585368c",
+     "## The site": "0cb8dd9a6f8a0096",
+     "## Making games": "2da7fa74c8884834",
+     "## The Game Codex and progress": "0738ef719cef3a4c",
+     "## Art direction and models": "a48fff7bf0a5f2fc",
+     "## Running live games (the back office)": "51ebf2ab756f6e4d",
+     "## Servers and AI seats": "98d08705087a33ec",
+     "## Selling things (the shop)": "9e020d69dd6a954e",
+     "## Continuing a build from the Claude app": "0d68081e924ca419",
+     "## Rules": "2e6b29afb85dcf7e",
+     "## Telling Homie": "80b46fdd9e578db8",
+     "## Beta": "9d02638207a26e73"
+    }
+   },
+   "named": {
+    "Homie Arcade": {
+     "sections": {
+      "AGENTS.md": {
+       "## Commands (all through the pinned CLI in node_modules)": "7cad8fd10f62fef1"
+      }
+     }
+    }
+   }
   }
  }
 }

package/lib/tools-build.mjs

@@ -0,0 +1,55 @@
+import { existsSync, readdirSync, mkdirSync, writeFileSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { createRequire } from 'node:module';
+import { partsPlugin, resolvePartImport } from './parts-build.mjs';
+const require=createRequire(import.meta.url);
+export function toolFiles(root) {
+  const dirs=[join(root,'tools')];
+  const apps=join(root,'apps');if(existsSync(apps))for(const app of readdirSync(apps,{withFileTypes:true}))if(app.isDirectory())dirs.push(join(apps,app.name,'tools'));
+  return dirs.flatMap(dir=>existsSync(dir)?readdirSync(dir).filter(f=>/^[a-z][a-z0-9-]*\.ts$/.test(f)).sort().map(f=>join(dir,f)):[]);
+}
+export async function buildTools(root,esbuild) {
+  const files=toolFiles(root),dir=join(root,'site/src/tools');
+  mkdirSync(dir,{recursive:true});
+  if(files.length){
+    const ts=require('typescript');
+    const options={target:ts.ScriptTarget.ES2022,module:ts.ModuleKind.ESNext,moduleResolution:ts.ModuleResolutionKind.Bundler,strict:true,noEmit:true,skipLibCheck:true,allowImportingTsExtensions:true};
+    const host=ts.createCompilerHost(options);
+    host.resolveModuleNames=(names,containing)=>names.map(name=>{
+      if(name.startsWith('@parts/')){const part=resolvePartImport(root,name);if(part.path)return {resolvedFileName:part.path,extension:part.path.endsWith('.ts')?ts.Extension.Ts:ts.Extension.Js};}
+      return ts.resolveModuleName(name,containing,options,host).resolvedModule;
+    });
+    const program=ts.createProgram(files,options,host);
+    const errors=ts.getPreEmitDiagnostics(program);
+    if(errors.length)throw new Error(ts.formatDiagnosticsWithColorAndContext(errors,{getCurrentDirectory:()=>root,getCanonicalFileName:f=>f,getNewLine:()=> '\n'}));
+  }
+  const contents=files.map((f,i)=>`import t${i} from ${JSON.stringify(f)};`).join('\n')+`\nexport default [${files.map((_,i)=>'t'+i).join(',')}];\n`;
+  const result=await esbuild.build({stdin:{contents,resolveDir:root},bundle:true,format:'esm',platform:'neutral',target:'es2022',write:false,plugins:[partsPlugin(root)],logLevel:'silent'});
+  const temp=join(dir,'index.mjs');writeFileSync(temp,result.outputFiles[0].text);
+  // Trusted studio code, as with the existing build command. No Worker bindings exist during build.
+  const defs=(await import(pathToFileURL(temp).href+'?build='+Date.now())).default;
+  const { CfWorkerJsonSchemaValidator }=await import('@modelcontextprotocol/server/validators/cf-worker');
+  const validator=new CfWorkerJsonSchemaValidator(),seen=new Set();
+  for(const t of defs){
+    if(!/^[a-z][a-z0-9_]{0,63}$/.test(t.name)||/^(studio_|app_|agent_|room_|shop_)/.test(t.name)||seen.has(t.name))throw new Error(`tool name is invalid, reserved or duplicated: ${t.name}`);
+    seen.add(t.name);
+    if(typeof t.description!=='string'||!t.description.trim()||typeof t.handler!=='function')throw new Error(`tool ${t.name} needs description and handler`);
+    if(!['owner','signed-in','public'].includes(t.audience)&&!(t.audience&&typeof t.audience.app==='string'&&typeof t.audience.role==='string'))throw new Error(`tool ${t.name} needs an audience`);
+    if(t.inputSchema?.type!=='object')throw new Error(`tool ${t.name} input schema must be an object`);
+    validator.getValidator(t.inputSchema);
+    if(t.kind!==undefined&&!['tool','prompt'].includes(t.kind))throw new Error(`tool ${t.name}: invalid kind`);
+    if(t.webhook&&(!/^[A-Z][A-Z0-9_]{0,63}$/.test(t.webhook.secret)||typeof t.webhook.person!=='string'||!t.webhook.person))throw new Error(`tool ${t.name}: webhook needs a named secret and account`);
+    for(const [name,event] of Object.entries(t.events??{})){
+      if(!/^external:[a-z][a-z0-9_-]{0,40}$/.test(name)||!event.game||!event.schema)throw new Error(`tool ${t.name}: invalid external event`);
+      validator.getValidator(event.schema);
+    }
+  }
+  // Existing studios retain their Worker customization; install the small registry hook once.
+  const worker=join(root,'site/src/worker.mjs');
+  if(existsSync(worker)){
+    let text=readFileSync(worker,'utf8');
+    if(!text.includes('useTools(')){text += "\nimport { useTools } from '@homie-rocks/studio/worker';\nuseTools(async () => (await import('./tools/index.mjs')).default);\n";writeFileSync(worker,text);}
+  }
+  return defs.map(t=>t.name);
+}

package/lib/tools-cli.mjs

@@ -0,0 +1,55 @@
+import {existsSync,mkdirSync,writeFileSync,readFileSync,chmodSync} from 'node:fs';
+import {join,dirname} from 'node:path';
+import {createServer} from 'node:http';
+import {randomUUID} from 'node:crypto';
+import {spawn} from 'node:child_process';
+export function newTool(root,name,{app=null}={}) {
+  if(!/^[a-z][a-z0-9-]{0,39}$/.test(name??'') || app!==null&&!/^[a-z][a-z0-9-]{0,39}$/.test(app))throw new Error('name uses lowercase letters, numbers and hyphens');
+  if(app&&!existsSync(join(root,'apps',app,'app.json')))throw new Error('unknown app');
+  const file=join(root,...(app?['apps',app,'tools']:['tools']),name+'.ts');if(existsSync(file))throw new Error('tool already exists');
+  mkdirSync(dirname(file),{recursive:true});writeFileSync(file,`import { defineTool } from '@homie-rocks/studio/tools';\n\nexport default defineTool<{ message: string }>({\n  name: '${name.replaceAll('-','_')}',\n  description: 'Describe what this tool does and when to use it.',\n  audience: ${app?JSON.stringify({app,role:'staff'}):"'owner'"},\n  inputSchema: { type: 'object', properties: { message: { type: 'string', maxLength: 200 } }, required: ['message'], additionalProperties: false },\n  async handler({ message }, context) {\n    return { message, by: context.caller.id };\n  },\n});\n`);
+  return {ok:true,command:'tool new',file,next:'Edit the definition, then homie-studio dev. Call it with homie-studio tool call '+name.replaceAll('-','_')+' --input \'{"message":"Hello"}\' --url http://localhost:8787'};
+}
+/** The official SDK owns discovery, registration, PKCE, refresh and issuer checks. */
+export async function connectToolClient(root,site,{publicOnly=false,open=defaultOpen,log=()=>{}}={}) {
+  const {Client,StreamableHTTPClientTransport,auth}=await import('mcp-studio-client');
+  const url=new URL('/mcp',site);if(url.protocol!=='https:'&&!['localhost','127.0.0.1','[::1]'].includes(url.hostname))throw new Error('Use HTTPS, or localhost for local development');
+  const client=new Client({name:'Homie studio tool CLI',version:'1.0.0'});
+  if(publicOnly){await client.connect(new StreamableHTTPClientTransport(url));return client;}
+  const file=join(root,'.studio','mcp',Buffer.from(url.origin).toString('base64url')+'.json');
+  let state={};try{state=JSON.parse(readFileSync(file,'utf8'));}catch{}
+  // Credentials without an issuer predate the SDK's OAuth binding fix; reconnect safely.
+  if((state.tokens&&!state.tokens.issuer)||(state.client&&!state.client.issuer))state={};
+  const save=()=>{mkdirSync(dirname(file),{recursive:true});writeFileSync(file,JSON.stringify(state),{mode:0o600});chmodSync(file,0o600);};
+  let accept;const returned=new Promise(resolve=>{accept=resolve;});
+  const csrf=randomUUID();
+  const server=createServer((req,res)=>{const back=new URL(req.url,'http://localhost');if(back.pathname!=='/callback'||back.searchParams.get('state')!==csrf){res.writeHead(400);res.end('Invalid callback');return;}res.end('Your AI is connected. You can close this tab.');accept(back);});
+  await new Promise(resolve=>server.listen(0,'127.0.0.1',resolve));
+  const redirect=`http://127.0.0.1:${server.address().port}/callback`;
+  const provider={redirectUrl:redirect,clientMetadata:{client_name:'Homie studio tool CLI',redirect_uris:[redirect],grant_types:['authorization_code','refresh_token'],response_types:['code'],token_endpoint_auth_method:'none'},state:()=>csrf,
+    clientInformation:()=>state.client,saveClientInformation:v=>{state.client=v;save();},tokens:()=>state.tokens,saveTokens:v=>{state.tokens=v;save();},
+    codeVerifier:()=>state.verifier,saveCodeVerifier:v=>{state.verifier=v;save();},
+    discoveryState:()=>state.discovery,saveDiscoveryState:v=>{state.discovery=v;save();},
+    invalidateCredentials:scope=>{if(scope==='all')state={};else {delete state[scope==='tokens'?'tokens':scope];if(scope==='tokens')delete state.client;}save();},
+    redirectToAuthorization:async u=>{log('Approve this connection in your browser.');await open(u.href);},
+  };
+  try{
+    // A new loopback port needs a matching registered redirect; refresh still uses the prior client.
+    if(!state.tokens){delete state.client;delete state.discovery;}
+    const result=await auth(provider,{serverUrl:url,scope:'studio offline_access'});
+    if(result==='REDIRECT'){
+      let timer;const timeout=new Promise((_,reject)=>{timer=setTimeout(()=>reject(new Error('Browser approval timed out')),300000);});
+      const back=await Promise.race([returned,timeout]).finally(()=>clearTimeout(timer));
+      if(back.searchParams.has('error'))throw new Error('Connection declined');
+      await auth(provider,{serverUrl:url,authorizationCode:back.searchParams.get('code'),iss:back.searchParams.get('iss')??undefined});
+    }
+    await client.connect(new StreamableHTTPClientTransport(url,{authProvider:provider}));return client;
+  }finally{server.close();}
+}
+function defaultOpen(url){const cmd=process.platform==='darwin'?'open':process.platform==='win32'?'explorer':'xdg-open';const child=spawn(cmd,[url],{stdio:'ignore',detached:true});child.unref();}
+export async function toolCommand(root,sub,positional,flags,{log=()=>{}}={}) {
+  if(sub==='new')return newTool(root,positional[2],{app:flags.get('app')??null});
+  if(!['call','list'].includes(sub))throw new Error('Use tool new <name>, tool list, or tool call <name> --input <JSON>');
+  const client=await connectToolClient(root,flags.get('url')??'http://localhost:8787',{publicOnly:flags.has('public'),log});
+  try{const result=sub==='list'?await client.listTools():await client.callTool({name:positional[2],arguments:JSON.parse(flags.get('input')??'{}')});return {ok:result.isError!==true,command:'tool '+sub,result,...(result.isError?{why:'The tool refused or failed; see its result.'}:{})};}finally{await client.close();}
+}

package/lib/worker-build.mjs

@@ -0,0 +1,35 @@
+import {existsSync,mkdirSync,readFileSync,writeFileSync,rmSync} from 'node:fs';
+import {join,relative,dirname} from 'node:path';
+import {readConfig} from './routes.mjs';
+import {paidReleases} from './parts-upload.mjs';
+import {configPath} from './studio.mjs';
+/** Preserve dynamic imports as real Worker modules: page startup never evaluates MCP libraries. */
+export async function buildWorker(root,esbuild) {
+  const source=join(root,'site/src/worker.mjs');if(!existsSync(source))return;
+  const out=join(root,'site/src/runtime');
+  const alias={...(readConfig(root)?.alias??{})};
+  if(paidReleases(root).length)alias['@homie-rocks/studio/worker']='@homie-rocks/studio/worker/selling';
+  const result=await esbuild.build({entryPoints:[source],absWorkingDir:root,alias,outdir:out,bundle:true,splitting:true,format:'esm',platform:'browser',mainFields:['module','main'],conditions:['workerd','worker','browser'],external:['node:*','cloudflare:*'],target:'es2022',write:false,minify:true,metafile:true,logLevel:'silent'});
+  rmSync(out,{recursive:true,force:true});
+  mkdirSync(out,{recursive:true});
+  for(const file of result.outputFiles)writeFileSync(file.path,file.contents);
+  const config=configPath(root);
+  if(existsSync(config)){
+    const original=readFileSync(config,'utf8');
+    const json=JSON.parse(original.replace(/^\s*\/\/.*$/gm,''));
+    const before=JSON.stringify(json);
+    json.main=relative(dirname(config),join(out,'worker.js')).split('\\').join('/');
+    json.no_bundle=true;json.find_additional_modules=true;
+    json.rules=[...(json.rules??[]).filter(r=>!r.homieMcp),{type:'ESModule',globs:['**/*.js'],fallthrough:true}];
+    // No duplicate rule on rebuild.
+    json.rules=json.rules.filter((r,i,all)=>all.findIndex(x=>JSON.stringify(x)===JSON.stringify(r))===i);
+    json.compatibility_flags=[...new Set([...(json.compatibility_flags??[]),'nodejs_compat'])];
+    if(JSON.stringify(json)!==before) {
+      const comments=original.match(/^(?:\s*\/\/[^\n]*\n)*/)?.[0]??'';
+      writeFileSync(config,comments+JSON.stringify(json,null,2)+'\n');
+    }
+  }
+  const sizes=Object.entries(result.metafile.outputs).map(([path,value])=>({path:relative(root,path),bytes:value.bytes,imports:value.imports}));
+  writeFileSync(join(out,'modules.json'),JSON.stringify(sizes,null,2)+'\n');
+  return sizes;
+}

package/netplay/NETPLAY.md

@@ -2151,12 +2151,26 @@ and holds that lead from `lead`. A step whose sample (or claim) changed, or that
 makes an entry. A period with no entry sends nothing; after 250 ms without a frame the held values
 are sent again as an ordinary entry. A hidden tab sends one neutral entry and stops stepping.
 
-**In this release a person's body is owner-moved** (`body: { move: 'owner' }` in the rules): its
-browser runs the game's `move` code and claims a position, as `netplay.movement: 'owner'` does
-today, and the server holds each claim to the body's `maxSpeed` (a tick of it every tick, a quarter
-of a second banked at most). It does not stop a changed browser walking through a wall. Bots, and a
-body whose player is away, are moved by the server with the same `move` code. Scores, pickups,
-rounds and placements are the server's in either case.
+**Server movement with immediate local prediction.** The host runs `move` for every body.
+The view library runs the same guarded module for its own player, one step per tick and one
+throwaway preview between ticks. A snapshot replaces that body's position, velocity, heading,
+grounded flag and motion; the view replays pending inputs from there. Late presses are mirrored
+onto the next replay tick while they remain inside the quarter-second window. Scores, pickups,
+collisions between entities and effects are always the host's decisions. Bot and AI bodies
+are interpolated, never predicted by a player's view.
+
+Small errors fade as a visual offset with a nominal 100 ms blend. Overlapping small corrections
+queue their individual fades, so their accumulated offset is not erased all at once. A disagreement
+beyond three ticks of travel plays the corrected path from the snapshot at 1.25 times speed,
+showing the hold and slide of a knock. Offset fades are limited by progress along the drawn
+path and the body's declared maximum movement speed, so a late-input correction cannot erase more travel than the player makes or compound a fast knock's catch-up speed. Catch-up preserves the drawn pose when a snapshot replaces its history, and uses the next movement preview when its next whole-tick history entry is not yet available. When movement
+stops after catch-up, the remaining fade follows the configured blend time, still bounded by that speed. An effect on the body waits for its drawn tick. Placements, epoch changes and clock rebases
+jump deliberately. Other bodies keep the helper's adaptive interpolation, with one send period
+as the default minimum delay. The `room.predict` settings customize these defaults.
+
+`body: { move: 'owner' }` remains available for existing rules games: the browser supplies its
+position and the host limits each claim to `maxSpeed`. It cannot prevent a modified owner walking
+through a wall. New Coin Dash and Gem Rush use authoritative server movement instead.
 
 ### 29.3 The life of a server-hosted room
 

package/netplay/netplay.ts

@@ -631,6 +631,8 @@ export interface NetplayOptions<C = unknown> {
   checkpointMs?: number;
   /** Fixed interpolation delay in ms. Default: adaptive (arrival age p90 + 1.2 intervals). */
   interpDelayMs?: number;
+  /** Floor under the adaptive interpolation buffer (rules views). */
+  interpFloorMs?: number;
   /** Host: return the full rules state. Called every `checkpointMs`, before yielding, and on pagehide. */
   checkpoint?: () => C;
   /** ms to wait for a welcome before falling back to offline host, when the socket could not even open. Default 4000. */
@@ -2947,7 +2949,7 @@ export function createNetplay<S = unknown, A = unknown, C = unknown>(opts: Netpl
 
   function interpDelay(): number {
     if (opts.interpDelayMs !== undefined) return opts.interpDelayMs;
-    return delaySmooth || Math.max(50, iv * 1.6 + 8);
+    return Math.max(opts.interpFloorMs ?? 0, delaySmooth || Math.max(50, iv * 1.6 + 8));
   }
 
   // ---------------------------------------------------------------- connect

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@homie-rocks/studio",
-  "version": "0.37.2",
+  "version": "0.39.0",
   "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, big songs and videos in the studio's own R2 once it has storage (uploaded, checked by SHA-256, served at the same addresses), deploy, and the homie.rocks directory.",
   "type": "module",
   "license": "Apache-2.0",
@@ -84,7 +84,11 @@
       "types": "./apps/apps.ts",
       "default": "./apps/apps.ts"
     },
-    "./worker/selling": "./worker/selling/index.mjs"
+    "./worker/selling": "./worker/selling/index.mjs",
+    "./tools": {
+      "types": "./tools/tools.ts",
+      "default": "./tools/tools.ts"
+    }
   },
   "files": [
     "bin/",
@@ -111,7 +115,8 @@
     "NOTICE",
     "links/",
     "apps/",
-    "app-starters/"
+    "app-starters/",
+    "tools/"
   ],
   "engines": {
     "node": ">=22"
@@ -122,17 +127,22 @@
     "@babel/parser": "8.0.7",
     "@babel/traverse": "8.0.7",
     "@babel/types": "8.0.6",
+    "@cloudflare/workers-oauth-provider": "1.2.3",
     "@coinbase/x402": "2.1.0",
     "@gltf-transform/core": "4.5.1",
     "@gltf-transform/extensions": "4.5.1",
     "@gltf-transform/functions": "4.5.1",
     "@jridgewell/trace-mapping": "0.3.31",
-    "@modelcontextprotocol/sdk": "1.32.1",
+    "@modelcontextprotocol/sdk": "1.30.0",
+    "@modelcontextprotocol/server": "2.0.0",
     "@x402/core": "2.28.0",
     "@x402/evm": "2.28.0",
+    "agents": "0.28.0",
     "esbuild": "0.28.1",
     "gltf-validator": "2.0.0-dev.3.10",
     "jose": "6.2.12",
+    "mcp-purchase-sdk": "npm:@modelcontextprotocol/sdk@1.32.1",
+    "mcp-studio-client": "npm:@modelcontextprotocol/client@2.3.1",
     "meshoptimizer": "1.3.0",
     "mppx": "0.13.2",
     "puppeteer-core": "25.8.0",
@@ -140,10 +150,11 @@
     "spdx-expression-parse": "5.0.0",
     "stripe": "23.0.0",
     "three": "0.185.1",
+    "typescript": "5.9.3",
     "viem": "2.57.4",
-    "typescript": "5.9.3"
+    "zod": "4.3.6"
   },
   "scripts": {
-    "test": "node --test test/*.test.mjs"
+    "test": "node --test --test-concurrency=2 --test-timeout=1800000 test/*.test.mjs"
   }
 }

package/port/probe.ts

@@ -123,7 +123,8 @@ export function exposePort(net: Netplay<unknown, unknown, unknown> | null, opts:
     rows.push([t, me ? me.x : NaN, me ? me.y : NaN, b.right[0], b.right[1], b.up[0], b.up[1], m, busy]);
     if (rows.length > RING) rows.splice(0, rows.length - RING);
   };
-  const loop = (t: number): void => { sample(t); requestAnimationFrame(loop); };
+  // The position is sampled now; rAF may carry an earlier timestamp on a busy renderer.
+  const loop = (): void => { sample(performance.now()); requestAnimationFrame(loop); };
   if (typeof requestAnimationFrame === 'function') requestAnimationFrame(loop);
   const probe: PortProbe = {
     v: 1,

package/rules/core.ts

@@ -177,7 +177,7 @@ export interface Core {
  * `noted`: told, as it happens, of a value the rules wrote that the runtime changed to make it fit, or dropped (pack.ts
  * `Adjusted`; also `effect`, `think` and `decision`): the handler, what was done, the field's name and what was written.
  */
-export function createCore(c: Compiled, opts: { observe?: (kind: string, handler: string, error?: string) => void; noted?: (kind: string, handler: string, what: string, at: string, written: string) => void; seed?: number; epoch?: number; restore?: SavedCore | null; restoreEpoch?: number; stage?: string; decisions?: boolean } = {}): Core {
+export function createCore(c: Compiled, opts: { moved?: (kind: string, tick: number, input: Readonly<Record<string, unknown>>, before: import('./pack.ts').MoveBody, after: import('./pack.ts').MoveBody) => void; observe?: (kind: string, handler: string, error?: string) => void; noted?: (kind: string, handler: string, what: string, at: string, written: string) => void; seed?: number; epoch?: number; restore?: SavedCore | null; restoreEpoch?: number; stage?: string; decisions?: boolean } = {}): Core {
   if (c.dims !== 2) throw new Error('this release runs rules with space.dims: 2; bodies with height (dims: 3) arrive in a later one');
   const dims = c.dims;
   const tickHz = c.settings.tickHz;
@@ -1002,6 +1002,7 @@ export function createCore(c: Compiled, opts: { observe?: (kind: string, handler
         }
         if (!k.move) continue;
         const b = { pos: e.pos, vel: e.vel, heading: e.heading, grounded: e.grounded, motion: e.mself };
+        const beforeMove = opts.moved ? { pos: e.pos, vel: e.vel, heading: e.heading, grounded: e.grounded, motion: { ...e.m } } : null;
         moveRadius = body.radius;
         run(k.name, 'move', e, 'move', () => (k.move as NonNullable<KindTable['move']>)(b, e.input, moveCtx), 'body');
         // The runtime rounds to 32-bit floats, here and in the browser, so both step from exactly the same numbers.
@@ -1011,6 +1012,7 @@ export function createCore(c: Compiled, opts: { observe?: (kind: string, handler
         naming('body', 'pos'); e.pos = clampIn(V(own(b, 'pos')), body.radius); naming('body', 'vel'); e.vel = V(own(b, 'vel')); naming('body', 'heading'); e.heading = dir(own(b, 'heading'), dims); naming();
         G.note = null;
         e.grounded = own(b, 'grounded') === true;
+        if (beforeMove) opts.moved!(k.name, tick, e.input, beforeMove, { pos: e.pos, vel: e.vel, heading: e.heading, grounded: e.grounded, motion: { ...e.m } });
       }
       // Phase 2: for every entity, its commands and then its tick, starting from a different entity each tick.
       const list = [...ents.values()];

package/rules/host.ts

@@ -58,6 +58,8 @@ export interface HostClock {
 }
 export interface HostOptions {
   game: string;
+  /** The build check compares a movement step before any tick handler can change it. */
+  moved?: NonNullable<Parameters<typeof createCore>[1]>['moved'];
   /** Told of every handler as it ends, and what it threw if it threw (core.ts `observe`): the build check listens. */
   observe?(kind: string, handler: string, error?: string): void;
   /** Told of a written value the runtime changed to make it fit (core.ts `noted`): the build check listens. */
@@ -226,7 +228,7 @@ export function createHost(o: HostOptions): Host {
     }
   }
   if (saved && saved.v !== 1) throw new Error('this save was written by another version of the runtime');
-  const core = createCore(c, { observe: o.observe, noted: o.noted, seed: Math.floor(random() * 4294967296) >>> 0, epoch: saved ? undefined : (Math.floor(random() * 4294967295) >>> 0) + 1, restore: saved?.core ?? null, restoreEpoch: o.restoreEpoch, stage: o.stage, decisions: !o.check });
+  const core = createCore(c, { moved: o.moved, observe: o.observe, noted: o.noted, seed: Math.floor(random() * 4294967296) >>> 0, epoch: saved ? undefined : (Math.floor(random() * 4294967295) >>> 0) + 1, restore: saved?.core ?? null, restoreEpoch: o.restoreEpoch, stage: o.stage, decisions: !o.check });
   let epoch = core.epoch;
   if (saved && (o.startPaused ?? o.restoreEpoch !== undefined)) for (const body of core.bodies()) if (body.driver !== 'bot' && body.owner !== 'reserved') core.seatAway(body.seat, true);
   let lastSaveAt = o.clock.now();

package/rules/pack.ts

@@ -263,12 +263,39 @@ export interface MoveBody { pos: Vec3; vel: Vec3; heading: Vec3; grounded: boole
  */
 export function stepMove(fn: (body: MoveBody, input: unknown, ctx: unknown) => void, body: MoveBody, input: Readonly<Record<string, unknown>>, ctx: unknown, quota: number, motion: FieldList, dims: number, failed: (error: unknown) => void): MoveBody & { used: number } {
   G.left = quota;
+  const bag = coerceFields(motion, body.motion, dims);
+  const target: Record<string, unknown> = {};
+  const work: Record<string, unknown> = {};
+  // Match core.typed: scalar writes round immediately; collections copy on first read and settle at the end.
+  for (const [name, fd] of motion) {
+    const held = (v: unknown): unknown => { naming('body.motion', name); const out = coerce(fd, v, dims); naming(); return out; };
+    Object.defineProperty(target, name, { enumerable: true,
+      get: () => {
+        if (!mutable(fd)) return bag[name];
+        if (work[name] === undefined) {
+          const size = fd.t === 'list' ? 1 + (bag[name] as unknown[]).length * cellsOf(fd.of as Field)
+            : fd.t === 'map' ? 1 + Object.keys(bag[name] as object).length * (1 + cellsOf(fd.of as Field)) : cellsOf(fd);
+          charge(6 * size); work[name] = thaw(fd, bag[name]);
+        }
+        return work[name];
+      },
+      set: (v: unknown) => {
+        charge(mutable(fd) ? 6 * est(fd, v) : cellsOf(fd) === 1 ? 3 : 6 * cellsOf(fd));
+        bag[name] = held(v); work[name] = undefined;
+      },
+    });
+  }
+  body.motion = Object.preventExtensions(target);
   try { fn(body, input, ctx); } catch (error) { failed(error); }
+  try {
+    for (const [name, fd] of motion) if (work[name] !== undefined) {
+      charge(6 * est(fd, work[name])); naming('body.motion', name); bag[name] = coerce(fd, work[name], dims); naming();
+    }
+  } catch (error) { failed(error); }
   const used = quota - (G.left > 0 ? G.left : 0);
   G.left = Infinity;
-  naming('body', 'pos'); const pos = vec3(body.pos, dims); naming('body', 'vel'); const vel = vec3(body.vel, dims); naming('body', 'heading'); const heading = dir(body.heading, dims);
-  naming('body', 'motion'); const held = thawFields(motion, coerceFields(motion, body.motion, dims)); naming();
-  return { pos, vel, heading, grounded: body.grounded === true, motion: held, used };
+  naming('body', 'pos'); const pos = vec3(body.pos, dims); naming('body', 'vel'); const vel = vec3(body.vel, dims); naming('body', 'heading'); const heading = dir(body.heading, dims); naming();
+  return { pos, vel, heading, grounded: body.grounded === true, motion: thawFields(motion, bag), used };
 }
 
 /** How many values `pack` has packed since this was last set to 0: the core reads it to charge a tick for the state it sends. */