import fs from "node:fs/promises";
import http from "node:http";
import path from "node:path";
import { randomUUID } from "node:crypto";
import puppeteer from "puppeteer-core";
import { PNG } from "pngjs";

const REPO_ROOT = path.resolve("/home/meswork/cnc_wams");
const QA_ROOT = path.join(REPO_ROOT, "qa/web-rtcp-5axis-site-test");
const OUTPUT_DIR = path.join(QA_ROOT, "output");
const EVIDENCE_SCOPE = "working7-full-functional-evidence";
const SCREENSHOT_DIR = path.join(OUTPUT_DIR, EVIDENCE_SCOPE);
const CHROME_PATH = process.env.CHROME_PATH || process.env.CHROMIUM || "/usr/bin/google-chrome";
const TARGET_URL = process.env.TARGET_URL || "";
const APP_URL = process.env.APP_URL || "/web-rtcp-5axis-sim-plan/app/index.html";
const JOB_ID = process.env.JOB_ID || `w7full-${new Date().toISOString().replace(/[-:.TZ]/g, "").slice(0, 14)}-${randomUUID().slice(0, 8)}`;
const REPORT_ID = process.env.REPORT_ID || `report-${JOB_ID}`;
const REPORT_BASENAME = `${EVIDENCE_SCOPE}-report`;
const WAIT_FAST = 50;

await fs.mkdir(OUTPUT_DIR, { recursive: true });
await fs.rm(SCREENSHOT_DIR, { recursive: true, force: true });
await fs.mkdir(SCREENSHOT_DIR, { recursive: true });

let server = null;
let targetUrl = TARGET_URL;
if (!targetUrl) {
  server = createStaticServer(REPO_ROOT);
  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
  const address = server.address();
  if (!address || typeof address === "string") throw new Error("failed to start static server");
  targetUrl = `http://127.0.0.1:${address.port}${APP_URL}`;
}

const browser = await puppeteer.launch({
  headless: true,
  executablePath: CHROME_PATH,
  defaultViewport: { width: 1600, height: 1150, deviceScaleFactor: 1 },
  ignoreHTTPSErrors: true,
  args: [
    "--ignore-certificate-errors",
    "--disable-gpu",
    "--enable-webgl",
    "--use-angle=swiftshader",
    "--enable-unsafe-swiftshader",
    "--no-sandbox",
  ],
});

const page = await browser.newPage();
const consoleErrors = [];
const pageErrors = [];
const networkErrors = [];
page.on("console", (msg) => {
  if (msg.type() === "error") consoleErrors.push(msg.text());
});
page.on("pageerror", (error) => pageErrors.push(error.message));
page.on("response", (response) => {
  if (response.status() >= 400) {
    networkErrors.push(`${response.status()} ${response.url()}`);
  }
});

const report = {
  jobId: JOB_ID,
  reportId: REPORT_ID,
  evidenceScope: EVIDENCE_SCOPE,
  generatedAt: new Date().toISOString(),
  targetUrl,
  chromePath: CHROME_PATH,
  screenshotsDir: SCREENSHOT_DIR,
  steps: [],
  buttonInventory: [],
  actionResults: [],
  checks: [],
  consoleErrors,
  pageErrors,
  networkErrors,
};

try {
  await page.goto(targetUrl, { waitUntil: "networkidle2", timeout: 60000 });
  await page.waitForSelector('[data-shell="gmoccapy-5axis"]', { timeout: 15000 });
  await page.waitForFunction(() => Boolean(window.webRtcp5AxisSimulation?.getState), { timeout: 15000 });
  await page.waitForFunction(() => document.querySelector("[data-five-axis-canvas]")?.dataset?.threeReady === "true", { timeout: 25000 });
  await windowReady();

  report.buttonInventory.push(...await collectButtonInventory());
  await captureStep("01-loaded-inventory", "我打开主界面并记录按钮库存", "我确认主界面九大区域、所有 data-action 控件、canvas 和运行时 API 已经加载。");

  await verifyInitialBlockedGates();
  await verifySidebarAndModeButtons();
  await verifyProfileAndPreviewButtons();
  await verifyProgramSourceOpenReloadAndRunControls();
  await verifyManualJogMdiOverridesSpindleCoolantAndSession();
  await verifyDiagnosticsAndNativeHalEntryPoints();

  addFinalChecks();
  report.status = report.checks.every((check) => check.pass) &&
    report.actionResults.every((action) => action.status === "PASS") &&
    pageErrors.length === 0
    ? "PASS"
    : "FAIL";

  const jsonPath = path.join(OUTPUT_DIR, `${REPORT_BASENAME}.json`);
  const pdfPath = path.join(OUTPUT_DIR, `${REPORT_BASENAME}.pdf`);
  const markdownPath = path.join(OUTPUT_DIR, `${REPORT_BASENAME}.md`);
  report.jsonPath = jsonPath;
  report.pdfPath = pdfPath;
  report.markdownPath = markdownPath;
  await fs.writeFile(jsonPath, `${JSON.stringify(report, null, 2)}\n`, "utf8");
  await writeMarkdownReport(markdownPath, report);
  await writePdfReport(pdfPath, report);

  console.log(`working7_full_functional_status=${report.status}`);
  console.log(`working7_full_functional_job_id=${report.jobId}`);
  console.log(`working7_full_functional_report_id=${report.reportId}`);
  console.log(`working7_full_functional_json=${jsonPath}`);
  console.log(`working7_full_functional_pdf=${pdfPath}`);
  console.log(`working7_full_functional_md=${markdownPath}`);
  console.log(`working7_full_functional_screenshots=${SCREENSHOT_DIR}`);
  if (report.status !== "PASS") process.exitCode = 1;
} finally {
  await page.close().catch(() => {});
  await browser.close().catch(() => {});
  if (server) await new Promise((resolve) => server.close(resolve));
}

async function verifyInitialBlockedGates() {
  await recordClick("RUN", "未上电直接 RUN 应被门禁拦截", async () => {
    const before = await getState();
    await click("RUN");
    await waitForState((state) => /machine must be on|blocked/i.test(state.operatorMessage || ""), 5000, "RUN blocked while power off");
    const after = await getState();
    return check("RUN gate blocks when power is off", after.runState === before.runState && /machine must be on/i.test(after.operatorMessage), JSON.stringify({ before: summarizeState(before), after: summarizeState(after) }));
  });
  await captureStep("02-initial-run-blocked", "我验证未上电 RUN 门禁", "未上电时 RUN 不会进入执行状态，页面给出 machine must be on 门禁原因。");

  await recordClick("mode-auto", "未上电 AUTO 应被门禁拦截", async () => {
    const dom = await getDomEvidence();
    return check("AUTO gate blocks when power is off", dom.buttons["mode-auto"]?.disabled === true && /machine must be on before AUTO/i.test(dom.buttons["mode-auto"]?.title || ""), JSON.stringify(dom.buttons["mode-auto"]));
  });
  await recordClick("mode-mdi", "未上电 MDI 应被门禁拦截", async () => {
    const dom = await getDomEvidence();
    return check("MDI gate blocks when power is off", dom.buttons["mode-mdi"]?.disabled === true && /machine must be on before MDI/i.test(dom.buttons["mode-mdi"]?.title || ""), JSON.stringify(dom.buttons["mode-mdi"]));
  });
  await recordClick("spindle-forward", "未上电主轴正转应被门禁拦截", async () => {
    const state = await getState();
    const dom = await getDomEvidence();
    return check("Spindle gate blocks when power is off", dom.buttons["spindle-forward"]?.disabled === true && /spindle blocked: machine must be on/i.test(dom.buttons["spindle-forward"]?.title || "") && state.spindle.direction === "stop", JSON.stringify({ state: summarizeState(state), button: dom.buttons["spindle-forward"] }));
  });
  await recordClick("toggle-mist", "未上电冷却应被门禁拦截", async () => {
    const state = await getState();
    const dom = await getDomEvidence();
    return check("Coolant gate blocks when power is off", dom.buttons["toggle-mist"]?.disabled === true && /coolant blocked: machine must be on/i.test(dom.buttons["toggle-mist"]?.title || "") && state.coolant.mist === false, JSON.stringify({ state: summarizeState(state), button: dom.buttons["toggle-mist"] }));
  });
}

async function verifySidebarAndModeButtons() {
  await recordClick("power", "POWER 上电", async () => {
    await click("power");
    const state = await waitForState((nextState) => nextState.machine.powerOn === true && nextState.machine.taskState === "on", 10000, "power on");
    return check("POWER sets task state ON", state.machine.powerOn === true && state.machine.taskState === "on", JSON.stringify(summarizeState(state)));
  });
  await recordClick("HOME", "HOME 回零", async () => {
    await click("HOME");
    const state = await waitForState((nextState) => nextState.machine.allHomed === true && nextState.machine.mode === "manual", 12000, "home");
    return check("HOME sets allHomed and keeps MANUAL", state.machine.allHomed === true && state.machine.mode === "manual", JSON.stringify(summarizeState(state)));
  });
  await captureStep("03-powered-homed", "我完成上电和回零", "POWER 和 HOME 后，机床处于 on/manual/allHomed 状态，DRO 与轴值保持可读。");

  await recordClick("mode-auto", "AUTO 模式", async () => {
    await click("mode-auto");
    const state = await waitForState((nextState) => nextState.machine.mode === "auto" && nextState.machine.powerOn === true, 10000, "auto");
    const dom = await getDomEvidence();
    return check("AUTO active and MANUAL inactive", state.machine.mode === "auto" && dom.buttons["mode-auto"]?.active === "true" && dom.buttons["mode-manual"]?.active === "false", JSON.stringify({ state: summarizeState(state), buttons: dom.buttons }));
  });
  await captureStep("04-auto-right-panel", "我验证右侧 AUTO 按钮", "右侧 AUTO 变为 active，MANUAL 变为 inactive，power/home 状态未丢失。");

  await recordClick("mode-manual", "MANUAL 模式", async () => {
    await click("mode-manual");
    const state = await waitForState((nextState) => nextState.machine.mode === "manual", 10000, "manual");
    const dom = await getDomEvidence();
    return check("MANUAL active and AUTO inactive", state.machine.mode === "manual" && dom.buttons["mode-manual"]?.active === "true" && dom.buttons["mode-auto"]?.active === "false", JSON.stringify({ state: summarizeState(state), buttons: dom.buttons }));
  });
  await recordClick("mode-jog", "JOG 入口归入 MANUAL 点动页", async () => {
    await click("mode-jog");
    const state = await waitForState((nextState) => nextState.machine.mode === "manual", 10000, "jog/manual");
    const dom = await getDomEvidence();
    return check("JOG button keeps manual jog page active", state.machine.mode === "manual" && dom.buttons["mode-jog"]?.active === "true", JSON.stringify({ state: summarizeState(state), buttons: dom.buttons["mode-jog"] }));
  });
  await recordClick("mode-mdi", "MDI 模式", async () => {
    await click("mode-mdi");
    const state = await waitForState((nextState) => nextState.machine.mode === "mdi", 10000, "mdi");
    const dom = await getDomEvidence();
    return check("MDI active", state.machine.mode === "mdi" && dom.buttons["mode-mdi"]?.active === "true", JSON.stringify({ state: summarizeState(state), buttons: dom.buttons["mode-mdi"] }));
  });
  await recordClick("mode-manual", "返回 MANUAL", async () => {
    await click("mode-manual");
    const state = await waitForState((nextState) => nextState.machine.mode === "manual", 10000, "manual");
    return check("Back to MANUAL", state.machine.mode === "manual", JSON.stringify(summarizeState(state)));
  });

  await recordClick("kins-tcp", "右侧 TCP 打开 RTCP", async () => {
    await click("kins-tcp");
    const state = await waitForState((nextState) => nextState.kinsType.startsWith("tcp-") && nextState.rtcpState === "on", 10000, "tcp kins");
    const canvas = await getCanvasDataset();
    return check("TCP kinematics enables RTCP", canvas.threeRtcpState === "on" && state.rtcpState === "on", JSON.stringify({ state: summarizeState(state), canvas }));
  });
  await recordClick("kins-identity", "右侧 IDENTITY 关闭 RTCP", async () => {
    await click("kins-identity");
    const state = await waitForState((nextState) => nextState.kinsType === "identity" && nextState.rtcpState === "off", 10000, "identity kins");
    const canvas = await getCanvasDataset();
    return check("IDENTITY disables RTCP", canvas.threeRtcpState === "off" && state.rtcpState === "off", JSON.stringify({ state: summarizeState(state), canvas }));
  });
  await captureStep("05-right-sidebar-all-states", "我验证右侧全班按钮", "右侧 E-STOP/POWER/RESET/AUTO/MANUAL/JOG/MDI/IDENTITY/TCP 的状态和门禁均已实际点击验证。");

  await recordClick("estop", "E-STOP 急停", async () => {
    await click("estop");
    const state = await waitForState((nextState) => nextState.machine.estopActive === true && nextState.machine.powerOn === false, 10000, "estop");
    return check("E-STOP drops power/spindle/coolant", state.machine.estopActive && !state.machine.powerOn && !state.spindle.enabled && !state.coolant.flood && !state.coolant.mist, JSON.stringify(summarizeState(state)));
  });
  await recordClick("power", "急停后 POWER 被阻止", async () => {
    await click("power");
    const state = await waitForState((nextState) => /reset estop first/i.test(nextState.operatorMessage || ""), 5000, "power blocked by estop");
    return check("POWER is blocked until RESET after E-STOP", state.machine.estopActive === true && state.machine.powerOn === false, JSON.stringify(summarizeState(state)));
  });
  await recordClick("reset", "RESET 清除急停", async () => {
    await click("reset");
    const state = await waitForState((nextState) => nextState.machine.estopActive === false && nextState.machine.powerOn === false, 10000, "reset");
    return check("RESET clears estop and leaves power off", !state.machine.estopActive && !state.machine.powerOn, JSON.stringify(summarizeState(state)));
  });
  await recordClick("power", "RESET 后重新上电", async () => {
    await click("power");
    const state = await waitForState((nextState) => nextState.machine.powerOn === true, 10000, "power on after reset");
    return check("POWER works after RESET", state.machine.powerOn === true, JSON.stringify(summarizeState(state)));
  });
  await recordClick("HOME", "RESET 后重新回零", async () => {
    await click("HOME");
    const state = await waitForState((nextState) => nextState.machine.allHomed === true, 10000, "home after reset");
    return check("HOME works after RESET", state.machine.allHomed === true, JSON.stringify(summarizeState(state)));
  });
}

async function verifyProfileAndPreviewButtons() {
  await selectProfile("xyzbc-trt", "切换到 xyzbc-trt 轮廓");
  await captureStep("06-profile-xyzbc", "我验证 Profile 下拉切换", "切换到 xyzbc-trt 后，INI、运动学和机床文件 staging 会重新加载到对应 profile。");
  await selectProfile("gmoccapy-xyzab", "切换到 reference-only gmoccapy-xyzab");
  await recordClick("kins-tcp", "reference-only profile 的 TCP 禁用", async () => {
    const domBefore = await getDomEvidence();
    await click("kins-tcp");
    await wait(WAIT_FAST);
    const state = await getState();
    const domAfter = await getDomEvidence();
    return check("TCP stays disabled for reference-only profile", domBefore.buttons["kins-tcp"]?.disabled === true && domAfter.buttons["kins-tcp"]?.disabled === true && state.rtcpState === "off", JSON.stringify({ before: domBefore.buttons["kins-tcp"], after: domAfter.buttons["kins-tcp"], state: summarizeState(state) }));
  });
  await selectProfile("xyzac-trt", "切回 xyzac-trt 轮廓");
  await waitForState((state) => state.iniConfigReadiness?.ready === true && state.machineFileStaging?.status === "staged", 20000, "xyzac restored");

  for (const [action, view] of [["view-x", "x"], ["view-y", "y"], ["view-z", "z"]]) {
    await recordClick(action, `预览 ${view.toUpperCase()} 视图`, async () => {
      await click(action);
      const state = await waitForState((nextState) => nextState.preview.selectedView === view, 5000, `${view} view`);
      const canvas = await getCanvasDataset();
      return check(`${view.toUpperCase()} view updates canvas dataset`, canvas.threeSelectedView === view && state.preview.selectedView === view, JSON.stringify({ state: summarizeState(state), canvas }));
    });
  }
  await recordClick("reset-view", "预览 Fit/复位视图", async () => {
    await click("reset-view");
    const state = await waitForState((nextState) => nextState.preview.selectedView === "iso", 5000, "reset view");
    const canvas = await getCanvasDataset();
    return check("Reset view returns to iso", canvas.threeSelectedView === "iso" && state.preview.selectedView === "iso", JSON.stringify({ state: summarizeState(state), canvas }));
  });
  await recordClick("clear-preview", "清除刀路预览", async () => {
    await click("clear-preview");
    const state = await waitForState((nextState) => Number(nextState.preview.pathPoints) === 0, 5000, "clear preview");
    const canvas = await getCanvasDataset();
    return check("Clear preview removes path points", Number(canvas.threePathPoints || 0) === 0 && Number(state.preview.pathPoints) === 0, JSON.stringify({ state: summarizeState(state), canvas }));
  });
  await recordClick("RELOAD", "Reload 恢复预览路径", async () => {
    await click("RELOAD");
    const state = await waitForState((nextState) => Number(nextState.preview.pathPoints) > 0 && nextState.runState === "idle", 5000, "reload restores preview");
    const canvas = await getCanvasDataset();
    return check("Reload restores toolpath preview points", Number(canvas.threePathPoints || 0) > 0 && state.runState === "idle", JSON.stringify({ state: summarizeState(state), canvas }));
  });
  await captureStep("07-preview-buttons", "我验证刀具预览按钮和刀路状态", "X/Y/Z/Fit/Clear/Reload 后，canvas dataset 中的 selectedView、pathPoints、RTCP 状态与 store 同步。");
}

async function verifyProgramSourceOpenReloadAndRunControls() {
  await recordClick("stage-linuxcnc-sources", "Stage LinuxCNC source", async () => {
    await click("stage-linuxcnc-sources");
    const state = await waitForState((nextState) => nextState.machineFileStaging?.status === "staged" && nextState.machineFileStaging?.gcodeSources?.length > 0, 20000, "stage sources");
    return check("Stage exposes LinuxCNC G-code sources", state.machineFileStaging.status === "staged" && state.machineFileStaging.gcodeSources.length > 0, JSON.stringify(summarizeState(state)));
  });
  await selectFirstLinuxCncSource();
  await captureStep("08-linuxcnc-source-loaded", "我验证 LinuxCNC G-code 来源选择", "Stage 和 source 下拉选择后，G-code 面板、程序行、刀路预览和 interpreter canonical motion 均已刷新。");

  await uploadProgramViaOpen();
  await captureStep("09-open-file-loaded", "我验证 Open 文件按钮", "通过隐藏 file input 实际上传本地 fixture/test-program.ngc，页面加载为 operator-file 程序。");

  await recordClick("RUN_READY", "Run Ready 一键准备", async () => {
    await click("RUN_READY");
    const state = await waitForState((nextState) => nextState.machine.powerOn === true && nextState.machine.allHomed === true && nextState.machine.mode === "auto" && nextState.machineFileStaging?.selectedGcodeSourceRel, 25000, "run ready");
    return check("Run Ready powers on, homes, enters AUTO, and opens a staged source", state.machine.powerOn && state.machine.allHomed && state.machine.mode === "auto" && Boolean(state.machineFileStaging.selectedGcodeSourceRel), JSON.stringify(summarizeState(state)));
  });
  await captureStep("10-run-ready", "我验证 Run Ready", "Run Ready 完成 power/home/auto/source/session 前置条件，准备进入 Task/HAL 程序执行。");

  await recordClick("RUN", "RUN 执行程序", async () => {
    await click("RUN");
    const state = await waitForState((nextState) => nextState.runState === "running" && nextState.programRuntimeFeedback?.sourceMode === "linuxcnc-task-motion-hal-wasm", 20000, "run");
    await wait(350);
    const later = await getState();
    const canvas = await getCanvasDataset();
    return check("RUN produces Task/HAL runtime feedback and executed path", later.runState === "running" && Number(canvas.threeExecutedPathPoints || 0) > 0 && later.machine.interpState === "reading", JSON.stringify({ state: summarizeState(later), canvas }));
  });
  await captureStep("11-run-realtime-path", "我验证刀具实时执行路径", "RUN 后 G-code 当前行、DRO、Task/HAL runtime feedback、canvas executedPathPoints 和当前段高亮同步变化。");

  await recordClick("PAUSE", "PAUSE 暂停", async () => {
    await click("PAUSE");
    const state = await waitForState((nextState) => nextState.runState === "paused" && nextState.machine.taskPaused === true, 10000, "pause");
    return check("PAUSE sets paused state", state.runState === "paused" && state.machine.taskPaused, JSON.stringify(summarizeState(state)));
  });
  await recordClick("RESUME", "RESUME 继续", async () => {
    await click("RESUME");
    const state = await waitForState((nextState) => nextState.runState === "running" && nextState.machine.interpState === "reading", 10000, "resume");
    return check("RESUME returns to running", state.runState === "running" && state.machine.interpState === "reading", JSON.stringify(summarizeState(state)));
  });
  await recordClick("PAUSE", "STEP 前暂停", async () => {
    await click("PAUSE");
    const state = await waitForState((nextState) => nextState.runState === "paused", 10000, "pause before step");
    return check("Paused before STEP", state.runState === "paused", JSON.stringify(summarizeState(state)));
  });
  await recordClick("STEP", "STEP 单步", async () => {
    const before = await getState();
    await click("STEP");
    const state = await waitForState((nextState) => nextState.machine.taskPaused === true && nextState.taskHalStatus?.task?.singleStepping === true, 10000, "step");
    return check("STEP performs one task/HAL step", state.taskHalStatus?.task?.singleStepping === true && Number(state.taskHalStatus?.ui?.taskCycle || 0) >= Number(before.taskHalStatus?.ui?.taskCycle || 0), JSON.stringify({ before: summarizeState(before), after: summarizeState(state) }));
  });
  await captureStep("12-pause-resume-step", "我验证暂停、继续和单步", "PAUSE/RESUME/STEP 的状态、interpState、taskPaused 和 Task/HAL singleStepping 均已验证。");

  await recordClick("STOP", "STOP 停止", async () => {
    await click("STOP");
    const state = await waitForState((nextState) => nextState.runState === "stopped" && nextState.machine.interpState === "idle", 10000, "stop");
    return check("STOP aborts motion and returns idle", state.runState === "stopped" && state.machine.interpState === "idle", JSON.stringify(summarizeState(state)));
  });
  await captureStep("13-stop-idle", "我验证 STOP 停止", "STOP 后 interpreter 返回 idle，进给速度清零，Task/HAL status loop 停止。");
}

async function verifyManualJogMdiOverridesSpindleCoolantAndSession() {
  await recordClick("mode-manual", "切到 MANUAL 准备点动", async () => {
    await click("mode-manual");
    const state = await waitForState((nextState) => nextState.machine.mode === "manual", 10000, "manual before jog");
    return check("Manual mode before jog", state.machine.mode === "manual", JSON.stringify(summarizeState(state)));
  });
  for (const [action, axis, direction] of [
    ["JOG_X_NEG", "x", -1],
    ["JOG_X_POS", "x", 1],
    ["JOG_Y_NEG", "y", -1],
    ["JOG_Y_POS", "y", 1],
  ]) {
    await recordClick(action, `${action} 点动`, async () => {
      const before = await getState();
      await click(action);
      const state = await waitForState((nextState) => direction > 0
        ? Number(nextState.axisPose?.[axis] || 0) > Number(before.axisPose?.[axis] || 0)
        : Number(nextState.axisPose?.[axis] || 0) < Number(before.axisPose?.[axis] || 0), 10000, action);
      return check(`${action} changes ${axis.toUpperCase()} axis`, true, JSON.stringify({ before: summarizeState(before), after: summarizeState(state) }));
    });
  }
  await captureStep("14-manual-jog-axis-values", "我验证手动点动和机床轴值", "X-/X+/Y-/Y+ 均实际改变对应轴值，DRO 和 axisPose 同步。");

  await recordClick("mode-mdi", "切到 MDI", async () => {
    await click("mode-mdi");
    const state = await waitForState((nextState) => nextState.machine.mode === "mdi", 10000, "mdi before command");
    return check("MDI mode active", state.machine.mode === "mdi", JSON.stringify(summarizeState(state)));
  });
  await recordAction("mdi-submit", "MDI 输入并执行 G90 X12.5 Y-4 Z1.25 F900", async () => {
    await setMdiCommand("G90 X12.5 Y-4 Z1.25 F900");
    await submitMdiCommand();
    const state = await waitForState((nextState) => nextState.runState === "mdi" && Math.abs(Number(nextState.axisPose?.x || 0) - 12.5) < 1e-9, 10000, "mdi command");
    return check("MDI updates axis pose and history", state.axisPose.x === 12.5 && state.axisPose.y === -4 && state.mdiHistory?.includes("G90 X12.5 Y-4 Z1.25 F900"), JSON.stringify(summarizeState(state)));
  });
  await recordClick("mdi-history", "MDI 历史快捷按钮", async () => {
    const historyButtonExists = await page.$('[data-action="mdi-history"]');
    if (!historyButtonExists) {
      return check("MDI history button exists", false, "missing [data-action=mdi-history]");
    }
    await page.click('[data-action="mdi-history"]');
    const state = await waitForState((nextState) => nextState.runState === "mdi" && nextState.activeProgram === "MDI", 8000, "mdi history");
    return check("MDI history executes", state.activeProgram === "MDI" && state.programSource === "operator-mdi", JSON.stringify(summarizeState(state)));
  });
  await recordClick("MDI_RUN", "底部 MDI_RUN 执行当前 MDI", async () => {
    await click("MDI_RUN");
    const state = await waitForState((nextState) => nextState.runState === "mdi" && nextState.machine.mode === "mdi", 8000, "bottom mdi run");
    return check("Bottom MDI_RUN executes in MDI mode", state.runState === "mdi" && state.machine.mode === "mdi", JSON.stringify(summarizeState(state)));
  });
  await captureStep("15-mdi-execution", "我验证 MDI 执行过程", "MDI 输入、表单提交、历史按钮和底部 MDI_RUN 都执行到 store/runtime，并写入历史。");

  await recordClick("mode-manual", "返回 MANUAL 准备倍率", async () => {
    await click("mode-manual");
    const state = await waitForState((nextState) => nextState.machine.mode === "manual", 10000, "manual before overrides");
    return check("Manual before overrides", state.machine.mode === "manual", JSON.stringify(summarizeState(state)));
  });
  for (const [action, predicate, label] of [
    ["rapid-override-down", (state) => Number(state.feed.rapidOverride) === 90, "Rapid -"],
    ["rapid-override-up", (state) => Number(state.feed.rapidOverride) === 100, "Rapid +"],
    ["rapid-override-reset", (state) => Number(state.feed.rapidOverride) === 100, "Rapid 100"],
    ["feed-override-up", (state) => Number(state.feed.feedOverride) === 110, "Feed +"],
    ["feed-override-down", (state) => Number(state.feed.feedOverride) === 100, "Feed -"],
    ["feed-override-reset", (state) => Number(state.feed.feedOverride) === 100, "Feed 100"],
    ["spindle-override-up", (state) => Number(state.spindle.override) === 110, "Spindle +"],
    ["spindle-override-down", (state) => Number(state.spindle.override) === 100, "Spindle -"],
    ["spindle-override-reset", (state) => Number(state.spindle.override) === 100, "Spindle 100"],
  ]) {
    await recordClick(action, label, async () => {
      await click(action);
      const state = await waitForState(predicate, 8000, label);
      return check(`${label} updates override`, predicate(state), JSON.stringify(summarizeState(state)));
    });
  }
  for (const [action, stateKey, label] of [
    ["ignore-limits", "ignoreLimits", "Limits"],
    ["block-delete", "optionalBlocks", "/ Block"],
    ["optional-stop", "optionalStop", "M1"],
  ]) {
    await recordClick(action, label, async () => {
      const before = await getState();
      await click(action);
      const state = await waitForState((nextState) => Boolean(nextState.gmoccapyGui?.[stateKey]) !== Boolean(before.gmoccapyGui?.[stateKey]), 8000, label);
      return check(`${label} toggles HAL GUI state`, Boolean(state.gmoccapyGui?.[stateKey]) !== Boolean(before.gmoccapyGui?.[stateKey]), JSON.stringify({ before: summarizeState(before), after: summarizeState(state) }));
    });
  }
  await captureStep("16-overrides-hal", "我验证倍率和 HAL 输入", "Rapid/Feed/Spindle 倍率和 Limits/Block/M1 均通过按钮实际改变状态，并在诊断中显示 last HAL effect。");

  for (const [action, predicate, label] of [
    ["spindle-forward", (state) => state.spindle.enabled === true && state.spindle.direction === "forward", "主轴 FWD"],
    ["spindle-reverse", (state) => state.spindle.enabled === true && state.spindle.direction === "reverse", "主轴 REV"],
    ["spindle-stop", (state) => state.spindle.enabled === false && state.spindle.direction === "stop", "主轴 STOP"],
    ["toggle-flood", (state, before) => state.coolant.flood !== before.coolant.flood, "Flood"],
    ["toggle-mist", (state, before) => state.coolant.mist !== before.coolant.mist, "Mist"],
  ]) {
    await recordClick(action, label, async () => {
      const before = await getState();
      await click(action);
      const state = await waitForState((nextState) => predicate(nextState, before), 8000, label);
      return check(`${label} updates state`, predicate(state, before), JSON.stringify({ before: summarizeState(before), after: summarizeState(state) }));
    });
  }
  await captureStep("17-spindle-coolant", "我验证主轴和冷却", "FWD/REV/STOP、Flood、Mist 均受 power gate 控制并实际更新状态。");

  await recordClick("SAVE_SESSION", "Save Session", async () => {
    await click("SAVE_SESSION");
    const state = await waitForState((nextState) => nextState.sessionPersistence?.status === "saved", 15000, "save session");
    return check("Save Session persists snapshot", state.sessionPersistence.status === "saved" && Boolean(state.sessionPersistence.path), JSON.stringify(summarizeState(state)));
  });
  await selectProfile("xyzbc-trt", "会话恢复前临时切换 profile");
  await recordClick("RESTORE_SESSION", "Restore Session", async () => {
    await click("RESTORE_SESSION");
    const state = await waitForState((nextState) => nextState.sessionPersistence?.status === "restored" && nextState.machineProfile === "xyzac-trt", 15000, "restore session");
    return check("Restore Session restores saved profile", state.sessionPersistence.status === "restored" && state.machineProfile === "xyzac-trt", JSON.stringify(summarizeState(state)));
  });
  await recordClick("FULL", "Full 全屏状态切换", async () => {
    const before = await getState();
    await click("FULL");
    const state = await waitForState((nextState) => Boolean(nextState.preview.fullscreen) !== Boolean(before.preview.fullscreen), 5000, "fullscreen");
    return check("FULL toggles preview fullscreen flag", Boolean(state.preview.fullscreen) !== Boolean(before.preview.fullscreen), JSON.stringify({ before: summarizeState(before), after: summarizeState(state) }));
  });
  await captureStep("18-session-fullscreen", "我验证会话和 Full 按钮", "Save/Restore 通过 OPFS 或 fallback 存储恢复 profile/程序/UI 状态，Full 切换 preview.fullscreen。");
}

async function verifyDiagnosticsAndNativeHalEntryPoints() {
  await recordClick("AUDIT_FULL_BOUNDARY", "Audit Full Boundary", async () => {
    await click("AUDIT_FULL_BOUNDARY");
    const state = await waitForState((nextState) => nextState.machineFileExecution || /machine-file|LinuxCNC/i.test(nextState.operatorMessage || ""), 20000, "audit full boundary");
    return check("Audit starts full LinuxCNC boundary path", Boolean(state.machineFileExecution || state.fullExecutionBoundary), JSON.stringify(summarizeState(state)));
  });
  await recordAction("GMOCAPY_HAL_PIN ignore-limits", "公开 API 写入 gmoccapy HAL pin", async () => {
    await page.evaluate(() => window.webRtcp5AxisSimulation.dispatch({
      type: "GMOCAPY_HAL_PIN",
      pin: "gmoccapy.ignore-limits",
      value: true,
    }));
    const state = await waitForState((nextState) => nextState.gmoccapyGui.ignoreLimits === true && /ignore-limits/i.test(nextState.operatorMessage || ""), 8000, "hal pin");
    return check("Native HAL pin model updates Web state", state.gmoccapyGui.ignoreLimits === true, JSON.stringify(summarizeState(state)));
  });
  await recordAction("GMOCAPY_NATIVE_PAGE file", "公开 API 切换 gmoccapy native file page", async () => {
    await page.evaluate(() => window.webRtcp5AxisSimulation.dispatch({
      type: "GMOCAPY_NATIVE_PAGE",
      page: "file-load",
    }));
    const state = await waitForState((nextState) => nextState.gmoccapyGui.activeNativePage === "file-load", 8000, "native page file");
    return check("Native page model switches to file-load page", state.gmoccapyGui.activeNativePage === "file-load", JSON.stringify(summarizeState(state)));
  });
  await captureStep("19-diagnostics-audit", "我验证诊断和 gmoccapy 边界", "Task policy、INI、Task/HAL、Full boundary、gmoccapy comm/HAL/native page 诊断均可读，HAL pin 模型可实际更新页面状态。");
}

async function selectProfile(profileId, label) {
  await recordAction("select-profile", label, async () => {
    await page.select('[data-action="select-profile"]', profileId);
    const state = await waitForState((nextState) => nextState.machineProfile === profileId, 15000, `profile ${profileId}`);
    if (profileId === "gmoccapy-xyzab") {
      await waitForState((nextState) => nextState.machineProfile === profileId && nextState.rtcpState === "off", 10000, `profile ${profileId} reference profile ready`);
    } else {
      await waitForState((nextState) => nextState.machineProfile === profileId && nextState.kinematicsRuntimeReadiness?.loaded === true, 20000, `profile ${profileId} kins`);
    }
    return check(`Profile switched to ${profileId}`, state.machineProfile === profileId, JSON.stringify(summarizeState(await getState())));
  });
}

async function selectFirstLinuxCncSource() {
  await recordAction("select-linuxcnc-gcode-source", "选择第一个 LinuxCNC 5-axis G-code source", async () => {
    const sourceRel = await page.$eval('[data-action="select-linuxcnc-gcode-source"]', (select) => {
      const options = [...select.options].map((option) => option.value).filter(Boolean);
      return options[0] || "";
    });
    if (!sourceRel) return check("LinuxCNC source option exists", false, "no source options");
    await page.select('[data-action="select-linuxcnc-gcode-source"]', sourceRel);
    const state = await waitForState((nextState) => nextState.machineFileStaging?.selectedGcodeSourceRel === sourceRel && nextState.programExecution?.summary?.motionEventCount > 0 && nextState.programExecutionSourceMode === "linuxcnc-interpreter-wasm", 20000, "source load");
    const canvas = await getCanvasDataset();
    return check("Selected LinuxCNC source has interpreter preview", state.programExecutionSourceMode === "linuxcnc-interpreter-wasm" && Number(canvas.threePathPoints || 0) > 0, JSON.stringify({ sourceRel, state: summarizeState(state), canvas }));
  });
}

async function uploadProgramViaOpen() {
  await recordAction("OPEN", "Open 上传本地 G-code fixture", async () => {
    const filePath = path.join(QA_ROOT, "fixtures/test-program.ngc");
    const input = await page.$('[data-action="OPEN_FILE"]');
    if (!input) return check("Open file input exists", false, "missing OPEN_FILE");
    await input.uploadFile(filePath);
    const state = await waitForState((nextState) => nextState.programSource === "operator-file" && nextState.activeProgram === "test-program.ngc", 12000, "open file");
    const canvas = await getCanvasDataset();
    return check("OPEN loads local program and preview", state.programSource === "operator-file" && Number(canvas.threePathPoints || 0) > 0, JSON.stringify({ state: summarizeState(state), canvas }));
  });
}

async function recordClick(action, label, executor) {
  return recordAction(action, label, executor);
}

async function recordAction(action, label, executor) {
  const before = await getState().catch(() => null);
  const beforeDom = await getDomEvidence().catch(() => null);
  let result;
  let error = null;
  try {
    result = await executor();
  } catch (caught) {
    error = caught instanceof Error ? caught.stack || caught.message : String(caught);
    result = check(label, false, error);
  }
  const after = await getState().catch(() => null);
  const afterDom = await getDomEvidence().catch(() => null);
  const checks = Array.isArray(result) ? result : [result];
  const record = {
    action,
    label,
    status: checks.every((item) => item?.pass) ? "PASS" : "FAIL",
    checks,
    error,
    before: summarizeState(before || {}),
    after: summarizeState(after || {}),
    domBefore: summarizeDom(beforeDom),
    domAfter: summarizeDom(afterDom),
  };
  report.actionResults.push(record);
  return record;
}

async function captureStep(name, title, description) {
  const screenshotPath = path.join(SCREENSHOT_DIR, `${name}.png`);
  await page.screenshot({ path: screenshotPath, fullPage: true });
  const [state, dom, pixelStats] = await Promise.all([
    getState(),
    getDomEvidence(),
    analyzePng(screenshotPath),
  ]);
  const step = {
    name,
    title,
    description,
    screenshotPath,
    pixelStats,
    state: summarizeState(state),
    dom,
  };
  report.steps.push(step);
  return step;
}

async function windowReady() {
  await waitForState((state) => (
    state.kinematicsRuntimeReadiness?.loaded === true &&
    state.interpreterRuntimeReadiness?.loaded === true &&
    state.taskHalRuntimeReadiness?.loaded === true &&
    state.machineFileStaging?.status === "staged" &&
    !state.interpreterExecutionPending
  ), 40000, "runtime, machine files, and interpreter preview ready");
}

async function click(action) {
  await page.evaluate((selector) => {
    const element = document.querySelector(selector);
    if (!element) throw new Error(`missing action ${selector}`);
    element.click();
  }, `[data-action="${action}"]`);
}

async function setMdiCommand(command) {
  await page.$eval('[data-action="mdi-command"]', (input, value) => {
    input.value = value;
    input.dispatchEvent(new Event("input", { bubbles: true }));
    input.dispatchEvent(new Event("change", { bubbles: true }));
  }, command);
  await waitForState((state) => state.machine.mdiCommand === command.toUpperCase(), 5000, "MDI input staged");
}

async function submitMdiCommand() {
  await page.$eval('[data-action="mdi-form"]', (form) => {
    form.dispatchEvent(new Event("submit", { bubbles: true, cancelable: true }));
  });
}

async function getState() {
  return page.evaluate(() => JSON.parse(JSON.stringify(window.webRtcp5AxisSimulation.getState())));
}

async function getCanvasDataset() {
  return page.$eval("[data-five-axis-canvas]", (canvas) => ({ ...canvas.dataset }));
}

async function waitForState(predicate, timeoutMs, label) {
  const started = Date.now();
  let lastState = null;
  while (Date.now() - started < timeoutMs) {
    lastState = await getState();
    if (predicate(lastState)) return lastState;
    await wait(WAIT_FAST);
  }
  throw new Error(`timeout waiting for ${label}: ${JSON.stringify(summarizeState(lastState || {}))}`);
}

async function getDomEvidence() {
  return page.evaluate(() => {
    const text = (selector) => document.querySelector(selector)?.textContent?.trim() || "";
    const button = (action) => {
      const element = document.querySelector(`[data-action="${action}"]`);
      return element ? {
        exists: true,
        tagName: element.tagName,
        disabled: Boolean(element.disabled),
        active: element.dataset?.active || null,
        commandReady: element.dataset?.commandReady || null,
        ariaDisabled: element.getAttribute("aria-disabled"),
        title: element.getAttribute("title") || "",
        label: element.getAttribute("aria-label") || element.textContent?.trim() || "",
        iconName: element.dataset?.iconName || null,
        iconVariant: element.dataset?.iconVariant || null,
        gmoccapyButtonId: element.dataset?.gmoccapyButtonId || null,
        nativePanel: element.dataset?.gmoccapyNativePanel || null,
        nativeButtonIndex: element.dataset?.gmoccapyNativeButtonIndex || null,
        halPin: element.dataset?.gmoccapyHalPin || null,
      } : { exists: false };
    };
    const actionNames = [...document.querySelectorAll("[data-action]")]
      .map((element) => element.dataset.action)
      .filter(Boolean);
    const buttons = Object.fromEntries([...new Set(actionNames)].map((action) => [action, button(action)]));
    return {
      regions: window.webRtcp5AxisSimulation.getRegions?.() || null,
      actionCount: actionNames.length,
      uniqueActions: [...new Set(actionNames)].sort(),
      buttons,
      canvas: { ...(document.querySelector("[data-five-axis-canvas]")?.dataset || {}) },
      gcode: {
        currentLine: Number(document.querySelector("[data-active-program-line]")?.dataset.activeProgramLine || 0),
        activeRowLine: Number(document.querySelector(".gcode-row.active")?.dataset.programLine || 0),
        activeExecution: document.querySelector(".gcode-row.active [data-line-execution]")?.textContent?.trim() || "",
      },
      values: {
        activeProgram: text(".gcode-header strong"),
        programSource: document.querySelector(".gcode-header [data-program-source]")?.dataset.programSource || "",
        rapidOverride: text('[data-value="rapid-override"]'),
        feedOverride: text('[data-value="feed-override"]'),
        spindleOverride: text('[data-value="spindle-override"]'),
        halLast: text('[data-value="gmoccapy-hal-last"]'),
        taskGates: text('[data-linuxcnc-task-policy="gates"]'),
        taskHal: text('[data-task-hal-runtime="readiness"]'),
        fullBoundary: text('[data-full-execution-boundary="status"]'),
        gmoccapyComm: text('[data-gmoccapy-comm="boundary"]'),
        gmoccapyHal: text('[data-gmoccapy-hal="boundary"]'),
        nativePageMatrix: text('[data-gmoccapy-page="matrix"]'),
        session: text('[data-session-persistence="status"]'),
        operatorMessage: text("[data-operator-message]"),
      },
    };
  });
}

async function collectButtonInventory() {
  return page.evaluate(() => [...document.querySelectorAll("[data-action]")].map((element, index) => ({
    index,
    action: element.dataset.action,
    tagName: element.tagName,
    type: element.getAttribute("type") || "",
    label: element.getAttribute("aria-label") || element.textContent?.trim() || "",
    disabled: Boolean(element.disabled),
    active: element.dataset.active || null,
    commandReady: element.dataset.commandReady || null,
    iconName: element.dataset.iconName || null,
    iconVariant: element.dataset.iconVariant || null,
    gmoccapyButtonId: element.dataset.gmoccapyButtonId || null,
    nativePanel: element.dataset.gmoccapyNativePanel || null,
    nativeButtonIndex: element.dataset.gmoccapyNativeButtonIndex || null,
    halPin: element.dataset.gmoccapyHalPin || null,
  })));
}

function addFinalChecks() {
  const inventoryActions = new Set(report.buttonInventory.map((item) => item.action));
  const testedActions = new Set(report.actionResults.map((item) => item.action));
  const requiredActions = [
    "select-profile",
    "view-x",
    "view-y",
    "view-z",
    "reset-view",
    "clear-preview",
    "select-linuxcnc-gcode-source",
    "stage-linuxcnc-sources",
    "OPEN",
    "OPEN_FILE",
    "RELOAD",
    "RUN_READY",
    "RUN",
    "STOP",
    "PAUSE",
    "RESUME",
    "STEP",
    "HOME",
    "JOG_X_NEG",
    "JOG_X_POS",
    "JOG_Y_NEG",
    "JOG_Y_POS",
    "MDI_RUN",
    "SAVE_SESSION",
    "RESTORE_SESSION",
    "AUDIT_FULL_BOUNDARY",
    "FULL",
    "estop",
    "power",
    "reset",
    "mode-auto",
    "mode-manual",
    "mode-jog",
    "mode-mdi",
    "kins-identity",
    "kins-tcp",
    "rapid-override-down",
    "rapid-override-up",
    "rapid-override-reset",
    "feed-override-down",
    "feed-override-up",
    "feed-override-reset",
    "ignore-limits",
    "block-delete",
    "optional-stop",
    "toggle-flood",
    "toggle-mist",
    "spindle-forward",
    "spindle-stop",
    "spindle-reverse",
    "spindle-override-down",
    "spindle-override-up",
    "spindle-override-reset",
    "mdi-submit",
    "mdi-history",
  ];
  report.checks.push(
    check("所有主界面区域存在", report.steps[0]?.dom?.regions && Object.values(report.steps[0].dom.regions).every(Boolean), JSON.stringify(report.steps[0]?.dom?.regions)),
    check("canvas 非空且 WebGL ready", report.steps.every((step) => step.dom?.canvas?.threeReady === "true" && step.pixelStats.nonBlackRatio > 0.1), report.steps.map((step) => `${step.name}:${step.pixelStats.nonBlackRatio}`).join(", ")),
    check("按钮库存包含核心 action", requiredActions.every((action) => inventoryActions.has(action) || action === "mdi-history" || action === "OPEN_FILE"), `missing=${requiredActions.filter((action) => !inventoryActions.has(action) && action !== "mdi-history" && action !== "OPEN_FILE").join(",")}`),
    check("核心按钮均执行验证", requiredActions.every((action) => testedActions.has(action) || action === "OPEN_FILE"), `missing=${requiredActions.filter((action) => !testedActions.has(action) && action !== "OPEN_FILE").join(",")}`),
    check("未发生页面异常", pageErrors.length === 0, pageErrors.join(" | ") || "-"),
    check("所有 action 断言通过", report.actionResults.every((item) => item.status === "PASS"), report.actionResults.filter((item) => item.status !== "PASS").map((item) => `${item.action}:${item.error || item.checks?.map((checkItem) => checkItem.detail).join(";")}`).join(" | ") || "-"),
  );
}

async function writeMarkdownReport(markdownPath, data) {
  const lines = [];
  lines.push("# working7 全量功能实际执行验证报告");
  lines.push("");
  lines.push(`生成时间：${data.generatedAt}`);
  lines.push(`job_id：${data.jobId}`);
  lines.push(`report_id：${data.reportId}`);
  lines.push(`目标页面：${data.targetUrl}`);
  lines.push(`总体结果：${data.status}`);
  lines.push("");
  lines.push("## 我验证的范围");
  lines.push("");
  lines.push("我在真实 Chromium 页面中逐项点击并验证主界面按钮、右侧全班按钮、程序执行、刀具预览、刀具实时执行路径、G-code 执行过程、机床轴值、倍率、主轴冷却、会话和诊断边界。");
  lines.push("");
  lines.push("## 总体验收");
  lines.push("");
  lines.push("| 检查项 | 结果 | 证据 |");
  lines.push("| --- | --- | --- |");
  for (const item of data.checks) {
    lines.push(`| ${escapeMarkdown(item.name)} | ${item.pass ? "PASS" : "FAIL"} | ${escapeMarkdown(item.detail)} |`);
  }
  lines.push("");
  lines.push("## 按钮执行矩阵");
  lines.push("");
  lines.push("| action | 我执行的操作 | 结果 | 关键状态变化 |");
  lines.push("| --- | --- | --- | --- |");
  for (const action of data.actionResults) {
    lines.push(`| ${escapeMarkdown(action.action)} | ${escapeMarkdown(action.label)} | ${action.status} | ${escapeMarkdown(action.checks.map((item) => item.detail).join("；").slice(0, 500))} |`);
  }
  lines.push("");
  lines.push("## 图文证据");
  lines.push("");
  for (const step of data.steps) {
    lines.push(`### ${step.name} ${step.title}`);
    lines.push("");
    lines.push(step.description);
    lines.push("");
    lines.push(`![${escapeMarkdown(step.title)}](${path.relative(path.dirname(markdownPath), step.screenshotPath)})`);
    lines.push("");
    lines.push("```json");
    lines.push(JSON.stringify({
      runState: step.state.runState,
      machineProfile: step.state.machineProfile,
      machine: step.state.machine,
      axisPose: step.state.axisPose,
      dro: step.state.dro,
      canvas: step.dom.canvas,
      gcode: step.dom.gcode,
      values: step.dom.values,
    }, null, 2));
    lines.push("```");
    lines.push("");
  }
  await fs.writeFile(markdownPath, `${lines.join("\n")}\n`, "utf8");
}

async function writePdfReport(pdfPath, data) {
  const reportPage = await browser.newPage();
  const checkRows = data.checks.map((item) => `
    <tr><td>${escapeHtml(item.name)}</td><td class="${item.pass ? "pass" : "fail"}">${item.pass ? "PASS" : "FAIL"}</td><td>${escapeHtml(item.detail)}</td></tr>
  `).join("");
  const actionRows = data.actionResults.map((item) => `
    <tr><td>${escapeHtml(item.action)}</td><td>${escapeHtml(item.label)}</td><td class="${item.status === "PASS" ? "pass" : "fail"}">${escapeHtml(item.status)}</td><td>${escapeHtml(item.checks.map((checkItem) => checkItem.detail).join("；").slice(0, 700))}</td></tr>
  `).join("");
  const steps = data.steps.map((step) => `
    <section>
      <h2>${escapeHtml(step.name)} ${escapeHtml(step.title)}</h2>
      <p>${escapeHtml(step.description)}</p>
      <p><strong>截图：</strong>${escapeHtml(step.screenshotPath)}</p>
      <img src="file://${step.screenshotPath}" />
      <pre>${escapeHtml(JSON.stringify({
        runState: step.state.runState,
        machineProfile: step.state.machineProfile,
        machine: step.state.machine,
        axisPose: step.state.axisPose,
        dro: step.state.dro,
        gcode: step.dom.gcode,
        canvas: {
          threeReady: step.dom.canvas.threeReady,
          threeSelectedView: step.dom.canvas.threeSelectedView,
          threePathPoints: step.dom.canvas.threePathPoints,
          threeExecutedPathPoints: step.dom.canvas.threeExecutedPathPoints,
          threeToolExecutionTraceSource: step.dom.canvas.threeToolExecutionTraceSource,
        },
      }, null, 2))}</pre>
    </section>
  `).join("");
  await reportPage.setContent(`<!doctype html>
    <html>
      <head>
        <meta charset="utf-8" />
        <style>
          body { font-family: Arial, "Noto Sans CJK SC", sans-serif; margin: 24px; color: #17202a; }
          h1 { font-size: 22px; margin-bottom: 6px; }
          h2 { font-size: 15px; margin-top: 18px; }
          p, li { font-size: 11px; line-height: 1.45; }
          table { border-collapse: collapse; width: 100%; margin: 12px 0; }
          th, td { border: 1px solid #9aa5b1; padding: 5px; font-size: 9px; vertical-align: top; }
          th { background: #eef2f7; }
          .pass { color: #126b37; font-weight: 700; }
          .fail { color: #a61b1b; font-weight: 700; }
          section { break-inside: avoid; border-top: 1px solid #d8dee6; padding-top: 8px; }
          img { width: 100%; max-height: 620px; object-fit: contain; border: 1px solid #ccd3dc; }
          pre { white-space: pre-wrap; font-size: 8px; background: #f7f9fc; padding: 6px; border: 1px solid #d8dee6; }
        </style>
      </head>
      <body>
        <h1>working7 全量功能实际执行验证报告</h1>
        <p>我在真实 Chromium 页面中逐项点击并验证按钮、程序运行、刀具预览、实时路径、G-code 执行过程、机床轴值和右侧控制区。</p>
        <p><strong>结果：</strong>${escapeHtml(data.status)}；<strong>job_id：</strong>${escapeHtml(data.jobId)}；<strong>report_id：</strong>${escapeHtml(data.reportId)}</p>
        <p><strong>目标页面：</strong>${escapeHtml(data.targetUrl)}</p>
        <h2>总体验收</h2>
        <table><thead><tr><th>检查项</th><th>结果</th><th>证据</th></tr></thead><tbody>${checkRows}</tbody></table>
        <h2>按钮执行矩阵</h2>
        <table><thead><tr><th>action</th><th>操作</th><th>结果</th><th>状态变化</th></tr></thead><tbody>${actionRows}</tbody></table>
        <h2>图文证据</h2>
        ${steps}
      </body>
    </html>`, { waitUntil: "load" });
  await reportPage.pdf({
    path: pdfPath,
    format: "A4",
    printBackground: true,
    margin: { top: "10mm", right: "9mm", bottom: "10mm", left: "9mm" },
  });
  await reportPage.close();
}

function summarizeState(state = {}) {
  return {
    machineProfile: state.machineProfile,
    activeProgram: state.activeProgram,
    programSource: state.programSource,
    programExecutionSourceMode: state.programExecutionSourceMode,
    runState: state.runState,
    activeLine: state.activeLine,
    machine: {
      powerOn: state.machine?.powerOn,
      estopActive: state.machine?.estopActive,
      taskState: state.machine?.taskState,
      mode: state.machine?.mode,
      allHomed: state.machine?.allHomed,
      interpState: state.machine?.interpState,
      taskPaused: state.machine?.taskPaused,
      mdiCommand: state.machine?.mdiCommand,
    },
    axisPose: pickAxes(state.axisPose),
    dro: pickAxes(state.dro),
    tcpPose: pickAxes(state.tcpPose),
    kinsType: state.kinsType,
    rtcpState: state.rtcpState,
    feed: {
      rapidOverride: Number(state.feed?.rapidOverride),
      feedOverride: Number(state.feed?.feedOverride),
      feedRate: Number(state.feed?.feedRate),
      currentVelocity: Number(state.feed?.currentVelocity),
    },
    spindle: {
      enabled: Boolean(state.spindle?.enabled),
      direction: state.spindle?.direction,
      override: Number(state.spindle?.override),
      rpm: Number(state.spindle?.rpm),
    },
    coolant: {
      flood: Boolean(state.coolant?.flood),
      mist: Boolean(state.coolant?.mist),
    },
    preview: {
      pathPoints: Number(state.preview?.pathPoints),
      selectedView: state.preview?.selectedView,
      fullscreen: Boolean(state.preview?.fullscreen),
    },
    gmoccapyGui: {
      ignoreLimits: Boolean(state.gmoccapyGui?.ignoreLimits),
      optionalBlocks: Boolean(state.gmoccapyGui?.optionalBlocks),
      optionalStop: Boolean(state.gmoccapyGui?.optionalStop),
      activeNativePage: state.gmoccapyGui?.activeNativePage,
      lastHalPinEffect: state.gmoccapyGui?.lastHalPinEffect,
    },
    mdiHistory: state.mdiHistory || [],
    sessionPersistence: {
      status: state.sessionPersistence?.status,
      storageMode: state.sessionPersistence?.storageMode,
      path: state.sessionPersistence?.path,
      savedAt: state.sessionPersistence?.savedAt,
      restoredAt: state.sessionPersistence?.restoredAt,
    },
    machineFileStaging: {
      status: state.machineFileStaging?.status,
      fileCount: state.machineFileStaging?.fileCount,
      selectedGcodeSourceRel: state.machineFileStaging?.selectedGcodeSourceRel,
      gcodeSourceCount: state.machineFileStaging?.gcodeSources?.length || 0,
    },
    taskHalStatus: {
      taskCycle: Number(state.taskHalStatus?.ui?.taskCycle || 0),
      servoCycle: Number(state.taskHalStatus?.ui?.servoCycle || 0),
      activeLine: Number(state.taskHalStatus?.ui?.activeLine || 0),
      singleStepping: Boolean(state.taskHalStatus?.task?.singleStepping),
    },
    programRuntimeFeedback: state.programRuntimeFeedback ? {
      sourceMode: state.programRuntimeFeedback.sourceMode,
      line: state.programRuntimeFeedback.line,
      sampleIndex: state.programRuntimeFeedback.sampleIndex,
      motionIndex: state.programRuntimeFeedback.motionIndex,
      currentVelocityMmPerMin: state.programRuntimeFeedback.currentVelocityMmPerMin,
      axisPose: pickAxes(state.programRuntimeFeedback.axisPose),
    } : null,
    operatorMessage: state.operatorMessage,
  };
}

function summarizeDom(dom) {
  if (!dom) return null;
  return {
    actionCount: dom.actionCount,
    gcode: dom.gcode,
    values: dom.values,
    canvas: {
      threeReady: dom.canvas?.threeReady,
      threeSelectedView: dom.canvas?.threeSelectedView,
      threePathPoints: dom.canvas?.threePathPoints,
      threeExecutedPathPoints: dom.canvas?.threeExecutedPathPoints,
      threeRtcpState: dom.canvas?.threeRtcpState,
    },
  };
}

function pickAxes(value = {}) {
  return {
    x: Number(value?.x || 0),
    y: Number(value?.y || 0),
    z: Number(value?.z || 0),
    a: Number(value?.a || 0),
    b: Number(value?.b || 0),
    c: Number(value?.c || 0),
  };
}

async function analyzePng(filePath) {
  const png = PNG.sync.read(await fs.readFile(filePath));
  let luminanceSum = 0;
  let nonBlack = 0;
  for (let index = 0; index < png.data.length; index += 4) {
    const luminance = png.data[index] * 0.2126 + png.data[index + 1] * 0.7152 + png.data[index + 2] * 0.0722;
    luminanceSum += luminance;
    if (luminance > 8) nonBlack += 1;
  }
  const total = png.width * png.height;
  return {
    width: png.width,
    height: png.height,
    averageLuminance: Number((luminanceSum / total).toFixed(2)),
    nonBlackRatio: Number((nonBlack / total).toFixed(4)),
  };
}

function check(name, pass, detail) {
  return { name, pass: Boolean(pass), detail: String(detail ?? "-") };
}

function createStaticServer(rootDir) {
  return http.createServer(async (request, response) => {
    try {
      const requestPath = decodeURIComponent(new URL(request.url || "/", "http://127.0.0.1").pathname);
      const relativePath = requestPath === "/" ? "/index.html" : requestPath;
      const targetPath = path.resolve(rootDir, `.${relativePath}`);
      if (!targetPath.startsWith(rootDir)) {
        response.writeHead(403);
        response.end("forbidden");
        return;
      }
      let filePath = targetPath;
      let stat = await fs.stat(filePath).catch(() => null);
      if (stat?.isDirectory()) {
        filePath = path.join(filePath, "index.html");
        stat = await fs.stat(filePath).catch(() => null);
      }
      if (!stat?.isFile()) {
        response.writeHead(404);
        response.end("not found");
        return;
      }
      const body = await fs.readFile(filePath);
      response.writeHead(200, {
        "Content-Type": contentTypeFor(filePath),
        "Content-Length": String(body.byteLength),
        "Cache-Control": "no-store",
      });
      response.end(body);
    } catch (error) {
      response.writeHead(500);
      response.end(error instanceof Error ? error.message : String(error));
    }
  });
}

function contentTypeFor(filePath) {
  const ext = path.extname(filePath).toLowerCase();
  return {
    ".css": "text/css; charset=utf-8",
    ".html": "text/html; charset=utf-8",
    ".js": "text/javascript; charset=utf-8",
    ".json": "application/json; charset=utf-8",
    ".mjs": "text/javascript; charset=utf-8",
    ".svg": "image/svg+xml",
    ".png": "image/png",
    ".wasm": "application/wasm",
    ".xml": "application/xml; charset=utf-8",
  }[ext] || "application/octet-stream";
}

function escapeHtml(value) {
  return String(value ?? "")
    .replace(/&/g, "&amp;")
    .replace(/</g, "&lt;")
    .replace(/>/g, "&gt;")
    .replace(/"/g, "&quot;")
    .replace(/'/g, "&#39;");
}

function escapeMarkdown(value) {
  return String(value ?? "").replace(/\|/g, "\\|").replace(/\n/g, " ");
}

function wait(ms) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}