gamekit777 0.1.0

package/dev-host/platform-server.ts

@@ -0,0 +1,78 @@
+/* 平台与「服务端」之间的那道缝。
+ *
+ * 本地服务端（浏览器里建表、按权重抽行）和真平台在这条缝的两侧各自成立。
+ * 缝画在这里而不是更靠上，是因为游戏那侧只看到 Host，换服务端时它一行都不用改。 */
+import type { BetLimits, RestoreInput, RngSeed, RoundResult } from '../sdk/index.ts';
+
+export interface WalletState {
+  /** 最小货币单位整数 */
+  balance: number;
+  currency: string;
+  decimals: number;
+  jackpot: number | null;
+}
+
+/** 一条校验结论，给公平性面板显示。失败的那条要能直接告诉玩家哪一步对不上 */
+export interface Check {
+  label: string;
+  ok: boolean;
+  detail?: string;
+}
+
+export interface Delivery<C, O> {
+  /** 已经还原好的结果。宿主把 restore 交给了服务端适配层时走这条 */
+  result?: RoundResult<O>;
+  /**
+   * 服务端抽中的那一行，原样。
+   *
+   * restore 是游戏代码，把游戏隔离进 iframe 之后它不在这一侧——
+   * 于是这条缝也得能只递「那一行」，由拿得到游戏的那一侧去还原。
+   * 「还原出的赔付 = 平台记账」这一条校验也跟着挪过去，它得先有结果才验得了。
+   */
+  row?: RestoreInput<C>;
+  wallet: WalletState;
+  checks: Check[];
+  /** 这一局的公平证，可以贴到验证页 */
+  proof?: unknown;
+}
+
+export type PlaceResult<C, O> =
+  | { ok: true; round: Delivery<C, O> }
+  | { ok: false; error: string };
+
+export interface PlaceInput<C> {
+  config: C;
+  /** 最小货币单位整数 */
+  bet: number;
+  clientSeed: string;
+}
+
+/** 定点复现：给 seed 复现那一局，给 simId 直接演表里第 N 行。只有本地服务端支持 */
+export interface PlayInput<C> extends PlaceInput<C> {
+  seed?: RngSeed;
+  simId?: number;
+}
+
+export interface PlatformServer<C, O> {
+  readonly kind: 'local' | 'remote';
+  init(): Promise<WalletState>;
+  place(input: PlaceInput<C>): Promise<PlaceResult<C, O>>;
+  /**
+   * 服务端强制的注额区间。null = 用默认区间。
+   *
+   * 真平台一定要覆盖：平台的 bet_cents % 100 === 0 是记账前提，违反了 RTP 会变成注额的函数。
+   */
+  limits(): BetLimits | null;
+  /** 开发期的充值。返回新钱包，没有就是不支持（真平台不支持） */
+  refill?(): WalletState | void;
+  /** 本地服务端才有：定点复现 */
+  play?(input: PlayInput<C>): Promise<PlaceResult<C, O>>;
+  /** 本地服务端才有：重新拉表（改了规则、建了新表之后） */
+  reload?(): Promise<{ modes: string[] }>;
+}
+
+/** 两个本地服务端共用一个钱包时用它，切换不清零 */
+export interface WalletRef { balance: number }
+
+export const DEFAULT_BALANCE = 100_000;
+export const DEFAULT_LIMITS: BetLimits = { min: 100, max: 1_000_000, step: 100 };

package/dev-host/platform.svelte.ts

@@ -0,0 +1,277 @@
+/* 参考平台。泛型：驱动任何符合清单的游戏。
+
+   它做的事就是真平台要做的事：持有配置和钱包、渲染设置 UI、生成种子、
+   调服务端、对账、驱动自动模式循环、记历史。游戏那边完全不知道它的存在——只看到一个 Host。
+
+   状态用 runes 写（这是个 Svelte 宿主），交给游戏的是框架中立的 Readable。
+   换成 React 宿主时这一层换成 useSyncExternalStore，游戏侧零改动。 */
+import {
+  defaultsOf, writable,
+  type GameDefinition, type GameStatus, type Host, type Readable, type RoundResult, type ViewSettings, type WalletView,
+} from '../sdk/index.ts';
+import { localServer } from './local.ts';
+import { DEFAULT_LIMITS, type Check, type PlatformServer, type PlayInput } from './platform-server.ts';
+
+export type Mode = 'manual' | 'auto';
+
+export interface GameApi<O> {
+  present(res: RoundResult<O>, rate?: number): Promise<void>;
+  status(): GameStatus;
+}
+
+export interface HistoryEntry {
+  n: number;
+  at: number;
+  mode: string;
+  bet: number;
+  payout: number;
+  multiplier: number;
+  checks: Check[];
+  proof: unknown;
+  seed: unknown;
+  simId: number | null;
+  config: unknown;
+}
+
+export interface PlayOptions {
+  seed?: PlayInput<unknown>['seed'];
+  simId?: number;
+  /** false = 直接看结果（present 用 Infinity 倍速） */
+  animate?: boolean;
+}
+
+/**
+ * 参考平台。服务端是注入的：
+ *   不传      → 本地服务端，浏览器里就地建表、按权重抽行、restore 还原
+ *   传 remote → 真平台
+ * 游戏那侧看到的 Host 完全一样，一行都不用改。
+ */
+export function createPlatform<C, O>(
+  spec: GameDefinition<C, O>, server: PlatformServer<C, O> = localServer({ spec }),
+) {
+  let api: GameApi<O> | null = null;
+  const defaults = defaultsOf(spec.schema);
+
+  /* ---- 交给游戏的 store。游戏只读 ---- */
+  const cfgStore = writable<{ v: C }>({ v: defaults });
+  const viewStore = writable<ViewSettings>({
+    sound: true, volume: 1, turbo: false,
+    reducedMotion: typeof matchMedia === 'function' && matchMedia('(prefers-reduced-motion: reduce)').matches,
+    skin: 'classic', locale: 'zh-CN', autoActive: false,
+  });
+  const walletStore = writable<WalletView>({ balance: 0, currency: 'CNY', decimals: 2 });
+  const jackpotStore = writable<{ v: number | null }>({ v: null });
+
+  class Platform {
+    config = $state<C>(defaults);
+    view = $state<ViewSettings>(viewStore.get());
+    balance = $state(0);
+    startBalance = $state(0);
+    currency = $state('CNY');
+    decimals = $state(2);
+    /** 服务端强制的注额区间。远程平台一定会给，本地是 null → 默认区间 */
+    serverLimits = $state(server.limits());
+    /** 上一局的校验结论，公平性面板用 */
+    checks = $state<Check[]>([]);
+    /** 上一局的公平证 */
+    proof = $state<unknown>(null);
+    history = $state<HistoryEntry[]>([]);
+    ready0 = $state(server.kind === 'local');
+    /**
+     * 注已经发出去了，但还没开始演。
+     *
+     * 本地服务端下这只是一个微任务，真平台下是一次网络往返——玩家完全来得及在这期间
+     * 改参数，而这一局的 config 早已冻结发给了服务端。所以否决权必须从下注那一刻就生效，
+     * 不能等 game.busy（那是演出开始才置上的）。
+     */
+    placing = $state(false);
+    /** 注额，最小货币单位 */
+    bet = $state(1_000);
+    mode = $state<Mode>('manual');
+    autoRounds = $state(10);
+    autoLeft = $state(0);
+    autoActive = $state(false);
+    err = $state<string | null>(null);
+    clientSeed = $state('player-local');
+    /** 游戏交回来的状态 */
+    game = $state<GameStatus>({ phase: 'loading', busy: false, canBet: false, canSkip: false, canEditConfig: false, progress: 0 });
+    /** 本地服务端已加载的表（mode 名） */
+    tableModes = $state<string[]>([]);
+
+    readonly spec = spec;
+    readonly server = server;
+    readonly remote = server.kind === 'remote';
+    #n = 0;
+
+    issues = $derived(spec.validate(this.config));
+    ready = $derived(this.issues.length === 0);
+    paytable = $derived(spec.paytableFor(this.config));
+    tableMode = $derived.by(() => { try { return spec.modeOf(this.config); } catch { return null; } });
+    /* 服务端说了算：平台的 bet_cents % 100 === 0 是记账前提——违反了 RTP 就变成注额的函数 */
+    limits = $derived(this.serverLimits ?? DEFAULT_LIMITS);
+    canBet = $derived(this.ready0 && this.ready && !this.autoActive && !this.placing
+      && !this.game.busy && this.game.phase !== 'loading');
+    pnl = $derived(this.balance - this.startBalance);
+
+    /** 先握手：余额、种子承诺、注额区间都在服务端那边 */
+    async init(): Promise<void> {
+      try {
+        const w = await server.init();
+        this.#apply(w.balance, w.currency, w.decimals);
+        this.startBalance = w.balance;
+        this.serverLimits = server.limits();
+        this.setBet(this.bet);
+        this.ready0 = true;
+        await this.reloadTables();
+      } catch (e) {
+        this.err = `连接平台失败：${e instanceof Error ? e.message : String(e)}`;
+      }
+    }
+
+    async reloadTables(): Promise<void> {
+      if (!server.reload) return;
+      try { this.tableModes = (await server.reload()).modes; }
+      catch (e) { this.err = `加载表失败：${e instanceof Error ? e.message : String(e)}`; }
+    }
+
+    bindGame(a: GameApi<O>): void { api = a; }
+    setGameStatus(s: GameStatus): void { this.game = s; }
+
+    host(): Host<C> {
+      return {
+        config: { get: () => cfgStore.get().v, subscribe: (run) => cfgStore.subscribe((s) => run(s.v)) } as Readable<C>,
+        view: viewStore,
+        wallet: walletStore,
+        jackpot: { get: () => jackpotStore.get().v, subscribe: (run) => jackpotStore.subscribe((s) => run(s.v)) } as Readable<number | null>,
+        audio: { context: () => audioCtx(), volume: () => this.view.volume },
+        locale: 'zh-CN',
+        requestConfig: (p) => { this.requestConfig(p); },
+        emit: (e) => { if (e.type === 'error') this.err = e.message; },
+        log: (lvl, msg, data) => console[lvl === 'debug' ? 'log' : lvl](`[${spec.slug}] ${msg}`, data ?? ''),
+      };
+    }
+
+    /* ---- 配置：平台是真值源，游戏来的是申请 ---- */
+    /** 平台的否决权：局中、自动中、注已发出，一律不批。返回是否批准 */
+    requestConfig(patch: Partial<C>): boolean {
+      if (this.autoActive || this.game.busy || this.placing) return false;
+      this.config = spec.normalize(patch, this.config);
+      cfgStore.set({ v: this.config });
+      return true;
+    }
+
+    setView(patch: Partial<ViewSettings>): void {
+      this.view = { ...this.view, ...patch };
+      viewStore.set(this.view);
+    }
+
+    setBet(minor: number): boolean {
+      if (this.autoActive || this.game.busy || this.placing) return false;
+      const { min, max, step } = this.limits;
+      const raw = Math.min(max, Math.max(min, Math.round(minor) || min));
+      // 对齐到步长：真平台按 (bet/100) × payoutCenti 赔付，不整除就得四舍五入，
+      // 声明的 RTP 会在小注上不成立
+      this.bet = step > 1 ? Math.max(min, Math.floor(raw / step) * step) : raw;
+      this.err = null;
+      return true;
+    }
+
+    refill(): void {
+      const w = server.refill?.();
+      if (w) { this.#apply(w.balance, w.currency, w.decimals); this.startBalance = w.balance; this.history = []; }
+      this.err = null;
+    }
+
+    #apply(balance: number, currency = this.currency, decimals = this.decimals): void {
+      this.balance = balance; this.currency = currency; this.decimals = decimals;
+      walletStore.set({ balance, currency, decimals });
+    }
+
+    /**
+     * 一局的完整链路：服务端算钱 → 校验 → 游戏演出 → 记历史。
+     *
+     * 校验的语义由服务端实现决定：本地服务端验承诺链、抽样区间、还原一致，真平台一样。
+     * 失败处理是同一条——没通过就不演。
+     */
+    async playOne(o: PlayOptions = {}): Promise<HistoryEntry | null> {
+      if (!api || this.game.busy || this.placing || !this.ready) return null;
+
+      this.placing = true;
+      let r;
+      try {
+        const input = { config: $state.snapshot(this.config) as C, bet: this.bet, clientSeed: this.clientSeed };
+        r = (o.seed || o.simId !== undefined) && server.play
+          ? await server.play({ ...input, seed: o.seed, simId: o.simId })
+          : await server.place(input);
+      } finally {
+        this.placing = false;
+      }
+
+      if (!r.ok) {
+        this.err = r.error;
+        this.checks = [{ label: '本局未通过校验', ok: false, detail: r.error }];
+        console.error(`[${spec.slug}] 本局未通过校验`, r.error);
+        return null;
+      }
+      this.err = null;
+      this.#apply(r.round.wallet.balance);     // 余额以服务端返回值为准，不本地推算
+      this.checks = r.round.checks;
+      this.proof = r.round.proof ?? null;
+
+      /* 这个平台在本进程里持有游戏，所以服务端适配层一定拿得到 restore。
+         只递「那一行」的那条路是给 iframe 宿主走的，不该到这里 */
+      if (!r.round.result) {
+        this.err = '服务端只给了抽中的那一行，这个平台不会还原它';
+        return null;
+      }
+      const res = r.round.result;
+      const proof = r.round.proof as { simId?: number } | null;
+      const entry: HistoryEntry = {
+        n: ++this.#n, at: Date.now(), mode: r.round.row?.mode ?? this.tableMode ?? 'base',
+        bet: res.bet, payout: res.payout, multiplier: res.multiplier, checks: r.round.checks, proof: r.round.proof,
+        seed: r.round.row?.seed ?? null, simId: proof?.simId ?? null, config: $state.snapshot(this.config),
+      };
+      this.history = [entry, ...this.history].slice(0, 50);
+      await api.present(res, o.animate === false ? Infinity : undefined);
+      return entry;
+    }
+
+    async startAuto(): Promise<void> {
+      if (this.autoActive) return;
+      this.autoActive = true;
+      this.setView({ autoActive: true });
+      let left = this.autoRounds > 0 ? this.autoRounds : Infinity;
+      this.autoLeft = isFinite(left) ? left : 0;
+
+      while (this.autoActive && left > 0) {
+        /* 余额判断在平台——只有它知道钱够不够，这也是自动循环必须归平台的原因 */
+        if (this.bet > this.balance) { this.err = '余额不足，自动模式已停止'; break; }
+        if (!await this.playOne()) break;
+        left--;
+        this.autoLeft = isFinite(left) ? left : 0;
+        await sleep(this.view.turbo ? 220 : 600);
+      }
+
+      this.autoActive = false;
+      this.setView({ autoActive: false });
+      this.autoLeft = this.autoRounds;
+    }
+
+    stopAuto(): void { this.autoActive = false; }
+  }
+
+  return new Platform();
+}
+
+export type PlatformOf<C, O> = ReturnType<typeof createPlatform<C, O>>;
+
+const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
+
+let ac: AudioContext | null = null;
+const audioCtx = (): AudioContext | null => {
+  try {
+    ac = ac ?? new AudioContext();
+    if (ac.state === 'suspended') void ac.resume();
+    return ac;
+  } catch { return null; }
+};

package/dev-host/remote.ts

@@ -0,0 +1,178 @@
+/* 真平台。
+ *
+ * 和假服务端最大的不同不是「换了个 URL」，而是**对账的语义变了**：
+ * 表模型下客户端无法重算 payout——payout 来自那张公开的权重表，不来自 round()。
+ * 能验的是抽样过程没作弊：
+ *
+ *   1. 揭示的种子哈希得上一局就公布过的承诺（反向哈希链，服务端无法事后挑种子）
+ *   2. 靶点落在中奖行的累积权重区间内
+ *   3. 赔付等于 注额/100 × 表里那一行的 payoutCenti
+ *
+ * 这比「重算一遍」更强——它验的是服务端没有在抽样这一步动手脚，
+ * 而不只是「两边跑同一份代码得到同一个数」。 */
+import { GameKitError, type BetResult, winCents } from '../protocol/index.ts';
+import type { GameKitClient } from '../client/index.ts';
+import { sha256, toHex, utf8, type BetLimits, type Restore, type RestoreInput, type RngSeed } from '../sdk/index.ts';
+import type { Check, PlaceInput, PlaceResult, PlatformServer, WalletState } from './platform-server.ts';
+
+export interface RemoteOptions<C, O> {
+  client: GameKitClient;
+  gameId: string;
+  /**
+   * 抽哪张表。影响赔付分布的 config 都冻结在这里。
+   *
+   * 传函数的话每注现算——玩家改了 N，下一注就该落到另一张表上。
+   * 通常直接传游戏的 modeOf。
+   */
+  mode?: string | ((config: C) => string);
+  /**
+   * 把服务端抽中的一行还原成可演出的结果。
+   *
+   * 不传就把那一行原样交出去（Delivery.row），由宿主自己还原——
+   * 游戏跑在 iframe 里时 restore 在被隔离的那一侧，这一侧碰不到它。
+   */
+  restore?: Restore<C, O>;
+}
+
+const bytesOf = (b64: string | null): Uint8Array | null =>
+  b64 === null ? null : Uint8Array.from(atob(b64), (ch) => ch.charCodeAt(0));
+
+export function createRemotePlatform<C, O>(o: RemoteOptions<C, O>): PlatformServer<C, O> {
+  const modeFor = (config: C): string =>
+    typeof o.mode === 'function' ? o.mode(config) : o.mode ?? 'base';
+  let wallet: WalletState = { balance: 0, currency: 'USD', decimals: 2, jackpot: null };
+  let limits: BetLimits | null = null;
+  /** 下一局将要用的种子的承诺。每局用完更新成刚揭示的那个种子 */
+  let commitment = '';
+
+  /**
+   * 下注，承诺过期时刷新一次再来。
+   *
+   * 过期的典型原因是玩家在另一个标签页下了注，本地这份种子状态落后了。
+   * 这不能靠传输层重试解决——重试一个过期的承诺只会把同一个错误再犯三遍，
+   * 所以 STALE_COMMITMENT 被刻意标成不可重试，由这里重新拉状态。
+   * 被拒的那一注什么都没发生，重下是安全的。
+   */
+  const placeOnce = async (input: PlaceInput<C>, retry: boolean): Promise<BetResult> => {
+    try {
+      return await o.client.bets.place({
+        gameId: o.gameId,
+        betCents: input.bet,
+        mode: modeFor(input.config),
+        // 存进历史局：回放要用这一刻的 config 解码，牌面才和玩家当时看到的一致
+        config: input.config as Record<string, unknown>,
+        // 带上自己以为在用的承诺。对不上说明本地拿的是过期状态，服务端会直接拒
+        ...(commitment ? { expectedServerSeedHash: commitment } : {}),
+      });
+    } catch (e) {
+      if (retry && e instanceof GameKitError && e.code === 'STALE_COMMITMENT') {
+        commitment = (await o.client.seeds.current()).serverSeedHash;
+        return placeOnce(input, false);
+      }
+      throw e;
+    }
+  };
+
+  const place = async (input: PlaceInput<C>): Promise<PlaceResult<C, O>> => {
+    let bet: BetResult;
+    try {
+      bet = await placeOnce(input, true);
+    } catch (e) {
+      return { ok: false, error: e instanceof GameKitError ? e.message : String(e) };
+    }
+
+    const checks: Check[] = [];
+    const fail = (error: string): PlaceResult<C, O> => ({ ok: false, error });
+
+    // 1. 承诺链。这一条是整套可证明公平的支点
+    const revealed = toHex(sha256(utf8(bet.proof.serverSeed)));
+    const expected = commitment || bet.proof.serverSeedHash;
+    if (revealed !== expected) {
+      return fail(`公平性校验失败：揭示的种子哈希 ${revealed.slice(0, 16)}… 对不上承诺 ${expected.slice(0, 16)}…`);
+    }
+    checks.push({
+      label: '揭示的种子哈希得上一局公布的承诺',
+      ok: true,
+      detail: `sha256(种子) = ${revealed.slice(0, 16)}…`,
+    });
+
+    // 2. 靶点落在中奖行的区间内。不下载整表也能验，表只在争议时才需要下载
+    const target = BigInt(bet.proof.drawTarget);
+    const inRange = BigInt(bet.proof.cumulativeBefore) <= target
+      && target < BigInt(bet.proof.cumulativeAfter);
+    if (!inRange) {
+      return fail(`公平性校验失败：靶点 ${bet.proof.drawTarget} 不在中奖行 [${bet.proof.cumulativeBefore}, ${bet.proof.cumulativeAfter}) 内`);
+    }
+    checks.push({
+      label: '靶点落在中奖行的累积权重区间内',
+      ok: true,
+      detail: `${bet.proof.cumulativeBefore} ≤ ${bet.proof.drawTarget} < ${bet.proof.cumulativeAfter}`,
+    });
+
+    // 3. 记账自洽
+    const want = winCents(bet.betCents, bet.outcome.payoutCenti);
+    if (bet.payoutCents !== want) {
+      return fail(`记账不自洽：${bet.betCents}/100 × ${bet.outcome.payoutCenti} 应为 ${want}，服务端给了 ${bet.payoutCents}`);
+    }
+    checks.push({ label: '赔付 = 注额/100 × 表里那一行的倍数', ok: true, detail: `${want} 分` });
+
+    const seed: RngSeed = {
+      server: bet.proof.serverSeed,
+      client: bet.proof.clientSeed,
+      nonce: bet.proof.nonce,
+    };
+    const row: RestoreInput<C> = {
+      config: input.config,
+      bet: bet.betCents,
+      payoutCenti: bet.outcome.payoutCenti,
+      frames: bytesOf(bet.outcome.frames),
+      mode: modeFor(input.config),
+      seed,
+    };
+
+    /* 钱已经扣了、种子已经揭示了，平台侧的状态必须先推进——
+       后面的还原无论成败，这一注在服务端都已经发生过了 */
+    commitment = bet.proof.serverSeed;   // 揭示的种子就是下一局的承诺
+    wallet = { ...wallet, balance: bet.balanceAfterCents };
+
+    if (!o.restore) return { ok: true, round: { row, wallet, checks, proof: bet.proof } };
+
+    let result;
+    try {
+      result = o.restore(row);
+    } catch (e) {
+      return fail(`演出数据还原失败：${e instanceof Error ? e.message : String(e)}`);
+    }
+
+    /* 还原出来的 payout 必须等于平台记的账。不等就是客户端要演的东西
+       和玩家实际拿到的钱不一样——这类 bug 完全静默，最伤信任 */
+    if (result.payout !== bet.payoutCents) {
+      return fail(`还原出的赔付 ${result.payout} 与平台记账的 ${bet.payoutCents} 不符，本局不演出`);
+    }
+    checks.push({ label: '还原出的演出与平台记账一致', ok: true, detail: `${result.payout} 分` });
+
+    return { ok: true, round: { result, row, wallet, checks, proof: bet.proof } };
+  };
+
+  return {
+    kind: 'remote',
+
+    async init(): Promise<WalletState> {
+      const session = await o.client.session.bootstrap();
+      commitment = session.seeds.serverSeedHash;
+      wallet = {
+        balance: session.wallet.balanceCents,
+        currency: session.wallet.currency,
+        decimals: session.wallet.decimals,
+        jackpot: null,          // 平台没有奖池，也不打算加
+      };
+
+      const game = await o.client.games.get(o.gameId);
+      limits = { min: game.minBetCents, max: game.maxBetCents, step: game.betStepCents };
+      return wallet;
+    },
+
+    limits: () => limits,
+    place,
+  };
+}

package/dev-host/run.ts

@@ -0,0 +1,46 @@
+/* 启动参考平台。
+
+   为什么要包一层而不是让每个游戏自己 mount(DevShell, {props})：
+   Svelte 的命令式 mount() 不做泛型推断，会把 C 擦成约束上界
+   （Record<string, unknown>），于是每个游戏的 dev.ts 都得写一次强转。
+   包在这里，强转只出现一次，游戏侧的调用是类型安全的。 */
+import { mount } from 'svelte';
+import type { GameModule } from '../sdk/index.ts';
+import type { PlatformServer } from './platform-server.ts';
+import type { HistoryEntry, PlatformOf } from './platform.svelte.ts';
+import DevShell from './DevShell.svelte';
+import { ensureHostFonts } from './fonts.ts';
+import './theme.css';
+
+export interface RunOptions<C = object, O = unknown> {
+  target?: HTMLElement;
+  title?: string;
+  note?: string;
+  /**
+   * 嵌在别的页面里（studio 的预览 iframe）：不画自己的页眉和标题，余额由外面那个页面的
+   * Header 显示；机台顶到容器边上，由外面决定它多宽
+   */
+  embedded?: boolean;
+  /** 不传就是本地表模型。传 createRemotePlatform(...) 就接到真平台上 */
+  server?: PlatformServer<C, O>;
+  onSaveCase?: (h: HistoryEntry, title: string) => Promise<string>;
+  onPlatform?: (p: PlatformOf<C, O>) => void;
+}
+
+export function runDevShell<C extends object, O>(
+  game: GameModule<C, O>, o: RunOptions<C, O> = {}
+): void {
+  ensureHostFonts();
+  mount(DevShell as unknown as typeof DevShell<object, unknown>, {
+    target: o.target ?? document.body,
+    props: {
+      game: game as unknown as GameModule<object, unknown>,
+      title: o.title,
+      note: o.note,
+      embedded: o.embedded,
+      server: o.server as unknown as PlatformServer<object, unknown> | undefined,
+      onSaveCase: o.onSaveCase,
+      onPlatform: o.onPlatform as unknown as ((p: PlatformOf<object, unknown>) => void) | undefined,
+    }
+  });
+}