# フィジカルAIの社会実装シミュレーション Log#1 | 自動運転バスの事故、責任はどこへ移るか

- 記録: LOG538（フィジカルAIの社会実装シミュレーション）
- 公開: 2026/11/20
- 記事のページ: https://pixelstomotors.com/record/autonomous-bus-accident-responsibility-shift-simulation
- サイト: Pixels to Motors（ADAPT DESIGN / 島津 栄一） https://pixelstomotors.com/
- 要約: ブラウザで動かす自動運転バスのシミュレーションでは、同じ場面でも運行の形をレベル2の運転士からレベル4の遠隔監視に変えると、問題に挙がる相手が運転士からメーカー・運行会社・遠隔監視者へ移った。

> AI が読むための記事の全文です（コード・実行ログを含む）。引用するときは上の「記事のページ」の住所を使ってください。

---

**試作のシミュレーションは、こちらで動かせます：[事故が起きたら誰の責任？（ブラウザで動く試作）](https://pixelstomotors.com/sim/av-accident-responsibility.html)**

ブラウザで動かす自動運転バスのシミュレーションでは、同じ交差点で同じ歩行者がスマホを見ながら渡ってきても、運行の形を「レベル2・運転士が乗る」から「レベル4・遠隔監視者1人が3台を見る」に変えると、問題として挙がる相手が運転士から、遠隔監視者・メーカー・運行会社へ移った。**制度がまだ決めていないことも、「システムに任せて見ているだけの運転士に、どこまでの注意を求めるか」から「遠隔監視者1人が何台まで見てよいか」に入れ替わった。** 実物のバスではなく、three.js で描いたT字路を、自動運転バス1台と人が動くシミュレーションの話です。

この回で作った試作で、できるようになったことです。

- 場面（スマホを見ている人の見落とし・誘導員の合図を当てにした発進・右折中の横断歩道・脇道から出るバスの前・横断歩道の外を斜めに渡る人）を選び、運行の形・センサー・交差点での速さ・誘導員・植え込み・見る人の休憩・バスの来る向きを選んで、その1回を3Dで見られる
- ひやりや事故が起きると、右のパネルに「人の問題／企業の問題／決まり・行政」の3段と、「まだ決まっていないこと」が出る。法律の答えは出さず、関係しそうな決まりの名前だけを示す
- 設定を1つ変えてもう一度見ると、まえ・あとを並べて、問題から外れた相手と新しく問題になった相手が出る。自動再生にすると、設定を1つずつ変えた回が続けて流れ、最後に一覧で比べられる
- 時間：題材の調査から、動く試作の公開まで、1回のチャットの中で進めた。前と比べられる時間は測っていない

このシミュレーションは、[課題地図](https://pixelstomotors.com/issues)（フィジカルAIが社会に出る前に解くべき課題を42件まとめたページ）の「事故時の責任分界」を、一般の人が触って確かめられる形にしたものです。最初は、配膳ロボットの店のブラウザ版（[LOG506](https://pixelstomotors.com/record/serving-robot-store-sim-in-the-browser)）を土台に、病院の廊下でロボットの速さを変える題材を出しました。それは「見方が狭い」と言われ、世の中の触れるシミュレーターを調べ直しました。調べると、一般の人に広く使われた例（MIT の [Moral Machine](https://www.moralmachine.net/) や、気候政策の En-ROADS など）は、倫理・感染症・気候が題材で、ロボットやフィジカルAIを題材にした一般向けのものは見当たりませんでした。とくに、事故が起きたときに誰の責任かを体験させるものは空白でした。

困っていたのは、事故の責任は「誰が悪いか」の一言で語られやすいことです。調べると、日本で動いている自動運転バスの多くは人が乗る形で、事故は人の見落としだけでなく、システムが人を認識できなかったり、通信の設定ミスでブレーキがかからなかったり、手動から自動へ切り替えた瞬間に起きたりしていました。同じ事故でも、運行の形や会社の決め方によって、問われる相手が入れ替わります。そこを、決まった事故を見せるのではなく、見る人が仕組みを選んで動かしながら確かめられる形にしました。

| やったこと | 何を・なぜ | 結果 |
|---|---|---|
| 題材の調査 | 一般の人が触るシミュレーターを広く調べ、課題地図の9分類と重ねた | 「事故の責任分界」は一般向けがほぼ空白。題材を「事故が起きたら誰の責任？」に決めた |
| 舞台 | ファミレスでは事故がほぼ起きないので、自動で動く乗り物と人が交わる所にした | 自動運転バスとT字路（横断歩道・植え込み・誘導員） |
| バスの形 | 画像で3案を出して選び、three.js で組んだ | アーチ屋根の案。前後のガラスの角を丸くした |
| バスの動き | 直線でガクガク加減速していたので、加速度の変わり方に上限を付けた | 交差点の外は時速35km、手前14mから設定の速さに落とす |
| 人の動き | ひやりのあと道を引き返していたので、止まるか下がってから進む形にした | 人がバスから離れて待つ |
| 調査 | 自動運転バスの運行の形・事故・法律・行政の動きを36件にまとめ、Codex に事実確認をさせた | 「ちがう」は0件。11件を直し・補った |
| 計画 v3 | 目的を「回数を当てる」から「場面のパターンで、問題の出どころを確かめる」に改めた | 運行の形を3つに。作る順を7段に決めた |
| 試作 | 説明の3段・運行の形・場面を選ぶ画面と比べる画面・自動再生まで作った | 作る順の1〜3段目まで |
| 直し | 全部のバスが同じ向きから来る、設定を変えても絵が変わらない、を直した | 向きを選べるようにし、回ごとの設定で描くようにした |

[図解: LOG538_problem_shift.html](https://pixelstomotors.com/embeds/LOG538_problem_shift.html)

![場面「見ている人の見落とし」をレベル4・遠隔監視3台で再生した画面。バスが歩行者と接触し、右のパネルに人の問題・企業の問題・決まり・行政が並ぶ](https://pixelstomotors.com/media/LOG538_02_scene_card.png)

試作は、この回の終わりの時点のものをサイトに置きました（直す所はまだ多くあります）。次の回で問題点と直す所を見直し、シミュレーションの組み立てそのものと、結果をデータで書き出す仕組みに手を入れます。


## 作業ログ ― 題材は、一般の人が触るシミュレーターの調査から決めた

最初に出した題材は、病院の廊下で搬送ロボットの速さと、動きの伝え方を変える案でした。課題地図の42件のうち、動きや空間の課題だけを拾い、制度の課題（責任の所在など）は動かしても見えないとして外していました。これに対して、エイイチから次の指摘がありました。

> 見方が狭いですね。まずはこういったシミュレーターが世の中にどんなものがあるのかリサーチしてください。

調べた範囲は、社会課題を一般の人が条件を変えて体験できるもの全般（倫理・気候・感染症・都市交通・財政・雇用など）、ロボットの導入の試算ツールとデジタルツイン、日本の行政や企業の事例です。型で分けると、次の5つになりました。

| 型 | 代表例 | ロボットの分野の状況 |
|---|---|---|
| 試算型（条件を入れて数字を見る） | En-ROADS（気候政策）、ロボットの費用対効果の計算 | 多い。ただし売る側が作った一次元の計算が中心 |
| システム型（人や物が動き、全体の現象が出る） | ワシントン・ポストの感染のシミュレーション、A/B Street | 企業向けのデジタルツインだけ。一般向けは配膳ロボットのブラウザ版くらい |
| 判断型（選ぶことを迫る） | Moral Machine | 自動運転の倫理に偏っている。サービスロボットの責任は空白 |
| 体験型（自分の身に置き換える） | FT の Uber Game | 遠隔の操作者の視点の体験は空白 |
| 交渉型（多人数で決まりを作る） | Intelligence Rising、Balancing Act | ロボットの規格・公道の決まり・責任分界を扱うものは空白 |

課題地図の9分類と重ねると、「産業構造・SIer」「規格・標準」「事故の責任分界」「学習データ」は、一般向けのものがほぼありませんでした。そこで、配膳ロボットのブラウザ版と同じシステム型（人と乗り物が動く）の上に、判断型（どこに問題があるかを見る人が考える）を載せる形にし、題材を「事故が起きたら誰の責任？」に決めました。調査は「数字の多くは提供者の発表や二次報道による」「一般向けが無いという判断は、今回の調査範囲での話」という前提つきです。

### 舞台はファミレスから、自動運転バスのT字路へ

最初の企画は、ファミレスの店を舞台に、配膳ロボットの事故を扱う形でした。これはエイイチが不可としました。ファミレスでは事故はほとんど起きないので、実際に事故が起きうる状況にする必要があります。場面の土台は「自動で動く乗り物と人のあいだで、操作が切り替わるとき」に決まり、見る人は決まった事故を見て責任を配る側ではなく、仕組みを作る側（運行会社の担当）に立つことになりました。

舞台は、自動運転バスが通るT字路です。本道（東西）に脇道（北）がつながり、脇道の入口に横断歩道があります。横断歩道の右手には背の高い植え込みがあり、バスから見えにくい所ができます。誘導員を置くかどうかも選べます。

| 言葉 | 意味 |
|---|---|
| レベル2 | 車が加減速とハンドルを手伝い、運転士が常に見ていて責任を持つ形。日本の自動運転バスの多くはこの形か、次のレベル4で人が乗る形 |
| レベル4 | 決められた場所・条件の中では、車がすべて運転する形。日本では道路交通法の「特定自動運行」として、都道府県の公安委員会の許可が要る（2023年4月から） |
| 特定自動運行主任者 | レベル4の運行で、車内か遠くの監視室から装置の動きを確かめ、事故のときに通報や報告をする人 |
| 遠隔監視者 | このシミュレーションでの呼び名。車内は無人で、遠くの監視室から映像でバスを見て、危ないときに止める指示を出す人。1人が1台を見る形と、3台を見る形を選べる |
| 運行供用者 | 自動車損害賠償保障法（自賠法）で、事故の賠償を負う立場。自動運転では、運送する会社がこれに当たるという整理が進んでいる |
| ひやり | このシミュレーションでは、バスが秒速1mより速く動いている間に、人が1m以内まで近づき、どちらかがよけたり止まったりした回 |

### three.js は、ブラウザで3Dを描く道具

[three.js](https://threejs.org/) は、ブラウザの中で3Dの絵を描くための JavaScript の部品です。配膳ロボットのブラウザ版と同じく、このシミュレーションも three.js で交差点・バス・人を描き、1つの HTML ファイルの中で計算と描画をしています。サーバーは使いません。

| 言葉 | このシミュレーションでの使い方 |
|---|---|
| シーン | 交差点・建物・植え込み・バス・人をまとめた3Dの舞台 |
| カメラ | 斜め上・反対側・真上・バスの後ろの4つから選べる。ドラッグで回し、ホイールで寄る |
| フレーム | 計算は0.1秒ごと、記録は0.5秒ごとに残し、再生では間をなめらかにつないで描く |

計算は engine.js、画面は app.html に分けて書き、build.py で three.js と engine.js を1つの HTML に入れています（全文はこの記事の終わりの方）。


## 作業ログ ― 自動運転バスの形は、画像の3案から選んだ

バスの形は、先に画像で見比べてから作ることにしました。エイイチが挙げた条件は次のとおりです。

- 背が高く、床が低い
- 前後が同じ形で、前後のガラスは平ら
- 屋根の上のセンサー（ライダー）は小さく、目立たせない
- ウインカーは左右の両側に付ける（左側だけは不可）
- 実在の車両に寄せたデザインにはしない

ChatGPT で出した3案から、アーチ屋根の案（B）を選び、three.js で形を組みました。前後のガラスの角が四角いままだったので、角を丸くしました。

![three.js で組んだ自動運転バス。アーチ屋根で前後が同じ形、前後のガラスの角を丸くした。左から斜め前・斜め上・横](https://pixelstomotors.com/media/LOG538_05_bus_model.png)


## 作業ログ ― バスと人の動きを、実際のバスに近づけた

### バスは交差点の外を時速35kmで走り、手前で落とす

最初の版では、バスが直線の途中でも加速と減速を繰り返し、カクカク動いていました。速さの指示がコマごとに切り替わり、それにそのまま合わせていたためです。直したのは次の3つです。

- 加速度の変わり方（ジャーク）にも上限を付けた（秒あたり1.8m/s²）。急に踏み込む・急に離す動きがなくなる
- 曲がる前は、横に受ける力が大きくならない速さ（横方向3.0m/s²）まで先に落とす
- 再生のときは、0.5秒ごとの記録の間を、道の上の位置でなめらかにつなぐ

交差点の外の速さは、最初は時速20kmにしていました。これにはエイイチから指摘がありました。

> バスで20キロなんてただの実験車両だよ

調べると、日本のレベル4の運行は、塩尻市のミニバスがレベル4のとき最高時速35km、柏の葉の中型バスが最高時速40kmでした。エイイチの指定（時速35〜40km）に合わせ、交差点の外は時速35km、交差点の手前14mから抜けて4mまでは設定の速さ（6・10・15km）にしました。

- ねらい：バスの動きを見て、実際のバスと思える形にする
- 変わったこと：直線は一定の速さで走り、交差点の手前でなめらかに落とす。カクカクした加減速がなくなった
- 見込める効果：見る人が「動きが変だから起きた事故」と受け取らず、場面そのものの問題に目を向けられる（見込み。見た人の受け取り方は測っていない）

### 人は引き返さず、止まるか下がってから進む

最初の版では、ひやりのあと、人が来た道を引き返していました。これは不可とされました。

> 人が交差点でバスとヒヤリとした後に道を折り返して戻ってしまうのは意味がわからないのでNG。その場で止まるか、バスから離れる動作が良いです（その後に進もうとしていた道に向かう）

人の動きを、その場で止まる・バスから横へ離れる・少し下がる、の3つにし、バスが離れたら、もともと行こうとしていた方へ進むようにしました。人がみなバスに突っ込んでいく、という指摘もあったので、人はバスとの間合いを保って待つようにしています。引き返さなくなったぶん、バスと人が譲り合って動けなくなる回が出たので、バスの進路の判断から「譲って待っている人」を外しました。

人の歩き方は6つの型があります（ふつう・連れ立って・ゆっくり・急いで・渡るか迷う・横断歩道の外を斜めに）。人の色は、歩く人の型ではなく役割で分けています（黄＝渡る人、青＝誘導員、灰＝通り過ぎるだけの人）。


## 作業ログ ― 自動運転バスの運行の形と事故を、調べてから作り直した

画面の説明を作り始めたところで、エイイチから、今の自動運転バスの状況を一度調べた方がよい、行政の動きも調べてほしい、Codex にも事実確認をさせてほしい、という依頼がありました。調べた中身は36件の文（C01〜C36）にして、調査メモにまとめました。

| 分かったこと | 中身 |
|---|---|
| 運行の形 | 日本の自動運転バスの多くは人が乗る形（レベル2の運転士、または車内に主任者が乗るレベル4）。運転者のいないレベル4は、国交省によると2026年6月の時点で11か所・許可は延べ12件 |
| 事故の起き方 | 人の見落としだけでなく、システムの想定外（カメラで認識できないと止まらない作り、通信の設定ミスでブレーキがかからない、操舵の遅れ）と、人とシステムの受け渡し（手動から自動へ切り替えた瞬間、運転士の介入が間に合わない）で起きている |
| 人が問われた例 | 人が発進や運転を担っていた場面（車内のオペレーターが書類送検ののち不起訴、米国では安全運転者が有罪） |
| 企業が問われた例 | 事故そのものより、報告・説明・ソフト更新（報告から被害の一部を省いた、更新のあとに同じ事象が再発した） |
| 決まり・行政 | 民事（自賠法）は運送する会社が責任を負う整理が進んでいる。刑事責任と事故を調べる仕組みは検討中 |
| 事故がなくても止まる | 保守の期間が終わり、運行が当面休みになった町がある |

Codex の事実確認では、「ちがう」と判定された文はありませんでした。一部ちがう・古い・補足が11件あり、調査メモに「事実確認で直したこと」として足しました（例：1人で3台を見る装置の認可を取ったのは町ではなく産総研だった、事故の台数の「最大約500台」は裏付けがなかった）。「確かめられない」の多くは、短い確認では一次資料まで届かなかったもので、誤りの証明ではありません。

### 計画 v3：回数を当てる道具から、問題の出どころを確かめる道具へ

調査の途中で、エイイチがシミュレーションの目的を言い直しました。

> シミュレーションの大事なのはヒヤリや事故の回数をリアルな数字に合わせることではなくて、どんなシチュエーションだと人、企業、法律、問題があるというのをパターンによって検証したいということだよ。

それまでは、1年回したときの事故の件数を現実に近づける調整をしていました。この指示で目的を改め、計画を v3 に書き直しました。決めたことは3つです。

[図解: LOG538_plan_decisions.html](https://pixelstomotors.com/embeds/LOG538_plan_decisions.html)

- 運行の形は「乗る／乗らない」から3つ（レベル2・運転士／レベル4・車内に主任者／レベル4・遠隔監視、台数つき）にする
- 運行会社が決める選択肢に「点検・保守」と「ソフト更新の確かめ方」を足す（動作不良の場面と一緒に入れる）
- 作る順は、説明の3段 → 運行の形 → 場面を選ぶ画面と比較 → 動作不良の場面 → 受け渡しの場面 → 自転車・車・信号 → 1年回す形

場面は、問題の出どころで5つに分けました（まわりの人や車／バスの判断の誤り／バスの動作不良／人とシステムの受け渡し／運行が続かない）。各場面は、参考にした実際の流れを持ちますが、画面には実在の会社名・製品名・事故の名前を出しません。歩行者の手がかりは「前を見ていたか」「急いでいたか」などの行動だけにし、障害を事故の原因として扱いません。


## 作業ログ ― 説明の3段と、運行の形4つ

ひやりや事故が起きるたびに、右のパネルに次の形で出します。

- 何が起きたか（1行）
- 人の問題：運転士・主任者・遠隔監視者・誘導員・歩行者が、何を見落とし、何を守らなかったか
- 企業の問題：メーカー・運行会社（見る人自身）・道の管理者が、何を決め、何を備えなかったか
- 決まり・行政：関係しそうな決まりを名前で示す（道路交通法の特定自動運行、自賠法、製造物責任法、民事の過失、事故の報告）。法律上の答えは出さない
- まだ決まっていないこと：1つ（レベル4の事故で誰が刑事責任を負うか／遠隔監視者1人が何台まで見てよいか など）

運行の形は4つです。見る人の呼び名も形ごとに変えます（運転士・車内の主任者・遠隔監視者）。設定の項目の「見る人の休憩」の見出しも、それに合わせて変わります。

| 運行の形 | 止まったあとの発進 | 見落としの割合（休憩ありのとき） | 気づいてから止める指示まで |
|---|---|---|---|
| レベル2・運転士 | 運転士 | 5% の1.5倍 | 0.9秒 |
| レベル4・車内に主任者 | バス | 5% | 1.2秒 |
| レベル4・遠隔監視1台 | バス | 5% | 2.0秒 |
| レベル4・遠隔監視3台 | バス | 5% の2.5倍 | 2.0秒 |

この割合と秒数は、比べるための仮の値で、測った値ではありません。レベル2の見落としを多めにしているのは、システムに任せて見ているだけになり、注意が落ちることを表すためです。

言葉もいくつか直しました。「見張る人」は「遠隔監視者」に、「1日を1秒」は「早送り」に、パネルの見出し「この1年の仕組み」は「シミュレーション設定」に、「責任を配る」は「責任の割合を考える」にしました。「費用」の数字は、運行会社が安全のために払う分を比べる目安です。


## 作業ログ ― 場面を選んで確かめる画面と、比べる画面

中心の遊び方を「1年回す」から「場面を選んで確かめる」に変えました。場面は、歩く人の動き・誘導員の合図・バスの向きを決め打ちにし、見落とすかどうかの「くじ」の値も固定しています。くじの値が同じでも、見落としの割合は運行の形や休憩で変わるので、設定を変えると結果が変わります。

| 場面 | 何が起きるか | もとのバスの向き |
|---|---|---|
| 見ている人の見落とし | スマホを見ている人が、バスの発進のころに横断歩道へ入る | 西から来て左折 |
| 誘導員の合図を当てにした発進 | 誘導員の合図はあいまいで、運転する側は「止めてくれる」と読む（誘導員を置く設定のときだけ） | 西から来て左折 |
| 右折中の横断歩道 | 東から来たバスが、対向車線を横切って横断歩道へ向かう | 東から来て右折 |
| 脇道から出るバスの前へ | 本道へ出るバスの前を、人が横断歩道で渡る | 脇道から出て左折 |
| 横断歩道の外を斜めに渡る人 | 脇道に入ったバスの前を、横断歩道の先で斜めに渡る | 西から来て左折 |

植え込みの陰から人が来る場面も作りかけましたが、植え込みが人を隠す時間が短く、ぶつかりそうになる回が作れなかったので外しました。

![設定の画面。右に場面の一覧と、運行の形・センサー・速さ・誘導員・植え込み・休憩・バスの来る向きのボタン。左が交差点の3D](https://pixelstomotors.com/media/LOG538_01_setup.png)

1回見たあとは、「設定を変えて見直す」「前の回と比べる」「同じ設定でもう一度」を選べます。比べる画面は、まえ・あとの設定を並べ、変えた項目に色を付け、問題から外れた相手と新しく問題になった相手を上にまとめます。

![比べる画面。運行の形をレベル4・遠隔監視3台からレベル2・運転士に変えると、遠隔監視者・メーカー・運行会社が問題から外れ、運転士が新しく問題になった](https://pixelstomotors.com/media/LOG538_03_compare.png)

### 設定を1つずつ変えて流す自動再生

いろいろな設定を自動で流すボタンも足しました。いまの設定で1回、そのあと設定を1つずつ変えた回（場面の前提で変えられない項目は除く）を続けて再生し、最後に一覧で並べます。再生中も、これまでの回の結果を新しい順に開いて読めるようにし、一覧の行を押すと、その回の説明（場面を1回見たときと同じカード）が下に開きます。

![自動再生の一覧。場面「右折中の横断歩道」で設定を1つずつ変えた回の結果と、かかわる人、まだ決まっていないことが並ぶ。3行目を開いた所](https://pixelstomotors.com/media/LOG538_04_auto_summary.png)

画面の細かい直しとして、エイイチの指示で、説明のカードを横幅いっぱいにし、事故のカードの赤い枠の下に出ていた薄い赤の影を消し、カードの上下の余白をそろえました。選択肢の（）の中の文は、ボタンの下に小さく左寄せの注記として出しています。


## 作業ログ ― 全部のバスが同じ向きから来る、設定を変えても絵が変わらない

自動再生を見たエイイチから、2つの指摘がありました。

> 全部バスが同じ方向から来るようになっているね

> 全部シミュレーション描画が同じだよ？誘導員とか植え込みとか条件設定変えたらそれに合わせないと。

1つ目の原因は、場面ごとにバスの向きを1つに決めていたことでした。5つの場面のうち3つが「西から来て左折」で、自動再生は同じ場面を設定だけ変えて流すので、毎回同じ向きになっていました。設定に「バスの来る向き」を足し、場面を選ぶときだけ出すようにしました（1年回すときは、もともと回ごとに向きが変わります）。

向きを変えると、バスが横断歩道に着く時刻が変わり、人とのぶつかりそうな間合いが崩れます。そこで、向きごとにバスが横断歩道に着く時刻を計算し、人が車道に着く時刻をその差だけずらしました。それでも間合いが合わない向きがあったので、場面ごとに、ずらす秒数と、人が渡ってくる側を逆にするかを、設定の組み合わせ32通り（運行の形4×休憩2×センサー2×速さ2）を総当たりして選びました。選んだ基準は、もとの向きのときの結果の並びにどれだけ近いかです。

| 場面 | 西から左折 | 東から右折 | 脇道から出て左折 | 脇道から出て右折 |
|---|---|---|---|---|
| 見ている人の見落とし | もとの向き | +0.75秒 | +1.0秒・渡る側を逆に | +1.0秒・渡る側を逆に |
| 誘導員の合図を当てにした発進 | もとの向き | そのまま | −0.25秒・渡る側を逆に | 渡る側を逆に |
| 右折中の横断歩道 | そのまま | もとの向き | −0.25秒・渡る側を逆に | 渡る側を逆に |
| 脇道から出るバスの前へ | 渡る側を逆に | 渡る側を逆に | もとの向き | そのまま |
| 横断歩道の外を斜めに渡る人 | もとの向き | そのまま | 選べない | 選べない |

斜めに渡る人は脇道の奥を歩くので、脇道から出るバスとは道筋が交わりません。この場面では、脇道からの2つの向きを選べないようにし、ボタンの下に理由を出しています。

総当たりの結果、向きを変えた回の多くは「何も起きなかった」か「ひやり」止まりで、事故になるのはもとの向きだけでした。向きごとに事故まで起きるように詰めるかを尋ねたところ、エイイチの答えは、そこまでは必要ない、でした。向きによって危なさが違うことも、場面のパターンの一部として読めます。

2つ目の原因は、3Dの絵が、画面の設定（いま選んでいるボタン）を見て植え込みの高さと誘導員を描いていたことでした。自動再生では回ごとに設定を変えて計算していたのに、絵は最初の設定のままでした。再生を始めるときに、その回の設定を3Dに渡し、植え込みの高さと誘導員の有無をその設定で描くようにしました。

- ねらい：自動再生で、設定を変えた回の違いが3Dでも見えるようにする
- 変わったこと：「低く刈ってもらう」の回は植え込みが低くなり、「置く」の回にだけ誘導員が立つ。バスも向きを変えた回はその方向から来る
- 見込める効果：結果のカードを読まなくても、何を変えた回かが絵で分かる（見込み。縮めた画面では誘導員の出入りを確かめきれていない）

### 運行の形を変えた結果（場面3つ×運行の形4つ）

図解の元にした12回の結果です。ブラウザの試作で、場面ごとに運行の形だけを変えて再生し、右のパネルの文をそのまま書き出しました（ほかの設定はセンサー・ふつう、時速10km、誘導員を置く、植え込みはそのまま、休憩をこまめに入れる）。

```json
{
 "miss_0": "事故\n見ている人の見落とし\n\n西から来て左折するバスが、ふつうに渡る人と接触した（時速8km）\n\n人の問題\n運転士この人を見落としたまま、発進させた\n誘導員合図が、バスと歩行者のどちらに向けたものか、あいまいだった\nふつうに渡る人スマホを見ていて、バスに気づくのが遅れた\n決まり・行政\n道路交通法レベル2では運転の主体は運転士。運転士の安全確認の義務が中心になる\n自動車損害賠償保障法けがをした人への賠償は、運送する会社（運行供用者）が負う、という整理が進んでいる\n民事の過失歩行者の不注意は、賠償の割合を減らす事情として見られることがある\n事故の報告運行する会社は、事故を警察に報告する。事故を調べる国の仕組みは、権限を強める方向で検討中\nまだ決まっていないこと\nシステムに任せて見ているだけの運転士に、どこまでの注意を求めるか\n設定を変えて見直す\n→\n同じ設定でもう一度",
 "miss_1": "何も起きなかった\n見ている人の見落とし\n止まれた理由\n車内の主任者が人に気づいて止めた\n設定を変えて見直す\n→\n前の回と比べる\n同じ設定でもう一度",
 "miss_2": "事故\n見ている人の見落とし\n\n西から来て左折するバスが、ふつうに渡る人と接触した（時速8km）\n\n人の問題\n遠隔監視者映像で気づいて止める指示を出すまでに、時間がかかった\n誘導員合図が、バスと歩行者のどちらに向けたものか、あいまいだった\nふつうに渡る人スマホを見ていて、バスに気づくのが遅れた\n企業の問題\nメーカーバスは、横断歩道に向かってくる人を先読みしないまま、自分で発進した\n運行会社（あなた）死角の少ないセンサーを入れていなかった\n決まり・行政\n道路交通法（特定自動運行）レベル4は公安委員会の許可を受けた運行。運行する会社と主任者に、決められた義務がある\n自動車損害賠償保障法けがをした人への賠償は、運送する会社（運行供用者）が負う、という整理が進んでいる\n製造物責任法センサーやソフトの作りに欠陥があればメーカーが問われ得る\n民事の過失歩行者の不注意は、賠償の割合を減らす事情として見られることがある\n事故の報告運行する会社は、事故を警察に報告する。事故を調べる国の仕組みは、権限を強める方向で検討中\nまだ決まっていないこと\nレベル4の事故で、誰が刑事責任を負うか\n設定を変えて見直す\n→\n前の回と比べる\n同じ設定でもう一度",
 "miss_3": "事故\n見ている人の見落とし\n\n西から来て左折するバスが、ふつうに渡る人と接触した（時速8km）\n\n人の問題\n遠隔監視者映像でこの人を見落とした\n遠隔監視者映像で気づいて止める指示を出すまでに、時間がかかった（1人で3台を見ていた）\n誘導員合図が、バスと歩行者のどちらに向けたものか、あいまいだった\nふつうに渡る人スマホを見ていて、バスに気づくのが遅れた\n企業の問題\nメーカーバスは、横断歩道に向かってくる人を先読みしないまま、自分で発進した\n運行会社（あなた）遠隔監視者1人に3台を見させていた\n運行会社（あなた）死角の少ないセンサーを入れていなかった\n決まり・行政\n道路交通法（特定自動運行）レベル4は公安委員会の許可を受けた運行。運行する会社と主任者に、決められた義務がある\n自動車損害賠償保障法けがをした人への賠償は、運送する会社（運行供用者）が負う、という整理が進んでいる\n製造物責任法センサーやソフトの作りに欠陥があればメーカーが問われ得る\n民事の過失歩行者の不注意は、賠償の割合を減らす事情として見られることがある\n事故の報告運行する会社は、事故を警察に報告する。事故を調べる国の仕組みは、権限を強める方向で検討中\nまだ決まっていないこと\n遠隔監視者1人が何台まで見てよいか（基準なし）\n設定を変えて見直す\n→\n前の回と比べる\n同じ設定でもう一度",
 "right_0": "ひやり\n右折中の横断歩道\n\n東から来て右折するバスに、ふつうに渡る人が0.8m まで近づいた（バスは時速5km）\n\n人の問題\n運転士発進させたあとに、この人が横断歩道へ入ってきた。発進の判断そのものが問われる\n誘導員合図が、バスと歩行者のどちらに向けたものか、あいまいだった\nふつうに渡る人スマホを見ていて、バスに気づくのが遅れた\n決まり・行政\n道路交通法レベル2では運転の主体は運転士。運転士の安全確認の義務が中心になる\n自動車損害賠償保障法けがをした人への賠償は、運送する会社（運行供用者）が負う、という整理が進んでいる\n民事の過失歩行者の不注意は、賠償の割合を減らす事情として見られることがある\nまだ決まっていないこと\nシステムに任せて見ているだけの運転士に、どこまでの注意を求めるか\n設定を変えて見直す\n→\n同じ設定でもう一度",
 "right_1": "ひやり\n右折中の横断歩道\n\n東から来て右折するバスに、ふつうに渡る人が0.8m まで近づいた（バスは時速5km）\n\n人の問題\n誘導員合図が、バスと歩行者のどちらに向けたものか、あいまいだった\nふつうに渡る人スマホを見ていて、バスに気づくのが遅れた\n企業の問題\nメーカーバスは、横断歩道に向かってくる人を先読みしないまま、自分で発進した\n運行会社（あなた）死角の少ないセンサーを入れていなかった\n決まり・行政\n道路交通法（特定自動運行）レベル4は公安委員会の許可を受けた運行。運行する会社と主任者に、決められた義務がある\n自動車損害賠償保障法けがをした人への賠償は、運送する会社（運行供用者）が負う、という整理が進んでいる\n製造物責任法センサーやソフトの作りに欠陥があればメーカーが問われ得る\n民事の過失歩行者の不注意は、賠償の割合を減らす事情として見られることがある\nまだ決まっていないこと\nレベル4の事故で、誰が刑事責任を負うか\n設定を変えて見直す\n→\n前の回と比べる\n同じ設定でもう一度",
 "right_2": "ひやり\n右折中の横断歩道\n\n東から来て右折するバスに、ふつうに渡る人が0.8m まで近づいた（バスは時速5km）\n\n人の問題\n遠隔監視者映像で気づいて止める指示を出すまでに、時間がかかった\n誘導員合図が、バスと歩行者のどちらに向けたものか、あいまいだった\nふつうに渡る人スマホを見ていて、バスに気づくのが遅れた\n企業の問題\nメーカーバスは、横断歩道に向かってくる人を先読みしないまま、自分で発進した\n運行会社（あなた）死角の少ないセンサーを入れていなかった\n決まり・行政\n道路交通法（特定自動運行）レベル4は公安委員会の許可を受けた運行。運行する会社と主任者に、決められた義務がある\n自動車損害賠償保障法けがをした人への賠償は、運送する会社（運行供用者）が負う、という整理が進んでいる\n製造物責任法センサーやソフトの作りに欠陥があればメーカーが問われ得る\n民事の過失歩行者の不注意は、賠償の割合を減らす事情として見られることがある\nまだ決まっていないこと\nレベル4の事故で、誰が刑事責任を負うか\n設定を変えて見直す\n→\n前の回と比べる\n同じ設定でもう一度",
 "right_3": "ひやり\n右折中の横断歩道\n\n東から来て右折するバスに、ふつうに渡る人が0.8m まで近づいた（バスは時速5km）\n\n人の問題\n遠隔監視者映像で気づいて止める指示を出すまでに、時間がかかった（1人で3台を見ていた）\n誘導員合図が、バスと歩行者のどちらに向けたものか、あいまいだった\nふつうに渡る人スマホを見ていて、バスに気づくのが遅れた\n企業の問題\nメーカーバスは、横断歩道に向かってくる人を先読みしないまま、自分で発進した\n運行会社（あなた）遠隔監視者1人に3台を見させていた\n運行会社（あなた）死角の少ないセンサーを入れていなかった\n決まり・行政\n道路交通法（特定自動運行）レベル4は公安委員会の許可を受けた運行。運行する会社と主任者に、決められた義務がある\n自動車損害賠償保障法けがをした人への賠償は、運送する会社（運行供用者）が負う、という整理が進んでいる\n製造物責任法センサーやソフトの作りに欠陥があればメーカーが問われ得る\n民事の過失歩行者の不注意は、賠償の割合を減らす事情として見られることがある\nまだ決まっていないこと\n遠隔監視者1人が何台まで見てよいか（基準なし）\n設定を変えて見直す\n→\n前の回と比べる\n同じ設定でもう一度",
 "exit_0": "何も起きなかった\n脇道から出るバスの前へ\n止まれた理由\n人が渡り終えるまでバスが待ったか、人がバスに気づいて待った\n設定を変えて見直す\n→\n同じ設定でもう一度",
 "exit_1": "ひやり\n脇道から出るバスの前へ\n\n脇道から出て左折するバスに、ふつうに渡る人が0.6m まで近づいた（バスは時速5km）\n\n人の問題\n誘導員合図が、バスと歩行者のどちらに向けたものか、あいまいだった\nふつうに渡る人スマホを見ていて、バスに気づくのが遅れた\n企業の問題\nメーカーバスは、横断歩道に向かってくる人を先読みしないまま、自分で発進した\n運行会社（あなた）死角の少ないセンサーを入れていなかった\n決まり・行政\n道路交通法（特定自動運行）レベル4は公安委員会の許可を受けた運行。運行する会社と主任者に、決められた義務がある\n自動車損害賠償保障法けがをした人への賠償は、運送する会社（運行供用者）が負う、という整理が進んでいる\n製造物責任法センサーやソフトの作りに欠陥があればメーカーが問われ得る\n民事の過失歩行者の不注意は、賠償の割合を減らす事情として見られることがある\nまだ決まっていないこと\nレベル4の事故で、誰が刑事責任を負うか\n設定を変えて見直す\n→\n前の回と比べる\n同じ設定でもう一度",
 "exit_2": "ひやり\n脇道から出るバスの前へ\n\n脇道から出て左折するバスに、ふつうに渡る人が0.6m まで近づいた（バスは時速5km）\n\n人の問題\n遠隔監視者映像で気づいて止める指示を出すまでに、時間がかかった\n誘導員合図が、バスと歩行者のどちらに向けたものか、あいまいだった\nふつうに渡る人スマホを見ていて、バスに気づくのが遅れた\n企業の問題\nメーカーバスは、横断歩道に向かってくる人を先読みしないまま、自分で発進した\n運行会社（あなた）死角の少ないセンサーを入れていなかった\n決まり・行政\n道路交通法（特定自動運行）レベル4は公安委員会の許可を受けた運行。運行する会社と主任者に、決められた義務がある\n自動車損害賠償保障法けがをした人への賠償は、運送する会社（運行供用者）が負う、という整理が進んでいる\n製造物責任法センサーやソフトの作りに欠陥があればメーカーが問われ得る\n民事の過失歩行者の不注意は、賠償の割合を減らす事情として見られることがある\nまだ決まっていないこと\nレベル4の事故で、誰が刑事責任を負うか\n設定を変えて見直す\n→\n前の回と比べる\n同じ設定でもう一度",
 "exit_3": "ひやり\n脇道から出るバスの前へ\n\n脇道から出て左折するバスに、ふつうに渡る人が0.6m まで近づいた（バスは時速5km）\n\n人の問題\n遠隔監視者映像で気づいて止める指示を出すまでに、時間がかかった（1人で3台を見ていた）\n誘導員合図が、バスと歩行者のどちらに向けたものか、あいまいだった\nふつうに渡る人スマホを見ていて、バスに気づくのが遅れた\n企業の問題\nメーカーバスは、横断歩道に向かってくる人を先読みしないまま、自分で発進した\n運行会社（あなた）遠隔監視者1人に3台を見させていた\n運行会社（あなた）死角の少ないセンサーを入れていなかった\n決まり・行政\n道路交通法（特定自動運行）レベル4は公安委員会の許可を受けた運行。運行する会社と主任者に、決められた義務がある\n自動車損害賠償保障法けがをした人への賠償は、運送する会社（運行供用者）が負う、という整理が進んでいる\n製造物責任法センサーやソフトの作りに欠陥があればメーカーが問われ得る\n民事の過失歩行者の不注意は、賠償の割合を減らす事情として見られることがある\nまだ決まっていないこと\n遠隔監視者1人が何台まで見てよいか（基準なし）\n設定を変えて見直す\n→\n前の回と比べる\n同じ設定でもう一度"
}
```


## 作業ログ ― サイトに新しいシリーズを足した

この記事は、新しいシリーズ「フィジカルAIの社会実装シミュレーション」の1本目です。初めは、サービスロボット導入シミュレーションの続きにする予定でしたが、エイイチが、課題地図用のシミュレーションなので新しいシリーズにする、と決めました。名前もエイイチが選びました。サイトには /series9 のページを足し、ヘッダーのシリーズの一覧とシリーズの一覧ページのカードに加えました。

シリーズの一覧のカードの絵は、3Dのバスと交差点をもとに、意外なカメラの位置で撮る、という指示でした。three.js のカメラを、植え込みの外側の地面すれすれ（高さ0.9m）に置き、望遠（画角24度）で交差点を見て、事故の瞬間を撮りました。バスが植え込みに半分隠れ、事故の印だけが植え込みの上に出ます。植え込みがバスと人の間の見通しを悪くしている、という場面の中身がそのまま絵になる位置です。

記事のサムネイルは、3Dだけを撮ったコマ3枚（斜め上から見た事故の瞬間・真上から見た右折のひやり・バスの後ろから見た斜めに渡る人）を、左に大1・右に小2で並べました。このシリーズのサムネイルの決まりは、この回で決めた形（ブラウザ版の3Dのコマを主役に、文字なし、明るい灰色の地）です。


## 作業ログ ― コードとデータ

ここから下は、この回の終わりの時点のコードと、確かめに使ったスクリプトの全文です。

### engine.js（交差点の計算。バスと人の動き・場面・向きのずらし）

```javascript
// 事故が起きたら誰の責任？ — 交差点の計算（試作 v0）
// 単位：m・秒。上から見て x が東、z が南（three.js と同じ向き）。
export const DEFAULTS = { mode: 'l2', sensor: 'normal', speed: 10, guide: true, route: 'short', rest: true };

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 }
};

// 再現できる乱数
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 },
];
// 場面のバスの向きを変える。歩く人が車道に着く時刻を、その向きでバスが横断歩道に着く時刻に合わせてずらす（場面の「ぶつかりそうな間合い」を保つ）
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];
  return { ...sc, route: dir, peds: sc.peds.map((p) => ({ ...p, arrive: Math.max(1, p.arrive + dt), ...(adj[1] ? { fromEast: !p.fromEast } : {}) })) };
}
export const PED_LABEL = { normal: 'ふつうに渡る人', group: '連れ立って渡る人', slow: 'ゆっくり渡る人', hurry: '急いで渡る人', hesitate: '渡るか迷っていた人', diagonal: '横断歩道の外を斜めに渡る人' };

// 1回の通過を計算する。record=true なら0.5秒ごとの記録を残す
export function simulatePass(cfg, rand, opts = {}) {
  const P = PARAMS;
  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)];
  const pose = (s) => RT.pose(s);
  const STOP = 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';
  // 見落とし：休憩なしで増える。レベル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.arrive ?? 4 + rand() * 18; // 車道の端に着く時刻（通過の始まりから）
    const phone = S.phone ?? ((type === 'normal' || type === 'group') && rand() < P.phoneRate);
    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 ? JSON.stringify(cfg) + RT.name + evening : null;
  if (ck && EMPTY_CACHE.has(ck)) return EMPTY_CACHE.get(ck);
  const bus = { s: 0, v: Math.max(vmax, P.cruise), a: 0, state: 'approach', stopT: 0, brakeAt: null };
  const ev = []; const frames = [];
  let startedBy = null, guideRaised = false, hitCtx = null;
  const log = (t, k, text, extra) => ev.push({ t, k, text, ...(extra || {}) });
  log(0, 'route', `バスは${RT.label}${RT.name === 'er' ? '（対向車線を横切る）' : ''}`);
  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;
    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 && (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);
    // これから通る道の上（車体の幅＋余裕）に人がいるか。いれば、前の端からその場所までの道のりを返す
    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 && (bus.brakeAt === null || bus.brakeAt > t + P.reaction)) { bus.brakeAt = t + P.reaction; log(t, 'sensed', 'センサーが歩行者を感知し、自動ブレーキ'); }
      if (opDanger && bus.brakeAt === null) { bus.brakeAt = t + P.operatorReaction; log(t, '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 && bus.brakeAt === null) { bus.brakeAt = t + P.remoteReaction * (MODE === 'l4r3' ? 1.5 : 1); /* 3台を見ていると、気づいて指示を出すまでが遅れる */ log(t, 'remote', '遠隔監視者が映像で気づき、停止を指示'); }
      // 止まったあと、道の前が空いたらブレーキを解く
      // （近くの人が2秒先までに道に入らないことを確かめ、止まってから1秒は待つ）
      if (bus.v === 0 && bus.brakeAt !== null && t >= bus.brakeAt) { 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') vT = 0;
    let aWant, J = P.jerk;
    if (braking) { aWant = -P.emergencyDecel; J = 25; }
    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' && 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', '横断歩道の手前で一時停止'); }
    bus.s += bus.v * P.dt;
    if (bus.state === 'approach' && bus.s > STOP) bus.s = STOP;
    // 歩く人
    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 }; }
      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) }; 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, 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') || { t: 0 }).t + 4) break; }
    if (bus.s > STOP + 40) break; // 交差点の先まで走り切ったら終わり
  }
  const hit = peds.some((p) => p.hit);
  // ひやり：動いているバスと1mより近づき、しかも急ブレーキか、人が飛びのくかした
  const nearPeds = peds.filter((p) => p.minD < P.nearMiss && p.reacted);
  const near = !hit && nearPeds.length > 0;
  const np = near ? 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;
  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; }
  return {
    hit, near, wait: Math.max(0, wait), events: ev, frames, route: RT.name,
    nearFacts: np ? { mode: MODE, id: np.id, dist: Math.max(0, np.minD), evening, pedType: np.type, phone: np.phone, missed: np.missed, hedge: np.hedge && RT.enters, ...np.ctx, startedBy, guideRaised, guideClear, trustGuide, route: RT.name } : null,
    facts: hit ? { ...hitCtx, hedge: hitPed.hedge && RT.enters, guideRaised, missed: hitPed.missed, phone: hitPed.phone, pedType: hitPed.type, fromBehindHedge: hitPed.hedge && RT.enters, guideClear, trustGuide, startedBy, evening, route: RT.name, mode: MODE } : null
  };
}

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;
  return v;
}

// 1年を回す。事故の通過は seed を残し、あとで記録つきで再計算する
export function simulateYear(cfg, seed = 1) {
  const P = PARAMS, out = { accidents: [], 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 r = simulatePass(cfg, rng(passSeed), { evening });
      out.passes++; out.waitSum += r.wait + (cfg.route === 'long' ? P.detourSec : 0);
      if (r.hit) { acc++; out.accidents.push({ day: d, pass: i, seed: passSeed, evening, facts: r.facts }); }
      if (r.near) { nr++; out.near++; }
    }
    out.daily.push({ acc, near: nr });
  }
  out.delayAvgMin = out.waitSum / out.passes / 60;
  out.cost = cost(cfg);
  return out;
}
```

### app.html（画面と3D。build.py で three.js と engine.js を入れて1つの HTML にする）

```html
<!DOCTYPE html>
<html lang="ja">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>事故が起きたら誰の責任？（試作）</title>
<link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Inter:wght@400;600&family=Noto+Sans+JP:wght@400;500;700&display=swap">
<style>
/* VOICE: サイトと同じ、静かで道具らしい画面
   IDEA: 交差点を上から見る運行の管理画面
   PICTURE: three.js の T字路。バス（白）・歩行者（黄）・誘導員（青）
   COLOUR and TYPE: 白地・黒の面、赤は事故だけ。Noto Sans JP ＋ Inter
   LAYOUT: 左に交差点、右に仕組みのパネル。結果からは1枚ずつの画面 */
:root{color-scheme:light;--ink:#111;--sub:#555;--face:#f7f7f7;--line:#e5e5e5;--red:#d93a3a}
*{box-sizing:border-box;min-width:0}
body{margin:0;background:#fff;color:var(--ink);font:15px/1.6 Inter,'Noto Sans JP',sans-serif;overflow-x:clip}
button{font:inherit;color:inherit}
.view{display:none}.view.on{display:flex}
#play{height:100vh;min-height:620px}
#stage{position:relative;flex:1;background:#eceef1;overflow:hidden}
#stage canvas{position:absolute;inset:0;width:100%;height:100%}
.card{position:absolute;background:#fff;border-radius:12px;padding:14px 18px}
#top{left:16px;top:16px;max-width:430px}
#top h1{margin:0;font-size:13px;font-weight:700}.tag{font-size:11px;font-weight:400;background:#f0f0f0;border-radius:4px;padding:2px 6px;margin-left:8px}
#intro p{margin:6px 0 0}#intro .lead{font-size:20px;font-weight:700;line-height:1.45}
#clock{display:none}#clock .d{font-size:28px;font-weight:600}#clock .d small{font-size:13px;font-weight:400;margin-left:8px}
.seg{display:flex;gap:4px;background:#f0f0f0;border-radius:8px;padding:3px;margin-top:8px}
.seg button{border:0;border-radius:6px;background:transparent;padding:6px 10px;font-size:12px;cursor:pointer}
.seg button.on{background:#111;color:#fff}
#stats{left:16px;right:16px;bottom:16px;display:none;grid-template-columns:repeat(4,minmax(0,1fr));gap:12px}
.st span{display:block;font-size:12px;color:var(--sub)}.st b{font-size:26px;font-weight:600}.st i{font-style:normal;font-size:13px;margin-left:3px}
#views{right:16px;top:16px;padding:8px;display:flex;flex-direction:column;gap:6px;align-items:flex-end}
#views .seg{margin:0;flex-wrap:wrap;justify-content:flex-end}
#views .hint{font-size:11px;color:var(--sub);padding:0 4px;align-self:flex-start;text-align:left}
#stage canvas,#acR canvas{touch-action:none;cursor:grab}
#callout{display:none;max-width:250px;padding:10px 12px;font-size:12px;line-height:1.6;pointer-events:none}
#callout b{display:block;font-size:13px}
#panel{width:360px;flex:none;background:#fff;padding:20px;display:flex;flex-direction:column;gap:14px;overflow:auto}
#panel h2{margin:0;font-size:15px}
#groups{display:flex;flex-direction:column;gap:14px}
#modeTabs{margin:0}#modeTabs button{flex:1;white-space:nowrap;font-size:12.5px;padding:7px 8px}
#scenes{display:flex;flex-direction:column;gap:6px}#scenes .h{font-size:13px;color:#333;margin-bottom:2px}
#scenes .sc{all:unset;box-sizing:border-box;cursor:pointer;display:block;border:1px solid #e3e3e0;border-radius:10px;padding:8px 10px}
#scenes .sc b{display:block;font-size:12.5px}#scenes .sc span{display:block;font-size:11.5px;color:#777;line-height:1.5;margin-top:2px}
#scenes .sc.on{border-color:#111;box-shadow:0 0 0 1px #111}
.inc.safe{border-color:#2f7d4f}.inc.safe .tag{background:#2f7d4f}
.sbtns{display:flex;flex-direction:column;gap:8px;margin-top:14px}.sbtns .link{align-self:flex-start;font-size:13px}
#panel .cta{height:44px;font-size:14px;white-space:nowrap;padding:0 16px}#panel .cta.sub{background:#fff;color:#111;border:1px solid #111}
#panel .note,#panelNote{font-size:11.5px;line-height:1.6;margin:0}#panel .link{font-size:13px}
#sceneCmp .cols{display:grid;grid-template-columns:1fr 1fr;gap:16px;margin-top:16px}
#sceneCmp .col h3{margin:0 0 8px;font-size:14px;color:#666}
#sceneCmp .cfg{display:grid;grid-template-columns:auto 1fr;gap:3px 12px;font-size:12px;color:#666;background:#f5f5f3;border-radius:10px;padding:10px 12px;margin-bottom:10px}#sceneCmp .cfg b{color:#111}#sceneCmp .cfg .chg{background:#fff1b8;border-radius:4px;padding:0 4px}
table.auto{width:100%;border-collapse:collapse;margin-top:14px;font-size:13px}table.auto th{text-align:left;font-size:11.5px;color:#777;font-weight:600;padding:8px 10px;border-bottom:1px solid #e3e3e0}
table.auto td{padding:10px;border-bottom:1px solid #eee;vertical-align:top;line-height:1.6}table.auto i{font-style:normal;display:inline-block;background:#f0f0ee;border-radius:999px;padding:1px 9px;margin:0 4px 4px 0;font-size:12px}table.auto i.me{background:#111;color:#fff}
table.auto tr.arow{cursor:pointer}table.auto tr.arow:hover td{background:#fafaf8}table.auto .tg{color:#999;margin-right:6px}table.auto tr.adet td{padding:14px 10px;background:#fafaf8}table.auto tr.adet .inc{max-width:none;width:100%;box-sizing:border-box;background:#fff}
table.auto .sub{color:#666;font-size:12px}.rk{display:inline-block;font-size:12px;font-weight:700;color:#fff;border-radius:6px;padding:2px 8px;white-space:nowrap}.rk.hit{background:#d93a3a}.rk.near{background:#111}.rk.safe{background:#2f7d4f}
.ahist{margin-top:14px;border-top:1px solid #eee;padding-top:10px}.ahist h4{margin:0 0 6px;font-size:11.5px;color:#777;font-weight:600}
.ahist details{border-bottom:1px solid #f0f0ee;padding:6px 0}.ahist summary{cursor:pointer;display:flex;align-items:center;gap:8px;font-size:12.5px;list-style:none}.ahist summary::-webkit-details-marker{display:none}
.ahist summary b{width:18px;color:#999;font-weight:600}.ahist summary span:last-child{flex:1}.ahist details .inc{margin-top:8px}
#cfgLine b.chg{background:#fff1b8;border-radius:4px;padding:0 4px}
#sceneCmp .sum{background:#111;color:#fff;border-radius:14px;padding:14px 16px;font-size:14px;line-height:1.7;margin-top:12px}
@media(max-width:900px){#sceneCmp .cols{grid-template-columns:1fr}}
.optNote{margin:6px 0 0;font-size:11.5px;line-height:1.6;color:#777}
#runInfo{display:flex;flex-direction:column;gap:14px}
#cfgLine{margin:0;font-size:12px;line-height:1.6;color:#666;background:#f5f5f3;border-radius:10px;padding:10px 12px;display:grid;grid-template-columns:auto 1fr;gap:3px 12px}#cfgLine b{color:#111;font-weight:600}
.inc{border:1px solid #e3e3e0;border-radius:12px;padding:12px 14px;display:flex;flex-direction:column;gap:6px}
.inc.hit{border-color:#d93a3a}
.inc .hd{display:flex;align-items:center;gap:8px;font-size:12px;color:#666}
.inc .tag{font-size:12px;font-weight:700;color:#fff;background:#111;border-radius:6px;padding:2px 8px;margin-left:0}
.inc.hit .tag{background:#d93a3a}
.inc .what{margin:0 0 2px;font-size:13.5px;font-weight:700;line-height:1.55}
.inc h4{margin:6px 0 0;font-size:11.5px;color:#777;font-weight:600}
.inc ul{margin:0;padding-left:18px;font-size:13px;line-height:1.7}
.inc ul.who3{list-style:none;padding:0;display:flex;flex-direction:column;gap:5px}.inc ul.who3 li{line-height:1.55;font-size:12.5px}
.inc ul.who3 b{display:inline-block;font-size:11px;font-weight:600;background:#f0f0ee;border-radius:999px;padding:0 8px;margin-right:6px}.inc ul.who3 b.me{background:#111;color:#fff}
.inc .open{background:#fff6e5;border-radius:8px;padding:8px 10px;font-size:12.5px;line-height:1.55;margin-top:6px}.inc .open span{display:block;font-size:11px;font-weight:700;color:#8a5a00}
.inc .who{display:flex;flex-wrap:wrap;gap:6px}
.inc .who span{font-size:12px;background:#f0f0ee;border-radius:999px;padding:3px 10px}
.inc .who span.me{background:#111;color:#fff}
#incLog{display:flex;flex-direction:column;gap:6px}
#incLog .li{box-sizing:border-box;display:block;width:100%;cursor:pointer;font-size:12px;color:#555;line-height:1.6;border-top:1px solid #eee;padding:6px 0}
#incLog .li:hover .row1{color:#111}#incLog .li .row1::after{content:' ＋';color:#999}#incLog .li[aria-expanded=true] .row1::after{content:' －'}
#incLog .li .more{display:none;margin-top:8px;white-space:normal;cursor:default;color:#111;font-size:13px}#incLog .li[aria-expanded=true] .more{display:block}
#incLog .more .w{display:block;font-weight:700;color:#111;font-size:12.5px}#incLog .more .h{display:block;margin-top:6px;color:#777;font-size:11px}
#incLog .more .ul span{display:block}#incLog .more .who{display:flex;flex-wrap:wrap;gap:4px;margin-top:2px}#incLog .more .who i{font-style:normal;background:#ecece9;border-radius:999px;padding:1px 8px}#incLog .more .who i.me{background:#111;color:#fff}
#incLog .li b{color:#111;margin-right:6px}#incLog .li b.hit{color:#d93a3a}
.grp span{display:block;font-size:13px;color:#333;margin-bottom:6px}
.opts{display:flex;gap:5px;flex-wrap:wrap}
.opts button{border:0;border-radius:7px;background:#f0f0f0;padding:5px 10px;font-size:12px;cursor:pointer;min-height:30px}
.opts button.on{background:#111;color:#fff}.opts button:disabled{opacity:.35;cursor:not-allowed}
#panel.locked .opts button{cursor:default;color:#9a9a9a;background:#f5f5f5}#panel.locked .opts button.on{color:#fff;background:#111}
.cta{display:flex;align-items:center;justify-content:center;gap:8px;height:48px;padding:0 22px;border:0;border-radius:8px;background:#111;color:#fff;font-size:15px;font-weight:500;cursor:pointer;text-decoration:none}
.link{background:none;border:0;padding:0;font-size:14px;text-decoration:underline;cursor:pointer}
.note{font-size:12px;color:var(--sub);margin:0}
.sheet{min-height:100vh;flex-direction:column;gap:20px;padding:32px clamp(16px,4vw,40px);max-width:1280px;margin:0 auto}
.sheet h2{margin:0;font-size:26px;line-height:1.35}
.eyebrow{margin:0;font-size:13px;color:var(--sub)}
.chg{display:flex;gap:8px;flex-wrap:wrap;align-items:center;font-size:14px}.chg span{background:#f0f0f0;border-radius:8px;padding:5px 10px}.chg span.now{background:#111;color:#fff}
.two{display:grid;grid-template-columns:minmax(0,1fr) 360px;gap:28px}
.row{background:var(--face);border-radius:12px;padding:14px 20px;display:grid;grid-template-columns:180px repeat(2,minmax(0,1fr));gap:12px;align-items:baseline}
.row .k{font-weight:700}.row .p{font-size:28px;font-weight:600;color:#8a8a8a}.row .n{font-size:28px;font-weight:600}.row small{font-size:13px;font-weight:400;margin-left:3px}.row em{font-style:normal;font-size:13px;margin-left:8px;color:#333}
.acc{display:block;text-align:left;width:100%;border:0;background:var(--face);border-radius:12px;padding:14px 16px;cursor:pointer;margin-bottom:10px}
.acc .w{font-size:13px;color:var(--sub)}.acc .t{display:block;margin:2px 0 4px;line-height:1.5}.acc .go{font-size:13px;font-weight:500}
#accident{height:100vh;min-height:620px}
#acL{width:min(560px,48%);flex:none;padding:28px 28px 20px;display:flex;flex-direction:column;gap:14px;overflow:auto}
#facts{display:flex;gap:10px;flex-wrap:wrap}.fact{background:var(--face);border-radius:12px;padding:10px 14px}.fact span{display:block;font-size:12px;color:var(--sub)}.fact b{font-size:24px;font-weight:600}.fact i{font-style:normal;font-size:13px;margin-left:3px}
.ev{display:flex;gap:12px;align-items:baseline;width:100%;text-align:left;border:0;border-radius:10px;background:var(--face);padding:12px 14px;cursor:pointer}
.ev b{min-width:58px;font-weight:600}.ev.on{background:#111;color:#fff}
#acR{flex:1;position:relative;background:#eceef1}
.party{background:var(--face);border-radius:12px;padding:14px 20px;display:grid;grid-template-columns:170px minmax(0,1fr) 300px 64px;gap:18px;align-items:center}
.party.me{background:#ececec}.party .nm{font-weight:700}.party .cl{font-size:13px;color:#333;line-height:1.6}.party .v{font-size:24px;font-weight:600;text-align:right}
input[type=range]{width:100%;accent-color:#111;height:28px}
.bars{display:flex;flex-direction:column;gap:6px}.bar{height:12px;border-radius:6px;background:#111}.bar.all{background:#b9b9b9}
.foot{display:flex;justify-content:space-between;align-items:center;gap:16px;flex-wrap:wrap}
@media(max-width:900px){#play,#accident{height:auto;flex-direction:column}#stage,#acR{height:62vh;flex:none}#panel{width:100%}#acL{width:100%}.two{grid-template-columns:1fr}.party{grid-template-columns:1fr 64px}.party .cl{grid-column:1/-1}.party input{grid-column:1/-1}.row{grid-template-columns:1fr 1fr 1fr}#stats{grid-template-columns:repeat(2,minmax(0,1fr))}}
</style>
</head>
<body>
<div id="play" class="view on">
  <div id="stage">
    <div id="top" class="card">
      <h1>事故が起きたら誰の責任？<span class="tag">試作 v0</span></h1>
      <div id="intro">
        <p class="lead">あなたは、この交差点を走る自動運転バスの運行を決める担当者です</p>
        <p id="introText">右で場面と設定を選んで、その1回を見てください。設定を1つ変えてもう一度見ると、問題が誰に移るかを比べられます。</p>
      </div>
      <div class="seg" id="sceneSpeeds" style="display:none;margin-top:10px"><button data-r="1" class="on">実際の速さ</button><button data-r="2">2倍</button><button data-r="4">4倍</button></div>
      <div id="clock">
        <div class="d" id="date">4月1日<small>1年のうち 1日目</small></div>
        <div class="seg" id="speeds">
          <button data-s="real">実際の速さ</button><button data-s="day" class="on">早送り</button><button data-s="skip">結果まで飛ばす</button>
        </div>
      </div>
    </div>
    <div id="views" class="card">
      <div class="seg" id="viewBtns">
        <button data-v="iso" class="on">斜め上</button><button data-v="opp">反対側</button><button data-v="top">真上</button><button data-v="follow">バスの後ろ</button>
      </div>
      <span class="hint">ドラッグで回す・ホイールや2本指で寄る</span>
    </div>
    <div id="callout" class="card"></div>
    <div id="stats" class="card">
      <div class="st"><span>事故</span><b id="sAcc" style="color:var(--red)">0</b><i>件</i></div>
      <div class="st"><span>ひやり（1m以内）</span><b id="sNear">0</b><i>回</i></div>
      <div class="st"><span>1便の遅れ（平均）</span><b id="sDelay">0.0</b><i>分</i></div>
      <div class="st"><span>運行の費用（いちばん安い仕組みを100）</span><b id="sCost">100</b></div>
    </div>
  </div>
  <aside id="panel">
    <h2 id="panelTitle" style="display:none"></h2>
    <div id="modeTabs" class="seg"><button data-m="scene" class="on">場面を選んで確かめる</button><button data-m="year">1年回す</button></div>
    <div id="scenes"></div>
    <div id="groups"></div>
    <div id="runInfo" style="display:none">
      <p id="cfgLine"></p>
      <div id="incident"><p class="note">ひやりや事故が起きると、ここに「何が起きたか・原因・かかわる人」が出ます</p></div>
      <div id="incLog"></div>
    </div>
    <div style="margin-top:auto;display:flex;flex-direction:column;gap:8px">
      <button class="cta" id="run">この仕組みで1年を回す <span aria-hidden="true">→</span></button>
      <button class="cta sub" id="autoRun" style="display:none">自動再生（設定を1つずつ変えて見る）</button>
      <p class="note" id="panelNote">数字は試作の仮の決まりで出しています。予測ではありません</p>
      <button class="link" id="stopRun" style="display:none;align-self:flex-start">止めて仕組みを変える</button>
    </div>
  </aside>
</div>

<div id="result" class="view sheet"></div>

<div id="accident" class="view">
  <div id="acL"></div>
  <div id="acR"></div>
</div>

<div id="assign" class="view sheet"></div>
<div id="compare" class="view sheet"></div>
<div id="sceneCmp" class="view sheet"></div>

<script type="text/plain" id="three-src">%%THREE%%</script>
<script type="text/plain" id="engine-src">%%ENGINE%%</script>
<script type="module">
{
const modURL = (id) => URL.createObjectURL(new Blob([document.getElementById(id).textContent], { type: 'text/javascript' }));
const THREE = await import(modURL('three-src'));
const E = await import(modURL('engine-src'));
const $ = (s) => document.querySelector(s);

// ---- 仕組みの項目 ----
const GROUPS = [
  { k: 'dir', scene: true, label: 'バスの来る向き', opts: [['wl', '西から来て左折'], ['er', '東から来て右折（対向車線を横切る）'], ['nl', '脇道から出て左折'], ['nr', '脇道から出て右折（対向車線を横切る）']] },
  { k: 'mode', label: '運行の形', opts: [['l2', 'レベル2・運転士（バスが走り、運転士が見張る。止まったあとの発進は運転士）'], ['l4in', 'レベル4・車内に主任者（バスが判断して走る。車内の主任者が見て、危ないときに止める）'], ['l4r1', 'レベル4・遠隔監視1台（車内は無人。遠隔監視者1人が1台を映像で見る）'], ['l4r3', 'レベル4・遠隔監視3台（車内は無人。遠隔監視者1人が3台を映像で見る）']] },
  { k: 'sensor', label: 'センサー', opts: [['normal', 'ふつう'], ['wide', '死角の少ないもの']] },
  { k: 'speed', label: '交差点での速さ', opts: [[6, '6 km/時'], [10, '10 km/時'], [15, '15 km/時']] },
  { k: 'guide', label: '交差点に誘導員', opts: [[true, '置く'], [false, '置かない']] },
  { k: 'route', label: '交差点の植え込み', opts: [['short', 'そのまま（見通しが悪い）'], ['long', '低く刈ってもらう（道の管理者に頼む）']] },
  { k: 'rest', label: (c) => `${WATCHER(c)}の休憩`, opts: [[true, 'こまめに入れる（見落としが減る・費用が上がる）'], [false, 'なしで回す（費用が下がる・見落としが増える）']] }
];
const NOUN = { dir: 'バスの向きを', mode: '運行の形を', sensor: 'センサーを', speed: '交差点の速さを', guide: '誘導員を', route: '植え込みを', rest: '休憩を' };
// 仕組みを変えたことを、文で言う（「〜したら、事故は減った」）
const changePhrase = (k, v) => ({ dir: `バスの来る向きを「${label('dir', v)}」にした`, mode: `運行の形を「${label('mode', v)}」にした`, sensor: `センサーを${v === 'wide' ? '死角の少ないもの' : 'ふつうのもの'}にした`, speed: `交差点の速さを時速${v}kmにした`,
  guide: v ? '誘導員を置いた' : '誘導員をなくした', route: v === 'long' ? '植え込みを低く刈ってもらった' : '植え込みをそのままにした', rest: v ? '休憩をこまめに入れた' : '休憩なしで回した' })[k];
// 選択肢の言葉は「本文（注釈）」の形。ボタンには本文だけ、注釈はボタンの下に小さく出す
const glabel = (g) => (typeof g.label === 'function' ? g.label(cfg) : g.label); // 見出しが、ほかの選択で変わるもの（休憩の対象など）
const splitOpt = (t) => { const m = t.match(/^(.*?)（(.*)）$/); return m ? [m[1], m[2]] : [t, '']; };
const label = (k, v) => splitOpt(GROUPS.find((g) => g.k === k).opts.find((o) => o[0] === v)[1])[0];
let cfg = { ...E.DEFAULTS, dir: E.SCENES[0].route };
const G = () => GROUPS.filter((g) => !g.scene || playKind === 'scene'); // バスの向きは場面のときだけ選ぶ（1年回すときは毎回ばらばら）
let locked = false;
// 場面によっては、前提として決まっている設定がある（例：誘導員の合図の場面は、誘導員がいることが前提）
const sceneReq = () => (playKind === 'scene' ? (E.SCENES.find((x) => x.id === sceneId) || {}).requires || {} : {});
// この場面で選べるバスの向き（場面のもとの向き＋ずらし方を決めてある向き）
const sceneDirs = () => { const sc = E.SCENES.find((x) => x.id === sceneId); return sc ? [sc.route, ...Object.keys(E.SCENE_DIRS[sc.id] || {})] : []; };
function drawPanel() {
  const req = sceneReq(); Object.assign(cfg, req);
  $('#groups').innerHTML = G().map((g) => { const fixed = g.k in req; return `<div class="grp"><span>${glabel(g)}</span><div class="opts">${g.opts.map((o, i) => `<button data-k="${g.k}" data-i="${i}" class="${cfg[g.k] === o[0] ? 'on' : ''}" aria-pressed="${cfg[g.k] === o[0]}" ${(fixed && cfg[g.k] !== o[0]) || (g.k === 'dir' && !sceneDirs().includes(o[0])) ? 'disabled' : ''}>${splitOpt(o[1])[0]}</button>`).join('')}</div>${fixed ? '<p class="optNote">この場面の前提なので、変えられません</p>' : g.k === 'dir' && sceneDirs().length < 4 ? '<p class="optNote">この場面の人は、脇道から出るバスとは交わりません</p>' : (() => { const n = splitOpt(g.opts.find((o) => o[0] === cfg[g.k])[1])[1]; return n ? `<p class="optNote">${n}</p>` : ''; })()}</div>`; }).join('');
  $('#panel').classList.toggle('locked', locked);
  $('#sCost').textContent = E.cost(cfg);
}
$('#groups').addEventListener('click', (e) => {
  const b = e.target.closest('button[data-k]'); if (!b || locked) return;
  const g = GROUPS.find((x) => x.k === b.dataset.k); cfg[g.k] = g.opts[+b.dataset.i][0];
  drawPanel(); scene.setCfg({ ...cfg });
});

// ---- 3D ----
const scene = (() => {
  const host = $('#stage');
  const r = new THREE.WebGLRenderer({ antialias: true });
  r.setPixelRatio(Math.min(devicePixelRatio, 2)); r.shadowMap.enabled = true; r.shadowMap.type = THREE.PCFSoftShadowMap;
  host.prepend(r.domElement);
  const s = new THREE.Scene(); s.background = new THREE.Color('#eceef1');
  const cam = new THREE.PerspectiveCamera(34, 1, 0.8, 400);
  const target = new THREE.Vector3(-1, 0, -4);
  const home = { az: Math.atan2(21, 32), el: Math.atan2(30, Math.hypot(21, 32)), dist: Math.hypot(21, 30, 32) };
  let az = home.az, el = home.el, dist = home.dist, mode = 'orbit';
  function placeCam() {
    if (mode === 'follow') return;
    cam.position.set(target.x + dist * Math.cos(el) * Math.sin(az), target.y + dist * Math.sin(el), target.z + dist * Math.cos(el) * Math.cos(az));
    cam.lookAt(target);
  }
  placeCam();
  s.add(new THREE.HemisphereLight('#ffffff', '#b9b4a8', 1.6));
  const d = new THREE.DirectionalLight('#ffffff', 1.5); d.position.set(-20, 40, 25); d.castShadow = true;
  d.shadow.mapSize.set(2048, 2048); Object.assign(d.shadow.camera, { left: -40, right: 40, top: 40, bottom: -40, near: 1, far: 120 }); s.add(d);
  const M = (c) => new THREE.MeshLambertMaterial({ color: c });
  const box = (w, h, dp, c, x, y, z, cast = false) => { const m = new THREE.Mesh(new THREE.BoxGeometry(w, h, dp), M(c)); m.position.set(x, y + h / 2, z); m.castShadow = cast; m.receiveShadow = true; s.add(m); return m; };
  box(260, 0.1, 260, '#e3e0d8', 0, -0.1, 0);
  box(200, 0.15, 14, '#efe7d4', 0, 0, 0);
  box(12, 0.15, 90, '#efe7d4', 0, 0, -51);
  box(200, 0.16, 7, '#7a7f87', 0, 0, 0);
  box(6, 0.16, 90, '#7a7f87', 0, 0, -48.5);
  for (let x = -96; x < 96; x += 4) if (Math.abs(x) > 5) box(2, 0.17, 0.15, '#f2f2f2', x, 0, 0);
  for (let x = -2.7; x <= 2.8; x += 0.9) box(0.45, 0.18, 2.8, '#ffffff', x, 0, -5.0);
  box(16, 2.6, 9, '#9aa0a8', -15, 0, -13, true); box(13, 2.2, 10, '#a3a8af', 15, 0, -14, true);
  box(16, 1.2, 6, '#b3b7bd', -15, 0, 12, true); box(16, 1.2, 6, '#b3b7bd', 15, 0, 12, true);
  const hedge = new THREE.Group(); for (const h of E.HEDGES) { const m = new THREE.Mesh(new THREE.BoxGeometry(h[1] - h[0], 1.3, h[3] - h[2]), M('#6f9a5a')); m.position.set((h[0] + h[1]) / 2, 0.8, (h[2] + h[3]) / 2); m.castShadow = true; hedge.add(m); } s.add(hedge);
  // バス
  const bus = new THREE.Group();
  const add = (g, w, h, dp, c, x, y, z) => { const m = new THREE.Mesh(new THREE.BoxGeometry(w, h, dp), M(c)); m.position.set(x, y, z); m.castShadow = true; g.add(m); return m; };
  {
    // バスの形（アーチ屋根）。真横から見た輪郭を幅方向に押し出す。前後は同じ形で、端のガラスは屋根の上まで続く
    const Lb = 5.2, Wb = 2.2, yb = 0.06, yt = 2.62, Rt = 1.35, Rb = 0.18, bv = 0.14, white = '#f6f6f4', glass = '#1d242c';
    const prof = (L2, y0, y1, rt, rbm) => { const x = L2 / 2, sh = new THREE.Shape();
      sh.moveTo(-x + rbm, y0); sh.lineTo(x - rbm, y0); sh.quadraticCurveTo(x, y0, x, y0 + rbm); sh.lineTo(x, y1 - rt);
      sh.absarc(x - rt, y1 - rt, rt, 0, Math.PI / 2, false); sh.lineTo(-x + rt, y1); sh.absarc(-x + rt, y1 - rt, rt, Math.PI / 2, Math.PI, false);
      sh.lineTo(-x, y0 + rbm); sh.quadraticCurveTo(-x, y0, -x + rbm, y0); return sh; };
    const ext = (sh, depth, bev, mat, seg = 24) => { const g = new THREE.ExtrudeGeometry(sh, { depth, curveSegments: seg, bevelEnabled: bev > 0, bevelSize: bev, bevelThickness: bev, bevelSegments: 5 }); g.translate(0, 0, -depth / 2); const m = new THREE.Mesh(g, mat); m.castShadow = true; bus.add(m); return m; };
    ext(prof(Lb - 2 * bv, yb + bv, yt - bv, Rt - bv, Rb), Wb - 2 * bv, bv, M(white));
    // 端のガラス：輪郭の端の部分だけを、車体の外へ少し出して作る。幅は車体より狭く、左右の面へは回り込まない
    const glassMat = new THREE.MeshPhongMaterial({ color: glass, specular: '#9aa6b2', shininess: 70 });
    const xe = Lb / 2 + 0.008, cy = yt - Rt, rr2 = Rt + 0.008, xg = 1.45, yw = 0.62, cx = Lb / 2 - Rt;
    for (const sg of [1, -1]) {
      // 縦の面は細かく区切って点を置く（角を丸めるときに、輪郭がなめらかになるように）
      const sh = new THREE.Shape(); sh.moveTo(xg, yw); sh.lineTo(xe, yw); for (let i = 1; i <= 24; i++) sh.lineTo(xe, yw + (cy - yw) * i / 24);
      const aEnd = Math.acos((xg - cx) / rr2); sh.absarc(cx, cy, rr2, 0, aEnd, false); sh.lineTo(xg, yw);
      const gwid = Wb - 2 * bv - 0.02, m = ext(sh, gwid, 0, glassMat, 40); if (sg < 0) m.scale.x = -1;
      // 端から見たガラスの四隅を丸める：ガラスの面に沿った長さ u で、両端に近い点ほど幅を狭める
      const uMax = (cy - yw) + rr2 * aEnd, hw = gwid / 2, rc = 0.32, pos = m.geometry.attributes.position;
      for (let i = 0; i < pos.count; i++) {
        const x = pos.getX(i), y = pos.getY(i), z = pos.getZ(i);
        const u = y <= cy + 1e-6 ? y - yw : (cy - yw) + rr2 * Math.atan2(y - cy, x - cx);
        const dEnd = Math.max(0, Math.min(u, uMax - u)); if (dEnd >= rc) continue;
        const lim = hw - rc + Math.sqrt(Math.max(0, rc * rc - (rc - dEnd) ** 2));
        if (Math.abs(z) > lim) pos.setZ(i, Math.sign(z) * lim);
      }
      pos.needsUpdate = true;
      add(bus, 0.02, 0.05, Wb * 0.62, '#e9f4ff', sg * (xe + 0.002), yw - 0.12, 0);
      for (const z of [0.5, -0.5]) add(bus, 0.02, 0.07, 0.22, sg > 0 ? '#ffffff' : '#d9534f', sg * (xe + 0.002), 0.34, z);
    }
    // 側面：外側の上の角を大きく丸めた窓、真ん中の2枚引き戸、足元のネイビーの帯
    // 側面に貼る部品は、層ごとに外へ少しずつ離す（同じ面に重ねるとチラつくため）。layer 0=窓とドア枠、1=ドアの板
    const flat = (sh, c, x, y, z, mx = 1, layer = 0) => { const g = new THREE.ExtrudeGeometry(sh, { depth: 0.02, bevelEnabled: false, curveSegments: 8 }); g.translate(0, 0, -0.01); const mat = M(c); mat.polygonOffset = true; mat.polygonOffsetFactor = -1 - layer * 2; mat.polygonOffsetUnits = -4 - layer * 4; const m = new THREE.Mesh(g, mat); m.position.set(x, y, z + Math.sign(z) * (0.012 + layer * 0.03)); m.scale.x = mx; bus.add(m); return m; };
    const rect = (w, h, q) => { const sh = new THREE.Shape(); sh.moveTo(-w / 2 + q, -h / 2); sh.lineTo(w / 2 - q, -h / 2); sh.quadraticCurveTo(w / 2, -h / 2, w / 2, -h / 2 + q); sh.lineTo(w / 2, h / 2 - q); sh.quadraticCurveTo(w / 2, h / 2, w / 2 - q, h / 2); sh.lineTo(-w / 2 + q, h / 2); sh.quadraticCurveTo(-w / 2, h / 2, -w / 2, h / 2 - q); sh.lineTo(-w / 2, -h / 2 + q); sh.quadraticCurveTo(-w / 2, -h / 2, -w / 2 + q, -h / 2); return sh; };
    const win = (() => { const w = 0.98, h = 1.5, q = 0.12, qo = 0.55, sh = new THREE.Shape(); sh.moveTo(0, 0); sh.lineTo(w - q, 0); sh.quadraticCurveTo(w, 0, w, q); sh.lineTo(w, h - qo); sh.quadraticCurveTo(w, h, w - qo, h); sh.lineTo(q, h); sh.quadraticCurveTo(0, h, 0, h - q); sh.lineTo(0, q); sh.quadraticCurveTo(0, 0, q, 0); return sh; })();
    for (const z of [1, -1]) {
      const zz = z * (Wb / 2 + 0.004);
      flat(win, glass, 0.74, 0.82, zz); flat(win, glass, -0.74, 0.82, zz, -1);
      flat(rect(1.36, 2.1, 0.08), '#dfe2e6', 0, 1.29, zz);
      for (const x of [-0.335, 0.335]) flat(rect(0.62, 2.0, 0.05), '#1f252d', x, 1.3, zz, 1, 1);
      add(bus, Lb - 0.9, 0.16, 0.03, '#1f3a5f', 0, 0.2, z * (Wb / 2 + 0.02));
    }
    for (const [x, z] of [[1.85, 1.0], [1.85, -1.0], [-1.85, 1.0], [-1.85, -1.0]]) { const w = new THREE.Mesh(new THREE.CylinderGeometry(0.32, 0.32, 0.28, 20), M('#262626')); w.rotation.x = Math.PI / 2; w.position.set(x, 0.32, z); bus.add(w); const hub = new THREE.Mesh(new THREE.CylinderGeometry(0.18, 0.18, 0.3, 16), M('#cfd2d6')); hub.rotation.x = Math.PI / 2; hub.position.set(x, 0.32, z); bus.add(hub); }
    // 屋根の LiDAR は真ん中に1つ、小さく
    add(bus, 0.12, 0.05, 0.12, '#8d939b', 0, yt + 0.02, 0); const ld = new THREE.Mesh(new THREE.CylinderGeometry(0.055, 0.06, 0.08, 16), M('#2b2f36')); ld.position.set(0, yt + 0.08, 0); bus.add(ld);
  }
  const blinkOn = new THREE.MeshBasicMaterial({ color: '#ffb020' }), blinkOff = new THREE.MeshLambertMaterial({ color: '#b08a40' });
  // ウインカー：前後の端の角（低い位置）と、側面の前後。左右どちらにも付け、曲がる側だけ光らせる
  const blinkers = [-1, 1].flatMap((side) => [[2.611, 0.5, side * 0.8, 0.02, 0.1, 0.16], [-2.611, 0.5, side * 0.8, 0.02, 0.1, 0.16], [2.25, 0.62, side * 1.106, 0.22, 0.08, 0.012], [-2.25, 0.62, side * 1.106, 0.22, 0.08, 0.012]].map(([x, y, z, w, h, d]) => { const m = new THREE.Mesh(new THREE.BoxGeometry(w, h, d), blinkOff); m.position.set(x, y, z); m.userData.left = side < 0; bus.add(m); return m; }));
  s.add(bus);
  const person = (c) => { const g = new THREE.Group(); const b = new THREE.Mesh(new THREE.CylinderGeometry(0.26, 0.28, 1.22, 14), M(c)); b.position.y = 0.61; b.castShadow = true; g.add(b); const h = new THREE.Mesh(new THREE.SphereGeometry(0.2, 14, 10), M(c)); h.position.y = 1.46; h.castShadow = true; g.add(h); return g; };
  let vc = cfg; // 描いている回の設定（自動再生では回ごとに変わる）
  const setRoute = (rt) => { hedge.scale.y = rt === 'short' ? 1 : 0.35; hedge.position.y = rt === 'short' ? 0 : -0.25; };
  const guide = person('#1f5fd6'); guide.position.set(-4.6, 0.15, -6.7); s.add(guide);
  const arm = new THREE.Mesh(new THREE.BoxGeometry(0.12, 0.12, 0.9), M('#1f5fd6')); arm.position.set(-4.6, 1.35, -6.2); s.add(arm);
  const pool = [];
  const ring = (c) => { const g = new THREE.Group(); const mat = new THREE.MeshBasicMaterial({ color: c }); const m = new THREE.Mesh(new THREE.TorusGeometry(1.4, 0.08, 8, 48), mat); m.rotation.x = -Math.PI / 2; g.add(m); const pin = new THREE.Mesh(new THREE.CylinderGeometry(0.06, 0.06, 2.2, 8), mat); pin.position.y = 2.6; g.add(pin); const head = new THREE.Mesh(new THREE.SphereGeometry(0.32, 16, 12), mat); head.position.y = 3.8; g.add(head); g.visible = false; s.add(g); return g; };
  const red = ring('#d93a3a'), black = ring('#111111');
  let cur = host;
  function resize() { const w = cur.clientWidth, h = cur.clientHeight; if (!w || !h) return; r.setSize(w, h, false); cam.aspect = w / h; cam.updateProjectionMatrix(); }
  const ro = new ResizeObserver(resize); ro.observe(host); resize();
  function setFrame(f, opts = {}) {
    const jump = Math.hypot(bus.position.x - f.bus.x, bus.position.z - f.bus.z) > 6;
    bus.position.set(f.bus.x, 0.16, f.bus.z); bus.rotation.y = f.bus.h;
    if (jump && mode === 'follow') snapFollow = true;
    // 左折の合図：交差点の手前から曲がり終わるまで点滅
    // 曲がる合図：曲がる側（左折なら左、右折なら右）だけを、交差点の手前から曲がり終わるまで点滅
    const lit = !!f.bus.blink && (performance.now() % 700) < 380;
    blinkers.forEach((m) => { m.material = lit && (f.bus.blink === 'L') === m.userData.left ? blinkOn : blinkOff; });
    // 人は id ごとに色と背の高さを少しずつ変える（誘導員の青は使わない）。通り過ぎるだけの人は淡い色
    while (pool.length < f.peds.length) { const p = person('#e8b923'); s.add(p); pool.push(p); }
    pool.forEach((p, i) => { const q = f.peds[i]; p.visible = !!q; if (!q) return; p.position.set(q.x, 0.15, q.z);
      const c = q.type === 'ambient' ? '#c4c1ba' : '#e8b923'; // 渡る人は黄色、通り過ぎるだけの人は淡い灰色、誘導員は青 if (p.userData.c !== c) { p.userData.c = c; p.children.forEach((m) => m.material.color.set(c)); }
      const sc = 0.9 + ((q.id * 37) % 5) * 0.05; p.scale.set(1, sc, 1); });
    arm.visible = !!f.guide && vc.guide; guide.visible = vc.guide;
    red.visible = !!opts.red; if (opts.red) red.position.set(opts.red.x, 0.3, opts.red.z);
    black.visible = !!opts.black; if (opts.black) black.position.set(opts.black.x, 0.3, opts.black.z);
  }
  function screenOf(x, z) { const v = new THREE.Vector3(x, 1.5, z).project(cam); return { x: (v.x + 1) / 2 * host.clientWidth, y: (1 - v.y) / 2 * host.clientHeight }; }
  let lastT = performance.now(), followH = 0, snapFollow = true; const lookAt = new THREE.Vector3();
  function loop() {
    const now = performance.now(), dtR = Math.min(0.1, (now - lastT) / 1000); lastT = now;
    if (mode === 'follow') {
      // 向きをなめらかに追い、斜め後ろの少し上から見る
      let dh = bus.rotation.y - followH; dh = Math.atan2(Math.sin(dh), Math.cos(dh));
      const k = snapFollow ? 1 : 1 - Math.exp(-dtR * 3);
      followH += dh * k;
      const dx = Math.cos(followH), dz = -Math.sin(followH);
      const want = new THREE.Vector3(bus.position.x - dx * 14, 8.5, bus.position.z - dz * 14);
      if (snapFollow) cam.position.copy(want); else cam.position.lerp(want, k);
      lookAt.lerp(new THREE.Vector3(bus.position.x + dx * 6, 0.5, bus.position.z + dz * 6), snapFollow ? 1 : k);
      cam.lookAt(lookAt); snapFollow = false;
    }
    r.render(s, cam); requestAnimationFrame(loop);
  }
  loop();
  // 動かす：ドラッグで回す、ホイール・2本指で寄る
  const ptrs = new Map(); let pinch0 = 0;
  const cv = r.domElement;
  cv.addEventListener('pointerdown', (e) => { cv.setPointerCapture(e.pointerId); ptrs.set(e.pointerId, { x: e.clientX, y: e.clientY }); if (ptrs.size === 2) { const [a, b] = [...ptrs.values()]; pinch0 = Math.hypot(a.x - b.x, a.y - b.y); } });
  cv.addEventListener('pointermove', (e) => {
    const p = ptrs.get(e.pointerId); if (!p) return;
    if (ptrs.size === 1) {
      if (mode === 'follow') setView('custom');
      az -= (e.clientX - p.x) * 0.006; el = Math.min(1.55, Math.max(0.12, el + (e.clientY - p.y) * 0.005)); placeCam();
    } else if (ptrs.size === 2) {
      p.x = e.clientX; p.y = e.clientY; const [a, b] = [...ptrs.values()]; const d = Math.hypot(a.x - b.x, a.y - b.y);
      if (pinch0) { dist = Math.min(90, Math.max(8, dist * pinch0 / d)); pinch0 = d; placeCam(); } return;
    }
    p.x = e.clientX; p.y = e.clientY;
  });
  const up = (e) => { ptrs.delete(e.pointerId); pinch0 = 0; };
  cv.addEventListener('pointerup', up); cv.addEventListener('pointercancel', up);
  cv.addEventListener('wheel', (e) => { e.preventDefault(); if (mode === 'follow') setView('custom'); dist = Math.min(90, Math.max(8, dist * Math.exp(e.deltaY * 0.0012))); placeCam(); }, { passive: false });
  function setView(v) {
    mode = v === 'follow' ? 'follow' : 'orbit'; if (mode === 'follow') { snapFollow = true; followH = bus.rotation.y; }
    if (v === 'iso') { az = home.az; el = home.el; dist = home.dist; }
    if (v === 'opp') { az = home.az + Math.PI; el = home.el; dist = home.dist; }
    if (v === 'top') { el = 1.55; dist = 52; }
    placeCam();
    document.querySelectorAll('#viewBtns button').forEach((b) => b.classList.toggle('on', b.dataset.v === v));
  }
  return { setView, setFrame, setRoute, setCfg: (c) => { vc = c; setRoute(c.route); }, screenOf, moveTo: (el) => { el.prepend(r.domElement); el.appendChild(document.getElementById('views')); ro.disconnect(); cur = el; ro.observe(el); requestAnimationFrame(resize); }, host };
})();
scene.setFrame({ bus: { ...E.busPose(49), v: 0 }, peds: [], guide: false });
$('#viewBtns').addEventListener('click', (e) => { const b = e.target.closest('button'); if (b) scene.setView(b.dataset.v); });

// ---- 1年を回す ----
const runs = []; let year = null, speed = 'day', timer = null, replay = null;
const dateOf = (d) => { const t = new Date(2027, 3, 1 + Math.floor(d * 365 / E.PARAMS.daysPerYear)); return `${t.getMonth() + 1}月${t.getDate()}日`; };
const timeOf = (i) => { const m = 7 * 60 + i * 18; return `${Math.floor(m / 60)}:${String(m % 60).padStart(2, '0')}`; };
$('#speeds').addEventListener('click', (e) => { const b = e.target.closest('button'); if (!b) return; speed = b.dataset.s; [...$('#speeds').children].forEach((x) => x.classList.toggle('on', x === b)); if (speed === 'skip') finishFast(); });
$('#run').addEventListener('click', () => (playKind === 'scene' ? startScene() : startYear()));
$('#autoRun').addEventListener('click', startAuto);
$('#incLog').addEventListener('click', (e) => { const b = e.target.closest('.li'); if (!b) return; const open = b.getAttribute('aria-expanded') !== 'true'; b.setAttribute('aria-expanded', String(open)); if (incLog[+b.dataset.i]) incLog[+b.dataset.i].open = open; /* 新しいできごとが来ても、ひらいたものはひらいたまま */ });
$('#stopRun').addEventListener('click', () => { auto = null; stopTimers(); setPlayMode('setup'); });
function setPlayMode(m) {
  const running = m === 'run' || m === 'scene';
  if (m === 'setup') { stopTimers(); scene.setCfg({ ...cfg }); }
  locked = running; drawPanel();
  $('#groups').style.display = running ? 'none' : ''; $('#runInfo').style.display = running ? '' : 'none';
  $('#modeTabs').style.display = running ? 'none' : ''; $('#scenes').style.display = running ? 'none' : '';
  if (running) { $('#cfgLine').innerHTML = G().map((g) => `<span>${glabel(g)}</span><b>${label(g.k, cfg[g.k])}</b>`).join(''); $('#incident').innerHTML = '<p class="note">ひやりや事故が起きると、ここに「何が起きたか・原因・かかわる人」が出ます</p>'; $('#incLog').innerHTML = ''; incLog = []; }
  $('#sceneSpeeds').style.display = m === 'scene' ? 'flex' : 'none';
  $('#intro').style.display = m === 'setup' ? '' : 'none'; $('#clock').style.display = m === 'run' ? 'block' : 'none';
  $('#stats').style.display = m === 'run' ? 'grid' : 'none'; $('#callout').style.display = 'none';
  $('#run').style.display = m === 'setup' ? '' : 'none'; $('#autoRun').style.display = m === 'setup' && playKind === 'scene' ? '' : 'none'; $('#stopRun').style.display = running ? '' : 'none';
  $('#stopRun').textContent = m === 'scene' ? '設定に戻る' : '止めて仕組みを変える'; $('#incLog').style.display = m === 'scene' ? 'none' : '';
  $('#panelTitle').textContent = running ? 'シミュレーション設定' : ''; $('#panelTitle').style.display = running ? '' : 'none'; // 決める画面では、左上の説明が同じことを言っているので出さない
  $('#panelNote').textContent = m === 'run' ? '数字は試作の仮の決まり。予測ではありません' : '数字は試作の仮の決まり。予測ではありません';
}
function stopTimers() { clearTimeout(timer); timer = null; replay = null; }
// ---- 場面を選んで確かめる ----
let playKind = 'scene', sceneId = E.SCENES[0].id, sceneRuns = [], runCounter = 0, sceneRate = 1;
$('#sceneSpeeds').addEventListener('click', (e) => { const b = e.target.closest('button'); if (!b) return; sceneRate = +b.dataset.r; [...$('#sceneSpeeds').children].forEach((x) => x.classList.toggle('on', x === b)); if (replay && replay.scene) replay.rate = sceneRate; });
function drawScenes() {
  $('#scenes').innerHTML = playKind === 'scene' ? '<div class="h">場面</div>' + E.SCENES.map((sc) => `<button class="sc ${sc.id === sceneId ? 'on' : ''}" data-id="${sc.id}"><b>${sc.title}</b><span>${sc.note}</span></button>`).join('') : '';
}
function setPlayKind(k) {
  playKind = k; [...$('#modeTabs').children].forEach((b) => b.classList.toggle('on', b.dataset.m === k));
  drawScenes(); drawPanel(); $('#autoRun').style.display = k === 'scene' ? '' : 'none';
  $('#run').innerHTML = k === 'scene' ? 'この場面を見る <span aria-hidden="true">→</span>' : 'この仕組みで1年を回す <span aria-hidden="true">→</span>';
  $('#introText').textContent = k === 'scene' ? '右で場面と設定を選んで、その1回を見てください。設定を1つ変えてもう一度見ると、問題が誰に移るかを比べられます。' : '右で仕組みを決めて、1年を回してください。いろいろな場面が混ざって起きます。起きた事故で誰にどれだけ責任があるかを、最後にあなたが考えます。';
}
$('#modeTabs').addEventListener('click', (e) => { const b = e.target.closest('button'); if (b) setPlayKind(b.dataset.m); });
$('#scenes').addEventListener('click', (e) => { const b = e.target.closest('.sc'); if (!b) return; sceneId = b.dataset.id; cfg.dir = E.SCENES.find((x) => x.id === sceneId).route; drawScenes(); drawPanel(); });
function startScene() {
  auto = null;
  const sc = E.SCENES.find((x) => x.id === sceneId); show('play'); setPlayMode('scene');
  $('#panelTitle').textContent = sc.title;
  $('#incident').innerHTML = '<p class="note">この場面を再生しています</p>';
  const p = { seed: 42, scene: E.sceneFor(sc, cfg.dir, cfg), cfg: { ...cfg }, kind: 'scene', runId: ++runCounter, rate: sceneRate };
  playPass(p, 1, (r) => sceneDone(p, r), -1);
}
// ---- 自動再生：選んだ場面を、設定を1つずつ変えながら次々に再生し、最後に一覧で並べる ----
let auto = null;
function autoVariants() {
  const req = sceneReq(), list = [{ label: 'いまの設定', cfg: { ...cfg }, k: null }];
  for (const g of G()) { if (g.k in req) continue; for (const o of g.opts) if (o[0] !== cfg[g.k] && (g.k !== 'dir' || sceneDirs().includes(o[0]))) list.push({ label: `${glabel(g)}を「${splitOpt(o[1])[0]}」に`, cfg: { ...cfg, [g.k]: o[0] }, k: g.k }); }
  return list;
}
function startAuto() {
  const sc = E.SCENES.find((x) => x.id === sceneId);
  auto = { sc, list: autoVariants(), i: 0, res: [] };
  show('play'); setPlayMode('scene'); $('#panelTitle').textContent = `${sc.title}（自動再生）`;
  autoNext();
}
function autoNext() {
  const a = auto; if (!a) return;
  if (a.i >= a.list.length) { const done = a; auto = null; openAutoSummary(done); return; }
  const v = a.list[a.i];
  $('#cfgLine').innerHTML = G().map((g) => `<span>${glabel(g)}</span><b class="${g.k === v.k ? 'chg' : ''}">${label(g.k, v.cfg[g.k])}</b>`).join('');
  $('#incident').innerHTML = `<p class="note" style="font-size:13px;color:#111"><b>${a.i + 1} / ${a.list.length}</b>　${v.label}</p><div id="autoNow"></div>${autoHistory(a)}`;
  const p = { seed: 42, scene: E.sceneFor(a.sc, v.cfg.dir, v.cfg), cfg: v.cfg, kind: 'scene', runId: ++runCounter, rate: sceneRate };
  playPass(p, 1, (r) => {
    if (auto !== a) return;
    const kind = r.hit ? 'hit' : r.near ? 'near' : 'safe';
    const ex = kind === 'hit' ? explain(r.facts, v.cfg, 'hit') : kind === 'near' ? explain(r.nearFacts, v.cfg, 'near') : null;
    a.res.push({ ...v, kind, ex, reasons: kind === 'safe' ? safeReasons(r, v.cfg) : null });
    // いまの回の結果を出し、その下にこれまでの回の履歴を並べる
    const cur = kind === 'safe' ? `<div class="inc safe"><div class="hd"><span class="tag">何も起きなかった</span></div><ul>${safeReasons(r, v.cfg).map((x) => `<li>${x}</li>`).join('')}</ul></div>` : incCard(kind, ex, v.label, '');
    $('#incident').innerHTML = `<p class="note" style="font-size:13px;color:#111"><b>${a.i + 1} / ${a.list.length}</b>　${v.label}</p>${cur}${autoHistory(a, true)}`;
    a.i++; timer = setTimeout(autoNext, 1500 / sceneRate);
  }, -1);
}
// 自動再生の履歴：これまでの回を新しい順に。押すと、その回の説明がひらく
function autoHistory(a, skipLast) {
  const list = (skipLast ? a.res.slice(0, -1) : a.res).map((x, i) => ({ x, n: i + 1 })).reverse();
  if (!list.length) return '';
  const badge = (x) => (x.kind === 'hit' ? '<span class="rk hit">事故</span>' : x.kind === 'near' ? '<span class="rk near">ひやり</span>' : '<span class="rk safe">何も起きなかった</span>');
  return `<div class="ahist"><h4>これまでの回</h4>${list.map(({ x, n }) => `<details><summary><b>${n}</b>${badge(x)}<span>${x.label}</span></summary>${x.kind === 'safe' ? `<div class="inc safe"><ul>${x.reasons.map((t) => `<li>${t}</li>`).join('')}</ul></div>` : incCard(x.kind, x.ex, x.label, '')}</details>`).join('')}</div>`;
}
function openAutoSummary(a) {
  const res = (x) => (x.kind === 'hit' ? '<span class="rk hit">事故</span>' : x.kind === 'near' ? '<span class="rk near">ひやり</span>' : '<span class="rk safe">何も起きなかった</span>');
  // 行を押すと、その回の詳しい説明（場面を1回見たときと同じカード）が下にひらく
  const detail = (x) => (x.kind === 'safe' ? `<div class="inc safe"><div class="hd"><span class="tag">何も起きなかった</span>${x.label}</div><h4>止まれた理由</h4><ul>${x.reasons.map((t) => `<li>${t}</li>`).join('')}</ul></div>` : incCard(x.kind, x.ex, x.label, ''));
  const rows = a.res.map((x, i) => `<tr class="arow" data-i="${i}"><td><span class="tg">＋</span>${i === 0 ? '<b>いまの設定</b>' : x.label}</td><td>${res(x)}</td><td>${x.ex ? x.ex.who.map((w) => `<i class="${w.includes('あなた') ? 'me' : ''}">${w}</i>`).join('') : `<span class="sub">${x.reasons[0]}</span>`}</td><td>${x.ex && x.ex.open ? `<span class="sub">${x.ex.open}</span>` : ''}</td></tr><tr class="adet" data-i="${i}" hidden><td colspan="4">${detail(x)}</td></tr>`).join('');
  $('#sceneCmp').innerHTML = `<p class="eyebrow">場面：${a.sc.title}（自動再生）</p><h2>設定を1つずつ変えると、結果と問題はどう変わる？</h2>
    <p class="note">いまの設定から1つだけ変えて、同じ場面を${a.res.length}回見た結果です。歩く人の動きは毎回同じです。行を押すと、その回の詳しい説明がひらきます</p>
    <table class="auto"><thead><tr><th>変えたこと</th><th>結果</th><th>かかわる人（何も起きなければ止まれた理由）</th><th>まだ決まっていないこと</th></tr></thead><tbody>${rows}</tbody></table>
    <div class="foot"><button class="link" id="autoBack">← 設定に戻る</button><button class="cta" id="autoAgain">別の場面で自動再生 <span aria-hidden="true">→</span></button></div>`;
  scene.moveTo($('#stage')); show('sceneCmp');
  $('#sceneCmp').querySelector('tbody').addEventListener('click', (e) => { const r = e.target.closest('.arow'); if (!r) return; const d = $('#sceneCmp').querySelector(`.adet[data-i="${r.dataset.i}"]`); d.hidden = !d.hidden; r.querySelector('.tg').textContent = d.hidden ? '＋' : '－'; });
  $('#autoBack').addEventListener('click', () => { show('play'); setPlayMode('setup'); });
  $('#autoAgain').addEventListener('click', () => { show('play'); setPlayMode('setup'); });
}
function safeReasons(r, c) {
  const k = new Set(r.events.map((e) => e.k)), out = [];
  if (k.has('sensed')) out.push('バスのセンサーが人に気づき、自動ブレーキで止まった');
  if (k.has('opbrake')) out.push(`${WATCHER(c)}が人に気づいて止めた`);
  if (k.has('remote')) out.push('遠隔監視者が映像で気づき、止める指示を出した');
  if (!out.length) out.push('人が渡り終えるまでバスが待ったか、人がバスに気づいて待った');
  return out;
}
function sceneDone(p, r) {
  const sc = p.scene, c = p.cfg;
  const kind = r.hit ? 'hit' : r.near ? 'near' : 'safe';
  const ex = kind === 'hit' ? explain(r.facts, c, 'hit') : kind === 'near' ? explain(r.nearFacts, c, 'near') : null;
  if (kind === 'safe') $('#incident').innerHTML = `<div class="inc safe"><div class="hd"><span class="tag">何も起きなかった</span>${sc.title}</div><h4>止まれた理由</h4><ul>${safeReasons(r, c).map((x) => `<li>${x}</li>`).join('')}</ul></div>`;
  const prev = sceneRuns.filter((x) => x.sceneId === sc.id).at(-1);
  sceneRuns.push({ sceneId: sc.id, cfg: c, kind, ex, reasons: kind === 'safe' ? safeReasons(r, c) : null });
  const btns = `<div class="sbtns"><button class="cta" id="sAgain">設定を変えて見直す <span aria-hidden="true">→</span></button>${prev ? '<button class="cta sub" id="sCmp">前の回と比べる</button>' : ''}<button class="link" id="sReplay">同じ設定でもう一度</button></div>`;
  $('#incident').insertAdjacentHTML('beforeend', btns);
  $('#sAgain').addEventListener('click', () => { setPlayMode('setup'); });
  $('#sReplay').addEventListener('click', () => startScene());
  if (prev) $('#sCmp').addEventListener('click', () => openSceneCompare(prev, sceneRuns.at(-1)));
}
function openSceneCompare(a, b) {
  const sc = E.SCENES.find((x) => x.id === b.sceneId);
  const res = (x) => (x.kind === 'hit' ? '事故' : x.kind === 'near' ? 'ひやり' : '何も起きなかった');
  const changed = G().filter((g) => a.cfg[g.k] !== b.cfg[g.k]);
  const col = (x, other, title) => `<div class="col"><h3>${title}</h3>
    <div class="cfg">${G().map((g) => `<span>${g.label instanceof Function ? g.label(x.cfg) : g.label}</span><b class="${x.cfg[g.k] !== other.cfg[g.k] ? 'chg' : ''}">${label(g.k, x.cfg[g.k])}</b>`).join('')}</div>
    ${x.kind === 'safe' ? `<div class="inc safe"><div class="hd"><span class="tag">何も起きなかった</span></div><h4>止まれた理由</h4><ul>${x.reasons.map((t) => `<li>${t}</li>`).join('')}</ul></div>` : incCard(x.kind, x.ex, sc.title, '')}</div>`;
  const wa = new Set(a.ex ? a.ex.who : []), wb = new Set(b.ex ? b.ex.who : []);
  const gone = [...wa].filter((w) => !wb.has(w)), added = [...wb].filter((w) => !wa.has(w));
  const sum = `変えたこと：${changed.length ? changed.map((g) => `${g.label instanceof Function ? g.label(b.cfg) : g.label}を「${label(g.k, b.cfg[g.k])}」に`).join('、') : 'なし'}。<br>結果：${res(a)} → ${res(b)}。` +
    (gone.length ? `<br>問題から外れた：${gone.join('・')}` : '') + (added.length ? `<br>新しく問題になった：${added.join('・')}` : '') + (!gone.length && !added.length ? '<br>かかわる人は変わらなかった' : '');
  $('#sceneCmp').innerHTML = `<p class="eyebrow">場面：${sc.title}</p><h2>設定を変えると、問題はどこへ移る？</h2><div class="sum">${sum}</div><div class="cols">${col(a, b, 'まえ')}${col(b, a, 'あと')}</div>
    <div class="foot"><button class="link" id="cmpBack">← 設定に戻る</button><button class="cta" id="cmpAgain">続けて、もう1つ変える <span aria-hidden="true">→</span></button></div>`;
  scene.moveTo($('#stage')); show('sceneCmp');
  $('#cmpBack').addEventListener('click', () => { show('play'); setPlayMode('setup'); });
  $('#cmpAgain').addEventListener('click', () => { show('play'); setPlayMode('setup'); });
}
function startYear() {
  show('play'); setPlayMode('run');
  year = { cfg: { ...cfg }, seed: (runs.length + 1) * 7919, day: 0, pass: 0, accidents: [], near: 0, waitSum: 0, passes: 0 };
  updateStats(); tick();
}
function simDay() {
  const P = E.PARAMS, y = year; const shows = []; y.today = { day: y.day, acc: 0, near: 0 };
  for (let i = 0; i < P.passesPerDay; i++) {
    const seed = (y.seed * 1000003 + y.day * P.passesPerDay + i) >>> 0, evening = i >= 34 && i < 37;
    const r = E.simulatePass(y.cfg, E.rng(seed), { evening });
    y.passes++; y.waitSum += r.wait + (y.cfg.route === 'long' ? P.detourSec : 0);
    if (r.hit) { y.today.acc++; const a = { day: y.day, pass: i, seed, evening, facts: r.facts }; y.accidents.push(a); shows.push({ ...a, kind: 'hit' }); }
    else if (r.near) { y.near++; y.today.near++; if (shows.length < 1) shows.push({ day: y.day, pass: i, seed, evening, kind: 'near' }); }
  }
  y.day++; return shows;
}
function updateStats() {
  $('#sAcc').textContent = year.accidents.length; $('#sNear').textContent = year.near;
  $('#sDelay').textContent = (year.passes ? year.waitSum / year.passes / 60 : 0).toFixed(2); $('#sCost').textContent = E.cost(year.cfg);
  const d = Math.min(year.day, E.PARAMS.daysPerYear - 1);
  $('#date').innerHTML = `${dateOf(d)}<small>1年のうち ${d + 1}日目</small>`;
}
function playPass(p, rate, done, fromT = 0) {
  scene.setCfg(p.cfg || year.cfg); // 誘導員・植え込みを、この回の設定どおりに描く
  const r = E.simulatePass(p.cfg || year.cfg, E.rng(p.seed), { evening: p.evening, record: true, scene: p.scene });
  const hitE = r.events.find((e) => e.k === 'hit'); const fr = r.frames;
  let mark = null;
  if (p.kind === 'near' || (p.scene && r.near)) { let best = null; for (const f of fr) { if (f.bus.v <= 1.0) continue; for (const q of f.peds) { if (q.type === 'ambient' || (r.nearFacts && q.id !== r.nearFacts.id)) continue; const dd = Math.hypot(q.x - f.bus.x, q.z - f.bus.z); if (!best || dd < best.d) best = { d: dd, x: q.x, z: q.z, t: f.t }; } } mark = best; }
  const tEnd = hitE ? hitE.t + 1.5 : Math.min(E.PARAMS.passTime, (fr.at(-1) || { t: 0 }).t);
  // fromT < 0：交差点の手前16mあたりから見せる（長い直線は飛ばす）
  if (fromT < 0) { const f0 = fr.find((f) => Math.hypot(f.bus.x, f.bus.z + 4) < 16); fromT = f0 ? f0.t : 0; }
  // 速さは再生の途中でも変えられる（p.rate）。経過時間を毎回足していく
  p.rate = p.rate || rate; let t = fromT, last = performance.now(); replay = p; let lastF = null;
  $('#callout').style.display = 'none'; // 前の回の印を消してから始める
  const step = () => {
    if (replay !== p) return;
    const now = performance.now(); t += (now - last) / 1000 * p.rate; last = now; const f = frameAt(fr, t, r.route); lastF = f || lastF;
    if (f) {
      const opts = {};
      if (hitE && t >= hitE.t) { const q = f.peds.reduce((a, b) => (Math.hypot(b.x - f.bus.x, b.z - f.bus.z) < Math.hypot(a.x - f.bus.x, a.z - f.bus.z) ? b : a), f.peds[0] || f.bus); opts.red = q; callout(q, p.scene ? '事故' : `事故　${dateOf(p.day)} ${timeOf(p.pass)}`, '右のパネルに原因'); showIncident('hit', r.facts, p); }
      // ひやりの印は、近づいた瞬間から少しのあいだだけ出す
      if (mark && t >= mark.t && t < mark.t + 2.5) { opts.black = mark; callout(mark, 'ひやり', '右のパネルに原因'); if (r.nearFacts) showIncident('near', r.nearFacts, p); }
      else if (mark && t >= mark.t + 2.5 && !opts.red) $('#callout').style.display = 'none';
      scene.setFrame(f, opts);
    }
    if (t < tEnd) requestAnimationFrame(step);
    else { if (!hitE) { $('#callout').style.display = 'none'; if (lastF) scene.setFrame(lastF, {}); } if (replay === p) replay = null; done && done(r); }
  };
  requestAnimationFrame(step);
}
// 0.5秒ごとの記録の間をつないで、なめらかに動かす
function frameAt(fr, t, route) {
  if (!fr.length) return null;
  const i = Math.max(0, Math.min(fr.length - 1, Math.floor(t / 0.5))), a = fr[i], b = fr[i + 1] || a;
  const k = b === a ? 0 : Math.min(1, Math.max(0, (t - a.t) / (b.t - a.t)));
  const L = (x, y) => x + (y - x) * k;
  let dh = b.bus.h - a.bus.h; dh = Math.atan2(Math.sin(dh), Math.cos(dh));
  const peds = a.peds.map((p) => { const q = b.peds.find((x) => x.id === p.id) || p; return { ...p, x: L(p.x, q.x), z: L(p.z, q.z) }; });
  // バスは、道のりと速さから3次の補間でなめらかにつなぎ、道の形に沿って置く（直線でつなぐと速さが段になって見える）
  if (route && a.bus.s !== undefined && b !== a) {
    const T = b.t - a.t, u = k, h00 = 2 * u ** 3 - 3 * u ** 2 + 1, h10 = u ** 3 - 2 * u ** 2 + u, h01 = -2 * u ** 3 + 3 * u ** 2, h11 = u ** 3 - u ** 2;
    let sv = h00 * a.bus.s + h10 * T * a.bus.v + h01 * b.bus.s + h11 * T * b.bus.v; sv = Math.min(Math.max(sv, Math.min(a.bus.s, b.bus.s)), Math.max(a.bus.s, b.bus.s));
    const ps = E.ROUTES[route].pose(sv);
    return { t, bus: { x: ps.x, z: ps.z, h: ps.h, v: L(a.bus.v, b.bus.v), blink: a.bus.blink }, peds, guide: a.guide || b.guide };
  }
  return { t, bus: { x: L(a.bus.x, b.bus.x), z: L(a.bus.z, b.bus.z), h: a.bus.h + dh * k, v: L(a.bus.v, b.bus.v), blink: a.bus.blink }, peds, guide: a.guide || b.guide };
}
// 走っている間のパネル：起きたことの説明
let incLog = [], incShown = null;
// ひやり・事故の説明カード（いま起きたものも、一覧でひらいたものも同じ見た目）
function incCard(kind, ex, when, note) {
  const sec = (title, arr) => (arr.length ? `<h4>${title}</h4><ul class="who3">${arr.map((x) => `<li><b class="${x.who.includes('あなた') ? 'me' : ''}">${x.who}</b>${x.text}</li>`).join('')}</ul>` : '');
  return `<div class="inc ${kind}"><div class="hd"><span class="tag">${kind === 'hit' ? '事故' : 'ひやり'}</span>${when}</div>
    <p class="what">${ex.what}</p>
    ${sec('人の問題', ex.people)}${sec('企業の問題', ex.company)}${sec('決まり・行政', ex.rules)}
    ${ex.open ? `<div class="open"><span>まだ決まっていないこと</span>${ex.open}</div>` : ''}
    ${note ? `<p class="note" style="margin:0">${note}</p>` : ''}</div>`;
}
function collapseIncident() {
  if (!year || !year.today) return;
  const d = year.today, txt = d.acc || d.near ? `${dateOf(d.day)}：事故${d.acc}件・ひやり${d.near}回` : `${dateOf(d.day)}：ひやりも事故もなし`;
  $('#incident').innerHTML = `<p class="note" style="margin:0">${txt}</p>`;
  if (incOpen) { incOpen = false; drawIncLog(); }
}
function showIncident(kind, f, p) {
  const key = p.seed + ':' + kind + ':' + (p.runId || ''); if (incShown === key) return; incShown = key;
  const ex = explain(f, p.cfg || year.cfg, kind);
  if (p.scene) { $('#incident').innerHTML = incCard(kind, ex, p.scene.title, ''); return; }
  $('#incident').innerHTML = incCard(kind, ex, `${dateOf(p.day)} ${timeOf(p.pass)}`, kind === 'hit' ? '1年が終わったら、この事故で誰にどれだけ責任があるかを考えます' : '');
  incLog.unshift({ kind, t: `${dateOf(p.day)} ${timeOf(p.pass)}`, s: ex.causes[0], ex }); incLog = incLog.slice(0, 8); incOpen = true;
  drawIncLog();
}
// 1日が終わり、そのできごとの再生も終わったら、説明のカードをたたんで「これまで」の一覧に移し、今日のまとめを出す
let incOpen = false;
function drawIncLog() {
  // 一覧の1行を押すと、その場で詳しい説明（何が起きたか・なぜ・かかわる人）をひらく
  $('#incLog').innerHTML = (incOpen ? incLog.slice(1) : incLog).map((x, i) => `<div class="li" role="button" tabindex="0" data-i="${incOpen ? i + 1 : i}" aria-expanded="${!!x.open}"><span class="row1"><b class="${x.kind}">${x.kind === 'hit' ? '事故' : 'ひやり'}</b>${x.t}　${x.s}</span><div class="more">${incCard(x.kind, x.ex, x.t, '')}</div></div>`).join('');
}
function callout(pt, title, text) { const c = $('#callout'); const s = scene.screenOf(pt.x, pt.z); c.style.display = 'block'; c.style.left = Math.min(s.x + 30, scene.host.clientWidth - 270) + 'px'; c.style.top = Math.max(s.y - 80, 90) + 'px'; c.innerHTML = `<b>${title}</b>${text}`; }
function tick() {
  if (!year) return;
  if (year.day >= E.PARAMS.daysPerYear) return endYear();
  const shows = simDay(); updateStats();
  if (!replay || !incOpen) collapseIncident(); // 説明のカードは、そのできごとの再生が終わった次の日にたたむ
  const hit = shows.find((x) => x.kind === 'hit');
  if (!replay) $('#callout').style.display = 'none';
  if (speed === 'skip') { timer = setTimeout(tick, 0); return; }
  if (hit) { playPass(hit, 1, () => { timer = setTimeout(tick, 1200); }); return; }
  if (speed === 'real') { const p = shows[0] || { day: year.day - 1, pass: 0, seed: (year.seed * 1000003 + (year.day - 1) * 40) >>> 0, kind: 'plain' }; playPass(p, 1, () => { timer = setTimeout(tick, 200); }); return; }
  // 1日を1秒：日は進めつづけ、再生はそれとは別に、1回の通過を交差点の先まで最後まで見せる
  if (!replay) {
    const p = shows[0] || { day: year.day - 1, pass: 0, seed: (year.seed * 1000003 + (year.day - 1) * E.PARAMS.passesPerDay) >>> 0, kind: 'plain' };
    playPass(p, 2.5, () => {}, -1);
  }
  timer = setTimeout(tick, 1000);
}
// 結果まで飛ばす：画面が固まらないよう、数日ずつ区切って計算し、そのあいだも日付と数字を進める
function finishFast() {
  if (!year) return; stopTimers(); const y = year;
  const chunk = () => { if (year !== y) return; for (let i = 0; i < 6 && y.day < E.PARAMS.daysPerYear; i++) simDay(); updateStats(); if (y.day < E.PARAMS.daysPerYear) timer = setTimeout(chunk, 0); else endYear(); };
  chunk();
}
function endYear() { stopTimers(); year.delay = year.waitSum / year.passes / 60; year.cost = E.cost(year.cfg); runs.push(year); showResult(); }

// ---- ③ 結果 ----
const views = ['play', 'result', 'accident', 'assign', 'compare', 'sceneCmp'];
function show(v) { views.forEach((x) => $('#' + x).classList.toggle('on', x === v)); window.scrollTo(0, 0); }
function accText(a) {
  const f = a.facts; const who = f.startedBy === 'bus' ? 'バスが自分で発進した直後' : '運転士が発進させた直後';
  const ped = f.fromBehindHedge && year.cfg.route === 'short' ? '植え込みの陰から来た歩行者' : (E.PED_LABEL[f.pedType] || '横断歩道に向かってきた歩行者');
  return `${E.ROUTES[f.route].label}。${who}、${ped}と接触`;
}
function showResult() {
  const y = runs.at(-1), prev = runs.at(-2);
  const diffs = prev ? G().filter((g) => prev.cfg[g.k] !== y.cfg[g.k]) : [];
  const head = !prev ? `この仕組みで、1年に事故が${y.accidents.length}件、ひやりが${y.near}回起きた`
    : (diffs.length ? diffs.map((g) => changePhrase(g.k, y.cfg[g.k])).join('、') + 'ら、' : '同じ仕組みのままで、') + `事故は${y.accidents.length < prev.accidents.length ? '減った' : y.accidents.length > prev.accidents.length ? '増えた' : '変わらなかった'}`;
  const rows = [['事故', 'accidents', '件', (r) => r.accidents.length, true], ['ひやり（1m以内）', 'near', '回', (r) => r.near], ['1便の遅れ（平均）', 'delay', '分', (r) => r.delay.toFixed(2)], ['運行の費用（いちばん安い仕組みを100）', 'cost', '', (r) => r.cost]];
  const dif = (a, b) => { const d = +a - +b; return d === 0 ? '同じ' : `${Math.abs(+d.toFixed(2))}${d > 0 ? '増' : '減'}`; };
  $('#result').innerHTML = `
    <p class="eyebrow">1年（営業日300日・1日40便）を回した結果</p>
    <h2>${head}</h2>
    ${prev ? `<div class="chg"><span style="background:none;padding:0;color:var(--sub)">変えたところ</span>${diffs.map((g) => `<span>${glabel(g)}　${label(g.k, prev.cfg[g.k])}</span><span aria-hidden="true" style="background:none;padding:0">→</span><span class="now">${label(g.k, y.cfg[g.k])}</span>`).join('') || '<span>なし（乱数だけが違う）</span>'}</div>` : ''}
    <div class="two">
      <div style="display:flex;flex-direction:column;gap:10px">
        <div class="row" style="background:none;padding:0 20px;font-size:13px;color:var(--sub)"><span></span><span>${prev ? '前の1年' : ''}</span><span>${prev ? '今の1年' : 'この1年'}</span></div>
        ${rows.map(([k, , u, f, red]) => `<div class="row"><span class="k">${k}</span><span class="p">${prev ? f(prev) : ''}<small>${prev ? u : ''}</small></span><span class="n" style="${red ? 'color:var(--red)' : ''}">${f(y)}<small style="color:var(--ink)">${u}</small>${prev ? `<em>${dif(f(y), f(prev))}</em>` : ''}</span></div>`).join('')}
        <p class="note">運行の費用は、安全のためにかけたお金の大きさです。車内に乗る人や遠隔監視者の人件費、死角の少ないセンサー、誘導員、植え込みの手入れの依頼、休憩の交代要員が上乗せされます。安全とお金のどちらを取るかも、仕組みを決める人の判断です。<br>数字は試作の仮の決まりで出しています。同じ仕組みでも、歩行者の動きは毎年少しずつ違います</p>
      </div>
      <div>
        <p style="margin:0 0 10px;font-weight:700">この1年の事故　${y.accidents.length}件</p>
        ${y.accidents.slice(0, 4).map((a, i) => `<button class="acc" data-i="${i}"><span class="w">${dateOf(a.day)} ${timeOf(a.pass)}${a.evening ? '（夕方の逆光）' : ''}</span><span class="t">${accText(a)}</span><span class="go">くわしく見て、責任の割合を考える →</span></button>`).join('') || '<p class="note">この1年は事故が起きませんでした。ひやりは起きています</p>'}
        ${y.accidents.length > 4 ? `<p class="note">ほか ${y.accidents.length - 4}件</p>` : ''}
      </div>
    </div>
    <div class="foot"><span></span><button class="cta" id="again">仕組みを変えて、もう1年回す <span aria-hidden="true">→</span></button></div>`;
  show('result');
  $('#result').querySelectorAll('.acc').forEach((b) => b.addEventListener('click', () => openAccident(y.accidents[+b.dataset.i])));
  $('#again').addEventListener('click', () => { show('play'); setPlayMode('setup'); });
}

// ---- ④ 事故をひらく ----
let current = null;
let acStageReady = false;
function openAccident(a) {
  const y = runs.at(-1);
  const r = E.simulatePass(y.cfg, E.rng(a.seed), { evening: a.evening, record: true });
  const hit = r.events.find((e) => e.k === 'hit'); const t0 = hit.t;
  const st = r.events.find((e) => e.k === 'start'); const sensed = r.events.filter((e) => (e.k === 'sensed' || e.k === 'opbrake') && (!st || e.t >= st.t)).at(-1); // 発進したあとに気づいた時刻
  current = { a, r, y };
  const ev = r.events.filter((e) => e.t >= t0 - 30);
  $('#acL').innerHTML = `
    <p class="eyebrow">${dateOf(a.day)} ${timeOf(a.pass)}　T字路の横断歩道</p>
    <h2 style="margin:0;font-size:26px">事故の30秒</h2>
    <div id="facts">
      <div class="fact"><span>ぶつかったときの速さ</span><b>${hit.kmh}</b><i>km/時</i></div>
      <div class="fact"><span>危ないと気づいたのは</span>${sensed ? `<b>${(t0 - sensed.t).toFixed(1)}</b><i>秒前</i>` : '<b style="font-size:18px">気づけなかった</b>'}</div>
      <div class="fact"><span>歩行者</span><b style="font-size:18px">${(E.PED_LABEL[a.facts.pedType] || '').replace('人', '')}${a.facts.phone ? '・スマホを見ていた' : ''}</b></div>
    </div>
    <div style="display:flex;flex-direction:column;gap:8px" id="evs">
      ${ev.map((e, i) => `<button class="ev" data-t="${e.t}"><b>${e.t - t0 === 0 ? '0秒' : `−${(t0 - e.t).toFixed(1)}秒`}</b><span>${e.text}</span></button>`).join('')}
    </div>
    <p class="note">記録を押すと、その時刻の交差点に切り替わります。実際の事故の流れを参考にした、架空の事故です</p>
    <div class="foot"><button class="link" id="backRes">← 結果に戻る</button><button class="cta" id="toAssign">責任の割合を考える <span aria-hidden="true">→</span></button></div>`;
  show('accident');
  if (!acStageReady) { scene.moveTo($('#acR')); acStageReady = true; } else scene.moveTo($('#acR'));
  const seek = (t) => { const f = r.frames[Math.min(r.frames.length - 1, Math.ceil(t / 0.5))]; scene.setFrame(f, t >= t0 ? { red: { x: hit.x, z: hit.z } } : {}); };
  $('#evs').addEventListener('click', (e) => { const b = e.target.closest('.ev'); if (!b) return; $('#evs').querySelectorAll('.ev').forEach((x) => x.classList.toggle('on', x === b)); seek(+b.dataset.t); });
  const last = $('#evs').lastElementChild; last && last.click();
  $('#backRes').addEventListener('click', () => { scene.moveTo($('#stage')); show('result'); });
  $('#toAssign').addEventListener('click', openAssign);
}

// ---- ⑤ 責任の割合を考える ----
let alloc = null;
// ひやり・事故の原因と、かかわる人を、記録から組み立てる（走っている間のパネルと、責任を配る画面で同じものを使う）
// 運行の形ごとの、見ている人の呼び名
const WATCHER = (c) => ({ l2: '運転士', l4in: '車内の主任者', l4r1: '遠隔監視者', l4r3: '遠隔監視者' })[c.mode] || '運転士';
const IS_L4 = (c) => c.mode !== 'l2';
// ひやり・事故の説明を、人／企業／決まり・行政の3段と「まだ決まっていないこと」に組み立てる
// 決まりは「関係しそうな決まり」の名前だけを示し、法律上の答えは出さない
function explain(f, c, kind) {
  const people = [], company = [], rules = [], opens = [];
  const add = (arr, who, text) => { if (!arr.some((x) => x.text === text)) arr.push({ who, text }); };
  const ped = E.PED_LABEL[f.pedType] || '歩行者', W = WATCHER(c), me = '運行会社（あなた）';
  if (f.state === 'approach') add(people, '歩行者', `交差点に近づくバスの前に、${ped}が車道へ入ってきた`);
  else if (f.startedBy === 'human') {
    if (f.missed) add(people, W, 'この人を見落としたまま、発進させた');
    else if (c.guide && f.trustGuide) { add(people, W, '「誘導員が歩行者を止めてくれる」と読んで、早めに発進させた'); opens.push('誘導員の合図に、運転する側がどこまで頼ってよいか（決まりがない）'); }
    else add(people, W, '発進させたあとに、この人が横断歩道へ入ってきた。発進の判断そのものが問われる');
  } else {
    if (f.hedge && c.route === 'short' && c.sensor === 'normal') add(company, 'メーカー', '植え込みの陰が、バスのセンサーの死角になっていた');
    else if (c.sensor === 'normal') add(company, 'メーカー', 'バスは、横断歩道に向かってくる人を先読みしないまま、自分で発進した');
    else add(people, ped, 'バスが発進したあとに、この人が横断歩道へ入ってきた');
    if (f.missed) add(people, W, c.mode === 'l4in' ? '車内で見ていたが、この人を見落とした' : '映像でこの人を見落とした');
    if (c.mode === 'l4r1' || c.mode === 'l4r3') add(people, W, `映像で気づいて止める指示を出すまでに、時間がかかった${c.mode === 'l4r3' ? '（1人で3台を見ていた）' : ''}`);
  }
  if (f.state !== 'approach' && c.guide && f.guideRaised && !f.guideClear) add(people, '誘導員', '合図が、バスと歩行者のどちらに向けたものか、あいまいだった');
  if (f.phone) add(people, ped, 'スマホを見ていて、バスに気づくのが遅れた');
  if (f.pedType === 'hurry') add(people, ped, '急いでいて、バスのすぐそばに来るまで止まらなかった');
  if (f.pedType === 'diagonal') add(people, ped, '横断歩道の外を斜めに渡っていた');
  if (f.pedType === 'hesitate') add(people, ped, '端で迷ったあと、急に渡りはじめた');
  if (f.evening) add(company, 'メーカー', '夕方の逆光で、センサーの見える距離が短くなっていた');
  // 運行会社（見る人）の判断
  if (!c.rest && f.missed) add(company, me, `${W}を休憩なしで働かせていて、見落としやすくなっていた`);
  if (c.mode === 'l4r3') add(company, me, '遠隔監視者1人に3台を見させていた');
  if (c.speed >= 15) add(company, me, '交差点の速さを時速15kmにしていて、止まりきるまでの距離が長かった');
  if (!c.guide && f.state !== 'approach') add(company, me, '交差点に誘導員を置いていなかった');
  if (c.sensor === 'normal' && IS_L4(c) && f.state !== 'approach') add(company, me, '死角の少ないセンサーを入れていなかった');
  if (f.hedge && c.route === 'short') { add(company, '道の管理者', '高い植え込みが、交差点の見通しを悪くしていた'); add(company, me, '植え込みを刈るよう、道の管理者に頼んでいなかった'); }
  // 決まり・行政（関係しそうな決まりの名前だけ）
  if (c.mode === 'l2') { add(rules, '道路交通法', 'レベル2では運転の主体は運転士。運転士の安全確認の義務が中心になる'); opens.push('システムに任せて見ているだけの運転士に、どこまでの注意を求めるか'); }
  else { add(rules, '道路交通法（特定自動運行）', 'レベル4は公安委員会の許可を受けた運行。運行する会社と主任者に、決められた義務がある'); opens.push('レベル4の事故で、誰が刑事責任を負うか'); }
  add(rules, '自動車損害賠償保障法', 'けがをした人への賠償は、運送する会社（運行供用者）が負う、という整理が進んでいる');
  if (company.some((x) => x.who === 'メーカー')) { add(rules, '製造物責任法', 'センサーやソフトの作りに欠陥があればメーカーが問われ得る'); opens.push('ソフトウェアの欠陥を、製造物の欠陥として問えるか（日本では未整理）'); }
  if (company.some((x) => x.who === '道の管理者')) add(rules, '国家賠償法', '道の管理に問題があれば、道を管理する役所が問われ得る');
  if (c.mode === 'l4r3' || (c.mode === 'l4r1' && f.missed)) opens.unshift('遠隔監視者1人が何台まで見てよいか（基準なし）');
  if (people.some((x) => x.who === ped)) add(rules, '民事の過失', '歩行者の不注意は、賠償の割合を減らす事情として見られることがある');
  if (kind === 'hit') add(rules, '事故の報告', '運行する会社は、事故を警察に報告する。事故を調べる国の仕組みは、権限を強める方向で検討中');
  const R = E.ROUTES[f.route];
  const what = kind === 'hit' ? `${R.label}するバスが、${ped}と接触した（時速${f.kmh ?? '?'}km）` : `${R.label}するバスに、${ped}が${f.dist < 0.1 ? 'ほとんど触れるほど' : f.dist.toFixed(1) + 'm まで'}近づいた（バスは時速${f.kmh}km）`;
  const who = [...new Set([...people, ...company].map((x) => x.who))];
  return { what, people, company, rules, open: opens[0] || '', who, causes: [...people, ...company].map((x) => x.text) };
}
function clues() {
  // 責任の割合を考える相手と、その手がかり（説明の3段と同じ記録から作る）
  const { a, y } = current, f = a.facts, c = y.cfg, ex = explain(f, c, 'hit'), W = WATCHER(c);
  const of = (nm, fallback) => { const t = [...ex.people, ...ex.company].filter((x) => x.who === nm || (nm === '歩行者' && x.who === (E.PED_LABEL[f.pedType] || '歩行者'))).map((x) => x.text); return t.length ? t.join('。') : fallback; };
  return [
    { k: 'maker', nm: 'メーカー', cl: of('メーカー', c.sensor === 'wide' ? '死角の少ないセンサーを入れていた' : '目立った問題は記録に残っていない') },
    { k: 'op', nm: '運行会社（あなた）', me: true, cl: of('運行会社（あなた）', '') + '（あなたが決めた：' + [label('mode', c.mode), `時速${c.speed}km`, c.guide ? '誘導員あり' : '誘導員なし', c.route === 'short' ? '植え込みはそのまま' : '植え込みを刈ってもらう', c.rest ? 'こまめに休憩' : '休憩なし'].join('・') + '）' },
    { k: 'driver', nm: W, cl: of(W, c.mode === 'l2' ? '発進させ、運転を見ていた' : '見ていたが、記録に残る見落としはない') },
    { k: 'guide', nm: '誘導員', cl: c.guide ? of('誘導員', '「止まれ」の合図ははっきり出ていた') : 'この1年は置いていない', off: !c.guide },
    { k: 'road', nm: '道の管理者', cl: c.route === 'short' ? of('道の管理者', '交差点の植え込みが高く、見通しを悪くしていた') + '（運行会社から刈るよう頼まれてはいない）' : '頼まれて、植え込みを低く刈っていた' },
    { k: 'ped', nm: '歩行者', cl: of('歩行者', '前を見て歩いていた') },
  ];
}
function openAssign() {
  const ps = clues(); const n = ps.filter((p) => !p.off).length;
  alloc = Object.fromEntries(ps.map((p) => [p.k, p.off ? 0 : Math.round(100 / n)])); fix(ps[0].k);
  const draw = () => ps.map((p) => `<div class="party ${p.me ? 'me' : ''}"><span class="nm">${p.nm}</span><span class="cl">${p.cl}</span><input type="range" min="0" max="100" step="1" value="${alloc[p.k]}" data-k="${p.k}" aria-label="${p.nm}の責任" ${p.off ? 'disabled' : ''}><span class="v"><span id="v-${p.k}">${alloc[p.k]}</span><small style="font-size:13px;font-weight:400">%</small></span></div>`).join('');
  $('#assign').innerHTML = `<p class="eyebrow">${dateOf(current.a.day)} ${timeOf(current.a.pass)}　T字路の横断歩道</p><h2>この事故、誰にどれだけ責任がある？</h2><p class="note">合計がいつも100%になるよう、ほかが自動で動きます</p><div style="display:flex;flex-direction:column;gap:10px" id="parties">${draw()}</div>
  <div class="foot"><button class="link" id="backAc">← 事故の30秒に戻る</button><button class="cta" id="toCompare">決めて、比べる <span aria-hidden="true">→</span></button></div>`;
  show('assign');
  $('#parties').addEventListener('input', (e) => { const k = e.target.dataset.k; alloc[k] = +e.target.value; fix(k); ps.forEach((p) => { $('#v-' + p.k).textContent = alloc[p.k]; $('#parties').querySelector(`input[data-k="${p.k}"]`).value = alloc[p.k]; }); });
  $('#backAc').addEventListener('click', () => show('accident'));
  $('#toCompare').addEventListener('click', () => openCompare(ps));
  function fix(k) {
    const others = ps.filter((p) => p.k !== k && !p.off).map((p) => p.k); const rest = 100 - alloc[k]; const sum = others.reduce((s, x) => s + alloc[x], 0);
    others.forEach((x) => { alloc[x] = sum ? Math.round(alloc[x] / sum * rest) : Math.round(rest / others.length); });
    const drift = 100 - Object.values(alloc).reduce((s, v) => s + v, 0); if (others[0]) alloc[others[0]] += drift;
  }
}

// ---- ⑥ 比べる ----
function openCompare(ps) {
  const top = ps.reduce((m, p) => (alloc[p.k] > alloc[m.k] ? p : m), ps[0]);
  $('#compare').innerHTML = `<p class="eyebrow">あなたの考えた割合</p><h2>あなたは「${top.nm}」の責任を一番重く見た</h2>
  <div style="display:flex;flex-direction:column;gap:10px">${ps.map((p) => `<div class="row" style="grid-template-columns:180px minmax(0,1fr) 90px"><span class="k">${p.nm}</span><div class="bars"><div class="bar" style="width:${alloc[p.k]}%"></div></div><span class="n" style="font-size:24px;text-align:right">${alloc[p.k]}<small>%</small></span></div>`).join('')}</div>
  <p class="note">ほかの人の割合と並べる部分は、答えを集める仕組みができてから入ります（試作 v0 では答えを送りません）。法律上の正解を示すものではありません</p>
  <div class="foot"><button class="link" id="otherAc">ほかの事故をひらく</button><button class="cta" id="again2">仕組みを変えて、もう1年回す <span aria-hidden="true">→</span></button></div>`;
  show('compare');
  $('#otherAc').addEventListener('click', () => { scene.moveTo($('#stage')); show('result'); });
  $('#again2').addEventListener('click', () => { scene.moveTo($('#stage')); show('play'); setPlayMode('setup'); });
}
drawPanel(); setPlayMode('setup'); setPlayKind('scene');
window.__ready = true;
}
</script>
</body>
</html>
```

### build.py（three.js と engine.js を app.html に入れる）

```python
import pathlib
d=pathlib.Path('/home/claude/sim'); s=(d/'app.html').read_text()
three=pathlib.Path('/home/claude/render/node_modules/three/build/three.module.min.js').read_text()
eng=(d/'engine.js').read_text()
for t in (three,eng): assert '</script' not in t
s=s.replace('%%THREE%%',three).replace('%%ENGINE%%',eng)
(d/'dist.html').write_text(s); print(len(s))
```

### tdir.mjs（場面×バスの向き×運行の形の結果を並べる）

```javascript
import * as E from '/home/claude/sim/engine.js';
for (const sc of E.SCENES) { const row=[];
  for (const d of ['wl','er','nl','nr']) { const out=[];
    for (const mode of ['l2','l4in','l4r1','l4r3']) { const cfg={...E.DEFAULTS,mode,dir:d,...(sc.requires||{})};
      const r=E.simulatePass(cfg,E.rng(42),{record:true,scene:E.sceneFor(sc,d,cfg)}); out.push(r.hit?'X':r.near?'n':'.'); }
    row.push(d+':'+out.join('')); }
  console.log(sc.id.padEnd(9), row.join('  ')); }
```

#### tdir.mjs の出力（ずらす前。もとの向き以外はほとんど何も起きなかった）

```text
miss      wl:X.XX  er:....  nl:.n..  nr:....
guide     wl:nnnn  er:nnnn  nl:....  nr:....
right     wl:.nnn  er:nnnn  nl:....  nr:....
exit      wl:....  er:....  nl:.nnn  nr:.nnn
diagonal  wl:nn..  er:nnnn  nl:....  nr:....
```

### tsweep.mjs（向きごとに、ずらす秒数と渡る側を総当たりで選ぶ）

```javascript
import * as E from '/home/claude/sim/engine.js';
const combos=[];for(const mode of ['l2','l4in','l4r1','l4r3'])for(const rest of [true,false])for(const sensor of ['normal','wide'])for(const speed of [10,15])combos.push({mode,rest,sensor,speed});
const run=(sc,d,extra,c,fl)=>{const cfg={...E.DEFAULTS,...c,dir:d,...(sc.requires||{})};const s=E.sceneFor(sc,d,cfg);const s2={...s,peds:s.peds.map(p=>({...p,arrive:Math.max(1,p.arrive+extra),...(fl?{fromEast:!p.fromEast}:{})}))};const r=E.simulatePass(cfg,E.rng(42),{record:true,scene:s2});return r.hit?2:r.near?1:0;};
const res={};
for(const sc of E.SCENES){res[sc.id]={};const ref=combos.map(c=>run(sc,sc.route,0,c));
 for(const d of ['wl','er','nl','nr']){ if(d===sc.route){res[sc.id][d]=0;continue;}
  let best=null;for(const fl of [false,true])for(let x=-12;x<=12;x+=0.25){const v=combos.map(c=>run(sc,d,x,c,fl));const score=v.reduce((a,b,i)=>a+(b===ref[i]?1:0)+(b>0?0.3:0),0)+ (new Set(v).size>1?2:0)-Math.abs(x)*0.05;if(!best||score>best.s)best={s:score,x,fl,v:v.join("")};}
  res[sc.id][d]=[best.x,best.fl];console.log(sc.id,d,best.x,best.fl,best.v,'ref',ref.join(''));}}
console.log(JSON.stringify(res));
```

#### tsweep.mjs の出力（0＝何も起きない・1＝ひやり・2＝事故。32通りの並び。ref はもとの向き）

```text
miss er 0.75 false 10001000100010001000100010001000 ref 20002000010020002000200020002000
miss nl 1 true 10001000100010001000100010001000 ref 20002000010020002000200020002000
miss nr 1 true 10001000100010001000100010001000 ref 20002000010020002000200020002000
guide er 0 false 10001000100010001000100010001000 ref 10001000100010001000100010001000
guide nl -0.25 true 10001000100010001000100010001000 ref 10001000100010001000100010001000
guide nr 0 true 10001000100010001000100010001000 ref 10001000100010001000100010001000
right wl 0 false 00000000100010001000100010001000 ref 10001000100010001000100010001000
right nl -0.25 true 00000000100010001000100010001000 ref 10001000100010001000100010001000
right nr 0 true 00000000100010001000100010001000 ref 10001000100010001000100010001000
exit wl 0 true 00000000100010001000100010001000 ref 00000000100010001000100010001000
exit er 0 true 00000000100010001000100010001000 ref 00000000100010001000100010001000
exit nr 0 false 00000000100010001000100010001000 ref 00000000100010001000100010001000
diagonal er 0 false 10001000100010001000100010001000 ref 10101010101010100000000000000000
diagonal nl 0 false 00000000000000000000000000000000 ref 10101010101010100000000000000000
diagonal nr 0 false 00000000000000000000000000000000 ref 10101010101010100000000000000000
{"miss":{"wl":0,"er":[0.75,false],"nl":[1,true],"nr":[1,true]},"guide":{"wl":0,"er":[0,false],"nl":[-0.25,true],"nr":[0,true]},"right":{"wl":[0,false],"er":0,"nl":[-0.25,true],"nr":[0,true]},"exit":{"wl":[0,true],"er":[0,true],"nl":0,"nr":[0,false]},"diagonal":{"wl":0,"er":[0,false],"nl":[0,false],"nr":[0,false]}}
```

### check14.py（自動再生を流して、向き・植え込み・誘導員の絵を確かめる）

```python
import subprocess, time, sys
from playwright.sync_api import sync_playwright
srv = subprocess.Popen([sys.executable, '-m', 'http.server', '8766'], cwd='/home/claude/sim', stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
time.sleep(1); errs=[]
try:
    with sync_playwright() as p:
        b = p.chromium.launch(executable_path='/usr/bin/google-chrome', args=['--use-gl=angle', '--use-angle=swiftshader', '--enable-unsafe-swiftshader'])
        pg = b.new_page(viewport={'width': 1280, 'height': 900})
        pg.on('pageerror', lambda e: errs.append(str(e)))
        pg.goto('http://localhost:8766/dist.html'); pg.wait_for_function('window.__ready === true', timeout=60000)
        pg.click('.sc[data-id="diagonal"]'); time.sleep(0.3); pg.screenshot(path='c14_diag.png', clip={'x':900,'y':0,'width':380,'height':900})
        pg.click('.sc[data-id="exit"]'); time.sleep(0.3)
        pg.click('#autoRun'); time.sleep(1); pg.click('#sceneSpeeds button[data-r="4"]')
        k=0
        while not pg.query_selector('#sceneCmp.on') and k<80:
            time.sleep(2.5); pg.screenshot(path=f'c14_{k:02d}.png'); k+=1
        print(pg.inner_text('table.auto'))
        b.close()
finally: srv.terminate()
print(errs)
```

#### check14.py の出力（場面「脇道から出るバスの前へ」の自動再生の一覧）

```text
変えたこと	結果	かかわる人（何も起きなければ止まれた理由）	まだ決まっていないこと
＋いまの設定	何も起きなかった	人が渡り終えるまでバスが待ったか、人がバスに気づいて待った	
＋バスの来る向きを「西から来て左折」に	何も起きなかった	人が渡り終えるまでバスが待ったか、人がバスに気づいて待った	
＋バスの来る向きを「東から来て右折」に	何も起きなかった	人が渡り終えるまでバスが待ったか、人がバスに気づいて待った	
＋バスの来る向きを「脇道から出て右折」に	何も起きなかった	人が渡り終えるまでバスが待ったか、人がバスに気づいて待った	
＋運行の形を「レベル4・車内に主任者」に	ひやり	誘導員ふつうに渡る人メーカー運行会社（あなた）	レベル4の事故で、誰が刑事責任を負うか
＋運行の形を「レベル4・遠隔監視1台」に	ひやり	遠隔監視者誘導員ふつうに渡る人メーカー運行会社（あなた）	レベル4の事故で、誰が刑事責任を負うか
＋運行の形を「レベル4・遠隔監視3台」に	ひやり	遠隔監視者誘導員ふつうに渡る人メーカー運行会社（あなた）	遠隔監視者1人が何台まで見てよいか（基準なし）
＋センサーを「死角の少ないもの」に	何も起きなかった	人が渡り終えるまでバスが待ったか、人がバスに気づいて待った	
＋交差点での速さを「6 km/時」に	何も起きなかった	運転士が人に気づいて止めた	
＋交差点での速さを「15 km/時」に	何も起きなかった	運転士が人に気づいて止めた	
＋交差点に誘導員を「置かない」に	何も起きなかった	人が渡り終えるまでバスが待ったか、人がバスに気づいて待った	
＋交差点の植え込みを「低く刈ってもらう」に	何も起きなかった	人が渡り終えるまでバスが待ったか、人がバスに気づいて待った	
＋運転士の休憩を「なしで回す」に	何も起きなかった	人が渡り終えるまでバスが待ったか、人がバスに気づいて待った	
[]
```

### data538.py（場面3つ×運行の形4つを再生し、右のパネルの文を書き出す）

```python
import subprocess, time, sys, json
from playwright.sync_api import sync_playwright
srv = subprocess.Popen([sys.executable, '-m', 'http.server', '8769'], cwd='/home/claude/sim', stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
time.sleep(1); out={}
try:
    with sync_playwright() as p:
        b = p.chromium.launch(executable_path='/usr/bin/google-chrome', args=['--use-gl=angle', '--use-angle=swiftshader', '--enable-unsafe-swiftshader'])
        pg = b.new_page(viewport={'width': 1200, 'height': 800})
        pg.goto('http://localhost:8769/dist.html'); pg.wait_for_function('window.__ready === true', timeout=60000)
        for sc in ['miss','right','exit']:
            for m in range(4):
                pg.click(f'.sc[data-id="{sc}"]'); pg.click(f'button[data-k="mode"][data-i="{m}"]'); time.sleep(.2)
                pg.click('#run'); time.sleep(.5); pg.click('#sceneSpeeds button[data-r="4"]')
                pg.wait_for_selector('#sReplay', timeout=200000); time.sleep(.3)
                out[f'{sc}_{m}'] = pg.inner_text('#incident')
                pg.click('#sAgain'); time.sleep(.3)
        b.close()
finally: srv.terminate()
json.dump(out, open('/home/claude/art538/scene_mode_cards.json','w'), ensure_ascii=False, indent=1)
print(len(out))
```

### card538.py と card.html の作り方（シリーズの一覧のカードの絵を、自由なカメラで撮る）

card.html は app.html に2か所だけ足して作りました。3Dの戻り値に、カメラを好きな位置・向き・画角に置く `__free` を足し、`window.__scene` に3Dを出しています。カメラをこの形にしている間は、画面の大きさが変わってもカメラを戻さないようにしました（placeCam の最初の行）。

```python
import pathlib
d=pathlib.Path('/home/claude/sim'); s=(d/'app.html').read_text()
s=s.replace("return { setView, setFrame, setRoute,","return { __free: (p, t, fov) => { mode = 'free'; cam.fov = fov; cam.position.set(...p); cam.lookAt(...t); cam.updateProjectionMatrix(); }, setView, setFrame, setRoute,",1)
s=s.replace("scene.setFrame({ bus: { ...E.busPose(49), v: 0 }, peds: [], guide: false });","scene.setFrame({ bus: { ...E.busPose(49), v: 0 }, peds: [], guide: false });\nwindow.__scene = scene;",1)
s=s.replace("if (mode === 'follow') return;","if (mode === 'follow' || mode === 'free') return;",1)
three=pathlib.Path('/home/claude/render/node_modules/three/build/three.module.min.js').read_text()
s=s.replace('%%THREE%%',three).replace('%%ENGINE%%',(d/'engine.js').read_text())
(d/'card.html').write_text(s)
```

```python
import subprocess, time, sys, json
from playwright.sync_api import sync_playwright
srv = subprocess.Popen([sys.executable, '-m', 'http.server', '8770'], cwd='/home/claude/sim', stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
time.sleep(1); O='/home/claude/art538/card/'
HIDE='#panel,#top,#views,#callout,#clock,#stats,#intro,#sceneSpeeds{display:none!important}#stage{position:fixed!important;inset:0!important;width:100vw!important;height:100vh!important}'
CAMS = json.loads(sys.argv[1])
try:
    with sync_playwright() as p:
        b = p.chromium.launch(executable_path='/usr/bin/google-chrome', args=['--use-gl=angle', '--use-angle=swiftshader', '--enable-unsafe-swiftshader'])
        pg = b.new_page(viewport={'width': 1800, 'height': 1200})
        pg.goto('http://localhost:8770/card.html'); pg.wait_for_function('window.__ready === true', timeout=60000)
        pg.click('.sc[data-id="miss"]'); pg.click('button[data-k="mode"][data-i="3"]'); time.sleep(.2)
        pg.click('#run'); time.sleep(.3)
        pg.add_style_tag(content=HIDE); pg.evaluate('dispatchEvent(new Event("resize"))')
        pg.wait_for_function("document.getElementById('callout').style.display==='block'", timeout=200000)
        pg.evaluate("document.querySelectorAll('#sceneSpeeds button')[0].click()")
        time.sleep(1.2)
        # 再生を止める（ボタンが隠れているので、replay を止める手段がない場合は、そのまま撮る）
        for name, c in CAMS.items():
            pg.evaluate(f"window.__scene.__free({c['p']}, {c['t']}, {c['f']})"); time.sleep(.5)
            pg.screenshot(path=O+name+'.png')
        b.close()
finally: srv.terminate()
```

撮った位置（カードに使ったのは hedge2）：

```text
hedge  : 位置 (13, 1.1, -1.2)  向ける先 (-1, 1.0, -5)    画角 30
worm   : 位置 (1.2, 0.35, -9.5) 向ける先 (-2, 1.4, -3)    画角 55
tele   : 位置 (-40, 120, -20)  向ける先 (-1, 0, -4.5)    画角 7
bus_eye: 位置 (-6, 2.6, -0.5)  向ける先 (1, 0.6, -5.5)   画角 40
hedge2 : 位置 (17, 0.9, -0.4)  向ける先 (-2, 1.3, -5.5)  画角 24
hedge3 : 位置 (11, 0.6, -2.0)  向ける先 (-1, 1.6, -6)    画角 36
hedge4 : 位置 (15, 1.6, 1.5)   向ける先 (-2, 0.8, -6)    画角 26
```

### make.py（このシリーズの記事サムネイル）

```python
"""フィジカルAIの社会実装シミュレーション（/series9）の記事サムネイルを作る（2026-11-20・LOG538 から）。
ブラウザで動かすシミュレーション（three.js）の3Dだけを撮ったコマを主役にする。文字は入れない。
地は TOP のカードと同じ明るい灰色（#eceef2）。three.js の背景（#eceef1）はほぼ同じ色なので置き換えない。

素材は Playwright で 1920×1080 に撮った3Dのコマ（パネル・ボタン・吹き出しを隠したもの）。
置き場所は iCloud の「フィジカルAIの社会実装シミュレーション/thumb_data/」。Mac 連携で写してから動かす。
  SRC=<素材のフォルダ>/ python3 make.py [LOG番号 ...]   # out/LOG{N}.png（1920×1080）と、public/thumbs/ の webp・HTML
並べ方は回ごとに変え、一覧で同じ形が続かないようにする。
"""
import os, sys
from PIL import Image

D = os.environ.get('SRC', '/mnt/user-data/uploads/PixelstoMotors/デジタルツイン学習R2R2R/フィジカルAIの社会実装シミュレーション/thumb_data/')
W, H, G = 1920, 1080, 14
LIGHT = (236, 238, 242)
HERE = os.path.dirname(os.path.abspath(__file__))
SITE = os.path.dirname(os.path.dirname(HERE))
os.makedirs(f'{HERE}/out', exist_ok=True)
HTML = '''<!DOCTYPE html>
<!-- フィジカルAIの社会実装シミュレーションのサムネイル。画像は tools/social_sim_thumbs/make.py で作る（2026-11-20） -->
<html lang="ja"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0">
<style>*{{margin:0;padding:0}}html,body{{background:#eceef2;height:100%;overflow:hidden}}img{{display:block;width:100%;height:100%;object-fit:cover}}</style>
</head><body><img src="img/LOG{n}.webp" alt=""></body></html>
'''


def part(spec, w, h):
    """spec = (素材名, 中心x, 中心y, 切り出す幅の割合)。中心は 0〜1"""
    name, fx, fy, z = spec
    im = Image.open(D + name + '.png').convert('RGB')
    cw = im.width * z; ch = cw * h / w
    x0 = min(max(0, im.width * fx - cw / 2), im.width - cw); y0 = min(max(0, im.height * fy - ch / 2), im.height - ch)
    return im.crop((int(x0), int(y0), int(x0 + cw), int(y0 + ch))).resize((w, h), Image.LANCZOS)


def mosaic(n, big, a, b, r=.6):
    """左に大1・右に小2"""
    out = Image.new('RGB', (W, H), LIGHT)
    bw = int((W - G) * r); sw = W - G - bw; sh = (H - G) // 2
    out.paste(part(big, bw, H), (0, 0))
    out.paste(part(a, sw, sh), (bw + G, 0))
    out.paste(part(b, sw, H - G - sh), (bw + G, sh + G))
    save(n, out)


def save(n, out):
    out.save(f'{HERE}/out/LOG{n}.png')
    os.makedirs(f'{SITE}/public/thumbs/img', exist_ok=True)
    out.save(f'{SITE}/public/thumbs/img/LOG{n}.webp', quality=86)
    open(f'{SITE}/public/thumbs/LOG{n}.html', 'w').write(HTML.format(n=n))


JOBS = {
    # 自動運転バス×T字路の試作を作った回。左＝西から来て左折するバスが、スマホを見て渡る人と接触した所（斜め上・遠隔監視3台）、
    # 右上＝東から来て右折するバスの前の人（真上）、右下＝斜めに渡る人をバスの後ろから見た所
    538: lambda n: mosaic(n, ('miss_iso', .49, .43, .48), ('right_top', .5, .37, .5), ('diag_follow', .6, .62, .6), r=.6),
}

if __name__ == '__main__':
    for n in [int(x) for x in sys.argv[1:]] or list(JOBS):
        JOBS[n](n); print(n)
```

### 調査メモ：自動運転バス・ロボタクシーの現状と事故の責任

```markdown
# 調査メモ：自動運転バス・ロボタクシーの現状と事故の責任（2026-11-20）

作成：Claude（Research の調査結果を要約）　用途：シミュレーション「事故が起きたら誰の責任？」の場面と「人・企業・決まり・行政」の整理
状態：**Codex の事実確認済み（2026-11-20）**。判定の詳細は `codex_report_av_liability_20261120.md`。下の「事実確認で直したこと」を優先する

番号つきの文（C01〜）は、事実確認の対象。出典は各項目の末尾。

---

## 1. レベルと運行形態

- C01 日本のレベル4は道路交通法の「特定自動運行」で、都道府県公安委員会の許可制（2023年4月施行）。許可なく行うと5年以下の拘禁刑または100万円以下の罰金。（警察庁 https://www.npa.go.jp/bureau/traffic/selfdriving/L4-summary.pdf ／長崎県警 https://www.police.pref.nagasaki.jp/police/shinsei/tokuteiseido/）
- C02 特定自動運行主任者は、遠隔監視室または車内で装置の作動状態を確かめ、事故時に消防への通報・現場措置業務実施者の派遣・警察への報告を行う。主任者を車内に置く形もできる。（警察庁 同上）
- C03 永平寺町は「1人の遠隔監視者が3台を運行可能なレベル4の自動運行装置の認可」を国内で初めて取得した。（RoAD to the L4「自動運転移動サービス社会実装・事業化の手引き」第2版）
- C04 総務省の2025年度実証（横浜など）で「監視員1人：自動運転バス2台」を検証。日立市の報告（2025年1月）は1対1から複数台監視へ移るためのアラート通知を検証。（総務省 https://www.soumu.go.jp/main_content/001043471.pdf ほか）
- C05 国交省は2026年6月8日、「レベル4のバス等が11箇所で実装、特定自動運行の許可は12件」と示した。デジタル庁「モビリティ・ロードマップ2026」も2026年5月時点で延べ12件。
- C06 政府目標は「地域限定型の無人自動運転移動サービスを2025年度目途に50か所程度、2027年度までに100か所以上」（デジタル田園都市国家構想総合戦略、2022年12月閣議決定）。

## 2. 日本の運行事例

- C07 永平寺町：2023年5月に国内初のレベル4（遠隔監視のみ）。ヤマハ系の電動カート、電磁誘導線、時速約12km、約2km。（国交省白書 2024）
- C08 柏の葉：2025年8月29日に関東運輸局が車両認可、2025年11月12日に千葉県公安委員会が特定自動運行を許可、2025年12月9日に千葉運輸支局が事業計画の変更を認可、2026年1月13日に運行開始。中型バス（いすゞエルガミオを先進モビリティが改造）、最高時速40km、レベル4区間は約700m、運転席に乗務員。運行は東武バスセントラル。（経産省 https://www.meti.go.jp/press/2025/01/20260113001/20260113001.html ／柏市）
- C09 塩尻市：2025年1月にレベル4の許可（駅→市役所の往路）。2026年3月6日に往復へ拡大。ティアフォー製Minibus、レベル4時は最高時速35km。（塩尻市 https://www.city.shiojiri.lg.jp/soshiki/10/49343.html）
- C10 大阪・関西万博の舞洲P&R～夢洲（約10.5km）：約2,800便・約41,800人。乗務員乗車型のレベル4で、添乗員が主任者を兼ねた。会場内e Moverは約7,300便・約40,400人。（大阪府 https://www.pref.osaka.lg.jp/documents/118923/04_siryo3.pdf）
- C11 茨城県日立市（ひたちBRT）：2025年2月からレベル4の営業運行（茨城県公安委員会の許可は2024年12月）。バス専用道約6.1km。
- C12 羽田イノベーションシティ：2023年10月にレベル4車両の認可（BOLDLY、ARMA）。警視庁のサイトで大田区の許可が2026年2月4日に「失効」と公示。（https://www.keishicho.metro.tokyo.lg.jp/tetsuzuki/kotsu/application/tokutei_jidou.html）

## 3. 事故・トラブル

- C13 東京パラリンピック選手村のe-Palette（2021年8月26日）：信号のないT字路を右折する場面。一時停止後、車内オペレーターと誘導員が安全を確認して発進。横断中の視覚障害のある選手と接触し、約2週間のけが。（トヨタ発表／自動運転ラボ https://jidounten-lab.com/u_33367）
- C14 同事故で警視庁は2022年1月、車内オペレーター（トヨタ社員）を過失運転致傷の疑いで書類送検した。
- C15 永平寺町の事故（2023年10月29日）：時速約12kmから6kmに減速して待避所に入る際、走路にかかって置かれた無人の自転車に接触。乗客4人にけがなし。ミリ波レーダー等は検知していたが、誤検知を抑えるためカメラの画像認識を優先する仕様で、AIの学習データ不足によりカメラが自転車を認識できなかった。遠隔監視者の停止も間に合わなかった。2024年3月16日に再開。（町の調査報告書 2023年11月10日、ITmedia https://monoist.itmedia.co.jp/mn/articles/2310/23/news064.html）
- C16 万博・舞洲（2025年4月28日）：待機場の勾配で停車時にパーキングブレーキが作動せず、約10m動いて時速約7kmで高さ約50cmの擁壁に衝突。回送中で手動運転、運転士1人、けが人なし。原因は自動運転システムがリセット信号を500kbpsで送り、車両側の250kbpsと合わず通信が詰まったこと。（Osaka Metro https://subway.osakametro.co.jp/news/news_release/20250611_park_and_ride_bus.php）
- C17 東京都・新木場ルート（レベル2）：2026年2月27日に右前輪が中央分離帯の縁石に接触。けが人なし。ルートの自動運転を中止し、3月からの都営バスの実証も延期。
- C18 石川県小松市（レベル2）：2026年5月13日に駅ロータリーで縁石に接触。データ解析で操舵の応答の遅れが判明し、当面休止。（北國新聞 https://www.hokkoku.co.jp/articles/-/2106441）
- C19 兵庫県豊岡市・城崎温泉：一般客を乗せた運行の初日、対向の大型トラックを避けようとして石垣に接触。オペレーターの手動介入なし。（MBS）
- C20 万博の舞洲ルートで、路上の雑草をセンサーが障害物と判断してブレーキがかかる事象があり、除草で対応した。（大阪府資料）
- C21 Uber（2018年3月、アリゾナ）：試験車が自転車を押して横断中の女性をはね死亡。システムは5.6秒前に検知したが分類できず、緊急自動ブレーキは無効化されていた。安全運転者は危険行為で有罪、保護観察3年（2023年7月）。Uberは不起訴。
- C22 Cruise（2023年10月2日、サンフランシスコ）：人の運転する車にはねられた歩行者を、無人車が路肩へ寄ろうとして約20フィート引きずった。カリフォルニアDMVが2023年10月24日に許可停止。事故報告から引きずりを省いたとして、NHTSAに150万ドルの民事制裁金、司法省との起訴猶予合意で刑事罰金50万ドル、CPUCに11.25万ドル。
- C23 Waymo：2025年8月20日のソフト更新後、停車中のスクールバスを追い越す事例。2025年12月に3,067台をリコール。再発のため、NHTSAが2026年11月6日に2,895台を対象にリコールクエリ（RQ26006）を開始。（https://www.technology.org/2026/11/10/waymo-robotaxis-school-bus-nhtsa-recall-query-2895-vehicles/）
- C24 Tesla（2019年の事故、2025年8月1日評決）：連邦陪審がTeslaの責任を33%と認定し、懲罰的賠償2億ドルを含む約2.43億ドルの支払いを命令。2026年2月20日に判事が再審請求を退けた。（CNBC https://www.cnbc.com/2026/02/20/tesla-loses-bid-toss-243-million-verdict-fatal-autopilot-crash-suit.html）
- C25 百度 Apollo Go（2026年3月31日、武漢）：100台超が路上で一斉停止。中国当局は新規の自動運転許可の発行を停止（2026年4月）。（https://www.automotiveworld.com/news/china-suspends-new-av-permits-after-baidus-mass-outage/）
- C26 百度（2025年8月、重慶）：工事中の穴に転落、乗客は無事。

## 4. 法律・制度

- C27 国交省「ロボットタクシー導入等に向けた自動運転における自賠法上の損害賠償責任に関する検討会」報告書（2025年4月30日）：運行供用者は旅客運送事業者などの運送主体。特定自動運行の受託事業者は原則として運行供用者に当たらない。乗客は当たらない。遠隔監視者は原則「運転者」ではないが、停止指示を送るべきときに送らず事故の直接原因になれば「運転者」と評価される余地がある。通信遮断などで安全に走れないシステムは「構造上の欠陥又は機能の障害」とされる可能性がある。（https://www.mlit.go.jp/report/press/jidosha01_hh_000066.html）
- C28 同報告書は、日本のPL法がソフトウェアに及ぶかどうかの結論を示していない。EUの改正製造物責任指令（2024年12月8日発効）がソフトを対象に含めたことに触れている。
- C29 デジタル庁のサブワーキンググループ報告書（2024年5月31日）は、レベル4では道路交通法上の「運転者」がいなくなると整理。報道によれば刑事免責の制度は設けない結論。
- C30 英国 Automated Vehicles Act 2024（2024年5月20日成立）：認可自動運転事業者（ASDE）を指定、自動運転機能の使用中は利用者責任者（user-in-charge）を運転のしかたに関する刑事責任から免責、無人の場合はNUiC運行事業者の免許制。（https://www.legislation.gov.uk/ukpga/2024/10/contents/enacted）

## 5. 行政の動き

- C31 交通政策審議会 自動運転WGの中間とりまとめ（2025年5月30日）：レベル3以上の死亡重傷事故と重大インシデントを運輸安全委員会の調査対象とする方針。
- C32 共同通信（2026年7月3日）：政府は秋の臨時国会に、運輸安全委員会に自動運転事故を調べさせる関連法の改正案を出す方針。（2026年11月20日時点で提出・成立は未確認）
- C33 警察庁「令和7年度 自動運転の拡大に向けた調査研究報告書」（2026年3月）：多数台が一斉に特定自動運行を終える事態への体制を、許可申請の段階で警察と事業者が協議することが望ましいとした。
- C34 国交省の自動運転社会実装推進事業の補助：2025年度は補助率が100%から80%に下がり、採択は前年度99件から60件程度に減った。（SOMPOインスティチュート・プラス https://www.sompo-ri.co.jp/topics_plus/20250418-18216/）
- C35 Waymo・GO・日本交通は2026年9月15日、2027年中に東京でレベル4完全無人の商用タクシーを目指すと発表。Waymoは2025年4月から都心7区で試験走行。
- C36 Uber・日産・Wayveは2026年3月12日に覚書を発表し、2026年後半までに東京でパイロット運行の準備（安全オペレーター同乗）。

---

## Research の報告にある「未確認」

e-Palette事故の送検後の処分、境町のレベル4許可、交通事故総合分析センターの役割、運輸安全委員会の法案の提出・成立、武漢の影響台数（100台超／最大約500台）、ドイツ・EUの制度の原文。

---

## 事実確認で直したこと（Codex、2026-11-20）

「ちがう」と判定された文はなし。直したのは次のとおり。「確かめられない」は、短い確認で一次資料まで届かなかったもので、誤りの証明ではない。

- C03 一部ちがう：1人で3台の装置認可（2023年3月30日）を申請・取得したのは**産総研**（町ではない）。
- C07 古い：永平寺町のレベル4は、車両・システムの保証と保守の期間が終わったため、**2026年4月1日から当面運休**。
- C14 追記：e-Palette事故の車内オペレーターは、**2022年3月4日に東京地検が不起訴**（日本交通政策研究会の研究報告による。検察の一次資料は未確認）。
- C15 一部ちがう：「カメラ優先」は単純化しすぎ。カメラで認識できず、他のセンサーが検知していても止まる判断をしない仕様だった。
- C17 古い：東京都が2026年3月30日に調査結果を公表。**手動から自動へ切り替えたとき**に右前輪が縁石に接触。
- C18 古い：小松市は5月13日の操舵の不具合（指示した角度と実際の角度のずれ）に加え、**2026年8月18日にも別の縁石接触**（運転士が危険と判断して介入したが間に合わず）。
- C21 補足：Uberのシステムは歩行者を「分類できなかった」のではなく、分類が変わり続け、歩行者と正しく分類できず進路も予測できなかった。
- C22 補足：Cruiseは事故の動画を当日NHTSAに出していたが、報告の文から引きずりを省いた（司法省）。
- C25 一部ちがう：武漢の一斉停止の台数は報道で約80〜100台／100台超と幅がある。「最大約500台」は裏付けなし。中国の新規許可停止は報道のみで、命令の範囲は未確認。
- C32 更新：その後の政府方針（国交省掲載）は、運輸安全委員会による原因究明体制を「引き続き検討し、2026年度内を目途に結論、必要に応じ速やかに法案提出」。秋の国会提出は既定事実ではない。
- 追加：万博の同じ路線で、2025年7月21日にレベル2走行中の縁石接触（近畿運輸局）。
- 追加：2026年6月の国連の会議で、一般道やレベル4を含む自動運転システムの国際基準が合意された（国交省）。
```

### Codex への事実確認の依頼文

```markdown
# 事実確認の依頼：自動運転バス・ロボタクシーの現状と事故の責任

作成：Claude（2026-11-20）　依頼者：エイイチ
対象：`research_autonomous_bus_liability_20261120.md`（同じフォルダ）の C01〜C36

---

## あなたの役割

この調査メモは、Claude の調査（Research）の結果を Claude が要約したもの。同じ書き手の確認は同じ盲点を持つ。
あなたは **「この文は間違っているか、古いか、出典が言っていないことを言っている」という前提で、その証拠を探す** 役割を担う。

- ウェブ検索で、できるだけ一次資料（官公庁・自治体・事業者の発表、法令の原文、裁判所や規制当局の資料）を当たる
- 「たぶん正しい」は書かない。正しいと判定する文には、確かめた出典の URL と、出典のどこにそう書いてあるか（見出しや段落の要約）を添える
- 日付・数字・金額・件数・人数・速度は特に厳しく確かめる
- 報告は日本語で書く。英語の原文の引用は入れない（読み手は英語が読めない）。英語の資料は日本語で要約する

---

## 判定のしかた

C01〜C36 の文ごとに、次のどれかを付ける。

- **正しい**：一次資料で確かめられた
- **一部ちがう**：どこがどう違うか、正しい値は何か
- **ちがう**：正しい内容と出典
- **確かめられない**：探した範囲と、見つからなかった理由
- **古い**：もっと新しい情報がある（その内容と日付）

そのうえで、メモの最後の「未確認」の項目も、分かる範囲で確かめる。

最後に、次の2つを書く。

1. このメモに **抜けている重要な事実**（2025〜2026年の日本の自動運転バスの事故・行政の動き・制度の変更で、シミュレーションの場面作りに効くもの）
2. 判定のまとめ表（番号・判定・一言）

---

## 守ること

- 対象メモは読むだけ。変更しない
- 書いてよいのは、このフォルダの報告 `codex_report_av_liability_20261120.md` と、`_codex_tmp_20261120/` の中の一時ファイルだけ
- git 操作をしない
```

### Codex の事実確認の結果

```markdown
# 自動運転バス・ロボタクシーの事実確認報告

確認基準日：2026年11月20日。対象は依頼書指定のC01〜C36。判定は文全体に付け、細部が確認できない場合はその旨を示す。「確かめられない」は誤りの証明ではない。公的資料・事業者発表を優先し、事故の訴追など一次資料を確認できなかった箇所は報道・研究資料と明記した。法制度の説明は個別事件の責任を決定するものではない。

## 各項目

- **C01：確かめられない。** [警察庁白書](https://www.npa.go.jp/hakusyo/r07/honbun/html/bb5545000.html)第5項は、運転者不在の限定地域の運行に許可制度が設けられ、2023年4月1日施行と説明。記載の刑罰の数字は法令本文で確認できていない。レベル4という技術分類と法令上の「特定自動運行」は厳密に同義と断定しない方がよい。
- **C02：確かめられない。** [警察庁白書](https://www.npa.go.jp/hakusyo/r07/honbun/html/bb5545000.html)は主任者を車内または車外の指定場所に配置し、事故時に必要な措置を講じると説明。消防通報・派遣・警察報告の各要件と例外を、ここでは条文に照らして個別に確認できなかった。
- **C03：一部ちがう。** [プロジェクト資料](https://www.road-to-the-l4.go.jp/publication/pdf/kakudaitf01_20231130.pdf)「許認可の状況」では、2023年3月30日の認可の申請者は**産総研**で、4台分、1人で3台運行可能。町自身が装置認可を取得したという表現は不正確。国内初の範囲はこの資料だけでは確認できない。
- **C04：確かめられない。** 提示の[総務省資料](https://www.soumu.go.jp/main_content/001043471.pdf)と日立市の2025年1月報告について、事業年度、台数、通知実験の組合せを一次資料で照合できなかった。
- **C05：正しい。** [国交省資料](https://www.mlit.go.jp/jidosha/content/002044688.pdf)「レベル４自動運転の実装実績」は11か所・許可12件とし、塩尻の2回目の許可を差の理由に挙げる。[6月8日の開催案内](https://www.mlit.go.jp/page/kanbo01_hy_010920.html)も参照。ただし延べ件数と同時点の有効許可数は異なる。デジタル庁の別資料は独立に確認できなかった。
- **C06：確かめられない。** 2022年閣議決定の原文と、両目標の対象・期限を今回照合できなかった。
- **C07：古い。** [国交省白書](https://www.mlit.go.jp/statistics/file000004/html/n1222c08.html)は2023年5月開始、約2km、時速12km、電動カートを確認。[町の案内](https://www.town.eiheiji.lg.jp/200/206/208/p010484.html)は保証・保守期間満了により2026年4月1日から当面運休と明記。ヤマハ系・電磁誘導線はこの確認では未照合。
- **C08：確かめられない。** [経産省発表](https://www.meti.go.jp/press/2025/01/20260113001/20260113001.html)「経緯・詳細」「実証内容」は2026年1月13日開始、約700m、最高40km/h、運転席乗務員、先進モビリティ改造、東武バスセントラルを確認。個々の認可日と車種名は同資料で全部確認できず、文全体を正しいとは判定しない。対象は東大関係者等向けシャトル。
- **C09：確かめられない。** [塩尻市](https://www.city.shiojiri.lg.jp/soshiki/10/61747.html)「許可を取得」は2025年1月の往路、2026年3月6日の往復許可を確認。車種と35km/hは同資料で確認できなかった。許可取得と実際の営業開始は区別する。
- **C10：確かめられない。** [大阪府掲載のOsaka Metro資料](https://www.pref.osaka.lg.jp/documents/118923/04_siryo3.pdf)「実施報告」は舞洲の約2,800便・推計約41,800人を確認。距離、主任者兼務、会場内の便数・人数は今回同じ一次資料で照合できなかった。
- **C11：確かめられない。** 日立BRTの営業開始、許可日、6.1kmの区間の対応を自治体・事業者の一次資料で確認できなかった。
- **C12：確かめられない。** [警視庁公示](https://www.keishicho.metro.tokyo.lg.jp/tetsuzuki/kotsu/application/tokutei_jidou.html)と車両認可の過去時点の記録を確認しきれず、2026年2月4日の失効の対象・理由を断定できない。車両認可と道路交通法上の許可は別手続き。
- **C13：確かめられない。** 選手村で接触・負傷した事実は[研究報告](https://www.nikkoken.or.jp/pdf/project/2021/A-850.pdf)で確認できるが、右折、一時停止、誘導員との確認、診断日数の細部をトヨタの一次発表で照合できなかった。
- **C14：確かめられない。** [時事通信の報道](https://home.kingsoft.jp/news/news/jiji/2022010600567.html)は2022年1月6日の送検、トヨタ社員、過失運転致傷容疑を伝える。警察・検察の一次公表は確認できず、判定基準に照らし報道確認にとどめる。送検は有罪を意味しない。
- **C15：一部ちがう。** [経産省委託報告書3.2.2](https://www.meti.go.jp/meti_lib/report/2023FY/000621.pdf)と[経産省資料](https://www.meti.go.jp/policy/mono_info_service/mono/automobile/jido_soko/pdf/r6dxjimukyokushiryou2.pdf)は2023年10月29日の無人自転車との接触、カメラで認識できず他のセンサーで検知しても停止判断しなかった仕様、追加学習などを経た2024年3月16日の再開を確認。「カメラ優先」とだけ書くと仕組みを単純化する。減速値や監視者の停止操作は今回未照合。元メモのITmedia記事は事故前の日付で、この事故の根拠にはならない。
- **C16：確かめられない。** [近畿運輸局](https://wwwtb.mlit.go.jp/kinki/content/000366667.pdf)は2025年4月28日、待機場で手動回送中の擁壁衝突、6月25日の自動運転再開を確認。[事業者発表](https://subway.osakametro.co.jp/news/news_release/20250611_park_and_ride_bus.php)に示された速度・通信速度等は今回独立に照合できなかった。
- **C17：古い。** [東京都の3月30日調査結果](https://www.metro.tokyo.lg.jp/information/press/2026/03/2026033029)は2月27日、新木場で手動から自動への切替時に右前輪が縁石に接触したと確定。[事故直後の発表](https://www.kouwan.metro.tokyo.lg.jp/documents/d/kouwan/20260227)は乗客2人・運転手に人的被害なし、別車両による運行を記載。都営バス実証の延期は独立に未確認。
- **C18：古い。** [小松市の9月11日更新](https://www.city.komatsu.lg.jp/soshiki/1985/rosenbasu/4/19006.html)は5月13日のレベル2接触と、指示された操舵角と実際の角度の乖離、自動運転用操舵システムの不具合を確認。8月18日にも別の縁石接触が発生しており、5月直後の「当面休止」だけでは現状を表さない。
- **C19：確かめられない。** [豊岡市11月9日資料](https://www.city.toyooka.lg.jp/_res/projects/default_project/_page_/001/039/464/20261109-2.pdf)は運行開始当日の城崎町内での石垣接触と安全確認までの休止を確認。トラック回避や手動介入なしは、引用報道の裏付けとなる調査結果を確認できなかった。
- **C20：正しい。** [大阪府掲載資料](https://www.pref.osaka.lg.jp/documents/118923/04_siryo3.pdf)「実証で分かった課題・対応」は雑草をセンサーが検知してブレーキが作動し、万博時に除草したと記載。
- **C21：確かめられない。** [米NTSB事故報告の概要](https://www.ntsb.gov/investigations/pages/HWY18MH010.aspx)は2018年の歩行者死亡、衝突5.6秒前の検知、緊急ブレーキが作動しない設計を確認。分類は変化したものの歩行者と正しく分類できず、進路も予測できなかったという意味であり、何にも分類できなかったわけではない。刑事処分とUberの不起訴を裁判・検察の一次資料で確認できなかった。
- **C22：確かめられない。** [米司法省](https://www.justice.gov/usao-ndca/pr/cruise-admits-submitting-false-report-influence-federal-investigation-and-agrees-pay)は2023年10月2日の事故、報告から引きずりを省略したこと、起訴猶予合意と50万ドルの刑事罰金を確認。動画は当日NHTSAに提出されていたとも記載。20フィート、DMV停止、他の制裁金は各当局の原資料を照合できなかった。
- **C23：確かめられない。** [NHTSA調査開始文書](https://static.nhtsa.gov/odi/inv/2026/INOA-RQ26006-19477.pdf)は2026年11月6日開始、対象2,895台、2025年12月10日届出のリコール後も停止中スクールバス通過の報告があることを確認。リコールの効果を調べる開始であり欠陥の最終認定ではない。8月20日の更新日と3,067台は今回未照合。
- **C24：確かめられない。** 提示の[CNBC報道](https://www.cnbc.com/2026/02/20/tesla-loses-bid-toss-243-million-verdict-fatal-autopilot-crash-suit.html)に対応する裁判所の評決・2月20日命令を確認できなかった。陪審の損害額と実際の支払額、控訴の有無は区別が必要。
- **C25：確かめられない。** [ロイター映像報道](https://www.youtube.com/watch?v=Pbpxq2_rwuc)は3月31日の複数台停止と負傷者なしを伝える。[FNN](https://www.fnn.jp/articles/-/1024420)は約80〜100台、[台湾公視](https://news.pts.org.tw/article/801914)は100台超と報じ、確定数は不明。[Bloomberg配信](https://newsdig.tbs.co.jp/articles/withbloomberg/2633604)は新規許可停止を報じるが、命令の原文・範囲・期間は未確認。「全国で全ての許可停止」と断定しない。
- **C26：確かめられない。** 重慶の2025年8月の事例について、日時、車両の運営主体、穴への転落、乗客の状態を独立した一次資料で確認できなかった。
- **C27：確かめられない。** [国交省検討資料](https://www.mlit.go.jp/policy/shingikai/content/001892045.pdf)24ページは、受託者の更新・監視等の過失と運行供用者の免責、通信遮断時の安全性と欠陥等の可能性を整理。提示の[報告書公表ページ](https://www.mlit.go.jp/report/press/jidosha01_hh_000066.html)の全文を通して運転者・乗客・受託者に関する各条件を確認できなかったため、文全体は未確定。これは検討会の解釈で、裁判所の個別判断ではない。
- **C28：確かめられない。** [EU指令原文](https://eur-lex.europa.eu/legal-content/EN/ALL/?uri=CELEX%3A32024L2853)は製造物にソフトウェアを含める。2024年12月8日発効と、国交省報告書で日本法の結論を示していないという消極的主張は本文全体で照合できなかった。指令と各国への国内法化・適用開始は区別する。
- **C29：確かめられない。** デジタル庁報告書と刑事免責についての報道・その後の制度を通読確認できなかった。運転者がいないことは、関係者の刑事責任が自動的に免除されることを意味しない。
- **C30：確かめられない。** [英国法原文](https://www.legislation.gov.uk/ukpga/2024/10/contents/enacted)は認可主体、利用者責任者、無人運行事業者の枠組みを置くが、成立日、免責範囲と例外、各規定の施行状況を今回十分に照合できなかった。成立と全面施行を同一視しない。
- **C31：確かめられない。** 2025年5月30日中間とりまとめの対象事故の範囲と、決定済みの制度か提言かを原文で確認できなかった。
- **C32：確かめられない。** 2026年7月3日報道の後、[国交省掲載の政府方針](https://www.mlit.go.jp/jidosha/content/002044688.pdf)は、運輸安全委員会による原因究明体制を引き続き検討し、2026年度内を目途に結論、必要に応じ速やかに法案提出と記載。資料の時点と国会提出・成立の有無を国会議案情報で網羅確認できず、秋提出を既定事実にも未提出と断定もできない。
- **C33：確かめられない。** [警察庁委託報告書](https://www.npa.go.jp/bureau/traffic/council/r7_tyosakenkyuhoukokusyo.pdf)の存在は確認したが、申請段階での協議の対象と表現を該当箇所で照合できなかった。
- **C34：確かめられない。** [提示のSOMPO記事](https://www.sompo-ri.co.jp/topics_plus/20250418-18216/)は二次資料。年度別の補助率・採択件数を国交省の採択結果と交付要綱で比較できなかった。予算枠、採択件数、実際の補助率を混同しない。
- **C35：正しい。** [GOの2026年9月15日開示](https://storage.googleapis.com/disclosed-file-bucket-d4575ee/20260914536186/1/general.pdf)「趣旨・契約内容」は3社の連携、2025年から都内7区で試験走行、2027年中を目標とするレベル4無人商用サービスの準備を記載。[Waymo](https://waymo.com/intl/it/waymo-in-japan/)は前年4月からの走行と説明。実現済みではなく目標。
- **C36：正しい。** [日産2026年3月12日発表](https://global.nissannews.com/ja-JP/releases/260312-01-j?origin=channel-NNG1441)は3社の覚書と東京で2026年後半までにパイロット導入の準備を説明。安全オペレーターの乗車を伴う計画で、無人商用サービス開始の確定ではない。

## 「未確認」項目

- **e-Palette送検後**：[日本交通政策研究会の研究報告](https://www.nikkoken.or.jp/pdf/project/2021/A-850.pdf)5.5.3は、東京地検が2022年3月4日に不起訴処分としたと記載。検察の一次資料は見つけられず、不起訴理由も確認できない。
- **境町のレベル4許可**：公安委員会の許可日・対象路線を確認できなかった。レベル2の運行実績をレベル4許可と取り違えない。
- **交通事故総合分析センター**：法令・公式資料による役割と、運輸安全委員会の事故原因調査との権限の違いを十分確認できなかった。
- **運輸安全委員会法案**：C32参照。提出・成立は確認できない。
- **武漢の台数**：C25参照。約80〜100台と100台超の報道があり、最大約500台を裏付ける信頼できる一次資料は確認できない。
- **ドイツ・EUの原文**：EU製造物責任指令は[C28のEUR-Lex原文](https://eur-lex.europa.eu/legal-content/EN/ALL/?uri=CELEX%3A32024L2853)第4条の定義等を参照。ドイツの自動運転制度の条文と最新施行状況は未確認。EU指令がそのまま日本のPL法を改正するわけではない。

## 場面作りに効く追加事実

1. **人とシステムの引継ぎが事故の焦点になる。** 東京都新木場では手動からレベル2に切り替えた際に接触した。[都の調査](https://www.metro.tokyo.lg.jp/information/press/2026/03/2026033029)を使い、切替時の位置、検知、運転者の監視と事後調査を分けて描ける。
2. **同じ場所の再発でも原因は同一とは限らない。** [小松市](https://www.city.komatsu.lg.jp/soshiki/1985/rosenbasu/4/19006.html)によると2026年8月18日は乗客11人が乗車し、システムの左操舵に運転士が危険と判断して介入したが、適切な操作に至らず接触。5月の操舵系の乖離とは調査上の説明が異なり、双方けが人なし。
3. **レベル4実績があってもサービス継続は保証されない。** [永平寺町](https://www.town.eiheiji.lg.jp/200/206/208/p010484.html)は車両・システムの保証と保守期間満了に伴い2026年4月から当面運休。事故だけでなく保守契約や代替交通も場面の条件になる。
4. **同じ万博路線で異なる運転状態の事故が起きた。** [近畿運輸局資料](https://wwwtb.mlit.go.jp/kinki/content/000366667.pdf)は2025年4月28日の手動回送中の擁壁衝突に加え、7月21日にレベル2走行中の縁石接触、9月4日の自動運転再開を記載。車両がレベル4対応でも事故時の運転状態を特定する必要がある。
5. **国際基準の進展。** [国交省発表](https://www.mlit.go.jp/report/press/jidosha10_hh_000350.html)は2026年6月の国連会議で一般道やレベル4を含む自動運転システムの国際基準が合意されたと説明。合意と各国での具体的な適用は別に確認する必要がある。

## 判定一覧

|番号|判定|一言|
|---|---|---|
|C01|確かめられない|許可・施行は確認、罰則未照合|
|C02|確かめられない|車内配置は確認、事故措置の細部未照合|
|C03|一部ちがう|装置認可の申請者は産総研|
|C04|確かめられない|実証の年度と条件未照合|
|C05|正しい|11か所、延べ12件|
|C06|確かめられない|閣議決定原文未照合|
|C07|古い|2026年4月から当面運休|
|C08|確かめられない|主要仕様確認、認可日等未照合|
|C09|確かめられない|許可日確認、車種・速度未照合|
|C10|確かめられない|舞洲の便数・人数確認、他未照合|
|C11|確かめられない|営業・許可・距離の対応未照合|
|C12|確かめられない|失効の過去公示を未照合|
|C13|確かめられない|事故の具体的な経過未照合|
|C14|確かめられない|送検は報道確認のみ|
|C15|一部ちがう|センサー統合と停止判断を要精密化|
|C16|確かめられない|手動回送事故確認、通信詳細未照合|
|C17|古い|3月に原因調査結果公表|
|C18|古い|8月にも別の接触事故|
|C19|確かめられない|接触確認、回避・介入は未照合|
|C20|正しい|雑草検知と除草を事業者が報告|
|C21|確かめられない|NTSBの事故分析確認、処分未照合|
|C22|確かめられない|司法省の合意確認、他制裁未照合|
|C23|確かめられない|調査開始確認、更新日等未照合|
|C24|確かめられない|裁判記録未照合|
|C25|確かめられない|台数に報道差、許可停止原文未確認|
|C26|確かめられない|独立した一次資料未確認|
|C27|確かめられない|一部確認、各責任主体の条件未照合|
|C28|確かめられない|EU対象確認、日本報告書全体未照合|
|C29|確かめられない|報告書・刑事免責の結論未照合|
|C30|確かめられない|英国法の免責範囲・施行未照合|
|C31|確かめられない|中間とりまとめ原文未照合|
|C32|確かめられない|後の政府方針あり、法案の状態未確定|
|C33|確かめられない|報告書の該当箇所未照合|
|C34|確かめられない|年度別の一次資料未照合|
|C35|正しい|2027年中の商用化は目標|
|C36|正しい|2026年後半までの準備を発表|
```


## 出典

- 課題地図：https://pixelstomotors.com/issues
- 警察庁「特定自動運行の許可制度の概要」：https://www.npa.go.jp/bureau/traffic/selfdriving/L4-summary.pdf
- 国土交通省「自動運転における自賠法上の損害賠償責任に関する検討会」報告書（2025年4月30日）：https://www.mlit.go.jp/report/press/jidosha01_hh_000066.html
- 塩尻市（レベル4の運行）：https://www.city.shiojiri.lg.jp/soshiki/10/49343.html
- 経済産業省（柏の葉のレベル4の運行開始）：https://www.meti.go.jp/press/2025/01/20260113001/20260113001.html
- Moral Machine：https://www.moralmachine.net/
- three.js：https://threejs.org/
