---
title: "研究記録サイトの来訪が減った原因を探す ― Google の順位が11/11に急落していた"
slug: visitors-drop-google-ranking-fell-nov-11
date: 2026-11-22
day: 547
meta_description: "pixelstomotors.com の人の表示は週163回から37回に減った。原因の1つは Google 検索の平均掲載順位が11/11に約17位から23〜71位へ落ちたこと。直接来る人の減少は原因不明。クローラーの404も2種類直した。"
tags: [サイト, アクセス解析, Search Console, Googleコアアップデート, SEO, クローラー, Cloudflare Workers, Codex]
series: "ひとり研究所の裏側"
cover: "/media/LOG547_cover.jpg"
---

**ロボットの研究記録サイト pixelstomotors.com の人の表示は、2026年10月26日の週の163回から11月16日の週の37回へ、約4分の1になった。減った分の1つは Google 検索から来る人で、Google の平均掲載順位が11月11日に約17位から23〜71位へ落ちていた。もう1つの、ブックマークや SNS のアプリなど「直接」来る人の減少（週66回→15回）は、原因がまだ分からない。** サイトに自前で入れている計測と、[Google Search Console](https://search.google.com/search-console/about)（自分のサイトが Google 検索でどう扱われているかを見る Google の無料の道具）で、Claude と一緒に確かめた。

この確認で、次のことができるようになった。

- 減った分を、原因が分かった分（Google の順位）と、分からない分（直接来る人）に分けられた。順位のほうは、Google の更新が落ち着いてから前後を比べる（12/4 に予約済み）。直接来る人のほうは、どこで知って来ていた人かを調べる必要がある、と次にやることがはっきりした
- 人が実際に読み込んでいる記事が分かった。ロボットアーム mechArm 270 の初期の作業記録（DAY12〜DAY126）と、配膳ロボットの試算。研究の外側の作業を書いた記事（このシリーズ）は、人にはほとんど読み進められていない
- 調べる途中で見つけた、クローラー（検索や AI のために、サイトを自動で読み回るプログラム）の「ページがない」が2種類あり、どちらも直して公開した。1つは週60回ほどの `/null`、もう1つは記事に載せたコードの中の文字を住所と見て取りに来る分（64記事分）。減ったかどうかは、来週のクローラーの記録で確かめる（今は見込み）
- かかった時間は、依頼（08:27）から2つ目の直しの公開を確かめるまで約55分。前に同じ確認をしたことがないので、比べる時間はない

きっかけは「サイトのアクセス解析」という一言だった。週ごとの数を並べると、人の表示は 163 → 136 → 71 → 37 と減り続けていた。一方で、ChatGPT や Claude が利用者に頼まれてサイトを読みに来た回数は、同じ4週で 55 → 61 → 51 → 100 と増えていた。人は減り、AI の読みは増えている。続けて「人の来訪が減ってる理由はなんですか？」と聞かれ、来た所ごとに分けて Search Console と突き合わせた。

| やったこと | なぜ | 結果 |
|---|---|---|
| サイトの計測の3つの数字と人の表示を、4週分並べた | 週の分析の始まり | 人の表示は 163 → 37。AI が依頼で読んだ数は 55 → 100 |
| 人の表示を、来た所（直接・Google・サイト内・その他）ごとに週で分けた | 何が減ったのかを分けるため | 直接・不明が 66 → 15、Google＋Yahoo が 41 → 9 |
| Search Console で、Google 検索の日ごとの表示と掲載順位を見た | Google から来る人の減り方を確かめるため | 11/10 に表示が1日21回に落ち、11/11 から順位も23〜71位に |
| X の投稿が止まっていないかを、X のプロフィールで見た | 直接来る人の減り方の原因の候補だったため | 1日5〜6本出ていた。止まっていない |
| 人がよく見たページを4週分まとめた | 何が読まれているかを知るため | 初期の DAY 記録と配膳ロボットの試算がよく読まれ、裏側の記事は読まれていない |
| クローラーの「ページがない」（404）の出どころを、サイトのコードで探した | 4週の記録に同じ形の404が並んでいたため | `/null` はハコブくんのスクリプト、`{src}` などは記事に載せたコードの中の文字 |
| 2つを直して公開した（2つ目は Codex のレビューを通した） | クローラーが無駄に取りに来る回数を減らすため | `/null` を生む文字をなくした。`{` `}` を含む住所に 410 を返すようにした |

下の図で、人の表示がどこから来た人で減ったかと、Google 検索の日ごとの表示・掲載順位を切り替えて見られます。

【図解】LOG547_where_visitors_came_from.html


## 作業ログ ― サイトの計測の数字を4週分並べた

### サイトの計測と、3つの数字の読み方

このサイトの計測は、[Cloudflare Workers](https://developers.cloudflare.com/workers/)（サイトの手前で動く小さなプログラム）の上で自前で数えている。Claude からは計測の道具（PTM）を通して数字を読み、数を読む前に、まず読み方（how_to_read）を読む決まりにしている。

いま主に見る数字は3つ。AI の利用者の依頼で読みに来た数（ChatGPT-User・Claude-User・Perplexity-User などがページを取りに来た回数）、AI のサービスのリンクから来た人の数、サイト名で検索して来た人の数。人の表示は、マウス・指・キーの操作があった表示だけを数える（表示の約9割は機械なので）。

### 4週の3つの数字と人の表示（2026-10-26〜11-22・11/22 は途中の数）

| 週 | 人の表示 | AI が依頼で読んだ数 | 内訳 | AI のリンクから来た人 | サイト名の検索 |
|---|---|---|---|---|---|
| 10/26〜 | 164 | 55 | ChatGPT-User 52・Claude-User 3 | 0 | 0 |
| 11/02〜 | 136 | 61 | ChatGPT-User 45・Claude-User 16 | 3（ChatGPT） | 0 |
| 11/09〜 | 71 | 51 | ChatGPT-User 35・Claude-User 8・Perplexity-User 8 | 3（ChatGPT） | 0 |
| 11/16〜 | 37 | 100 | ChatGPT-User 71・Claude-User 29 | 4（ChatGPT） | 未記録 |

人の表示は、計測の道具の2つの集計（3つの数字の集計と、ページごとの集計）で、10/26 の週だけ 164 と 163 の1件の差がある。以下の来た所の表は、ページごとの集計（163）で数えている。

11/9 の週の Perplexity-User 8件は、LOG527 で調べたとおり設定ファイルを探す機械だった。AI のリンクから来た人は4週で合わせて10人で、すべて ChatGPT から。30人に満たないので、増えたか減ったかの判断はまだできない。

### Claude-User の読みと、作業の時刻を突き合わせた

11/16 の週の Claude-User 29件には、こちらの作業が混ざっているかもしれない。Claude-User の1件ずつの時刻を出し、チャットの履歴と並べた。

| Claude-User の時刻（日本時間） | 読んだページ | 同じ時間帯の作業 |
|---|---|---|
| 11/17 09:41〜09:42 | /series4・/record/day17・/record/day18 | 不明 |
| 11/17 13:08 | /record/making-explainer-video-with-ai | 不明 |
| 11/17 18:04〜18:09 | π0.5 の記録10本（/guide/pi05-mecharm-270 など） | SO-101 の受け入れを整理したチャット（LOG530）の日 |
| 11/18 20:36〜22:17 | /series5・/record/first-video-end-to-end・/guide・/record/making-explainer-video-with-ai | ガイドのサムネイルを作ったチャット（LOG531）の夜 |
| 11/19 01:31〜21:49 | /・/tokushoho・/record/youtube-views-to-right-viewers・/serving-robot-one-less-staff | 不明 |
| 11/20 10:40〜19:30 | /・/issues・/message | 不明 |
| 11/22 07:52 | /・/series4 | 不明 |

作業の日と重なるものはあるが、分単位で時刻が合ったものはない。決まりどおり「試し」とは言わず、未確認として扱う。AI の読みの増え方を見るときは、ChatGPT-User（35 → 71）を中心に見るほうが安全。


## 作業ログ ― 人の表示を来た所ごとに分けた

### 週ごとの来た所（人の表示・計測のページごとの集計から）

| 週 | 直接・不明 | Google＋Yahoo | サイト内の移動 | その他 | 合計 |
|---|---|---|---|---|---|
| 10/26〜 | 66 | 41（Google 33・Yahoo 8） | 43 | 13 | 163 |
| 11/02〜 | 67 | 39（Google 37・Yahoo 2） | 17 | 13 | 136 |
| 11/09〜 | 20 | 21（Google 21） | 21 | 9 | 71 |
| 11/16〜 | 15 | 9（Google 9） | 7 | 6 | 37 |

その他の内訳は次のとおり。

| 週 | その他の内訳 |
|---|---|
| 10/26〜 | LinkedIn 4・Microsoft Teams 3・X（t.co）3・市のサイト 2・Google アプリ 1 |
| 11/02〜 | LinkedIn 3・LinkedIn アプリ 1・ChatGPT 3・Bing 2・studio.design 2・YouTube 1・X（t.co）1 |
| 11/09〜 | ChatGPT 3・LinkedIn 3・Google Keep 2・自分の試しのリンクの印 1 |
| 11/16〜 | ChatGPT 4・studio.design 1・Bing 1 |

11/16 の週の合計は、11/9 以降の集計（108）から 11/16 以降の集計（37）を引いて 11/9 の週（71）を出している。

**減った分の大半は「直接・不明」（66 → 15）と「Google＋Yahoo」（41 → 9）だった。** サイト内の移動は、外から入ってくる人が減れば一緒に減るので、原因ではなく結果と見ている。

### Google 検索の日ごとの表示・クリック・掲載順位（Search Console・2026-10-19〜11-21）

Search Console の「検索結果のパフォーマンス」を、日ごとの表で開いて読み取った（新しいドメイン sc-domain:pixelstomotors.com）。最初は Claude のデスクトップアプリの中のブラウザで開こうとしたが、Google への再ログインを求められたので、ふだんの Chrome（Claude in Chrome）で開いた。

| 日 | クリック | 表示 | 平均掲載順位 |
|---|---|---|---|
| 10/19 | 6 | 155 | 21.0 |
| 10/20 | 0 | 143 | 19.7 |
| 10/21 | 1 | 146 | 15.8 |
| 10/22 | 1 | 143 | 17.6 |
| 10/23 | 2 | 111 | 19.6 |
| 10/24 | 0 | 100 | 20.2 |
| 10/25 | 3 | 132 | 19.8 |
| 10/26 | 2 | 187 | 20.6 |
| 10/27 | 2 | 131 | 14.2 |
| 10/28 | 3 | 125 | 18.1 |
| 10/29 | 1 | 109 | 14.8 |
| 10/30 | 0 | 100 | 15.4 |
| 10/31 | 2 | 86 | 21.5 |
| 11/01 | 2 | 89 | 18.8 |
| 11/02 | 0 | 87 | 16.2 |
| 11/03 | 2 | 97 | 20.3 |
| 11/04 | 2 | 96 | 17.0 |
| 11/05 | 6 | 133 | 12.2 |
| 11/06 | 5 | 98 | 16.3 |
| 11/07 | 1 | 70 | 13.3 |
| 11/08 | 4 | 95 | 18.3 |
| 11/09 | 6 | 148 | 17.4 |
| 11/10 | 2 | 21 | 17.3 |
| 11/11 | 1 | 9 | 70.7 |
| 11/12 | 0 | 22 | 34.3 |
| 11/13 | 1 | 13 | 50.1 |
| 11/14 | 0 | 17 | 51.4 |
| 11/15 | 0 | 13 | 47.4 |
| 11/16 | 1 | 10 | 23.3 |
| 11/17 | 0 | 10 | 46.0 |
| 11/18 | 0 | 14 | 42.1 |
| 11/19 | 0 | 23 | 56.9 |
| 11/20 | 1 | 22 | 62.8 |
| 11/21 | 0 | 18 | 66.4 |

11/9 までは掲載順位が12〜22位で、表示は1日70〜187回。11/10 に表示が21回へ落ち（順位はまだ17位）、11/11 からは順位も23〜71位に下がった。Google の11月のコアアップデート（検索の順位の付け方の大きな更新）は 11/10 に始まっている（LOG527）。クリックは、11/9 までの週ごとに 12・20 回、11/9 の週は 10 回、11/16 の週は 2 回。サイトの計測で Google から来た人（33・37・21・9）と、増え減りの向きがそろっている。

### X の投稿は止まっていなかった

直接・不明の来訪には、X や LinkedIn のアプリの中のブラウザから来た人が入りやすい（アプリは来た所を送らないことが多い）。X の投稿が減っていれば、直接の来訪が減った説明になる。サイトのフッターにある X のアカウント（@adaptdesignjp）を開き、投稿を新しい順に29本読み取った。

| 日（日本時間） | 投稿の数（読み取った分） |
|---|---|
| 11/21 | 2（10:39・03:30） |
| 11/20 | 7（22:30・13:00・12:41・12:42・12:00・11:00・10:30） |
| 11/19 | 5（22:30・13:00・12:00・10:30・03:30） |
| 11/18 | 3 以上（22:30・13:00・12:00） |

11/18〜11/21 も1日5〜7本出ていて、予約投稿は止まっていなかった。X の投稿の数は、直接の来訪の減り方を説明しない。

### /message を開いた7回は、外の人だった

減る前の2週の「直接・不明」は、短い時間で何度も開かれたページに偏っていた。10/26 の週は /gpu-buy-or-rent が17回（表示の中央値11秒）、11/2 の週は /issues が11回・/manga-archive が8回・/message が7回。少ない人数が繰り返し開いていた形に見えたので、エイイチ自身の確認が計測を止める印（?p2m-notrack=1）なしで入っていたかもしれない、と Claude は見立てた。

これに対してエイイチから、/message を7回も開いていない、別の人ではないか、と返ってきた。見立ては外れていて、直接来た人の多くは外の人だった。そうなると、直接の来訪が 66 → 15 に減ったのは、実際に見に来る人が減ったと見るのが自然になる。どこで知って来ていた人たちかは、来た所が「不明」なので、今の記録では分からない。


## 作業ログ ― 人が読んでいるページを4週分まとめた

### ページごとの人の表示（2026-10-26〜11-22・表示が3回以上のページ）

表示の中央値は、そのページにいた時間の真ん中の値。「75%まで読んだ」は、ページの4分の3まで下に進んだ表示の割合。

| ページ | 表示 | 中央値（秒） | 25%まで | 50%まで | 75%まで | 最後まで |
|---|---|---|---|---|---|---|
| / （トップ） | 51 | 15 | 69% | 43% | 27% | 20% |
| /issues （課題地図） | 22 | 10 | 9% | 5% | 0% | 0% |
| /gpu-buy-or-rent | 21 | 11 | 52% | 52% | 10% | 0% |
| /manga-archive | 14 | 9 | 21% | 7% | 7% | 0% |
| /series8 | 13 | 15 | 15% | 15% | 15% | 8% |
| /record/day18 | 11 | 53 | 91% | 64% | 27% | 9% |
| /message | 11 | 10 | 100% | 100% | 91% | 9% |
| /series6 | 8 | 18 | 63% | 38% | 38% | 25% |
| /record/day17 | 8 | 25 | 75% | 75% | 38% | 0% |
| /record/day12 | 8 | 23 | 100% | 63% | 38% | 25% |
| /record/service-robot-last-mile | 7 | 15 | 0% | 0% | 0% | 0% |
| /record/large-restaurant-five-serving-robots-longer-wait | 7 | 19 | 29% | 14% | 14% | 0% |
| /record/from-sim-series-to-lp | 6 | 69 | 50% | 50% | 17% | 0% |
| /record/beyond-imitation-learning | 6 | 19 | 50% | 50% | 50% | 0% |
| /series4 | 5 | 9 | 100% | 40% | 40% | 40% |
| /record/building-a-physical-ai-lab-at-home | 5 | 20 | 40% | 20% | 0% | 0% |
| /consult | 5 | 13 | 100% | 60% | 20% | 20% |
| /record/alphanist-binary-reward-assembly | 5 | 16 | 80% | 60% | 60% | 40% |
| /record/check-serving-robot-sim-with-phone | 5 | 39 | 20% | 20% | 20% | 0% |
| /record/youtube-opening-question-first | 5 | 11 | 20% | 0% | 0% | 0% |
| /record/day145 | 4 | 59 | 50% | 25% | 25% | 0% |
| /record/serving-robot-cost-subsidy | 4 | 45 | 25% | 25% | 25% | 0% |
| /record/so101-imitation-learning-papers | 4 | 15 | 0% | 0% | 0% | 0% |
| /record/video-patterns-and-try-it | 4 | 18 | 25% | 25% | 25% | 25% |
| /serving-robot-one-less-staff | 4 | 156 | 75% | 50% | 50% | 50% |
| /record/serving-robot-video-part2 | 4 | 11 | 25% | 0% | 0% | 0% |
| /record/serving-robot-video-ledger | 4 | 12 | 50% | 50% | 0% | 0% |
| /record/small-store-second-robot-wait | 3 | 15 | 33% | 33% | 33% | 0% |
| /record/one-year-lp-charts | 3 | 14 | 0% | 0% | 0% | 0% |
| /record/serving-robot-hidden-waits | 3 | 15 | 33% | 0% | 0% | 0% |
| /record/road-marking-job-post-and-physical-ai | 3 | 56 | 67% | 67% | 67% | 0% |
| /manga/ep133 | 3 | 9 | 100% | 0% | 0% | 0% |
| /record/claude-project-linked-folders | 3 | 28 | 67% | 33% | 33% | 0% |
| /record/day126 | 3 | 93 | 67% | 67% | 33% | 33% |

### 読まれ方の種類で分けた

| 種類 | 主なページ | 読まれ方 |
|---|---|---|
| mechArm 270 の初期の DAY 記録 | day12・17・18・120・126・145 | 回数が多く、半分以上まで読む人が多い。Google から来ている |
| 配膳ロボットの試算 | /series8・配膳ロボットの LP・大型店に5台・補助金 | 毎週少しずつ。LP は中央値156秒で、動画を何度も再生している（4回の表示で133回） |
| 考察記事 | 日本のロボットの差（中央値449秒）・HD マップ（364秒） | 回数は少ないが、来た人は長く読む |
| 入口のページ | トップ・/issues・/manga-archive | トップは読まれる。/issues とマンガの一覧は、開いてすぐ離れる |
| π0.5・研究室の記録、動画の作り方、マンガの裏側 | 記事の数は多い | 1本あたり1〜2回で、ほとんど読み進まれない |

ChatGPT のリンクから来た10人の行き先は、YouTube の冒頭の作り方の記事（2回）・動画づくりの記事・day12・トップなどに散らばっていて、決まった入口はなかった。


## 作業ログ ― クローラーの「ページがない」（404）の出どころを探した

### 404 と 410 と、meta-externalagent

404 は、サーバーが「そのページはない」と返す番号。410 は「そのページはもうない（今後もない）」と返す番号で、取りに来る側に、もう来なくてよいと伝える意味を持つ。[meta-externalagent](https://developers.facebook.com/docs/sharing/webmasters/web-crawlers/) は、Meta が AI のためにサイトを読み回るクローラー。

クローラーの記録（11/9 から2週）には、同じ形の404が並んでいた。

| 住所 | 返した番号 | 取りに来た回数 | 取りに来たクローラー |
|---|---|---|---|
| /null | 404 | 26（〜11/18）・11/16 の週は60 | meta-externalagent |
| /files/LOG502/{src}・{c}・{o}・{e[0]}・{e[1]}・{m[l]}・{EI[p][0]} | 404 | 各2〜4 | ClaudeBot・GPTBot・Amazonbot |
| /files/LOG506/{href}・/files/LOG507/{src}・/files/LOG511/{src} ほか | 404 | 各2〜4 | ClaudeBot・GPTBot・Amazonbot |
| /record/{src}・/record/{href}・/record/{URL}・/record/${MSG_URL} ほか | 404 | 各1〜2 | ClaudeBot・GPTBot・Amazonbot |
| /files/LOG493/{s.img.startsWith('/') | 404 | 4 | GPTBot・ClaudeBot・Amazonbot |

### /files/LOG502/{src} は、記事に載せたコードの中の文字だった

p2m-site（このサイトのコードの置き場所）で、`public/files/LOG502/` のファイルを探した。

```
$ grep -c '{src}\|{c}\|{e\[0\]}' public/files/LOG502/*
public/files/LOG502/02_sec12.py.txt:3
public/files/LOG502/01_sec10.py.txt:0
public/files/LOG502/04_sec15.py.txt:0
public/files/LOG502/03_sec13.py.txt:1
public/files/LOG502/05_sec16.py.txt:0
public/files/LOG502/index.json:0
public/files/LOG502/LOG502_full.md:4
$ grep -n 'src="{src}"\|href="{href}"\|{s.img.startsWith' -r public/files/LOG502 public/files/LOG493 public/files/LOG506
public/files/LOG502/LOG502_full.md:696:            f'<img data-a="pop" data-t="0.35" data-d="0.5" src="{src}" style="position:absolute;left:{left}px;top:{top}px;width:{w}px">')
public/files/LOG502/02_sec12.py.txt:203:            f'<img data-a="pop" data-t="0.35" data-d="0.5" src="{src}" style="position:absolute;left:{left}px;top:{top}px;width:{w}px">')
public/files/LOG493/LOG493_full.md:627:          <img src={s.img.startsWith('/') ? s.img : media(`/media/${s.img}`)} alt={`${s.ja}｜${s.en}`} loading="lazy" />
public/files/LOG493/03_sec04.txt:144:          <img src={s.img.startsWith('/') ? s.img : media(`/media/${s.img}`)} alt={`${s.ja}｜${s.en}`} loading="lazy" />
```

【画像】LOG547_01_code_src_placeholder.png サイトに置いた LOG502 のコードのファイル。203行目の src="{src}" を、クローラーが住所と見て /files/LOG502/{src} を取りに来ていた

記事に載せた Python のコードには、HTML を組み立てる文字として `src="{src}"` が入っている。GPTBot・ClaudeBot・Amazonbot は、.txt や .md の中からも `src="…"` `href="…"` の形を拾い、そのファイルの置き場所（/files/LOG502/）から見た住所として取りに来ていた。`/record/{src}` のほうは、記事の Markdown 版（`/record/{slug}.md`）の中のコードから拾っている。同じ形の文字があるのは、`public/files/` の64記事分だった。

```
$ grep -rlE 'src="\{|href="\{|src=\{|href=\{|\$\{[A-Z_]+\}' public/files | sed -E 's#public/files/(LOG[0-9]+)/.*#\1#' | sort -u | wc -l
64
$ find public src/pages -name '*[{}`]*'
（出力なし）
```

コードは全文を載せる決まりなので、中身は変えない。サイトに `{` `}` `` ` `` を名前に含むファイルは1つもないので、そういう住所には 410 を返してよい、と考えた。

### /null は、ハコブくんのスクリプトの文字の 'null' だった

/null のほうは、ページの中にリンクがなかった。トップ・記事・課題地図・マンガのページの HTML、サイトマップ、llms.txt、更新の一覧 updates.json を探しても、null へのリンクはない。

```
$ curl -s https://pixelstomotors.com/updates.json | python3 -c "..."
<class 'dict'> ['items']
20
[{'id': 'record:ai-leaves-cleanup-600gb-video-frames-on-external-ssd', 'kind': 'record', 'label': 'LOG546', 'title': 'AIに作業を任せると、片付けは残る ― 外付けSSDの600GBが動画のコマだった', 'url': '/record/ai-leaves-cleanup-600gb-video-frames-on-external-ssd', 'date': '2026-11-22T00:00:00.000Z'}, {'id': 'record:why-microfactory-robots-are-reliable-llm-and-pi05', 'kind': 'record', 'label': 'LOG545', 'title': '小さな会社のロボットはなぜ確実に動くのか ― MicroFactory の LLM と π0.5 の使い分け', 'url': '/record/why-microfactory-robots-are-reliable-llm-and-pi05', 'date': '2026-11-21T00:00:00.000Z'}]
[]
$ for u in / /record/ai-leaves-cleanup-600gb-video-frames-on-external-ssd /issues /manga-archive /series8 /manga/ep147 /record/day18; do ... grep null ...; done
== / 96356
== /record/ai-leaves-cleanup-600gb-video-frames-on-external-ssd 87175
== /issues 120988
== /manga-archive 84609
== /series8 136008
== /manga/ep147 70430
== /record/day18 54308
（どのページにも null へのリンクはなかった）
$ curl -s https://pixelstomotors.com/sitemap.xml | grep -c null
0
```

次に、実際のブラウザ（Playwright の Chromium）でページを動かし、`/null` を取りに行く動きがないかを見た。

```python
import asyncio,sys
from playwright.async_api import async_playwright
pages=sys.argv[1:]
async def main():
  async with async_playwright() as p:
    b=await p.chromium.launch()
    for path in pages:
      ctx=await b.new_context(user_agent="Mozilla/5.0 (compatible; probe)")
      pg=await ctx.new_page()
      hits=[]
      pg.on("request",lambda r:hits.append(r.url))
      try:
        await pg.goto("https://pixelstomotors.com"+path+("&" if "?" in path else "?")+"p2m-notrack=1",wait_until="networkidle",timeout=45000)
        await pg.wait_for_timeout(4000)
      except Exception as e: print("ERR",path,e)
      bad=[h for h in hits if "/null" in h or "undefined" in h or "%7B" in h]
      print(path,len(hits),bad)
      await ctx.close()
    await b.close()
asyncio.run(main())
```

```
$ python3 /tmp/probe.py / /record/day109 /manga/ep13 /english-4-koma/ep31 /record/ai-leaves-cleanup-600gb-video-frames-on-external-ssd
/ 64 []
/record/day109 31 []
/manga/ep13 34 []
/english-4-koma/ep31 30 []
/record/ai-leaves-cleanup-600gb-video-frames-on-external-ssd 30 []
```

ブラウザで動かしても `/null` は出ない。そこで、ページが読み込むスクリプトの中の文字を探した。

```
$ curl -s https://pixelstomotors.com/_astro/HakobuParade.astro_astro_type_script_index_0_lang.DJ-JM5aE.js | grep -oE ".{60}['\"\`]null['\"\`].{30}"
{})}catch{}}try{const t=JSON.parse(localStorage.getItem(u)||"null");t&&!t.done&&location.pathnam
("click",n);try{const c=JSON.parse(localStorage.getItem(u)||"null");c&&c.id===n.id&&(c.clicked=!
```

更新を知らせるハコブくんのスクリプトに、`"null"` という文字が2か所あった。meta-externalagent は同じスクリプトの中の `'/updates.json'` を、2週で952回取りに来ている。スクリプトの中の文字の並びを住所として拾っていて、`"null"` も同じように `/null` として取りに来ていると見た。1件ずつの記録を見ても、`/null` は特定のページの直後ではなく、ほかのページを読み回る合間に1〜2時間おきに出ていた。

| 時刻（11/22・日本時間） | meta-externalagent が取りに来たもの |
|---|---|
| 04:13:56 | /null（404） |
| 04:14:37 | / |
| 06:09:46 | /null（404） |
| 07:34:12 | /null（404） |

これはブラウザで再現できていないので、「ほぼ確実」までで、確かめきれてはいない。直したあとに `/null` が減れば、見立てが合っていたことになる。


## 作業ログ ― /null の元になる文字を、ハコブくんのスクリプトからなくした

### HakobuParade.astro の変更（差分）

```diff
diff --git a/src/components/HakobuParade.astro b/src/components/HakobuParade.astro
index af81f24..a0a2f0d 100644
--- a/src/components/HakobuParade.astro
+++ b/src/components/HakobuParade.astro
@@ -94,9 +94,11 @@
       }
     } catch { /* 送れなくてもサイトの動きには影響させない */ }
   }
+  // 最後に知らせた更新を読む。なければ null（文字の 'null' を書かない：クローラーが JS の中の文字を住所と見て /null を取りに来ていた。2026-11-22）
+  const readShown = () => { const v = localStorage.getItem(SHOWN_KEY); return v ? JSON.parse(v) : null; };
   // 押さずにあとで見に来たか：最後に知らせた更新のページを、7日以内に開いたら1回だけ送る
   try {
-    const last = JSON.parse(localStorage.getItem(SHOWN_KEY) || 'null');
+    const last = readShown();
     if (last && !last.done && location.pathname === last.url && Date.now() - last.at < 7 * 864e5) {
       if (!last.clicked) report('later', last); // 押して来た分は click で送り済み
       last.done = true; localStorage.setItem(SHOWN_KEY, JSON.stringify(last));
@@ -140,7 +142,7 @@
     say.addEventListener('click', () => {
       if (preview) return;
       report('click', it);
-      try { const last = JSON.parse(localStorage.getItem(SHOWN_KEY) || 'null'); if (last && last.id === it.id) { last.clicked = true; localStorage.setItem(SHOWN_KEY, JSON.stringify(last)); } } catch { /* なし */ }
+      try { const last = readShown(); if (last && last.id === it.id) { last.clicked = true; localStorage.setItem(SHOWN_KEY, JSON.stringify(last)); } } catch { /* なし */ }
     });
     document.body.append(box, say);
     const RUN = reduce ? 4000 : 7500;
```

- ねらい：クローラーが住所と見て取りに来る `"null"` の文字を、スクリプトからなくす
- 変わったこと：最後に知らせた更新を読む小さな関数 `readShown()` を足し、値がないときは文字ではなく null をそのまま返す。動き（あとで見に来たかの記録・押したかの記録）は変えていない
- 見込める効果：meta-externalagent の `/null` が週60回ほどから0回へ。来週のクローラーの記録で確かめる

### 直したあとの HakobuParade.astro（全文）

```astro
---
// サイトに新しい更新（記録・4コマ・課題地図の最近の動き）があると、ハコブくんが画面の下を走り回って知らせる。
// 動画の進み具合のページの「動画が公開されたら走るハコブくん」と同じ動き・同じ決まり：
// - 知らせた更新はこのブラウザに覚えておき、同じ更新では2回走らない
// - 初めて来た人には、今日（日本時間）公開された分だけ知らせる
// - タブが見えていないときは走らず、見えたときに走る
// 吹き出しを押すと、その更新のページへ移る
// 5〜20回に1回、走っている途中でコケて、起き上がってまた走る（回数はこのブラウザに覚える。2026-10-24）
// 確かめ用：どのページでも ?hk=trip を付けて開くとコケる走り、?hk=run でふつうの走りを1回見られる（記録は送らない・知らせ済みにもしない）
// 効果を測るため、「出た・吹き出しを押した・押さずにあとで（7日以内に）その更新を見に来た」を /api/hk-event に送る。
// 送るのは出来事の種類・どの更新か・どのページで・画面の幅だけ（見た人を見分ける番号は作らない）。数は /api/hk-stats で見られる
---
<script>
  type Item = { id: string; kind: 'record' | 'manga' | 'issues'; label: string; title: string; url: string; date: string };
  const KEY = 'p2m-site-announced';
  const IMG = '/site/hakobu/';
  const reduce = window.matchMedia('(prefers-reduced-motion: reduce)').matches;
  const HEAD: Record<Item['kind'], string> = {
    record: '新しい記録を公開しました！',
    manga: '新しい4コママンガを公開しました！',
    issues: '課題地図に最近の動きが加わりました！',
  };
  let seen: Set<string> | null = null;
  let items: Item[] = [];
  let running = false;
  const SHOWN_KEY = 'p2m-site-announced-last';
  const TRIP_KEY = 'p2m-site-hk-trip';
  const TRIP_MS = 3600; // つまずいてから、起き上がって照れるまで
  // コケたときの体の動き（q はつまずいてからの ms）。rot は前に倒れる角度、dx は前へずれる量、dy は上下、flip は向き、sy は縦の縮み
  // つまずく → 手をバタバタさせながら倒れる → ドテッ → 起きようとしてモタモタ → 1回目は失敗 → やっと起きる → きょろきょろして照れる
  const smooth = (v: number) => v * v * (3 - 2 * v);
  const clamp = (v: number) => Math.min(1, Math.max(0, v));
  function tripPose(q: number): { rot: number; dx: number; dy: number; flip: number; sy: number; face: 'joy' | 'open' } {
    const P = { rot: 0, dx: 0, dy: 0, flip: 1, sy: 1, face: 'open' as 'joy' | 'open' };
    const seg = (a: number, b: number) => clamp((q - a) / (b - a));
    if (q < 180) { // つまずく：前につんのめって、小さく跳ねる
      const v = smooth(seg(0, 180)); P.rot = 22 * v; P.dx = 10 * v; P.dy = -9 * Math.sin(Math.PI * v);
    } else if (q < 700) { // バタバタ：前のめりのまま、体を小刻みに揺らしながら倒れていく
      const v = seg(180, 700); P.rot = 22 + 48 * smooth(v) + 11 * Math.sin(q / 26); P.dx = 10 + 18 * v; P.dy = -5 * Math.abs(Math.sin(q / 40)) * (1 - v);
    } else if (q < 820) { // ドテッ
      const v = smooth(seg(700, 820)); P.rot = 70 + 22 * v; P.dx = 28 + 4 * v; P.face = 'joy';
    } else if (q < 960) { // 地面で小さく弾む
      const v = seg(820, 960); P.rot = 92 - 7 * Math.sin(Math.PI * v); P.dx = 32; P.face = 'joy';
    } else if (q < 1560) { // モタモタ：寝たまま小刻みにもがく
      const v = seg(960, 1560); P.rot = 89 + 3 * Math.sin(q / 21) * (1 - v * .5); P.dx = 32 + 2.5 * Math.sin(q / 47); P.face = 'joy';
    } else if (q < 1980) { // 起きようとして、途中で力尽きる
      const v = seg(1560, 1980); P.rot = 89 - 38 * Math.sin(Math.PI * v) + 2 * Math.sin(q / 17) * Math.sin(Math.PI * v); P.dx = 32; P.face = v < .5 ? 'joy' : 'open';
    } else if (q < 2120) { // ペタッと戻る
      const v = seg(1980, 2120); P.rot = 89 - 5 * Math.sin(Math.PI * v); P.dx = 32; P.face = 'joy';
    } else if (q < 2720) { // もう一度、ぷるぷるしながらゆっくり起き上がる（少し後ろへ行き過ぎる）
      const v = smooth(seg(2120, 2720)); P.rot = 89 - 99 * v + 2.5 * Math.sin(q / 15) * (1 - v); P.dx = 32; P.face = 'joy';
    } else if (q < 2920) { // ふらついて止まる
      const v = seg(2720, 2920); P.rot = -10 * (1 - v) * Math.cos(Math.PI * 2.5 * v); P.dx = 32;
    } else if (q < 3240) { // きょろきょろ（誰か見てた？）
      const v = seg(2920, 3240); P.flip = v > .3 && v < .7 ? -1 : 1; P.dx = 32;
    } else { // 照れて、ちょっと縮こまる
      const v = seg(3240, 3600); P.rot = 6 * Math.sin(Math.PI * v); P.sy = 1 - .05 * Math.sin(Math.PI * v); P.dx = 32; P.face = 'joy';
    }
    return P;
  }

  // 次にコケるまでの残り回数を1つ減らし、0になったらコケる。コケたら次は5〜20回後に決め直す
  function willTrip(): boolean {
    const next = () => 5 + Math.floor(Math.random() * 16);
    try {
      let n = parseInt(localStorage.getItem(TRIP_KEY) || '', 10);
      if (!(n > 0)) n = next();
      n -= 1;
      const trip = n <= 0;
      localStorage.setItem(TRIP_KEY, String(trip ? next() : n));
      return trip;
    } catch { return Math.random() < 1 / 12; } // 覚えられない環境では、平均して12回に1回
  }

  // 効果の記録を送る（ページを移っても届くよう sendBeacon を使う）
  // 送らない場合（サイトの使われ方の記録と同じ決まり。2026-10-28）：?p2m-notrack=1 で記録しない設定にしたブラウザ（エイイチ・Claude の確認）、
  // 「トラッキングしないで」の設定のブラウザ
  // 機械の印（2026-10-28）：wd＝navigator.webdriver、hl＝名乗りに Headless・bot などが入っているかの判定結果だけ（名乗りそのものは送らない）
  const HK_AUTO_UA = /headless|lighthouse|bot\/|bot;|\bbot\b|crawl|spider|slurp|preview|phantom|puppeteer|playwright|selenium/i;
  function reportOff(): boolean {
    const nav = navigator as Navigator & { globalPrivacyControl?: boolean };
    if (nav.doNotTrack === '1' || nav.globalPrivacyControl === true) return true;
    try { return localStorage.getItem('p2m-notrack') === '1' || new URLSearchParams(location.search).get('p2m-notrack') === '1'; } catch { return false; }
  }
  function report(e: 'shown' | 'click' | 'later', it: { id: string; kind: string }) {
    if (reportOff()) return;
    const body = JSON.stringify({
      e, id: it.id, kind: it.kind, path: location.pathname, w: window.innerWidth < 600 ? 'sp' : 'pc',
      wd: navigator.webdriver ? 1 : 0, hl: HK_AUTO_UA.test(navigator.userAgent || '') ? 1 : 0,
    });
    try {
      if (!navigator.sendBeacon || !navigator.sendBeacon('/api/hk-event', new Blob([body], { type: 'text/plain' }))) {
        fetch('/api/hk-event', { method: 'POST', body, keepalive: true }).catch(() => {});
      }
    } catch { /* 送れなくてもサイトの動きには影響させない */ }
  }
  // 最後に知らせた更新を読む。なければ null（文字の 'null' を書かない：クローラーが JS の中の文字を住所と見て /null を取りに来ていた。2026-11-22）
  const readShown = () => { const v = localStorage.getItem(SHOWN_KEY); return v ? JSON.parse(v) : null; };
  // 押さずにあとで見に来たか：最後に知らせた更新のページを、7日以内に開いたら1回だけ送る
  try {
    const last = readShown();
    if (last && !last.done && location.pathname === last.url && Date.now() - last.at < 7 * 864e5) {
      if (!last.clicked) report('later', last); // 押して来た分は click で送り済み
      last.done = true; localStorage.setItem(SHOWN_KEY, JSON.stringify(last));
    }
  } catch { /* 覚えられない環境では送らない */ }

  const load = () => { try { const v = localStorage.getItem(KEY); return v ? new Set<string>(JSON.parse(v)) : null; } catch { return null; } };
  const save = (s: Set<string>) => { try { localStorage.setItem(KEY, JSON.stringify([...s].slice(-300))); } catch { /* 覚えられない環境では毎回の判定だけ */ } };
  const today = () => new Date().toLocaleDateString('sv-SE', { timeZone: 'Asia/Tokyo' });
  const dayOf = (iso: string) => new Date(iso).toLocaleDateString('sv-SE', { timeZone: 'Asia/Tokyo' });

  function check() {
    if (!items.length || running || document.hidden) return;
    if (!seen) {
      seen = load();
      if (!seen) seen = new Set(items.filter((i) => dayOf(i.date) !== today()).map((i) => i.id)); // 初めて：今日より前の分は知らせ済み
      save(seen);
    }
    const fresh = items.filter((i) => !seen!.has(i.id));
    if (!fresh.length) return;
    fresh.forEach((i) => seen!.add(i.id)); save(seen);
    const it = fresh[0];
    const more = fresh.length > 1 ? `（ほかに ${fresh.length - 1} 件）` : '';
    report('shown', it);
    try { localStorage.setItem(SHOWN_KEY, JSON.stringify({ id: it.id, kind: it.kind, url: it.url, at: Date.now(), clicked: false, done: location.pathname === it.url })); } catch { /* なし */ }
    parade(HEAD[it.kind] + more, `${it.label}　${it.title}`, it.url, it, willTrip());
  }

  function parade(text: string, sub: string, url: string, it: Item, trip: boolean, preview = false) {
    running = true;
    const box = document.createElement('div'); box.className = 'hk-parade'; box.setAttribute('aria-hidden', 'true');
    const pb = document.createElement('div'); pb.className = 'hk-pb';
    const body = new Image(); body.src = IMG + 'body.webp'; body.alt = '';
    const face = new Image(); face.src = IMG + 'face-joy.webp'; face.alt = ''; face.className = 'hk-face';
    const faceOpen = new Image(); faceOpen.src = IMG + 'face-open.webp'; // 先に読み込んでおく
    pb.append(body, face); box.append(pb);
    const say = document.createElement('a'); say.className = 'hk-say'; say.href = url; say.setAttribute('role', 'status');
    const t = document.createElement('span'); t.textContent = text;
    const s = document.createElement('small'); s.textContent = sub;
    say.append(t, s);
    say.addEventListener('click', () => {
      if (preview) return;
      report('click', it);
      try { const last = readShown(); if (last && last.id === it.id) { last.clicked = true; localStorage.setItem(SHOWN_KEY, JSON.stringify(last)); } } catch { /* なし */ }
    });
    document.body.append(box, say);
    const RUN = reduce ? 4000 : 7500;
    trip = trip && !reduce; // 動きを減らす設定のときはコケない
    // コケるのは、行きか帰りの前半（速くなってきたところ）。倒れた体が画面の端からはみ出さないよう、真ん中より手前にする
    const TRIP_AT = trip ? RUN * ((Math.random() < .5 ? 0 : 1) + .25 + Math.random() * .15) / 2 : Infinity;
    const DUR = RUN + (trip ? TRIP_MS : 0);
    let t0: number | null = null, faceT = 0, tripDir = 1;
    const setFace = (f: 'joy' | 'open') => { const src = f === 'joy' ? IMG + 'face-joy.webp' : faceOpen.src; if (face.src !== src && !face.src.endsWith(src)) face.src = src; };
    const step = (now: number) => {
      if (t0 === null) t0 = now;
      const e = now - t0;
      // コケている間は、走りの時間を止める
      const inTrip = e >= TRIP_AT && e < TRIP_AT + TRIP_MS;
      const r = e < TRIP_AT ? e : inTrip ? TRIP_AT : e - TRIP_MS;
      const w = box.offsetWidth, span = Math.max(0, window.innerWidth - w - 16);
      if (!reduce) {
        // 左右に1往復。走る速さに強弱をつけ、跳ねながら行く
        const ph = (r / RUN) * 2, k = ph % 1, right = Math.floor(ph) % 2 === 0;
        const ease = k < .5 ? 2 * k * k : 1 - Math.pow(-2 * k + 2, 2) / 2;
        let x = 8 + span * (right ? ease : 1 - ease);
        let y = -Math.abs(Math.sin(r / 140)) * 10, rot = 0;
        let flip = 1, sy = 1;
        if (inTrip) {
          const q = e - TRIP_AT, dir = right ? 1 : -1;
          tripDir = dir;
          const P = tripPose(q);
          rot = P.rot * dir; x += P.dx * dir; y = P.dy; flip = P.flip; sy = P.sy;
          box.style.transformOrigin = P.rot > 0 ? (right ? '100% 100%' : '0% 100%') : '50% 100%'; // 前に倒れるときは前の足もと、立っているときは真ん中を軸に
          setFace(P.face);
        } else {
          // 起き上がったあとは、倒れて前へずれた分を少しずつ戻しながら走り出す（照れくさそうに、ゆっくり走り出す）
          if (e >= TRIP_AT + TRIP_MS) x += tripDir * 32 * Math.exp(-(e - TRIP_AT - TRIP_MS) / 500);
          if (e - faceT > 280) { faceT = e; setFace(face.src.endsWith('face-joy.webp') ? 'open' : 'joy'); }
        }
        box.style.transform = `translate(${x}px, ${y}px) rotate(${rot}deg)`;
        pb.style.transform = `scaleX(${(right ? 1 : -1) * flip}) scaleY(${sy})`;
      } else box.style.transform = 'translate(16px, 0)';
      if (e < DUR) requestAnimationFrame(step);
      else {
        box.remove();
        say.classList.add('hk-say-out');
        setTimeout(() => say.remove(), 300);
        running = false;
        if (!preview) check(); // 続けて知らせるものがあれば、もう一度
      }
    };
    requestAnimationFrame(step);
  }

  fetch('/updates.json', { cache: 'no-cache' })
    .then((r) => (r.ok ? r.json() : { items: [] }))
    .then((d) => {
      items = d.items ?? [];
      // 確かめ用（?hk=trip / ?hk=run）：いちばん新しい更新で1回走る。記録は送らず、知らせ済みにもしない
      const hk = new URLSearchParams(location.search).get('hk');
      if ((hk === 'trip' || hk === 'run') && items[0]) {
        const it = items[0];
        running = true;
        parade(HEAD[it.kind], `${it.label}　${it.title}`, it.url, it, hk === 'trip', true);
        return;
      }
      check();
    })
    .catch(() => { /* 一覧が読めないときは走らない */ });
  document.addEventListener('visibilitychange', () => { if (!document.hidden) check(); });
</script>

<style is:global>
  .hk-parade { position: fixed; z-index: 60; left: 0; bottom: calc(8px + env(safe-area-inset-bottom, 0px)); width: 92px; pointer-events: none; will-change: transform; transform-origin: 50% 100%; }
  .hk-pb { position: relative; aspect-ratio: 292 / 460; }
  .hk-pb img { display: block; width: 100%; height: auto; }
  .hk-pb .hk-face { position: absolute; left: 52.055%; top: 9.130%; width: 30.479%; height: 18.696%; }
  .hk-say { position: fixed; z-index: 61; left: 0; right: 0; margin: 0 auto; bottom: calc(168px + env(safe-area-inset-bottom, 0px));
    width: max-content; max-width: min(92vw, 520px); display: flex; flex-direction: column; gap: 2px;
    background: var(--dark, #242424); color: #fff; border-radius: 12px; padding: 10px 16px; text-align: center;
    font: 600 15px/1.5 Inter, 'Noto Sans JP', sans-serif; box-shadow: 0 6px 24px rgba(0,0,0,.25); text-decoration: none; transition: opacity .3s; }
  .hk-say small { font-size: 12.5px; font-weight: 400; opacity: .75; overflow: hidden; display: -webkit-box; -webkit-line-clamp: 2; -webkit-box-orient: vertical; }
  .hk-say:hover small { text-decoration: underline; }
  .hk-say:focus-visible { outline: 2px solid #fff; outline-offset: 2px; }
  .hk-say-out { opacity: 0; }
  @keyframes hk-pop { 0% { transform: scale(.6); opacity: 0; } 70% { transform: scale(1.04); opacity: 1; } 100% { transform: scale(1); } }
  @media (prefers-reduced-motion: no-preference) { .hk-say { animation: hk-pop .45s ease-out both; } }
  @media (max-width: 599px) { .hk-parade { width: 76px; } .hk-say { bottom: calc(140px + env(safe-area-inset-bottom, 0px)); font-size: 14px; } }
</style>
```

### ビルドと、手元のブラウザでの確かめ

```
$ npm run build
09:00:39 [@astrojs/sitemap] `sitemap-index.xml` created at `dist`
09:00:39 [build] 944 page(s) built in 39.26s
09:00:39 [build] Complete!
$ grep -c '"null"' dist/_astro/HakobuParade*.js
0
```

ハコブくんが走ること（`?hk=run`）と、あとで見に来たときに記録の印（done）が付くことを、作った dist を手元で開いて確かめた。

```python
import asyncio
from playwright.async_api import async_playwright
async def main():
  async with async_playwright() as p:
    b=await p.chromium.launch(); pg=await b.new_page(); logs=[]
    pg.on("console",lambda m:logs.append(m.text)); pg.on("response",lambda r:logs.append(f"{r.status} {r.url}"))
    await pg.goto("http://localhost:8765/record/day18.html?hk=run&p2m-notrack=1"); await pg.wait_for_timeout(3000)
    print("say:",await pg.locator(".hk-say").count(), pg.url)
    print("\n".join(l for l in logs if "Hakobu" in l or "updates" in l or "404" in l[:3] or "rror" in l))
    await b.close()
asyncio.run(main())
```

```
$ python3 /tmp/t2.py
say: 1 http://localhost:8765/record/day18.html?hk=run&p2m-notrack=1
404 http://localhost:8765/media/s-1920x1080_0f8a12e5-b434-4d40-8ed2-8306c22de9c9.webp
200 http://localhost:8765/_astro/HakobuParade.astro_astro_type_script_index_0_lang.7zSLlD3_.js
200 http://localhost:8765/updates.json
```

（/media/ の 404 は、手元のサーバーに R2 の画像がないため。）

```python
import asyncio
from playwright.async_api import async_playwright
async def main():
  async with async_playwright() as p:
    b=await p.chromium.launch(); pg=await b.new_page(); errs=[]; reqs=[]
    pg.on("pageerror",lambda e:errs.append(str(e))); pg.on("request",lambda r:reqs.append(r.url))
    await pg.goto("http://localhost:8765/record/day18.html?p2m-notrack=1")
    await pg.evaluate("localStorage.setItem('p2m-site-announced-last', JSON.stringify({id:'x',kind:'record',url:'/record/day18.html',at:Date.now(),clicked:false,done:false}))")
    await pg.reload(); await pg.wait_for_timeout(1500)
    print(await pg.evaluate("localStorage.getItem('p2m-site-announced-last')"), errs, [r for r in reqs if 'hk-event' in r or r.endswith('/null')])
    await b.close()
asyncio.run(main())
```

```
$ python3 /tmp/t3.py
{"id":"x","kind":"record","url":"/record/day18.html","at":1795305814034,"clicked":false,"done":true} [] []
```

main に入れて公開し（commit c633f94）、約2分半後に公開中のスクリプトが新しい版（7zSLlD3_）に替わり、`"null"` が0になったことを確かめた。

```
/_astro/HakobuParade.astro_astro_type_script_index_0_lang.7zSLlD3_.js 0
```


## 作業ログ ― コードの中の文字を住所と見て来るクローラーに 410 を返した

### worker/index.js の変更（差分）

サイトの入口の worker で、古い住所の転送（movedTo）のあと、静的なファイルを返す前に、住所に `{` `}` `` ` ``（またはそのエンコード %7B %7D %60）を含むものへ 410 を返す。クローラーの記録には 410 として残す。

```diff
diff --git a/worker/index.js b/worker/index.js
index 8be2d74..3405a3b 100644
--- a/worker/index.js
+++ b/worker/index.js
@@ -11,6 +11,7 @@
 // - /api/cr-stats        その記録を、どのクローラーが・いつ・どのページを読んだかで数えて見せる（2026-10-25）
 // - /api/kpi-stats       主に見る3つの数字（AI の依頼読み・AI のリンクからの来訪・サイト名の検索）を日ごと・週ごとに見せる（worker/kpi.js。2026-11-06）
 // - /mcp/{鍵}            サイトの計測を Claude につなぐ部品（MCP サーバー。worker/mcp.js。2026-11-06）
+// - { } ` を含む住所   記事のコードの中の文字をクローラーが住所と見て来たもの。410 を返す（2026-11-22）
 // - 5分ごとの scheduled  SNS の予約投稿の時刻が来ていたら GitHub Actions を起こす（worker/sns_cron.js）。前の日の3つの数字がまだなければ集計して残す（worker/kpi.js）
 //
 // 守り（2026-10-23）
@@ -44,6 +45,15 @@ export default {
       } catch { /* 数え損ねても転送はする */ }
       return secured(Response.redirect(to.toString(), 301));
     }
+    // 記事に載せたコードの中の文字（src="{src}"・${MSG_URL} など）を、クローラーが住所と見て取りに来る（2026-11-22。64記事分）。
+    // ページではないので 404 より「もうない」の 410 を返し、取りに来る回数を減らす。{ } ` を含むファイルはサイトにない
+    if (/[{}`]|%7B|%7D|%60/i.test(url.pathname)) {
+      try {
+        const bot = crawlerOf(request, url);
+        if (bot) ctx.waitUntil(crRecord(request, env, url, bot, 410).catch(() => {}));
+      } catch { /* 数え損ねても返す */ }
+      return secured(new Response('Gone', { status: 410, headers: { 'x-robots-tag': 'noindex', 'content-type': 'text/plain; charset=utf-8' } }));
+    }
     let res = await env.ASSETS.fetch(request);
     // 記事の全文ページ（/record/{slug}.md。2026-11-01）は、検索では記事ページを正とする（canonical）。文字コードも付ける
     const full = res.ok && url.pathname.match(/^\/record\/([^/]+)\.md$/);
```

```
$ node --check worker/index.js && echo syntax-ok
syntax-ok
$ node -e 'const re=/[{}`]|%7B|%7D|%60/i; for (const p of [...]) console.log(re.test(p)?410:"pass",p)'
410 /files/LOG502/%7Bsrc%7D
410 /record/%24%7BMSG_URL%7D
410 /files/LOG511/%7B%60
pass /record/day18
pass /files/LOG502/02_sec12.py.txt
pass /null
pass /files/LOG502/%27%20%2B%20LOGO%20%2B%20%27
```

`' + LOGO + '` の形（`/files/LOG502/%27%20%2B%20LOGO%20%2B%20%27`）は `{` を含まないので対象外のまま。数が少ないので、今回は広げなかった。

- ねらい：コードの中の文字から生まれた住所に、「もうない」とはっきり返す
- 変わったこと：`{` `}` `` ` `` を含む住所は、404 ではなく 410 を返す。ほかの住所の返し方は変えていない
- 見込める効果：GPTBot・ClaudeBot・Amazonbot が同じ住所を取りに来る回数が減る見込み。ただし Google は 404 と 410 をほぼ同じに扱う（下の Codex の指摘）。来週のクローラーの記録で、410 の住所への再訪が減るかを見る

### Codex のレビュー（依頼箱の依頼255）

サイトの決まりでは、公開後に戻しにくい変更（住所・転送など）は外のレビューを挟む。変更を枝 crawler-410 に置き、依頼箱（Mac の上で Claude Code に依頼を渡して自動で回す仕組み）から [Codex](https://openai.com/codex/)（OpenAI のコードの AI）にレビューを頼んだ。依頼箱の Claude Code は Codex を起動するだけで、レビューそのものはしない。

#### 依頼255（依頼箱に置いた依頼文）

````markdown
---
作業フォルダ: /Users/shimazueiichi/r2r2r-scripts
上限時間: 60
---
# Codex に、サイトの worker で { } ` を含む住所に 410 を返す変更をレビューしてもらう

あなた（Claude Code）の仕事は **Codex を起動してレビューを任せることだけ**。レビューそのものはしない。r2r2r-scripts を含め、どのファイルも変更しない。

## 手順

1. Codex CLI があるか確かめる：`command -v codex || ls ~/.npm-global/bin/codex`。見つからない・ログインが切れている場合は、何もせずに止めて、報告の「決めてほしいこと」にその旨を書く。
2. 次をそのまま実行する（依頼書の中身をあなたが要約・書き換えしない）：

```bash
REVIEW_DIR="$HOME/Library/Mobile Documents/com~apple~CloudDocs/デスクトップ/ADAPT DESIGN/じぶんの/PixelstoMotors/_crawler410_review_20261122"
find "$REVIEW_DIR" -type f -exec brctl download {} \; 2>/dev/null
git clone -q --depth 1 -b crawler-410 https://github.com/PixelstoMotors/p2m-site "$REVIEW_DIR/p2m-site" 2>&1 | tail -3
codex exec --skip-git-repo-check -C "$REVIEW_DIR" -s workspace-write \
  "codex_review_request.md を読んで、その指示どおりにレビューし、報告を codex_report.md としてこのフォルダに書いてください。crawler410.diff と p2m-site/ は読むだけで、書いてよいのはこの報告ファイルだけです。" \
  > "$REVIEW_DIR/_codex_run.log" 2>&1
```

   clone に失敗した場合は、p2m-site なしで codex を動かしてよい（crawler410.diff だけでレビューさせる）。そのことを報告に書く。
3. 終わったら `codex_report.md` ができたか確かめる。
   - できていれば、報告には「できた」とそのパスと、Codex の報告の全文を写す。
   - できていなければ、`_codex_run.log` の末尾 40 行を報告に写す。

## 守ること

- Codex の報告の中身をあなたが評価・手直ししない。
- `-s workspace-write` を外さない・制限を外す指定を足さない。
- 失敗しても自分でレビューを代わりにやらない。

報告の最後は「判定：合格／止めた（決めてほしいことあり）／失敗」のどれか1つで終える。
````

#### codex_review_request.md（Codex に渡したレビューの依頼）

```markdown
# レビュー依頼：worker で { } ` を含む住所に 410 を返す

## 対象
- 差分：`crawler410.diff`（p2m-site の main と枝 crawler-410 の差）
- 全体：`p2m-site/`（枝 crawler-410 を clone したもの。`worker/index.js` の fetch）

## 背景
- 記事に載せたコード（`public/files/LOG{N}/*.txt`・`LOG{N}_full.md`・`/record/{slug}.md`）の中の `src="{src}"`・`${MSG_URL}`・`{s.img.startsWith('/')` などを、GPTBot・ClaudeBot・Amazonbot が住所と見て取りに来て、404 が週に数十種類出ている（64記事分）。
- コードは全文を載せる決まりなので、中身は変えない。代わりに、住所に `{` `}` `` ` ``（またはそのエンコード %7B %7D %60）を含むものへ 410 を返し、取りに来る回数を減らしたい。
- サイトに `{ } `` ` `` を名前に含むファイルはない（`find public src/pages -name '*[{}\`]*'` が空）。

## 見てほしいこと
1. 正しいページ・ファイル・API・転送（`movedTo`・`/pixelstomotors/`・`/api/`・`/media/`・`/mcp/`）を誤って 410 にしてしまう場合がないか。特に、クエリ文字列（?via=… や ?key=…）は `url.pathname` に入らないので対象外のはずだが、確かめてほしい。
2. 置いた位置（movedTo の転送のあと、ASSETS.fetch の前）が正しいか。
3. 410 にするのが 404 より悪くなる点（検索・AI のクローラーの扱い）がないか。
4. クローラーの記録（crRecord）に 410 で残す書き方に問題がないか。

## 報告の形
- 指摘ごとに「重さ（必須／推奨／据え置き）・場所・中身・直し方」
- 最後に「判定：このまま出してよい／直してから出す」
```

#### codex_report.md（Codex の報告・全文）

```markdown
# crawler410 レビュー報告

## 1. 一部の住所は 410 の処理を通らない

- **重さ：推奨**
- **場所：** `p2m-site/wrangler.jsonc` の `assets.run_worker_first`、`worker/index.js:32–57`
- **中身：** `/api/`、`/media/`、`/mcp/` は判定より先にそれぞれの処理へ渡される。`/pixelstomotors/` はまず 301 で接頭辞を外し、その転送先が通常のパスなら次のリクエストで 410 になる。また、`/_astro/`、`/site/`、`/og/`、`/thumbs/`、`/embeds/`、`/sim/`、`/favicon` で始まるパスは `run_worker_first` の除外対象で、静的アセットがない場合も Worker の 410 判定を通らない。したがって「文字を含むすべての住所に 410」ではない。優先処理は既存の API、R2 のファイル、MCP の鍵、旧 URL の転送を壊さないために有益だが、これらの経路に誤認 URL がある場合は今回の対策は届かない。Cloudflare の[ルーティング設定の説明](https://developers.cloudflare.com/workers/static-assets/routing/worker-script/)でも、否定パターンは Worker の先行実行から除外される。
- **直し方：** この範囲を仕様として明記し、実際の 404 記録に除外経路があるか確認する。必要な経路だけ、既存の正常なファイルや API を壊さない方法で別途対応する。無条件に判定を先頭へ移す必要はない。

## 2. 410 の記録はページ・テキストと認識されたものに限られる

- **重さ：推奨**
- **場所：** `worker/index.js:50–54`、`worker/index.js:580–592`
- **中身：** `crRecord` の呼び方、非同期の `ctx.waitUntil`、失敗時に応答を妨げない扱い、ステータス 410 の保存と集計は既存の 301・通常応答と整合している。一方 `crawlerOf` は GET・HEAD、既知の User-Agent、`CR_PAGE` に合うパスに限定する。例えば `/files/LOG410/{src}.png` は 410 を返すが末尾が `.png` なので記録されない。対象外経路も記録されない。よって 410 の記録だけでは対策対象の全アクセス数や削減効果を測れない。パスは従来どおり先頭 160 文字に切られる。
- **直し方：** 全 410 を観測したい場合は、410 専用に User-Agent の判定とパス拡張子の判定を分け、既知のクローラーに限って記録する方法を検討する。現在のページ・テキスト限定で十分なら、その制限を明記して据え置く。

## 3. 410 でクロールが減るとは限らない

- **重さ：据え置き**
- **場所：** `worker/index.js:47–55`
- **中身：** Google は [404 と 410 を同じように扱い](https://developers.google.com/crawling/docs/troubleshooting/http-status-codes)、どちらも対象 URL をインデックスから除外する。したがって Google について 410 が 404 よりクロールを減らすとは言えない。GPTBot・ClaudeBot・Amazonbot がこの変更でどの程度再訪を減らすかも確認できず、効果は保証できない。410 は永続的に利用できないことを表すため、今後この文字を含む正当なパスを作る場合はその URL が除外されるリスクがある。`X-Robots-Tag: noindex` が付いていても 410 自体で取得は失敗する。
- **直し方：** 410 は対象が今後も存在しないという前提で採用し、公開後に対象 URL の応答とアクセス推移を観測する。将来該当文字を含む正規パスを追加するときは判定を見直す。

## 確認結果

- `new URL(request.url)` の `pathname` のみを正規表現で検査するため、正常なパスの `?via={...}`、`?key=%7B...%7D` などのクエリ文字列だけで 410 にはならない。大文字・小文字の異なる `%7B`、`%7D`、`%60` も検出する。
- `movedTo` の後に置くことで、既存の移転先が優先される。特に `/files/` のダッシュ修正は該当文字を含むパスでも先に 301 になる。`ASSETS.fetch` の前なので、Worker が処理する通常経路では対象を 410 にできる。この優先順位による既存の正常なページ、転送、API の誤った 410 は確認できなかった。
- ファイル名に該当文字がないという依頼文の前提と、静的なルートの構成に基づく確認であり、本番 R2 の全キーや実際の Cloudflare 上の応答は検証していない。

**判定：このまま出してよい**
```

```
2026-11-22T09:05:53 開始 20261122_255_Codexにサイトのworkerの410をレビューしてもらう.md［列：コード］
2026-11-22T09:09:31 完了 20261122_255_Codexにサイトのworkerの410をレビューしてもらう.md → 結果/20261122_255_Codexにサイトのworkerの410をレビューしてもらう_20261122_0905.md
```

判定は「このまま出してよい」。指摘の1（/_astro/ や /media/ などはこの判定を通らない）は、今回の404がすべて /files/ と /record/ なので影響しない。指摘の3（Google は 404 と 410 を同じに扱う）は、上の「見込める効果」に書いた。main に入れて公開した（commit b568594）。

### 直したあとの worker/index.js（全文）

```javascript
// サイトの入口。ほとんどのページは作っておいた静的ファイル（dist/）をそのまま返す。
// ここで処理するのは3つだけ:
// - /pixelstomotors/…   旧 URL の形。/pixelstomotors を外した URL へ 301 で転送する
// - /media/{ファイル名}  記事・4コマの画像と動画を R2（p2m-media）から返す（GitHub には入れないため）
// - /api/message         メッセージフォームの送信を R2（p2m-messages）に保存し、メールで知らせる
// - /api/hk-event        更新を知らせるハコブくんが「出た・押された・あとで見に来た」を R2（p2m-messages の hk-events/）に1件ずつ残す
// - /api/hk-stats        その記録を日ごと・更新ごとに数えて見せる（数だけ。誰かは分からない）
// - /api/ev              サイトの使われ方（1回のページ表示ごとの、読んだ深さ・押したもの・迷い）を R2（p2m-messages の ev/）に残す
// - /api/ev-stats        その記録を週ごと・ページごとに数えて見せる（数だけ。誰かは分からない）
// - ページ・llms.txt・全文の Markdown など  静的ファイルを返す。検索エンジン・AI のクローラーが読みに来たら、R2（p2m-messages の cr/）に1件ずつ残す
// - /api/cr-stats        その記録を、どのクローラーが・いつ・どのページを読んだかで数えて見せる（2026-10-25）
// - /api/kpi-stats       主に見る3つの数字（AI の依頼読み・AI のリンクからの来訪・サイト名の検索）を日ごと・週ごとに見せる（worker/kpi.js。2026-11-06）
// - /mcp/{鍵}            サイトの計測を Claude につなぐ部品（MCP サーバー。worker/mcp.js。2026-11-06）
// - { } ` を含む住所   記事のコードの中の文字をクローラーが住所と見て来たもの。410 を返す（2026-11-22）
// - 5分ごとの scheduled  SNS の予約投稿の時刻が来ていたら GitHub Actions を起こす（worker/sns_cron.js）。前の日の3つの数字がまだなければ集計して残す（worker/kpi.js）
//
// 守り（2026-10-23）
// - 数の表（/api/hk-stats・/api/ev-stats・/api/cr-stats）は、鍵（Cloudflare の秘密の値 STATS_KEY）を付けたときだけ見られる。鍵がなければ 404
// - 送信の口（/api/message・/api/hk-event・/api/ev）は、このサイトのページから送られたものだけ受け取る
// - 同じ送信元からの送りすぎは、Cloudflare の流量制限（wrangler.jsonc の ratelimits）で断る。送信元の IP アドレスは数えるためだけに使い、記録しない
// - フォームには人には見えない欄（website）を置き、そこが埋まった送信は保存せずに受け取ったふりをする（自動投稿の対策）
// - このファイルが返す応答には、内容の種類を推測させない指定（nosniff）を付ける。ページ側の指定は public/_headers
import { EmailMessage } from 'cloudflare:email';
import { snsCron } from './sns_cron.js';
import { kpiCron, kpiRange, todayJst, addDays } from './kpi.js';
import { handleMcp } from './mcp.js';
import { gscRefresh } from './gsc.js';

export default {
  async fetch(request, env, ctx) {
    const url = new URL(request.url);
    if (url.pathname.startsWith('/mcp/')) return secured(await handleMcp(request, env, url, { evStats, crStats, hkStats }));
    if (url.pathname.startsWith('/api/') || url.pathname.startsWith('/media/') || url.pathname === '/pixelstomotors' || url.pathname.startsWith('/pixelstomotors/')) {
      return secured(await route(request, env, url));
    }
    // 古い住所・まちがった住所への訪問を、今のページへ恒久転送する（2026-10-30。クローラーの「返せなかったページ」から）
    const moved = movedTo(url.pathname);
    if (moved) {
      const to = new URL(moved, url);
      to.search = url.search;
      // クローラーの記録にも残す（返した結果 301。どの古い住所に来たかが分かるように）
      try {
        const bot = crawlerOf(request, url);
        if (bot) ctx.waitUntil(crRecord(request, env, url, bot, 301).catch(() => {}));
      } catch { /* 数え損ねても転送はする */ }
      return secured(Response.redirect(to.toString(), 301));
    }
    // 記事に載せたコードの中の文字（src="{src}"・${MSG_URL} など）を、クローラーが住所と見て取りに来る（2026-11-22。64記事分）。
    // ページではないので 404 より「もうない」の 410 を返し、取りに来る回数を減らす。{ } ` を含むファイルはサイトにない
    if (/[{}`]|%7B|%7D|%60/i.test(url.pathname)) {
      try {
        const bot = crawlerOf(request, url);
        if (bot) ctx.waitUntil(crRecord(request, env, url, bot, 410).catch(() => {}));
      } catch { /* 数え損ねても返す */ }
      return secured(new Response('Gone', { status: 410, headers: { 'x-robots-tag': 'noindex', 'content-type': 'text/plain; charset=utf-8' } }));
    }
    let res = await env.ASSETS.fetch(request);
    // 記事の全文ページ（/record/{slug}.md。2026-11-01）は、検索では記事ページを正とする（canonical）。文字コードも付ける
    const full = res.ok && url.pathname.match(/^\/record\/([^/]+)\.md$/);
    if (full) {
      res = new Response(res.body, res);
      res.headers.set('Content-Type', 'text/markdown; charset=utf-8');
      res.headers.set('Link', `<https://pixelstomotors.com/record/${full[1]}>; rel="canonical"`);
    }
    // 検索エンジン・AI のクローラーが読みに来たか（記録の失敗でページを止めない）
    // 記事の「AIで読む」から来た全文ページ（?via=chatgpt など）は、名乗りが一覧にない読み手（Gemini など）も「その他」として残す（2026-11-01）
    try {
      // TOP の「このサイトの楽しみ方」から来た /llms.txt?via=… も同じく数える（2026-11-03）
      const via = (/^\/record\/[^/]+\.md$/.test(url.pathname) || (/^\/record\/[^/.]+$/.test(url.pathname) && url.searchParams.get('via') === 'gemini') || url.pathname === '/llms.txt' || url.pathname === '/llms' || url.pathname === '/llms.html') && AI_VIA.has(url.searchParams.get('via') || '') ? url.searchParams.get('via') : '';
      const bot = crawlerOf(request, url) || (via ? 'その他' : null);
      if (bot) ctx.waitUntil(crRecord(request, env, url, bot, res.status, via).catch(() => {}));
    } catch { /* 数え損ねてもページは返す */ }
    return res;
  },
  // 5分ごと（wrangler.jsonc の triggers）：SNS の予約投稿の時刻が来ていたら、GitHub Actions を起こす（worker/sns_cron.js）
  async scheduled(event, env, ctx) {
    ctx.waitUntil(snsCron(env, event.scheduledTime).then((m) => console.log('sns-cron:', m), (e) => console.error('sns-cron:', e.message)));
    // 前の日の分を作ったとき（1日1回）だけ、Search Console からサイト名の検索の数も取り直す（worker/gsc.js）
    ctx.waitUntil(kpiCron(env).then(async (m) => {
      console.log(m);
      if (m.startsWith('kpi: made')) console.log('gsc:', JSON.stringify(await gscRefresh(env)));
    }).catch((e) => console.error('kpi-cron:', e.message)));
  },
};

// 転送先の決まった古い住所
const MOVED = {
  // 今は使っていないページ（Dify で AI エージェントを動かしていた頃のもの）。トップへ（エイイチ 2026-11-02）
  '/ai-agent': '/',
  '/ai-agent/': '/',
  '/manga': '/manga-archive',
  '/manga/': '/manga-archive',
  '/record/precision-is-not-learning': '/record/precision-is-not-learning-so101',
  '/record/precision-is-not-learning/': '/record/precision-is-not-learning-so101',
  // LOG518 を LOG なしのガイドへ移した（エイイチ 2026-11-15）。全文ページ（.md）はガイドにないので、ガイドのページへ
  '/record/generalist-ai-robot-foundation-model-gen-1-5-one-shot': '/guide/generalist-ai-gen-1-5',
  '/record/generalist-ai-robot-foundation-model-gen-1-5-one-shot/': '/guide/generalist-ai-gen-1-5',
  '/record/generalist-ai-robot-foundation-model-gen-1-5-one-shot.md': '/guide/generalist-ai-gen-1-5',
  // 元の HTML があったときに Cloudflare が案内していた別名も（2026-11-15 codex のレビュー A1）
  '/record/generalist-ai-robot-foundation-model-gen-1-5-one-shot.html': '/guide/generalist-ai-gen-1-5',
  '/record/generalist-ai-robot-foundation-model-gen-1-5-one-shot/index': '/guide/generalist-ai-gen-1-5',
  '/record/generalist-ai-robot-foundation-model-gen-1-5-one-shot/index.html': '/guide/generalist-ai-gen-1-5',
};
// 1桁の話数で来たとき、0を付けた住所へ転送するのは、ページがある話だけ（ない話を転送しても 404 になるだけなので。2026-10-30 の codex のレビュー）
const EPISODES_1_9 = { manga: new Set(['1', '2', '3', '4', '5', '6', '7', '9']), 'english-4-koma': new Set(['1', '2', '3', '4', '7', '9']) };
function movedTo(path) {
  if (MOVED[path]) return MOVED[path];
  // 記事の素材のファイル名の「--」が「—」（「-」が「–」）に化けた住所（10/30 に直す前のリンク）。元のファイル名へ（2026-11-02）
  if (path.startsWith('/files/') && /%E2%80%9[34]/i.test(path)) return path.replace(/%E2%80%94/gi, '--').replace(/%E2%80%93/gi, '-');
  // シリーズのページは、前は /prototype1〜6 だった（エイイチ 2026-10-30）。同じ番号の /series へ
  const sp = path.match(/^\/prototype([1-6])\/?$/);
  if (sp) return `/series${sp[1]}`;
  // 4コマの話数は2桁（ep09）。1桁（ep9）で来たら0を付けた住所へ
  const m = path.match(/^\/(manga|english-4-koma)\/ep([1-9])$/);
  if (m && EPISODES_1_9[m[1]].has(m[2])) return `/${m[1]}/ep0${m[2]}`;
  return '';
}

async function route(request, env, url) {
    // 旧 URL の形（/pixelstomotors/…）で来たら、/pixelstomotors を外した URL へ恒久転送する
    if (url.pathname === '/pixelstomotors' || url.pathname.startsWith('/pixelstomotors/')) {
      const to = new URL(url.pathname.slice('/pixelstomotors'.length) || '/', url);
      to.search = url.search;
      return Response.redirect(to.toString(), 301);
    }
    if (url.pathname.startsWith('/media/')) return media(request, env, url);
    if (url.pathname === '/api/message') return guarded(request, env, url, 'RL_MESSAGE', () => message(request, env));
    if (url.pathname === '/api/hk-event') return guarded(request, env, url, 'RL_EVENT', () => hkEvent(request, env));
    if (url.pathname === '/api/ev') return guarded(request, env, url, 'RL_EVENT', () => evRecord(request, env, url));
    if (url.pathname === '/api/hk-stats') return (await statsAllowed(request, env, url)) ? hkStats(request, env, url) : notFound();
    if (url.pathname === '/api/ev-stats') return (await statsAllowed(request, env, url)) ? evStats(request, env, url) : notFound();
    if (url.pathname === '/api/cr-stats') return (await statsAllowed(request, env, url)) ? crStats(request, env, url) : notFound();
    if (url.pathname === '/api/kpi-stats') return (await statsAllowed(request, env, url)) ? kpiStats(request, env, url) : notFound();
    return env.ASSETS.fetch(request);
}

const notFound = () => new Response('Not Found', { status: 404, headers: { 'x-robots-tag': 'noindex' } });

// worker が返す応答に、内容の種類を推測させない指定などを付ける（転送の応答は見出しを変えられないので作り直す）
function secured(res) {
  const r = new Response(res.body, res);
  r.headers.set('x-content-type-options', 'nosniff');
  r.headers.set('referrer-policy', 'strict-origin-when-cross-origin');
  return r;
}

// このサイトのページから送られたものか（ブラウザは POST に Origin を付ける。付かないときは Sec-Fetch-Site で見る）
function sameSite(request, url) {
  const o = request.headers.get('origin');
  if (o) { try { return new URL(o).host === url.host; } catch { return false; } }
  return request.headers.get('sec-fetch-site') === 'same-origin';
}

// 送信の口の共通の守り：POST 以外・ほかのサイトから・送りすぎを断ってから処理する
async function guarded(request, env, url, limiter, handle) {
  if (request.method !== 'POST') return new Response('Method Not Allowed', { status: 405 });
  if (!sameSite(request, url)) return new Response(null, { status: 403 });
  const rl = env[limiter];
  if (rl) {
    try {
      const { success } = await rl.limit({ key: request.headers.get('cf-connecting-ip') || 'unknown' });
      if (!success) return new Response(null, { status: 429, headers: { 'retry-after': '60' } });
    } catch { /* 流量制限が使えないときは通す（サイトの動きを止めない） */ }
  }
  return handle();
}

// 数の表を見てよいか。鍵は ?key=… か Authorization: Bearer … で渡す。鍵が設定されていなければ誰にも見せない
async function statsAllowed(request, env, url) {
  const key = env.STATS_KEY;
  if (!key) return false;
  const given = url.searchParams.get('key') || (request.headers.get('authorization') || '').replace(/^Bearer\s+/i, '');
  if (!given) return false;
  const [a, b] = await Promise.all([given, key].map((x) => crypto.subtle.digest('SHA-256', new TextEncoder().encode(x))));
  return crypto.subtle.timingSafeEqual(a, b);
}

async function media(request, env, url) {
  if (request.method !== 'GET' && request.method !== 'HEAD') return new Response('Method Not Allowed', { status: 405 });
  const key = decodeURIComponent(url.pathname.slice('/media/'.length));
  if (!key || key.includes('/') || key.startsWith('.')) return new Response('Not Found', { status: 404 });
  // 動画の途中から再生できるよう、Range（一部だけの取得）にも答える
  const obj = await env.MEDIA.get(key, { range: request.headers, onlyIf: request.headers });
  if (obj === null) return new Response('Not Found', { status: 404 });
  const headers = new Headers();
  obj.writeHttpMetadata(headers);
  headers.set('etag', obj.httpEtag);
  headers.set('accept-ranges', 'bytes');
  headers.set('cache-control', 'public, max-age=86400');
  if (!('body' in obj) || !obj.body) return new Response(null, { status: 304, headers });
  let status = 200;
  if (obj.range && request.headers.has('range')) {
    // R2 の range は {offset, length} か {suffix}。キーがあっても値が undefined のことがあるため、値で判定する
    // （'suffix' in r で判定すると NaN になり、ブラウザが動画を再生しなかった）
    const r = obj.range;
    let start, end;
    if (typeof r.suffix === 'number') {
      start = Math.max(0, obj.size - r.suffix);
      end = obj.size - 1;
    } else {
      start = typeof r.offset === 'number' ? r.offset : 0;
      end = typeof r.length === 'number' ? Math.min(obj.size - 1, start + r.length - 1) : obj.size - 1;
    }
    headers.set('content-range', `bytes ${start}-${end}/${obj.size}`);
    headers.set('content-length', String(end - start + 1));
    status = 206;
  }
  return new Response(request.method === 'HEAD' ? null : obj.body, { status, headers });
}

// メッセージフォームの「ご相談の種類」。値はフォーム（src/pages/message.astro）の option と同じ
const TOPICS = { 'physical-ai': 'フィジカルAI・ロボット', ai: 'AI活用・仕組みづくり', media: '取材・登壇', other: 'その他' };

async function message(request, env) {
  if (request.method !== 'POST') return new Response('Method Not Allowed', { status: 405 });
  let d;
  try { d = await request.json(); } catch { return json({ ok: false, error: '送信の形が正しくありません' }, 400); }
  // 人には見えない欄が埋まっていたら自動投稿。保存も通知もせず、受け取ったふりをする
  if (String(d.website || '').trim()) return json({ ok: true });
  const name = String(d.name || '').trim().slice(0, 200);
  const email = String(d.email || '').trim().slice(0, 300);
  const body = String(d.body || '').trim().slice(0, 10000);
  // 相談の種類（フォームの選択肢と同じ値）。古いページから送られて種類がないときは「未選択」として受け取る
  const topic = Object.hasOwn(TOPICS, d.topic) ? d.topic : '';
  if (!name || !email || !body || !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email) || d.agree !== true) {
    return json({ ok: false, error: '入力を確かめてください' }, 400);
  }
  const at = new Date().toISOString();
  const key = `${at.replace(/[:.]/g, '-')}-${crypto.randomUUID().slice(0, 8)}.json`;
  await env.MESSAGES.put(key, JSON.stringify({ at, name, email, topic, body, ua: request.headers.get('user-agent') || '' }, null, 1),
    { httpMetadata: { contentType: 'application/json' } });
  // 保存できたら、メールで知らせる。メールが送れなくても、保存は済んでいるので送信者には成功と返す
  try {
    await notify(env, { at, name, email, topic, body, key });
  } catch (e) {
    console.error('メール通知に失敗', e && e.message);
  }
  return json({ ok: true });
}

// 届いたメッセージを MAIL（Cloudflare の送信の仕組み）でエイイチのメールへ送る。
// 送り元はこのドメインの form@pixelstomotors.com。返信先（Reply-To）に送信者のメールを入れる
async function notify(env, m) {
  if (!env.MAIL) return;
  const from = 'form@pixelstomotors.com';
  const to = 'pixelstomotors@adaptdesign.jp';
  const topicName = Object.hasOwn(TOPICS, m.topic) ? TOPICS[m.topic] : '未選択';
  const subject = `[Pixels to Motors] ${topicName}: ${m.name}`;
  const text = [
    `種類: ${topicName}`,
    `名前: ${m.name}`,
    `メール: ${m.email}`,
    `受け取り: ${m.at}`,
    `保存先: p2m-messages/${m.key}`,
    '',
    m.body,
  ].join('\n');
  const raw = [
    `From: Pixels to Motors <${from}>`,
    `To: <${to}>`,
    `Reply-To: ${encodeWord(m.name)} <${m.email}>`,
    `Subject: ${encodeWord(subject)}`,
    `Date: ${new Date(m.at).toUTCString()}`,
    `Message-ID: <${m.key.replace(/\.json$/, '')}@pixelstomotors.com>`,
    'MIME-Version: 1.0',
    'Content-Type: text/plain; charset=utf-8',
    'Content-Transfer-Encoding: base64',
    '',
    base64(text),
  ].join('\r\n');
  await env.MAIL.send(new EmailMessage(from, to, raw));
}

// 日本語の見出しをメールの決まり（RFC 2047）で符号化する。見出しは1行に収めるので改行を入れない
function encodeWord(s) {
  return `=?utf-8?B?${base64(s, false)}?=`;
}

// fold=true のとき、本文用に 76 文字ごとに改行を入れる（見出しに入れると途中で切れて壊れる）
function base64(s, fold = true) {
  const bytes = new TextEncoder().encode(s);
  let bin = '';
  for (const b of bytes) bin += String.fromCharCode(b);
  const out = btoa(bin);
  return fold ? out.replace(/(.{76})/g, '$1\r\n') : out;
}

function json(o, status = 200) {
  return new Response(JSON.stringify(o), { status, headers: { 'content-type': 'application/json; charset=utf-8' } });
}

// ---------- 更新を知らせるハコブくんの効果の記録 ----------
// 1件 = 1つの空のファイル。中身は持たず、何が起きたかを付箋（customMetadata）に書く（一覧のときに中身を読まずに数えられる）
// 残すのは「出た(shown)／押された(click)／押さずにあとで見に来た(later)」「どの更新か」「どのページで」「画面の幅（pc/sp）」「日付」だけ。
// IP アドレス・ブラウザの種類・Cookie・見た人を見分ける番号は残さない
const HK_EVENTS = new Set(['shown', 'click', 'later']);
const HK_KINDS = new Set(['record', 'manga', 'issues']);
async function hkEvent(request, env) {
  if (request.method !== 'POST') return new Response('Method Not Allowed', { status: 405 });
  let d;
  try { d = JSON.parse((await request.text()).slice(0, 2000)); } catch { return new Response(null, { status: 400 }); }
  const e = String(d.e || ''), kind = String(d.kind || '');
  const id = String(d.id || '').slice(0, 160), path = String(d.path || '').slice(0, 160), w = d.w === 'sp' ? 'sp' : 'pc';
  if (!HK_EVENTS.has(e) || !HK_KINDS.has(kind) || !/^(record|manga|issues):[\w.-]+$/.test(id) || !path.startsWith('/')) {
    return new Response(null, { status: 400 });
  }
  const at = new Date();
  const day = new Date(at.getTime() + 9 * 3600e3).toISOString().slice(0, 10); // 日本時間の日付
  const key = `hk-events/${day}/${at.getTime()}-${crypto.randomUUID().slice(0, 8)}`;
  // k：b＝機械（クローラー・自動のブラウザの名乗り、navigator.webdriver）／n＝機械の印なし。2026-10-28 から（それより前は印なし＝o）
  const k = evKind(request, { wd: d.wd, hl: d.hl, u: 1 }) === 'b' ? 'b' : 'n';
  await env.MESSAGES.put(key, '', { customMetadata: { e, kind, id, path, w, k } });
  return new Response(null, { status: 204 });
}

async function hkStats(request, env, url) {
  if (request.method !== 'GET') return new Response('Method Not Allowed', { status: 405 });
  // who=notbot で機械の印のない記録だけ、who=bot で機械だけ、who=old で印を付ける前（2026-10-28 より前）の記録だけを数える（なければ全部）
  const WHO = { notbot: 'n', bot: 'b', old: 'o' };
  const who = WHO[url.searchParams.get('who')] ? url.searchParams.get('who') : '';
  const rows = [];
  const kinds = new Map();
  let cursor;
  do {
    const r = await env.MESSAGES.list({ prefix: 'hk-events/', cursor, include: ['customMetadata'], limit: 1000 });
    for (const o of r.objects) {
      const m = o.customMetadata || {};
      const day = o.key.split('/')[1], k = m.k || 'o';
      const kv = kinds.get(k) || { shown: 0, click: 0, later: 0 }; kv[m.e] = (kv[m.e] || 0) + 1; kinds.set(k, kv);
      if (who && k !== WHO[who]) continue;
      rows.push({ day, ...m });
    }
    cursor = r.truncated ? r.cursor : undefined;
  } while (cursor);
  const add = (map, k, ev) => { const v = map.get(k) || { shown: 0, click: 0, later: 0 }; v[ev] = (v[ev] || 0) + 1; map.set(k, v); return v; };
  // 週は月曜はじまり（日本時間の日付から、その週の月曜の日付を出す）
  const weekOf = (day) => { const d = new Date(day + 'T00:00:00Z'); d.setUTCDate(d.getUTCDate() - ((d.getUTCDay() + 6) % 7)); return d.toISOString().slice(0, 10); };
  const byDay = new Map(), byWeek = new Map(), byItem = new Map(), byW = new Map();
  for (const r of rows) { add(byDay, r.day, r.e); add(byWeek, weekOf(r.day), r.e); add(byItem, r.id, r.e); add(byW, r.w, r.e); }
  const KIND_JA = { n: '機械の印なし', b: '機械', o: '印なし（10/28より前）' };
  const data = {
    total: rows.length,
    who: who || null,
    byKind: ['n', 'b', 'o'].filter((k) => kinds.has(k)).map((k) => ({ kind: KIND_JA[k], ...kinds.get(k) })),
    byWeek: [...byWeek].sort((a, b) => b[0].localeCompare(a[0])).map(([week, v]) => {
      const end = new Date(week + 'T00:00:00Z'); end.setUTCDate(end.getUTCDate() + 6);
      return { week: `${week} 〜 ${end.toISOString().slice(5, 10)}`, ...v };
    }),
    byDay: [...byDay].sort((a, b) => b[0].localeCompare(a[0])).map(([day, v]) => ({ day, ...v })),
    byItem: [...byItem].sort((a, b) => b[1].shown - a[1].shown).map(([id, v]) => ({ id, ...v })),
    byWidth: [...byW].map(([w, v]) => ({ w, ...v })),
  };
  if (url.searchParams.get('format') === 'json') {
    return new Response(JSON.stringify(data), { headers: { 'content-type': 'application/json; charset=utf-8', 'x-robots-tag': 'noindex', 'cache-control': 'no-store' } });
  }
  const pct = (v) => (v.shown ? `${Math.round(((v.click + v.later) / v.shown) * 100)}%` : '-');
  const esc = (s) => String(s).replace(/[&<>"]/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' }[c]));
  const table = (head, list, key) => `<table><tr><th>${head}</th><th>出た</th><th>吹き出しを押した</th><th>押さずにあとで見に来た</th><th>見に行った割合</th></tr>${
    list.map((v) => `<tr><td>${esc(v[key])}</td><td>${v.shown}</td><td>${v.click}</td><td>${v.later}</td><td>${pct(v)}</td></tr>`).join('')}</table>`;
  const html = `<!doctype html><html lang="ja"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><meta name="robots" content="noindex">
<title>ハコブくんの知らせの記録</title><style>body{font:14px/1.7 -apple-system,'Noto Sans JP',sans-serif;margin:24px;color:#242424;background:#f7f7f7}
h1{font-size:20px}h2{font-size:16px;margin-top:28px}table{border-collapse:collapse;background:#fff;min-width:min(100%,640px)}th,td{border:1px solid #ddd;padding:6px 10px;text-align:left}th{background:#eee}p{color:#555}</style></head><body>
<h1>ハコブくんの知らせの記録</h1><p>サイトの更新を知らせてハコブくんが走った回数と、そのあと見た人がどう動いたか。数だけを残しており、誰かは分からない。日付は日本時間。</p>
<p>${who ? `絞り込み：${esc(who)}（?who= を外すと全部）` : '全部の記録。?who=notbot で機械の印のない記録だけ、?who=bot で機械だけ、?who=old で印を付ける前の記録だけに絞れる'}</p>
<h2>人と機械（絞り込みに関係なく全部。2026-10-28 から印を付けている）</h2>${table('種類', data.byKind, 'kind')}
<h2>週ごと（月曜はじまり。週が変わると新しい行が増える）</h2>${table('週', data.byWeek, 'week')}
<h2>日ごと</h2>${table('日付', data.byDay, 'day')}
<h2>更新ごと</h2>${table('更新', data.byItem, 'id')}
<h2>画面の幅（pc＝広い／sp＝スマホ）</h2>${table('幅', data.byWidth, 'w')}
<p>記録の件数：${data.total}</p></body></html>`;
  return new Response(html, { headers: { 'content-type': 'text/html; charset=utf-8', 'x-robots-tag': 'noindex', 'cache-control': 'no-store' } });
}


// ---------- サイトの使われ方の記録（src/components/SiteMeasure.astro が送る） ----------
// 1回のページ表示 = 1件。中身は持たず、付箋（customMetadata）に書く（一覧のときに中身を読まずに数えられる）。
// 同じ表示が戻ってきて送り直したときは n が増える。数えるときは v（その表示だけの番号）ごとに n が最大の1件を使う。
// IP アドレス・ブラウザの種類・Cookie は残さない。v はブラウザに保存されない、その表示だけの番号
// browser-test・scenes（と TOP の top-）は、/series8 とトップの部品が付けている名前。ここに無いと押した記録が捨てられていた（2026-11-19 に気づいて足した）
// sim3d は ブラウザ版（/sim/serving-robot-3d）の操作（店・台数・人数・混み具合・再生など）
const EV_AREAS = new Set(['hakobu', 'header', 'footer', 'crumbs', 'toc', 'consult', 'pager', 'related', 'body', 'main', 'sim', 'now', 'files', 'ai', 'other',
  'browser-test', 'top-browser-test', 'scenes', 'top-scenes', 'sim3d']);
const EV_DEPTHS = new Set([0, 25, 50, 75, 100]);
const evInt = (x, max) => { const n = Math.floor(Number(x)); return Number.isFinite(n) && n >= 0 ? Math.min(n, max) : 0; };
// 自動で巡回するプログラムの名乗り（検索エンジン・AI のクローラー・SNS のプレビュー・自動のブラウザ）。名乗りそのものは保存しない
const EV_BOT_UA = /bot\/|bot;|\bbot\b|crawl|spider|slurp|headless|lighthouse|preview|facebookexternalhit|embedly|python-|curl\/|wget|go-http|okhttp|axios|node-fetch|playwright|puppeteer|selenium|phantom/i;
// 人か機械か：b＝機械（自動のブラウザ・クローラーの名乗り）／h＝人の操作があった／x＝どちらとも言えない（操作なし）。2026-10-25 から
const evKind = (request, d) => {
  const ua = request.headers.get('user-agent') || '';
  let verified = false;
  try { verified = !!(request.cf && (request.cf.verifiedBotCategory || (request.cf.botManagement && request.cf.botManagement.verifiedBot))); } catch { /* 使えない環境では名乗りだけで見る */ }
  if (verified || !ua || EV_BOT_UA.test(ua) || Number(d.wd) === 1 || Number(d.hl) === 1) return 'b';
  return Number(d.u) === 1 ? 'h' : 'x';
};
const evText = (x, max) => String(x == null ? '' : x).replace(/[\u0000-\u001f|>]/g, ' ').slice(0, max);

async function evRecord(request, env, url) {
  if (request.method !== 'POST') return new Response('Method Not Allowed', { status: 405 });
  // ほかのサイトから送られたもの・送りすぎは、guarded() で断っている
  let d;
  try { d = JSON.parse((await request.text()).slice(0, 6000)); } catch { return new Response(null, { status: 400 }); }
  const v = String(d.v || ''), p = String(d.p || '');
  if (!/^[a-z0-9]{6,16}$/.test(v) || !p.startsWith('/') || p.length > 160) return new Response(null, { status: 400 });
  const f = String(d.f || '');
  const s = Number(d.s);
  const clicks = (Array.isArray(d.c) ? d.c : []).slice(0, 8)
    .filter((c) => Array.isArray(c) && EV_AREAS.has(String(c[1])))
    .map((c) => `${evText(c[0], 100)}>${c[1]}`);
  let c = clicks.join('|');
  if (c.length > 900) c = c.slice(0, 900);
  const meta = {
    v, n: String(evInt(d.n, 50)), p,
    f: f === '(戻る)' || (f.startsWith('/') && f.length <= 160) ? f : '',
    r: /^[a-z0-9.-]{1,80}$/i.test(String(d.r || '')) ? String(d.r).toLowerCase() : '',
    us: /^[a-z0-9._-]{1,40}$/.test(String(d.us || '')) ? String(d.us) : '',
    w: d.w === 'sp' ? 'sp' : 'pc',
    s: String(EV_DEPTHS.has(s) ? s : 0),
    t: String(evInt(d.t, 7200)),
    c,
    d: String(evInt(d.d, 999)), g: String(evInt(d.g, 999)), cp: String(evInt(d.cp, 999)), vp: String(evInt(d.vp, 999)),
    fs: String(evInt(d.fs, 1)), fx: String(evInt(d.fx, 99)), fv: String(evInt(d.fv, 99)),
    k: evKind(request, d),
  };
  const at = new Date();
  const day = new Date(at.getTime() + 9 * 3600e3).toISOString().slice(0, 10); // 日本時間の日付
  await env.MESSAGES.put(`ev/${day}/${at.getTime()}-${v}-${meta.n}`, '', { customMetadata: meta });
  return new Response(null, { status: 204 });
}

// 週は月曜はじまり（日本時間の日付から、その週の月曜の日付を出す）
const evWeekOf = (day) => { const d = new Date(day + 'T00:00:00Z'); d.setUTCDate(d.getUTCDate() - ((d.getUTCDay() + 6) % 7)); return d.toISOString().slice(0, 10); };
const evMedian = (a) => { if (!a.length) return 0; const b = [...a].sort((x, y) => x - y); const m = b.length >> 1; return b.length % 2 ? b[m] : Math.round((b[m - 1] + b[m]) / 2); };
const EV_AREA_JA = { hakobu: 'ハコブくん', header: 'ヘッダー', footer: 'フッター', crumbs: '現在地', toc: '目次', consult: '相談の案内', pager: '前後の記事', related: '関連記事', body: '本文', main: 'ページの中身', now: '今の続き', files: '記事の素材', other: 'その他',
  'browser-test': 'ブラウザ版の入口', 'top-browser-test': 'TOPのブラウザ版の入口', scenes: '3Dの場面', 'top-scenes': 'TOPの3Dの場面', sim3d: 'ブラウザ版の操作' };

async function evStats(request, env, url) {
  if (request.method !== 'GET') return new Response('Method Not Allowed', { status: 405 });
  const since = /^\d{4}-\d{2}-\d{2}$/.test(url.searchParams.get('since') || '') ? url.searchParams.get('since') : '';
  const week = /^\d{4}-\d{2}-\d{2}$/.test(url.searchParams.get('week') || '') ? url.searchParams.get('week') : '';
  // who=human で人だけ、who=bot で機械だけ、who=unknown で操作のなかった表示だけ、who=old で印を付ける前の記録だけを数える（なければ全部）
  const WHO = { human: 'h', bot: 'b', unknown: 'x', old: 'o' };
  const who = WHO[url.searchParams.get('who')] ? url.searchParams.get('who') : '';
  // 1) 記録を読む（v ごとに n が最大の1件）
  const views = new Map();
  let cursor, pages = 0, truncated = false;
  do {
    const r = await env.MESSAGES.list({ prefix: 'ev/', cursor, include: ['customMetadata'], limit: 1000, ...(since && !cursor ? { startAfter: `ev/${since}` } : {}) });
    for (const o of r.objects) {
      const m = o.customMetadata || {};
      if (!m.v) continue;
      const day = o.key.split('/')[1];
      if (since && day < since) continue;
      const prev = views.get(m.v);
      if (!prev || Number(m.n) >= Number(prev.n)) views.set(m.v, { ...m, day });
    }
    cursor = r.truncated ? r.cursor : undefined;
    if (++pages >= 40 && cursor) { truncated = true; break; }
  } while (cursor);
  // 2) メッセージフォームから実際に届いた数（p2m-messages の一番上に置かれた .json の数）
  const sent = new Map();
  cursor = undefined; pages = 0;
  do {
    const r = await env.MESSAGES.list({ delimiter: '/', cursor, limit: 1000 });
    for (const o of r.objects) {
      const m = o.key.match(/^(\d{4}-\d{2}-\d{2})T(\d{2})-(\d{2})-(\d{2})-(\d{3})Z/);
      if (!m) continue;
      const day = new Date(Date.UTC(+m[1].slice(0, 4), +m[1].slice(5, 7) - 1, +m[1].slice(8, 10), +m[2], +m[3], +m[4]) + 9 * 3600e3).toISOString().slice(0, 10);
      if (since && day < since) continue;
      const w = evWeekOf(day); sent.set(w, (sent.get(w) || 0) + 1);
    }
    cursor = r.truncated ? r.cursor : undefined;
  } while (cursor && ++pages < 10);

  // 3) 数える
  const rows = [...views.values()].map((m) => ({
    ...m, week: evWeekOf(m.day), s: Number(m.s) || 0, t: Number(m.t) || 0,
    d: Number(m.d) || 0, g: Number(m.g) || 0, cp: Number(m.cp) || 0, vp: Number(m.vp) || 0,
    fs: Number(m.fs) || 0, fx: Number(m.fx) || 0, fv: Number(m.fv) || 0,
    k: m.k || 'o',
    clicks: m.c ? m.c.split('|').map((x) => { const i = x.lastIndexOf('>'); return { target: x.slice(0, i), area: x.slice(i + 1) }; }) : [],
  }));
  // 人と機械の内訳は、絞り込む前の全部の記録で週ごとに数える
  const kinds = new Map();
  for (const r of rows) { const x = kinds.get(r.week) || { h: 0, b: 0, x: 0, o: 0 }; x[r.k]++; kinds.set(r.week, x); }
  const counted = who ? rows.filter((r) => r.k === WHO[who]) : rows;
  const isMsg = (p) => p === '/message' || p === '/message/';
  const outside = (c) => c.area !== 'hakobu' && !c.target.startsWith('/') && !c.target.startsWith('#') && !c.target.startsWith('btn:') && !c.target.startsWith('(リンクなし)') && !c.target.startsWith('iframe');
  const weeks = new Map();
  for (const r of counted) {
    const w = weeks.get(r.week) || { week: r.week, views: 0, times: [], read75: 0, dead: 0, rage: 0, out: 0, back: 0, sp: 0, msgViews: 0, formStart: 0, formSubmit: 0, formValid: 0 };
    w.views++; w.times.push(r.t); if (r.s >= 75) w.read75++; w.dead += r.d; w.rage += r.g;
    w.out += r.clicks.filter(outside).length; if (r.f === '(戻る)') w.back++; if (r.w === 'sp') w.sp++;
    if (isMsg(r.p)) { w.msgViews++; w.formStart += r.fs; w.formSubmit += r.fx; w.formValid += r.fv; }
    weeks.set(r.week, w);
  }
  for (const k of sent.keys()) if (!weeks.has(k)) weeks.set(k, { week: k, views: 0, times: [], read75: 0, dead: 0, rage: 0, out: 0, back: 0, sp: 0, msgViews: 0, formStart: 0, formSubmit: 0, formValid: 0 });
  const pct = (a, b) => (b ? Math.round((a / b) * 100) : 0);
  const byWeek = [...weeks.values()].sort((a, b) => b.week.localeCompare(a.week)).map((w) => {
    const end = new Date(w.week + 'T00:00:00Z'); end.setUTCDate(end.getUTCDate() + 6);
    return {
      week: w.week, label: `${w.week} 〜 ${end.toISOString().slice(5, 10)}`, views: w.views, medianSeconds: evMedian(w.times),
      read75Pct: pct(w.read75, w.views), spPct: pct(w.sp, w.views), backViews: w.back, outClicks: w.out, deadClicks: w.dead, rageClicks: w.rage,
      messageViews: w.msgViews, formStarts: w.formStart, formSubmits: w.formSubmit, formSubmitsValid: w.formValid, messagesReceived: sent.get(w.week) || 0,
      humanViews: (kinds.get(w.week) || {}).h || 0, botViews: (kinds.get(w.week) || {}).b || 0, unknownViews: (kinds.get(w.week) || {}).x || 0, unmarkedViews: (kinds.get(w.week) || {}).o || 0,
    };
  });
  // ページごと・移り方・押したもの（week= を付けるとその週だけ。付けなければ全期間）
  const scope = week ? counted.filter((r) => r.week === week) : counted;
  const count = (map, k, add = 1) => map.set(k, (map.get(k) || 0) + add);
  const pagesMap = new Map(), moves = new Map(), refs = new Map(), utms = new Map(), targets = new Map(), areas = new Map(), dead = new Map();
  for (const r of scope) {
    const pg = pagesMap.get(r.p) || { path: r.p, views: 0, times: [], s25: 0, s50: 0, s75: 0, s100: 0, dead: 0, rage: 0, copies: 0, plays: 0, out: 0 };
    pg.views++; pg.times.push(r.t);
    if (r.s >= 25) pg.s25++; if (r.s >= 50) pg.s50++; if (r.s >= 75) pg.s75++; if (r.s >= 100) pg.s100++;
    pg.dead += r.d; pg.rage += r.g; pg.copies += r.cp; pg.plays += r.vp; pg.out += r.clicks.filter(outside).length;
    pagesMap.set(r.p, pg);
    if (r.f) count(moves, `${r.f} → ${r.p}`);
    // referrer がなくてもリンクの印（utm_source）があれば、その名前で数える（2026-10-30）
    count(refs, r.r || (r.us ? `${r.us}（リンクの印）` : (r.f ? '（サイト内）' : '（直接・不明）')));
    if (r.us) count(utms, r.us);
    for (const c of r.clicks) {
      count(areas, c.area);
      if (c.target.startsWith('(リンクなし)')) count(dead, `${r.p} ${c.target}`);
      else count(targets, `${c.target}｜${EV_AREA_JA[c.area] || c.area}`);
    }
  }
  const top = (map, n, key) => [...map].sort((a, b) => b[1] - a[1]).slice(0, n).map(([k, v]) => ({ [key]: k, count: v }));
  const data = {
    total: rows.length, counted: counted.length, truncated, since: since || null, week: week || null, who: who || null,
    byWeek,
    byPage: [...pagesMap.values()].sort((a, b) => b.views - a.views).slice(0, 100).map((p) => ({
      path: p.path, views: p.views, medianSeconds: evMedian(p.times),
      read25Pct: pct(p.s25, p.views), read50Pct: pct(p.s50, p.views), read75Pct: pct(p.s75, p.views), read100Pct: pct(p.s100, p.views),
      deadClicks: p.dead, rageClicks: p.rage, copies: p.copies, videoPlays: p.plays, outClicks: p.out,
    })),
    moves: top(moves, 50, 'move'),
    referrers: top(refs, 30, 'from'),
    utmSources: top(utms, 30, 'source'),
    clicks: top(targets, 60, 'target'),
    areas: [...areas].sort((a, b) => b[1] - a[1]).map(([a, n]) => ({ area: EV_AREA_JA[a] || a, count: n })),
    deadClicks: top(dead, 30, 'where'),
  };
  if (url.searchParams.get('format') === 'json') {
    return new Response(JSON.stringify(data), { headers: { 'content-type': 'application/json; charset=utf-8', 'x-robots-tag': 'noindex', 'cache-control': 'no-store' } });
  }
  const esc = (s) => String(s).replace(/[&<>"]/g, (ch) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' }[ch]));
  const table = (cols, list) => list.length
    ? `<div class="wrap"><table><tr>${cols.map(([, h]) => `<th>${h}</th>`).join('')}</tr>${list.map((r) => `<tr>${cols.map(([k]) => `<td>${esc(r[k])}</td>`).join('')}</tr>`).join('')}</table></div>`
    : '<p>まだ記録がありません。</p>';
  const html = `<!doctype html><html lang="ja"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><meta name="robots" content="noindex">
<title>サイトの使われ方の記録</title><style>body{font:14px/1.7 -apple-system,'Noto Sans JP',sans-serif;margin:24px;color:#242424;background:#f7f7f7}
h1{font-size:20px}h2{font-size:16px;margin-top:28px}.wrap{overflow-x:auto}table{border-collapse:collapse;background:#fff}th,td{border:1px solid #ddd;padding:6px 10px;text-align:left;white-space:nowrap}th{background:#eee}p{color:#555}</style></head><body>
<h1>サイトの使われ方の記録</h1><p>1回のページ表示ごとに、どこまで読んだか・何を押したか・迷ったかを数えたもの。誰かは分からない。日付は日本時間、週は月曜はじまり。${week ? `ページごと以下の表は ${esc(week)} の週だけ。` : 'ページごと以下の表は全期間。?week=週の月曜の日付 でその週だけになる。'}${truncated ? ' 記録が多すぎて一部だけ数えた（?since=日付 で期間を絞る）。' : ''}</p>
<p>人と機械：「人」はマウス・指・キーの操作があった表示、「機械」はクローラーや自動のブラウザの名乗り・印があった表示、「操作なし」はどちらとも言えない表示、「印なし」は 2026-10-25 より前の記録。いま数えているのは <b>${esc({ human: '人', bot: '機械', unknown: '操作なし', old: '印なし' }[who] || '全部')}</b>（?who=human・bot・unknown・old で絞る。週ごとの表の「人」〜「印なし」の4列は常に全部の内訳）。</p>
<h2>週ごと</h2>${table([['label', '週'], ['views', '表示'], ['medianSeconds', '表示時間（中央値・秒）'], ['read75Pct', '75％以上読んだ（％）'], ['spPct', 'スマホ（％）'], ['backViews', '戻るで戻った'], ['outClicks', '外へのクリック'], ['deadClicks', 'リンクなしを押した'], ['rageClicks', '連打'], ['messageViews', 'フォームの表示'], ['formStarts', '入力を始めた'], ['formSubmits', '送信を押した'], ['formSubmitsValid', 'うち入力がそろっていた'], ['messagesReceived', '届いたメッセージ'], ['humanViews', '人'], ['botViews', '機械'], ['unknownViews', '操作なし'], ['unmarkedViews', '印なし']], byWeek)}
<h2>ページごと</h2>${table([['path', 'ページ'], ['views', '表示'], ['medianSeconds', '表示時間（中央値・秒）'], ['read25Pct', '25％'], ['read50Pct', '50％'], ['read75Pct', '75％'], ['read100Pct', '最後まで'], ['deadClicks', 'リンクなしを押した'], ['rageClicks', '連打'], ['copies', 'コピー'], ['videoPlays', '動画の再生'], ['outClicks', '外へのクリック']], data.byPage)}
<h2>ページからページへの移り方</h2>${table([['move', '移り方'], ['count', '回数']], data.moves)}
<h2>どこから来たか</h2>${table([['from', '来たところ'], ['count', '回数']], data.referrers)}
<h2>リンクに付いた来た元の印（utm_source。2026-10-30 から）</h2><p>ChatGPT などの AI は、回答の中のリンクに ?utm_source=chatgpt.com のような印を付ける。アプリから開くと「どこから来たか」が送られないので、この印で AI から来た人を数える。</p>${table([['source', '印'], ['count', '回数']], data.utmSources)}
<h2>押したリンク・ボタン（行き先｜ページのどの部分か）</h2>${table([['target', '押したもの'], ['count', '回数']], data.clicks)}
<h2>押した場所（ページのどの部分か）</h2>${table([['area', '部分'], ['count', '回数']], data.areas)}
<h2>リンクでない所を押した（ページと、押したものの種類）</h2>${table([['where', '場所'], ['count', '回数']], data.deadClicks)}
<p>記録の件数（ページ表示の数）：${data.total}</p></body></html>`;
  return new Response(html, { headers: { 'content-type': 'text/html; charset=utf-8', 'x-robots-tag': 'noindex', 'cache-control': 'no-store' } });
}

// ───────── 検索エンジン・AI のクローラーの訪問（2026-10-25）─────────
// ページ上の計測（/api/ev）は JavaScript を動かさないクローラーを数えられないので、配信のときに名乗りで数える。
// 残すのは「どのクローラーか・どのページか・返した結果（200 など）・Cloudflare が本物と確かめたか・日時」だけ。名乗りそのものは保存しない。
// 名乗りはまねできるので、「確かめた」が 0 のものは偽物が混ざりうる（Cloudflare が判定を渡さない環境では ? になる）
const CRAWLERS = [
  ['GPTBot', 'OpenAI（学習）'], ['OAI-SearchBot', 'OpenAI（ChatGPT の検索）'], ['ChatGPT-User', 'ChatGPT（利用者の依頼で読む）'],
  ['ClaudeBot', 'Anthropic（学習）'], ['Claude-SearchBot', 'Anthropic（Claude の検索）'], ['Claude-User', 'Claude（利用者の依頼で読む）'], ['anthropic-ai', 'Anthropic'],
  ['PerplexityBot', 'Perplexity（検索）'], ['Perplexity-User', 'Perplexity（利用者の依頼で読む）'],
  ['Google-CloudVertexBot', 'Google（Vertex AI）'], ['GoogleOther', 'Google（その他）'], ['Googlebot', 'Google（検索）'],
  ['bingbot', 'Bing（検索。ChatGPT の検索・Copilot も使う）'], ['DuckAssistBot', 'DuckDuckGo（AI の回答）'], ['DuckDuckBot', 'DuckDuckGo（検索）'],
  ['Applebot', 'Apple（Siri・検索・AI）'], ['Amazonbot', 'Amazon（Alexa・AI）'], ['meta-externalagent', 'Meta（AI）'], ['FacebookBot', 'Meta'],
  ['Bytespider', 'ByteDance（AI）'], ['CCBot', 'Common Crawl（多くの AI の学習データ）'], ['MistralAI-User', 'Mistral（利用者の依頼で読む）'],
  ['cohere-ai', 'Cohere'], ['Diffbot', 'Diffbot'], ['YouBot', 'You.com'], ['YandexBot', 'Yandex（検索）'], ['Baiduspider', 'Baidu（検索）'], ['Yeti', 'Naver（検索）'],
];
// 数えるのはページ・テキストだけ（画像・CSS・JS は wrangler.jsonc の run_worker_first で外している）
// 「AIで読む」の質問文で、全文ページの住所に付けている印（src/pages/record/[slug].astro の AI_TARGETS）
const AI_VIA = new Set(['chatgpt', 'claude', 'perplexity', 'gemini', 'copy']);
const CR_PAGE = /(\/|\/[^/.]*|\.html|\.md|\.txt|\.xml|\.json)$/i;
function crawlerOf(request, url) {
  if (request.method !== 'GET' && request.method !== 'HEAD') return null;
  if (!CR_PAGE.test(url.pathname)) return null;
  const ua = (request.headers.get('user-agent') || '').toLowerCase();
  if (!ua) return null;
  for (const [name] of CRAWLERS) if (ua.includes(name.toLowerCase())) return name;
  return null;
}
async function crRecord(request, env, url, bot, status, via = '') {
  let ok = '?';
  try {
    const cf = request.cf || {};
    if ('verifiedBotCategory' in cf) ok = cf.verifiedBotCategory ? '1' : '0';
    else if (cf.botManagement && 'verifiedBot' in cf.botManagement) ok = cf.botManagement.verifiedBot ? '1' : '0';
  } catch { /* 判定がなければ ? のまま */ }
  const at = new Date();
  const day = new Date(at.getTime() + 9 * 3600e3).toISOString().slice(0, 10);
  const meta = { b: bot, p: url.pathname.slice(0, 160), s: String(status), ok, ...(via ? { v: via } : {}) };
  await env.MESSAGES.put(`cr/${day}/${at.getTime()}-${Math.random().toString(36).slice(2, 8)}`, '', { customMetadata: meta });
}
async function crStats(request, env, url) {
  if (request.method !== 'GET') return new Response('Method Not Allowed', { status: 405 });
  const since = /^\d{4}-\d{2}-\d{2}$/.test(url.searchParams.get('since') || '') ? url.searchParams.get('since') : '';
  const only = url.searchParams.get('bot') || '';
  const rows = [];
  let cursor, pages = 0, truncated = false;
  do {
    const r = await env.MESSAGES.list({ prefix: 'cr/', cursor, include: ['customMetadata'], limit: 1000, ...(since && !cursor ? { startAfter: `cr/${since}` } : {}) });
    for (const o of r.objects) {
      const m = o.customMetadata || {};
      if (!m.b) continue;
      const day = o.key.split('/')[1];
      if (since && day < since) continue;
      rows.push({ ...m, day, week: evWeekOf(day), at: Number(o.key.split('/')[2].split('-')[0]) || 0 });
    }
    cursor = r.truncated ? r.cursor : undefined;
    if (++pages >= 40 && cursor) { truncated = true; break; }
  } while (cursor);
  const label = { ...Object.fromEntries(CRAWLERS), その他: 'その他（「AIで読む」経由で、名乗りが一覧にない読み手）' };
  const count = (map, k) => map.set(k, (map.get(k) || 0) + 1);
  // クローラーごと（全期間）
  const bots = new Map();
  for (const r of rows) {
    const b = bots.get(r.b) || { bot: r.b, who: label[r.b] || r.b, visits: 0, pages: new Set(), records: new Set(), verified: 0, unverified: 0, errors: 0, last: '' };
    b.visits++; b.pages.add(r.p); if (r.p.startsWith('/record/') || r.p.startsWith('/files/')) b.records.add(r.p.split('/').slice(0, 3).join('/'));
    if (r.ok === '1') b.verified++; else if (r.ok === '0') b.unverified++;
    if (Number(r.s) >= 400) b.errors++;
    if (r.day > b.last) b.last = r.day;
    bots.set(r.b, b);
  }
  // 週ごと × クローラー
  const weeks = new Map();
  for (const r of rows) { const w = weeks.get(r.week) || new Map(); count(w, r.b); weeks.set(r.week, w); }
  // ページごと（?bot= でそのクローラーだけ）
  // 返せなかった訪問（400以上）をページ・結果ごとに（2026-10-30）
  const errMap = new Map();
  for (const r of rows) {
    if (Number(r.s) < 400) continue;
    const k = `${r.p}\t${r.s}`;
    const e = errMap.get(k) || { path: r.p, status: r.s, visits: 0, bots: new Set(), last: '' };
    e.visits++; e.bots.add(r.b); if (r.day > e.last) e.last = r.day; errMap.set(k, e);
  }
  const scope = only ? rows.filter((r) => r.b === only) : rows;
  const paths = new Map(), pathBots = new Map();
  for (const r of scope) { count(paths, r.p); const s = pathBots.get(r.p) || new Set(); s.add(r.b); pathBots.set(r.p, s); }
  // 「AIで読む」経由（?via=）。押した AI ごとに、実際に読みに来たのはだれか（2026-11-01）
  const viaMap = new Map();
  for (const r of rows) {
    if (!r.v) continue;
    const e = viaMap.get(r.v) || { via: r.v, visits: 0, records: new Set(), bots: new Map(), last: '' };
    e.visits++; e.records.add(r.p); count(e.bots, r.b); if (r.day > e.last) e.last = r.day; viaMap.set(r.v, e);
  }
  const viaWeeks = new Map();
  for (const r of rows) { if (!r.v) continue; const w = viaWeeks.get(r.week) || new Map(); count(w, r.v); viaWeeks.set(r.week, w); }
  const data = {
    total: rows.length, truncated, since: since || null, bot: only || null,
    byBot: [...bots.values()].sort((a, b) => b.visits - a.visits).map((b) => ({
      bot: b.bot, who: b.who, visits: b.visits, pages: b.pages.size, records: b.records.size, verified: b.verified, unverified: b.unverified, errors: b.errors, last: b.last,
    })),
    byWeek: [...weeks].sort((a, b) => b[0].localeCompare(a[0])).map(([week, m]) => ({ week, total: [...m.values()].reduce((x, y) => x + y, 0), bots: [...m].sort((a, b) => b[1] - a[1]).map(([b, n]) => `${b} ${n}`).join('、') })),
    byPage: [...paths].sort((a, b) => b[1] - a[1]).slice(0, 100).map(([path, n]) => ({ path, visits: n, bots: [...(pathBots.get(path) || [])].join('、') })),
    byVia: [...viaMap.values()].sort((a, b) => b.visits - a.visits).map((e) => ({ via: e.via, visits: e.visits, records: e.records.size, bots: [...e.bots].sort((a, b) => b[1] - a[1]).map(([b, n]) => `${b} ${n}`).join('、'), last: e.last })),
    byViaWeek: [...viaWeeks].sort((a, b) => b[0].localeCompare(a[0])).map(([week, m]) => ({ week, total: [...m.values()].reduce((x, y) => x + y, 0), via: [...m].sort((a, b) => b[1] - a[1]).map(([v, n]) => `${v} ${n}`).join('、') })),
    errors: [...errMap.values()].sort((a, b) => b.visits - a.visits).slice(0, 100).map((e) => ({ path: e.path, status: e.status, visits: e.visits, bots: [...e.bots].join('、'), last: e.last })),
    // ?bot= のときは1回ずつの訪問（日本時間の時刻・ページ・「AIで読む」の印・結果）を新しい順に200件まで。
    // エイイチや Claude の作業の時刻と突き合わせて、試しの分かどうかを見分けるため（2026-11-12）
    ...(only ? { hits: scope.filter((r) => r.at).sort((a, b) => b.at - a.at).slice(0, 200).map((r) => ({
      at: new Date(r.at + 9 * 3600e3).toISOString().slice(0, 19).replace('T', ' '), path: r.p, via: r.v || '', status: r.s, verified: r.ok,
    })) } : {}),
  };
  if (url.searchParams.get('format') === 'json') {
    return new Response(JSON.stringify(data), { headers: { 'content-type': 'application/json; charset=utf-8', 'x-robots-tag': 'noindex', 'cache-control': 'no-store' } });
  }
  const esc = (s) => String(s).replace(/[&<>"]/g, (ch) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' }[ch]));
  const table = (cols, list) => list.length
    ? `<div class="wrap"><table><tr>${cols.map(([, h]) => `<th>${h}</th>`).join('')}</tr>${list.map((r) => `<tr>${cols.map(([k]) => `<td>${esc(r[k])}</td>`).join('')}</tr>`).join('')}</table></div>`
    : '<p>まだ記録がありません。</p>';
  const html = `<!doctype html><html lang="ja"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><meta name="robots" content="noindex">
<title>クローラーの訪問の記録</title><style>body{font:14px/1.7 -apple-system,'Noto Sans JP',sans-serif;margin:24px;color:#242424;background:#f7f7f7}
h1{font-size:20px}h2{font-size:16px;margin-top:28px}.wrap{overflow-x:auto}table{border-collapse:collapse;background:#fff}th,td{border:1px solid #ddd;padding:6px 10px;text-align:left;white-space:nowrap}th{background:#eee}p{color:#555}</style></head><body>
<h1>クローラーの訪問の記録</h1><p>検索エンジン・AI のクローラーが、どのページを読みに来たか（2026-10-25 から）。名乗りで見分けているので、「Cloudflare が確かめた」が 0 のものは偽物が混ざりうる。日付は日本時間、週は月曜はじまり。?since=日付 で期間を、?bot=名前（例 GPTBot）でページごとの表をそのクローラーだけに絞る。${truncated ? ' 記録が多すぎて一部だけ数えた。' : ''}</p>
<h2>クローラーごと</h2>${table([['bot', '名前'], ['who', 'だれの・何のため'], ['visits', '読んだ回数'], ['pages', 'ページの数'], ['records', '記録（LOG）の数'], ['verified', 'Cloudflare が確かめた'], ['unverified', '確かめられなかった'], ['errors', '見つからない等（400以上）'], ['last', '最後に来た日']], data.byBot)}
<h2>週ごと</h2>${table([['week', '週（月曜）'], ['total', '合計'], ['bots', '内訳']], data.byWeek)}
<h2>「AIで読む」経由（記事のボタンから、全文ページを読みに来た回数）</h2><p>押した AI（via）ごと。copy は「質問文をコピー」。「その他」は名乗りが一覧にない読み手（Gemini・人のブラウザなど）。押した回数は /api/ev-stats の場所 ai。</p>${table([['via', '押した AI'], ['visits', '読みに来た回数'], ['records', '記事の数'], ['bots', '読みに来たのはだれか'], ['last', '最後の日']], data.byVia)}
${table([['week', '週（月曜）'], ['total', '合計'], ['via', '内訳']], data.byViaWeek)}
<h2>よく読まれたページ${only ? `（${esc(only)} だけ）` : ''}</h2>${table([['path', 'ページ'], ['visits', '回数'], ['bots', '読みに来たクローラー']], data.byPage)}
<h2>返せなかったページ（400以上）</h2>${table([['path', 'ページ'], ['status', '返した結果'], ['visits', '回数'], ['bots', 'クローラー'], ['last', '最後の日']], data.errors)}
<p>記録の件数：${data.total}</p></body></html>`;
  return new Response(html, { headers: { 'content-type': 'text/html; charset=utf-8', 'x-robots-tag': 'noindex', 'cache-control': 'no-store' } });
}

// ───────── 主に見る3つの数字（2026-11-06。集計は worker/kpi.js）─────────
async function kpiStats(request, env, url) {
  if (request.method !== 'GET') return new Response('Method Not Allowed', { status: 405 });
  const day = (k, d) => (/^\d{4}-\d{2}-\d{2}$/.test(url.searchParams.get(k) || '') ? url.searchParams.get(k) : d);
  const today = todayJst();
  // ?sc=refresh で Search Console からサイト名の検索の数を取り直す（?since= の週から。最初の埋め戻し用）
  if (url.searchParams.get('sc') === 'refresh') {
    try { return json(await gscRefresh(env, { since: day('since', '') })); } catch (e) { return json({ ok: false, error: e.message }, 500); }
  }
  const data = await kpiRange(env, day('since', addDays(today, -28)), day('until', today));
  if (url.searchParams.get('format') === 'json') {
    return new Response(JSON.stringify(data), { headers: { 'content-type': 'application/json; charset=utf-8', 'x-robots-tag': 'noindex', 'cache-control': 'no-store' } });
  }
  const esc = (s) => String(s).replace(/[&<>"]/g, (ch) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' }[ch]));
  const kv = (o) => Object.entries(o || {}).sort((a, b) => b[1] - a[1]).map(([k, v]) => `${k} ${v}`).join('、');
  const table = (cols, list) => list.length
    ? `<div class="wrap"><table><tr>${cols.map(([, h]) => `<th>${h}</th>`).join('')}</tr>${list.map((r) => `<tr>${cols.map(([k, , f]) => `<td>${esc(f ? f(r[k], r) : (r[k] ?? '-'))}</td>`).join('')}</tr>`).join('')}</table></div>`
    : '<p>まだ記録がありません。</p>';
  const html = `<!doctype html><html lang="ja"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><meta name="robots" content="noindex">
<title>3つの数字</title><style>body{font:14px/1.7 -apple-system,'Noto Sans JP',sans-serif;margin:24px;color:#242424;background:#f7f7f7}
h1{font-size:20px}h2{font-size:16px;margin-top:28px}.wrap{overflow-x:auto}table{border-collapse:collapse;background:#fff}th,td{border:1px solid #ddd;padding:6px 10px;text-align:left;white-space:nowrap}th{background:#eee}p{color:#555}</style></head><body>
<h1>3つの数字</h1><p>AI に調べられることで、人の来訪や知名度がいつ増えはじめるかを見るための数。日付は日本時間、週は月曜はじまり。${esc(data.since)} 〜 ${esc(data.until)}（?since=・?until= で変える）。${data.pendingDays.length ? ` 集計がまだの日が ${data.pendingDays.length} 日ある（開き直すと作る）。` : ''}</p>
<p>AI の依頼読み：ChatGPT-User・Claude-User・Perplexity-User などが読んだページの数（「AIで読む」ボタン経由はエイイチ・Claude の試しが混ざりうる）。AI のリンクから：chatgpt.com などのリンクから来た、人の操作があった表示。サイト名の検索：Search Console から週ごとに記録したクリック数。</p>
<h2>週ごと</h2>${table([['week', '週（月曜）'], ['days', '日数'], ['aiReads', 'AI の依頼読み'], ['aiReadsViaButton', 'うちボタン経由'], ['aiReferrals', 'AI のリンクから来た人'], ['nameSearch', 'サイト名の検索（クリック）'], ['humanViews', '人の表示（参考）'], ['aiReadsByBot', '依頼読みの内訳', kv], ['aiReferralsBySource', 'リンクの内訳', kv]], [...data.byWeek].reverse())}
<h2>日ごと</h2>${table([['day', '日付', (v, r) => v + (r.partial ? '（途中）' : '')], ['aiReads', 'AI の依頼読み'], ['aiReadsViaButton', 'うちボタン経由'], ['aiReferrals', 'AI のリンクから来た人'], ['humanViews', '人の表示（参考）'], ['aiReadsByBot', '依頼読みの内訳', kv], ['aiReferralsBySource', 'リンクの内訳', kv]], [...data.byDay].reverse())}
</body></html>`;
  return new Response(html, { headers: { 'content-type': 'text/html; charset=utf-8', 'x-robots-tag': 'noindex', 'cache-control': 'no-store' } });
}
```

### 公開後の確かめ

公開から約2分後に 410 に替わった。正しいページ・ファイル・クエリ付きの住所は、今までどおり 200 を返す。

```
$ curl -s -o /dev/null -w '%{http_code}' https://pixelstomotors.com/files/LOG502/%7Bsrc%7D
410
410 /record/%24%7BMSG_URL%7D
200 /record/day18
200 /files/LOG502/02_sec12.py.txt
200 /llms.txt?via=%7Bx%7D
200 /
```

レビュー用の枝 crawler-410 は、GitHub への接続が2回切れて消せていない。中身は main に入っているので、残っていても動きには関わらない。


## 作業ログ ― これから確かめること

| 確かめること | 何で見るか | いつ |
|---|---|---|
| /null が減ったか | クローラーの記録の /null の回数（11/16 の週は60） | 11/23〜11/29 の週の記録 |
| 410 にした住所への再訪が減ったか | クローラーの記録の、410 を返した住所の回数 | 同じ週から2週 |
| Google の順位が戻るか | Search Console の日ごとの掲載順位と表示 | 12/4（予約済み） |
| 直接来る人が、どこで知って来ていた人か | 直接の来訪が多かったページ（/gpu-buy-or-rent・/issues・/message）に、来た所が分かる印を付けたリンクを置くか、考える | 次の週の分析 |
| サイト名の検索（11/16 の週） | Search Console | 11/25 以降 |
