<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>电梯调度实验室 · Elevator Lab</title>
<style>
  :root {
    --bg: #070b10;
    --bg-soft: #0b1118;
    --panel: #0f1620;
    --panel-2: #121a24;
    --line: rgba(148, 163, 184, 0.14);
    --line-soft: rgba(148, 163, 184, 0.08);
    --line-strong: rgba(148, 163, 184, 0.26);
    --text: #e7eef5;
    --muted: #8b9aab;
    --faint: #5d6b7c;
    --accent: #3ddc97;
    --accent-dim: rgba(61, 220, 151, 0.12);
    --blue: #4cb3ff;
    --amber: #f2b544;
    --coral: #ff8a5c;
    --danger: #ff6b6b;
    --sans: "SF Pro Display", "SF Pro Text", -apple-system, BlinkMacSystemFont, "Segoe UI", "PingFang SC", "Hiragino Sans GB", "Microsoft YaHei", sans-serif;
    --mono: ui-monospace, "SF Mono", "JetBrains Mono", "Cascadia Code", "Roboto Mono", Consolas, monospace;
  }

  * { box-sizing: border-box; }
  html, body { margin: 0; padding: 0; }
  body {
    background: var(--bg);
    color: var(--text);
    font-family: var(--sans);
    font-size: 14px;
    line-height: 1.5;
    min-height: 100dvh;
    -webkit-font-smoothing: antialiased;
    text-rendering: optimizeLegibility;
  }
  body::before {
    content: "";
    position: fixed;
    inset: 0;
    z-index: 0;
    pointer-events: none;
    background:
      radial-gradient(950px 520px at 6% -12%, rgba(61, 220, 151, 0.10), transparent 62%),
      radial-gradient(760px 460px at 98% -4%, rgba(76, 179, 255, 0.07), transparent 58%),
      linear-gradient(rgba(148, 163, 184, 0.032) 1px, transparent 1px) 0 0 / 48px 48px,
      linear-gradient(90deg, rgba(148, 163, 184, 0.032) 1px, transparent 1px) 0 0 / 48px 48px;
  }
  button, input { font: inherit; }
  button { color: inherit; }
  [hidden] { display: none !important; }
  .mono { font-family: var(--mono); font-variant-numeric: tabular-nums; }

  .app {
    position: relative;
    z-index: 1;
    max-width: 1520px;
    margin: 0 auto;
    padding: 24px clamp(14px, 3vw, 36px) 70px;
  }

  
  .topbar {
    display: flex;
    align-items: flex-end;
    justify-content: space-between;
    gap: 28px;
    padding-bottom: 22px;
    border-bottom: 1px solid var(--line);
    animation: rise 0.55s cubic-bezier(0.16, 1, 0.3, 1) both;
  }
  .brand { display: flex; align-items: center; gap: 14px; }
  .brand-mark {
    width: 38px;
    height: 46px;
    color: var(--accent);
    flex: none;
    filter: drop-shadow(0 6px 18px rgba(61, 220, 151, 0.18));
  }
  .brand-kicker {
    font-family: var(--mono);
    font-size: 10px;
    letter-spacing: 0.19em;
    color: var(--faint);
    margin-bottom: 3px;
  }
  h1 {
    margin: 0;
    font-size: clamp(24px, 2.5vw, 32px);
    line-height: 1.08;
    letter-spacing: -0.035em;
    font-weight: 700;
  }
  .topbar-sub {
    margin-top: 7px;
    color: var(--muted);
    font-size: 12.5px;
    letter-spacing: 0.01em;
  }
  .topbar-meta { display: flex; align-items: center; gap: 26px; flex-wrap: wrap; justify-content: flex-end; }
  .meta-item { display: flex; flex-direction: column; gap: 3px; }
  .meta-label { font-size: 9.5px; letter-spacing: 0.16em; color: var(--faint); text-transform: uppercase; }
  .meta-value { font-size: 12px; color: var(--text); }
  .live-dot {
    display: inline-flex;
    align-items: center;
    gap: 8px;
    border: 1px solid var(--line);
    background: rgba(255, 255, 255, 0.025);
    border-radius: 99px;
    padding: 6px 12px;
    font-size: 11.5px;
    color: var(--muted);
    white-space: nowrap;
  }
  .live-dot i {
    width: 6px; height: 6px; border-radius: 50%;
    background: var(--accent);
    box-shadow: 0 0 0 0 rgba(61, 220, 151, 0.45);
    animation: breathe 2.4s ease-in-out infinite;
  }

  
  .panel {
    position: relative;
    margin-top: 16px;
    border: 1px solid var(--line);
    border-radius: 16px;
    background: linear-gradient(180deg, rgba(18, 26, 36, 0.92), rgba(11, 16, 23, 0.94));
    box-shadow:
      inset 0 1px 0 rgba(255, 255, 255, 0.035),
      0 26px 60px -48px rgba(0, 0, 0, 0.9);
    animation: rise 0.6s cubic-bezier(0.16, 1, 0.3, 1) both;
  }
  .panel-head {
    display: flex;
    align-items: flex-start;
    justify-content: space-between;
    gap: 18px;
    padding: 18px 22px 0;
  }
  .eyebrow {
    display: block;
    font-family: var(--mono);
    font-size: 9.5px;
    letter-spacing: 0.18em;
    color: var(--faint);
    margin-bottom: 5px;
  }
  h2 { margin: 0; font-size: 16px; letter-spacing: -0.02em; font-weight: 650; }
  .panel-sub { margin: 5px 0 0; color: var(--muted); font-size: 11.5px; }

  
  .control-panel { padding: 18px 22px 16px; }
  .control-main {
    display: grid;
    grid-template-columns: minmax(280px, 1.05fr) minmax(200px, 0.8fr) minmax(200px, 0.8fr) minmax(180px, 0.62fr);
    gap: 20px 26px;
    align-items: start;
  }
  .field { display: flex; flex-direction: column; gap: 8px; min-width: 0; }
  .field-label {
    font-size: 10.5px;
    letter-spacing: 0.07em;
    color: var(--muted);
    font-weight: 600;
    display: flex;
    align-items: baseline;
    gap: 8px;
    min-height: 17px;
  }
  .field-label output { color: var(--accent); font-family: var(--mono); font-size: 12px; }
  .field-label .dim { color: var(--faint); font-weight: 400; letter-spacing: 0; }
  .field-hint { font-size: 10.5px; color: var(--faint); }

  .seg {
    display: inline-flex;
    padding: 3px;
    gap: 2px;
    background: #090e14;
    border: 1px solid var(--line);
    border-radius: 11px;
    align-self: flex-start;
  }
  .seg button {
    border: 0;
    background: transparent;
    color: var(--muted);
    padding: 8px 13px;
    border-radius: 8px;
    font-size: 12px;
    font-weight: 600;
    cursor: pointer;
    white-space: nowrap;
    transition: color 0.18s ease, background 0.18s ease, box-shadow 0.18s ease;
  }
  .seg button:hover { color: var(--text); }
  .seg button[aria-pressed="true"] {
    color: var(--accent);
    background: var(--accent-dim);
    box-shadow: inset 0 0 0 1px rgba(61, 220, 151, 0.24);
  }
  .seg button:active { transform: translateY(1px); }

  .range-row { display: flex; align-items: center; gap: 12px; }
  input[type="range"] {
    --fill: 50%;
    -webkit-appearance: none;
    appearance: none;
    width: 100%;
    height: 4px;
    border-radius: 99px;
    outline: none;
    background: linear-gradient(90deg, var(--accent) 0%, var(--accent) var(--fill), rgba(148, 163, 184, 0.18) var(--fill), rgba(148, 163, 184, 0.18) 100%);
    cursor: pointer;
  }
  input[type="range"]::-webkit-slider-thumb {
    -webkit-appearance: none;
    width: 14px; height: 14px;
    border-radius: 50%;
    background: var(--accent);
    border: 2px solid #04120b;
    box-shadow: 0 0 0 1px rgba(61, 220, 151, 0.5), 0 2px 8px rgba(0, 0, 0, 0.6);
  }
  input[type="range"]::-moz-range-thumb {
    width: 12px; height: 12px;
    border-radius: 50%;
    background: var(--accent);
    border: 2px solid #04120b;
    box-shadow: 0 0 0 1px rgba(61, 220, 151, 0.5);
  }
  input[type="number"], input[type="text"] {
    width: 78px;
    flex: none;
    background: #090e14;
    border: 1px solid var(--line);
    border-radius: 9px;
    color: var(--text);
    padding: 8px 10px;
    font-family: var(--mono);
    font-size: 13px;
    outline: none;
    transition: border-color 0.16s ease, box-shadow 0.16s ease;
  }
  input[type="number"]:focus, input[type="text"]:focus {
    border-color: rgba(61, 220, 151, 0.55);
    box-shadow: 0 0 0 3px rgba(61, 220, 151, 0.1);
  }
  input[type="number"]::-webkit-outer-spin-button,
  input[type="number"]::-webkit-inner-spin-button { opacity: 0.35; }
  .seed-row { display: flex; align-items: center; gap: 8px; }
  .seed-row input { width: 126px; }
  .seed-row .btn { padding: 8px 11px; }

  .control-sub {
    display: flex;
    align-items: flex-end;
    justify-content: space-between;
    gap: 20px;
    margin-top: 18px;
    padding-top: 17px;
    border-top: 1px solid var(--line-soft);
    flex-wrap: wrap;
  }
  .field.grow { flex: 1; min-width: 420px; }
  .algo-row { display: flex; gap: 8px; flex-wrap: wrap; }
  .algo-chip {
    --c: var(--accent);
    display: flex;
    flex-direction: column;
    align-items: flex-start;
    gap: 2px;
    min-width: 126px;
    padding: 9px 12px 8px;
    border: 1px solid var(--line);
    border-radius: 10px;
    background: rgba(255, 255, 255, 0.015);
    cursor: pointer;
    text-align: left;
    transition: border-color 0.18s ease, background 0.18s ease, transform 0.12s ease;
  }
  .algo-chip:hover { background: rgba(255, 255, 255, 0.04); }
  .algo-chip:active { transform: translateY(1px); }
  .algo-chip .chip-top { display: flex; align-items: center; gap: 7px; }
  .chip-mark {
    width: 6px; height: 6px; border-radius: 50%;
    background: rgba(148, 163, 184, 0.35);
    transition: background 0.18s ease, box-shadow 0.18s ease;
  }
  .algo-chip strong { font-size: 11.5px; letter-spacing: 0.05em; font-weight: 700; color: #c3ceda; }
  .algo-chip small { font-size: 10.5px; color: var(--faint); line-height: 1.35; padding-left: 13px; }
  .algo-chip[aria-pressed="true"] {
    border-color: var(--c);
    background: rgba(255, 255, 255, 0.035);
    box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.05);
  }
  .algo-chip[aria-pressed="true"] .chip-mark { background: var(--c); box-shadow: 0 0 0 3px rgba(255, 255, 255, 0.05); }
  .algo-chip[aria-pressed="true"] strong { color: var(--c); }
  .algo-chip[aria-pressed="true"] small { color: #9aa9b9; }

  .actions { display: flex; align-items: center; gap: 10px; flex-wrap: wrap; }
  .btn {
    display: inline-flex;
    align-items: center;
    justify-content: center;
    gap: 8px;
    border: 1px solid var(--line-strong);
    background: rgba(255, 255, 255, 0.035);
    border-radius: 10px;
    color: var(--text);
    padding: 10px 17px;
    font-size: 12.5px;
    font-weight: 600;
    letter-spacing: 0.01em;
    cursor: pointer;
    transition: background 0.18s ease, border-color 0.18s ease, transform 0.12s ease;
    white-space: nowrap;
  }
  .btn:hover { background: rgba(255, 255, 255, 0.075); border-color: rgba(148, 163, 184, 0.4); }
  .btn:active { transform: translateY(1px); }
  .btn:disabled { opacity: 0.5; cursor: default; transform: none; }
  .btn-primary {
    background: var(--accent);
    border-color: transparent;
    color: #04120b;
    box-shadow: 0 8px 26px -14px rgba(61, 220, 151, 0.8);
  }
  .btn-primary:hover { background: #56e8a9; border-color: transparent; }
  .btn.small { padding: 8px 12px; font-size: 11.5px; }
  .link-btn {
    background: none; border: 0; padding: 2px 0;
    color: var(--faint); font-size: 11px; cursor: pointer;
    text-decoration: underline; text-underline-offset: 3px;
  }
  .link-btn:hover { color: var(--text); }
  .link-btn:disabled { opacity: 0.4; cursor: default; }

  .manual-row {
    display: flex;
    align-items: center;
    gap: 14px 20px;
    flex-wrap: wrap;
    margin-top: 16px;
    padding-top: 15px;
    border-top: 1px solid var(--line-soft);
  }
  .manual-row .field-label { min-height: 0; }
  .manual-inputs { display: flex; align-items: center; gap: 8px; flex-wrap: wrap; }
  .manual-inputs input { width: 62px; text-align: center; }
  .manual-arrow { color: var(--faint); font-family: var(--mono); }
  .manual-count { font-size: 11px; color: var(--faint); font-family: var(--mono); }
  .manual-hint { margin-left: auto; color: var(--faint); font-size: 10.5px; }
  .manual-hint b { color: #b9c6d4; font-weight: 600; }
  .run-status { font-size: 10.5px; color: var(--faint); font-family: var(--mono); letter-spacing: 0.01em; }

  
  .stage-section { margin-top: 16px; animation: rise 0.65s cubic-bezier(0.16, 1, 0.3, 1) both; }
  .stage-section .section-head {
    display: flex;
    align-items: flex-end;
    justify-content: space-between;
    gap: 18px;
    padding: 0 2px 12px;
    flex-wrap: wrap;
  }
  .section-head h2 { font-size: 17px; }
  .section-head .right { color: var(--faint); font-size: 11px; font-family: var(--mono); }
  .stage { display: grid; gap: 14px; grid-template-columns: minmax(0, 1fr); }
  .stage[data-cols="2"] { grid-template-columns: repeat(2, minmax(0, 1fr)); }
  .stage[data-cols="3"] { grid-template-columns: repeat(3, minmax(0, 1fr)); }
  .stage[data-cols="4"] { grid-template-columns: repeat(2, minmax(0, 1fr)); }
  .viz-card {
    --algo: var(--accent);
    border: 1px solid var(--line);
    border-radius: 14px;
    overflow: hidden;
    background: linear-gradient(180deg, rgba(16, 23, 32, 0.94), rgba(8, 12, 17, 0.97));
    box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.03), 0 20px 44px -40px rgba(0, 0, 0, 0.9);
    display: flex;
    flex-direction: column;
    min-width: 0;
  }
  .viz-head {
    display: flex;
    align-items: center;
    justify-content: space-between;
    gap: 12px;
    padding: 11px 14px;
    border-bottom: 1px solid var(--line-soft);
    flex-wrap: wrap;
  }
  .viz-title { display: flex; align-items: center; gap: 8px; min-width: 0; }
  .algo-mark { width: 7px; height: 7px; border-radius: 2px; background: var(--algo); box-shadow: 0 0 10px rgba(255, 255, 255, 0.12); }
  .viz-name { font-family: var(--mono); font-size: 11.5px; font-weight: 700; letter-spacing: 0.06em; color: var(--algo); }
  .viz-cn { font-size: 10.5px; color: var(--faint); }
  .viz-live { display: flex; align-items: center; gap: 12px; font-size: 10.5px; color: var(--faint); font-family: var(--mono); }
  .viz-live b { color: var(--text); font-weight: 600; font-size: 11px; }
  .viz-clock { color: #9fb0c1; min-width: 58px; text-align: right; }
  .viz-canvas-wrap { position: relative; height: 520px; min-height: 0; }
  .stage[data-cols="2"] .viz-canvas-wrap { height: 440px; }
  .stage[data-cols="3"] .viz-canvas-wrap { height: 380px; }
  .stage[data-cols="4"] .viz-canvas-wrap { height: 368px; }
  .viz-canvas-wrap canvas { display: block; width: 100%; height: 100%; }

  .playbar {
    display: flex;
    align-items: center;
    gap: 13px;
    margin-top: 12px;
    padding: 10px 14px;
    border: 1px solid var(--line);
    border-radius: 12px;
    background: rgba(13, 19, 26, 0.78);
    flex-wrap: wrap;
  }
  .play-btn {
    width: 34px; height: 34px;
    flex: none;
    display: inline-flex; align-items: center; justify-content: center;
    border: 1px solid var(--line-strong);
    border-radius: 50%;
    background: rgba(255, 255, 255, 0.04);
    cursor: pointer;
    transition: background 0.16s ease, transform 0.12s ease;
    color: var(--text);
    padding: 0;
  }
  .play-btn:hover { background: rgba(255, 255, 255, 0.09); }
  .play-btn:active { transform: scale(0.96); }
  .play-btn svg { width: 14px; height: 14px; }
  .scrub-wrap { flex: 1; min-width: 180px; display: flex; align-items: center; }
  .scrub { width: 100%; }
  .time-label { font-family: var(--mono); font-size: 10.5px; color: var(--muted); white-space: nowrap; min-width: 148px; text-align: right; }
  .speed-btn {
    border: 1px solid var(--line);
    background: rgba(255, 255, 255, 0.03);
    border-radius: 8px;
    padding: 6px 10px;
    font-family: var(--mono);
    font-size: 11px;
    color: var(--muted);
    cursor: pointer;
    min-width: 46px;
  }
  .speed-btn:hover { color: var(--text); border-color: var(--line-strong); }
  .replay-icon { width: 13px; height: 13px; }

  
  .metrics-panel { overflow: hidden; }
  .metrics-panel .panel-head { padding-bottom: 15px; }
  .metric-algo { font-size: 11px; color: var(--muted); font-family: var(--mono); text-align: right; }
  .metrics-grid {
    display: grid;
    grid-template-columns: repeat(7, minmax(0, 1fr));
    border-top: 1px solid var(--line);
  }
  .metric {
    padding: 15px 18px 16px;
    border-right: 1px solid var(--line-soft);
    min-width: 0;
  }
  .metric:last-child { border-right: 0; }
  .metric-label { display: block; font-size: 10.5px; color: var(--faint); letter-spacing: 0.05em; }
  .metric-num { margin-top: 5px; white-space: nowrap; }
  .metric-num strong {
    font-family: var(--mono);
    font-size: clamp(19px, 1.8vw, 25px);
    font-weight: 650;
    letter-spacing: -0.035em;
    font-variant-numeric: tabular-nums;
    color: var(--text);
  }
  .metric-num em { font-style: normal; font-size: 10px; color: var(--faint); margin-left: 4px; }
  .metric.primary .metric-num strong { color: var(--accent); }
  .metric.primary .metric-label { color: #9dc9b8; }

  
  .table-wrap { overflow-x: auto; padding-top: 10px; }
  table { width: 100%; border-collapse: collapse; font-size: 12px; min-width: 780px; }
  thead th {
    text-align: right;
    padding: 9px 14px 10px;
    border-bottom: 1px solid var(--line);
    color: var(--faint);
    font-size: 10px;
    letter-spacing: 0.07em;
    font-weight: 600;
    white-space: nowrap;
  }
  thead th:first-child { text-align: left; padding-left: 22px; }
  tbody td {
    text-align: right;
    padding: 12px 14px;
    border-bottom: 1px solid var(--line-soft);
    font-family: var(--mono);
    font-size: 11.5px;
    color: #c3cfdb;
    font-variant-numeric: tabular-nums;
    white-space: nowrap;
  }
  tbody td:first-child { text-align: left; padding-left: 22px; font-family: var(--sans); }
  tbody tr:last-child td { border-bottom: 0; }
  tbody tr:hover { background: rgba(255, 255, 255, 0.022); }
  .algo-cell { display: flex; align-items: center; gap: 9px; }
  .table-dot { width: 7px; height: 7px; border-radius: 2px; flex: none; }
  .algo-cell b { font-family: var(--mono); font-size: 11px; letter-spacing: 0.04em; }
  .algo-cell span { color: var(--faint); font-size: 10.5px; }
  td.best { color: var(--accent); font-weight: 700; }
  td.best::after { content: " ·"; color: rgba(61, 220, 151, 0.45); }
  .compare-note { padding: 10px 22px 16px; color: var(--faint); font-size: 10.5px; }

  
  .selfcheck-summary { display: flex; align-items: center; gap: 12px; flex-wrap: wrap; }
  .badge {
    display: inline-flex; align-items: center; gap: 7px;
    border-radius: 99px;
    padding: 6px 13px;
    font-size: 11.5px;
    font-weight: 650;
    font-family: var(--mono);
    letter-spacing: 0.01em;
  }
  .badge.good { color: var(--accent); background: rgba(61, 220, 151, 0.1); border: 1px solid rgba(61, 220, 151, 0.28); }
  .badge.bad { color: var(--danger); background: rgba(255, 107, 107, 0.1); border: 1px solid rgba(255, 107, 107, 0.3); }
  .badge.run { color: var(--muted); background: rgba(255, 255, 255, 0.04); border: 1px solid var(--line); }
  .summary-note { color: var(--faint); font-size: 10.5px; }
  .assert-grid {
    display: grid;
    grid-template-columns: repeat(3, minmax(0, 1fr));
    margin-top: 16px;
    border-top: 1px solid var(--line);
  }
  .assert {
    display: flex;
    gap: 11px;
    padding: 13px 16px;
    border-bottom: 1px solid var(--line-soft);
    border-right: 1px solid var(--line-soft);
    min-width: 0;
    align-items: flex-start;
  }
  .assert:nth-child(3n) { border-right: 0; }
  .assert-icon {
    flex: none;
    width: 17px; height: 17px;
    border-radius: 50%;
    display: inline-flex; align-items: center; justify-content: center;
    margin-top: 1px;
  }
  .assert.pass .assert-icon { color: var(--accent); background: rgba(61, 220, 151, 0.12); }
  .assert.fail .assert-icon { color: var(--danger); background: rgba(255, 107, 107, 0.12); }
  .assert-icon svg { width: 10px; height: 10px; }
  .assert-name { font-size: 11.5px; font-weight: 600; color: #cfdae5; line-height: 1.35; }
  .assert.fail .assert-name { color: #ffb4b4; }
  .assert-detail { margin-top: 2px; font-size: 10px; color: var(--faint); line-height: 1.45; word-break: break-word; }
  .selfcheck-tail {
    display: flex;
    justify-content: space-between;
    align-items: center;
    gap: 16px;
    padding: 14px 22px 17px;
    flex-wrap: wrap;
    color: var(--faint);
    font-size: 10.5px;
  }
  .selfcheck-tail code {
    font-family: var(--mono);
    color: #93a4b6;
    font-size: 10.5px;
    background: rgba(255, 255, 255, 0.03);
    border: 1px solid var(--line-soft);
    border-radius: 6px;
    padding: 4px 8px;
  }

  
  .alert {
    position: fixed;
    top: 18px;
    left: 50%;
    z-index: 100;
    transform: translate(-50%, -14px);
    display: flex;
    align-items: flex-start;
    gap: 10px;
    max-width: min(620px, 92vw);
    padding: 12px 17px;
    border-radius: 11px;
    border: 1px solid rgba(255, 107, 107, 0.42);
    background: linear-gradient(180deg, #1d1114, #150d10);
    color: #ffd9d9;
    font-size: 12px;
    line-height: 1.55;
    box-shadow: 0 24px 60px -26px rgba(0, 0, 0, 0.95), inset 0 1px 0 rgba(255, 255, 255, 0.05);
    opacity: 0;
    pointer-events: none;
    transition: opacity 0.2s ease, transform 0.2s ease;
  }
  .alert.show { opacity: 1; transform: translate(-50%, 0); }
  .alert-icon {
    flex: none;
    width: 17px; height: 17px;
    border-radius: 50%;
    background: rgba(255, 107, 107, 0.16);
    color: var(--danger);
    display: inline-flex; align-items: center; justify-content: center;
    font-weight: 700;
    font-size: 11px;
    margin-top: 1px;
  }

  footer {
    display: flex;
    justify-content: space-between;
    align-items: center;
    gap: 18px;
    flex-wrap: wrap;
    margin-top: 26px;
    padding-top: 18px;
    border-top: 1px solid var(--line);
    color: var(--faint);
    font-size: 10.5px;
  }
  footer code { font-family: var(--mono); color: #8798aa; font-size: 10.5px; }

  @keyframes rise {
    from { opacity: 0; transform: translateY(10px); }
    to { opacity: 1; transform: translateY(0); }
  }
  @keyframes breathe {
    0%, 100% { box-shadow: 0 0 0 0 rgba(61, 220, 151, 0.4); opacity: 1; }
    50% { box-shadow: 0 0 0 5px rgba(61, 220, 151, 0); opacity: 0.72; }
  }
  @media (prefers-reduced-motion: reduce) {
    * { animation-duration: 0.001ms !important; animation-iteration-count: 1 !important; transition-duration: 0.001ms !important; }
  }

  @media (max-width: 1180px) {
    .control-main { grid-template-columns: 1fr 1fr; }
    .metrics-grid { grid-template-columns: repeat(4, minmax(0, 1fr)); }
    .metric:nth-child(4n) { border-right: 0; }
    .metric { border-bottom: 1px solid var(--line-soft); }
    .assert-grid { grid-template-columns: repeat(2, minmax(0, 1fr)); }
    .assert:nth-child(3n) { border-right: 1px solid var(--line-soft); }
    .assert:nth-child(2n) { border-right: 0; }
    .stage[data-cols="3"], .stage[data-cols="4"] { grid-template-columns: repeat(2, minmax(0, 1fr)); }
  }
  @media (max-width: 980px) {
    .topbar { align-items: flex-start; flex-direction: column; gap: 16px; }
    .topbar-meta { justify-content: flex-start; gap: 18px; }
    .stage[data-cols="2"], .stage[data-cols="3"], .stage[data-cols="4"] { grid-template-columns: minmax(0, 1fr); }
    .stage .viz-canvas-wrap { height: 460px !important; }
    .field.grow { min-width: 100%; }
    .manual-hint { margin-left: 0; }
  }
  @media (max-width: 720px) {
    .app { padding: 16px 12px 48px; }
    .control-main { grid-template-columns: 1fr; }
    .metrics-grid { grid-template-columns: repeat(2, minmax(0, 1fr)); }
    .metric:nth-child(4n) { border-right: 1px solid var(--line-soft); }
    .metric:nth-child(2n) { border-right: 0; }
    .assert-grid { grid-template-columns: 1fr; }
    .assert { border-right: 0 !important; }
    .panel-head { padding: 16px 16px 0; }
    .control-panel { padding: 16px; }
    .topbar-meta .meta-item { display: none; }
    .algo-chip { flex: 1; }
    .time-label { min-width: 0; width: 100%; text-align: left; }
  }
</style>
</head>
<body>
<div class="app">
  <header class="topbar">
    <div class="brand">
      <svg class="brand-mark" viewBox="0 0 40 46" aria-hidden="true">
        <rect x="3.5" y="7.5" width="10" height="31" rx="2" fill="none" stroke="currentColor" stroke-width="1.4" opacity="0.75"/>
        <rect x="16.5" y="7.5" width="10" height="31" rx="2" fill="none" stroke="currentColor" stroke-width="1.4"/>
        <rect x="29.5" y="7.5" width="7" height="31" rx="2" fill="none" stroke="currentColor" stroke-width="1.4" opacity="0.45"/>
        <rect x="5.5" y="27" width="6" height="8" rx="1" fill="currentColor"/>
        <rect x="18.5" y="13" width="6" height="8" rx="1" fill="currentColor" opacity="0.82"/>
        <rect x="31" y="20" width="4" height="7" rx="1" fill="currentColor" opacity="0.5"/>
      </svg>
      <div>
        <div class="brand-kicker">SIMULATION SUITE / ELEVATOR 01</div>
        <h1>电梯调度实验室</h1>
        <div class="topbar-sub">12 层楼 · 3 部轿厢 · 4 种策略。固定 seed,每一帧都可复现。</div>
      </div>
    </div>
    <div class="topbar-meta">
      <div class="meta-item">
        <span class="meta-label">Building</span>
        <span class="meta-value mono">12F / 3 CARS</span>
      </div>
      <div class="meta-item">
        <span class="meta-label">Engine</span>
        <span class="meta-value mono">window.__elevatorLab</span>
      </div>
      <div class="live-dot"><i></i> 本地仿真 · 零网络请求</div>
    </div>
  </header>

  <main>
    <section class="panel control-panel" aria-label="实验参数">
      <div class="control-main">
        <div class="field">
          <span class="field-label">客流场景</span>
          <div class="seg" id="scenarioSeg">
            <button type="button" data-scenario="morning" aria-pressed="true">早高峰上行</button>
            <button type="button" data-scenario="noon" aria-pressed="false">午间双向</button>
            <button type="button" data-scenario="random" aria-pressed="false">随机到站</button>
          </div>
          <span class="field-hint" id="scenarioHint">大量乘客从 1 层涌入并上行</span>
        </div>

        <div class="field">
          <span class="field-label">到达率 <output id="rateOut" for="rateSlider">20</output> 人/分钟</span>
          <div class="range-row">
            <input type="range" id="rateSlider" min="2" max="30" step="1" value="20" aria-label="到达率">
            <input type="number" id="rateNumber" min="2" max="30" step="1" value="20" aria-label="到达率数值">
          </div>
          <span class="field-hint">有效范围 2 – 30</span>
        </div>

        <div class="field">
          <span class="field-label">仿真时长 <output id="durationOut" for="durationSlider">120</output> 秒</span>
          <div class="range-row">
            <input type="range" id="durationSlider" min="60" max="600" step="10" value="120" aria-label="仿真时长">
            <input type="number" id="durationNumber" min="60" max="600" step="10" value="120" aria-label="仿真时长数值">
          </div>
          <span class="field-hint">有效范围 60 – 600 秒</span>
        </div>

        <div class="field">
          <span class="field-label">随机种子</span>
          <div class="seed-row">
            <input type="number" id="seedInput" min="0" max="2147483647" step="1" value="20261108" aria-label="随机种子">
            <button type="button" class="btn small" id="seedDice" title="生成新的随机种子">换一个</button>
          </div>
          <span class="field-hint">相同种子 = 相同结果</span>
        </div>
      </div>

      <div class="control-sub">
        <div class="field grow">
          <span class="field-label">调度算法 <span class="dim">可多选,并排对比</span></span>
          <div class="algo-row" id="algoRow">
            <button type="button" class="algo-chip" data-algo="NEAREST" style="--c:#3ddc97" aria-pressed="true">
              <span class="chip-top"><span class="chip-mark"></span><strong>NEAREST</strong></span>
              <small>最近空闲轿厢</small>
            </button>
            <button type="button" class="algo-chip" data-algo="FCFS" style="--c:#4cb3ff" aria-pressed="false">
              <span class="chip-top"><span class="chip-mark"></span><strong>FCFS</strong></span>
              <small>先来先服务</small>
            </button>
            <button type="button" class="algo-chip" data-algo="SCAN" style="--c:#f2b544" aria-pressed="false">
              <span class="chip-top"><span class="chip-mark"></span><strong>SCAN</strong></span>
              <small>电梯式扫描</small>
            </button>
            <button type="button" class="algo-chip" data-algo="LOOK" style="--c:#ff8a5c" aria-pressed="false">
              <span class="chip-top"><span class="chip-mark"></span><strong>LOOK</strong></span>
              <small>到顶即返</small>
            </button>
          </div>
        </div>
        <div class="actions">
          <button type="button" class="btn btn-primary" id="runBtn">运行仿真</button>
          <button type="button" class="btn" id="selfTestBtn">运行自检</button>
        </div>
      </div>

      <div class="manual-row">
        <span class="field-label">手动注入请求</span>
        <div class="manual-inputs">
          <input type="number" id="manualFrom" min="1" max="12" step="1" value="1" aria-label="手动请求起点楼层">
          <span class="manual-arrow">→</span>
          <input type="number" id="manualTo" min="1" max="12" step="1" value="12" aria-label="手动请求终点楼层">
          <button type="button" class="btn small" id="injectBtn">注入并重跑</button>
          <span class="manual-count" id="manualCount">已注入 0 条</span>
          <button type="button" class="link-btn" id="clearManual" disabled>清空</button>
        </div>
        <span class="manual-hint">试试输入 <b>13</b> 或 <b>0</b>:中文提示并恢复上一次有效值,不静默。</span>
        <span class="run-status" id="runStatus" aria-live="polite">就绪</span>
      </div>
    </section>

    <section class="stage-section" aria-label="楼体剖面与回放">
      <div class="section-head">
        <div>
          <div class="eyebrow">LIVE SECTION</div>
          <h2>楼体剖面</h2>
        </div>
        <div class="right">轿厢位置 · 外呼归属 · 候梯队列 · 实时回放</div>
      </div>
      <div id="stage" class="stage" data-cols="1"></div>
      <div class="playbar">
        <button type="button" class="play-btn" id="playBtn" aria-label="播放或暂停"></button>
        <div class="scrub-wrap">
          <input type="range" id="scrub" class="scrub" min="0" max="1000" step="1" value="0" aria-label="回放进度">
        </div>
        <span class="time-label" id="timeLabel">00:00.0 / 00:00.0</span>
        <button type="button" class="speed-btn" id="speedBtn" aria-label="切换回放倍速">4×</button>
        <button type="button" class="play-btn" id="replayBtn" aria-label="从头重播">
          <svg class="replay-icon" viewBox="0 0 16 16" fill="none" aria-hidden="true">
            <path d="M3.2 5.4A6 6 0 1 1 2.4 9" stroke="currentColor" stroke-width="1.5" stroke-linecap="round"/>
            <path d="M3.4 1.9v3.9h3.9" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
          </svg>
        </button>
      </div>
    </section>

    <section class="panel metrics-panel" aria-label="运行指标">
      <div class="panel-head">
        <div>
          <div class="eyebrow">METRICS</div>
          <h2>运行指标</h2>
          <p class="panel-sub">等待与乘梯时间以秒计,运行层数为全部轿厢累计移动距离。</p>
        </div>
        <div class="metric-algo" id="metricAlgo">NEAREST · 最近空闲</div>
      </div>
      <div class="metrics-grid">
        <div class="metric primary">
          <span class="metric-label">平均等待</span>
          <div class="metric-num"><strong id="m-avgWait">--</strong><em>s</em></div>
        </div>
        <div class="metric">
          <span class="metric-label">P95 等待</span>
          <div class="metric-num"><strong id="m-p95Wait">--</strong><em>s</em></div>
        </div>
        <div class="metric">
          <span class="metric-label">最长等待</span>
          <div class="metric-num"><strong id="m-maxWait">--</strong><em>s</em></div>
        </div>
        <div class="metric">
          <span class="metric-label">平均乘梯</span>
          <div class="metric-num"><strong id="m-avgRide">--</strong><em>s</em></div>
        </div>
        <div class="metric">
          <span class="metric-label">总运行层数</span>
          <div class="metric-num"><strong id="m-totalFloors">--</strong><em>层</em></div>
        </div>
        <div class="metric">
          <span class="metric-label">停靠次数</span>
          <div class="metric-num"><strong id="m-stops">--</strong><em>次</em></div>
        </div>
        <div class="metric">
          <span class="metric-label">送达人数</span>
          <div class="metric-num"><strong id="m-delivered">--</strong><em>人</em></div>
        </div>
      </div>
    </section>

    <section class="panel" id="comparePanel" aria-label="算法对比表格" hidden>
      <div class="panel-head">
        <div>
          <div class="eyebrow">A / B COMPARISON</div>
          <h2>并排对比</h2>
          <p class="panel-sub">同一 seed、同一客流;绿色标记为该列最优值。</p>
        </div>
        <div class="metric-algo" id="compareHint">--</div>
      </div>
      <div class="table-wrap">
        <table>
          <thead>
            <tr>
              <th scope="col">算法</th>
              <th scope="col">平均等待</th>
              <th scope="col">P95 等待</th>
              <th scope="col">最长等待</th>
              <th scope="col">平均乘梯</th>
              <th scope="col">总运行层数</th>
              <th scope="col">停靠次数</th>
              <th scope="col">送达人数</th>
              <th scope="col">未完成</th>
            </tr>
          </thead>
          <tbody id="compareBody"></tbody>
        </table>
      </div>
      <div class="compare-note">等待类指标越低越好;总运行层数反映空驶代价,停靠次数反映启停开销。</div>
    </section>

    <section class="panel" aria-label="自检断言">
      <div class="panel-head">
        <div>
          <div class="eyebrow">SELF-CHECK</div>
          <h2>自检断言</h2>
          <p class="panel-sub">每次点击都会在浏览器内重跑确定性仿真,核对队列、方向、指标与输入校验。</p>
        </div>
        <div class="selfcheck-summary" id="selfcheckSummary">
          <span class="badge run">等待运行</span>
          <span class="summary-note">21 项不变量</span>
        </div>
      </div>
      <div class="assert-grid" id="assertGrid"></div>
      <div class="selfcheck-tail">
        <span>同 seed 重跑结果逐位一致;四部策略共用同一请求流。</span>
        <code>window.__elevatorLab = { run, selfTest, scenarios }</code>
      </div>
    </section>
  </main>

  <footer>
    <span>纯前端 · Canvas 2D · 无外部依赖 · 无网络请求</span>
    <code>run({ scenario, arrivalRate, duration, seed, algorithm })</code>
  </footer>
</div>

<div class="alert" id="alert" role="alert" aria-live="assertive">
  <span class="alert-icon">!</span>
  <span id="alertText"></span>
</div>

<script>
(function () {
  'use strict';

  
  const VERSION = '1.0.0';
  const FLOORS = 12;
  const ELEVATOR_COUNT = 3;
  const CAPACITY = 12;
  const SPEED = 1.15;
  const DT = 0.1;
  const DOOR_BASE = 1.25;
  const DOOR_PER_PAX = 0.09;
  const SAMPLE_INTERVAL = 0.2;
  const MAX_CLEAR_SECONDS = 900;
  const ELEVATOR_START = [1, 6, 12];
  const FLOOR_MIN = 1;
  const FLOOR_MAX = FLOORS;
  const SEED_MAX = 2147483647;

  const ALGORITHMS = {
    NEAREST: { id: 'NEAREST', name: 'NEAREST', cn: '最近空闲', color: '#3ddc97', desc: '只挑最近的空闲轿厢,繁忙时退化为最短预计到达。' },
    FCFS:    { id: 'FCFS',    name: 'FCFS',    cn: '先来先服务', color: '#4cb3ff', desc: '按请求到达顺序派车,优先任务最少的轿厢。' },
    SCAN:    { id: 'SCAN',    name: 'SCAN',    cn: '电梯式扫描', color: '#f2b544', desc: '沿当前方向运行到端点再折返,途中响应请求。' },
    LOOK:    { id: 'LOOK',    name: 'LOOK',    cn: '到顶即返',   color: '#ff8a5c', desc: '到达该方向最远请求后立即折返,不空驶到端点。' }
  };
  const ALGO_ORDER = ['NEAREST', 'FCFS', 'SCAN', 'LOOK'];

  const SCENARIOS = {
    morning: {
      id: 'morning', name: '早高峰上行', short: '早高峰',
      desc: '约 85% 的乘客从 1 层出发,前往 2 – 12 层。'
    },
    noon: {
      id: 'noon', name: '午间双向', short: '午间',
      desc: '低区与高区之间双向交换客流,上下行各约一半。'
    },
    random: {
      id: 'random', name: '随机到站', short: '随机',
      desc: '起终点在全楼随机产生,方向自然混合。'
    }
  };

  const ELEVATOR_COLORS = ['#5fe3b0', '#5fb9ff', '#f4c15d'];

  
  function round3(n) { return Math.round(n * 1000) / 1000; }
  function clamp(n, lo, hi) { return Math.min(hi, Math.max(lo, n)); }
  function mean(list) {
    if (!list.length) return 0;
    let sum = 0;
    for (let i = 0; i < list.length; i++) sum += list[i];
    return sum / list.length;
  }
  function percentile(sorted, p) {
    if (!sorted.length) return 0;
    const idx = Math.min(sorted.length - 1, Math.max(0, Math.ceil(p * sorted.length) - 1));
    return sorted[idx];
  }
  function mulberry32(seed) {
    let a = seed >>> 0;
    return function () {
      a |= 0;
      a = (a + 0x6D2B79F5) | 0;
      let t = Math.imul(a ^ (a >>> 15), 1 | a);
      t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
      return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
    };
  }
  function randInt(rng, min, max) {
    return min + Math.floor(rng() * (max - min + 1));
  }
  function hexA(hex, alpha) {
    const n = parseInt(hex.slice(1), 16);
    return 'rgba(' + ((n >> 16) & 255) + ',' + ((n >> 8) & 255) + ',' + (n & 255) + ',' + alpha + ')';
  }

  function validateFloor(value, label) {
    const n = Number(value);
    const name = label || '楼层';
    if (!Number.isInteger(n) || n < FLOOR_MIN || n > FLOOR_MAX) {
      throw new Error(name + '必须是 ' + FLOOR_MIN + '~' + FLOOR_MAX + ' 的整数,收到「' + String(value) + '」');
    }
    return n;
  }

  function normalizeOptions(raw) {
    const o = (raw && typeof raw === 'object') ? raw : {};
    const scenario = o.scenario == null ? 'morning' : String(o.scenario);
    if (!SCENARIOS[scenario]) {
      throw new Error('未知客流场景「' + scenario + '」,可选:' + Object.keys(SCENARIOS).join('、'));
    }
    const algorithm = o.algorithm == null ? 'NEAREST' : String(o.algorithm);
    if (!ALGORITHMS[algorithm]) {
      throw new Error('未知调度算法「' + algorithm + '」,可选:' + ALGO_ORDER.join('、'));
    }
    const arrivalRate = Number(o.arrivalRate == null ? 12 : o.arrivalRate);
    if (!Number.isFinite(arrivalRate) || arrivalRate < 2 || arrivalRate > 30) {
      throw new Error('到达率必须在 2~30 人/分钟之间,收到「' + String(o.arrivalRate) + '」');
    }
    const duration = Number(o.duration == null ? 120 : o.duration);
    if (!Number.isFinite(duration) || duration < 60 || duration > 600) {
      throw new Error('仿真时长必须在 60~600 秒之间,收到「' + String(o.duration) + '」');
    }
    const seed = Number(o.seed == null ? 20261108 : o.seed);
    if (!Number.isInteger(seed) || seed < 0 || seed > SEED_MAX) {
      throw new Error('随机种子必须是 0~' + SEED_MAX + ' 的整数,收到「' + String(o.seed) + '」');
    }
    const manualSource = Array.isArray(o.manualRequests) ? o.manualRequests : [];
    const manualRequests = manualSource.map(function (m, i) {
      const item = (m && typeof m === 'object') ? m : {};
      const from = validateFloor(item.from, '手动请求 #' + (i + 1) + ' 的起点楼层');
      const to = validateFloor(item.to, '手动请求 #' + (i + 1) + ' 的终点楼层');
      if (from === to) {
        throw new Error('手动请求 #' + (i + 1) + ' 的起点与终点不能相同(均为 ' + from + ' 层)');
      }
      const time = Number(item.time == null ? 1 : item.time);
      if (!Number.isFinite(time) || time < 0 || time > duration) {
        throw new Error('手动请求 #' + (i + 1) + ' 的到达时间必须在 0~' + duration + ' 秒之间');
      }
      return { from: from, to: to, time: time, dir: to > from ? 1 : -1 };
    });
    return {
      scenario: scenario,
      algorithm: algorithm,
      arrivalRate: arrivalRate,
      duration: duration,
      seed: seed,
      manualRequests: manualRequests
    };
  }

  
  function pickOD(rng, scenario) {
    if (scenario === 'morning') {
      if (rng() < 0.85) {
        return { from: 1, to: randInt(rng, 2, FLOORS) };
      }
      let from = randInt(rng, 1, FLOORS);
      let to = randInt(rng, 1, FLOORS);
      while (to === from) to = randInt(rng, 1, FLOORS);
      return { from: from, to: to };
    }
    if (scenario === 'noon') {
      if (rng() < 0.5) {
        return { from: randInt(rng, 1, 6), to: randInt(rng, 7, 12) };
      }
      return { from: randInt(rng, 7, 12), to: randInt(rng, 1, 6) };
    }
    const from = randInt(rng, 1, FLOORS);
    let to = randInt(rng, 1, FLOORS);
    while (to === from) to = randInt(rng, 1, FLOORS);
    return { from: from, to: to };
  }

  function generatePassengers(opts) {
    const rng = mulberry32(opts.seed);
    const list = [];
    const ratePerSecond = opts.arrivalRate / 60;
    let t = round3(0.15 + rng() * 0.35);
    let id = 0;
    while (true) {
      const gap = -Math.log(1 - rng() * 0.999999) / ratePerSecond;
      t = round3(t + gap);
      if (t >= opts.duration - 1e-9) break;
      const od = pickOD(rng, opts.scenario);
      list.push({
        id: id++,
        arriveTime: t,
        from: od.from,
        to: od.to,
        dir: od.to > od.from ? 1 : -1,
        status: 'waiting',
        assignedElevator: null,
        assignedCallKey: null,
        boardTime: null,
        doneTime: null,
        wait: null,
        ride: null,
        elevator: null
      });
    }
    for (let i = 0; i < opts.manualRequests.length; i++) {
      const m = opts.manualRequests[i];
      list.push({
        id: id++,
        arriveTime: round3(Math.min(m.time, Math.max(0, opts.duration - 0.2))),
        from: m.from,
        to: m.to,
        dir: m.dir,
        status: 'waiting',
        assignedElevator: null,
        assignedCallKey: null,
        boardTime: null,
        doneTime: null,
        wait: null,
        ride: null,
        elevator: null
      });
    }
    list.sort(function (a, b) {
      return a.arriveTime - b.arriveTime || a.id - b.id;
    });
    list.forEach(function (p, i) { p.id = i; });
    return list;
  }

  
  class Simulation {
    constructor(opts) {
      this.opts = opts;
      this.t = 0;
      this.tick = 0;
      this.finished = false;
      this.passengers = [];
      this.byId = new Map();
      this.waiting = [];
      this.nextRequestIndex = 0;
      this.tracks = [];
      this.dispatchLog = [];
      this.directionEvents = [];
      this.stopLog = [];
      this.doneCount = 0;
      this.nextSampleAt = 0;
      this.violations = {
        duplicateDispatch: [],
        scanReverse: [],
        lookReverse: []
      };
      this.callOwners = new Map();
      this.elevators = ELEVATOR_START.map((start, i) => ({
        id: i,
        name: 'ABC'[i],
        pos: start,
        dir: 0,
        state: 'idle',
        doorTimer: 0,
        loads: [],
        carCalls: new Set(),
        carCallAge: new Map(),
        calls: new Map(),
        stops: 0,
        distance: 0,
        riders: 0
      }));
    }

    execute() {
      this.passengers = generatePassengers(this.opts);
      this.byId = new Map(this.passengers.map(function (p, i) { return [i, p]; }));
      const duration = this.opts.duration;
      const hardStop = duration + MAX_CLEAR_SECONDS;

      this.sample(true);

      while (this.t <= hardStop + 1e-9) {
        while (
          this.nextRequestIndex < this.passengers.length &&
          this.passengers[this.nextRequestIndex].arriveTime <= this.t + 1e-9
        ) {
          this.waiting.push(this.passengers[this.nextRequestIndex]);
          this.nextRequestIndex++;
        }

        this.dispatchPending();
        this.updateElevators(DT);

        this.t = round3(this.t + DT);
        this.tick++;
        this.sample(false);

        if (this.t >= duration - 1e-9) {
          const drained = this.elevators.every(function (e) {
            return e.state === 'idle' && e.loads.length === 0 && e.calls.size === 0 && e.carCalls.size === 0;
          });
          if (
            drained &&
            this.nextRequestIndex >= this.passengers.length &&
            this.waiting.length === 0
          ) {
            this.finished = true;
            break;
          }
        }

        if (this.t >= hardStop) break;
      }

      this.sample(true);
      return this.buildResult();
    }

    collectStops(e) {
      const set = new Set();
      for (const call of e.calls.values()) set.add(call.floor);
      for (const floor of e.carCalls) set.add(floor);
      return Array.from(set).sort(function (a, b) { return a - b; });
    }

    findCallOwner(key) {
      let found = null;
      for (let i = 0; i < this.elevators.length; i++) {
        const e = this.elevators[i];
        if (e.calls.has(key)) {
          if (found && found.id !== e.id) {
            this.violations.duplicateDispatch.push({
              t: this.t, key: key, previous: found.id, next: e.id
            });
          }
          if (!found) found = e;
        }
      }
      return found;
    }

    findCall(key) {
      if (key == null) return null;
      for (let i = 0; i < this.elevators.length; i++) {
        const call = this.elevators[i].calls.get(key);
        if (call) return call;
      }
      return null;
    }

    estimateArrival(e, floor, dir) {
      const loadPenalty = (e.calls.size + e.carCalls.size) * 0.55 + e.loads.length * 0.09;
      let distance;
      if (e.state === 'idle' || e.dir === 0) {
        distance = Math.abs(e.pos - floor);
      } else if (e.dir > 0) {
        distance = floor >= e.pos
          ? floor - e.pos
          : (FLOORS - e.pos) + (FLOORS - floor);
      } else {
        distance = floor <= e.pos
          ? e.pos - floor
          : (e.pos - 1) + (floor - 1);
      }
      let eta = distance / SPEED + DOOR_BASE + loadPenalty;
      if (e.dir === dir && ((e.dir > 0 && floor >= e.pos) || (e.dir < 0 && floor <= e.pos))) {
        eta *= 0.82;
      }
      return eta;
    }

    chooseElevator(floor, dir) {
      const candidates = this.elevators.filter(function (e) { return e.loads.length < CAPACITY; });
      if (!candidates.length) return null;
      const algo = this.opts.algorithm;
      const self = this;

      if (algo === 'NEAREST') {
        const idle = candidates.filter(function (e) {
          return e.state === 'idle' && e.dir === 0 && e.calls.size === 0 && e.carCalls.size === 0;
        });
        if (idle.length) {
          return idle.reduce(function (best, e) {
            const d = Math.abs(e.pos - floor);
            const bd = Math.abs(best.pos - floor);
            if (d !== bd) return d < bd ? e : best;
            return e.id < best.id ? e : best;
          });
        }
      }

      const score = function (e) {
        const eta = self.estimateArrival(e, floor, dir);
        if (algo === 'FCFS') {
          return (e.calls.size + e.carCalls.size + e.loads.length / CAPACITY) * 100 + eta;
        }
        if (algo === 'NEAREST') return eta * 100 + e.id * 0.001;
        return eta;
      };

      return candidates.reduce(function (best, e) {
        return score(e) < score(best) ? e : best;
      });
    }

    dispatchPending() {
      if (!this.waiting.length) return;
      const groups = new Map();
      for (let i = 0; i < this.waiting.length; i++) {
        const p = this.waiting[i];
        if (p.assignedElevator !== null) {
          if (this.findCall(p.assignedCallKey)) continue;
          p.assignedElevator = null;
          p.assignedCallKey = null;
        }
        const key = p.from + ':' + p.dir;
        let list = groups.get(key);
        if (!list) {
          list = [];
          groups.set(key, list);
        }
        list.push(p);
      }
      if (!groups.size) return;

      const ordered = Array.from(groups.entries()).sort(function (a, b) {
        let ta = Infinity, tb = Infinity;
        for (let i = 0; i < a[1].length; i++) if (a[1][i].arriveTime < ta) ta = a[1][i].arriveTime;
        for (let i = 0; i < b[1].length; i++) if (b[1][i].arriveTime < tb) tb = b[1][i].arriveTime;
        return ta - tb || a[0].localeCompare(b[0]);
      });

      for (let g = 0; g < ordered.length; g++) {
        const key = ordered[g][0];
        const list = ordered[g][1];
        const owner = this.findCallOwner(key);
        if (owner) {
          const call = owner.calls.get(key);
          for (let i = 0; i < list.length; i++) {
            list[i].assignedElevator = owner.id;
            list[i].assignedCallKey = key;
            call.passengers.add(list[i].id);
          }
          continue;
        }

        const parts = key.split(':');
        const floor = Number(parts[0]);
        const dir = Number(parts[1]);
        const chosen = this.chooseElevator(floor, dir);
        if (!chosen) continue;

        if (this.callOwners.has(key) && this.callOwners.get(key) !== chosen.id) {
          this.violations.duplicateDispatch.push({
            t: this.t, key: key, previous: this.callOwners.get(key), next: chosen.id
          });
        }

        const call = { key: key, floor: floor, dir: dir, passengers: new Set(), createdAt: this.t };
        for (let i = 0; i < list.length; i++) {
          list[i].assignedElevator = chosen.id;
          list[i].assignedCallKey = key;
          call.passengers.add(list[i].id);
        }
        chosen.calls.set(key, call);
        this.callOwners.set(key, chosen.id);
        this.dispatchLog.push({
          t: this.t,
          floor: floor,
          dir: dir,
          elevator: chosen.id,
          count: list.length,
          passengers: list.map(function (p) { return p.id; }),
          key: key
        });
      }
    }

    setDirection(e, nextDir, reason) {
      if (e.dir === nextDir) return;
      const from = e.dir;
      e.dir = nextDir;
      if (from !== 0 && nextDir !== 0 && from === -nextDir) {
        const event = {
          t: this.t,
          elevator: e.id,
          from: from,
          to: nextDir,
          pos: round3(e.pos),
          reason: reason
        };
        this.directionEvents.push(event);
        if (this.opts.algorithm === 'SCAN') {
          const atEnd = (from > 0 && Math.abs(e.pos - FLOORS) < 1e-6) ||
                        (from < 0 && Math.abs(e.pos - 1) < 1e-6);
          if (!atEnd) this.violations.scanReverse.push(event);
        }
        if (this.opts.algorithm === 'LOOK') {
          const stops = this.collectStops(e);
          const ahead = stops.filter(function (f) {
            return from > 0 ? f > e.pos + 1e-6 : f < e.pos - 1e-6;
          });
          if (ahead.length) {
            this.violations.lookReverse.push({ event: event, ahead: ahead });
          }
        }
      }
    }

    openDoors(e, floor) {
      e.pos = floor;
      e.state = 'doors';
      e.stops++;
      this.stopLog.push({ t: this.t, elevator: e.id, floor: floor });

      let boarded = 0;
      let alighted = 0;

      for (let i = e.loads.length - 1; i >= 0; i--) {
        const p = e.loads[i];
        if (p.to === floor) {
          e.loads.splice(i, 1);
          p.status = 'done';
          p.doneTime = this.t;
          p.ride = Math.max(0, round3(this.t - p.boardTime));
          this.doneCount++;
          alighted++;
        }
      }
      e.carCalls.delete(floor);
      e.carCallAge.delete(floor);

      const here = this.waiting.filter(function (p) {
        return p.status === 'waiting' && p.assignedElevator === e.id && p.from === floor;
      });
      here.sort(function (a, b) { return a.arriveTime - b.arriveTime || a.id - b.id; });
      for (let i = 0; i < here.length; i++) {
        const p = here[i];
        if (e.loads.length >= CAPACITY) break;
        p.status = 'riding';
        p.boardTime = this.t;
        p.wait = Math.max(0, round3(this.t - p.arriveTime));
        p.elevator = e.id;
        e.loads.push(p);
        if (!e.carCallAge.has(p.to)) e.carCallAge.set(p.to, this.t);
        e.carCalls.add(p.to);
        e.riders++;
        const wi = this.waiting.indexOf(p);
        if (wi >= 0) this.waiting.splice(wi, 1);
        boarded++;
      }

      const consumed = Array.from(e.calls.entries());
      for (let i = 0; i < consumed.length; i++) {
        const key = consumed[i][0];
        const call = consumed[i][1];
        if (call.floor !== floor) continue;
        const ids = Array.from(call.passengers);
        for (let j = 0; j < ids.length; j++) {
          const p = this.byId.get(ids[j]);
          if (p && p.status === 'waiting') {
            p.assignedElevator = null;
            p.assignedCallKey = null;
          }
        }
        e.calls.delete(key);
        this.callOwners.delete(key);
      }

      e.doorTimer = round3(DOOR_BASE + (boarded + alighted) * DOOR_PER_PAX);
    }

    updateElevators(dt) {
      for (let i = 0; i < this.elevators.length; i++) {
        this.updateElevator(this.elevators[i], dt);
      }
    }

    updateFcfsElevator(e, dt) {
      const stops = this.collectStops(e);
      const here = Math.round(e.pos);
      const atFloor = Math.abs(e.pos - here) < 1e-6;

      if (atFloor && stops.indexOf(here) !== -1) {
        this.openDoors(e, here);
        return;
      }
      if (!stops.length) {
        e.state = 'idle';
        this.setDirection(e, 0, 'fcfs-clear');
        return;
      }

      let target = stops[0];
      let bestAge = Infinity;
      for (let i = 0; i < stops.length; i++) {
        const f = stops[i];
        let age = Infinity;
        for (const call of e.calls.values()) {
          if (call.floor === f && call.createdAt < age) age = call.createdAt;
        }
        if (e.carCallAge.has(f) && e.carCallAge.get(f) < age) age = e.carCallAge.get(f);
        if (age < bestAge) {
          bestAge = age;
          target = f;
        }
      }

      if (Math.abs(target - e.pos) < 1e-9) {
        this.openDoors(e, target);
        return;
      }

      const dir = target > e.pos ? 1 : -1;
      this.setDirection(e, dir, 'fcfs-target');
      e.state = 'moving';

      const step = SPEED * dt;
      const nextPos = e.pos + dir * step;
      const reached = dir > 0 ? nextPos >= target - 1e-9 : nextPos <= target + 1e-9;
      if (reached) {
        e.distance = round3(e.distance + Math.abs(target - e.pos));
        e.pos = target;
        this.openDoors(e, target);
      } else {
        e.distance = round3(e.distance + Math.abs(nextPos - e.pos));
        e.pos = round3(nextPos);
      }
    }

    updateElevator(e, dt) {
      if (e.state === 'doors') {
        e.doorTimer = round3(e.doorTimer - dt);
        if (e.doorTimer <= 1e-9) {
          e.doorTimer = 0;
          e.state = 'idle';
        }
        return;
      }

      if (this.opts.algorithm === 'FCFS') {
        this.updateFcfsElevator(e, dt);
        return;
      }

      const stops = this.collectStops(e);
      const here = Math.round(e.pos);
      const atFloor = Math.abs(e.pos - here) < 1e-6;

      if (e.state === 'idle') {
        if (atFloor && stops.indexOf(here) !== -1) {
          this.openDoors(e, here);
          return;
        }
        if (!stops.length) {
          this.setDirection(e, 0, 'no-demand');
          return;
        }
        if (e.dir === 0) {
          let nearest = stops[0];
          for (let i = 1; i < stops.length; i++) {
            if (Math.abs(stops[i] - e.pos) < Math.abs(nearest - e.pos)) nearest = stops[i];
          }
          this.setDirection(e, nearest > e.pos ? 1 : -1, 'pick-nearest');
        }
        const aheadIdle = stops.filter(function (f) {
          return e.dir > 0 ? f > e.pos + 1e-6 : f < e.pos - 1e-6;
        });
        if (!aheadIdle.length) {
          if (this.opts.algorithm !== 'SCAN') {
            const behind = stops.filter(function (f) {
              return e.dir > 0 ? f < e.pos - 1e-6 : f > e.pos + 1e-6;
            });
            if (behind.length) {
              this.setDirection(e, -e.dir, 'look-reverse-idle');
            } else {
              this.setDirection(e, 0, 'no-demand');
              return;
            }
          }
        }
        e.state = 'moving';
      }

      if (e.dir === 0) {
        e.state = 'idle';
        return;
      }

      const dir = e.dir;
      const ahead = stops.filter(function (f) {
        return dir > 0 ? f > e.pos + 1e-6 : f < e.pos - 1e-6;
      });

      let target;
      let endpointRun = false;
      if (ahead.length) {
        target = dir > 0 ? ahead[0] : ahead[ahead.length - 1];
      } else if (this.opts.algorithm === 'SCAN') {
        target = dir > 0 ? FLOORS : 1;
        endpointRun = true;
      } else {
        const behind = stops.filter(function (f) {
          return dir > 0 ? f < e.pos - 1e-6 : f > e.pos + 1e-6;
        });
        if (!behind.length) {
          e.state = 'idle';
          this.setDirection(e, 0, 'clear');
          return;
        }
        this.setDirection(e, -dir, 'reverse');
        return;
      }

      const step = SPEED * dt;
      const nextPos = e.pos + dir * step;
      const reached = dir > 0 ? nextPos >= target - 1e-9 : nextPos <= target + 1e-9;

      if (reached) {
        e.distance = round3(e.distance + Math.abs(target - e.pos));
        e.pos = target;
        if (!endpointRun) {
          this.openDoors(e, target);
        } else {
          const remaining = this.collectStops(e);
          if (!remaining.length) {
            e.state = 'idle';
            this.setDirection(e, 0, 'end-clear');
          } else {
            this.setDirection(e, -dir, 'scan-end');
            e.state = 'moving';
          }
        }
      } else {
        e.distance = round3(e.distance + Math.abs(nextPos - e.pos));
        e.pos = round3(nextPos);
      }
    }

    sample(force) {
      if (!force && this.t + 1e-9 < this.nextSampleAt) return;
      const grid = [];
      for (let i = 0; i <= FLOORS; i++) grid.push([0, 0]);
      for (let i = 0; i < this.waiting.length; i++) {
        const p = this.waiting[i];
        if (p.dir > 0) grid[p.from][0]++;
        else grid[p.from][1]++;
      }
      this.tracks.push({
        t: this.t,
        waiting: this.waiting.length,
        done: this.doneCount,
        grid: grid,
        elevators: this.elevators.map(function (e) {
          return {
            pos: round3(e.pos),
            dir: e.dir,
            state: e.state,
            load: e.loads.length,
            calls: Array.from(new Set(Array.from(e.calls.values()).map(function (c) { return c.floor; })))
          };
        })
      });
      this.nextSampleAt = round3(this.t + SAMPLE_INTERVAL);
    }

    buildResult() {
      const done = this.passengers.filter(function (p) { return p.status === 'done'; });
      const waits = done
        .map(function (p) { return Math.max(0, p.wait == null ? 0 : p.wait); })
        .sort(function (a, b) { return a - b; });
      const rides = done.map(function (p) {
        return Math.max(0, p.ride == null ? 0 : p.ride);
      });
      const avgWait = mean(waits);
      const p95Wait = percentile(waits, 0.95);
      const maxWait = waits.length ? waits[waits.length - 1] : 0;
      const avgRide = mean(rides);
      const totalFloors = round3(this.elevators.reduce(function (s, e) { return s + e.distance; }, 0));
      const stops = this.elevators.reduce(function (s, e) { return s + e.stops; }, 0);
      const generated = this.passengers.length;
      const delivered = done.length;

      return {
        ok: true,
        version: VERSION,
        algo: ALGORITHMS[this.opts.algorithm],
        options: {
          scenario: this.opts.scenario,
          algorithm: this.opts.algorithm,
          arrivalRate: this.opts.arrivalRate,
          duration: this.opts.duration,
          seed: this.opts.seed,
          manualRequests: this.opts.manualRequests.slice()
        },
        metrics: {
          avgWait: avgWait,
          p95Wait: p95Wait,
          maxWait: maxWait,
          avgRide: avgRide,
          totalFloors: totalFloors,
          stops: stops,
          delivered: delivered,
          generated: generated,
          unfinished: generated - delivered
        },
        passengers: this.passengers.map(function (p) {
          return {
            id: p.id,
            arriveTime: p.arriveTime,
            from: p.from,
            to: p.to,
            dir: p.dir,
            status: p.status,
            boardTime: p.boardTime,
            doneTime: p.doneTime,
            wait: p.wait,
            ride: p.ride,
            elevator: p.elevator
          };
        }),
        tracks: this.tracks,
        dispatch: this.dispatchLog,
        directionEvents: this.directionEvents,
        stopLog: this.stopLog,
        violations: this.violations,
        simTime: this.t,
        finished: this.finished,
        generated: generated
      };
    }
  }

  function run(rawOpts) {
    const opts = normalizeOptions(rawOpts);
    const sim = new Simulation(opts);
    return sim.execute();
  }

  
  function selfTest() {
    const results = [];
    function check(name, fn) {
      let pass = false;
      let detail = '';
      try {
        const r = fn();
        if (r && typeof r === 'object') {
          pass = !!r.pass;
          detail = r.detail || '';
        } else {
          pass = !!r;
        }
      } catch (err) {
        pass = false;
        detail = '异常:' + (err && err.message ? err.message : String(err));
      }
      results.push({ name: name, pass: pass, detail: detail });
    }

    const base = { scenario: 'morning', arrivalRate: 12, duration: 90, seed: 20261108 };

    let nearest, nearestAgain, fcfs, scan, look, noon, randomCase;
    try {
      nearest = run(Object.assign({}, base, { algorithm: 'NEAREST' }));
      nearestAgain = run(Object.assign({}, base, { algorithm: 'NEAREST' }));
      fcfs = run(Object.assign({}, base, { algorithm: 'FCFS' }));
      scan = run(Object.assign({}, base, { algorithm: 'SCAN' }));
      look = run(Object.assign({}, base, { algorithm: 'LOOK' }));
      noon = run(Object.assign({}, base, { scenario: 'noon', algorithm: 'FCFS' }));
      randomCase = run(Object.assign({}, base, { scenario: 'random', algorithm: 'LOOK' }));
    } catch (err) {
      return {
        total: 1,
        passed: 0,
        failed: 1,
        results: [{ name: '基础仿真可执行', pass: false, detail: '异常:' + err.message }]
      };
    }

    check('同 seed 重跑结果一致', function () {
      const metricsSame = JSON.stringify(nearest.metrics) === JSON.stringify(nearestAgain.metrics);
      const paxSame = nearest.passengers.length === nearestAgain.passengers.length &&
        nearest.passengers.every(function (p, i) {
          const q = nearestAgain.passengers[i];
          return p.arriveTime === q.arriveTime && p.doneTime === q.doneTime && p.elevator === q.elevator;
        });
      return {
        pass: metricsSame && paxSame,
        detail: '两次均送达 ' + nearest.metrics.delivered + ' 人,指标与完成时刻逐项一致'
      };
    });

    check('指标全部为有限数值', function () {
      const keys = ['avgWait', 'p95Wait', 'maxWait', 'avgRide', 'totalFloors', 'stops', 'delivered'];
      const bad = keys.filter(function (k) {
        return !Number.isFinite(nearest.metrics[k]) || nearest.metrics[k] < 0;
      });
      return {
        pass: bad.length === 0,
        detail: bad.length ? '异常字段:' + bad.join('、') : '7 项指标均为有限非负数'
      };
    });

    check('结束时候梯队列清空', function () {
      const last = nearest.tracks[nearest.tracks.length - 1];
      return {
        pass: !!last && last.waiting === 0 && nearest.metrics.unfinished === 0,
        detail: '末帧等待 ' + (last ? last.waiting : '?') + ' 人,未完成 ' + nearest.metrics.unfinished + ' 人'
      };
    });

    check('送达守恒:送达 + 未完成 = 生成', function () {
      const total = nearest.metrics.delivered + nearest.metrics.unfinished;
      return {
        pass: total === nearest.metrics.generated,
        detail: total + ' = ' + nearest.metrics.delivered + ' + ' + nearest.metrics.unfinished
      };
    });

    check('同层同向请求不重复派车', function () {
      const slots = new Map();
      let duplicated = 0;
      for (let i = 0; i < nearest.dispatch.length; i++) {
        const d = nearest.dispatch[i];
        const key = d.t + '|' + d.floor + '|' + d.dir;
        if (slots.has(key) && slots.get(key) !== d.elevator) duplicated++;
        slots.set(key, d.elevator);
      }
      const runtime = nearest.violations.duplicateDispatch.length;
      return {
        pass: duplicated === 0 && runtime === 0,
        detail: nearest.dispatch.length + ' 条派车记录,重复 ' + (duplicated + runtime) + ' 次'
      };
    });

    check('SCAN 方向不在中途反折', function () {
      const bad = scan.violations.scanReverse.length;
      const turns = scan.directionEvents.length;
      return {
        pass: bad === 0,
        detail: '记录到 ' + turns + ' 次折返,违规 ' + bad + ' 次(只允许在 12 / 1 层)'
      };
    });

    check('LOOK 到达该方向最远请求即返', function () {
      const bad = look.violations.lookReverse.length;
      return {
        pass: bad === 0,
        detail: '反向 ' + look.directionEvents.length + ' 次,越过未服务请求 ' + bad + ' 次'
      };
    });

    check('乘客起终点均在 1~12 层且不同层', function () {
      const bad = nearest.passengers.filter(function (p) {
        return p.from < 1 || p.from > 12 || p.to < 1 || p.to > 12 || p.from === p.to;
      });
      return {
        pass: bad.length === 0,
        detail: '检查 ' + nearest.passengers.length + ' 名乘客,非法 ' + bad.length + ' 条'
      };
    });

    check('等待时间非负', function () {
      const done = nearest.passengers.filter(function (p) { return p.status === 'done'; });
      const bad = done.filter(function (p) { return typeof p.wait !== 'number' || p.wait < 0; });
      return {
        pass: bad.length === 0,
        detail: '已送达 ' + done.length + ' 人,负等待 ' + bad.length + ' 人'
      };
    });

    check('乘梯时间严格大于 0', function () {
      const done = nearest.passengers.filter(function (p) { return p.status === 'done'; });
      const bad = done.filter(function (p) { return typeof p.ride !== 'number' || p.ride <= 0; });
      return {
        pass: bad.length === 0,
        detail: '最短乘梯 ' + (done.length ? Math.min.apply(null, done.map(function (p) { return p.ride; })).toFixed(2) : '0.00') + ' 秒'
      };
    });

    check('统计量自洽:均值 ≤ P95 ≤ 最长', function () {
      const m = nearest.metrics;
      const tol = 1e-9;
      return {
        pass: m.avgWait <= m.maxWait + tol && m.p95Wait <= m.maxWait + tol && m.maxWait >= 0,
        detail: '平均 ' + m.avgWait.toFixed(2) + 's ≤ P95 ' + m.p95Wait.toFixed(2) + 's ≤ 最长 ' + m.maxWait.toFixed(2) + 's'
      };
    });

    check('轿厢载客数不超过容量 12', function () {
      let bad = 0;
      let maxLoad = 0;
      for (let i = 0; i < nearest.tracks.length; i++) {
        const evs = nearest.tracks[i].elevators;
        for (let j = 0; j < evs.length; j++) {
          if (evs[j].load > CAPACITY || evs[j].load < 0) bad++;
          if (evs[j].load > maxLoad) maxLoad = evs[j].load;
        }
      }
      return {
        pass: bad === 0,
        detail: '轨迹峰值载客 ' + maxLoad + ' 人,超载帧 ' + bad + ' 帧'
      };
    });

    check('轿厢位置始终在 1~12 层', function () {
      let bad = 0;
      for (let i = 0; i < nearest.tracks.length; i++) {
        const evs = nearest.tracks[i].elevators;
        for (let j = 0; j < evs.length; j++) {
          if (evs[j].pos < 1 - 1e-6 || evs[j].pos > 12 + 1e-6) bad++;
        }
      }
      return {
        pass: bad === 0,
        detail: '检查 ' + nearest.tracks.length + ' 帧轨迹,越界 ' + bad + ' 次'
      };
    });

    check('完成乘客均有轿厢与时间戳', function () {
      const done = nearest.passengers.filter(function (p) { return p.status === 'done'; });
      const bad = done.filter(function (p) {
        return p.elevator === null || p.boardTime === null || p.doneTime === null ||
               p.doneTime < p.boardTime;
      });
      return {
        pass: bad.length === 0,
        detail: '已送达 ' + done.length + ' 人,信息缺失 ' + bad.length + ' 人'
      };
    });

    check('请求生成量与到达率相符', function () {
      const expected = base.arrivalRate / 60 * base.duration;
      const low = Math.floor(expected * 0.45);
      const high = Math.ceil(expected * 2.0);
      const n = nearest.metrics.generated;
      return {
        pass: n >= low && n <= high,
        detail: n + ' 人(期望约 ' + expected.toFixed(0) + ' 人,合理区间 ' + low + '~' + high + ')'
      };
    });

    check('非法到达率被中文拒绝', function () {
      let message = '';
      try {
        run(Object.assign({}, base, { algorithm: 'NEAREST', arrivalRate: 31 }));
      } catch (err) {
        message = err.message;
      }
      return {
        pass: message.indexOf('到达率') !== -1 && message.indexOf('2~30') !== -1,
        detail: message || '未抛出错误'
      };
    });

    check('非法楼层 13 / 0 被中文拒绝', function () {
      let message = '';
      try {
        run(Object.assign({}, base, {
          algorithm: 'NEAREST',
          manualRequests: [{ from: 13, to: 2 }]
        }));
      } catch (err) {
        message = err.message;
      }
      let messageZero = '';
      try {
        run(Object.assign({}, base, {
          algorithm: 'NEAREST',
          manualRequests: [{ from: 0, to: 2 }]
        }));
      } catch (err) {
        messageZero = err.message;
      }
      return {
        pass: message.indexOf('1~12') !== -1 && messageZero.indexOf('1~12') !== -1,
        detail: (message || '13 未拒绝') + ';' + (messageZero || '0 未拒绝')
      };
    });

    check('同层起终点请求被拒绝', function () {
      let message = '';
      try {
        run(Object.assign({}, base, {
          algorithm: 'NEAREST',
          manualRequests: [{ from: 5, to: 5 }]
        }));
      } catch (err) {
        message = err.message;
      }
      return {
        pass: message.indexOf('不能相同') !== -1,
        detail: message || '未抛出错误'
      };
    });

    check('停靠次数与停靠日志一致', function () {
      const stops = nearest.metrics.stops;
      return {
        pass: stops === nearest.stopLog.length && stops > 0,
        detail: '指标 ' + stops + ' 次 = 日志 ' + nearest.stopLog.length + ' 条'
      };
    });

    check('三种客流模式特征成立', function () {
      const morningRatio = nearest.passengers.length
        ? nearest.passengers.filter(function (p) { return p.from === 1; }).length / nearest.passengers.length
        : 0;
      const noonHasUp = noon.passengers.some(function (p) { return p.dir > 0; });
      const noonHasDown = noon.passengers.some(function (p) { return p.dir < 0; });
      const randomFloors = new Set(randomCase.passengers.map(function (p) { return p.from; })).size;
      return {
        pass: morningRatio >= 0.7 && noonHasUp && noonHasDown && randomFloors >= 5,
        detail: '早高峰 1 层占比 ' + (morningRatio * 100).toFixed(0) + '%,午间双向 ' +
          (noonHasUp && noonHasDown ? '成立' : '缺失') + ',随机起点覆盖 ' + randomFloors + ' 层'
      };
    });

    check('四种算法均完成全部送达', function () {
      const all = [nearest, fcfs, scan, look];
      const bad = all.filter(function (r) {
        return r.metrics.unfinished !== 0 || !Number.isFinite(r.metrics.avgWait);
      });
      return {
        pass: bad.length === 0,
        detail: all.map(function (r) { return r.algo.name + ' ' + r.metrics.delivered + ' 人'; }).join(' · ')
      };
    });

    const passed = results.filter(function (r) { return r.pass; }).length;
    return {
      total: results.length,
      passed: passed,
      failed: results.length - passed,
      results: results
    };
  }

  
  window.__elevatorLab = {
    run: run,
    selfTest: selfTest,
    scenarios: SCENARIOS,
    algorithms: ALGORITHMS,
    version: VERSION
  };

  
  const ui = {
    scenario: 'morning',
    rate: 20,
    duration: 120,
    seed: 20261108,
    algorithms: ['NEAREST'],
    manual: []
  };
  const lastValid = {
    rate: 20,
    duration: 120,
    seed: 20261108,
    manualFrom: 1,
    manualTo: 12
  };
  const lastValidPair = { from: 1, to: 12 };

  const dom = {};
  let stageViews = [];
  let currentResults = [];
  let runTimer = 0;
  let alertTimer = 0;
  let rafId = null;
  let lastTs = 0;

  const playback = {
    t: 0,
    maxT: 0,
    playing: false,
    speed: 4
  };

  const ICON_PLAY = '<svg viewBox="0 0 16 16" aria-hidden="true"><path d="M5.4 3.2l7 4.8-7 4.8z" fill="currentColor"/></svg>';
  const ICON_PAUSE = '<svg viewBox="0 0 16 16" aria-hidden="true"><rect x="4.1" y="3" width="3.1" height="10" rx="1" fill="currentColor"/><rect x="8.8" y="3" width="3.1" height="10" rx="1" fill="currentColor"/></svg>';
  const ICON_CHECK = '<svg viewBox="0 0 12 12" aria-hidden="true"><path d="M2 6.4l2.6 2.6L10 3.2" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round"/></svg>';
  const ICON_CROSS = '<svg viewBox="0 0 12 12" aria-hidden="true"><path d="M3 3l6 6M9 3l-6 6" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round"/></svg>';

  function $(id) { return document.getElementById(id); }

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

  function showError(message) {
    dom.alertText.textContent = message;
    dom.alert.classList.add('show');
    clearTimeout(alertTimer);
    alertTimer = setTimeout(function () {
      dom.alert.classList.remove('show');
    }, 7000);
  }

  function setRunStatus(text) {
    dom.runStatus.textContent = text;
  }

  function updateRangeFill(input, min, max) {
    const v = Number(input.value);
    const pct = ((v - min) / (max - min)) * 100;
    input.style.setProperty('--fill', clamp(pct, 0, 100) + '%');
  }

  function fmtClock(seconds) {
    const s = Math.max(0, seconds);
    const m = Math.floor(s / 60);
    const rest = s - m * 60;
    return String(m).padStart(2, '0') + ':' + rest.toFixed(1).padStart(4, '0');
  }

  function fmtNum(value, digits) {
    if (!Number.isFinite(value)) return '--';
    return value.toFixed(digits);
  }

  
  function syncControlsFromState() {
    document.querySelectorAll('[data-scenario]').forEach(function (btn) {
      btn.setAttribute('aria-pressed', String(btn.dataset.scenario === ui.scenario));
    });
    document.querySelectorAll('[data-algo]').forEach(function (chip) {
      chip.setAttribute('aria-pressed', String(ui.algorithms.indexOf(chip.dataset.algo) !== -1));
    });
    dom.rateSlider.value = String(ui.rate);
    dom.rateNumber.value = String(ui.rate);
    dom.rateOut.textContent = String(ui.rate);
    dom.durationSlider.value = String(ui.duration);
    dom.durationNumber.value = String(ui.duration);
    dom.durationOut.textContent = String(ui.duration);
    dom.seedInput.value = String(ui.seed);
    updateRangeFill(dom.rateSlider, 2, 30);
    updateRangeFill(dom.durationSlider, 60, 600);
    dom.scenarioHint.textContent = SCENARIOS[ui.scenario].desc;
    updateManualMeta();
  }

  function updateManualMeta() {
    dom.manualCount.textContent = '已注入 ' + ui.manual.length + ' 条';
    dom.clearManual.disabled = ui.manual.length === 0;
  }

  function rememberManualPair() {
    try {
      const a = validateFloor(dom.manualFrom.value, '起点楼层');
      const b = validateFloor(dom.manualTo.value, '终点楼层');
      if (a !== b) {
        lastValidPair.from = a;
        lastValidPair.to = b;
      }
    } catch (err) {
      
    }
  }

  function setRate(value, source) {
    ui.rate = value;
    lastValid.rate = value;
    dom.rateSlider.value = String(value);
    dom.rateNumber.value = String(value);
    dom.rateOut.textContent = String(value);
    updateRangeFill(dom.rateSlider, 2, 30);
    if (source !== 'init') scheduleRun();
  }

  function setDuration(value, source) {
    ui.duration = value;
    lastValid.duration = value;
    dom.durationSlider.value = String(value);
    dom.durationNumber.value = String(value);
    dom.durationOut.textContent = String(value);
    updateRangeFill(dom.durationSlider, 60, 600);
    if (source !== 'init') scheduleRun();
  }

  function scheduleRun(delay) {
    clearTimeout(runTimer);
    runTimer = setTimeout(performRun, delay == null ? 280 : delay);
  }

  
  function performRun() {
    if (!ui.algorithms.length) {
      showError('至少保留一种调度算法。');
      return;
    }
    const base = {
      scenario: ui.scenario,
      arrivalRate: ui.rate,
      duration: ui.duration,
      seed: ui.seed,
      manualRequests: ui.manual.slice()
    };
    let results;
    try {
      results = ui.algorithms.map(function (algo) {
        return window.__elevatorLab.run(Object.assign({}, base, { algorithm: algo }));
      });
    } catch (err) {
      showError(err.message);
      setRunStatus('参数被拒绝,保留上一次有效配置');
      return;
    }
    currentResults = results;
    renderStage(results);
    renderMetrics(results);
    renderCompare(results);
    startPlayback(results);
    const first = results[0];
    setRunStatus(
      'seed ' + ui.seed + ' · ' + SCENARIOS[ui.scenario].short + ' · ' +
      ui.rate + ' 人/分 · ' + ui.duration + 's · 生成 ' + first.metrics.generated + ' 人'
    );
  }

  
  function renderStage(results) {
    const stage = dom.stage;
    stage.innerHTML = '';
    stage.dataset.cols = String(Math.min(results.length, 4));
    stageViews = results.map(function (res) {
      const card = document.createElement('article');
      card.className = 'viz-card';
      card.style.setProperty('--algo', res.algo.color);
      card.innerHTML =
        '<div class="viz-head">' +
          '<div class="viz-title">' +
            '<span class="algo-mark"></span>' +
            '<span class="viz-name">' + res.algo.name + '</span>' +
            '<span class="viz-cn">' + res.algo.cn + '</span>' +
          '</div>' +
          '<div class="viz-live">' +
            '<span>等待 <b data-live="waiting">0</b></span>' +
            '<span>送达 <b data-live="done">0</b></span>' +
            '<span class="viz-clock" data-live="clock">00:00.0</span>' +
          '</div>' +
        '</div>' +
        '<div class="viz-canvas-wrap"><canvas role="img" aria-label="' + res.algo.name + ' 调度下的 12 层电梯剖面"></canvas></div>';
      stage.appendChild(card);
      const canvas = card.querySelector('canvas');
      return {
        res: res,
        card: card,
        canvas: canvas,
        ctx: canvas.getContext('2d'),
        waitingEl: card.querySelector('[data-live="waiting"]'),
        doneEl: card.querySelector('[data-live="done"]'),
        clockEl: card.querySelector('[data-live="clock"]')
      };
    });
  }

  function startPlayback(results) {
    playback.maxT = results.reduce(function (max, r) {
      const last = r.tracks[r.tracks.length - 1];
      return Math.max(max, last ? last.t : 0);
    }, 0);
    playback.t = 0;
    playback.playing = true;
    lastTs = 0;
    syncPlayUI();
    dom.scrub.value = '0';
  }

  function findFrameIndex(frames, t) {
    let lo = 0;
    let hi = frames.length - 1;
    while (lo < hi) {
      const mid = (lo + hi + 1) >> 1;
      if (frames[mid].t <= t) lo = mid;
      else hi = mid - 1;
    }
    return lo;
  }

  function frameAt(res, t) {
    const frames = res.tracks;
    if (!frames.length) return null;
    const i = findFrameIndex(frames, t);
    const a = frames[i];
    const b = frames[Math.min(i + 1, frames.length - 1)];
    const span = b.t - a.t;
    const k = span > 1e-6 ? clamp((t - a.t) / span, 0, 1) : 0;
    const useB = k > 0.5;
    const lead = useB ? b : a;
    return {
      waiting: lead.waiting,
      done: lead.done,
      grid: lead.grid,
      elevators: a.elevators.map(function (e, idx) {
        const f = b.elevators[idx];
        return {
          pos: e.pos + (f.pos - e.pos) * k,
          dir: lead.elevators[idx].dir,
          state: lead.elevators[idx].state,
          load: lead.elevators[idx].load,
          calls: lead.elevators[idx].calls
        };
      })
    };
  }

  function roundRect(ctx, x, y, w, h, r) {
    const rr = Math.min(r, w / 2, h / 2);
    ctx.beginPath();
    ctx.moveTo(x + rr, y);
    ctx.lineTo(x + w - rr, y);
    ctx.arcTo(x + w, y, x + w, y + rr, rr);
    ctx.lineTo(x + w, y + h - rr);
    ctx.arcTo(x + w, y + h, x + w - rr, y + h, rr);
    ctx.lineTo(x + rr, y + h);
    ctx.arcTo(x, y + h, x, y + h - rr, rr);
    ctx.lineTo(x, y + rr);
    ctx.arcTo(x, y, x + rr, y, rr);
    ctx.closePath();
  }

  function drawFrame(view, frame) {
    const wrap = view.canvas.parentElement;
    if (!wrap) return;
    const w = wrap.clientWidth;
    const h = wrap.clientHeight;
    if (!w || !h) return;
    const dpr = Math.min(window.devicePixelRatio || 1, 2);
    const cw = Math.round(w * dpr);
    const ch = Math.round(h * dpr);
    if (view.canvas.width !== cw || view.canvas.height !== ch) {
      view.canvas.width = cw;
      view.canvas.height = ch;
    }
    const ctx = view.ctx;
    ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
    ctx.clearRect(0, 0, w, h);

    const padL = 34;
    const padR = Math.min(82, w * 0.17);
    const padT = 30;
    const padB = 24;
    const bodyW = Math.max(80, w - padL - padR);
    const bodyH = Math.max(80, h - padT - padB);
    const gap = bodyH / (FLOORS - 1);
    const fy = function (floor) { return padT + (FLOORS - floor) * gap; };
    const colW = bodyW / ELEVATOR_COUNT;

    const bg = ctx.createLinearGradient(0, 0, 0, h);
    bg.addColorStop(0, 'rgba(61,220,151,0.035)');
    bg.addColorStop(0.45, 'rgba(0,0,0,0)');
    bg.addColorStop(1, 'rgba(76,179,255,0.025)');
    ctx.fillStyle = bg;
    ctx.fillRect(0, 0, w, h);

    for (let i = 0; i < ELEVATOR_COUNT; i++) {
      const x0 = padL + i * colW + Math.max(4, colW * 0.05);
      const x1 = padL + (i + 1) * colW - Math.max(4, colW * 0.05);
      ctx.fillStyle = 'rgba(255,255,255,0.017)';
      roundRect(ctx, x0, padT - 10, x1 - x0, bodyH + 20, 8);
      ctx.fill();

      ctx.strokeStyle = 'rgba(148,163,184,0.075)';
      ctx.setLineDash([2, 6]);
      ctx.beginPath();
      ctx.moveTo((x0 + x1) / 2, padT - 8);
      ctx.lineTo((x0 + x1) / 2, padT + bodyH + 8);
      ctx.stroke();
      ctx.setLineDash([]);

      const cx = padL + colW * (i + 0.5);
      ctx.fillStyle = 'rgba(148,163,184,0.5)';
      ctx.font = '600 10px ' + 'ui-monospace, "SF Mono", monospace';
      ctx.textAlign = 'center';
      ctx.textBaseline = 'middle';
      ctx.fillText('ABC'[i], cx, 13);
      ctx.fillStyle = hexA(ELEVATOR_COLORS[i], 0.5);
      ctx.fillRect(cx - 11, 22, 22, 1.5);
    }

    for (let f = 1; f <= FLOORS; f++) {
      const y = fy(f);
      const strong = f % 3 === 0 || f === 1 || f === FLOORS;
      ctx.strokeStyle = strong ? 'rgba(148,163,184,0.2)' : 'rgba(148,163,184,0.095)';
      ctx.lineWidth = 1;
      ctx.beginPath();
      ctx.moveTo(padL, y);
      ctx.lineTo(padL + bodyW, y);
      ctx.stroke();

      ctx.fillStyle = f === 1 ? 'rgba(61,220,151,0.85)' : 'rgba(139,154,171,0.8)';
      ctx.font = '10px ui-monospace, "SF Mono", monospace';
      ctx.textAlign = 'right';
      ctx.textBaseline = 'middle';
      ctx.fillText(String(f), padL - 9, y);
    }

    ctx.save();
    ctx.beginPath();
    ctx.rect(padL, padT - 10, bodyW, bodyH + 20);
    ctx.clip();

    const wx = padL + bodyW + 14;
    ctx.textAlign = 'left';
    ctx.textBaseline = 'middle';
    for (let f = 1; f <= FLOORS; f++) {
      const row = frame.grid[f] || [0, 0];
      const y = fy(f);
      if (row[0]) {
        ctx.fillStyle = 'rgba(61,220,151,0.92)';
        ctx.font = '600 9.5px ui-monospace, "SF Mono", monospace';
        ctx.fillText('↑ ' + row[0], wx, y - 6);
      }
      if (row[1]) {
        ctx.fillStyle = 'rgba(255,138,92,0.92)';
        ctx.font = '600 9.5px ui-monospace, "SF Mono", monospace';
        ctx.fillText('↓ ' + row[1], wx, y + 8);
      }
    }

    ctx.font = '9px ' + '"PingFang SC", "Microsoft YaHei", sans-serif';
    ctx.fillStyle = 'rgba(93,107,124,0.85)';
    ctx.textAlign = 'left';
    ctx.fillText('候梯', wx, padT - 16);

    for (let i = 0; i < frame.elevators.length; i++) {
      const e = frame.elevators[i];
      const color = ELEVATOR_COLORS[i];
      const cx = padL + colW * (i + 0.5);
      for (let c = 0; c < e.calls.length; c++) {
        const y = fy(e.calls[c]);
        ctx.fillStyle = hexA(color, 0.42);
        roundRect(ctx, cx - 12, y - 1.5, 24, 3, 1.5);
        ctx.fill();
      }
    }

    const carH = Math.min(30, Math.max(16, gap * 0.6));
    const carW = Math.min(66, Math.max(30, colW * 0.5));

    for (let i = 0; i < frame.elevators.length; i++) {
      const e = frame.elevators[i];
      const color = ELEVATOR_COLORS[i];
      const cx = padL + colW * (i + 0.5);
      const cy = fy(clamp(e.pos, 1, FLOORS));
      const x = cx - carW / 2;
      const y = cy - carH / 2;

      ctx.save();
      ctx.shadowColor = hexA(color, 0.4);
      ctx.shadowBlur = 16;
      const grad = ctx.createLinearGradient(x, y, x, y + carH);
      grad.addColorStop(0, hexA(color, 0.96));
      grad.addColorStop(1, hexA(color, 0.55));
      ctx.fillStyle = grad;
      roundRect(ctx, x, y, carW, carH, 6);
      ctx.fill();
      ctx.restore();

      ctx.strokeStyle = 'rgba(4,18,11,0.4)';
      ctx.lineWidth = 1;
      roundRect(ctx, x + 0.6, y + 0.6, carW - 1.2, carH - 1.2, 5.6);
      ctx.stroke();

      if (e.state === 'doors') {
        ctx.strokeStyle = 'rgba(4,18,11,0.55)';
        ctx.beginPath();
        ctx.moveTo(cx, y + 4);
        ctx.lineTo(cx, y + carH - 4);
        ctx.stroke();
        ctx.fillStyle = 'rgba(255,255,255,0.35)';
        ctx.fillRect(x + 5, y + carH / 2 - 0.6, carW - 10, 1.2);
      }

      ctx.fillStyle = '#04120b';
      ctx.font = '700 9.5px ui-monospace, "SF Mono", monospace';
      ctx.textAlign = 'center';
      ctx.textBaseline = 'middle';
      ctx.fillText(String(e.load), cx, cy + 0.5);

      if (e.dir !== 0 && e.state !== 'doors') {
        const ax = cx + carW / 2 + 8;
        const ay = cy;
        ctx.fillStyle = e.dir > 0 ? 'rgba(61,220,151,0.9)' : 'rgba(255,138,92,0.9)';
        ctx.beginPath();
        if (e.dir > 0) {
          ctx.moveTo(ax, ay - 5);
          ctx.lineTo(ax + 5, ay + 3);
          ctx.lineTo(ax - 5, ay + 3);
        } else {
          ctx.moveTo(ax, ay + 5);
          ctx.lineTo(ax + 5, ay - 3);
          ctx.lineTo(ax - 5, ay - 3);
        }
        ctx.closePath();
        ctx.fill();
      }
    }

    ctx.restore();

    ctx.fillStyle = 'rgba(93,107,124,0.55)';
    ctx.font = '9px ui-monospace, "SF Mono", monospace';
    ctx.textAlign = 'right';
    ctx.textBaseline = 'alphabetic';
    ctx.fillText('12F', padL - 9, padT - 13);
  }

  function drawStage() {
    if (!stageViews.length) return;
    for (let i = 0; i < stageViews.length; i++) {
      const view = stageViews[i];
      const frame = frameAt(view.res, playback.t);
      if (!frame) continue;
      drawFrame(view, frame);
      view.waitingEl.textContent = String(frame.waiting);
      view.doneEl.textContent = String(frame.done);
      view.clockEl.textContent = fmtClock(playback.t);
    }
    dom.timeLabel.textContent = fmtClock(playback.t) + ' / ' + fmtClock(playback.maxT);
    if (playback.playing) {
      dom.scrub.value = String(Math.round((playback.t / Math.max(playback.maxT, 1e-6)) * 1000));
    }
  }

  function syncPlayUI() {
    dom.playBtn.innerHTML = playback.playing ? ICON_PAUSE : ICON_PLAY;
    dom.playBtn.setAttribute('aria-label', playback.playing ? '暂停回放' : '播放回放');
    dom.speedBtn.textContent = playback.speed + '×';
  }

  function playLoop(ts) {
    if (lastTs === 0) lastTs = ts;
    const dt = Math.min(0.08, Math.max(0, (ts - lastTs) / 1000));
    lastTs = ts;
    if (playback.playing && playback.maxT > 0) {
      playback.t = Math.min(playback.maxT, playback.t + dt * playback.speed);
      if (playback.t >= playback.maxT) {
        playback.playing = false;
        syncPlayUI();
      }
    }
    drawStage();
    rafId = requestAnimationFrame(playLoop);
  }

  function ensureLoop() {
    if (rafId === null) {
      lastTs = 0;
      rafId = requestAnimationFrame(playLoop);
    }
  }

  
  function setMetric(id, value) {
    dom[id].textContent = value;
  }

  function renderMetrics(results) {
    const r = results[0];
    const m = r.metrics;
    dom.metricAlgo.textContent = results.length > 1
      ? '对比 ' + results.length + ' 种 · 主视图 ' + r.algo.name
      : r.algo.name + ' · ' + r.algo.cn;
    setMetric('m-avgWait', fmtNum(m.avgWait, 1));
    setMetric('m-p95Wait', fmtNum(m.p95Wait, 1));
    setMetric('m-maxWait', fmtNum(m.maxWait, 1));
    setMetric('m-avgRide', fmtNum(m.avgRide, 1));
    setMetric('m-totalFloors', String(Math.round(m.totalFloors)));
    setMetric('m-stops', String(m.stops));
    setMetric('m-delivered', String(m.delivered));
  }

  function renderCompare(results) {
    const panel = dom.comparePanel;
    if (results.length < 2) {
      panel.hidden = true;
      dom.compareBody.innerHTML = '';
      return;
    }
    panel.hidden = false;
    dom.compareHint.textContent = results.length + ' 种算法 · 同一请求流';

    const minCols = {
      avgWait: 'min', p95Wait: 'min', maxWait: 'min',
      avgRide: 'min', totalFloors: 'min', stops: 'min'
    };
    const best = {};
    Object.keys(minCols).forEach(function (key) {
      let v = Infinity;
      results.forEach(function (r) {
        if (r.metrics[key] < v) v = r.metrics[key];
      });
      best[key] = v;
    });
    let maxDelivered = -Infinity;
    results.forEach(function (r) {
      if (r.metrics.delivered > maxDelivered) maxDelivered = r.metrics.delivered;
    });

    dom.compareBody.innerHTML = results.map(function (r) {
      const m = r.metrics;
      function cls(key) {
        return Math.abs(m[key] - best[key]) < 1e-9 ? ' class="best"' : '';
      }
      function num(key, digits) {
        return '<td' + cls(key) + '>' + fmtNum(m[key], digits) + '</td>';
      }
      return '<tr>' +
        '<td><span class="algo-cell">' +
          '<span class="table-dot" style="background:' + r.algo.color + '"></span>' +
          '<b style="color:' + r.algo.color + '">' + r.algo.name + '</b>' +
          '<span>' + r.algo.cn + '</span>' +
        '</span></td>' +
        num('avgWait', 1) +
        num('p95Wait', 1) +
        num('maxWait', 1) +
        num('avgRide', 1) +
        '<td' + cls('totalFloors') + '>' + Math.round(m.totalFloors) + '</td>' +
        '<td' + cls('stops') + '>' + m.stops + '</td>' +
        '<td' + (m.delivered === maxDelivered ? ' class="best"' : '') + '>' + m.delivered + '</td>' +
        '<td>' + m.unfinished + '</td>' +
      '</tr>';
    }).join('');
  }

  
  function renderSelfTest(report) {
    const bad = report.failed > 0;
    dom.selfcheckSummary.innerHTML =
      '<span class="badge ' + (bad ? 'bad' : 'good') + '">' +
        report.passed + ' / ' + report.total + ' 通过' +
      '</span>' +
      '<span class="summary-note">' + (bad ? report.failed + ' 项未通过' : '全部不变量成立') + '</span>';
    dom.assertGrid.innerHTML = report.results.map(function (r) {
      return '<div class="assert ' + (r.pass ? 'pass' : 'fail') + '">' +
        '<span class="assert-icon">' + (r.pass ? ICON_CHECK : ICON_CROSS) + '</span>' +
        '<div class="assert-text">' +
          '<div class="assert-name">' + escapeHtml(r.name) + '</div>' +
          '<div class="assert-detail">' + escapeHtml(r.detail || '') + '</div>' +
        '</div>' +
      '</div>';
    }).join('');
  }

  function runSelfTest() {
    dom.selfTestBtn.disabled = true;
    dom.selfTestBtn.textContent = '自检运行中…';
    dom.selfcheckSummary.innerHTML = '<span class="badge run">运行中…</span>' +
      '<span class="summary-note">正在重跑确定性仿真</span>';
    requestAnimationFrame(function () {
      let report;
      try {
        report = window.__elevatorLab.selfTest();
      } catch (err) {
        report = {
          total: 1,
          passed: 0,
          failed: 1,
          results: [{ name: '自检执行', pass: false, detail: err.message }]
        };
      }
      renderSelfTest(report);
      dom.selfTestBtn.disabled = false;
      dom.selfTestBtn.textContent = '运行自检';
    });
  }

  
  function bindControls() {
    document.querySelectorAll('[data-scenario]').forEach(function (btn) {
      btn.addEventListener('click', function () {
        ui.scenario = btn.dataset.scenario;
        syncControlsFromState();
        scheduleRun(120);
      });
    });

    dom.rateSlider.addEventListener('input', function () {
      const v = Number(dom.rateSlider.value);
      if (!Number.isFinite(v)) return;
      setRate(v, 'slider');
      dom.rateNumber.value = String(v);
    });

    dom.rateNumber.addEventListener('change', function () {
      const v = Number(dom.rateNumber.value);
      if (!Number.isFinite(v) || v < 2 || v > 30) {
        showError('到达率必须在 2~30 人/分钟之间,已恢复上一次有效值 ' + lastValid.rate + ' 人/分钟。');
        dom.rateNumber.value = String(lastValid.rate);
        setRate(lastValid.rate, 'restore');
        return;
      }
      setRate(v, 'number');
    });

    dom.durationSlider.addEventListener('input', function () {
      const v = Number(dom.durationSlider.value);
      if (!Number.isFinite(v)) return;
      setDuration(v, 'slider');
      dom.durationNumber.value = String(v);
    });

    dom.durationNumber.addEventListener('change', function () {
      const v = Number(dom.durationNumber.value);
      if (!Number.isFinite(v) || v < 60 || v > 600) {
        showError('仿真时长必须在 60~600 秒之间,已恢复上一次有效值 ' + lastValid.duration + ' 秒。');
        dom.durationNumber.value = String(lastValid.duration);
        setDuration(lastValid.duration, 'restore');
        return;
      }
      setDuration(v, 'number');
    });

    dom.seedInput.addEventListener('change', function () {
      const v = Number(dom.seedInput.value);
      if (!Number.isInteger(v) || v < 0 || v > SEED_MAX) {
        showError('随机种子必须是 0~' + SEED_MAX + ' 的整数,已恢复上一次有效值 ' + lastValid.seed + '。');
        dom.seedInput.value = String(lastValid.seed);
        return;
      }
      ui.seed = v;
      lastValid.seed = v;
      scheduleRun(200);
    });

    dom.seedDice.addEventListener('click', function () {
      ui.seed = 1 + Math.floor(Math.random() * (SEED_MAX - 1));
      lastValid.seed = ui.seed;
      dom.seedInput.value = String(ui.seed);
      scheduleRun(150);
    });

    document.querySelectorAll('[data-algo]').forEach(function (chip) {
      chip.addEventListener('click', function () {
        const id = chip.dataset.algo;
        const idx = ui.algorithms.indexOf(id);
        if (idx !== -1) {
          if (ui.algorithms.length === 1) {
            showError('至少保留一种调度算法。');
            return;
          }
          ui.algorithms.splice(idx, 1);
        } else {
          ui.algorithms.push(id);
          ui.algorithms.sort(function (a, b) {
            return ALGO_ORDER.indexOf(a) - ALGO_ORDER.indexOf(b);
          });
        }
        syncControlsFromState();
        scheduleRun(120);
      });
    });

    dom.runBtn.addEventListener('click', function () {
      clearTimeout(runTimer);
      performRun();
    });

    dom.selfTestBtn.addEventListener('click', runSelfTest);

    dom.injectBtn.addEventListener('click', function () {
      let from;
      let to;
      try {
        from = validateFloor(dom.manualFrom.value, '起点楼层');
        to = validateFloor(dom.manualTo.value, '终点楼层');
        if (from === to) {
          throw new Error('起点楼层与终点楼层不能相同(均为 ' + from + ' 层)');
        }
      } catch (err) {
        showError(err.message + ',已恢复上一次有效组合 ' + lastValidPair.from + ' → ' + lastValidPair.to + '。');
        dom.manualFrom.value = String(lastValidPair.from);
        dom.manualTo.value = String(lastValidPair.to);
        lastValid.manualFrom = lastValidPair.from;
        lastValid.manualTo = lastValidPair.to;
        return;
      }
      lastValid.manualFrom = from;
      lastValid.manualTo = to;
      lastValidPair.from = from;
      lastValidPair.to = to;
      const time = Math.min(1 + ui.manual.length * 0.8, Math.max(0.5, ui.duration - 0.3));
      ui.manual.push({ from: from, to: to, time: round3(time) });
      updateManualMeta();
      performRun();
    });

    dom.clearManual.addEventListener('click', function () {
      ui.manual = [];
      updateManualMeta();
      performRun();
    });

    dom.manualFrom.addEventListener('change', function () {
      const raw = dom.manualFrom.value;
      try {
        const v = validateFloor(raw, '起点楼层');
        lastValid.manualFrom = v;
        dom.manualFrom.value = String(v);
        rememberManualPair();
      } catch (err) {
        showError(err.message + ',已恢复上一次有效值 ' + lastValid.manualFrom + '。');
        dom.manualFrom.value = String(lastValid.manualFrom);
      }
    });

    dom.manualTo.addEventListener('change', function () {
      const raw = dom.manualTo.value;
      try {
        const v = validateFloor(raw, '终点楼层');
        lastValid.manualTo = v;
        dom.manualTo.value = String(v);
        rememberManualPair();
      } catch (err) {
        showError(err.message + ',已恢复上一次有效值 ' + lastValid.manualTo + '。');
        dom.manualTo.value = String(lastValid.manualTo);
      }
    });

    dom.playBtn.addEventListener('click', function () {
      if (playback.maxT <= 0) return;
      if (!playback.playing && playback.t >= playback.maxT - 1e-6) {
        playback.t = 0;
      }
      playback.playing = !playback.playing;
      lastTs = 0;
      syncPlayUI();
    });

    dom.replayBtn.addEventListener('click', function () {
      playback.t = 0;
      playback.playing = true;
      lastTs = 0;
      syncPlayUI();
      dom.scrub.value = '0';
    });

    dom.speedBtn.addEventListener('click', function () {
      const options = [1, 2, 4, 8];
      const idx = options.indexOf(playback.speed);
      playback.speed = options[(idx + 1) % options.length];
      syncPlayUI();
    });

    dom.scrub.addEventListener('input', function () {
      playback.playing = false;
      syncPlayUI();
      playback.t = (Number(dom.scrub.value) / 1000) * playback.maxT;
      drawStage();
    });
  }

  function boot() {
    dom.stage = $('stage');
    dom.rateSlider = $('rateSlider');
    dom.rateNumber = $('rateNumber');
    dom.rateOut = $('rateOut');
    dom.durationSlider = $('durationSlider');
    dom.durationNumber = $('durationNumber');
    dom.durationOut = $('durationOut');
    dom.seedInput = $('seedInput');
    dom.seedDice = $('seedDice');
    dom.scenarioHint = $('scenarioHint');
    dom.manualFrom = $('manualFrom');
    dom.manualTo = $('manualTo');
    dom.injectBtn = $('injectBtn');
    dom.manualCount = $('manualCount');
    dom.clearManual = $('clearManual');
    dom.runStatus = $('runStatus');
    dom.runBtn = $('runBtn');
    dom.selfTestBtn = $('selfTestBtn');
    dom.alert = $('alert');
    dom.alertText = $('alertText');
    dom.playBtn = $('playBtn');
    dom.replayBtn = $('replayBtn');
    dom.speedBtn = $('speedBtn');
    dom.scrub = $('scrub');
    dom.timeLabel = $('timeLabel');
    dom.metricAlgo = $('metricAlgo');
    dom.comparePanel = $('comparePanel');
    dom.compareBody = $('compareBody');
    dom.compareHint = $('compareHint');
    dom.selfcheckSummary = $('selfcheckSummary');
    dom.assertGrid = $('assertGrid');
    dom.mAvgWait = $('m-avgWait');
    dom.mp95Wait = $('m-p95Wait');
    dom.mMaxWait = $('m-maxWait');
    dom.mAvgRide = $('m-avgRide');
    dom.mTotalFloors = $('m-totalFloors');
    dom.mStops = $('m-stops');
    dom.mDelivered = $('m-delivered');

    dom['m-avgWait'] = dom.mAvgWait;
    dom['m-p95Wait'] = dom.mp95Wait;
    dom['m-maxWait'] = dom.mMaxWait;
    dom['m-avgRide'] = dom.mAvgRide;
    dom['m-totalFloors'] = dom.mTotalFloors;
    dom['m-stops'] = dom.mStops;
    dom['m-delivered'] = dom.mDelivered;

    syncControlsFromState();
    syncPlayUI();
    bindControls();
    ensureLoop();
    performRun();

    setTimeout(function () {
      runSelfTest();
    }, 650);
  }

  if (document.readyState === 'loading') {
    document.addEventListener('DOMContentLoaded', boot);
  } else {
    boot();
  }
})();
</script>
</body>
</html>