外部 API 接入：页面跑在别人 App 里，怎么把请求送出去

能不能让宿主加白名单 / 用官方 API？
├─ 能 ──▶ 直接用，到此为止
└─ 不能
   ├─ 页面源是你的吗？
   │  ├─ 是 ──▶ 同源反代（第 9 节）
   │  └─ 否
   │     ├─ script-src 放行你的域名？
   │     │  ├─ 是 ──▶ JSONP + 长轮询（第 3–5 节）
   │     │  └─ 否
   │     │     ├─ frame-src 放行？ ──▶ iframe 桥（第 10 节）
   │     │     └─ 都锁 ──▶ 没有技术手段能绕
   │     └─ 你的 Worker/服务器能出网吗？
   │        ├─ 能 ──▶ 用它做接应点
   │        └─ 被上游按 IP 限 ──▶ 再加一级出口（第 6 节）

location.origin                                  // 页面在哪个源（不是你的就认命）
document.querySelector('meta[http-equiv="Content-Security-Policy"]')?.content

content-security-policy: default-src 'self'; script-src 'self' https://cdn.xxx.com; connect-src 'self'

# 服务端视角通不通
curl -i -X POST https://api.example.com/v1/x \
  -H "content-type: application/json" -d '{"q":"test"}'

<!-- 受 connect-src 管，锁了就死 -->
<script>fetch('https://relay.mydomain.com/q')</script>
<script>new WebSocket('wss://relay.mydomain.com')</script>
<script>new EventSource('https://relay.mydomain.com/sse')</script>

<!-- 受 script-src 管，connect-src 管不着 -->
<script src="https://relay.mydomain.com/q?cb=cb1"></script>

Refused to load the script 'https://relay.mydomain.com/q' because it violates
the following Content Security Policy directive: "script-src 'self'"

宿主页面
  │ ① <script src=".../tk?cb=__jp0">                        取一次性令牌
  │ ② <script src=".../q?tk=...&reqId=...&q=你好&cb=__jp1">  发起
  ▼
Worker（持上游 Key）
  │ 1. Guard DO 核销 tk（原子，用一次就废）+ 令牌桶限流
  │ 2. sid 直接用 reqId 派生 → 重试落回同一个会话，不会重复扣费
  │ 3. Session DO 写状态、设 alarm，立刻返回 {sid, key}
  ▼
宿主页面拿到 sid 和 key
  │ ③ <script src=".../poll?sid=...&key=...&rev=0&rrev=0&cb=__jp2">
  ▼
Session DO：没有新增量就挂起 25 秒（不是空转）
  │ 有增量立刻返回 → __jp2({"d":"增量","next":7,"done":0})

/tk    → Guard DO 签发一次性令牌（5 分钟）
/q     → Guard 核销令牌 + 限流 → Session DO 启动生成 → 返回 {sid, key}
/poll  → Session DO 校验 key → 没有新增量就挂起 25s → 返回增量

// src/index.js
const CB_RE  = /^[A-Za-z_$][A-Za-z0-9_$.]{0,63}$/;
const SID_RE = /^[a-f0-9]{32}$/;
const URL_BUDGET = 2000;          // URL 上留给 q 的字节数（不是字符）
const REF_OK = ['app.builda.game', 'game.builda.game'];

// Referer 只是筛子，不是鉴权：能伪造、能被隐私设置抹掉
function refOk(req) {
  const ref = req.headers.get('referer') || '';
  try { return REF_OK.includes(ref ? new URL(ref).host : ''); }
  catch (e) { return false; }
}

function js(cb, obj, status = 200) {
  const body = cb
    ? cb + '(' + JSON.stringify(obj) + ')'
    : JSON.stringify(obj);
  return new Response(body, {
    status,
    headers: {
      'content-type': cb ? 'application/javascript; charset=utf-8' : 'application/json',
      'cache-control': 'no-store',
      'x-content-type-options': 'nosniff',
    },
  });
}

export default {
  async fetch(req, env) {
    const u  = new URL(req.url);
    const cb = u.searchParams.get('cb') || '';

    // ① callback 名白名单，防反射型 XSS
    if (cb && !CB_RE.test(cb)) return new Response('bad callback', { status: 400 });

    // ② 只放行三条路径，别做成任意代理
    const p = u.pathname;
    if (p !== '/tk' && p !== '/q' && p !== '/poll') return new Response('not found', { status: 404 });

    const guard = env.GUARD.get(env.GUARD.idFromName('guard'));

    // ── 签发一次性令牌 ───────────────────────────────
    if (p === '/tk') {
      if (!refOk(req)) return js(cb, { ok: false, err: 'forbidden' });

      // cid 是客户端首次生成的设备标识，用来分桶限流。
      // 不要用 IP 分桶：移动网络大量用户共享同一个出口 IP，会互相误伤。
      const cid = (u.searchParams.get('cid') || '').toLowerCase();
      if (!SID_RE.test(cid)) return js(cb, { ok: false, err: 'bad-cid' });

      const r = await guard.fetch('https://g/issue?uid=' + cid);
      return js(cb, await r.json());
    }

    // ── 发起 ─────────────────────────────────────────
    if (p === '/q') {
      if (!refOk(req)) return js(cb, { ok: false, err: 'forbidden' });

      const q  = u.searchParams.get('q') || '';
      const tk = u.searchParams.get('tk') || '';
      const reqId = (u.searchParams.get('reqId') || '').toLowerCase();

      if (!q.trim()) return js(cb, { ok: false, err: 'empty' });
      if (!SID_RE.test(reqId)) return js(cb, { ok: false, err: 'bad-req' });

      // 按"编码后字节数"算，中文一个字 9 字节，别拿字符数当预算
      if (encodeURIComponent(q).length > URL_BUDGET) {
        return js(cb, { ok: false, err: 'too-long' });
      }

      // 令牌核销：DO 内串行，先删后判，天然没有 TOCTOU
      const rr = await guard.fetch('https://g/redeem?tk=' + encodeURIComponent(tk));
      const rj = await rr.json();
      if (!rj.ok) return js(cb, { ok: false, err: 'bad-tk' });

      // 限流：同一个 DO 里的令牌桶，跨 isolate 有效
      const ar = await guard.fetch('https://g/allow?k=' + encodeURIComponent(rj.uid));
      if (!(await ar.json()).ok) return js(cb, { ok: false, err: 'rate' });

      // sid 直接用客户端传来的 reqId：重试落回同一个 DO，重复扣费自然消失
      const sid  = reqId;
      const stub = env.SESSION.get(env.SESSION.idFromName('s:' + sid));
      const t = new URL('https://s/start');
      t.searchParams.set('sid', sid);
      t.searchParams.set('q', q);
      t.searchParams.set('think', u.searchParams.get('think') || '');

      const st = await (await stub.fetch(t.toString())).json();
      if (!st.ok) return js(cb, st);
      return js(cb, { ok: true, sid, key: st.key });
    }

    // ── 取增量 ───────────────────────────────────────
    const sid = (u.searchParams.get('sid') || '').toLowerCase();
    const key = u.searchParams.get('key') || '';
    if (!SID_RE.test(sid)) return js(cb, { ok: false, err: 'bad-sid' });

    const stub = env.SESSION.get(env.SESSION.idFromName('s:' + sid));
    const t = new URL('https://s/poll');
    t.searchParams.set('key', key);
    t.searchParams.set('rev',  u.searchParams.get('rev')  || '0');
    t.searchParams.set('rrev', u.searchParams.get('rrev') || '0');

    const r = await stub.fetch(t.toString());

    // 关键：先 JSON.parse 再 stringify。
    // 上游 502 时会吐一整页 HTML，直接拼进 JS 就是语法错误 + 可控注入面。
    let obj;
    try { obj = JSON.parse(await r.text()); }
    catch (e) { obj = { ok: false, err: 'bad-payload' }; }
    return js(cb, obj);
  },
};

const REF_OK = ['app.builda.game', 'game.builda.game'];

// src/session.js
export class Session {
  // 构造函数里恢复一次：DO 被驱逐后重新拉起时内存是空的，
  // 不恢复就会出现"轮询永远返回空、done 永远是 0"。
  constructor(state, env) {
    this.state = state;
    this.env = env;
    this.chunks  = [];      // 正文增量，按块存，游标是块序号
    this.rchunks = [];      // 思考增量
    this.rev = 0;
    this.rrev = 0;
    this.done = 0;
    this.err = '';
    this.key = '';
    this.at = 0;
    this.waiters = [];

    state.blockConcurrencyWhile(async () => {
      const meta = await state.storage.get('meta');
      if (!meta) return;
      this.key  = meta.key || '';
      this.done = meta.done || 0;
      this.err  = meta.err || '';
      this.chunks  = (await state.storage.get('chunks'))  || [];
      this.rchunks = (await state.storage.get('rchunks')) || [];
      this.rev  = this.chunks.length;
      this.rrev = this.rchunks.length;
      this.at   = meta.at || 0;
    });
  }

  async fetch(req) {
    const u = new URL(req.url);
    if (u.pathname === '/start') return this.start(u);
    return this.poll(u);
  }

  // ── 启动：只写状态、起 alarm，不在这里跑生成 ──
  async start(u) {
    // 幂等：同一个 sid 重试多少次，都返回同一把 key
    if (this.key) return Response.json({ ok: true, key: this.key });

    this.key = crypto.randomUUID().replace(/-/g, '');
    await this.state.storage.put('meta', {
      sid: u.searchParams.get('sid'),
      key: this.key,
      q: u.searchParams.get('q') || '',
      think: u.searchParams.get('think') === '1',
      at: Date.now(),
    });

    // 用 alarm 触发，而不是 waitUntil：
    // waitUntil 在响应后只有约 30 秒，生成动辄 60 秒以上，长回答会被腰斩，
    // 而且表现为"永远没有 done"，客户端只能等到自己的总超时。
    await this.state.storage.setAlarm(Date.now() + 50);
    return Response.json({ ok: true, key: this.key });
  }

  // ── 生成在 alarm 里跑 ──
  async alarm() {
    const meta = await this.state.storage.get('meta');
    if (!meta) return;

    // alarm 至少投递一次：如果上次跑到一半 DO 被驱逐，这次会重入。
    // 不挡一下就会重复调用上游、重复计费。
    if (meta.running && !this.done) {
      this.err = 'interrupted';
      this.done = 1;
      await this.state.storage.put('meta', { ...meta, done: 1, err: this.err, at: Date.now() });
      return;
    }

    if (this.done) {
      // 已完成：再等 10 分钟无人访问就回收，DO 不会自己过期
      if (Date.now() - (this.at || meta.at) > 600000) {
        await this.state.storage.deleteAll();
        return;
      }
      await this.state.storage.setAlarm(Date.now() + 60000);
      return;
    }

    await this.state.storage.put('meta', { ...meta, running: 1 });

    await this.run(meta.q, meta.think);
    this.done = 1;
    this.at = Date.now();
    await this.state.storage.put('meta', { ...meta, done: 1, err: this.err, at: this.at });
    this.wake();
    // 留一个 alarm 做回收
    await this.state.storage.setAlarm(Date.now() + 60000);
  }

  async run(q, think) {
    const ctl = new AbortController();

    try {
      const up = await fetch('https://api.example.com/v1/chat', {
        method: 'POST',
        headers: {
          'content-type': 'application/json',
          authorization: 'Bearer ' + this.env.UP_KEY,
        },
        body: JSON.stringify({ q, think, stream: true }),
        signal: ctl.signal,
      });

      if (!up.ok) throw new Error('HTTP ' + up.status);

      const reader = up.body.getReader();
      const dec = new TextDecoder();
      let buf = '';
      let dirty = 0;
      let lastFlush = Date.now();

      for (;;) {
        // 20 秒没有任何新数据就判死，否则永远转圈
        let idle = null;
        const guard = new Promise((_, rej) => {
          idle = setTimeout(() => rej(new Error('idle-timeout')), 20000);
        });

        let it;
        try {
          it = await Promise.race([reader.read(), guard]);
        } finally {
          clearTimeout(idle);
        }

        if (it.done) break;
        buf += dec.decode(it.value, { stream: true });

        let cut;
        while ((cut = buf.indexOf('\n')) >= 0) {
          const line = buf.slice(0, cut).trim();
          buf = buf.slice(cut + 1);
          if (!line.startsWith('data:')) continue;

          const payload = line.slice(5).trim();
          if (payload === '[DONE]') { this.done = 1; return; }

          let j;
          try { j = JSON.parse(payload); } catch (e) { continue; }
          const d = j.choices && j.choices[0] && j.choices[0].delta;
          if (!d) continue;

          // 一块一块追加，游标就是块的序号，永远不会切在半个 emoji 上
          if (d.reasoning_content) { this.rchunks.push(d.reasoning_content); this.rrev++; }
          if (d.content)           { this.chunks.push(d.content);            this.rev++;  }
          dirty++;
          this.wake();

          if (dirty >= 20 || Date.now() - lastFlush > 2000) {
            await this.state.storage.put('chunks',  this.chunks);
            await this.state.storage.put('rchunks', this.rchunks);
            dirty = 0;
            lastFlush = Date.now();
          }
        }
      }
      this.done = 1;
    } catch (e) {
      this.err = String((e && e.message) || e);
      this.done = 1;
    }
  }

  // ── 取增量：没有新内容就挂起 ──
  async poll(u) {
    const key = u.searchParams.get('key') || '';
    if (!this.key) return Response.json({ ok: false, err: 'no-session' });

    // sid 会出现在宿主网络日志、CDN 日志、用户截图里，
    // 必须有第二因子，否则拿到 sid 的人能 from=0 拉走整段对话。
    if (key !== this.key) return Response.json({ ok: false, err: 'forbidden' });

    const rev  = Math.max(0, Number(u.searchParams.get('rev'))  || 0);
    const rrev = Math.max(0, Number(u.searchParams.get('rrev')) || 0);

    // 服务端挂起：有增量立刻回，没有就等，最多 25 秒。
    // 客户端从"每 300ms 轮一次、一次问答 600 个请求"降到 6–10 个请求。
    await this.waitFor(rev, rrev, 25000);

    return Response.json({
      d:     this.chunks.slice(rev).join(''),
      next:  this.rev,          // 不透明游标：客户端只负责原样回传
      rd:    this.rchunks.slice(rrev).join(''),
      rnext: this.rrev,
      done:  this.done,
      err:   this.err,
    });
  }

  waitFor(rev, rrev, ms) {
    if (this.rev > rev || this.rrev > rrev || this.done) return Promise.resolve();
    return new Promise((resolve) => {
      const done = () => {
        clearTimeout(timer);
        const i = this.waiters.indexOf(done);
        if (i >= 0) this.waiters.splice(i, 1);
        resolve();
      };
      const timer = setTimeout(done, ms);
      this.waiters.push(done);
    });
  }

  wake() {
    const list = this.waiters.splice(0);
    for (const f of list) f();
  }
}

// src/guard.js
const RATE = 20 / 60000;   // 20 次/分钟
const CAP  = 20;

export class Guard {
  constructor(state) {
    this.state = state;
    this.tk = new Map();     // tk → { uid, exp }
    this.bk = new Map();     // uid → { tokens, at }
  }

  async fetch(req) {
    const u = new URL(req.url);
    const now = Date.now();

    if (u.pathname === '/issue') {
      const tk = crypto.randomUUID().replace(/-/g, '');
      const uid = u.searchParams.get('uid') || 'anon';
      this.tk.set(tk, { uid, exp: now + 300000 });
      await this.state.storage.setAlarm(now + 60000);
      return Response.json({ ok: true, tk });
    }

    if (u.pathname === '/redeem') {
      const tk = u.searchParams.get('tk') || '';
      const v = this.tk.get(tk);
      // 先删再看：DO 单线程串行，两次并发核销一定一前一后，
      // 第二次拿到 undefined。这是 KV 的 get-delete 做不到的。
      this.tk.delete(tk);
      if (!v || v.exp < now) return Response.json({ ok: false, err: 'bad-tk' });
      return Response.json({ ok: true, uid: v.uid });
    }

    if (u.pathname === '/allow') {
      const k = u.searchParams.get('k') || 'anon';
      let b = this.bk.get(k) || { tokens: CAP, at: now };
      b.tokens = Math.min(CAP, b.tokens + (now - b.at) * RATE);
      b.at = now;
      const ok = b.tokens >= 1;
      if (ok) b.tokens -= 1;
      this.bk.set(k, b);
      return Response.json({ ok });
    }

    return Response.json({ ok: false }, { status: 404 });
  }

  async alarm() {
    const now = Date.now();
    for (const [k, v] of this.tk) if (v.exp < now) this.tk.delete(k);
    for (const [k, v] of this.bk) if (now - v.at > 3600000) this.bk.delete(k);
    if (this.tk.size || this.bk.size) await this.state.storage.setAlarm(now + 60000);
  }
}

name = "my-relay"
main = "src/index.js"
compatibility_date = "2026-11-01"

[[durable_objects.bindings]]
name = "SESSION"
class_name = "Session"

[[durable_objects.bindings]]
name = "GUARD"
class_name = "Guard"

[[migrations]]
tag = "v1"
new_sqlite_classes = ["Session", "Guard"]

[[routes]]
pattern = "relay.mydomain.com/*"
zone_name = "mydomain.com"      # 根域（已接入 Cloudflare 的那个），不是子域

wrangler secret put UP_KEY
wrangler deploy

import express from 'express';
import crypto from 'node:crypto';

const app = express();

const SESS = new Map();     // sid → 会话
const TK   = new Map();     // tk  → 过期时间
const BUCKET = new Map();   // uid → 令牌桶

const CB_RE = /^[A-Za-z_$][A-Za-z0-9_$.]{0,63}$/;
const RATE = 20 / 60000, CAP = 20;

function reply(req, res, payload) {
  const cb = String(req.query.cb || '');
  res.set('Cache-Control', 'no-store');
  res.set('X-Content-Type-Options', 'nosniff');
  if (!cb) return res.json(payload);
  if (!CB_RE.test(cb)) return res.status(400).type('text/plain').send('bad callback');
  res.type('application/javascript').send(`${cb}(${JSON.stringify(payload)})`);
}

function allow(k) {
  const now = Date.now();
  const b = BUCKET.get(k) || { tokens: CAP, at: now };
  b.tokens = Math.min(CAP, b.tokens + (now - b.at) * RATE);
  b.at = now;
  const ok = b.tokens >= 1;
  if (ok) b.tokens -= 1;
  BUCKET.set(k, b);
  return ok;
}

// ① 发一次性令牌
app.get('/tk', (req, res) => {
  const tk = crypto.randomBytes(16).toString('hex');
  TK.set(tk, Date.now() + 300000);
  reply(req, res, { ok: true, tk });
});

// ② 发起
app.get('/q', (req, res) => {
  const tk = String(req.query.tk || '');
  const exp = TK.get(tk);
  TK.delete(tk);                                  // 单进程同步执行，天然原子
  if (!exp || exp < Date.now()) return reply(req, res, { ok: false, err: 'bad-tk' });

  const reqId = String(req.query.reqId || '');
  if (!/^[a-f0-9]{32}$/.test(reqId)) return reply(req, res, { ok: false, err: 'bad-req' });

  if (!allow('u')) return reply(req, res, { ok: false, err: 'rate' });

  const q = String(req.query.q || '');
  if (!q.trim()) return reply(req, res, { ok: false, err: 'empty' });
  if (encodeURIComponent(q).length > 2000) return reply(req, res, { ok: false, err: 'too-long' });

  let st = SESS.get(reqId);
  if (!st) {
    // 同一个 reqId 只跑一次：客户端超时重试不会重复触发上游、重复扣费
    st = {
      chunks: [], rchunks: [], done: 0, err: '',
      key: crypto.randomBytes(16).toString('hex'),
      at: Date.now(), waiters: [],
    };
    SESS.set(reqId, st);
    runUpstream(q, st);
  }
  reply(req, res, { ok: true, sid: reqId, key: st.key });
});

// ③ 取增量（没有新内容就挂起）
app.get('/poll', async (req, res) => {
  const st = SESS.get(String(req.query.sid));
  if (!st) return reply(req, res, { ok: false, err: 'no-session' });
  if (String(req.query.key) !== st.key) return reply(req, res, { ok: false, err: 'forbidden' });

  const rev  = Math.max(0, Number(req.query.rev)  || 0);
  const rrev = Math.max(0, Number(req.query.rrev) || 0);
  st.at = Date.now();

  await waitFor(st, rev, rrev, 25000);

  reply(req, res, {
    d: st.chunks.slice(rev).join(''),
    next: st.chunks.length,          // 不透明游标，客户端原样回传
    rd: st.rchunks.slice(rrev).join(''),
    rnext: st.rchunks.length,
    done: st.done,
    err: st.err,
  });
});

function waitFor(st, rev, rrev, ms) {
  if (st.chunks.length > rev || st.rchunks.length > rrev || st.done) return Promise.resolve();
  return new Promise((resolve) => {
    const fire = () => {
      clearTimeout(timer);
      const i = st.waiters.indexOf(fire);
      if (i >= 0) st.waiters.splice(i, 1);
      resolve();
    };
    const timer = setTimeout(fire, ms);
    st.waiters.push(fire);
  });
}

async function runUpstream(q, st) {
  try {
    const up = await fetch('https://api.example.com/v1/chat', {
      method: 'POST',
      headers: {
        'content-type': 'application/json',
        authorization: 'Bearer ' + process.env.UP_KEY,
      },
      body: JSON.stringify({ q, stream: true }),
      signal: AbortSignal.timeout(120000),
    });
    if (!up.ok) throw new Error('HTTP ' + up.status);

    const reader = up.body.getReader();
    const dec = new TextDecoder();
    let buf = '';

    for (;;) {
      const { done, value } = await reader.read();
      if (done) break;
      buf += dec.decode(value, { stream: true });

      let cut;
      while ((cut = buf.indexOf('\n')) >= 0) {
        const line = buf.slice(0, cut).trim();
        buf = buf.slice(cut + 1);
        if (!line.startsWith('data:')) continue;

        const payload = line.slice(5).trim();
        if (payload === '[DONE]') { st.done = 1; wake(st); return; }

        let j;
        try { j = JSON.parse(payload); } catch { continue; }
        const d = j.choices && j.choices[0] && j.choices[0].delta;
        if (!d) continue;

        // 按块存，游标是块序号：不会把 emoji 的代理对切成两半
        if (d.reasoning_content) st.rchunks.push(d.reasoning_content);
        if (d.content)           st.chunks.push(d.content);
        wake(st);
      }
    }
    st.done = 1;
    wake(st);
  } catch (e) {
    st.err = String((e && e.message) || e);
    st.done = 1;
    wake(st);
  } finally {
    st.at = Date.now();
  }
}

function wake(st) {
  for (const f of st.waiters.splice(0)) f();
}

// 十分钟没人取就回收，否则文本常驻内存
setInterval(() => {
  const now = Date.now();
  for (const [k, v] of SESS) if (now - v.at > 600000) SESS.delete(k);
  for (const [k, v] of TK) if (v < now) TK.delete(k);
  for (const [k, v] of BUCKET) if (now - v.at > 3600000) BUCKET.delete(k);
}, 60000);

app.listen(8787);

let seq = 0;

function jsonp(url, timeout = 30000) {
  return new Promise((resolve, reject) => {
    const name = '__jp' + Date.now().toString(36) + (seq++);
    const script = document.createElement('script');
    let settled = false;

    const cleanup = () => {
      try { delete window[name]; } catch (e) { window[name] = undefined; }
      if (script.parentNode) script.parentNode.removeChild(script);
      clearTimeout(timer);
    };

    window[name] = (data) => {
      if (settled) return;
      settled = true;
      resolve(data);
      cleanup();
    };

    const timer = setTimeout(() => {
      if (settled) return;
      settled = true;
      reject(new Error('jsonp-timeout'));
      cleanup();
    }, timeout);

    script.onerror = () => {
      if (settled) return;
      settled = true;
      reject(new Error('jsonp-network'));
      cleanup();
    };

    script.src = url + (url.indexOf('?') >= 0 ? '&' : '?') + 'cb=' + name;
    script.async = true;
    document.head.appendChild(script);
  });
}

function randId() {
  const b = new Uint8Array(16);
  crypto.getRandomValues(b);
  return [...b].map(x => x.toString(16).padStart(2, '0')).join('');
}

// ① 设备标识：首次生成后持久化，用来分桶限流（换设备即换桶）
function cid() {
  let v = localStorage.getItem('cid');
  if (!v) { v = randId(); localStorage.setItem('cid', v); }
  return v;
}

// ② 取一次性令牌（可以预取，5 分钟内有效）
const t = await jsonp('/tk?cid=' + cid(), 15000);
if (!t.ok) throw new Error(t.err || 'tk-failed');

// ③ 发起：reqId 由客户端生成，重试沿用同一个
const reqId = randId();
const r = await jsonp('/q?tk=' + t.tk + '&reqId=' + reqId + '&q=' + encodeURIComponent('你好'), 20000);
if (!r.ok) throw new Error(r.err);

const { sid, key } = r;   // key 只在 poll 的 URL 里出现，不落任何存储

// ✓ 正确：编码后的字节数
const okByByte = encodeURIComponent(q).length <= 2000;

// ✗ 错误：字符数，中文会超 9 倍
const wrongByChar = q.length <= 2000;

① GET /tk                       →  {ok:true, tk}                5 分钟有效
② GET /q?tk&reqId&q&cb          →  {ok:true, sid, key}          立即返回
③ GET /poll?sid&key&rev&rrev    →  {d, next, rd, rnext, done}   挂起 25s
④ rev = next, rrev = rnext，重复 ③
⑤ done:1 或 err 非空 → 结束

async function ask(question, onDelta, onReason, signal) {
  // ① 令牌（cid() 见 4.2）
  const t = await jsonp('/tk?cid=' + cid(), 15000);
  if (!t.ok) throw new Error(t.err || 'tk-failed');

  // ② 发起：reqId 固定，重试不会重复扣费
  const reqId = randId();
  const start = await jsonp(
    '/q?tk=' + t.tk + '&reqId=' + reqId + '&q=' + encodeURIComponent(question), 20000);
  if (!start.ok) throw new Error(start.err || 'start-failed');

  const { sid, key } = start;

  let rev = 0, rrev = 0;
  const startedAt = Date.now();
  const LIMIT = 180000;          // 只算"页面在前台"的时间
  let hiddenAt = 0, hiddenMs = 0;

  const onVis = () => {
    if (document.hidden) hiddenAt = Date.now();
    else if (hiddenAt) { hiddenMs += Date.now() - hiddenAt; hiddenAt = 0; }
  };
  document.addEventListener('visibilitychange', onVis);

  try {
    while (Date.now() - startedAt - hiddenMs < LIMIT) {
      if (signal && signal.aborted) throw new Error('aborted');

      const r = await jsonp(
        `/poll?sid=${sid}&key=${key}&rev=${rev}&rrev=${rrev}`, 30000);

      if (r.err && r.err !== 'expired') throw new Error(r.err);

      if (r.d)  { onDelta(r.d);   rev  = r.next;  }
      if (r.rd) { onReason(r.rd); rrev = r.rnext; }
      if (r.done) return;

      // 服务端已经挂了 25 秒，正常情况下这里立刻就能进下一轮，
      // 不需要再 sleep(300) 空转；只有服务端提前返回空才补 200ms。
      if (!r.d && !r.rd) await sleep(200);
    }
    throw new Error('timeout');
  } finally {
    document.removeEventListener('visibilitychange', onVis);
  }
}

本机 curl 上游：200
Worker 调上游：429 / 403，稳定复现
换一把 Key：还是 429

宿主页面 ──script──▶ Worker ──▶ VPS / 云函数（独立 IP）──▶ 上游

relay2.mydomain.com {
    @bad not header X-Relay-Token "你的随机长串"
    respond @bad 403

    reverse_proxy https://api.example.com {
        header_up Host api.example.com
        flush_interval -1
    }
}

const up = await fetch('https://relay2.mydomain.com/v1/chat', {
  method: 'POST',
  headers: {
    'content-type': 'application/json',
    'x-relay-token': this.env.RELAY_TOKEN,
  },
  body,
});