gamekit777 0.1.0

package/studio/src/stats.ts

@@ -0,0 +1,134 @@
+/* probe 用的那点统计：两个赔付直方图是不是同一个分布。
+ *
+ * 用 G 检验（对数似然比）而不是 Pearson χ²：赔付分布极度长尾，
+ * 稀有档位的期望计数很小，Pearson 在那里数值不稳。桶合并之后两者渐近等价，
+ * G 在小期望上更保守一点。 */
+
+/** 上正则化不完全伽马 Q(a, x)——χ² 分布的右尾。Numerical Recipes 的 gammq */
+export function gammaQ(a: number, x: number): number {
+  if (x <= 0) return 1;
+  if (x < a + 1) return 1 - gammaPSeries(a, x);
+  return gammaQContinued(a, x);
+}
+
+function lgamma(z: number): number {
+  const c = [76.18009172947146, -86.50532032941677, 24.01409824083091,
+    -1.231739572450155, 0.1208650973866179e-2, -0.5395239384953e-5];
+  let y = z, x = z;
+  let tmp = x + 5.5;
+  tmp -= (x + 0.5) * Math.log(tmp);
+  let ser = 1.000000000190015;
+  for (const ci of c) ser += ci / ++y;
+  return -tmp + Math.log(2.5066282746310005 * ser / x);
+}
+
+function gammaPSeries(a: number, x: number): number {
+  let ap = a, sum = 1 / a, del = sum;
+  for (let n = 0; n < 500; n++) {
+    ap += 1; del *= x / ap; sum += del;
+    if (Math.abs(del) < Math.abs(sum) * 1e-14) break;
+  }
+  return sum * Math.exp(-x + a * Math.log(x) - lgamma(a));
+}
+
+function gammaQContinued(a: number, x: number): number {
+  const FPMIN = 1e-300;
+  let b = x + 1 - a, c = 1 / FPMIN, d = 1 / b, h = d;
+  for (let i = 1; i < 500; i++) {
+    const an = -i * (i - a);
+    b += 2;
+    d = an * d + b; if (Math.abs(d) < FPMIN) d = FPMIN;
+    c = b + an / c; if (Math.abs(c) < FPMIN) c = FPMIN;
+    d = 1 / d;
+    const del = d * c;
+    h *= del;
+    if (Math.abs(del - 1) < 1e-14) break;
+  }
+  return Math.exp(-x + a * Math.log(x) - lgamma(a)) * h;
+}
+
+/** χ² 右尾概率 */
+export const chiSquareTail = (stat: number, df: number): number => (df <= 0 ? 1 : gammaQ(df / 2, stat / 2));
+
+export interface HistogramTest {
+  /** G 统计量 */
+  g: number;
+  df: number;
+  p: number;
+  /** 合并桶之后，各桶标准化偏差 (o-e)/√e 的最大绝对值 */
+  maxSigma: number;
+  /** 只在一侧出现且期望计数够大的赔付——支持集就不同，不用算统计量就能判 */
+  disjoint: number[];
+  bins: number;
+}
+
+/**
+ * 两个样本是否来自同一分布（同质性检验）。
+ *
+ * 期望计数 < minExpected 的桶合并进相邻桶——否则一个只出现过两次的爆奖
+ * 就能把统计量推到天上，那不是分布不同，是样本不够。
+ */
+export function compareHistograms(
+  a: ReadonlyMap<number, number>, b: ReadonlyMap<number, number>, minExpected = 5,
+): HistogramTest {
+  const na = [...a.values()].reduce((s, v) => s + v, 0);
+  const nb = [...b.values()].reduce((s, v) => s + v, 0);
+  const n = na + nb;
+  const keys = [...new Set([...a.keys(), ...b.keys()])].sort((x, y) => x - y);
+
+  const disjoint: number[] = [];
+  for (const k of keys) {
+    const ca = a.get(k) ?? 0, cb = b.get(k) ?? 0;
+    // 一侧为零、另一侧按合并样本算期望也 ≥ minExpected：这不是抽样噪声
+    const expected = ((ca + cb) / n) * Math.min(na, nb);
+    if ((ca === 0 || cb === 0) && expected >= minExpected) disjoint.push(k);
+  }
+
+  // 按赔付排序后贪心合并，直到每桶在两侧的期望都 ≥ minExpected
+  const bins: { ca: number; cb: number }[] = [];
+  let cur = { ca: 0, cb: 0 };
+  for (const k of keys) {
+    cur.ca += a.get(k) ?? 0;
+    cur.cb += b.get(k) ?? 0;
+    const tot = cur.ca + cur.cb;
+    if ((tot / n) * na >= minExpected && (tot / n) * nb >= minExpected) { bins.push(cur); cur = { ca: 0, cb: 0 }; }
+  }
+  if (cur.ca + cur.cb > 0) {
+    if (bins.length > 0) { bins[bins.length - 1]!.ca += cur.ca; bins[bins.length - 1]!.cb += cur.cb; }
+    else bins.push(cur);
+  }
+
+  let g = 0, maxSigma = 0;
+  for (const { ca, cb } of bins) {
+    const tot = ca + cb;
+    const ea = (tot * na) / n, eb = (tot * nb) / n;
+    if (ca > 0) g += 2 * ca * Math.log(ca / ea);
+    if (cb > 0) g += 2 * cb * Math.log(cb / eb);
+    if (ea > 0) maxSigma = Math.max(maxSigma, Math.abs(ca - ea) / Math.sqrt(ea));
+    if (eb > 0) maxSigma = Math.max(maxSigma, Math.abs(cb - eb) / Math.sqrt(eb));
+  }
+  const df = Math.max(0, bins.length - 1);
+  return { g, df, p: chiSquareTail(g, df), maxSigma, disjoint, bins: bins.length };
+}
+
+export const histogram = (xs: ArrayLike<number>): Map<number, number> => {
+  const m = new Map<number, number>();
+  for (let i = 0; i < xs.length; i++) m.set(xs[i]!, (m.get(xs[i]!) ?? 0) + 1);
+  return m;
+};
+
+/** C(n, k)，BigInt */
+export function choose(n: number, k: number): bigint {
+  if (k < 0 || k > n) return 0n;
+  let r = 1n;
+  for (let i = 1; i <= k; i++) r = (r * BigInt(n - k + i)) / BigInt(i);
+  return r;
+}
+
+/** P(n, k) = n!/(n-k)!，BigInt */
+export function permutations(n: number, k: number): bigint {
+  if (k < 0 || k > n) return 0n;
+  let r = 1n;
+  for (let i = 0; i < k; i++) r *= BigInt(n - i);
+  return r;
+}

package/studio/src/studio-plugin.ts

@@ -0,0 +1,76 @@
+/* 往游戏的 vite dev server 里注入 studio：页面、预览页、API。
+ *
+ * 三者同源是刻意的。页面要 import 游戏 logic 算赔率表、跑求解；预览要 fetch 产物；
+ * 发布要用浏览器 cookie 打反代到 /v1。分开起第二个 server 这三件事全要绕。
+ *
+ * 不往游戏目录写任何文件：两个 html 从内存吐，入口用 /@fs 指回 studio 包。
+ * 为什么不直接用游戏自己的 index.html：那是给 `bun run dev` 的，指向 src/dev.ts。 */
+import type { Plugin } from 'vite';
+import { API_PREFIX, createApi } from './api.ts';
+import type { Engine } from './engine.ts';
+
+export interface StudioPluginOptions {
+  engine: Engine;
+  /** 游戏入口的绝对路径，默认导出 GameModule */
+  gameEntry: string;
+  /** studio 包根，preview/ 和 app/ 在这里 */
+  studioRoot: string;
+}
+
+export const VIRTUAL_GAME = 'virtual:studio/game';
+export const PREVIEW_PATH = '/__studio/preview.html';
+export const PAGE_PATH = '/__studio/';
+
+const page = (title: string, entry: string): string => `<!doctype html>
+<html lang="zh-CN">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
+<title>${title}</title>
+<script type="module" src="/@fs${entry}"></script>
+</head>
+<body></body>
+</html>
+`;
+
+export function studioPlugin(o: StudioPluginOptions): Plugin {
+  const previewHtml = page('GameKit Studio 预览', `${o.studioRoot}/preview/entry.ts`);
+  const appHtml = page('GameKit Studio', `${o.studioRoot}/app/main.ts`);
+  const api = createApi(o.engine);
+
+  return {
+    name: 'gamekit-studio',
+
+    resolveId(id) {
+      // 返回真实路径而不是 \0 前缀的虚拟 id：让 vite 把它当普通文件，HMR 才跟得上
+      if (id === VIRTUAL_GAME) return o.gameEntry;
+      return null;
+    },
+
+    configureServer(server) {
+      server.middlewares.use(api);
+      server.middlewares.use((req, res, next) => {
+        const path = req.url?.split('?')[0];
+        const html = path === PREVIEW_PATH ? previewHtml
+          : path === PAGE_PATH || path === '/__studio' || path === '/__studio/index.html' ? appHtml
+          : null;
+        if (!html) return next();
+        void server.transformIndexHtml(req.url!, html).then((out) => {
+          res.setHeader('Content-Type', 'text/html; charset=utf-8');
+          res.end(out);
+        }, next);
+      });
+    },
+
+    /* 规则改了要让 node 侧知道：采样缓存按指纹作废、页面收到广播。
+       预览页自己的热更新由 vite 照常处理，这里只是顺便通知 */
+    handleHotUpdate(ctx) {
+      if (ctx.file.startsWith(o.engine.game.dir) && !ctx.file.includes('/.studio/')) {
+        queueMicrotask(() => o.engine.touch());
+      }
+      return undefined;
+    },
+  };
+}
+
+export { API_PREFIX };

package/studio/src/tasks.ts

@@ -0,0 +1,52 @@
+/* 在游戏目录里跑 check / test / verify / build。
+ *
+ * 就是 `bun run <task>`，studio 不自己实现这些——游戏目录的 package.json 才是真值。
+ * 加的只有超时、输出截断和一点诊断抽取，让 AI 拿到的是结构而不是一屏日志。 */
+import { spawn } from 'node:child_process';
+
+export type TaskName = 'check' | 'test' | 'verify' | 'build';
+
+export interface TaskResult {
+  task: TaskName;
+  ok: boolean;
+  exitCode: number | null;
+  timedOut: boolean;
+  durationMs: number;
+  /** 从输出里抽出来的错误行，AI 优先看这里 */
+  issues: string[];
+  /** 完整输出（截断到 maxOutput） */
+  output: string;
+}
+
+export interface RunTaskOptions {
+  timeoutMs?: number;
+  maxOutput?: number;
+}
+
+const ISSUE = /(error|✗|Error:|FAIL|AssertionError|TS\d{4}:|✖|失败|不通过)/;
+
+export function runTask(gameDir: string, task: TaskName, o: RunTaskOptions = {}): Promise<TaskResult> {
+  const timeoutMs = o.timeoutMs ?? 300_000;
+  const maxOutput = o.maxOutput ?? 40_000;
+  const t0 = Date.now();
+
+  return new Promise((resolve) => {
+    const child = spawn('bun', ['run', task], { cwd: gameDir, stdio: ['ignore', 'pipe', 'pipe'], env: { ...process.env, FORCE_COLOR: '0', NO_COLOR: '1' } });
+    let out = '';
+    const push = (b: Buffer): void => { if (out.length < maxOutput * 2) out += b.toString(); };
+    child.stdout.on('data', push);
+    child.stderr.on('data', push);
+
+    let timedOut = false;
+    const timer = setTimeout(() => { timedOut = true; child.kill('SIGKILL'); }, timeoutMs);
+
+    child.on('close', (code) => {
+      clearTimeout(timer);
+      const clean = out.replace(/\x1b\[[0-9;]*m/g, '');
+      const lines = clean.split('\n');
+      const issues = lines.filter((l) => ISSUE.test(l)).map((l) => l.trim()).filter(Boolean).slice(0, 60);
+      const output = clean.length > maxOutput ? `${clean.slice(0, maxOutput / 2)}\n…（截断 ${clean.length - maxOutput} 字）…\n${clean.slice(-maxOutput / 2)}` : clean;
+      resolve({ task, ok: code === 0 && !timedOut, exitCode: code, timedOut, durationMs: Date.now() - t0, issues, output });
+    });
+  });
+}

package/studio/src/worker/pool.ts

@@ -0,0 +1,84 @@
+/* 主进程侧：一池 worker，每个都加载了同一份游戏代码。
+ *
+ * 池按规则指纹存活：指纹一变整池换掉。这是「主进程不持有游戏代码」的另一半——
+ * 主进程只认识指纹和纯数据，游戏代码活在哪一批 worker 里由指纹决定。 */
+import { Worker } from 'node:worker_threads';
+import { availableParallelism } from 'node:os';
+import { pathToFileURL } from 'node:url';
+
+interface Pending { resolve: (v: unknown) => void; reject: (e: Error) => void }
+
+const RPC = new URL('./rpc.ts', import.meta.url);
+
+export class WorkerPool {
+  #workers: Worker[] = [];
+  #pending = new Map<number, Pending>();
+  #next = 0;
+  #rr = 0;
+  #ready: Promise<void>;
+  readonly size: number;
+
+  constructor(o: { specPath: string; size?: number }) {
+    this.size = o.size ?? Math.max(1, Math.min(8, availableParallelism() - 1));
+    const workerData = { specUrl: pathToFileURL(o.specPath).href };
+    const readies: Promise<void>[] = [];
+    for (let i = 0; i < this.size; i++) {
+      const w = new Worker(RPC, { workerData });
+      readies.push(new Promise<void>((resolve, reject) => {
+        const onReady = (m: { id: number; ok: boolean; result?: unknown; error?: string }): void => {
+          if (m.id !== -1) return;
+          w.off('message', onReady);
+          resolve();
+        };
+        w.on('message', onReady);
+        w.once('error', reject);
+      }));
+      w.on('message', (m: { id: number; ok: boolean; result?: unknown; error?: string }) => {
+        if (m.id === -1) return;
+        const p = this.#pending.get(m.id);
+        if (!p) return;
+        this.#pending.delete(m.id);
+        if (m.ok) p.resolve(m.result);
+        else p.reject(new Error(m.error));
+      });
+      w.on('error', (e: unknown) => {
+        // 一个 worker 崩了，挂在它上面的调用全部失败，别让它们悬着
+        const err = e instanceof Error ? e : new Error(String(e));
+        for (const [id, p] of this.#pending) { p.reject(err); this.#pending.delete(id); }
+      });
+      this.#workers.push(w);
+    }
+    this.#ready = Promise.all(readies).then(() => undefined);
+  }
+
+  ready(): Promise<void> { return this.#ready; }
+
+  /** 轮转派发。任务都是纯计算，谁接都一样 */
+  call<T>(task: string, args: unknown, worker?: number): Promise<T> {
+    const w = this.#workers[worker ?? (this.#rr++ % this.#workers.length)]!;
+    const id = this.#next++;
+    return new Promise<T>((resolve, reject) => {
+      this.#pending.set(id, { resolve: resolve as (v: unknown) => void, reject });
+      w.postMessage({ id, task, args });
+    });
+  }
+
+  /** 把 [0, n) 切给所有 worker 并行跑，按序拼回 */
+  async spread<T>(n: number, run: (worker: number, from: number, to: number) => Promise<T>): Promise<T[]> {
+    const k = Math.min(this.size, Math.max(1, Math.ceil(n / 2_000)));
+    const per = Math.ceil(n / k);
+    const jobs: Promise<T>[] = [];
+    for (let i = 0; i < k; i++) {
+      const from = i * per;
+      const to = Math.min(n, from + per);
+      if (to > from) jobs.push(run(i, from, to));
+    }
+    return Promise.all(jobs);
+  }
+
+  async dispose(): Promise<void> {
+    await Promise.all(this.#workers.map((w) => w.terminate()));
+    this.#workers = [];
+    for (const [id, p] of this.#pending) { p.reject(new Error('worker 池已关闭')); this.#pending.delete(id); }
+  }
+}

package/studio/src/worker/rpc.ts

@@ -0,0 +1,178 @@
+/* 工作线程侧：加载游戏清单，按名字执行任务。
+ *
+ * 为什么所有游戏代码都在这里跑而不在主进程：bun 的 import() 缓存不认 query，
+ * 改了规则再 import 拿到的还是旧模块。worker 每个都有独立的模块缓存，
+ * 换一批 worker 就是换一份代码——这比任何破缓存的花招都可靠。
+ * 顺带把「平台的模块图里不能有游戏代码」这条不变式在 studio 里也守住了。 */
+import { parentPort, workerData } from 'node:worker_threads';
+import { sampleSeed, type GameDefinition, type RngSeed } from 'gamekit777/sdk';
+import type { Segment } from 'gamekit777/weights';
+import { type BuiltTable, type SampleBatch, buildTable, checkBetLinearity, sampleRange } from 'gamekit777/publish';
+
+type Config = Record<string, unknown>;
+type AnySpec = GameDefinition<Config, unknown>;
+
+interface Boot { specUrl: string }
+interface Call { id: number; task: string; args: unknown }
+
+const boot = workerData as Boot;
+const spec = ((await import(boot.specUrl)) as { default?: AnySpec }).default;
+if (!spec || typeof spec.normalize !== 'function' || typeof spec.round !== 'function' || !Array.isArray(spec.modes)) {
+  throw new Error('game.ts 的默认导出要是 defineGame({...}) 的返回值');
+}
+
+/**
+ * 给任意一份配置采样：借清单的 round / seedPrefix，只把 mode 换成这一份配置。
+ * probe 要逐字段换值采样，那些配置多半不对应任何 mode，所以不能走 spec.configOf。
+ * book 设成 'none'：probe 只看赔付分布，不用编演出。
+ */
+const specFor = (config: Config, name: string, seedPrefix: string): AnySpec => ({
+  ...spec, seedPrefix, book: 'none',
+  modes: [{ name, config }], modeKeys: Object.keys(config),
+  configOf: () => spec.normalize(config),
+  modeOf: () => name,
+});
+
+const bookKind = (): 'none' | 'seed' | 'custom' => (spec.book === 'none' ? 'none' : spec.book === 'seed' ? 'seed' : 'custom');
+
+const pack = (batch: SampleBatch): { payoutCenti: Int32Array; data: Uint8Array; offsets: Int32Array; draws: number } => {
+  let total = 0;
+  for (const b of batch.books) total += b.length;
+  const data = new Uint8Array(total);
+  const offsets = new Int32Array(batch.books.length + 1);
+  let at = 0;
+  for (let i = 0; i < batch.books.length; i++) { data.set(batch.books[i]!, at); at += batch.books[i]!.length; offsets[i + 1] = at; }
+  return { payoutCenti: batch.payoutCenti, data, offsets, draws: batch.draws };
+};
+
+const modeAt = (i: number): AnySpec['modes'][number] => {
+  const m = spec.modes[i];
+  if (!m) throw new Error(`没有第 ${i} 个 mode（共 ${spec.modes.length} 个）`);
+  return m;
+};
+
+const tasks: Record<string, (args: never) => unknown | Promise<unknown>> = {
+  /** 纯数据快照。主进程只认识这个，不认识清单本身 */
+  snapshot: () => ({
+    schema: spec.schema,
+    spec: {
+      slug: spec.slug, title: spec.title, description: spec.description,
+      autoplay: spec.autoplay, rtp: spec.rtp, sims: spec.sims, seedPrefix: spec.seedPrefix,
+      book: bookKind(),
+      modes: spec.modes.map((m) => ({ name: m.name, config: m.config })),
+      modeKeys: spec.modeKeys,
+    },
+  }),
+
+  normalize: (a: { config: Partial<Config>; prev?: Config }) => {
+    const config = spec.normalize(a.config, a.prev);
+    let mode: string | null;
+    try { mode = spec.modeOf(config); } catch { mode = null; }
+    return { config, issues: spec.validate(config), mode };
+  },
+
+  paytable: (a: { config: Config }) => spec.paytableFor(spec.normalize(a.config)),
+
+  modeOf: (a: { configs: Config[] }) => a.configs.map((c) => { try { return spec.modeOf(c); } catch { return null; } }),
+
+  /**
+   * purity=true 时照抄 scripts/verify.ts 的手法：把 Math.random 和 crypto 换成会抛的假实现。
+   * 每次跑 case 都顺带验一遍「rules/ 没偷用随机源」，这是白捡的保障。
+   */
+  round: (a: { config: Config; bet: number; seed: RngSeed; purity?: boolean }) => {
+    if (!a.purity) return spec.round(a);
+    const realRandom = Math.random;
+    const realCrypto = globalThis.crypto;
+    const boom = (who: string) => (): never => { throw new Error(`round() 调用了 ${who}`); };
+    Math.random = boom('Math.random') as typeof Math.random;
+    Object.defineProperty(globalThis, 'crypto', { configurable: true, get: boom('crypto') });
+    try {
+      return spec.round(a);
+    } finally {
+      Math.random = realRandom;
+      Object.defineProperty(globalThis, 'crypto', { configurable: true, value: realCrypto, writable: true });
+    }
+  },
+
+  /**
+   * 表模型的一条往返：按清单重建第 simId 局 → 编 book → restore 还原。
+   * case 库验表模型走这条，不需要先建好表——(seedPrefix, mode, simId) 确定性派生就能重建那一行。
+   */
+  tableRoundtrip: (a: { modeIndex: number; simId: number; config: Config; bet: number }) => {
+    const mode = modeAt(a.modeIndex);
+    const batch = sampleRange(spec, a.modeIndex, a.simId, a.simId + 1);
+    const payoutCenti = batch.payoutCenti[0]!;
+    const frames = batch.books[0] ?? null;
+    const seed = sampleSeed(spec.seedPrefix, mode.name, a.simId);
+    const restored = spec.restore({ config: a.config, bet: a.bet, payoutCenti, frames, mode: mode.name, seed });
+    return { payoutCenti, frames, seed, restored };
+  },
+
+  /**
+   * 用主进程并行采好的 batch 建表。buildTable 要清单本身（算 declaredTiers、验注额线性），
+   * 所以在 worker 里跑；采样那一步慢，由主进程切给全部 worker，这里只吃现成的。
+   */
+  buildFromBatch: async (a: {
+    modeIndex: number; payoutCenti: Int32Array; data: Uint8Array; offsets: Int32Array; draws: number;
+    declaredRtpPpm?: number; segments?: Segment[];
+  }): Promise<BuiltTable> => {
+    modeAt(a.modeIndex);
+    const books: Uint8Array[] = [];
+    for (let i = 0; i + 1 < a.offsets.length; i++) books.push(a.data.subarray(a.offsets[i]!, a.offsets[i + 1]!));
+    const batch: SampleBatch = { payoutCenti: a.payoutCenti, books, draws: a.draws };
+    return buildTable({ ...spec, sims: a.payoutCenti.length }, a.modeIndex, {
+      sampler: () => batch, declaredRtpPpm: a.declaredRtpPpm, segments: a.segments,
+    });
+  },
+
+  restore: (a: { config: Config; bet: number; payoutCenti: number; frames: Uint8Array | null; mode: string; seed: RngSeed }) => spec.restore(a),
+
+  /**
+   * 对给定 config 采样 [from, to)。走 publish 的 sampleRange，
+   * 白嫖它的 payout 整数性 / 上限校验——那些正是「能不能打表」的硬门槛。
+   */
+  sample: (a: { config: Config; name: string; seedPrefix: string; from: number; to: number }) => {
+    const batch = sampleRange(specFor(a.config, a.name, a.seedPrefix), 0, a.from, a.to);
+    return { payoutCenti: batch.payoutCenti, draws: batch.draws };
+  },
+
+  /** 用清单里的 mode 采样，含 book 编码 */
+  sampleSpec: (a: { modeIndex: number; from: number; to: number }) => {
+    modeAt(a.modeIndex);
+    return pack(sampleRange(spec, a.modeIndex, a.from, a.to));
+  },
+
+  /** 成对种子：两个 config 在同一批种子下，赔付变了多少局 */
+  pairedDiff: (a: { configA: Config; configB: Config; seedPrefix: string; count: number }) => {
+    const ca = spec.normalize(a.configA);
+    const cb = spec.normalize(a.configB);
+    let changed = 0;
+    for (let i = 0; i < a.count; i++) {
+      const seed = sampleSeed(a.seedPrefix, 'pair', i);
+      const pa = spec.round({ config: ca, bet: 100, seed }).payout;
+      const pb = spec.round({ config: cb, bet: 100, seed }).payout;
+      if (pa !== pb) changed++;
+    }
+    return { changed, count: a.count };
+  },
+
+  betLinearity: (a: { config: Config; seedPrefix: string; indices: number[] }) => {
+    checkBetLinearity(specFor(a.config, 'lin', a.seedPrefix), 0, a.indices);
+    return { ok: true };
+  },
+};
+
+parentPort!.on('message', (m: Call) => {
+  void (async () => {
+    try {
+      const fn = tasks[m.task];
+      if (!fn) throw new Error(`worker 不认识任务 ${m.task}`);
+      const result = await fn(m.args as never);
+      parentPort!.postMessage({ id: m.id, ok: true, result });
+    } catch (e) {
+      parentPort!.postMessage({ id: m.id, ok: false, error: e instanceof Error ? e.message : String(e) });
+    }
+  })();
+});
+
+parentPort!.postMessage({ id: -1, ok: true, result: 'ready' });