gamekit777 0.1.6 → 0.1.8

package/studio/cli.ts

@@ -2,7 +2,7 @@
 /* `gamekit777` 这个命令的入口：按子命令分派。
  *
  *   gamekit777 studio [dir] [--mcp|--no-mcp] [--game-port N] [--backend URL]   起工作台（MCP 走 stdio）
- *   gamekit777 new [名字]                                      新建游戏并装依赖：给名字 → 子目录 ./名字；不给 → 就地用当前（空）目录
+ *   gamekit777 new [名字] [--no-update]                        新建游戏并装依赖：给名字 → 子目录 ./名字；不给 → 就地用当前（空）目录；比 npm 旧就换最新版重跑
  *
  * 只是薄薄一层分派，逻辑各在 bin.ts 和 src/scaffold.ts。 */
 const [sub, ...rest] = process.argv.slice(2);
@@ -10,7 +10,8 @@ const [sub, ...rest] = process.argv.slice(2);
 const usage = (): never => {
   process.stderr.write(`用法：
   gamekit777 studio [dir] [--mcp|--no-mcp] [--game-port N] [--backend URL]
-  gamekit777 new [名字]                        新建游戏并装依赖：给名字 → 生成 ./名字；不给 → 就地用当前目录（必须是空目录，id 取目录名）
+  gamekit777 new [名字] [--no-update]          新建游戏并装依赖：给名字 → 生成 ./名字；不给 → 就地用当前目录（必须是空目录，id 取目录名）
+                                               比 npm 上的最新版旧时自动换最新版重跑；--no-update 用当前这份
 
 接 Claude Code：在游戏目录里
   claude mcp add gamekit -- bunx gamekit777 studio
@@ -26,12 +27,24 @@ switch (sub) {
   }
   case 'new': {
     /* 只收一个可选的名字。不给就用当前目录：AI 多半已经站在要建的目录里，再套一层 my-game 只会让它 cd 错地方。
-       标题之类都在生成后的 game.meta.json 里改，少一层「命令行参数 vs 配置文件」的分叉 */
-    if (rest.length > 1 || rest[0]?.startsWith('-')) usage();
-    const { scaffold } = await import('./src/scaffold.ts');
+       标题之类都在生成后的 game.meta.json 里改，少一层「命令行参数 vs 配置文件」的分叉。
+       跑之前先看 npm 有没有更新的版本：bunx 把裸 `gamekit777` 缓存成一个临时目录、隔天照用，
+       旧脚手架生成的模板对不上新装的运行时。比 npm 旧就用精确版本号重跑一遍，模板与运行时同时是最新的 */
+    const noUpdate = rest.includes('--no-update');
+    const args = rest.filter((a) => a !== '--no-update');
+    if (args.length > 1 || args[0]?.startsWith('-')) usage();
+    const { scaffold, reexecArgs, inWorkspace } = await import('./src/scaffold.ts');
+    const { newerOnNpm, ownVersion } = await import('./src/version.ts');
+    const latest = noUpdate || inWorkspace(process.cwd()) ? null : await newerOnNpm();
+    if (latest) {
+      process.stderr.write(`· 这份 gamekit777 是 ${ownVersion()}，npm 上最新是 ${latest}，改用最新版生成（--no-update 可跳过）\n`);
+      const { cmd, args: a, env } = reexecArgs(latest, args[0]);
+      const { spawnSync } = await import('node:child_process');
+      process.exit(spawnSync(cmd, a, { stdio: 'inherit', env }).status ?? 1);
+    }
     try {
-      const r = await scaffold({ name: rest[0] }, process.cwd());
-      process.stdout.write(`✓ ${r.inPlace ? `就地生成在 ${r.dest}` : r.dest}\n\n${r.next.map((n) => `  ${n}`).join('\n')}\n\n  ${r.inPlace ? '' : `cd ${r.dest} && `}bunx gamekit777 studio\n`);
+      const r = await scaffold({ name: args[0], noUpdate: true }, process.cwd());
+      process.stdout.write(`✓ ${r.inPlace ? `就地生成在 ${r.dest}` : r.dest}（gamekit777 ${r.gamekit}）\n\n${r.next.map((n) => `  ${n}`).join('\n')}\n\n  ${r.inPlace ? '' : `cd ${r.dest} && `}bunx gamekit777 studio\n`);
     } catch (e) {
       process.stderr.write(`✗ ${e instanceof Error ? e.message : String(e)}\n`);
       process.exit(1);

package/studio/preview/entry.ts

@@ -3,7 +3,7 @@
  * 壳就是 dev-host 的 DevShell——和 `bun run dev` 看到的是同一个参考平台，同一条本地表模型：
  * 浏览器里就地建表、按权重抽行、restore 还原。studio 多接的只有三样：
  * 建好的正式产物（有就优先用）、存为 case、以及 node 侧的总线（MCP 的 preview_* 工具从那儿进来）。 */
-import { runDevShell, parseTable, localServer, type LoadedTable, type PlatformOf } from 'gamekit777/dev-host';
+import { runDevShell, parseTable, localServer, layoutFromSearch, safeFromSearch, type LoadedTable, type PlatformOf } from 'gamekit777/dev-host';
 import type { GameModule } from 'gamekit777/sdk';
 import game from 'virtual:studio/game';
 import { api, connectBridge } from './bridge.ts';
@@ -23,6 +23,10 @@ let p: PlatformOf<object, unknown> | null = null;
 runDevShell(g, {
   // 嵌入模式：页眉和余额由 studio 页面画，这里只剩机台和机台下面的开发面板
   embedded: true,
+  /* 布局默认桌面，不按窗口判——iframe 有多宽由 studio 页面决定。首载从 ?layout= 读，之后由 set 命令就地切；
+     ?safe= 是设备预设模拟的刘海，iframe 里 env() 拿不到 */
+  layout: layoutFromSearch(location.search) ?? 'desktop',
+  simSafe: safeFromSearch(location.search) ?? undefined,
   server: localServer({ spec: g, external }),
   onPlatform: (plat) => { p = plat; },
   onSaveCase: async (h, title) => {
@@ -39,6 +43,7 @@ const snapshot = (): Record<string, unknown> => {
   return {
     config: plain(p.config), mode: p.tableMode, bet: p.bet, balance: p.balance, pnl: p.pnl,
     status: plain(p.game), lastError: p.err, tableModes: plain(p.tableModes),
+    layout: p.layout, stage: plain(p.stage),
     recent: p.history.slice(0, 10).map((h) => ({ n: h.n, mode: h.mode, multiplier: h.multiplier, payout: h.payout, simId: h.simId, ok: h.checks.every((c) => c.ok) })),
   };
 };
@@ -60,6 +65,10 @@ const bridge = connectBridge({
         if (cmd.clientSeed !== undefined) { plat.clientSeed = String(cmd.clientSeed); applied.push('clientSeed'); }
         if (cmd.skin !== undefined) { plat.setView({ skin: String(cmd.skin) }); applied.push('skin'); }
         if (cmd.turbo !== undefined) { plat.setView({ turbo: !!cmd.turbo }); applied.push('turbo'); }
+        if (cmd.layout !== undefined) {
+          if (cmd.layout === 'desktop' || cmd.layout === 'mobile') { plat.setLayout(cmd.layout); applied.push('layout'); }
+          else rejected.push({ key: 'layout', reason: '只能是 desktop / mobile' });
+        }
         return { applied, rejected, state: snapshot() };
       }
       case 'play': {

package/studio/src/engine.ts

@@ -5,6 +5,7 @@
 import { existsSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs';
 import { join, relative } from 'node:path';
 import { Sha256 } from 'gamekit777/sdk/hash';
+import type { StageInfo, StageLayout } from 'gamekit777/sdk';
 import type { Segment } from 'gamekit777/weights';
 import { Bus } from './bus.ts';
 import { buildMode, groupsSummary, listArtifacts, readArtifactBytes, sampleMode, type Artifact, type BuildModeOptions } from './build.ts';
@@ -31,6 +32,9 @@ export interface PreviewState {
   lastError: string | null;
   recent: unknown[];
   consoleErrors: string[];
+  /** 机台布局与交给游戏的舞台（含安全区）。页面的切换按钮和 MCP 的 preview_set 都以这里为准 */
+  layout: StageLayout | null;
+  stage: StageInfo | null;
   updatedAt: number;
 }
 
@@ -85,7 +89,7 @@ export class Engine {
   readonly assets: AssetStore;
   preview: PreviewState = {
     connected: false, config: null, mode: null, bet: null, balance: null,
-    status: null, lastError: null, recent: [], consoleErrors: [], updatedAt: 0,
+    status: null, lastError: null, recent: [], consoleErrors: [], layout: null, stage: null, updatedAt: 0,
   };
   #publish = new Map<string, PublishRequest>();
   #lastFingerprint: string;

package/studio/src/mcp.ts

@@ -145,12 +145,15 @@ export function createMcpServer(engine: Engine): McpServer {
   });
 
   s.registerTool('scaffold', {
-    description: '新建一个游戏（能跑的抛硬币）并 bun install。不给 name 就在当前目录就地生成（当前目录必须是空的，id 取目录名）；给 name 就生成到子目录 ./name。当前目录已经是项目时会拒绝并让你给名字。标题之后改 game.meta.json。生成后要在那个目录里重启 studio。',
-    inputSchema: { name: z.string().optional().describe('子目录名，同时是 id（小写短横线）。不给 = 用当前目录') },
+    description: '新建一个游戏（能跑的抛硬币）并 bun install。不给 name 就在当前目录就地生成（当前目录必须是空的，id 取目录名）；给 name 就生成到子目录 ./name。当前目录已经是项目时会拒绝并让你给名字。标题之后改 game.meta.json。模板钉死生成它的 gamekit777 版本；npm 上有更新版本时会用那一版代跑。生成后要在那个目录里重启 studio。',
+    inputSchema: {
+      name: z.string().optional().describe('子目录名，同时是 id（小写短横线）。不给 = 用当前目录'),
+      noUpdate: z.boolean().optional().describe('不查 npm、不用更新的版本代跑'),
+    },
   }, async (a) => {
     try {
-      const r = await scaffold({ name: a.name }, process.cwd());
-      return out(`## ✅ ${r.inPlace ? `已就地生成在 ${r.dest}` : `已生成 ${r.dest}`}\n\n${r.files} 个文件，依赖${r.installed ? '已装' : '未装'}。\n\n${r.next.map((n) => `- ${n}`).join('\n')}`, r);
+      const r = await scaffold({ name: a.name, noUpdate: a.noUpdate }, process.cwd());
+      return out(`## ✅ ${r.inPlace ? `已就地生成在 ${r.dest}` : `已生成 ${r.dest}`}\n\n${r.files} 个文件，依赖${r.installed ? '已装' : '未装'}，gamekit777 ${r.gamekit}${r.upgradedTo ? '（由 npm 最新版代跑）' : ''}。\n\n${r.next.map((n) => `- ${n}`).join('\n')}`, r);
     } catch (e) { return fail(e instanceof Error ? e.message : String(e)); }
   });
 
@@ -282,25 +285,27 @@ export function createMcpServer(engine: Engine): McpServer {
   });
 
   s.registerTool('preview_state', {
-    description: '预览页的当前状态：连没连、当前 config / mode / 注额 / 余额、已加载的表、最近几局、控制台报错。',
+    description: '预览页的当前状态：连没连、当前 config / mode / 注额 / 余额、已加载的表、最近几局、控制台报错、机台布局（desktop/mobile）与交给游戏的舞台尺寸和安全区。',
     inputSchema: {},
   }, async () => {
     engine.touch();
     const p = engine.preview;
     if (!engine.bus.previewConnected) return out(`预览页没连着。请在浏览器打开 ${engine.urls.studio}`, { connected: false });
     return out([`## 预览（本地表模型）`, `- mode ${p.mode}，注额 ${p.bet}，余额 ${p.balance}`, `- config ${JSON.stringify(p.config)}`,
+      ...(p.stage ? [`- 布局 ${p.layout}，舞台 ${p.stage.width}×${p.stage.height}，安全区 上 ${p.stage.safe.top} 下 ${p.stage.safe.bottom}`] : []),
       `- 最近 ${p.recent.length} 局`, ...(p.lastError ? [`- ⚠️ 最近错误：${p.lastError}`] : []),
       ...(p.consoleErrors.length ? ['', '### 控制台报错', ...p.consoleErrors.slice(-5).map((e) => `- ${e}`)] : [])].join('\n'), p);
   });
 
   s.registerTool('preview_set', {
-    description: '改预览的设置：config、注额、客户端种子、造型、极速。局中/自动中会被平台否决，rejected 里会说。',
+    description: '改预览的设置：config、注额、客户端种子、造型、极速、机台布局（desktop 桌面 / mobile 手机竖屏全屏）。局中/自动中会被平台否决，rejected 里会说。',
     inputSchema: {
       config: z.record(z.string(), z.unknown()).optional(),
       bet: z.number().int().optional().describe('最小货币单位（分）'),
       clientSeed: z.string().optional(),
       skin: z.string().optional(),
       turbo: z.boolean().optional(),
+      layout: z.enum(['desktop', 'mobile']).optional().describe('切机台布局。游戏不重挂，收到 host.stage 后自己重排。两种布局都要验过；具体机型尺寸与刘海只能在 studio 页面机台上方选，MCP 不切'),
     },
   }, async (a) => {
     try {

package/studio/src/scaffold.ts

@@ -1,11 +1,17 @@
 /* 建新游戏：脚手架 + 写 package.json + bun install。
  *
  * 这是 MCP 的 scaffold 工具背后的东西。装依赖这一步只有这里会自动做——
- * 别处发现缺 node_modules 一律只提示，不代作者动手。 */
+ * 别处发现缺 node_modules 一律只提示，不代作者动手。
+ *
+ * 一条不变式：**模板里钉的 gamekit777 版本 = 生成它的那份 gamekit777。**
+ * 写 `^x.y.z` 违反它——bunx 缓存里的旧脚手架写出 `^0.1.2`，bun install 却装到 0.1.7，
+ * 模板和运行时错位，第一条 check 就红。所以版本钉死；而「跑着的是旧版」这件事
+ * 由 newerOnNpm 兜：比 npm 旧就换最新版重跑一遍，模板与运行时同时是最新的。 */
 import { spawn } from 'node:child_process';
-import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
 import { basename, join } from 'node:path';
 import { scaffoldGame, ID_PATTERN } from 'gamekit777/create-game';
+import { REEXEC_ENV, newerOnNpm, ownVersion } from './version.ts';
 
 export const DEFAULT_ID = 'my-game';
 export const DEFAULT_TITLE = '我的游戏';
@@ -42,10 +48,12 @@ export interface ScaffoldRequest {
   /** 子目录名，同时是 id。不给就在 cwd 里就地生成，id 取自目录名 */
   name?: string;
   title?: string;
-  /** package.json 里 gamekit777 的版本说明符。仓库内是 workspace:*，创作者机器上是版本号 */
+  /** package.json 里 gamekit777 的版本说明符。仓库内是 workspace:*，创作者机器上是精确版本号 */
   gamekitSpec?: string;
   /** 跳过 bun install */
   skipInstall?: boolean;
+  /** 不查 npm、不自升级：离线或明确要用当前这份 */
+  noUpdate?: boolean;
 }
 
 export interface ScaffoldResult {
@@ -56,21 +64,26 @@ export interface ScaffoldResult {
   files: number;
   installed: boolean;
   installOutput: string;
+  /** 模板钉的 gamekit777 版本；仓库内是 workspace:* */
+  gamekit: string;
+  /** 由更新的版本代跑时是那个版本号；自己跑的是 null */
+  upgradedTo: string | null;
   next: string[];
 }
 
-function bunInstall(cwd: string): Promise<{ ok: boolean; output: string }> {
+function run(cmd: string, args: string[], cwd: string, env?: NodeJS.ProcessEnv): Promise<{ ok: boolean; output: string }> {
   return new Promise((resolve) => {
-    const child = spawn('bun', ['install'], { cwd, stdio: ['ignore', 'pipe', 'pipe'] });
+    const child = spawn(cmd, args, { cwd, env: env ?? process.env, stdio: ['ignore', 'pipe', 'pipe'] });
     let out = '';
     child.stdout.on('data', (b: Buffer) => { out += b.toString(); });
     child.stderr.on('data', (b: Buffer) => { out += b.toString(); });
+    child.on('error', (e) => resolve({ ok: false, output: `${out}\n${e.message}` }));
     child.on('close', (code) => resolve({ ok: code === 0, output: out.slice(-4000) }));
   });
 }
 
-/** 仓库内跑就用 workspace:*，否则用 studio 自己这份 gamekit777 的版本号 */
-function defaultSpec(dest: string): string {
+/** 往上找 6 层，有 workspaces 的 package.json 就是在仓库内 */
+export function inWorkspace(dest: string): boolean {
   let dir = dest;
   for (let i = 0; i < 6; i++) {
     dir = join(dir, '..');
@@ -78,42 +91,72 @@ function defaultSpec(dest: string): string {
     if (existsSync(pkg)) {
       try {
         const m = JSON.parse(readFileSync(pkg, 'utf8')) as { workspaces?: string[] };
-        if (m.workspaces) return 'workspace:*';
+        if (m.workspaces) return true;
       } catch { /* 继续往上 */ }
     }
   }
-  /* 仓库内这个文件在 packages/studio/src/，薄壳在 packages/gamekit777/；
-     压平进 npm 包后在 gamekit777/studio/src/，包根就是 gamekit777 本身。两种布局都试 */
-  for (const rel of ['../../package.json', '../../../gamekit777/package.json']) {
-    try {
-      const m = JSON.parse(readFileSync(new URL(rel, import.meta.url), 'utf8')) as { name?: string; version?: string };
-      if (m.name === 'gamekit777' && m.version) return `^${m.version}`;
-    } catch { /* 下一个 */ }
-  }
-  return '*';
+  return false;
+}
+
+/** 仓库内跑就用 workspace:*，否则钉死成 studio 自己这份 gamekit777 的精确版本 */
+export function defaultSpec(dest: string): string {
+  if (inWorkspace(dest)) return 'workspace:*';
+  return ownVersion() ?? 'latest';
+}
+
+/** 用 npm 上更新的那份代跑 `new`。精确版本的 bunx 目录不会被旧缓存顶掉 */
+export function reexecArgs(latest: string, name?: string): { cmd: string; args: string[]; env: NodeJS.ProcessEnv } {
+  return {
+    cmd: 'bun',
+    args: ['x', `gamekit777@${latest}`, 'new', ...(name ? [name] : [])],
+    env: { ...process.env, [REEXEC_ENV]: latest },
+  };
+}
+
+const countFiles = (dir: string): number =>
+  readdirSync(dir).reduce((n, f) => {
+    if (f === 'node_modules' || f === '.git') return n;
+    const p = join(dir, f);
+    return n + (statSync(p).isDirectory() ? countFiles(p) : 1);
+  }, 0);
+
+export function nextSteps(dest: string, id: string, inPlace: boolean, upgradedTo: string | null): string[] {
+  return [
+    inPlace
+      ? `就地生成在当前目录 ${dest}（id = ${id}，取自目录名），不用 cd。是一个能跑的抛硬币；名字和标题在 game.meta.json 里改。`
+      : `游戏在 ${dest}（id = ${id}），是一个能跑的抛硬币。从能跑的东西开始改；名字和标题在 game.meta.json 里改。`,
+    ...(upgradedTo ? [`模板由 npm 上最新的 gamekit777@${upgradedTo} 生成并钉死在 package.json 里；之后在这个目录里跑的 gamekit777 命令都用项目里装的这份，不再受 bunx 缓存影响。正在运行的 studio 还是旧版，要在这个目录里重启它。`] : []),
+    `先读 ${join(dest, 'CLAUDE.md')}：清单字段、round() 的硬约束、modes/book/restore 怎么选、演出侧约定。`,
+    '改 src/rules/ 下的纯逻辑（零 DOM、零自取随机），改 src/components/ 下的演出。',
+    '已发布过的 mode 解码逻辑不能改，要改就换 slug；结果漂移由 studio/cases.jsonl 兜。',
+    '用 run_task 跑 check / test / verify；用 probe_table 看能不能打表；用 preview_play 在预览里演几局。',
+  ];
 }
 
 export async function scaffold(req: ScaffoldRequest, cwd: string): Promise<ScaffoldResult> {
   const { id, dest, inPlace } = resolveTarget(cwd, req.name);
-  const r = scaffoldGame({ id, title: req.title ?? DEFAULT_TITLE, dest, gamekitSpec: req.gamekitSpec ?? defaultSpec(dest) });
+  const spec = req.gamekitSpec ?? defaultSpec(dest);
+
+  /* 只有「创作者机器 + 默认版本」这条路才查 npm：仓库内是 workspace，自验指定了 tarball，都不用 */
+  const latest = !req.gamekitSpec && spec !== 'workspace:*' && !req.noUpdate && !req.skipInstall ? await newerOnNpm() : null;
+  if (latest) {
+    const { cmd, args, env } = reexecArgs(latest, req.name);
+    const r = await run(cmd, args, cwd, env);
+    if (!r.ok) throw new Error(`用 gamekit777@${latest} 生成失败（当前这份是 ${spec}）：\n${r.output}`);
+    return {
+      dest, id, inPlace, files: countFiles(dest), installed: true, installOutput: r.output,
+      gamekit: latest, upgradedTo: latest, next: nextSteps(dest, id, inPlace, latest),
+    };
+  }
+
+  const r = scaffoldGame({ id, title: req.title ?? DEFAULT_TITLE, dest, gamekitSpec: spec });
 
   let installed = false, installOutput = '';
   if (!req.skipInstall) {
-    const i = await bunInstall(dest);
+    const i = await run('bun', ['install'], dest);
     installed = i.ok; installOutput = i.output;
     if (!i.ok) throw new Error(`bun install 失败：\n${i.output}`);
   }
 
-  return {
-    dest, id, inPlace, files: r.files.length, installed, installOutput,
-    next: [
-      inPlace
-        ? `就地生成在当前目录 ${dest}（id = ${id}，取自目录名），不用 cd。是一个能跑的抛硬币；名字和标题在 game.meta.json 里改。`
-        : `游戏在 ${dest}（id = ${id}），是一个能跑的抛硬币。从能跑的东西开始改；名字和标题在 game.meta.json 里改。`,
-      `先读 ${join(dest, 'CLAUDE.md')}：清单字段、round() 的硬约束、modes/book/restore 怎么选、演出侧约定。`,
-      '改 src/rules/ 下的纯逻辑（零 DOM、零自取随机），改 src/components/ 下的演出。',
-      '已发布过的 mode 解码逻辑不能改，要改就换 slug；结果漂移由 studio/cases.jsonl 兜。',
-      '用 run_task 跑 check / test / verify；用 probe_table 看能不能打表；用 preview_play 在预览里演几局。',
-    ],
-  };
+  return { dest, id, inPlace, files: r.files.length, installed, installOutput, gamekit: spec, upgradedTo: null, next: nextSteps(dest, id, inPlace, null) };
 }

package/studio/src/studio-plugin.ts

@@ -5,9 +5,7 @@
  *
  * 不往游戏目录写任何文件：两个 html 从内存吐，入口用 /@fs 指回 studio 包。
  * 不依赖游戏目录里有 index.html：脚手架出来的项目没有它，`bun run dev` 就是起 studio。 */
-import { readFileSync } from 'node:fs';
-import type { Plugin } from 'vite';
-import { compile } from 'svelte/compiler';
+import type { DevEnvironment, Plugin, Rollup } from 'vite';
 import { API_PREFIX, createApi } from './api.ts';
 import type { Engine } from './engine.ts';
 
@@ -55,18 +53,36 @@ export function studioPlugin(o: StudioPluginOptions): Plugin {
       return null;
     },
 
-    /* 资源库组件的 <style> 兜底。vite-plugin-svelte 把组件 CSS 存在模块信息里，样式虚拟模块
-       （…svelte?svelte&type=style&lang.css）从那里取；组件还没编译过就先来要样式（重连、刷新、缓存未命中）时
-       它拿不到，退回读文件——整份 .svelte 源码被当 CSS 交给下游，namespace-css 直接炸页。
-       库组件在游戏根之外、内容自足，这里自己编一遍只取 CSS：scoped class 的哈希只由样式文本决定，和组件那次编译一致 */
-    load(id) {
+    /* svelte 组件 <style> 的兜底。
+       vite-plugin-svelte 把编译出的 CSS 挂在组件模块的 meta 上，样式虚拟模块（…svelte?svelte&type=style&lang.css）
+       用 getModuleInfo(不带 query 的文件名) 去取。两种情况取不到，它就放弃，vite 退回读文件——
+       整份 .svelte 源码被当 CSS 交给下游：模板里的 `{#if}` 变成一条条空规则，`<style>` 里的选择器没有 hash，页面整个走样。
+         1. 装成 npm 包后 gamekit777 在游戏的 node_modules 里，vite 给这类模块 id 加 ?v=<hash>，文件名对不上 id。
+            仓库内是符号链接到 packages/，走 /@fs 路径没有 ?v=，所以只有创作者机器上才坏。
+         2. 组件还没编译过就先来要样式（资源库现场编译、重连、刷新）。
+       这里按文件名在模块图里找那次编译留下的 CSS；没有就先把组件本身 transform 一遍再找——
+       不能自己 compile 一遍只取 CSS：dev 下 vite-plugin-svelte 用文件名算 scope hash（s-xxx），
+       默认的按内容算（svelte-xxx），两边对不上，等于没修。 */
+    async load(id) {
       const m = /^([^?]+\.svelte)\?(?:.*&)?svelte(?:&.*)?&type=style(?:&|$)/.exec(id) ?? /^([^?]+\.svelte)\?(?:.*&)?type=style(?:&|$)/.exec(id);
       const file = m?.[1];
-      if (!file || !file.startsWith(o.engine.assets.dir)) return null;
-      try {
-        const src = readFileSync(file, 'utf8');
-        return { code: compile(src, { filename: file, generate: 'client', css: 'external' }).css?.code ?? '' };
-      } catch { return null; }
+      if (!file) return null;
+      const env = this.environment;
+      if (env.mode !== 'dev') return null;
+      const dev = env as DevEnvironment;
+      const pick = (): { code: string; map: Rollup.SourceMapInput | undefined; moduleType: 'css' } | null => {
+        for (const mod of dev.moduleGraph.getModulesByFile(file) ?? []) {
+          // 插件写的 meta 落在 info.meta 上（vite 的 ModuleInfo 代理），mod.meta 是另一份、可能是空的
+          const meta = (mod.info?.meta ?? mod.meta) as { svelte?: { css?: { code?: string; map?: Rollup.SourceMapInput } } } | undefined;
+          const css = meta?.svelte?.css;
+          if (typeof css?.code === 'string') return { code: css.code, map: css.map, moduleType: 'css' };
+        }
+        return null;
+      };
+      const hit = pick();
+      if (hit) return hit;
+      try { await dev.transformRequest(`/@fs${file}`); } catch { return null; }
+      return pick();
     },
 
     configureServer(server) {

package/studio/src/version.ts

@@ -0,0 +1,62 @@
+/* gamekit777 的三个版本：跑着的这份、npm 上最新的、创作者项目里装的。
+ *
+ * 只有 `new` 暴露在 bunx 的缓存下：bun 把裸 `gamekit777` 和 `@latest` 共用一个临时目录，
+ * 装过一次就一直用那份（实测隔天仍是旧版）。项目建好之后 `bunx gamekit777 studio` 优先用
+ * 项目 node_modules 里的那份，所以后面的命令天然和模板一致——要守的只有生成模板这一步。 */
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+const readVersion = (file: string | URL): string | null => {
+  try {
+    const m = JSON.parse(readFileSync(file, 'utf8')) as { name?: string; version?: string };
+    return m.name === 'gamekit777' && m.version ? m.version : null;
+  } catch { return null; }
+};
+
+/** 正在运行的这份 gamekit777 的版本。npm 包里 studio/src 往上两层就是包根；仓库内往上两层是 packages/，薄壳在它下面 */
+export function ownVersion(): string | null {
+  for (const rel of ['../../package.json', '../../gamekit777/package.json']) {
+    const v = readVersion(new URL(rel, import.meta.url));
+    if (v) return v;
+  }
+  return null;
+}
+
+/** 某个游戏目录里装的 gamekit777 版本；没装或是 workspace 链接回仓库时也照读 */
+export function installedVersion(gameDir: string): string | null {
+  const file = join(gameDir, 'node_modules', 'gamekit777', 'package.json');
+  return existsSync(file) ? readVersion(file) : null;
+}
+
+export const NPM_REGISTRY = process.env.GAMEKIT_NPM_REGISTRY ?? 'https://registry.npmjs.org';
+
+/** npm 上的最新版。查不到（离线、超时、registry 挂了）返回 null，调用方按「不升级」处理 */
+export async function latestVersion(timeoutMs = 5000): Promise<string | null> {
+  try {
+    const res = await fetch(`${NPM_REGISTRY}/gamekit777/latest`, { signal: AbortSignal.timeout(timeoutMs) });
+    if (!res.ok) return null;
+    const m = await res.json() as { version?: string };
+    return typeof m.version === 'string' ? m.version : null;
+  } catch { return null; }
+}
+
+/** 只比主.次.修订三段数字；预发布后缀忽略。a 比 b 新返回正数 */
+export function compareVersions(a: string, b: string): number {
+  const pa = a.split('-')[0]!.split('.').map(Number);
+  const pb = b.split('-')[0]!.split('.').map(Number);
+  for (let i = 0; i < 3; i++) {
+    const d = (pa[i] ?? 0) - (pb[i] ?? 0);
+    if (d !== 0) return d;
+  }
+  return 0;
+}
+
+/** 环境变量：由自升级出来的子进程带着，防止再套一层；也可手动设置跳过检查 */
+export const REEXEC_ENV = 'GAMEKIT_NEW_REEXEC';
+
+/** 跑着的比 npm 最新的旧就返回最新版号；查不到、在仓库内、已是子进程都返回 null */
+export async function newerOnNpm(own: string | null = ownVersion()): Promise<string | null> {
+  if (!own || process.env[REEXEC_ENV]) return null;
+  const latest = await latestVersion();
+  return latest && compareVersions(latest, own) > 0 ? latest : null;
+}

package/create-game/template/game.meta.json.tmpl

@@ -1,8 +0,0 @@
-{
-  "id": "__ID__",
-  "title": "__TITLE__",
-  "version": "1.0.0",
-  "aspect": "16:9",
-  "orientation": "any",
-  "fonts": []
-}

package/create-game/template/tsconfig.json

@@ -1,22 +0,0 @@
-{
-  "extends": "@tsconfig/svelte/tsconfig.json",
-  "compilerOptions": {
-    "target": "ES2022",
-    "lib": ["ES2022", "DOM", "DOM.Iterable"],
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "strict": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "noImplicitOverride": true,
-    "noFallthroughCasesInSwitch": true,
-    "noEmit": true,
-    "isolatedModules": true,
-    "verbatimModuleSyntax": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "allowImportingTsExtensions": true,
-    "types": ["vite/client"]
-  },
-  "include": ["src", "test", "scripts", "*.ts"]
-}