10.2 断言终局状态与结局

// file: web/verify_ne10.mjs
// tier: W
// verify: NODE_PATH=/opt/homebrew/lib/node_modules node web/verify_ne10.mjs
// 卷二 10.1/10.2/10.3：Playwright 无头打开 ne10.html，注入 25 步选择序列真玩，
// 逐步断言可用选项集合、终局状态与结局、两遍确定性，再批跑 20 条路径与 Python 侧对照。
// NODE_PATH 对 ESM import 无效 → 必须 createRequire；规格侧复用同一份 engine.ts。

import { createRequire } from "node:module";
import { readFileSync, mkdirSync } from "node:fs";
import { join, dirname } from "node:path";
import { fileURLToPath, pathToFileURL } from "node:url";
import { initState, applyChoice, condOk, nodeById, digest } from "../core/src/inkwell/engine.ts";

const require = createRequire(import.meta.url);
const { chromium } = require("playwright");

const HERE = dirname(fileURLToPath(import.meta.url));
const ROOT = join(HERE, "..");
const SHOTS = join(ROOT, "out/shots");
mkdirSync(SHOTS, { recursive: true });

const spec = JSON.parse(readFileSync(join(ROOT, "config/story_spec.json"), "utf8"));
const batch = JSON.parse(readFileSync(join(ROOT, "out/ne_10_3_batch_paths.json"), "utf8"));
const url = pathToFileURL(join(HERE, "dist/ne10.html")).href;

// 规格侧的可用选项集合：与页面同一份 engine.ts，故两侧集合必须相同
function specAvailable(state) {
  const n = nodeById(spec, state.node);
  return (n.choices || []).filter((c) => condOk(c.when, state)).map((c) => c.id);
}

// 规格侧的确定性策略：总是选第一个可用选项，走出一条完整序列
function specFirstPath() {
  let s = initState(spec);
  const seq = [];
  for (let i = 0; i < 64; i += 1) {
    const n = nodeById(spec, s.node);
    if (n.ending) break;
    const opts = (n.choices || []).filter((c) => condOk(c.when, s));
    if (!opts.length) break;
    seq.push(opts[0].id);
    s = applyChoice(spec, s, opts[0].id);
  }
  return seq;
}

let fail = 0;
function check(name, got, want) {
  const ok = got === want;
  if (!ok) fail += 1;
  console.log(`${ok ? "OK  " : "FAIL"} ${name}: ${got}${ok ? "" : " != " + want}`);
}

const browser = await chromium.launch();
const ctx = await browser.newContext({ viewport: { width: 820, height: 1000 } });
const page = await ctx.newPage();

// 冷启动预热页：首个 page 读像素恒为空白，先画一次 8x8 再丢弃
const warm = await ctx.newPage();
await warm.setContent('<canvas id="w" width="8" height="8"></canvas>');
await warm.evaluate(() => {
  const g = document.getElementById("w").getContext("2d");
  g.fillStyle = "#38bdf8";
  g.fillRect(0, 0, 8, 8);
});
await warm.close();

// ---- 10.1 注入选择序列真玩：逐步断言可用集合，记录每步节点与好感度 ----
const seq = specFirstPath();
check("注入序列长度", seq.length, 25);
console.log("== 10.1 注入序列逐步轨迹（节点 / 点击 / 到达 / 好感度）");
await page.goto(url);
await page.evaluate(() => window.__ne10.reset());
let sspec = initState(spec);
for (let i = 0; i < seq.length; i += 1) {
  const dom = await page.evaluate(() => ({ node: window.__ne10.node, available: window.__ne10.available }));
  const want = specAvailable(sspec);
  const same = want.length === dom.available.length && want.every((x) => dom.available.includes(x));
  if (!same) fail += 1;
  await page.click(`[data-choice-id="${seq[i]}"]`);
  sspec = applyChoice(spec, sspec, seq[i]);
  const after = await page.evaluate(() => ({ node: window.__ne10.node, aff: window.__ne10.aff }));
  const a = Object.keys(after.aff).sort().map((k) => `${k}=${after.aff[k]}`).join(" ");
  console.log(`${same ? "OK  " : "FAIL"} step ${String(i + 1).padStart(2)} ${dom.node} 可用${dom.available.length} 注入 ${seq[i]} → ${after.node} 好感度 ${a}`);
}

// ---- 10.2 断言终局状态与结局 ----
console.log("== 10.2 终局断言");
const fin = await page.evaluate(() => ({
  node: window.__ne10.node, ending: window.__ne10.ending,
  digest: window.__ne10.digest, canonical: window.__ne10.canonical,
}));
check("终局节点", fin.node, "e_lit");
check("结局", fin.ending, "灯守");
check("终局摘要（浏览器 vs 期望）", fin.digest, 4162796975);
check("终局摘要（浏览器 vs 规格侧 engine.ts）", fin.digest, digest(sspec));

await page.goto(url);
await page.evaluate(() => window.__ne10.reset());
for (const c of seq) await page.click(`[data-choice-id="${c}"]`);
const d2 = await page.evaluate(() => window.__ne10.digest);
check("两遍渲染确定性", d2, 4162796975);

const shot = await page.screenshot({ path: join(SHOTS, "ne10_final_lit.png"), fullPage: true });
console.log(`OK   截图 out/shots/ne10_final_lit.png ${shot.length} bytes`);
if (shot.length <= 0) { fail += 1; console.log("FAIL 截图为空"); }

// ---- 10.3 多路径批跑：20 条采样序列与 Python 侧对照 ----
console.log("== 10.3 多路径批跑汇总");
let pass = 0;
for (const p of batch.paths) {
  await page.goto(url);
  await page.evaluate(() => window.__ne10.reset());
  for (const c of p.seq) await page.click(`[data-choice-id="${c}"]`);
  const got = await page.evaluate(() => ({ node: window.__ne10.node, ending: window.__ne10.ending, digest: window.__ne10.digest }));
  const ok = got.node === p.node && got.ending === p.ending && got.digest === p.digest;
  if (ok) pass += 1;
  else {
    fail += 1;
    console.log(`FAIL ${p.name} 浏览器 node=${got.node} ending=${got.ending} digest=${got.digest} | py node=${p.node} ending=${p.ending} digest=${p.digest}`);
    console.log(`     重放：${JSON.stringify(p.seq)}`);
  }
  console.log(`${ok ? "OK  " : "FAIL"} ${p.name} 步 ${String(p.seq.length).padStart(2)} 终局 ${got.node} 结局 ${got.ending} 摘要 ${got.digest}`);
}
console.log(`批跑通过 ${pass}/${batch.paths.length}`);

await browser.close();
console.log(`== verify_ne10: 失败 ${fail}`);
process.exit(fail ? 1 : 0);

== 10.2 终局断言
OK   终局节点: e_lit
OK   结局: 灯守
OK   终局摘要（浏览器 vs 期望）: 4162796975
OK   终局摘要（浏览器 vs 规格侧 engine.ts）: 4162796975
OK   两遍渲染确定性: 4162796975
OK   截图 out/shots/ne10_final_lit.png 43536 bytes