前言：本书的读法与贯穿项目《合成小岛》

pebble/
  config/    # 唯一真源：economy.json / ch00_budget.json / ch00_schema.json …
  sim/       # Python：读 config 跑数值仿真，产出 JSON + CSV + SVG
  core/      # TypeScript：读 config 跑逻辑内核，node --test 断言
  web/       # 单文件 HTML：把 core/ 内联成浏览器可玩原型

// file: core/src/ch00_two_hosts.ts
// tier: P
// verify: node core/src/ch00_two_hosts.ts
//
// 一份逻辑，两种宿主：同一段 runFrames() 分别跑在 mock 宿主与注入的平台宿主上，
// 逻辑内核只依赖 Host 抽象，不直接碰 window / wx / tt / my。
// 约束：只用可擦除语法（禁 enum / namespace / 参数属性 / 装饰器）。

export interface Host {
  now(): number;
  storageGet(key: string): string | null;
  storageSet(key: string, value: string): void;
}

export interface Frame {
  readonly tickIndex: number;
  readonly tMs: number;
  readonly dtMs: number;
}

/** 逻辑内核：只读 Host，不关心宿主是真机还是 mock。 */
export function runFrames(host: Host, frames: number, dtMs: number): Frame[] {
  const out: Frame[] = [];
  let last = host.now();
  for (let i = 0; i < frames; i += 1) {
    const t = host.now();
    out.push({ tickIndex: i, tMs: t, dtMs: t - last });
    last = t;
  }
  void dtMs;
  return out;
}

/** mock 宿主：确定性时钟，每次 now() 前进固定步长，供单测与仿真使用。 */
export function mockHost(stepMs: number): Host {
  let t = 0;
  const store = new Map<string, string>();
  return {
    now: () => {
      t += stepMs;
      return t;
    },
    storageGet: (k) => store.get(k) ?? null,
    storageSet: (k, v) => {
      store.set(k, v);
    },
  };
}

/** 平台宿主：把任意平台对象（wx / tt / my / 浏览器）适配成 Host。 */
export function platformHost(platform: {
  now(): number;
  getItem(k: string): string | null;
  setItem(k: string, v: string): void;
}): Host {
  return {
    now: () => platform.now(),
    storageGet: (k) => platform.getItem(k),
    storageSet: (k, v) => platform.setItem(k, v),
  };
}

/** 演示用的内存平台对象：模拟一个真实宿主的外部时钟。 */
export function fakePlatform(stepMs: number) {
  let t = 0;
  const store = new Map<string, string>();
  return {
    now: () => {
      t += stepMs;
      return t;
    },
    getItem: (k: string) => store.get(k) ?? null,
    setItem: (k: string, v: string) => {
      store.set(k, v);
    },
  };
}

function main(): void {
  const FRAMES = 8;
  const STEP = 16;

  const mock = mockHost(STEP);
  const device = platformHost(fakePlatform(STEP));

  const a = runFrames(mock, FRAMES, STEP);
  const b = runFrames(device, FRAMES, STEP);

  mock.storageSet("save", "island-1");
  device.storageSet("save", "island-1");

  const idxEqual = a.every((f, i) => f.tickIndex === b[i].tickIndex && f.dtMs === b[i].dtMs);
  const saveEqual = mock.storageGet("save") === device.storageGet("save");

  const report = {
    frames: FRAMES,
    stepMs: STEP,
    mockTicks: a.map((f) => f.tickIndex),
    deviceTicks: b.map((f) => f.tickIndex),
    mockDt: a[0].dtMs,
    deviceDt: b[0].dtMs,
    idxEqual,
    saveEqual,
  };
  console.log(JSON.stringify(report, null, 2));
  if (!idxEqual || !saveEqual) throw new Error("两种宿主结果不一致");
  console.log("OK 一份逻辑两种宿主：逐帧一致");
}

main();

{
  "frames": 8,
  "stepMs": 16,
  "mockTicks": [0, 1, 2, 3, 4, 5, 6, 7],
  "deviceTicks": [0, 1, 2, 3, 4, 5, 6, 7],
  "mockDt": 16,
  "deviceDt": 16,
  "idxEqual": true,
  "saveEqual": true
}
OK 一份逻辑两种宿主：逐帧一致

# file:   → 还原路径（相对 pebble/）。带 file: 的块一定是完整可运行文件。
# tier:   → S | P | W | D | X | B，缺省即报错。
# verify: → S / P / W / B 块必填，就是把它跑起来的那条命令。

# snippet: 跟着跑的三步
# 1) 环境自检（S 层，确认 python3.14 + numpy/pandas 与 node 26 都在）
/opt/homebrew/bin/python3 sim/ch00_env_check.py

# 2) 跑 S 层仿真，产出 JSON + CSV + SVG 到 out/
/opt/homebrew/bin/python3 sim/ch00_constraint_budget.py --config config/ --out out/

# 3) 跑 P 层内核断言
node --test 'core/test/*.test.ts'