アップロード前に一度だけ取りにいかれた画像が、エッジで 404 のまま残りました。保持の規則をステータス別に分け、アップロードと消去を一組にしました

// clock.mjs — 手で進める時計。1年分の保持も待たずに確かめるために使います
export class FakeClock {
  #now = 0;
  now() { return this.#now; }
  advance(sec) { this.#now += sec; }
}

// edge.mjs — エッジキャッシュの「保持の規則」だけを写した模型です（CDN の内部を再現したものではありません）
// キー = パス + クエリ。応答ごとに保持秒数をポリシーで決め、期限が切れたら取り直します。
export class Edge {
  constructor({ clock, origin, policy }) {
    this.clock = clock; this.origin = origin; this.policy = policy;
    this.store = new Map();
    this.originHits = 0;
  }
  get(url) {
    const now = this.clock.now();
    const hit = this.store.get(url);
    if (hit && now < hit.expiresAt) return { ...hit.res, cache: "HIT" };
    const res = this.origin.get(url);       // 取り直し（MISS または EXPIRED）
    this.originHits += 1;
    const ttl = this.policy(res.status);
    if (ttl > 0) this.store.set(url, { res, expiresAt: now + ttl });
    else this.store.delete(url);
    return { ...res, cache: hit ? "EXPIRED" : "MISS" };
  }
  purge(url) { this.store.delete(url); }
}
 
export class Origin {
  constructor() { this.files = new Map(); this.down = false; }
  upload(path, bytes) { this.files.set(path, bytes); }
  get(url) {
    const path = url.split("?")[0];
    if (this.down) return { status: 503, bytes: 0 };
    return this.files.has(path)
      ? { status: 200, bytes: this.files.get(path) }
      : { status: 404, bytes: 0 };
  }
}

// policies.mjs — 変更前と変更後の保持規則を、秒数の表として持ちます
const YEAR = 365 * 24 * 3600;
export const before = (status) => (status === 200 || status === 404 ? YEAR : 0);         // 404 まで1年
export const after  = (status) => (status === 200 ? YEAR : status === 404 ? 60 : 0);     // 404 は60秒・5xx は保持しない

// timeline.mjs — 「アップロード前に一度アクセスされた画像」が、いつ見えるようになるかを並べます
import { FakeClock } from "./clock.mjs";
import { Edge, Origin } from "./edge.mjs";
import { before, after } from "./policies.mjs";
 
function run(name, policy) {
  const clock = new FakeClock(); const origin = new Origin();
  const edge = new Edge({ clock, origin, policy });
  const path = "/img/new_wall_0412.jpg";
  const rows = [];
  const hit = (label) => { const r = edge.get(path); rows.push([label, r.status, r.cache]); return r; };
  hit("アップロード前に先読み");          // アプリが一覧の更新を先に受け取り、画像を取りにいった
  clock.advance(30); origin.upload(path, 480_000);
  hit("アップロード直後(+30秒)");
  clock.advance(45); hit("+75秒");
  clock.advance(3600); hit("+約1時間");
  // 見えるようになるまでの秒数を数える
  const probe = new Edge({ clock: new FakeClock(), origin: new Origin(), policy });
  const o = probe.origin; probe.get(path); o.upload(path, 480_000);
  let t = 0; const step = 15;
  while (t < 2 * 365 * 24 * 3600) { probe.clock.advance(step); t += step; if (probe.get(path).status === 200) break; }
  console.log(`\n■ ${name}`);
  for (const [l, s, c] of rows) console.log(`  ${l.padEnd(26)} status=${s} cache=${c}`);
  console.log(`  → アップロードから 200 が返るまで: ${t >= 2*365*24*3600 ? "2年待っても返らない" : t + " 秒"}`);
}
run("変更前（404 も 1 年保持）", before);
run("変更後（404 は 60 秒）", after);

// load.mjs — 404 を短くすると、存在しない URL への問い合わせがオリジンに届く。その代償を数えます
import { FakeClock } from "./clock.mjs";
import { Edge, Origin } from "./edge.mjs";
const YEAR = 365 * 24 * 3600;
const cases = {
  "404=1年   ": (s) => (s === 200 || s === 404 ? YEAR : 0),
  "404=60秒  ": (s) => (s === 200 ? YEAR : s === 404 ? 60 : 0),
  "404=保持なし": (s) => (s === 200 ? YEAR : 0),
};
console.log("存在しない画像 1 本へ、1 秒に 1 回、10 分間（600 回）");
for (const [name, policy] of Object.entries(cases)) {
  const clock = new FakeClock(); const edge = new Edge({ clock, origin: new Origin(), policy });
  for (let i = 0; i < 600; i++) { edge.get("/img/ghost.jpg"); clock.advance(1); }
  console.log(`  ${name} オリジンに届いた回数: ${String(edge.originHits).padStart(3)}`);
}
 
console.log("\nオリジンが 5 分間 503 を返したあと復旧（その間も 1 秒に 1 回の問い合わせ）");
const five = {
  "5xx=保持(誤)": (s) => (s === 200 ? YEAR : 3600),
  "5xx=保持なし ": (s) => (s === 200 ? YEAR : s === 404 ? 60 : 0),
};
for (const [name, policy] of Object.entries(five)) {
  const clock = new FakeClock(); const origin = new Origin(); origin.upload("/img/ok.jpg", 300_000);
  const edge = new Edge({ clock, origin, policy });
  origin.down = true;
  for (let i = 0; i < 300; i++) { edge.get("/img/ok.jpg"); clock.advance(1); }
  origin.down = false;
  const later = [];
  for (const wait of [1, 60, 600]) { clock.advance(wait); later.push(edge.get("/img/ok.jpg").status); }
  console.log(`  ${name} 復旧後の status (+1秒/+61秒/+661秒): ${later.join(" / ")}`);
}

// probe.mjs — 「オリジンにまだ無い」のか「エッジが 404 を抱えている」のかを、2 本の問い合わせで分けます
// 通常の URL と、クエリ付きの URL（キーが別になる）を並べて見ます。
export function diagnose(edge, path, nonce) {
  const plain = edge.get(path);
  const fresh = edge.get(`${path}?probe=${nonce}`);
  let verdict;
  if (plain.status === 200 && fresh.status === 200) verdict = "ok";
  else if (plain.status === 404 && fresh.status === 404) verdict = "origin-missing";   // 本当に無い。アップロードを疑う
  else if (plain.status === 404 && fresh.status === 200) verdict = "edge-holding-404"; // オリジンにはある。エッジが抱えている
  else verdict = `other(${plain.status}/${fresh.status})`;
  return { path, plain: plain.status, fresh: fresh.status, plainCache: plain.cache, verdict };
}

// sweep.mjs — 新しく足した画像を順に診断し、エッジが 404 を抱えているものだけを消します
// あわせて「アップロードしたら、同じ手順でそのパスを消す」一組にしておく理由を確かめます
import { FakeClock } from "./clock.mjs";
import { Edge, Origin } from "./edge.mjs";
import { before } from "./policies.mjs";
import { diagnose } from "./probe.mjs";
 
const clock = new FakeClock(); const origin = new Origin();
const edge = new Edge({ clock, origin, policy: before });          // 変更前の規則で起きた状態を作る
const added = ["/img/w_0410.jpg", "/img/w_0411.jpg", "/img/w_0412.jpg", "/img/w_0413.jpg"];
 
edge.get("/img/w_0412.jpg"); edge.get("/img/w_0413.jpg");          // 一覧の更新が先に届き、2 本は先に取りにいかれた
clock.advance(40);
for (const p of added.slice(0, 3)) origin.upload(p, 400_000);      // w_0413 だけアップロードが遅れている
let n = 0;
const report = added.map((p) => diagnose(edge, p, ++n));
for (const r of report) console.log(`${r.path.padEnd(18)} plain=${r.plain}(${r.plainCache}) fresh=${r.fresh} → ${r.verdict}`);
 
for (const r of report) if (r.verdict === "edge-holding-404") edge.purge(r.path);   // 抱えているものだけ、1 本ずつ
console.log("\n消したあと（w_0413 はまだオリジンに無いので触っていません）");
for (const p of added.slice(0, 3)) console.log(`${p.padEnd(18)} → ${edge.get(p).status}`);
 
// w_0413 が遅れて届く。アップロードだけで終えた場合と、消すところまで一組にした場合
clock.advance(600);
const uploadOnly = (p) => origin.upload(p, 400_000);
const uploadAndPurge = (p) => { origin.upload(p, 400_000); edge.purge(p); };
uploadOnly("/img/w_0413.jpg");
console.log(`\nw_0413 をアップロードだけで終えた場合 → ${edge.get("/img/w_0413.jpg").status}（${edge.get("/img/w_0413.jpg").cache}）`);
origin.files.delete("/img/w_0413.jpg"); edge.purge("/img/w_0413.jpg"); edge.get("/img/w_0413.jpg"); // 同じ状況を作り直す
uploadAndPurge("/img/w_0413.jpg");
console.log(`w_0413 をアップロードと消去の一組にした場合 → ${edge.get("/img/w_0413.jpg").status}`);

// plan.mjs — 保持規則を変える前に、現在の設定を保存し、差分と戻し方を表にします（設定そのものは触りません）
import { writeFileSync, readFileSync, existsSync } from "node:fs";
 
const current = { 200: "1y", 404: "1y", "5xx": "unset" };  // 現在値は管理画面で読み取って手で写す（ここは例の値）
const target  = { 200: "1y", 404: "60s", "5xx": "none" };
 
if (!existsSync("rules.before.json")) writeFileSync("rules.before.json", JSON.stringify(current, null, 2));
const saved = JSON.parse(readFileSync("rules.before.json", "utf8"));   // 戻すときはこのファイルが正本
 
for (const k of Object.keys(target)) {
  const from = saved[k], to = target[k];
  console.log(`${String(k).padEnd(4)} ${from.padEnd(5)} → ${to.padEnd(5)} ${from === to ? "(変更なし)" : `戻す値: ${from}`}`);
}

// アプリ側：一覧が「準備できた」と言うまで、画像を先読みしない
// （一覧に ready を持たせ、サーバーはアップロードと消去が終わってから ready を立てる）
type CatalogItem = { id: string; path: string; ready: boolean };
 
export function visibleItems(items: CatalogItem[]): CatalogItem[] {
  return items.filter((i) => i.ready);   // ready でないものは、一覧にも先読みにも出さない
}

curl -sI "https://example.com/img/new_wall.jpg" | grep -iE "^(HTTP|age|cache|x-cache|cf-cache)"