// 事故が起きたら誰の責任？ — 交差点の計算（試作 v1：止める手段の通り道・不具合の差し込み・出来事の記録）
// 単位：m・秒。上から見て x が東、z が南（three.js と同じ向き）。
export const DEFAULTS = { mode: 'l2', sensor: 'normal', speed: 10, guide: true, route: 'short', rest: true, maint: 'often', update: 'test', commLoss: 'stop' };
export const RULES_VERSION = 'v1-2026-11-20';
// 止める手段と、その指示が通る道。不具合は、この道の1本を切る形で差し込む
//  ads：バスの自動運転の装置 → 車体（自動ブレーキ・ふだんの減速）
//  pedal：運転士の足のブレーキ（機械でつながる。レベル2）
//  estop：車内の非常停止ボタン（自動運転の装置を通らない。レベル4・車内）
//  remote：遠隔監視者 → 通信 → 自動運転の装置 → 車体
export const CHANNELS = { ads: ['ads'], pedal: [], estop: [], remote: ['net', 'ads'] };
export const FAULT_LABEL = { brake: 'ブレーキの指示が車体に届かない', steer: '曲がるときのハンドルの動きが遅れる', update: 'ソフト更新のあと、止まる位置がずれる', comm: '遠隔との通信が切れる' };

export const PARAMS = {
  daysPerYear: 300, passesPerDay: 40, dt: 0.1, passTime: 75,
  pedRatePerPass: 0.8, phoneRate: 0.2, fromBehindHedge: 0.4, walk: [1.0, 1.5],
  // 歩く人の型（割合）：ふつう / 連れ立って / ゆっくり / 急いで / 渡るか迷う / 横断歩道の外を斜めに
  pedTypes: [['normal', 0.45], ['group', 0.15], ['slow', 0.12], ['hurry', 0.1], ['hesitate', 0.1], ['diagonal', 0.08]],
  slowWalk: [0.6, 0.9], hurryWalk: [2.0, 2.8], ambient: [1, 3],
  guideClear: 0.7, operatorTrustGuide: 0.4, missRest: 0.05, missNoRest: 0.10,
  reaction: 0.9, decel: 2.5, emergencyDecel: 3.0, operatorReaction: 1.2,
  // バスの動き：ゆるやかな加速・減速。加速度の変わり方（ジャーク）にも上限をつけ、曲がる前は横Gが大きくならない速さに落とす
  cruise: 35 / 3.6, zoneBefore: 14, zoneAfter: 4, // 交差点の外は時速35kmで走り（20人前後のミニバス。最高は時速40km前後）、交差点の手前14mから抜けて4mまでは設定の速さ
  accel: 1.0, comfortDecel: 1.3, trackDecel: 2.0, jerk: 1.8, latAcc: 3.0,
  predictNormal: 1.0, predictWide: 2.0, predictOp: 1.2, // 人の何秒先の位置まで読むか
  sensorNormal: { range: 10, half: 95 }, sensorWide: { range: 14, half: 150 },
  eveningRange: 0.7, detourSec: 0, remoteReaction: 2.0, nearMiss: 1.0, pedR: 0.25,
  cost: { base: 100, sensorWide: 30, guide: 40, detour: 10, rest: 15, onboard: 20, remote1: 12, remote3: 4, maint: 10, update: 5 },
  // 不具合（案）。場面では決め打ちで起こす。1年回すときは、1回の通過ごとにこの割合で起こす
  trigD: 40,            // 場面の合図：バスが止まる位置の40m手前を通った時刻を0とし、人はそこから決めた秒数で動く
  coast: 0.3,           // ブレーキが効かないときの、転がるだけの減速（m/秒²）
  driverNotice: 1.5,    // 運転士がブレーキの異常に気づいて踏むまで（秒）
  estopReaction: 2.5,   // 車内の主任者が異常に気づいて非常停止を押すまで（秒）
  steerLag: 0.9,       // ハンドルの遅れで外へふくらむ速さ（バスの速さに対する割合）
  steerCorrect: 1.0,    // 運転士がハンドルで戻す速さ（m/秒）
  latMax: 4.5,          // これより横向きの力が大きいと、曲がりきれず外へふくらむ（m/秒²）
  updateShift: 1.8,     // ソフト更新のあと、止まる位置が先へずれる長さ（m）
  updateNotice: 0.8,    // 運転士が「いつもの所で止まらない」と気づいて踏むまで（秒）
  recoverSec: 600,      // 通信が切れてその場で止まったとき、現場に人が来て動かすまで（秒）
  faultRate: { brake: [1 / 60000, 1 / 6000], steer: [1 / 60000, 1 / 6000], update: [1 / 30000, 1 / 3000], comm: 1 / 4000 } // [こまめ／最低限] [試走／そのまま]
};
// 建物（上から見た長方形）：[xmin, xmax, zmin, zmax]
export const BUILDINGS = [[-23, -7, -17.5, -8.5], [8.5, 21.5, -19, -9], [-23, -7, 9, 15], [7, 23, 9, 15]];
// 車道かどうか（それ以外は歩道や縁石の外）
const onRoad = (x, z) => Math.abs(z) < 3.5 || (Math.abs(x) < 3 && z < -3.5);
// その向きでバスが「止まる位置の40m手前」を通る時刻（その手前は時速35kmで一定に走るので、計算で決まる）
export function trigT(route) { return (ROUTES[route].stopS - PARAMS.trigD) / PARAMS.cruise; }

// 再現できる乱数
export function rng(seed) {
  let a = seed >>> 0;
  return () => { 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; };
}

// 植え込み（近道のときだけある）：[xmin, xmax, zmin, zmax]
export const HEDGES = [[3.4, 9.0, -5.0, -3.6]];
// 横断歩道（脇道の入口）
export const CROSS = { xmin: -3.2, xmax: 3.2, zmin: -6.5, zmax: -3.5 };
export const PED_Z = -5.8;

// バスの道：4通り。直線 → 90度曲がる → 直線。h は向き（0で東・π/2で北）
// 左側通行：東へ向かう車線は z=-1.75、西へは z=+1.75、北へ向かう脇道の車線は x=-1.5、南へは x=+1.5
const leftOf = (h) => ({ x: -Math.sin(h), z: -Math.cos(h) });
function makeRoute(name, label, x0, z0, h0, len1, turn, R) {
  const L2 = Math.PI / 2 * R, L3 = 45;
  const p1 = { x: x0 + Math.cos(h0) * len1, z: z0 - Math.sin(h0) * len1 };
  const lv = leftOf(h0), C = { x: p1.x + turn * R * lv.x, z: p1.z + turn * R * lv.z };
  const h2 = h0 + turn * Math.PI / 2, lv2 = leftOf(h2), p2 = { x: C.x - turn * R * lv2.x, z: C.z - turn * R * lv2.z };
  const pose = (s) => {
    if (s <= len1) return { x: x0 + Math.cos(h0) * s, z: z0 - Math.sin(h0) * s, h: h0 };
    if (s <= len1 + L2) { const h = h0 + turn * (s - len1) / R, l = leftOf(h); return { x: C.x - turn * R * l.x, z: C.z - turn * R * l.z, h }; }
    const t = s - len1 - L2; return { x: p2.x + Math.cos(h2) * t, z: p2.z - Math.sin(h2) * t, h: h2 };
  };
  const pts = []; for (let q = 0; q <= len1 + L2 + L3 + 12; q += 0.1) pts.push(pose(q));
  const fast = (q) => pts[Math.max(0, Math.min(pts.length - 1, Math.round(q * 10)))]; // 速く引くための、0.1m刻みの表
  const r = { name, label, turn, R, pose, fast, arcStart: len1, arcEnd: len1 + L2, total: len1 + L2 + L3, stopS: 0, enters: name === 'wl' || name === 'er' };
  for (let s = 0; s < r.total; s += 0.02) { const p = pose(s), fx = p.x + Math.cos(p.h) * BUS_L / 2, fz = p.z - Math.sin(p.h) * BUS_L / 2;
    if (fx > CROSS.xmin - 0.3 && fx < CROSS.xmax + 0.3 && fz > CROSS.zmin - (r.enters ? 0.3 : 1.2) && fz < CROSS.zmax + 0.3) { r.stopS = s; break; } }
  return r;
}
const BUS_L = 5.2, BUS_W = 2.2;
export const ROUTES = {
  wl: makeRoute('wl', '西から来て左折', -75, -1.75, 0, 70, 1, 3.5),
  er: makeRoute('er', '東から来て右折', 75, 1.75, Math.PI, 71.5, -1, 5),
  nl: makeRoute('nl', '脇道から出て左折', 1.5, -75, -Math.PI / 2, 69.75, 1, 3.5),
  nr: makeRoute('nr', '脇道から出て右折', 1.5, -75, -Math.PI / 2, 71.75, -1, 5),
};
export const ROUTE_SHARE = [['wl', 0.4], ['er', 0.25], ['nl', 0.2], ['nr', 0.15]];
export const STOP_S = ROUTES.wl.stopS;
export function busPose(s, route = 'wl') { return ROUTES[route].pose(s); }
// バスの車体（中心＝pose、向き h：0で東向き）と点の距離
function distToBus(p, px, pz) {
  const c = Math.cos(p.h), s = Math.sin(p.h);
  const dx = px - p.x, dz = pz - p.z;
  const u = dx * c - dz * s;      // 進む向き
  const w = dx * s + dz * c;      // 横
  const du = Math.max(Math.abs(u) - BUS_L / 2, 0), dw = Math.max(Math.abs(w) - BUS_W / 2, 0);
  return Math.hypot(du, dw);
}
// 車体のすぐ前（前4m・左右1.8m）に人がいるか
function inFront(p, px, pz) {
  const c = Math.cos(p.h), s = Math.sin(p.h), dx = px - p.x, dz = pz - p.z;
  const u = dx * c - dz * s, w = dx * s + dz * c;
  return u > BUS_L / 2 - 0.2 && u < BUS_L / 2 + 4 && Math.abs(w) < 1.8;
}
function frontHalf(p, px, pz) { const c = Math.cos(p.h), s = Math.sin(p.h); return (px - p.x) * c - (pz - p.z) * s > 0; }
function segHitsRect(x1, z1, x2, z2, r) {
  // 線分が長方形を通るか（簡単な刻みで判定）
  for (let i = 1; i < 20; i++) { const t = i / 20, x = x1 + (x2 - x1) * t, z = z1 + (z2 - z1) * t; if (x > r[0] && x < r[1] && z > r[2] && z < r[3]) return true; }
  return false;
}
function blocked(cfg, x1, z1, x2, z2) {
  if (cfg.route !== 'short') return false;
  return HEDGES.some((h) => segHitsRect(x1, z1, x2, z2, h));
}
function inCross(px, pz, pad = 0) { return px > CROSS.xmin - pad && px < CROSS.xmax + pad && pz > CROSS.zmin && pz < CROSS.zmax; }

// 脇道の車道（横断歩道から北）。歩く人が車道に入る直前かを見るのに使う
const inSideRoad = (x, z) => Math.abs(x) < 3.2 && z < -3.5 && z > -40;
const pick = (rand, table) => { let u = rand(), acc = 0; for (const [k, w] of table) { acc += w; if (u < acc) return k; } return table.at(-1)[0]; };
const EMPTY_CACHE = new Map();
// 場面を選んで確かめるための場面（道・歩く人・誘導員の合図を決め打ちにしたもの）。arrive はバスが交差点に来るころに合わせてある
export const SCENES = [
  { id: 'miss', title: '見ている人の見落とし', note: 'スマホを見ている人が、バスの発進のころに横断歩道へ入る', route: 'wl', peds: [{ type: 'normal', fromEast: false, phone: true, sp: 1.2, arrive: 15.5, missRoll: 0.07 }], guideClear: false, trustGuide: false },
  { id: 'guide', requires: { guide: true }, title: '誘導員の合図を当てにした発進', note: '誘導員の合図はあいまい。運転する側は「止めてくれる」と読む', route: 'wl', peds: [{ type: 'normal', fromEast: false, phone: true, sp: 1.3, arrive: 16.75, missRoll: 0.5 }], guideClear: false, trustGuide: true },
  { id: 'right', title: '右折中の横断歩道', note: '東から来たバスが、対向車線を横切って横断歩道へ向かう', route: 'er', peds: [{ type: 'normal', fromEast: false, phone: true, sp: 1.3, arrive: 17.75, missRoll: 0.5 }], guideClear: false, trustGuide: false },
  { id: 'exit', title: '脇道から出るバスの前へ', note: '本道へ出るバスの前を、人が横断歩道で渡る', route: 'nl', peds: [{ type: 'normal', fromEast: true, phone: true, sp: 1.3, arrive: 16.0, missRoll: 0.5 }], guideClear: false, trustGuide: false },
  { id: 'diagonal', title: '横断歩道の外を斜めに渡る人', note: '脇道に入ったバスの前を、横断歩道の先で斜めに渡る', route: 'wl', peds: [{ type: 'diagonal', fromEast: false, phone: false, sp: 1.3, arrive: 17.25, missRoll: 0.5 }], guideClear: true, trustGuide: false },
];
// 場面の人の時刻は「合図（バスが止まる位置の40m手前を通った時刻）から何秒後に車道の端に着くか」（lead）で持つ
for (const sc of SCENES) for (const p of sc.peds) if (p.arrive !== undefined && p.lead === undefined) { p.lead = p.arrive - trigT(sc.route); delete p.arrive; }
// 動作不良の場面（バスの不具合を決め打ちで起こす）。人の動きも合図からの秒数で決める
SCENES.push(
  { id: 'brake', fault: 'brake', group: 'C', title: 'ブレーキが効かない', note: '交差点の手前で、ブレーキの指示が車体に届かなくなる。横断歩道には渡る人がいる', route: 'wl', peds: [{ type: 'normal', fromEast: false, phone: true, sp: 1.3, lead: 4.2, missRoll: 0.5 }], guideClear: false, trustGuide: false },
  { id: 'steer', fault: 'steer', group: 'C', requires: { guide: false }, title: '曲がりが遅れて歩道へ', note: '横断歩道の前から動き出したとき、ハンドルの動きが遅れて外へふくらむ。角の歩道に人が立っている', route: 'er', peds: [{ type: 'stand', x: -5.6, z: -7.6, phone: true, missRoll: 0.5 }], guideClear: true, trustGuide: false },
  { id: 'update', fault: 'update', group: 'C', title: 'ソフト更新のあと、止まる位置がずれる', note: '更新のあと、バスがいつもより先、横断歩道の上で止まろうとする', route: 'wl', peds: [{ type: 'normal', fromEast: true, phone: true, sp: 1.2, lead: 6.5, missRoll: 0.5 }], guideClear: false, trustGuide: false },
  { id: 'comm', fault: 'comm', group: 'C', title: '遠隔との通信が切れる', note: '交差点に入ったところで、遠くの見張りとの通信が切れる。急いで渡る人が来る', route: 'er', peds: [{ type: 'hurry', fromEast: false, phone: false, sp: 2.4, lead: 10, missRoll: 0.5 }], guideClear: false, trustGuide: false },
);
// 場面のバスの向きを変える。歩く人が車道に着く時刻を、その向きでバスが横断歩道に着く時刻に合わせてずらす（場面の「ぶつかりそうな間合い」を保つ）
const ARR = new Map();
function busArrive(cfg, route) {
  const k = route + JSON.stringify(cfg); if (ARR.has(k)) return ARR.get(k);
  const r = simulatePass(cfg, rng(1), { record: true, scene: { route, peds: [], guideClear: true, trustGuide: false } });
  const S = ROUTES[route].stopS; const f = r.frames.find((x) => x.bus.s >= S - 1) || r.frames[r.frames.length - 1];
  ARR.set(k, f.t); return f.t;
}
// 向きを変えたときの、歩く人の時刻のずらし（秒）と、渡ってくる側を逆にするか。各向きで場面の間合いが保たれるよう、設定を総当たりして選んだ値
export const SCENE_DIRS = {
  miss: { er: [0.75, false], nl: [1, true], nr: [1, true] },
  guide: { er: [0, false], nl: [-0.25, true], nr: [0, true] },
  right: { wl: [0, false], nl: [-0.25, true], nr: [0, true] },
  exit: { wl: [0, true], er: [0, true], nr: [0, false] },
  diagonal: { er: [0, false] }, // 斜めに渡る人は脇道の奥を歩くので、脇道から出るバスとは交わらない
};
export function sceneFor(sc, dir, cfg) {
  if (!dir || dir === sc.route) return sc;
  const adj = (SCENE_DIRS[sc.id] || {})[dir]; if (!adj) return sc;
  const dt = busArrive(cfg, dir) - busArrive(cfg, sc.route) + adj[0] - (trigT(dir) - trigT(sc.route));
  return { ...sc, route: dir, peds: sc.peds.map((p) => ({ ...p, lead: Math.max(1 - trigT(dir), p.lead + dt), ...(adj[1] ? { fromEast: !p.fromEast } : {}) })) };
}
export const PED_LABEL = { normal: 'ふつうに渡る人', group: '連れ立って渡る人', slow: 'ゆっくり渡る人', hurry: '急いで渡る人', hesitate: '渡るか迷っていた人', diagonal: '横断歩道の外を斜めに渡る人' };

// 1回の通過を計算する。record=true なら0.5秒ごとの記録を残す
let bus = null; // いま計算している回のバス（pose から外へのふくらみを読むため）
export function simulatePass(cfg, rand, opts = {}) {
  const P = PARAMS; bus = null;
  const evening = (opts.scene && opts.scene.evening) || opts.evening || false;
  const SC = opts.scene || null; // 場面を選んで確かめるとき：道・歩く人・誘導員の合図などを決め打ちにする
  const RT = ROUTES[(SC && SC.route) || opts.route || pick(rand, ROUTE_SHARE)];
  // 外へふくらんだ分（off）を足した、バスの実際の位置。外側＝曲がる向きと反対
  const pose = (s) => { const p = RT.pose(s); if (!bus || !bus.off) return p; const l = leftOf(p.h), k = -RT.turn * bus.off; return { x: p.x + l.x * k, z: p.z + l.z * k, h: p.h + (bus.yaw || 0) }; };
  // 不具合：場面では決め打ち（点検や試走で見つかれば起きない）、1年回すときは外から渡される
  const FAULT = (SC && SC.fault) || opts.fault || null;
  let prevented = null;
  if (SC && FAULT) { if ((FAULT === 'brake' || FAULT === 'steer') && cfg.maint === 'often') prevented = 'maint'; if (FAULT === 'update' && cfg.update === 'test') prevented = 'test'; }
  const fault = prevented ? null : FAULT;
  const STOP = RT.stopS + (fault === 'update' ? P.updateShift : 0); // 止まろうとする位置（更新のずれがあれば先へ）
  const STOP0 = RT.stopS;
  const vmax = cfg.speed / 3.6;
  const sens = cfg.sensor === 'wide' ? P.sensorWide : P.sensorNormal;
  const range = sens.range * (evening ? P.eveningRange : 1);
  // 運行の形：l2＝レベル2・運転士が乗る（発進は運転士）／l4in＝レベル4・車内に主任者／l4r1・l4r3＝レベル4・遠くで1人が1台／3台を見る
  const MODE = cfg.mode || 'l2', humanStart = MODE === 'l2', onboard = MODE === 'l2' || MODE === 'l4in', remote = MODE === 'l4r1' || MODE === 'l4r3';
  const broken = new Set(); // 切れている道（ads／net）
  const chOk = (src) => CHANNELS[src].every((c) => !broken.has(c));
  const failed = new Set(); // 届かなかった指示（同じ指示を何度も記録しない）
  // 見落とし：休憩なしで増える。レベル2は「任せて見ているだけ」の監視疲れで少し増える。遠くで3台を見ると大きく増える
  const missP = (cfg.rest ? P.missRest : P.missNoRest) * (MODE === 'l2' ? 1.5 : MODE === 'l4r3' ? 2.5 : 1);
  // 歩く人（脇道を渡る人）
  const peds = [];
  let n = 0; if (SC) n = SC.peds.length; else { let l = Math.exp(-P.pedRatePerPass), k = 0, p = 1; do { k++; p *= rand(); } while (p > l); n = k - 1; }
  let S = {};
  // 見落としは「くじ」の値と見落としの割合で決まる。場面ではくじの値を固定するので、休憩や運行の形を変えると結果が変わる
  const mk = (o) => { const p = { id: peds.length, phone: false, missed: (S.missRoll ?? rand()) < missP, hes: 0, hit: false, minD: 99, ...o }; peds.push(p); return p; };
  for (let i = 0; i < n; i++) {
    S = SC ? SC.peds[i] : {};
    const type = S.type ?? pick(rand, P.pedTypes);
    const fromEast = S.fromEast ?? rand() < P.fromBehindHedge;
    const dir = fromEast ? -1 : 1;
    let sp = P.walk[0] + rand() * (P.walk[1] - P.walk[0]);
    if (type === 'slow') sp = P.slowWalk[0] + rand() * (P.slowWalk[1] - P.slowWalk[0]);
    if (type === 'hurry') sp = P.hurryWalk[0] + rand() * (P.hurryWalk[1] - P.hurryWalk[0]);
    if (S.sp) sp = S.sp;
    const arrive = S.lead !== undefined ? trigT(RT.name) + S.lead : S.arrive ?? 4 + rand() * 18; // 車道の端に着く時刻（通過の始まりから）。場面では合図からの秒数
    const phone = S.phone ?? ((type === 'normal' || type === 'group') && rand() < P.phoneRate);
    if (type === 'stand') { mk({ type, stand: true, fromEast: false, hedge: false, sp: 0, x: S.x, z: S.z, ux: 0, uz: 1, phone: !!S.phone }); continue; } // 歩道で立ち止まっている人（渡らない）
    if (type === 'diagonal') {
      // 脇道の歩道を北から歩いてきて、角の手前から横断歩道の外を斜めに渡り、反対側の角へ向かう
      const sx = fromEast ? 1 : -1, zA = -9.2 - rand() * 1.6, zB = -6.9 - rand() * 0.4;
      const A = { x: sx * 4.6, z: zA }, B = { x: -sx * 4.6, z: zB }, C = { x: -sx * 30, z: -6.8 };
      const L = Math.hypot(B.x - A.x, B.z - A.z), ux = (B.x - A.x) / L, uz = (B.z - A.z) / L;
      const k = (4.6 - 3.2) / Math.abs(ux); // 角から車道の端までの距離
      const D = sp * arrive;
      let x, z, path;
      if (D <= k) { x = A.x + ux * (k - D); z = A.z + uz * (k - D); path = [B, C]; }
      else { x = A.x; z = A.z - (D - k); path = [A, B, C]; }
      const p = mk({ type, fromEast, hedge: false, sp, x, z, ux: 0, uz: 1, path, phone: rand() < P.phoneRate });
      const t0 = path[0], d0 = Math.hypot(t0.x - x, t0.z - z) || 1; p.ux = (t0.x - x) / d0; p.uz = (t0.z - z) / d0;
      continue;
    }
    const edgeX = fromEast ? CROSS.xmax : CROSS.xmin;
    const base = { type, fromEast, hedge: fromEast, sp, ux: dir, uz: 0, phone };
    if (type === 'group') {
      const m = 2 + (rand() < 0.4 ? 1 : 0), offs = [[0, 0], [0.7, 0.45], [1.3, -0.45]];
      for (let j = 0; j < m; j++) mk({ ...base, phone: j === 0 ? phone : false, x: edgeX - dir * sp * (arrive + offs[j][0]), z: PED_Z + offs[j][1] });
    } else {
      mk({ ...base, hes: type === 'hesitate' ? (S.hes ?? 1 + rand() * 3) : 0, x: edgeX - dir * sp * arrive, z: PED_Z });
    }
  }
  // 歩道を通り過ぎるだけの人（交差点は渡らない。見た目の人通り）
  const amb = [];
  { const na = P.ambient[0] + Math.floor(rand() * (P.ambient[1] - P.ambient[0] + 1));
    for (let i = 0; i < na; i++) {
      const sp = P.walk[0] + rand() * (P.walk[1] - P.walk[0]), kind = rand();
      if (kind < 0.6) { const d = rand() < 0.5 ? 1 : -1; amb.push({ id: 100 + i, x: -28 + rand() * 56, z: 5.0 + rand() * 0.8, ux: d, uz: 0, sp }); }
      else { const side = rand() < 0.5 ? -1 : 1; amb.push({ id: 100 + i, x: side * (4.3 + rand() * 0.6), z: -9 - rand() * 18, ux: 0, uz: -1, sp }); }
    } }
  const guideClear = SC && SC.guideClear !== undefined ? SC.guideClear : rand() < P.guideClear;
  const trustGuide = SC && SC.trustGuide !== undefined ? SC.trustGuide : rand() < P.operatorTrustGuide;
  // 渡る人がいない通過は、結果がいつも同じ。仕組み・道・夕方ごとに一度だけ計算して使い回す（1年を速く回すため）
  const ck = !peds.length && !opts.record && !FAULT ? JSON.stringify(cfg) + RT.name + evening : null;
  if (ck && EMPTY_CACHE.has(ck)) return EMPTY_CACHE.get(ck);
  bus = { s: 0, v: Math.max(vmax, P.cruise), a: 0, state: 'approach', stopT: 0, brakeAt: null, brakeSrc: null, off: 0, yaw: 0 };
  const ev = []; const frames = [];
  let startedBy = null, guideRaised = false, hitCtx = null, faultOn = false, faultT = null, curbT = null, crash = null, mrm = false, mrmBlock = false, recover = 0, steerFixed = false;
  const tried = {}; // 止める手段ごとに、指示を出した時刻と届いたか
  const log = (t, k, text, extra) => ev.push({ t: +t.toFixed(2), k, text, ...(extra || {}) });
  // 止める指示を出す。通り道が切れていれば届かない（記録だけ残る）
  const command = (src, t, delay, k, text, early = false) => {
    if (!tried[src]) tried[src] = { t, ok: chOk(src) };
    if (!chOk(src)) { if (!failed.has(src)) { failed.add(src); log(t, 'nodeliver', `${text}。しかし指示は${src === 'remote' && broken.has('net') ? '、通信が切れていて届かない' : '車体に届かない'}`, { src }); } return false; }
    if (bus.brakeAt === null || (early && bus.brakeAt > t + delay)) { bus.brakeAt = t + delay; bus.brakeSrc = src; log(t, k, text, { src }); return true; }
    return false;
  };
  if (prevented) log(0, 'prevented', prevented === 'maint' ? `点検で「${FAULT_LABEL[FAULT]}」を見つけ、運行の前に直した（その日の朝の2便は運休）` : `試走で「${FAULT_LABEL[FAULT]}」を見つけ、更新を戻した`);
  log(0, 'route', `バスは${RT.label}${RT.name === 'er' ? '（対向車線を横切る）' : ''}`);
  if (fault === 'update') log(0, 'fault', '先週ソフトを更新した。止まる位置が、いつもより先になっている（誰も知らない）', { fault });
  let detectedLogged = false;
  const T = P.passTime;
  const blinkAt = (s) => (s > RT.arcStart - 15 && s < RT.arcEnd ? (RT.turn > 0 ? 'L' : 'R') : '');
  for (let step = 0; step * P.dt < T; step++) {
    const t = step * P.dt;
    // 不具合を差し込む
    if (fault && !faultOn) {
      const at = fault === 'brake' ? bus.s >= STOP0 - 30 : fault === 'steer' ? bus.state === 'go' && bus.s >= STOP0 - 0.1 : fault === 'comm' ? bus.s >= RT.arcStart - 2 : fault === 'update' ? bus.s >= STOP0 - 0.3 && bus.v > 0.3 : false;
      if (at) {
        faultOn = true; faultT = t;
        const cut = fault === 'brake' ? 'ads' : fault === 'comm' ? 'net' : null; if (cut && bus.brakeSrc && CHANNELS[bus.brakeSrc].includes(cut)) { bus.brakeAt = null; bus.brakeSrc = null; } // 出ていた指示も届かなくなる
        if (fault === 'brake') { broken.add('ads'); log(t, 'fault', 'ブレーキの指示が車体に届かなくなった（自動運転の装置と車体のあいだの通信の設定ミス）。エラーが表示される', { fault }); }
        if (fault === 'steer') log(t, 'fault', '動き出したが、ハンドルの動きが遅れて曲がりきれず、外へふくらむ', { fault });
        if (fault === 'update') log(t, 'fault', 'いつもの位置を過ぎても止まらない（更新で止まる位置が先へずれていた）', { fault });
        if (fault === 'comm') {
          broken.add('net');
          if (!remote) log(t, 'fault', '遠くのセンターとの通信が切れた。車内に人がいるので、運行には影響しない', { fault });
          else if (cfg.commLoss === 'stop') { mrm = true; log(t, 'fault', '遠隔監視者との通信が切れた。バスはその場で止まる作り', { fault }); }
          else log(t, 'fault', '遠隔監視者との通信が切れた。バスは走り続ける作り。見張る人がいなくなる', { fault });
        }
      }
    }
    // 不具合への人の対応（気づくまでの時間のあとで、自分の手段で止める・直す）
    if (faultOn && fault === 'brake') {
      if (MODE === 'l2' && t >= faultT + P.driverNotice) command('pedal', t, 0, 'opbrake', '運転士がエラーに気づき、足でブレーキを踏んだ');
      if (MODE === 'l4in' && t >= faultT + P.estopReaction) command('estop', t, 0, 'opbrake', '車内の主任者がエラーに気づき、非常停止を押した');
      if (remote && t >= faultT + P.remoteReaction * (MODE === 'l4r3' ? 1.5 : 1)) command('remote', t, 0, 'remote', '遠隔監視者がエラーに気づき、停止を指示');
    }
    if (faultOn && fault === 'steer' && !steerFixed) {
      if (MODE === 'l2' && t >= faultT + P.operatorReaction) { steerFixed = true; log(t, 'steerfix', '運転士がハンドルを切って、道へ戻しはじめた'); }
      if (MODE === 'l4in' && t >= faultT + 2.0) command('estop', t, 0, 'opbrake', '車内の主任者がふくらみに気づき、非常停止を押した');
      if (remote && t >= faultT + (P.remoteReaction + 1) * (MODE === 'l4r3' ? 1.5 : 1)) command('remote', t, 0, 'remote', '遠隔監視者が映像でふくらみに気づき、停止を指示した');
    }
    if (faultOn && fault === 'update' && MODE === 'l2' && !tried.pedal && t >= faultT + P.updateNotice && (SC ? (SC.peds[0] || {}).missRoll ?? 0.5 : 0.5) >= missP) command('pedal', t, 0, 'opbrake', '運転士が「いつもの所で止まらない」と気づき、ブレーキを踏んだ');
    const ps = pose(bus.s);
    const fx = ps.x + Math.cos(ps.h) * BUS_L / 2, fz = ps.z - Math.sin(ps.h) * BUS_L / 2;
    // センサー：前の範囲で、植え込みの陰でない人
    const sees = (p) => {
      const dx = p.x - fx, dz = p.z - fz, d = Math.hypot(dx, dz);
      if (d > range) return false;
      const ang = Math.atan2(-dz, dx) - ps.h; const a = Math.abs(Math.atan2(Math.sin(ang), Math.cos(ang))) * 180 / Math.PI;
      if (a > sens.half) return false;
      if (cfg.sensor !== 'wide' && blocked(cfg, fx, fz, p.x, p.z)) return false;
      return true;
    };
    // オペレーターの目（車内の前）
    const opSees = (p) => Math.hypot(p.x - fx, p.z - fz) < 25 && !blocked(cfg, fx, fz, p.x, p.z);
    // 発進の前に気にする場所：横断歩道と、その先の脇道（斜めに渡る人）
    const conflict = (p, pad) => !p.waitBus && !p.stand && (inCross(p.x, p.z, pad) || (Math.abs(p.x) < 3.2 + pad && p.z < -3.5 && p.z > -11)); // 下がってバスを待っている人は、バスに道をゆずっている
    const live = peds.filter((p) => !p.gone);
    const sensed = live.filter(sees);
    if (cfg.sensor !== 'wide' && bus.v > 0.3) for (const p of live) if (!p.sensedOnce) { if (sees(p)) p.sensedOnce = true; else { const W = P.sensorWide, dx = p.x - fx, dz = p.z - fz, d = Math.hypot(dx, dz), ang = Math.atan2(-dz, dx) - ps.h, a = Math.abs(Math.atan2(Math.sin(ang), Math.cos(ang))) * 180 / Math.PI; if (d < W.range * (evening ? P.eveningRange : 1) && a < W.half) p.wideWouldSee = true; } }
    // これから通る道の上（車体の幅＋余裕）に人がいるか。いれば、前の端からその場所までの道のりを返す
    const look = 2 + bus.v * 3;
    // horizon 秒先の、歩いている人の位置も見る（先読み）
    const onPath = (p, horizon = 0) => {
      const far = look + 3 + horizon * 1.5; if (Math.abs(p.x - fx) > far || Math.abs(p.z - fz) > far) return null;
      if (!pathPts) { pathPts = []; for (let q = -0.3; q <= look; q += 0.8) { const pp = RT.fast(bus.s + BUS_L / 2 + q); pathPts.push(pp.x, pp.z, q); } }
      const key = p.id * 10 + horizon; if (memo.has(key)) return memo.get(key);
      const r2 = (BUS_W / 2 + (p.waitBus ? 0.2 : 0.5)) ** 2, n = horizon > 0 && p.moving !== false ? 2 : 1;
      for (let i = 0; i < pathPts.length; i += 3) for (let k = 0; k < n; k++) {
        const x = p.x + p.ux * p.sp * horizon * k, z = p.z + p.uz * p.sp * horizon * k, dx = x - pathPts[i], dz = z - pathPts[i + 1];
        if (dx * dx + dz * dz < r2) { const v = Math.max(0, pathPts[i + 2]); memo.set(key, v); return v; }
      }
      memo.set(key, null); return null;
    };
    let pathPts = null; const memo = new Map();
    const senseH = cfg.sensor === 'wide' ? P.predictWide : P.predictNormal;
    if (bus.state === 'approach' || bus.state === 'go') {
      const reach = bus.v * P.reaction + bus.v * bus.v / (2 * P.emergencyDecel) + 1.0;
      const danger = bus.v > 0.2 && sensed.find((p) => { const q = onPath(p, senseH); return q !== null && q < reach; });
      const opDanger = onboard && bus.v > 0.2 && live.find((p) => { if (!opSees(p) || p.missed) return false; const q = onPath(p, P.predictOp); return q !== null && q < reach + 0.5; });
      if (danger) danger.reacted = true; if (opDanger) opDanger.reacted = true;
      if (danger) command('ads', t, P.reaction, 'sensed', 'センサーが歩行者を感知し、自動ブレーキ', true);
      if (opDanger) command(MODE === 'l2' ? 'pedal' : 'estop', t, P.operatorReaction, 'opbrake', MODE === 'l2' ? '運転士が非常ブレーキ' : '車内の主任者が非常停止');
      // オペレーターが乗らないとき：遠くの担当が、バスのカメラの映像で気づいて止める（通信と気づくまでの分だけ遅れる）
      const remoteDanger = remote && bus.v > 0.2 && sensed.find((p) => { if (p.missed) return false; const q = onPath(p, P.predictOp); return q !== null && q < reach + 1.5; });
      if (remoteDanger) remoteDanger.reacted = true;
      if (remoteDanger) command('remote', t, P.remoteReaction * (MODE === 'l4r3' ? 1.5 : 1), 'remote', '遠隔監視者が映像で気づき、停止を指示'); // 3台を見ていると、気づいて指示を出すまでが遅れる
      // 止まったあと、道の前が空いたらブレーキを解く
      // （近くの人が2秒先までに道に入らないことを確かめ、止まってから1秒は待つ）
      if (bus.v === 0 && bus.brakeAt !== null && t >= bus.brakeAt && !(faultOn && (fault === 'brake' || fault === 'steer'))) { bus.heldT = (bus.heldT || 0) + P.dt; if (bus.heldT > 1.0 && !live.some((p) => { const q = onPath(p, 2.0); return q !== null && q < 4; })) { bus.brakeAt = null; bus.heldT = 0; } }
    }
    const braking = bus.brakeAt !== null && t >= bus.brakeAt;
    if (bus.state === 'approach') {
      if (sensed.some((p) => conflict(p, 3)) && !detectedLogged) { log(t, 'sensor', 'センサーが横断歩道のまわりに人を感知'); detectedLogged = true; }
    } else if (bus.state === 'stopped') {
      let clear;
      if (!humanStart) clear = !sensed.some((p) => conflict(p, cfg.sensor === 'wide' ? 3 : 1)); // ふつうのセンサーは、横断歩道に向かってくる人を先読みしない
      else {
        const seen = live.filter(opSees);
        const pad = cfg.guide && trustGuide ? 0.5 : 3;
        clear = !seen.some((p) => conflict(p, pad) && !p.missed);
      }
      if (clear && t - bus.stopT > 1.5) {
        bus.state = 'go'; startedBy = humanStart ? 'human' : 'bus';
        log(t, 'start', !humanStart ? 'バスが自分で「渡る人はいない」と判断して発進' : '運転士が発進させる');
        if (cfg.guide) { guideRaised = true; log(t, 'guide', guideClear ? '誘導員が歩行者に「止まれ」の合図（はっきり伝わる）' : '誘導員が手を水平に上げる（どちらへの合図か、あいまい）'); }
        if (humanStart && cfg.guide && trustGuide) log(t, 'trust', '運転士は「誘導員が歩行者を止めてくれる」と読んだ');
      }
    }
    // 速さの目標：設定の速さ → 曲がる前の減速 → 横断歩道の手前で止まる
    const zs = STOP - P.zoneBefore, ze = RT.arcEnd + P.zoneAfter, cruise = Math.max(vmax, P.cruise);
    let vT = bus.s < zs ? Math.min(cruise, Math.sqrt(vmax * vmax + 2 * P.comfortDecel * (zs - bus.s))) : bus.s > ze ? cruise : vmax;
    const vC = Math.sqrt(P.latAcc * RT.R);
    if (bus.s < RT.arcEnd) vT = Math.min(vT, Math.sqrt(vC * vC + 2 * P.comfortDecel * Math.max(0, RT.arcStart - bus.s)));
    if (bus.state === 'approach') vT = Math.min(vT, Math.sqrt(2 * P.comfortDecel * Math.max(0, STOP - bus.s - 0.02)));
    if (bus.state === 'stopped' || bus.state === 'after' || mrm) vT = 0;
    let aWant, J = P.jerk;
    const adsDead = broken.has('ads');
    if (braking) { aWant = -P.emergencyDecel; J = 25; }
    else if (adsDead) aWant = -P.coast; // 自動運転の装置からの指示が届かない：アクセルも減速も効かず、転がるだけ
    else if (bus.brakeAt !== null) aWant = Math.min(bus.a, 0); // 気づいてからブレーキが効くまで
    else aWant = Math.max(-P.trackDecel, Math.min(P.accel, (vT - bus.v) / 0.7));
    bus.a = Math.max(bus.a - J * P.dt, Math.min(bus.a + J * P.dt, aWant));
    bus.v = Math.max(0, bus.v + bus.a * P.dt);
    if (bus.v === 0 && bus.a < 0) bus.a = 0;
    if (bus.state === 'approach' && !adsDead && STOP - bus.s < 0.06 && bus.v < 0.25) { bus.v = 0; bus.a = 0; bus.brakeAt = null; bus.state = 'stopped'; bus.stopT = t; log(t, 'stop', fault === 'update' && bus.brakeAt === null ? `横断歩道の上（いつもより${P.updateShift}m先）で止まった` : '横断歩道の手前で一時停止'); }
    bus.s += bus.v * P.dt;
    if (bus.state === 'approach' && !adsDead && bus.s > STOP) bus.s = STOP;
    if (adsDead && bus.state === 'approach' && bus.s > STOP0) bus.state = 'go'; // 止まれずに横断歩道を越えた
    // 外へふくらむ：曲がる途中で速すぎるとき、またはハンドルが遅れるとき
    { const onArc = bus.s > RT.arcStart && bus.s < RT.arcEnd, vSafe = Math.sqrt(P.latMax * RT.R); let d = 0;
      if (onArc && bus.v > vSafe) d += (bus.v - vSafe) * 0.8;
      if (faultOn && fault === 'steer' && !steerFixed && bus.s < RT.arcEnd + 15) d += P.steerLag * bus.v;
      if (steerFixed && bus.off > 0) d -= P.steerCorrect;
      const before = bus.off; bus.off = Math.max(0, bus.off + d * P.dt); bus.yaw = bus.v > 0.3 ? Math.atan2(bus.off - before, bus.v * P.dt) * -RT.turn * 0.6 : bus.yaw; }
    // その場で止まる作り（通信が切れたとき）：止まったら、現場に人が来るまで動けない
    if (mrm && bus.v < 0.05) { bus.v = 0; bus.a = 0; }
    if (mrm && bus.v === 0 && !recover) { recover = P.recoverSec; const p0 = pose(bus.s); mrmBlock = Math.abs(p0.x) < 7 && p0.z > -9 && p0.z < 4; log(t, 'mrm', mrmBlock ? 'バスが交差点の中で止まり、ほかの車の通り道をふさいだ。現場に人が来るまで動かせない' : 'バスがその場で止まった。現場に人が来るまで動かせない'); }
    // 車体の四隅：歩道（縁石）に乗ったか、建物にぶつかったか
    { const p0 = pose(bus.s), c = Math.cos(p0.h), sn = Math.sin(p0.h);
      for (const [u, w] of [[BUS_L / 2, BUS_W / 2], [BUS_L / 2, -BUS_W / 2], [-BUS_L / 2, BUS_W / 2], [-BUS_L / 2, -BUS_W / 2]]) {
        const x = p0.x + u * c + w * sn, z = p0.z - u * sn + w * c;
        if (curbT === null && bus.v > 0.3 && bus.off > 0.3 && !onRoad(x, z)) { curbT = t; log(t, 'curb', `バスが縁石に乗り上げ、歩道に入った（時速${Math.round(bus.v * 3.6)}km）`, { kmh: Math.round(bus.v * 3.6), x, z }); }
        if (!crash && bus.v > 0.3 && BUILDINGS.some((b) => x > b[0] && x < b[1] && z > b[2] && z < b[3])) { crash = { kmh: Math.round(bus.v * 3.6), x, z }; log(t, 'building', `バスが角の建物にぶつかった（時速${crash.kmh}km）`, { x, z, kmh: crash.kmh }); bus.v = 0; bus.a = 0; bus.state = 'after'; }
      } }
    // 歩く人
    const ps2 = pose(bus.s);
    for (const p of peds) {
      if (p.gone || p.hit) continue;
      const nx = p.x + p.ux * 1.2, nz = p.z + p.uz * 1.2; // 車道の縁から少し下がったところで待つ
      const atEdge = !inSideRoad(p.x, p.z) && inSideRoad(nx, nz);
      const dBus = Math.hypot(ps2.x - p.x, ps2.z - p.z);
      const busMovingNear = bus.v > 0.3 && dBus < 7;
      let stop = false;
      if (atEdge) {
        if (p.hes > 0) { stop = true; p.hes -= P.dt; } // 渡るか迷って、端で立ち止まる
        else if (p.type === 'hurry') { if (bus.v > 0.3 && dBus < 3.5) stop = true; } // 急いでいる人は、すぐそばに来るまで止まらない
        else if (!p.phone && busMovingNear) stop = true;
        if (guideRaised && guideClear && bus.state === 'go' && busMovingNear) { stop = true; p.stoppedByGuide = true; }
      }
      // 目の前にバスの車体があれば、スマホを見ていても止まる（自分から車体にぶつかりには行かない）
      const blockedAhead = distToBus(ps2, p.x + p.ux * 1.0, p.z + p.uz * 1.0) < 0.9; // 車体との間を1mより詰めない
      if (!stop && blockedAhead) {
        stop = true;
        // 止まったバスに道をふさがれたままなら、少し下がってバスから離れる（引き返しはしない）
        if (bus.v < 0.1) { p.blockT = (p.blockT || 0) + P.dt; if (p.blockT > 1.5 && !p.backed) { p.back = 3; p.backed = true; } }
      }
      // 動いているバスがすぐ近くに来たら、その場から少し離れる
      if (bus.v > 0.3 && distToBus(ps2, p.x, p.z) < (p.phone ? 0.9 : 2.0) && !(p.back > 0) && !p.waitBus) { p.back = 2.0; p.reacted = distToBus(ps2, p.x, p.z) < 1.2; } // スマホを見ていない人は、2m以内に来たら早めに離れる
      if (p.back > 0) {
        // バスの進む向きに対して横へ、車体の通り道の外まで下がる（最大3m）
        const c = Math.cos(ps2.h), sn = Math.sin(ps2.h), w = (p.x - ps2.x) * sn + (p.z - ps2.z) * c, sg = w >= 0 ? 1 : -1;
        if (Math.abs(w) < BUS_W / 2 + 0.6 && p.back > 0) { const step = 1.0 * P.dt; p.x += sn * sg * step; p.z += c * sg * step; p.back -= step; }
        else p.back = 0;
        stop = true;
        if (p.back <= 0) p.waitBus = true;
      }
      // 下がったあとは、進もうとしていた方向の先がバスで空くまで待ち、空いたら元の向きに渡る
      // お互いに待ってしまったら、人のほうが来た道を少し戻って歩道まで下がり、バスを先に通す（向きは変えない）
      if (p.waitBus && bus.v < 0.1) { p.waitT = (p.waitT || 0) + P.dt; if (p.waitT > 3 && !p.retreated) { p.retreat = 2.5; p.retreated = true; } }
      if (p.retreat > 0) { const step = Math.min(p.retreat, 1.0 * P.dt); p.retreat -= step; p.x -= p.ux * step; p.z -= p.uz * step; stop = true; }
      else if (p.waitBus) { if (distToBus(ps2, p.x + p.ux * 2.0, p.z + p.uz * 2.0) < 1.0 || (bus.v > 0.3 && distToBus(ps2, p.x, p.z) < 3)) stop = true; else { p.waitBus = false; p.blockT = 0; p.backed = false; p.waitT = 0; p.retreated = false; } }
      p.moving = !stop;
      if (!stop) {
        p.x += p.ux * p.sp * P.dt; p.z += p.uz * p.sp * P.dt;
        // 曲がり角（道筋の点）に着いたら、次の点へ向きを変える
        if (p.path && p.path.length) { const w = p.path[0]; if ((w.x - p.x) * p.ux + (w.z - p.z) * p.uz <= 0) { p.path.shift(); const nw = p.path[0]; if (nw) { const d = Math.hypot(nw.x - p.x, nw.z - p.z) || 1; p.ux = (nw.x - p.x) / d; p.uz = (nw.z - p.z) / d; } } }
      }
      if (Math.abs(p.x) > 30 || p.z < -40 || p.z > 30) p.gone = true;
      const d = distToBus(ps2, p.x, p.z) - P.pedR;
      // ひやりは、動いているバスに1mより近づいたときだけ数える。そのときの様子を残す（原因を示すため）
      if (bus.v > 1.0 && d < p.minD) { p.minD = d; p.ctx = { state: bus.state, kmh: Math.round(bus.v * 3.6), blocked: blocked(cfg, fx, fz, p.x, p.z) || !!p.hedgeHidden, braking: bus.brakeAt !== null && t >= bus.brakeAt, onSidewalk: !!p.stand }; }
      if (d <= 0 && !p.hit && bus.v > 0.3) { p.hit = true; hitCtx = { state: bus.state, kmh: Math.round(bus.v * 3.6), blocked: blocked(cfg, fx, fz, p.x, p.z), braking: bus.brakeAt !== null && t >= bus.brakeAt, onSidewalk: !!p.stand }; log(t, 'hit', `止まりきる前に、バスと歩行者が接触（バスは時速${(bus.v * 3.6).toFixed(0)}km）`, { x: p.x, z: p.z, kmh: Math.round(bus.v * 3.6) }); bus.v = 0; bus.state = 'after'; }
    }
    if (opts.record) for (const a of amb) { a.x += a.ux * a.sp * P.dt; a.z += a.uz * a.sp * P.dt; }
    if (opts.record && step % 5 === 0) frames.push({ t: +t.toFixed(1), bus: { ...ps2, s: bus.s, v: bus.v, off: +bus.off.toFixed(2), blink: blinkAt(bus.s) },
      peds: peds.filter((p) => !p.gone).map((p) => ({ id: p.id, x: p.x, z: p.z, phone: p.phone, type: p.type })).concat(amb.filter((a) => Math.abs(a.x) < 32 && a.z > -42).map((a) => ({ id: a.id, x: a.x, z: a.z, type: 'ambient' }))), guide: guideRaised });
    if (bus.state === 'after') { if (!opts.record || t > (ev.find((x) => x.k === 'hit' || x.k === 'building') || { t: 0 }).t + 4) break; }
    if (faultOn && (fault === 'brake' || fault === 'steer') && bus.v === 0 && bus.brakeAt !== null && t > Math.max(faultT, bus.brakeAt) + (opts.record ? 5 : 0.5)) { if (!ev.some((e) => e.k === 'halted')) log(t, 'halted', 'バスは止まったまま。点検のため、この便はここで運休'); break; }
    if (recover && (!opts.record || t > ev.find((x) => x.k === 'mrm').t + 6)) break;
    if (bus.s > STOP0 + 40) break; // 交差点の先まで走り切ったら終わり
  }
  const hitPedAny = peds.some((p) => p.hit), hit = hitPedAny || !!crash;
  // ひやり：動いているバスと1mより近づき、しかも急ブレーキか、人が飛びのくかした
  const nearPeds = peds.filter((p) => p.minD < P.nearMiss && p.reacted);
  const near = !hit && (nearPeds.length > 0 || curbT !== null);
  const np = near && nearPeds.length ? nearPeds.reduce((a, b) => (b.minD < a.minD ? b : a)) : null;
  const hitPed = peds.find((p) => p.hit);
  const wait = (ev.find((e) => e.k === 'start') && ev.find((e) => e.k === 'stop') ? ev.find((e) => e.k === 'start').t - ev.find((e) => e.k === 'stop').t : 0) + recover;
  if (ck) { const res = { hit: false, near: false, wait: Math.max(0, wait), events: [], frames: [], route: RT.name, nearFacts: null, facts: null }; EMPTY_CACHE.set(ck, res); return res; }
  // 記録から決まる共通の事実（説明はこれだけから作る）
  const common = { mode: MODE, route: RT.name, evening, startedBy, guideRaised, guideClear, trustGuide, fault: FAULT, faultOn, prevented, commLoss: cfg.commLoss,
    tried: Object.fromEntries(Object.entries(tried).map(([k, v]) => [k, { t: +v.t.toFixed(1), ok: v.ok }])), curb: curbT !== null, mrm: !!recover, mrmBlock, brakeSrc: bus.brakeSrc };
  const pedFacts = (p) => ({ id: p.id, pedType: p.type, phone: p.phone, missed: p.missed, hedge: p.hedge && RT.enters, sensorLimit: !!p.wideWouldSee });
  let nearFacts = null;
  if (np) nearFacts = { ...common, target: 'ped', dist: Math.max(0, np.minD), ...pedFacts(np), ...np.ctx };
  else if (near) nearFacts = { ...common, target: 'curb', kmh: (ev.find((e) => e.k === 'curb') || {}).kmh, state: bus.state };
  let facts = null;
  if (hitPed) facts = { ...common, target: 'ped', ...hitCtx, ...pedFacts(hitPed), fromBehindHedge: hitPed.hedge && RT.enters };
  else if (crash) facts = { ...common, target: 'building', kmh: crash.kmh, state: 'go' };
  const issueFacts = !hit && !near && FAULT ? { ...common, target: null } : null; // 事故もひやりもないが、不具合で問題が出た（運休・交差点をふさぐ・見張りのない時間など）
  return { hit, near, wait: Math.max(0, wait), events: ev, frames, route: RT.name, nearFacts, facts, issueFacts, prevented, mrm: !!recover, mrmBlock };
}

export function cost(cfg) {
  const c = PARAMS.cost; let v = c.base;
  if (cfg.sensor === 'wide') v += c.sensorWide;
  if (cfg.guide) v += c.guide;
  if (cfg.route === 'long') v += c.detour;
  const m = cfg.mode || 'l2'; v += m === 'l2' || m === 'l4in' ? c.onboard : m === 'l4r1' ? c.remote1 : c.remote3;
  if (cfg.rest) v += c.rest;
  if (cfg.maint === 'often') v += c.maint;
  if (cfg.update === 'test') v += c.update;
  return v;
}

// 1年を回す。事故の通過は seed を残し、あとで記録つきで再計算する
export function simulateYear(cfg, seed = 1) {
  const P = PARAMS, out = { accidents: [], nears: [], faults: [], near: 0, waitSum: 0, passes: 0, daily: [] };
  let k = 0;
  for (let d = 0; d < P.daysPerYear; d++) {
    let acc = 0, nr = 0;
    for (let i = 0; i < P.passesPerDay; i++) {
      const passSeed = (seed * 1000003 + k++) >>> 0;
      const evening = i >= 34 && i < 37;
      const fault = drawFault(cfg, passSeed);
      const r = simulatePass(cfg, rng(passSeed), { evening, fault });
      out.passes++; out.waitSum += r.wait + (cfg.route === 'long' ? P.detourSec : 0);
      if (fault) out.faults.push({ day: d, pass: i, fault, kind: r.hit ? 'hit' : r.near ? 'near' : 'safe' });
      if (r.hit) { acc++; out.accidents.push({ day: d, pass: i, seed: passSeed, evening, fault, facts: r.facts }); }
      if (r.near) { nr++; out.near++; out.nears.push({ day: d, pass: i, seed: passSeed, evening, fault, facts: r.nearFacts }); }
    }
    out.daily.push({ acc, near: nr });
  }
  out.delayAvgMin = out.waitSum / out.passes / 60;
  out.cost = cost(cfg);
  return out;
}

// 外へふくらんだ分を足したバスの位置（再生で、記録の間をつなぐときに使う）
export function poseOff(route, s, off) { const RT = ROUTES[route], p = RT.pose(s); if (!off) return p; const l = leftOf(p.h), k = -RT.turn * off; return { x: p.x + l.x * k, z: p.z + l.z * k, h: p.h }; }
// 1年回すとき、その回に不具合が起きるか（歩く人の乱数とは別の乱数で決める）
export function drawFault(cfg, passSeed) {
  const fr = rng(passSeed ^ 0x5bd1e995)(), R = PARAMS.faultRate; let acc = 0;
  for (const [f, p] of [['brake', R.brake[cfg.maint === 'often' ? 0 : 1]], ['steer', R.steer[cfg.maint === 'often' ? 0 : 1]], ['update', R.update[cfg.update === 'test' ? 0 : 1]], ['comm', R.comm]]) { acc += p; if (fr < acc) return f; }
  return null;
}
