@ractive-ch/tab-mcp 0.0.0-stage → 0.1.0-alpha.1

package/index.js

@@ -0,0 +1,3558 @@
+// @bun
+// src/address.ts
+var BASE32_ALPHABET = "abcdefghijklmnopqrstuvwxyz234567";
+function base32(bytes) {
+  let out = "";
+  let buffer = 0;
+  let bits = 0;
+  for (const byte of bytes) {
+    buffer = buffer << 8 | byte;
+    bits += 8;
+    while (bits >= 5) {
+      bits -= 5;
+      out += BASE32_ALPHABET[buffer >>> bits & 31];
+    }
+    buffer &= (1 << bits) - 1;
+  }
+  if (bits > 0)
+    out += BASE32_ALPHABET[buffer << 5 - bits & 31];
+  return out;
+}
+var SECRET_PATTERN = /^[A-Za-z0-9_-]{43}$/;
+var ADDRESS_ID_PATTERN = /^[a-z2-7]{52}$/;
+function isWellFormedSecret(secret) {
+  return SECRET_PATTERN.test(secret);
+}
+function isAddressId(id) {
+  return ADDRESS_ID_PATTERN.test(id);
+}
+function addressIdFromSecret(secret) {
+  const digest = new Bun.CryptoHasher("sha256").update(secret).digest();
+  return base32(new Uint8Array(digest.buffer, digest.byteOffset, digest.length));
+}
+function newSecret() {
+  return crypto.getRandomValues(new Uint8Array(32)).toBase64({ alphabet: "base64url", omitPadding: true });
+}
+function shortAddress(id) {
+  return id.slice(0, 8);
+}
+// src/config.ts
+var MIN_MESSAGE_BYTES = 16384;
+var MAX_APP_NAME = 64;
+var DEFAULT_CONFIG = {
+  port: 8080,
+  host: "0.0.0.0",
+  allowedOrigins: [],
+  sites: [],
+  clientIdHosts: [],
+  trustProxy: "none",
+  cors: true,
+  store: "sqlite",
+  sqlitePath: "tab-mcp.db",
+  maxSessions: 500,
+  maxSessionsPerIp: 5,
+  maxConcurrentRequests: 8,
+  requestTimeoutMs: 300000,
+  keepAliveMs: 20000,
+  idleTimeoutMs: 3600000,
+  sessionLifetimeMs: 43200000,
+  heartbeatMs: 25000,
+  helloTimeoutMs: 1e4,
+  bodyTimeoutMs: 1e4,
+  maxMessageBytes: 1048576,
+  accessTokenTtlMs: 3600000,
+  refreshTokenTtlMs: 2592000000,
+  grantLifetimeMs: 7776000000,
+  sweepIntervalMs: 600000,
+  backpressureLimitBytes: 4 * 1048576,
+  httpIdleTimeoutS: 30,
+  logLevel: "info",
+  development: false
+};
+
+class ConfigError extends Error {
+  name = "ConfigError";
+}
+function normalizeOrigin(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new ConfigError(`not an origin: ${value}`);
+  }
+  if (url.protocol !== "https:" && url.protocol !== "http:") {
+    throw new ConfigError(`origin must be http or https: ${value}`);
+  }
+  if (url.pathname !== "/" && url.pathname !== "" || url.search !== "" || url.hash !== "" || url.username !== "" || url.password !== "") {
+    throw new ConfigError(`an origin has no path, query or credentials (browsers send only the origin): ${value}`);
+  }
+  return url.origin;
+}
+function resolveConfig(input = {}) {
+  const config = { ...DEFAULT_CONFIG, ...input };
+  if (config.publicUrl !== undefined) {
+    const origin = normalizeOrigin(config.publicUrl);
+    if (!origin.startsWith("https:") && !config.development) {
+      throw new ConfigError("TAB_MCP_PUBLIC_URL must be https outside development");
+    }
+    config.publicUrl = origin;
+  } else if (!config.development) {
+    throw new ConfigError("TAB_MCP_PUBLIC_URL is required");
+  }
+  if (config.allowedOrigins !== "*") {
+    config.allowedOrigins = config.allowedOrigins.map(normalizeOrigin);
+  }
+  config.sites = config.sites.map((site) => validateSite(site));
+  const seen = new Set(config.allowedOrigins === "*" ? [] : config.allowedOrigins);
+  for (const site of config.sites) {
+    if (seen.has(site.origin)) {
+      throw new ConfigError(`origin configured twice: ${site.origin}`);
+    }
+    seen.add(site.origin);
+  }
+  config.clientIdHosts = config.clientIdHosts.map((h) => {
+    const host = h.trim().toLowerCase();
+    if (!/^[a-z0-9.-]+(:\d+)?$/.test(host)) {
+      throw new ConfigError(`not a host name: ${h}`);
+    }
+    return host;
+  });
+  const positive = [
+    "maxSessions",
+    "maxSessionsPerIp",
+    "maxConcurrentRequests",
+    "requestTimeoutMs",
+    "keepAliveMs",
+    "idleTimeoutMs",
+    "sessionLifetimeMs",
+    "heartbeatMs",
+    "helloTimeoutMs",
+    "bodyTimeoutMs",
+    "maxMessageBytes",
+    "accessTokenTtlMs",
+    "refreshTokenTtlMs",
+    "grantLifetimeMs",
+    "sweepIntervalMs",
+    "backpressureLimitBytes",
+    "httpIdleTimeoutS"
+  ];
+  for (const key of positive) {
+    const v = config[key];
+    if (typeof v !== "number" || !Number.isFinite(v) || v <= 0) {
+      throw new ConfigError(`${key} must be a positive number`);
+    }
+  }
+  if (config.maxMessageBytes < MIN_MESSAGE_BYTES) {
+    throw new ConfigError(`maxMessageBytes must be at least ${MIN_MESSAGE_BYTES} (16 KiB)`);
+  }
+  if (config.httpIdleTimeoutS > 255) {
+    throw new ConfigError("httpIdleTimeoutS must be at most 255");
+  }
+  if (!Number.isInteger(config.port) || config.port < 0 || config.port > 65535) {
+    throw new ConfigError("port must be 0-65535");
+  }
+  return config;
+}
+var SITE_KEYS = new Set(["origin", "name", "pairing", "limits"]);
+var LIMIT_KEYS = [
+  "maxMessageBytes",
+  "maxConcurrentRequests",
+  "requestTimeoutMs",
+  "keepAliveMs",
+  "idleTimeoutMs",
+  "sessionLifetimeMs",
+  "heartbeatMs"
+];
+function isAppName(value) {
+  return typeof value === "string" && value.trim().length > 0 && value.length <= MAX_APP_NAME && ![...value].some((ch) => {
+    const c = ch.codePointAt(0) ?? 0;
+    return c < 32 || c >= 127 && c <= 159;
+  });
+}
+function validateSite(input) {
+  if (typeof input !== "object" || input === null || Array.isArray(input)) {
+    throw new ConfigError("a site must be an object with an origin");
+  }
+  const site = input;
+  for (const key of Object.keys(site)) {
+    if (!SITE_KEYS.has(key))
+      throw new ConfigError(`unknown site key: ${key}`);
+  }
+  if (typeof site["origin"] !== "string") {
+    throw new ConfigError("a site needs an origin");
+  }
+  const out = { origin: normalizeOrigin(site["origin"]) };
+  if (site["name"] !== undefined) {
+    if (!isAppName(site["name"])) {
+      throw new ConfigError(`site name must be 1-${MAX_APP_NAME} characters: ${out.origin}`);
+    }
+    out.name = site["name"];
+  }
+  const pairing = site["pairing"];
+  if (pairing !== undefined && pairing !== "code") {
+    if (pairing === "oidc") {
+      throw new ConfigError(`pairing "oidc" (identity binding) is planned but not available yet: ${out.origin}`);
+    }
+    throw new ConfigError(`pairing must be "code": ${out.origin}`);
+  }
+  out.pairing = "code";
+  const limits = site["limits"];
+  if (limits !== undefined) {
+    if (typeof limits !== "object" || limits === null) {
+      throw new ConfigError(`site limits must be an object: ${out.origin}`);
+    }
+    const given = limits;
+    const parsed = {};
+    for (const [key, value] of Object.entries(given)) {
+      if (!LIMIT_KEYS.includes(key)) {
+        throw new ConfigError(`unknown site limit: ${key}`);
+      }
+      if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+        throw new ConfigError(`site limit ${key} must be a positive number`);
+      }
+      parsed[key] = value;
+    }
+    if (parsed.maxMessageBytes !== undefined && parsed.maxMessageBytes < MIN_MESSAGE_BYTES) {
+      throw new ConfigError(`site limit maxMessageBytes must be at least ${MIN_MESSAGE_BYTES}`);
+    }
+    out.limits = parsed;
+  }
+  return out;
+}
+function defaultLimits(config) {
+  return {
+    maxMessageBytes: config.maxMessageBytes,
+    maxConcurrentRequests: config.maxConcurrentRequests,
+    requestTimeoutMs: config.requestTimeoutMs,
+    keepAliveMs: config.keepAliveMs,
+    idleTimeoutMs: config.idleTimeoutMs,
+    sessionLifetimeMs: config.sessionLifetimeMs,
+    heartbeatMs: config.heartbeatMs
+  };
+}
+function siteFor(config, origin) {
+  const defaults = defaultLimits(config);
+  const configured = origin === null ? undefined : config.sites.find((s) => s.origin === origin);
+  if (configured !== undefined) {
+    const site = {
+      origin: configured.origin,
+      pairing: configured.pairing ?? "code",
+      limits: { ...defaults, ...configured.limits }
+    };
+    if (configured.name !== undefined)
+      site.name = configured.name;
+    return site;
+  }
+  if (config.allowedOrigins === "*" || origin !== null && config.allowedOrigins.includes(origin)) {
+    return {
+      origin: config.allowedOrigins === "*" ? "*" : origin ?? "",
+      pairing: "code",
+      limits: defaults
+    };
+  }
+  return;
+}
+function largestMessageBytes(config) {
+  return Math.max(config.maxMessageBytes, ...config.sites.map((s) => s.limits?.maxMessageBytes ?? 0));
+}
+function seconds(env, name) {
+  const raw = env[name];
+  if (raw === undefined || raw === "")
+    return;
+  const n = Number(raw);
+  if (!Number.isFinite(n) || n <= 0) {
+    throw new ConfigError(`${name} must be a positive number of seconds`);
+  }
+  return Math.round(n * 1000);
+}
+function integer(env, name) {
+  const raw = env[name];
+  if (raw === undefined || raw === "")
+    return;
+  const n = Number(raw);
+  if (!Number.isInteger(n) || n < 0) {
+    throw new ConfigError(`${name} must be a whole number`);
+  }
+  return n;
+}
+function oneOf(env, name, values) {
+  const raw = env[name];
+  if (raw === undefined || raw === "")
+    return;
+  if (!values.includes(raw)) {
+    throw new ConfigError(`${name} must be one of ${values.join(", ")}`);
+  }
+  return raw;
+}
+function configFromEnv(env) {
+  const out = {};
+  const set = (key, value) => {
+    if (value !== undefined)
+      out[key] = value;
+  };
+  set("development", env["NODE_ENV"] === "development" ? true : undefined);
+  const publicUrl = env["TAB_MCP_PUBLIC_URL"];
+  if (publicUrl !== undefined && publicUrl !== "")
+    out.publicUrl = publicUrl;
+  set("port", integer(env, "TAB_MCP_PORT"));
+  const host = env["TAB_MCP_HOST"];
+  if (host !== undefined && host !== "")
+    out.host = host;
+  const origins = env["TAB_MCP_ALLOWED_ORIGINS"];
+  if (origins !== undefined) {
+    const trimmed = origins.trim();
+    out.allowedOrigins = trimmed === "*" ? "*" : trimmed.split(",").map((s) => s.trim()).filter((s) => s !== "");
+  }
+  const sites = env["TAB_MCP_SITES"];
+  if (sites !== undefined && sites.trim() !== "") {
+    let parsed;
+    try {
+      parsed = JSON.parse(sites);
+    } catch {
+      throw new ConfigError("TAB_MCP_SITES must be a JSON array of sites");
+    }
+    if (!Array.isArray(parsed)) {
+      throw new ConfigError("TAB_MCP_SITES must be a JSON array of sites");
+    }
+    out.sites = parsed;
+  }
+  const hosts = env["TAB_MCP_CLIENT_ID_HOSTS"];
+  if (hosts !== undefined && hosts.trim() !== "") {
+    out.clientIdHosts = hosts.split(",").map((h) => h.trim()).filter((h) => h !== "");
+  }
+  set("trustProxy", oneOf(env, "TAB_MCP_TRUST_PROXY", [
+    "none",
+    "x-real-ip",
+    "x-forwarded-for"
+  ]));
+  const cors = oneOf(env, "TAB_MCP_CORS", ["on", "off"]);
+  if (cors !== undefined)
+    out.cors = cors === "on";
+  set("store", oneOf(env, "TAB_MCP_STORE", ["sqlite", "memory"]));
+  const sqlitePath = env["TAB_MCP_SQLITE_PATH"];
+  if (sqlitePath !== undefined && sqlitePath !== "")
+    out.sqlitePath = sqlitePath;
+  set("maxSessions", integer(env, "TAB_MCP_MAX_SESSIONS"));
+  set("maxSessionsPerIp", integer(env, "TAB_MCP_MAX_SESSIONS_PER_IP"));
+  set("maxConcurrentRequests", integer(env, "TAB_MCP_MAX_CONCURRENT_REQUESTS"));
+  set("requestTimeoutMs", seconds(env, "TAB_MCP_REQUEST_TIMEOUT_S"));
+  set("keepAliveMs", seconds(env, "TAB_MCP_KEEPALIVE_S"));
+  set("idleTimeoutMs", seconds(env, "TAB_MCP_IDLE_TIMEOUT_S"));
+  set("sessionLifetimeMs", seconds(env, "TAB_MCP_SESSION_LIFETIME_S"));
+  set("heartbeatMs", seconds(env, "TAB_MCP_HEARTBEAT_S"));
+  set("bodyTimeoutMs", seconds(env, "TAB_MCP_BODY_TIMEOUT_S"));
+  set("maxMessageBytes", integer(env, "TAB_MCP_MAX_MESSAGE_BYTES"));
+  set("accessTokenTtlMs", seconds(env, "TAB_MCP_ACCESS_TOKEN_TTL_S"));
+  set("refreshTokenTtlMs", seconds(env, "TAB_MCP_REFRESH_TOKEN_TTL_S"));
+  set("grantLifetimeMs", seconds(env, "TAB_MCP_GRANT_LIFETIME_S"));
+  set("logLevel", oneOf(env, "TAB_MCP_LOG_LEVEL", [
+    "error",
+    "warn",
+    "info",
+    "debug"
+  ]));
+  return out;
+}
+// src/ip.ts
+function parseIpv4(ip) {
+  const parts = ip.split(".");
+  if (parts.length !== 4)
+    return;
+  const octets = parts.map((p) => /^\d{1,3}$/.test(p) ? Number(p) : -1);
+  return octets.every((o) => o >= 0 && o <= 255) ? octets : undefined;
+}
+function parseIpv6(ip) {
+  const address = ip.split("%")[0] ?? "";
+  const halves = address.split("::");
+  if (halves.length > 2)
+    return;
+  const parseSide = (side) => {
+    if (side === "")
+      return [];
+    const groups = [];
+    const items = side.split(":");
+    for (const [i, item] of items.entries()) {
+      if (i === items.length - 1 && item.includes(".")) {
+        const v4 = parseIpv4(item);
+        if (v4 === undefined)
+          return;
+        groups.push((v4[0] ?? 0) << 8 | (v4[1] ?? 0), (v4[2] ?? 0) << 8 | (v4[3] ?? 0));
+      } else if (/^[0-9a-fA-F]{1,4}$/.test(item)) {
+        groups.push(Number.parseInt(item, 16));
+      } else {
+        return;
+      }
+    }
+    return groups;
+  };
+  const head = parseSide(halves[0] ?? "");
+  const tail = halves.length === 2 ? parseSide(halves[1] ?? "") : [];
+  if (head === undefined || tail === undefined)
+    return;
+  if (halves.length === 1)
+    return head.length === 8 ? head : undefined;
+  const missing = 8 - head.length - tail.length;
+  if (missing < 1)
+    return;
+  return [...head, ...new Array(missing).fill(0), ...tail];
+}
+var PRIVATE_V4 = [
+  [0, 0, 0, 0, 8],
+  [10, 0, 0, 0, 8],
+  [100, 64, 0, 0, 10],
+  [127, 0, 0, 0, 8],
+  [169, 254, 0, 0, 16],
+  [172, 16, 0, 0, 12],
+  [192, 0, 0, 0, 24],
+  [192, 0, 2, 0, 24],
+  [192, 88, 99, 0, 24],
+  [192, 168, 0, 0, 16],
+  [198, 18, 0, 0, 15],
+  [198, 51, 100, 0, 24],
+  [203, 0, 113, 0, 24],
+  [224, 0, 0, 0, 4],
+  [240, 0, 0, 0, 4]
+];
+function v4Number(o) {
+  return ((o[0] ?? 0) << 24 >>> 0) + ((o[1] ?? 0) << 16) + ((o[2] ?? 0) << 8) + (o[3] ?? 0);
+}
+function isPublicV4(octets) {
+  const n = v4Number(octets);
+  return PRIVATE_V4.every(([a, b, c, d, bits]) => {
+    const mask = bits === 0 ? 0 : 4294967295 << 32 - bits >>> 0;
+    return (n & mask) >>> 0 !== (v4Number([a, b, c, d]) & mask) >>> 0;
+  });
+}
+function isPublicV6(g) {
+  const [g0 = 0, g1 = 0] = g;
+  const embedded = [
+    (g[6] ?? 0) >> 8,
+    (g[6] ?? 0) & 255,
+    (g[7] ?? 0) >> 8,
+    (g[7] ?? 0) & 255
+  ];
+  if (g.slice(0, 5).every((x) => x === 0) && (g[5] === 65535 || g[5] === 0)) {
+    return g[5] === 65535 && isPublicV4(embedded);
+  }
+  if (g0 === 100 && g1 === 65435 && g.slice(2, 6).every((x) => x === 0)) {
+    return isPublicV4(embedded);
+  }
+  if ((g0 & 57344) !== 8192)
+    return false;
+  if (g0 === 8193 && g1 < 512)
+    return false;
+  if (g0 === 8193 && g1 === 3512)
+    return false;
+  if (g0 === 8194)
+    return false;
+  if (g0 === 16383 && g1 < 4096)
+    return false;
+  return true;
+}
+function isPublicIp(ip) {
+  const v4 = parseIpv4(ip);
+  if (v4 !== undefined)
+    return isPublicV4(v4);
+  const v6 = parseIpv6(ip.replace(/^\[|\]$/g, ""));
+  if (v6 !== undefined)
+    return isPublicV6(v6);
+  return false;
+}
+function isLoopbackHost(hostname) {
+  const h = hostname.replace(/^\[|\]$/g, "").toLowerCase();
+  if (h === "localhost" || h.endsWith(".localhost"))
+    return true;
+  const v4 = parseIpv4(h);
+  if (v4 !== undefined)
+    return v4[0] === 127;
+  const v6 = parseIpv6(h);
+  return v6?.slice(0, 7).every((x) => x === 0) === true && v6[7] === 1;
+}
+function ipPrefixKey(ip) {
+  const v4 = parseIpv4(ip);
+  if (v4 !== undefined)
+    return v4.join(".");
+  const v6 = parseIpv6(ip.replace(/^\[|\]$/g, ""));
+  if (v6 === undefined)
+    return ip;
+  if (v6.slice(0, 5).every((g) => g === 0) && v6[5] === 65535) {
+    const hi = v6[6] ?? 0;
+    const lo = v6[7] ?? 0;
+    return `${hi >> 8}.${hi & 255}.${lo >> 8}.${lo & 255}`;
+  }
+  return `${v6.slice(0, 4).map((g) => g.toString(16)).join(":")}::/64`;
+}
+
+// src/log.ts
+var ORDER = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  debug: 3
+};
+function createLogger(level, sink = (line) => {
+  process.stdout.write(`${line}
+`);
+}) {
+  const max = ORDER[level];
+  const write = (lvl, event, fields) => {
+    if (ORDER[lvl] > max)
+      return;
+    sink(JSON.stringify({
+      time: new Date().toISOString(),
+      level: lvl,
+      event,
+      ...fields
+    }));
+  };
+  return {
+    error: (e, f) => write("error", e, f),
+    warn: (e, f) => write("warn", e, f),
+    info: (e, f) => write("info", e, f),
+    debug: (e, f) => write("debug", e, f)
+  };
+}
+function truncateIp(ip) {
+  const v4 = parseIpv4(ip);
+  if (v4 !== undefined)
+    return `${v4.slice(0, 3).join(".")}.0/24`;
+  const v6 = parseIpv6(ip);
+  if (v6 === undefined)
+    return "?";
+  const mapped = v6.slice(0, 5).every((g) => g === 0) && v6[5] === 65535;
+  if (mapped) {
+    const hi = v6[6] ?? 0;
+    return `${hi >> 8}.${hi & 255}.${(v6[7] ?? 0) >> 8}.0/24`;
+  }
+  return `${v6.slice(0, 3).map((g) => g.toString(16)).join(":")}::/48`;
+}
+function installCrashLogging(logger, exit = (code) => process.exit(code)) {
+  const name = (error) => error instanceof Error ? error.name : typeof error;
+  const onRejection = (error) => {
+    logger.error("process.unhandled_rejection", { error: name(error) });
+  };
+  const onException = (error) => {
+    logger.error("process.uncaught_exception", { error: name(error) });
+    exit(1);
+  };
+  process.on("unhandledRejection", onRejection);
+  process.on("uncaughtException", onException);
+  return () => {
+    process.off("unhandledRejection", onRejection);
+    process.off("uncaughtException", onException);
+  };
+}
+// src/protocol.ts
+var SUBPROTOCOL = "tab-mcp.v1";
+var MCP_PROTOCOL_VERSION = "2026-07-28";
+var PROTOCOL_VERSION_META_KEY = "io.modelcontextprotocol/protocolVersion";
+var CloseCode = {
+  normal: 1000,
+  policyViolation: 1008,
+  tooLarge: 1009,
+  sessionExpired: 4001,
+  idleTimeout: 4002,
+  heartbeatLost: 4003,
+  shuttingDown: 4004,
+  replaced: 4005,
+  rateLimited: 4008
+};
+var MAX_TITLE = 300;
+var MAX_NAME = 200;
+var MAX_ID = 128;
+var MAX_HEADER_COUNT = 32;
+var MAX_HEADER_VALUE = 8192;
+var FIELD_VALUE = /^[\t\x20-\x7E\x80-\xFF]*$/;
+function isObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function isString(v, max) {
+  return typeof v === "string" && v.length <= max;
+}
+function isId(v) {
+  return typeof v === "string" && v.length > 0 && v.length <= MAX_ID;
+}
+function isStatus(v) {
+  return typeof v === "number" && Number.isInteger(v) && v >= 200 && v <= 599;
+}
+function isHeaders(v) {
+  if (!isObject(v))
+    return false;
+  const entries = Object.entries(v);
+  if (entries.length > MAX_HEADER_COUNT)
+    return false;
+  return entries.every(([k, val]) => /^[a-z0-9-]{1,64}$/.test(k) && isString(val, MAX_HEADER_VALUE) && FIELD_VALUE.test(val));
+}
+function idOf(v) {
+  return isId(v["id"]) ? v["id"] : undefined;
+}
+function parseTabMessage(text) {
+  let v;
+  try {
+    v = JSON.parse(text);
+  } catch {
+    return { ok: false, error: "not JSON" };
+  }
+  if (!isObject(v))
+    return { ok: false, error: "not a JSON object" };
+  const type = v["type"];
+  if (typeof type !== "string" || type.length === 0 || type.length > 64) {
+    return { ok: false, error: "missing type" };
+  }
+  const id = idOf(v);
+  const bad = (error) => id === undefined ? { ok: false, error } : { ok: false, error, id };
+  switch (type) {
+    case "hello": {
+      const library = v["library"];
+      const page = v["page"];
+      if (!isObject(library) || !isString(library["name"], MAX_NAME) || !isString(library["version"], MAX_NAME)) {
+        return bad("hello.library must be {name, version}");
+      }
+      if (!isObject(page) || !isString(page["title"], MAX_TITLE)) {
+        return bad("hello.page must be {title}");
+      }
+      if (typeof v["secret"] !== "string")
+        return bad("hello.secret missing");
+      const app = v["app"];
+      if (app !== undefined && (!isObject(app) || !isAppName(app["name"]))) {
+        return bad(`hello.app.name must be 1-${MAX_APP_NAME} characters`);
+      }
+      const hello = {
+        type,
+        library: { name: library["name"], version: library["version"] },
+        page: { title: page["title"] },
+        secret: v["secret"]
+      };
+      if (isObject(app) && isAppName(app["name"])) {
+        hello.app = { name: app["name"] };
+      }
+      return { ok: true, message: hello };
+    }
+    case "pong": {
+      const t = v["t"];
+      if (typeof t !== "number")
+        return bad("pong.t must be a number");
+      return { ok: true, message: { type, t } };
+    }
+    case "bye": {
+      const reason = v["reason"];
+      return {
+        ok: true,
+        message: {
+          type,
+          reason: isString(reason, MAX_NAME) ? reason : ""
+        }
+      };
+    }
+    case "http.response": {
+      if (id === undefined)
+        return bad("http.response.id missing");
+      const { status, headers, body } = v;
+      if (!isStatus(status))
+        return bad("http.response.status invalid");
+      if (!isHeaders(headers))
+        return bad("http.response.headers invalid");
+      if (typeof body !== "string")
+        return bad("http.response.body invalid");
+      return { ok: true, message: { type, id, status, headers, body } };
+    }
+    case "http.response.start": {
+      if (id === undefined)
+        return bad("http.response.start.id missing");
+      const { status, headers } = v;
+      if (!isStatus(status))
+        return bad("http.response.start.status invalid");
+      if (!isHeaders(headers))
+        return bad("http.response.start.headers invalid");
+      return { ok: true, message: { type, id, status, headers } };
+    }
+    case "http.response.chunk": {
+      if (id === undefined)
+        return bad("http.response.chunk.id missing");
+      const data = v["data"];
+      if (typeof data !== "string")
+        return bad("http.response.chunk.data invalid");
+      return { ok: true, message: { type, id, data } };
+    }
+    case "http.response.end": {
+      if (id === undefined)
+        return bad("http.response.end.id missing");
+      return { ok: true, message: { type, id } };
+    }
+    case "pairing.start":
+    case "pairing.stop":
+    case "grants.revokeAll":
+      return { ok: true, message: { type } };
+    case "grant.revoke": {
+      const grantId = v["grantId"];
+      if (!isId(grantId))
+        return bad("grant.revoke.grantId missing");
+      return { ok: true, message: { type, grantId } };
+    }
+    case "error": {
+      const code = v["code"];
+      const message = v["message"];
+      if (!isString(code, MAX_NAME))
+        return bad("error.code invalid");
+      const m = {
+        type,
+        code,
+        message: isString(message, 1000) ? message : ""
+      };
+      if (id !== undefined)
+        m.id = id;
+      return { ok: true, message: m };
+    }
+    default:
+      return id === undefined ? { ok: true, unknown: true, type } : { ok: true, unknown: true, type, id };
+  }
+}
+// package.json
+var version = "0.1.0-alpha.1";
+
+// src/exchange.ts
+var RelayErrorCode = {
+  pageNotOpen: -31001,
+  timeout: -31002,
+  tabGone: -31003,
+  overloaded: -31004,
+  sendFailed: -31005,
+  tooLarge: -31006,
+  badResponse: -31007,
+  storeUnavailable: -31008
+};
+var encoder = new TextEncoder;
+var NULL_BODY_STATUSES = new Set([204, 205, 304]);
+var PASSED_RESPONSE_HEADERS = new Set(["content-type", "cache-control"]);
+function isEventStream(headers) {
+  return (headers["content-type"] ?? "").toLowerCase().startsWith("text/event-stream");
+}
+function endsAtBoundary(text) {
+  return text.endsWith(`
+
+`) || text.endsWith(`\r
+\r
+`) || text.endsWith("\r\r");
+}
+function sseEvent(data) {
+  const lines = data.split(/\r\n|\r|\n/);
+  return `event: message
+${lines.map((l) => `data: ${l}`).join(`
+`)}
+
+`;
+}
+function rpcErrorBody(rpcId, code, message, data) {
+  const error = { code, message };
+  if (data !== undefined)
+    error["data"] = data;
+  return JSON.stringify({ jsonrpc: "2.0", id: rpcId ?? null, error });
+}
+
+class Exchange {
+  id;
+  isListen;
+  response;
+  status = 0;
+  outcome = "pending";
+  badResponseReason;
+  #options;
+  #resolve;
+  #state = "waiting";
+  #relayStarted = false;
+  #tabStarted = false;
+  #wrap = false;
+  #wrapped = "";
+  #controller;
+  #atBoundary = true;
+  #bodyBytes = 0;
+  #startTimer;
+  #requestTimer;
+  #keepAliveTimer;
+  constructor(options) {
+    this.#options = options;
+    this.id = options.id;
+    this.isListen = options.isListen;
+    this.response = new Promise((resolve) => {
+      this.#resolve = resolve;
+    });
+    if (options.rpcId !== undefined) {
+      this.#startTimer = setTimeout(() => this.#startRelayStream(), options.keepAliveMs);
+    }
+    if (!options.isListen) {
+      this.#requestTimer = setTimeout(() => this.#timeout(), options.requestTimeoutMs);
+    }
+  }
+  get done() {
+    return this.#state === "done";
+  }
+  onResponse(msg) {
+    if (this.#tabStarted) {
+      this.#badResponse("http.response after http.response.start");
+      return;
+    }
+    if (this.#state === "waiting") {
+      if (!this.#account(msg.body))
+        return;
+      if (NULL_BODY_STATUSES.has(msg.status) && msg.body !== "") {
+        this.#badResponse(`status ${msg.status} must not have a body`);
+        return;
+      }
+      let response;
+      try {
+        response = new Response(msg.body === "" ? null : msg.body, {
+          status: msg.status,
+          headers: this.#headers(msg.headers)
+        });
+      } catch {
+        this.#badResponse("the response could not be built");
+        return;
+      }
+      this.#respond(response, msg.status);
+      this.#finish("ok");
+    } else if (this.#state === "streaming" && this.#relayStarted) {
+      if (!this.#account(msg.body))
+        return;
+      if (msg.body !== "")
+        this.#write(sseEvent(msg.body));
+      this.#finish("ok");
+    }
+  }
+  onStart(msg) {
+    if (this.#tabStarted) {
+      this.#badResponse("http.response.start sent twice");
+      return;
+    }
+    this.#tabStarted = true;
+    if (this.#state === "waiting") {
+      if (NULL_BODY_STATUSES.has(msg.status)) {
+        this.#badResponse(`status ${msg.status} cannot be streamed`);
+        return;
+      }
+      let headers;
+      try {
+        headers = this.#headers(msg.headers);
+      } catch {
+        this.#badResponse("the response headers are invalid");
+        return;
+      }
+      this.#openStream(msg.status, headers);
+    } else if (this.#state === "streaming" && this.#relayStarted) {
+      this.#wrap = !isEventStream(msg.headers);
+    }
+  }
+  onChunk(data) {
+    if (this.#state !== "streaming")
+      return;
+    if (!this.#account(data))
+      return;
+    if (this.#wrap)
+      this.#wrapped += data;
+    else
+      this.#write(data);
+  }
+  onEnd() {
+    if (this.#state !== "streaming")
+      return;
+    if (this.#wrap && this.#wrapped !== "")
+      this.#write(sseEvent(this.#wrapped));
+    this.#finish("ok");
+  }
+  clientClosed() {
+    if (this.#state === "done")
+      return;
+    if (this.#state === "waiting")
+      this.#respond(new Response(null, { status: 503 }), 0);
+    this.#options.cancel("client_closed");
+    this.#finish("client_closed", false);
+  }
+  fail(status, code, message, cancelTab) {
+    if (this.#state === "done")
+      return;
+    if (this.#state === "waiting") {
+      this.#respond(this.#errorResponse(status, code, message), status);
+    } else if (this.#atBoundary && this.#options.rpcId !== undefined) {
+      this.#write(sseEvent(rpcErrorBody(this.#options.rpcId, code, message)));
+    }
+    if (cancelTab)
+      this.#options.cancel("error");
+    this.#finish(`error_${code}`);
+  }
+  #badResponse(reason) {
+    this.badResponseReason = reason;
+    this.fail(502, RelayErrorCode.badResponse, "The page sent an invalid response.", true);
+  }
+  #account(data) {
+    this.#bodyBytes += Buffer.byteLength(data);
+    if (this.isListen || this.#bodyBytes <= this.#options.maxBodyBytes) {
+      return true;
+    }
+    this.fail(502, RelayErrorCode.tooLarge, "The page sent a response that is too large.", true);
+    return false;
+  }
+  #timeout() {
+    if (this.#state === "done")
+      return;
+    this.fail(504, RelayErrorCode.timeout, "The page did not answer in time.", false);
+    this.#options.cancel("timeout");
+  }
+  #startRelayStream() {
+    if (this.#state !== "waiting")
+      return;
+    this.#relayStarted = true;
+    this.#openStream(200, this.#headers({ "content-type": "text/event-stream" }));
+  }
+  #openStream(status, headers) {
+    const stream = new ReadableStream({
+      start: (controller) => {
+        this.#controller = controller;
+      },
+      cancel: () => this.clientClosed()
+    }, new ByteLengthQueuingStrategy({
+      highWaterMark: this.#options.maxBodyBytes
+    }));
+    if (isEventStream(Object.fromEntries(headers))) {
+      headers.set("x-accel-buffering", "no");
+      if (!headers.has("cache-control"))
+        headers.set("cache-control", "no-cache");
+    }
+    let response;
+    try {
+      response = new Response(stream, { status, headers });
+    } catch {
+      this.#badResponse("the response could not be built");
+      return;
+    }
+    this.#state = "streaming";
+    this.#respond(response, status);
+    this.#scheduleKeepAlive();
+  }
+  #write(text) {
+    if (this.#state !== "streaming" || this.#controller === undefined || text === "")
+      return;
+    try {
+      this.#controller.enqueue(encoder.encode(text));
+    } catch {
+      this.clientClosed();
+      return;
+    }
+    this.#atBoundary = endsAtBoundary(text);
+    const room = this.#controller.desiredSize;
+    if (room !== null && room < 0) {
+      this.#options.cancel("error");
+      this.#finish("backpressure");
+      return;
+    }
+    this.#scheduleKeepAlive();
+  }
+  #scheduleKeepAlive() {
+    clearTimeout(this.#keepAliveTimer);
+    if (this.#state !== "streaming" || this.#wrap) {
+      if (this.#state === "streaming") {
+        this.#keepAliveTimer = setTimeout(() => {
+          this.#write(`: keep-alive
+
+`);
+        }, this.#options.keepAliveMs);
+      }
+      return;
+    }
+    this.#keepAliveTimer = setTimeout(() => {
+      if (this.#atBoundary)
+        this.#write(`: keep-alive
+
+`);
+      else
+        this.#scheduleKeepAlive();
+    }, this.#options.keepAliveMs);
+  }
+  #headers(fromTab) {
+    const headers = new Headers(this.#options.extraHeaders);
+    for (const [k, v] of Object.entries(fromTab)) {
+      if (PASSED_RESPONSE_HEADERS.has(k))
+        headers.set(k, v);
+    }
+    return headers;
+  }
+  #errorResponse(status, code, message) {
+    const headers = this.#headers({ "content-type": "application/json" });
+    return new Response(rpcErrorBody(this.#options.rpcId, code, message), {
+      status,
+      headers
+    });
+  }
+  #respond(response, status) {
+    clearTimeout(this.#startTimer);
+    this.status = status;
+    this.#resolve(response);
+  }
+  #finish(outcome, closeStream = true) {
+    if (this.#state === "done")
+      return;
+    const wasStreaming = this.#state === "streaming";
+    this.#state = "done";
+    this.outcome = outcome;
+    clearTimeout(this.#startTimer);
+    clearTimeout(this.#requestTimer);
+    clearTimeout(this.#keepAliveTimer);
+    if (wasStreaming && closeStream) {
+      try {
+        this.#controller?.close();
+      } catch {}
+    }
+    this.#options.onDone(this);
+  }
+}
+
+// src/oauth/server.ts
+import { timingSafeEqual as timingSafeEqual2 } from "crypto";
+
+// src/ratelimit.ts
+class RateLimiter {
+  #buckets = new Map;
+  #capacity;
+  #refill;
+  #maxKeys;
+  constructor(options) {
+    this.#capacity = options.capacity;
+    this.#refill = options.refillPerSecond;
+    this.#maxKeys = options.maxKeys ?? 1e4;
+  }
+  take(key, now = Date.now()) {
+    let bucket = this.#buckets.get(key);
+    if (bucket === undefined) {
+      if (this.#buckets.size >= this.#maxKeys) {
+        const oldest = this.#buckets.keys().next().value;
+        if (oldest !== undefined)
+          this.#buckets.delete(oldest);
+      }
+      bucket = { tokens: this.#capacity, updatedAt: now };
+      this.#buckets.set(key, bucket);
+    } else {
+      const elapsed = Math.max(0, now - bucket.updatedAt) / 1000;
+      bucket.tokens = Math.min(this.#capacity, bucket.tokens + elapsed * this.#refill);
+      bucket.updatedAt = now;
+    }
+    if (bucket.tokens < 1)
+      return false;
+    bucket.tokens -= 1;
+    return true;
+  }
+  sweep(now = Date.now()) {
+    for (const [key, b] of this.#buckets) {
+      const elapsed = Math.max(0, now - b.updatedAt) / 1000;
+      if (b.tokens + elapsed * this.#refill >= this.#capacity) {
+        this.#buckets.delete(key);
+      }
+    }
+  }
+}
+
+// src/tokens.ts
+var PREFIX = {
+  access: "tmcp_at_",
+  refresh: "tmcp_rt_"
+};
+function random(bytes) {
+  return crypto.getRandomValues(new Uint8Array(bytes)).toBase64({ alphabet: "base64url", omitPadding: true });
+}
+function newToken(kind) {
+  return PREFIX[kind] + random(32);
+}
+function newId(prefix) {
+  return `${prefix}_${random(12)}`;
+}
+function hashToken(token) {
+  return new Bun.CryptoHasher("sha256").update(token).digest().toBase64({ alphabet: "base64url", omitPadding: true });
+}
+async function issueTokenPair(store, grant, options) {
+  const now = options.now ?? Date.now();
+  const accessToken = newToken("access");
+  const refreshToken = newToken("refresh");
+  const base = {
+    grantId: grant.grantId,
+    addressId: grant.addressId,
+    clientId: grant.clientId,
+    clientName: grant.clientName,
+    scopes: grant.scopes,
+    grantCreatedAt: grant.grantCreatedAt,
+    issuedAt: now
+  };
+  const accessExpires = Math.min(now + options.accessTtlMs, options.grantEndsAt);
+  const refreshStored = await store.put({
+    ...base,
+    hash: hashToken(refreshToken),
+    kind: "refresh",
+    expiresAt: Math.min(now + options.refreshTtlMs, options.grantEndsAt)
+  });
+  if (!refreshStored)
+    return;
+  const accessStored = await store.put({
+    ...base,
+    hash: hashToken(accessToken),
+    kind: "access",
+    expiresAt: accessExpires
+  });
+  if (!accessStored)
+    return;
+  return {
+    accessToken,
+    refreshToken,
+    expiresIn: Math.max(0, Math.floor((accessExpires - now) / 1000))
+  };
+}
+
+// src/oauth/cimd.ts
+class ClientMetadataError extends Error {
+  name = "ClientMetadataError";
+  reason;
+  constructor(reason, message) {
+    super(message);
+    this.reason = reason;
+  }
+}
+var MAX_CLIENT_ID_LENGTH = 2048;
+var MAX_NAME_LENGTH = 64;
+var MAX_REDIRECT_URIS = 20;
+var MIN_CACHE_MS = 5 * 60000;
+var DEFAULT_CACHE_MS = 60 * 60000;
+var MAX_CACHE_MS = 24 * 60 * 60000;
+var MAX_CACHE_ENTRIES = 1000;
+async function defaultLookup(hostname) {
+  const records = await Bun.dns.lookup(hostname, {});
+  return records.map((r) => r.address);
+}
+var INVISIBLE = /[\u034F\u115F\u1160\u17B4\u17B5\u2800\u3164\uFFA0]/gu;
+function displayName(raw) {
+  let cleaned = raw.normalize("NFC").replace(/[\p{Cc}\p{Zl}\p{Zp}]/gu, " ").replace(/\p{Cf}/gu, "").replace(INVISIBLE, "");
+  cleaned = cleaned.replace(/\s+/g, " ").trim();
+  const chars = [...cleaned];
+  return chars.length > MAX_NAME_LENGTH ? `${chars.slice(0, MAX_NAME_LENGTH - 1).join("")}\u2026` : cleaned;
+}
+function cacheMs(header) {
+  if (header === null)
+    return DEFAULT_CACHE_MS;
+  const directives = header.toLowerCase().split(",").map((d) => d.trim());
+  if (directives.includes("no-store") || directives.includes("no-cache")) {
+    return MIN_CACHE_MS;
+  }
+  const maxAge = directives.map((d) => /^max-age=(\d+)$/.exec(d)?.[1]).find((v) => v !== undefined);
+  if (maxAge === undefined)
+    return DEFAULT_CACHE_MS;
+  return Math.min(MAX_CACHE_MS, Math.max(MIN_CACHE_MS, Number(maxAge) * 1000));
+}
+function isIpLiteral(hostname) {
+  const h = hostname.replace(/^\[|\]$/g, "");
+  return parseIpv4(h) !== undefined || parseIpv6(h) !== undefined;
+}
+
+class ClientMetadataFetcher {
+  #cache = new Map;
+  #perHost = new RateLimiter({ capacity: 5, refillPerSecond: 0.2 });
+  #global = new RateLimiter({ capacity: 30, refillPerSecond: 1 });
+  #allowedHosts;
+  #logger;
+  #timeoutMs;
+  #maxBytes;
+  #lookup;
+  #fetch;
+  #testMode;
+  #now;
+  constructor(options = {}) {
+    this.#allowedHosts = options.allowedHosts ?? [];
+    this.#logger = options.logger;
+    this.#timeoutMs = options.timeoutMs ?? 5000;
+    this.#maxBytes = options.maxBytes ?? 65536;
+    this.#lookup = options.lookup ?? defaultLookup;
+    this.#fetch = options.fetch ?? fetch;
+    this.#testMode = options.testMode;
+    this.#now = options.now ?? Date.now;
+  }
+  async get(clientId) {
+    const url = this.#checkUrl(clientId);
+    const now = this.#now();
+    const cached = this.#cache.get(clientId);
+    if (cached !== undefined && cached.until > now)
+      return cached.meta;
+    if (!this.#perHost.take(url.host, now)) {
+      throw new ClientMetadataError("rate_limited", "Too many requests for this AI app's details. Try again in a minute.");
+    }
+    if (!this.#global.take("all", now)) {
+      throw new ClientMetadataError("rate_limited", "The relay is busy. Try again in a minute.");
+    }
+    const address = await this.#vettedAddress(url);
+    const { meta, ttlMs } = await this.#fetchDocument(url, clientId, address);
+    if (this.#cache.size >= MAX_CACHE_ENTRIES) {
+      const oldest = this.#cache.keys().next().value;
+      if (oldest !== undefined)
+        this.#cache.delete(oldest);
+    }
+    this.#cache.delete(clientId);
+    this.#cache.set(clientId, { meta, until: now + ttlMs });
+    return meta;
+  }
+  #checkUrl(clientId) {
+    const refuse = (message) => new ClientMetadataError("invalid_client_id", message);
+    if (clientId.length === 0 || clientId.length > MAX_CLIENT_ID_LENGTH) {
+      throw refuse("The AI app's client_id is missing or too long.");
+    }
+    let url;
+    try {
+      url = new URL(clientId);
+    } catch {
+      throw refuse("The AI app's client_id is not a URL.");
+    }
+    const test = this.#testMode !== undefined;
+    const scheme = url.protocol === "https:" || test && url.protocol === "http:";
+    if (!scheme) {
+      throw refuse("The AI app's client_id must be an https:// URL.");
+    }
+    if (url.href !== clientId) {
+      throw refuse("The AI app's client_id is not a canonical URL.");
+    }
+    if (url.username !== "" || url.password !== "" || url.hash !== "") {
+      throw refuse("The AI app's client_id must not contain credentials or a fragment.");
+    }
+    if (url.pathname === "/" || url.pathname === "") {
+      throw refuse("The AI app's client_id must have a path.");
+    }
+    if (url.port !== "" && !test) {
+      throw refuse("The AI app's client_id must use the default port.");
+    }
+    if (this.#allowedHosts.length > 0 && !this.#allowedHosts.includes(url.host)) {
+      throw new ClientMetadataError("host_not_allowed", `This relay does not accept AI apps from ${url.host}.`);
+    }
+    if (isIpLiteral(url.hostname) && !this.#addressAllowed(url.hostname)) {
+      throw this.#notLoaded("private_address", url);
+    }
+    return url;
+  }
+  #addressAllowed(address) {
+    if (isPublicIp(address))
+      return true;
+    return this.#testMode !== undefined && isLoopbackHost(address);
+  }
+  #notLoaded(reason, url, detail = reason) {
+    this.#logger?.info("oauth.cimd_failed", { host: url.host, reason: detail });
+    return new ClientMetadataError(reason, `The AI app's details could not be loaded from ${url.host}.`);
+  }
+  async#vettedAddress(url) {
+    const hostname = url.hostname.replace(/^\[|\]$/g, "");
+    if (isIpLiteral(hostname))
+      return hostname;
+    let addresses;
+    try {
+      addresses = await this.#lookup(hostname);
+    } catch {
+      throw this.#notLoaded("unresolvable", url);
+    }
+    if (addresses.length === 0 || !addresses.every((a) => this.#addressAllowed(a))) {
+      throw this.#notLoaded("private_address", url);
+    }
+    return addresses.find((a) => parseIpv4(a) !== undefined) ?? addresses[0] ?? "";
+  }
+  async#fetchDocument(url, clientId, address) {
+    const fail = (detail) => this.#notLoaded("fetch_failed", url, detail);
+    const pinned = new URL(clientId);
+    pinned.hostname = address.includes(":") ? `[${address}]` : address;
+    const hostname = url.hostname.replace(/^\[|\]$/g, "");
+    const tls = url.protocol === "https:" ? {
+      tls: {
+        ...isIpLiteral(hostname) ? {} : { serverName: hostname },
+        ...this.#testMode?.ca === undefined ? {} : { ca: this.#testMode.ca }
+      }
+    } : {};
+    let response;
+    try {
+      response = await this.#fetch(pinned.href, {
+        method: "GET",
+        redirect: "manual",
+        headers: { accept: "application/json", host: url.host },
+        signal: AbortSignal.timeout(this.#timeoutMs),
+        ...tls
+      });
+    } catch (error) {
+      throw fail(`fetch_failed:${error instanceof Error ? error.name : "unknown"}`);
+    }
+    try {
+      if (response.status !== 200)
+        throw fail(`status_${response.status}`);
+      const type = (response.headers.get("content-type") ?? "").split(";")[0]?.trim().toLowerCase();
+      if (type !== "application/json")
+        throw fail("not_json");
+      const text = await this.#readLimited(response, url);
+      let doc;
+      try {
+        doc = JSON.parse(text);
+      } catch {
+        throw fail("bad_json");
+      }
+      const meta = validateDocument(doc, clientId, url);
+      return { meta, ttlMs: cacheMs(response.headers.get("cache-control")) };
+    } finally {
+      if (!response.bodyUsed)
+        response.body?.cancel().catch(() => {});
+    }
+  }
+  async#readLimited(response, url) {
+    const tooLarge = () => this.#notLoaded("too_large", url);
+    const length = Number(response.headers.get("content-length") ?? "0");
+    if (length > this.#maxBytes)
+      throw tooLarge();
+    const reader = response.body?.getReader();
+    if (reader === undefined)
+      return "";
+    const chunks = [];
+    let total = 0;
+    for (;; ) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      total += value.byteLength;
+      if (total > this.#maxBytes) {
+        await reader.cancel().catch(() => {});
+        throw tooLarge();
+      }
+      chunks.push(value);
+    }
+    try {
+      return new TextDecoder("utf-8", { fatal: true }).decode(Buffer.concat(chunks));
+    } catch {
+      throw this.#notLoaded("fetch_failed", url, "bad_utf8");
+    }
+  }
+}
+function validateDocument(doc, clientId, url) {
+  const invalid = (message) => new ClientMetadataError("invalid_metadata", message);
+  if (typeof doc !== "object" || doc === null || Array.isArray(doc)) {
+    throw invalid("The AI app's details are not a JSON object.");
+  }
+  const d = doc;
+  if (d["client_id"] !== clientId) {
+    throw invalid("The AI app's details name a different client_id.");
+  }
+  if (d["client_secret"] !== undefined || d["client_secret_expires_at"] !== undefined) {
+    throw invalid("The AI app's details must not contain a client secret.");
+  }
+  const name = d["client_name"];
+  if (typeof name !== "string" || displayName(name) === "") {
+    throw invalid("The AI app's details have no client_name.");
+  }
+  if (/\(\s*[^()\s]*[a-z0-9-]\.[a-z]{2,}[^()]*\)/i.test(displayName(name))) {
+    throw invalid("The AI app's name contains a web address in parentheses, which this relay does not show.");
+  }
+  const uris = d["redirect_uris"];
+  if (!Array.isArray(uris) || uris.length === 0 || uris.length > MAX_REDIRECT_URIS || !uris.every((u) => typeof u === "string" && isRedirectUri(u))) {
+    throw invalid("The AI app's details have no valid redirect_uris.");
+  }
+  const method = d["token_endpoint_auth_method"];
+  if (method !== undefined && method !== "none") {
+    throw invalid('The AI app must use token_endpoint_auth_method "none" with this relay.');
+  }
+  const grants = d["grant_types"];
+  if (grants !== undefined && (!Array.isArray(grants) || !grants.includes("authorization_code"))) {
+    throw invalid("The AI app's details do not allow the authorization code grant.");
+  }
+  const responses = d["response_types"];
+  if (responses !== undefined && (!Array.isArray(responses) || !responses.includes("code"))) {
+    throw invalid(`The AI app's details do not allow response type "code".`);
+  }
+  return {
+    clientId,
+    name: displayName(name),
+    host: url.host,
+    redirectUris: uris
+  };
+}
+var PRIVATE_USE_SCHEME = /^[a-z][a-z0-9+-]*(\.[a-z0-9+-]+)+:$/;
+function isRedirectUri(value) {
+  if (value.length > 2048 || value.includes("#"))
+    return false;
+  let u;
+  try {
+    u = new URL(value);
+  } catch {
+    return false;
+  }
+  if (u.username !== "" || u.password !== "")
+    return false;
+  if (u.protocol === "https:")
+    return u.hostname !== "";
+  if (u.protocol === "http:")
+    return LOOPBACK_REDIRECT_HOSTS.has(u.hostname);
+  return PRIVATE_USE_SCHEME.test(u.protocol);
+}
+var LOOPBACK_REDIRECT_HOSTS = new Set(["localhost", "127.0.0.1", "[::1]"]);
+function redirectUriMatches(requested, registered) {
+  if (requested === registered)
+    return true;
+  let a;
+  let b;
+  try {
+    a = new URL(requested);
+    b = new URL(registered);
+  } catch {
+    return false;
+  }
+  if (a.protocol !== "http:" || b.protocol !== "http:")
+    return false;
+  if (!LOOPBACK_REDIRECT_HOSTS.has(b.hostname) || a.hostname !== b.hostname) {
+    return false;
+  }
+  if (a.href !== requested || a.username !== "" || a.password !== "" || a.hash !== "") {
+    return false;
+  }
+  a.port = "";
+  b.port = "";
+  return a.href === b.href;
+}
+
+// src/oauth/html.ts
+var ESCAPES = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;"
+};
+function escapeHtml(text) {
+  return text.replace(/[&<>"']/g, (c) => ESCAPES[c] ?? c);
+}
+var AUTHORIZE_CSS = `:root { color-scheme: light dark; --accent: #1d4ed8; --error: #b91c1c; }
+@media (prefers-color-scheme: dark) { :root { --accent: #93b4ff; --error: #fca5a5; } }
+* { box-sizing: border-box; }
+body { margin: 0; font: 1rem/1.5 system-ui, -apple-system, "Segoe UI", sans-serif; background: Canvas; color: CanvasText; }
+main { max-width: 34rem; margin: 3rem auto; padding: 0 1rem; }
+h1 { font-size: 1.5rem; line-height: 1.25; margin: 0 0 1rem; }
+p { margin: 0 0 1rem; }
+code, .origin { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; overflow-wrap: anywhere; }
+.help { color: GrayText; font-size: 0.9rem; }
+.error { color: var(--error); font-weight: 600; }
+label { display: block; font-weight: 600; margin-bottom: 0.25rem; }
+input[type="text"] { font: 1.5rem/1.2 ui-monospace, SFMono-Regular, Menlo, monospace; letter-spacing: 0.2em; width: 10ch; padding: 0.4rem 0.5rem; border: 2px solid GrayText; border-radius: 0.4rem; background: Field; color: FieldText; }
+input[type="text"]:focus-visible, button:focus-visible, a:focus-visible { outline: 3px solid var(--accent); outline-offset: 2px; }
+.actions { display: flex; gap: 0.75rem; flex-wrap: wrap; margin: 1.5rem 0 1.25rem; }
+button, .button { font: inherit; padding: 0.5rem 1.25rem; border-radius: 0.4rem; border: 2px solid var(--accent); cursor: pointer; text-decoration: none; display: inline-block; }
+button.primary, .button.primary { background: var(--accent); color: Canvas; }
+button.secondary, .button:not(.primary) { background: transparent; color: var(--accent); }
+footer { margin-top: 2.5rem; font-size: 0.85rem; color: GrayText; }
+`;
+function pageHeaders(formTargets = []) {
+  const formAction = ["'self'", ...formTargets].join(" ");
+  return new Headers({
+    "content-type": "text/html; charset=utf-8",
+    "content-security-policy": `default-src 'none'; style-src 'self'; img-src 'self'; base-uri 'none'; frame-ancestors 'none'; form-action ${formAction}`,
+    "x-frame-options": "DENY",
+    "x-content-type-options": "nosniff",
+    "referrer-policy": "same-origin",
+    "cache-control": "no-store"
+  });
+}
+function renderPage(title, body) {
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<meta name="robots" content="noindex">
+<title>${escapeHtml(title)}</title>
+<link rel="stylesheet" href="/authorize.css">
+</head>
+<body>
+<main>
+${body}
+<footer>tab-mcp relay. It passes requests between AI tools and web pages and does not store their contents.</footer>
+</main>
+</body>
+</html>`;
+}
+
+// src/oauth/pairing.ts
+import { timingSafeEqual } from "crypto";
+var PAIRING_CODE_TTL_MS = 120000;
+var PAIRING_MAX_ATTEMPTS = 5;
+function newPairingCode() {
+  const buffer = new Uint32Array(1);
+  for (;; ) {
+    crypto.getRandomValues(buffer);
+    const n = buffer[0] ?? 0;
+    if (n < 4294000000)
+      return String(n % 1e6).padStart(6, "0");
+  }
+}
+function sameCode(a, b) {
+  const x = Buffer.from(a);
+  const y = Buffer.from(b);
+  return x.length === y.length && timingSafeEqual(x, y);
+}
+
+class PairingCodes {
+  #send;
+  #ttlMs;
+  #maxAttempts;
+  #current;
+  #previous;
+  #timer;
+  constructor(send, options = {}) {
+    this.#send = send;
+    this.#ttlMs = options.ttlMs ?? PAIRING_CODE_TTL_MS;
+    this.#maxAttempts = options.maxAttempts ?? PAIRING_MAX_ATTEMPTS;
+  }
+  get active() {
+    return this.#current !== undefined;
+  }
+  get attemptsLeft() {
+    return this.#current === undefined ? 0 : this.#maxAttempts - this.#current.attempts;
+  }
+  start() {
+    if (this.#current !== undefined) {
+      this.#send(this.#current.code, this.#current.expiresAt);
+      return;
+    }
+    this.#issue();
+  }
+  stop() {
+    clearTimeout(this.#timer);
+    this.#timer = undefined;
+    this.#current = undefined;
+    this.#previous = undefined;
+  }
+  check(input, now = Date.now(), admit = () => true) {
+    const current = this.#current;
+    if (current === undefined)
+      return "inactive";
+    const typed = input.replace(/[\s-]/g, "");
+    if (!/^\d{6}$/.test(typed))
+      return "malformed";
+    if (!admit())
+      return "limited";
+    if (now >= current.expiresAt) {
+      this.#previous = current.code;
+      this.#issue();
+      return "expired";
+    }
+    if (sameCode(typed, current.code)) {
+      this.#previous = undefined;
+      this.#issue();
+      return "ok";
+    }
+    current.attempts++;
+    const expired = this.#previous !== undefined && sameCode(typed, this.#previous);
+    if (current.attempts >= this.#maxAttempts) {
+      this.#previous = undefined;
+      this.#issue();
+      return "locked";
+    }
+    return expired ? "expired" : "wrong";
+  }
+  #issue() {
+    clearTimeout(this.#timer);
+    const expiresAt = Date.now() + this.#ttlMs;
+    this.#current = { code: newPairingCode(), expiresAt, attempts: 0 };
+    this.#timer = setTimeout(() => {
+      if (this.#current === undefined)
+        return;
+      this.#previous = this.#current.code;
+      this.#issue();
+    }, this.#ttlMs);
+    this.#send(this.#current.code, expiresAt);
+  }
+}
+var MESSAGES = {
+  wrong: "That code is not right. Check the code shown in the page and try again.",
+  expired: "That code has expired. The page now shows a new code: enter that one.",
+  locked: "Too many wrong codes. The page now shows a new code: enter that one.",
+  inactive: "The page is not showing a code right now. In the page, open \u201CConnect your AI tool\u201D to see one, then enter it here.",
+  malformed: "Enter the 6 digits shown in the page.",
+  limited: "Too many attempts for this page. Wait a few minutes and try again. If it keeps happening, someone else may be guessing: use \u201CNew address\u201D in the page."
+};
+var codePairing = {
+  kind: "code",
+  render() {
+    return `<p><label for="code">Code shown in the page</label>
+<input id="code" name="code" type="text" inputmode="numeric" autocomplete="one-time-code" pattern="[0-9 ]{6,7}" maxlength="7" required autofocus aria-describedby="code-help"></p>
+<p id="code-help" class="help">In the page, \u201CConnect your AI tool\u201D shows a 6-digit code. It changes every 2 minutes.</p>`;
+  },
+  check(target, form, admit) {
+    const result = target.codes.check(form.get("code") ?? "", Date.now(), admit);
+    if (result === "ok")
+      return { ok: true };
+    let message = MESSAGES[result];
+    if (result === "wrong") {
+      const left = target.codes.attemptsLeft;
+      message += ` ${left === 1 ? "1 try is" : `${left} tries are`} left for this code.`;
+    }
+    return {
+      ok: false,
+      message,
+      reason: result === "limited" ? "rate_limited" : result
+    };
+  }
+};
+var PAIRING_METHODS = {
+  code: codePairing
+};
+
+// src/oauth/server.ts
+var SCOPE = "tools";
+var PENDING_TTL_MS = 10 * 60000;
+var AUTH_CODE_TTL_MS = 60000;
+var MAX_PENDING = 1e4;
+var MAX_PENDING_PER_IP = 10;
+var MAX_PENDING_PER_ADDRESS = 20;
+var MAX_CODES = 1e4;
+var MAX_FORM_BYTES = 8192;
+var MAX_STATE_LENGTH = 1024;
+
+class OAuthError extends Error {
+  status;
+  code;
+  constructor(status, code, description) {
+    super(description);
+    this.status = status;
+    this.code = code;
+  }
+}
+function constantTimeEqual(a, b) {
+  const x = Buffer.from(a);
+  const y = Buffer.from(b);
+  return x.length === y.length && timingSafeEqual2(x, y);
+}
+function s256(verifier) {
+  return new Bun.CryptoHasher("sha256").update(verifier).digest().toBase64({ alphabet: "base64url", omitPadding: true });
+}
+var VERIFIER = /^[A-Za-z0-9\-._~]{43,128}$/;
+function single(params, names) {
+  const out = {};
+  for (const name of names) {
+    const values = params.getAll(name);
+    if (values.length > 1)
+      return { duplicate: name };
+    const value = values[0];
+    out[name] = value === undefined || value === "" ? undefined : value;
+  }
+  return out;
+}
+function random2(bytes) {
+  return crypto.getRandomValues(new Uint8Array(bytes)).toBase64({ alphabet: "base64url", omitPadding: true });
+}
+function formTarget(redirectUri) {
+  try {
+    const u = new URL(redirectUri);
+    return u.protocol === "http:" || u.protocol === "https:" ? u.origin : u.protocol;
+  } catch {
+    return "'none'";
+  }
+}
+function hostOf(url) {
+  try {
+    const u = new URL(url);
+    return u.host || u.protocol;
+  } catch {
+    return url;
+  }
+}
+
+class AuthorizationServer {
+  #host;
+  #cimd;
+  #pending = new Map;
+  #pendingPerIp = new Map;
+  #pendingPerAddress = new Map;
+  #codes = new Map;
+  #authCodeTtlMs;
+  #methods;
+  #csrfSecret = random2(32);
+  #viewsPerIp = new RateLimiter({
+    capacity: 30,
+    refillPerSecond: 0.5
+  });
+  #attemptsPerIp = new RateLimiter({
+    capacity: 20,
+    refillPerSecond: 0.1
+  });
+  #guessesPerAddressIp = new RateLimiter({
+    capacity: 10,
+    refillPerSecond: 1 / 60
+  });
+  #guessesPerAddress = new RateLimiter({
+    capacity: 30,
+    refillPerSecond: 1 / 30
+  });
+  #tokenPerIp = new RateLimiter({ capacity: 30, refillPerSecond: 1 });
+  constructor(host, testMode) {
+    this.#host = host;
+    this.#authCodeTtlMs = testMode?.authCodeTtlMs ?? AUTH_CODE_TTL_MS;
+    this.#methods = testMode?.pairingMethods ?? PAIRING_METHODS;
+    this.#cimd = new ClientMetadataFetcher({
+      allowedHosts: host.config.clientIdHosts,
+      logger: host.logger,
+      ...testMode?.cimd === undefined ? {} : { testMode: testMode.cimd }
+    });
+  }
+  get #issuer() {
+    return this.#host.publicUrl();
+  }
+  #cors() {
+    return this.#host.config.cors ? { "access-control-allow-origin": "*" } : {};
+  }
+  #json(status, value, headers = {}) {
+    return new Response(JSON.stringify(value), {
+      status,
+      headers: {
+        "content-type": "application/json",
+        ...this.#cors(),
+        ...headers
+      }
+    });
+  }
+  preflight(methods) {
+    if (!this.#host.config.cors) {
+      return new Response(null, { status: 405, headers: { allow: methods } });
+    }
+    return new Response(null, {
+      status: 204,
+      headers: {
+        ...this.#cors(),
+        "access-control-allow-methods": `${methods}, OPTIONS`,
+        "access-control-allow-headers": "authorization, content-type, mcp-protocol-version",
+        "access-control-max-age": "600"
+      }
+    });
+  }
+  protectedResource(addressId) {
+    if (!isAddressId(addressId))
+      return new Response("Not found", { status: 404 });
+    return this.#json(200, {
+      resource: `${this.#issuer}/a/${addressId}/mcp`,
+      authorization_servers: [this.#issuer],
+      scopes_supported: [SCOPE],
+      bearer_methods_supported: ["header"],
+      resource_name: "Tools of a web page (tab-mcp)"
+    }, { "cache-control": "public, max-age=3600" });
+  }
+  metadata() {
+    const issuer = this.#issuer;
+    return this.#json(200, {
+      issuer,
+      authorization_endpoint: `${issuer}/authorize`,
+      token_endpoint: `${issuer}/token`,
+      revocation_endpoint: `${issuer}/revoke`,
+      response_types_supported: ["code"],
+      response_modes_supported: ["query"],
+      grant_types_supported: ["authorization_code", "refresh_token"],
+      code_challenge_methods_supported: ["S256"],
+      token_endpoint_auth_methods_supported: ["none"],
+      revocation_endpoint_auth_methods_supported: ["none"],
+      scopes_supported: [SCOPE],
+      client_id_metadata_document_supported: true,
+      authorization_response_iss_parameter_supported: true,
+      service_documentation: "https://github.com/ractive/tab-mcp"
+    }, { "cache-control": "public, max-age=3600" });
+  }
+  stylesheet() {
+    return new Response(AUTHORIZE_CSS, {
+      headers: {
+        "content-type": "text/css; charset=utf-8",
+        "cache-control": "public, max-age=3600",
+        "x-content-type-options": "nosniff"
+      }
+    });
+  }
+  #page(status, title, body, formTargets = [], extraHeaders = {}) {
+    const headers = pageHeaders(formTargets);
+    for (const [k, v] of Object.entries(extraHeaders))
+      headers.append(k, v);
+    return new Response(renderPage(title, body), { status, headers });
+  }
+  #errorPage(status, message) {
+    return this.#page(status, "This connection cannot be made", `<h1>This connection cannot be made</h1>
+<p role="alert">${escapeHtml(message)}</p>
+<p>Go back to your AI tool and try again. If it keeps happening, the AI tool may not work with this relay.</p>`);
+  }
+  #errorUrl(redirectUri, state, error, description) {
+    const url = new URL(redirectUri);
+    const params = {
+      error,
+      error_description: description,
+      ...state === undefined ? {} : { state },
+      iss: this.#issuer
+    };
+    for (const [k, v] of Object.entries(params))
+      url.searchParams.append(k, v);
+    return url.href;
+  }
+  #invalidRequestPage(redirectUri, state, error, description) {
+    const url = this.#errorUrl(redirectUri, state, error, description);
+    const host = hostOf(redirectUri);
+    return this.#page(400, "This connection cannot be made", `<h1>This connection cannot be made</h1>
+<p role="alert">The AI tool sent a request this relay cannot accept: ${escapeHtml(description)} (${escapeHtml(error)}).</p>
+<p>You can go back to the AI tool at ${escapeHtml(host)} to tell it, or close this page.</p>
+<div class="actions"><a class="button" href="${escapeHtml(url)}">Go back to ${escapeHtml(host)}</a></div>`);
+  }
+  #redirectError(redirectUri, state, error, description) {
+    return new Response(null, {
+      status: 303,
+      headers: {
+        location: this.#errorUrl(redirectUri, state, error, description),
+        "cache-control": "no-store",
+        "referrer-policy": "no-referrer"
+      }
+    });
+  }
+  #redirect(redirectUri, params) {
+    const url = new URL(redirectUri);
+    for (const [k, v] of Object.entries(params))
+      url.searchParams.append(k, v);
+    return new Response(null, {
+      status: 303,
+      headers: {
+        location: url.href,
+        "cache-control": "no-store",
+        "referrer-policy": "no-referrer"
+      }
+    });
+  }
+  async authorize(req, ip) {
+    if (!this.#viewsPerIp.take(ip)) {
+      return this.#errorPage(429, "Too many requests from your network. Wait a minute and try again.");
+    }
+    const query = new URL(req.url).searchParams;
+    const p = single(query, [
+      "response_type",
+      "client_id",
+      "redirect_uri",
+      "code_challenge",
+      "code_challenge_method",
+      "state",
+      "resource",
+      "scope"
+    ]);
+    if ("duplicate" in p) {
+      if (p.duplicate === "client_id" || p.duplicate === "redirect_uri") {
+        return this.#errorPage(400, `The request names ${p.duplicate} twice.`);
+      }
+    }
+    const clientId = "duplicate" in p ? query.get("client_id") : p["client_id"];
+    const redirectUri = "duplicate" in p ? query.get("redirect_uri") : p["redirect_uri"];
+    if (clientId === undefined || clientId === null) {
+      return this.#errorPage(400, "The request has no client_id.");
+    }
+    let client;
+    try {
+      client = await this.#cimd.get(clientId);
+    } catch (error) {
+      if (error instanceof ClientMetadataError) {
+        this.#host.logger.info("oauth.client_refused", {
+          reason: error.reason,
+          host: hostOf(clientId).slice(0, 100)
+        });
+        return this.#errorPage(400, error.message);
+      }
+      throw error;
+    }
+    if (redirectUri === undefined || redirectUri === null) {
+      return this.#errorPage(400, "The request has no redirect_uri.");
+    }
+    if (!client.redirectUris.some((r) => redirectUriMatches(redirectUri, r))) {
+      this.#host.logger.info("oauth.client_refused", {
+        reason: "redirect_uri",
+        host: client.host
+      });
+      return this.#errorPage(400, `${client.name} asked to return to an address it has not registered (${hostOf(redirectUri)}).`);
+    }
+    const state = "duplicate" in p ? undefined : p["state"];
+    const fail = (error, description) => this.#invalidRequestPage(redirectUri, state, error, description);
+    if ("duplicate" in p) {
+      return fail("invalid_request", `${p.duplicate} was sent more than once`);
+    }
+    if (state !== undefined && state.length > MAX_STATE_LENGTH) {
+      return fail("invalid_request", "state is too long");
+    }
+    if (p["response_type"] !== "code") {
+      return fail("unsupported_response_type", "only response_type=code is supported");
+    }
+    const challenge = p["code_challenge"];
+    if (challenge === undefined) {
+      return fail("invalid_request", "code_challenge is required (PKCE)");
+    }
+    if (p["code_challenge_method"] !== "S256") {
+      return fail("invalid_request", "code_challenge_method must be S256");
+    }
+    if (!/^[A-Za-z0-9\-._~]{43,128}$/.test(challenge)) {
+      return fail("invalid_request", "code_challenge is malformed");
+    }
+    const resource = p["resource"];
+    const addressId = this.#addressOf(resource);
+    if (resource === undefined || addressId === undefined) {
+      return fail("invalid_target", "resource must be the MCP address of a page on this relay");
+    }
+    const scopes = this.#grantedScopes(p["scope"]);
+    if (scopes === undefined) {
+      return fail("invalid_scope", `the only scope is "${SCOPE}"`);
+    }
+    if (this.#host.session(addressId) === undefined) {
+      return this.#offlinePage(client, `/authorize${new URL(req.url).search}`, this.#errorUrl(redirectUri, state, "access_denied", "the user cancelled the connection"));
+    }
+    this.#sweepPending();
+    if (this.#pending.size >= MAX_PENDING || (this.#pendingPerIp.get(ip) ?? 0) >= MAX_PENDING_PER_IP || (this.#pendingPerAddress.get(addressId) ?? 0) >= MAX_PENDING_PER_ADDRESS) {
+      return this.#errorPage(429, "Too many connection requests are open right now. Wait a few minutes and try again.");
+    }
+    const pending = {
+      id: random2(24),
+      expiresAt: Date.now() + PENDING_TTL_MS,
+      ip,
+      client,
+      redirectUri,
+      state,
+      codeChallenge: challenge,
+      addressId,
+      resource,
+      scopes
+    };
+    this.#addPending(pending);
+    const browser = this.#browserId(req);
+    return this.#pairingPage(pending, browser.id, undefined, 200, browser.cookie);
+  }
+  #addPending(p) {
+    this.#pending.set(p.id, p);
+    this.#pendingPerIp.set(p.ip, (this.#pendingPerIp.get(p.ip) ?? 0) + 1);
+    this.#pendingPerAddress.set(p.addressId, (this.#pendingPerAddress.get(p.addressId) ?? 0) + 1);
+  }
+  #dropPending(p) {
+    if (!this.#pending.delete(p.id))
+      return;
+    const dec = (map, key) => {
+      const n = (map.get(key) ?? 1) - 1;
+      if (n <= 0)
+        map.delete(key);
+      else
+        map.set(key, n);
+    };
+    dec(this.#pendingPerIp, p.ip);
+    dec(this.#pendingPerAddress, p.addressId);
+  }
+  #offlinePage(client, retryUrl, cancelUrl, error) {
+    const errorHtml = error === undefined ? "" : `<p class="error" role="alert">${escapeHtml(error)}</p>`;
+    const body = `<h1>Open the page first</h1>
+${errorHtml}
+<p><strong>${escapeHtml(client.name)}</strong> (${escapeHtml(client.host)}) wants to use the tools of a web page, but that page is not open right now.</p>
+<p>Open the page, click \u201CConnect your AI tool\u201D, then try again here.</p>
+<div class="actions">
+<a class="button primary" href="${escapeHtml(retryUrl)}">Try again</a>
+<a class="button" href="${escapeHtml(cancelUrl)}">Cancel</a>
+</div>`;
+    return this.#page(200, "Open the page first", body);
+  }
+  async authorizeSubmit(req, ip) {
+    const origin = req.headers.get("origin");
+    const site = req.headers.get("sec-fetch-site");
+    if (origin !== null && origin !== this.#issuer || site !== null && site !== "same-origin") {
+      return this.#errorPage(403, "This form can only be sent from this page.");
+    }
+    if (!this.#attemptsPerIp.take(ip)) {
+      return this.#errorPage(429, "Too many attempts from your network. Wait a few minutes, then start again from your AI tool.");
+    }
+    const type = (req.headers.get("content-type") ?? "").split(";")[0]?.trim();
+    if (type !== "application/x-www-form-urlencoded") {
+      return this.#errorPage(400, "The form was not sent correctly.");
+    }
+    const text = await this.#readForm(req);
+    if (text === undefined) {
+      return this.#errorPage(413, "The form was too large.");
+    }
+    const form = new URLSearchParams(text);
+    const pending = this.#pending.get(form.get("request_id") ?? "");
+    if (pending === undefined || pending.expiresAt <= Date.now()) {
+      return this.#errorPage(400, "This connection request has expired or was already used.");
+    }
+    const browser = this.#browserId(req);
+    const csrf = form.get("csrf") ?? "";
+    if (browser.cookie !== undefined || !Bun.CSRF.verify(csrf, {
+      secret: this.#csrfSecret,
+      sessionId: `${pending.id}.${browser.id}`,
+      maxAge: PENDING_TTL_MS
+    })) {
+      return this.#errorPage(403, "The form could not be checked. Your browser may block cookies for this site.");
+    }
+    const action = form.get("action");
+    if (action === "cancel") {
+      this.#dropPending(pending);
+      this.#host.logger.info("oauth.cancelled", {
+        address: shortAddress(pending.addressId),
+        client: pending.client.host
+      });
+      return this.#redirectError(pending.redirectUri, pending.state, "access_denied", "the user cancelled the connection");
+    }
+    if (action !== "connect") {
+      return this.#pairingPage(pending, browser.id);
+    }
+    const session = this.#host.session(pending.addressId);
+    if (session === undefined) {
+      return this.#pairingPage(pending, browser.id, "The page is still not open.");
+    }
+    const method = this.#methods[session.site.pairing];
+    if (method === undefined) {
+      return this.#errorPage(500, "This page's pairing method is not available.");
+    }
+    const admit = () => this.#guessesPerAddressIp.take(`${pending.addressId}|${ip}`) && this.#guessesPerAddress.take(pending.addressId);
+    const result = await method.check(session, form, admit);
+    if (!result.ok) {
+      this.#host.logger.info("oauth.pairing_failed", {
+        address: shortAddress(pending.addressId),
+        client: pending.client.host,
+        reason: result.reason
+      });
+      return this.#pairingPage(pending, browser.id, result.message, result.reason === "rate_limited" ? 429 : 400);
+    }
+    this.#dropPending(pending);
+    const code = random2(32);
+    if (this.#codes.size >= MAX_CODES)
+      this.#sweepCodes(true);
+    const { id: _id, expiresAt: _expires, ip: _ip, ...request } = pending;
+    this.#codes.set(hashToken(code), {
+      ...request,
+      expiresAt: Date.now() + this.#authCodeTtlMs,
+      used: false
+    });
+    this.#host.logger.info("oauth.paired", {
+      address: shortAddress(pending.addressId),
+      client: pending.client.host,
+      method: method.kind
+    });
+    return this.#redirect(pending.redirectUri, {
+      code,
+      ...pending.state === undefined ? {} : { state: pending.state },
+      iss: this.#issuer
+    });
+  }
+  #addressOf(resource) {
+    if (resource === undefined)
+      return;
+    const prefix = `${this.#issuer}/a/`;
+    if (!resource.startsWith(prefix) || !resource.endsWith("/mcp")) {
+      return;
+    }
+    const id = resource.slice(prefix.length, -"/mcp".length);
+    return isAddressId(id) ? id : undefined;
+  }
+  #grantedScopes(scope) {
+    if (scope === undefined)
+      return [SCOPE];
+    const requested = scope.split(" ").filter((s) => s !== "");
+    if (requested.length === 0)
+      return [SCOPE];
+    return requested.includes(SCOPE) ? [SCOPE] : undefined;
+  }
+  #browserId(req) {
+    const name = this.#cookieName();
+    const header = req.headers.get("cookie") ?? "";
+    for (const part of header.split(";")) {
+      const [k, v] = part.trim().split("=");
+      if (k === name && v !== undefined && /^[A-Za-z0-9_-]{22}$/.test(v)) {
+        return { id: v };
+      }
+    }
+    const id = random2(16);
+    const secure = this.#issuer.startsWith("https:") ? "; Secure" : "";
+    return {
+      id,
+      cookie: `${name}=${id}; Path=/; HttpOnly; SameSite=Lax; Max-Age=${PENDING_TTL_MS / 1000}${secure}`
+    };
+  }
+  #cookieName() {
+    return this.#issuer.startsWith("https:") ? "__Host-tab-mcp-authorize" : "tab-mcp-authorize";
+  }
+  async#readForm(req) {
+    const length = Number(req.headers.get("content-length") ?? "0");
+    if (length > MAX_FORM_BYTES)
+      return;
+    const bytes = await req.arrayBuffer().catch(() => new ArrayBuffer(0));
+    if (bytes.byteLength > MAX_FORM_BYTES)
+      return;
+    return new TextDecoder().decode(bytes);
+  }
+  #pairingPage(pending, browserId, error, status = 200, cookie) {
+    const csrf = Bun.CSRF.generate(this.#csrfSecret, {
+      sessionId: `${pending.id}.${browserId}`,
+      expiresIn: PENDING_TTL_MS
+    });
+    const client = pending.client;
+    const clientLabel = `<strong>${escapeHtml(client.name)}</strong> (${escapeHtml(client.host)})`;
+    const hidden = `<input type="hidden" name="request_id" value="${escapeHtml(pending.id)}">
+<input type="hidden" name="csrf" value="${escapeHtml(csrf)}">`;
+    const errorHtml = error === undefined ? "" : `<p class="error" role="alert" id="error">${escapeHtml(error)}</p>`;
+    const extra = cookie === undefined ? {} : { "set-cookie": cookie };
+    const targets = [formTarget(pending.redirectUri)];
+    const cancel = `<button type="submit" class="secondary" name="action" value="cancel" formnovalidate>Cancel</button>`;
+    const session = this.#host.session(pending.addressId);
+    if (session === undefined) {
+      const body = `<h1>Open the page first</h1>
+${errorHtml}
+<p>${clientLabel} wants to use the tools of a web page, but that page is not open right now.</p>
+<p>Open the page, click \u201CConnect your AI tool\u201D, then try again here.</p>
+<form method="post" action="/authorize">
+${hidden}
+<div class="actions">
+<button type="submit" class="primary" name="action" value="retry">Try again</button>
+${cancel}
+</div>
+</form>`;
+      return this.#page(status, "Open the page first", body, targets, extra);
+    }
+    const method = this.#methods[session.site.pairing];
+    if (method === undefined) {
+      return this.#errorPage(500, "This page's pairing method is not available.");
+    }
+    const page = session.origin === "" ? "a page that did not say where it runs" : `<span class="origin">${escapeHtml(session.origin)}</span>`;
+    const target = session.appName === undefined ? `tools from ${page}` : `<strong>${escapeHtml(session.appName)}</strong> on ${page}`;
+    const heading = `Connect ${client.name} from ${client.host}`;
+    const body = `<h1>${escapeHtml(heading)}</h1>
+<p>You're connecting ${clientLabel} to ${target}.</p>
+<p>${escapeHtml(client.name)} can then use this page's tools while the page is open. You can disconnect it in the page at any time.</p>
+${errorHtml}
+<form method="post" action="/authorize">
+${hidden}
+${method.render(session)}
+<div class="actions">
+<button type="submit" class="primary" name="action" value="connect">Connect</button>
+${cancel}
+</div>
+</form>
+<p class="help">After you connect, your browser goes back to ${escapeHtml(hostOf(pending.redirectUri))}. Only connect AI tools you started yourself.</p>`;
+    return this.#page(status, heading, body, targets, extra);
+  }
+  async token(req, ip) {
+    const noStore = { "cache-control": "no-store", pragma: "no-cache" };
+    try {
+      if (!this.#tokenPerIp.take(ip)) {
+        throw new OAuthError(429, "temporarily_unavailable", "too many requests; try again shortly");
+      }
+      const params = await this.#formParams(req);
+      const p = single(params, [
+        "grant_type",
+        "client_id",
+        "code",
+        "redirect_uri",
+        "code_verifier",
+        "refresh_token",
+        "resource",
+        "scope"
+      ]);
+      if ("duplicate" in p) {
+        throw new OAuthError(400, "invalid_request", `${p.duplicate} was sent more than once`);
+      }
+      const clientId = p["client_id"];
+      if (clientId === undefined) {
+        throw new OAuthError(400, "invalid_request", "client_id is required");
+      }
+      let body;
+      if (p["grant_type"] === "authorization_code") {
+        body = await this.#codeGrant(p, clientId);
+      } else if (p["grant_type"] === "refresh_token") {
+        body = await this.#refreshGrant(p, clientId);
+      } else if (p["grant_type"] === undefined) {
+        throw new OAuthError(400, "invalid_request", "grant_type is required");
+      } else {
+        throw new OAuthError(400, "unsupported_grant_type", "only authorization_code and refresh_token are supported");
+      }
+      return this.#json(200, body, noStore);
+    } catch (error) {
+      return this.#oauthErrorResponse(error, noStore);
+    }
+  }
+  #oauthErrorResponse(error, headers) {
+    if (error instanceof OAuthError) {
+      const extra = { ...headers };
+      if (error.status === 401)
+        extra["www-authenticate"] = 'Basic realm="tab-mcp"';
+      if (error.status === 429 || error.status === 503)
+        extra["retry-after"] = "10";
+      return this.#json(error.status, { error: error.code, error_description: error.message }, extra);
+    }
+    this.#host.logger.error("oauth.error", {
+      message: error instanceof Error ? error.name : "unknown"
+    });
+    return this.#json(503, {
+      error: "temporarily_unavailable",
+      error_description: "the relay cannot issue tokens right now"
+    }, { ...headers, "retry-after": "10" });
+  }
+  async#formParams(req) {
+    const type = (req.headers.get("content-type") ?? "").split(";")[0]?.trim();
+    if (type !== "application/x-www-form-urlencoded") {
+      throw new OAuthError(400, "invalid_request", "the body must be application/x-www-form-urlencoded");
+    }
+    if (req.headers.get("authorization") !== null) {
+      throw new OAuthError(401, "invalid_client", "client authentication is not supported (token_endpoint_auth_method none)");
+    }
+    const text = await this.#readForm(req);
+    if (text === undefined) {
+      throw new OAuthError(413, "invalid_request", "the request is too large");
+    }
+    const params = new URLSearchParams(text);
+    if (params.has("client_secret") || params.has("client_assertion")) {
+      throw new OAuthError(400, "invalid_client", "client authentication is not supported (token_endpoint_auth_method none)");
+    }
+    return params;
+  }
+  async#codeGrant(p, clientId) {
+    const code = p["code"];
+    const redirectUri = p["redirect_uri"];
+    const verifier = p["code_verifier"];
+    if (code === undefined || redirectUri === undefined || verifier === undefined) {
+      throw new OAuthError(400, "invalid_request", "code, redirect_uri and code_verifier are required");
+    }
+    const key = hashToken(code);
+    const issued = this.#codes.get(key);
+    const invalid = (why) => new OAuthError(400, "invalid_grant", why);
+    if (issued === undefined)
+      throw invalid("the code is not valid");
+    if (issued.used) {
+      if (issued.grantId !== undefined) {
+        await this.#revokeGrant(issued.addressId, issued.grantId, "reuse_detected");
+      }
+      throw invalid("the code was already used");
+    }
+    issued.used = true;
+    if (issued.expiresAt <= Date.now())
+      throw invalid("the code has expired");
+    if (!constantTimeEqual(clientId, issued.client.clientId)) {
+      throw invalid("the code was issued to another client");
+    }
+    if (redirectUri !== issued.redirectUri) {
+      throw invalid("redirect_uri does not match the authorization request");
+    }
+    if (p["resource"] !== undefined && p["resource"] !== issued.resource) {
+      throw new OAuthError(400, "invalid_target", "resource does not match the authorization request");
+    }
+    if (!VERIFIER.test(verifier) || !constantTimeEqual(s256(verifier), issued.codeChallenge)) {
+      throw invalid("code_verifier does not match the code_challenge");
+    }
+    const now = Date.now();
+    const grantId = newId("g");
+    issued.grantId = grantId;
+    const config = this.#host.config;
+    const tokens = await issueTokenPair(this.#host.store, {
+      grantId,
+      addressId: issued.addressId,
+      clientId: issued.client.clientId,
+      clientName: issued.client.name,
+      scopes: issued.scopes,
+      grantCreatedAt: now
+    }, {
+      accessTtlMs: config.accessTokenTtlMs,
+      refreshTtlMs: config.refreshTokenTtlMs,
+      grantEndsAt: now + config.grantLifetimeMs,
+      now
+    });
+    if (tokens === undefined) {
+      throw invalid("the connection was revoked");
+    }
+    this.#host.logger.info("oauth.grant_created", {
+      address: shortAddress(issued.addressId),
+      client: issued.client.host
+    });
+    this.#host.grantAdded(issued.addressId, {
+      grantId,
+      client: {
+        id: issued.client.clientId,
+        name: issued.client.name,
+        host: issued.client.host
+      },
+      createdAt: new Date(now).toISOString()
+    });
+    return this.#tokenBody(tokens, issued.scopes);
+  }
+  #tokenBody(tokens, scopes) {
+    return {
+      access_token: tokens.accessToken,
+      token_type: "Bearer",
+      expires_in: tokens.expiresIn,
+      refresh_token: tokens.refreshToken,
+      scope: scopes.join(" ")
+    };
+  }
+  async#refreshGrant(p, clientId) {
+    const token = p["refresh_token"];
+    if (token === undefined) {
+      throw new OAuthError(400, "invalid_request", "refresh_token is required");
+    }
+    const invalid = (why) => new OAuthError(400, "invalid_grant", why);
+    const hash = hashToken(token);
+    const record = await this.#host.store.get(hash);
+    if (record === undefined || record.kind !== "refresh") {
+      throw invalid("the refresh token is not valid");
+    }
+    if (!constantTimeEqual(clientId, record.clientId)) {
+      throw invalid("the refresh token was issued to another client");
+    }
+    const now = Date.now();
+    if (record.expiresAt <= now)
+      throw invalid("the refresh token has expired");
+    if (record.usedAt !== undefined) {
+      await this.#reuseDetected(record);
+      throw invalid("the refresh token was already used; the connection was revoked");
+    }
+    if (p["resource"] !== undefined && p["resource"] !== `${this.#issuer}/a/${record.addressId}/mcp`) {
+      throw new OAuthError(400, "invalid_target", "resource is not the address this token belongs to");
+    }
+    const scope = p["scope"];
+    if (scope !== undefined) {
+      const wanted = scope.split(" ").filter((s) => s !== "");
+      if (!wanted.every((s) => record.scopes.includes(s))) {
+        throw new OAuthError(400, "invalid_scope", "scope exceeds the grant");
+      }
+    }
+    if (!await this.#host.store.markUsed(hash, now)) {
+      await this.#reuseDetected(record);
+      throw invalid("the refresh token was already used; the connection was revoked");
+    }
+    const tokens = await issueTokenPair(this.#host.store, {
+      grantId: record.grantId,
+      addressId: record.addressId,
+      clientId: record.clientId,
+      clientName: record.clientName,
+      scopes: record.scopes,
+      grantCreatedAt: record.grantCreatedAt
+    }, {
+      accessTtlMs: this.#host.config.accessTokenTtlMs,
+      refreshTtlMs: this.#host.config.refreshTokenTtlMs,
+      grantEndsAt: record.grantCreatedAt + this.#host.config.grantLifetimeMs,
+      now
+    });
+    if (tokens === undefined) {
+      throw invalid("the connection was revoked");
+    }
+    this.#host.logger.debug("oauth.refreshed", {
+      address: shortAddress(record.addressId),
+      client: hostOf(record.clientId)
+    });
+    return this.#tokenBody(tokens, record.scopes);
+  }
+  async#reuseDetected(record) {
+    this.#host.logger.warn("oauth.refresh_reuse", {
+      address: shortAddress(record.addressId),
+      client: hostOf(record.clientId)
+    });
+    await this.#revokeGrant(record.addressId, record.grantId, "reuse_detected");
+  }
+  async#revokeGrant(addressId, grantId, reason) {
+    const now = Date.now();
+    const n = await this.#host.store.revoke({ grantId }, { now, keepUntil: now + this.#host.config.grantLifetimeMs });
+    if (n > 0)
+      this.#host.grantRemoved(addressId, grantId, reason);
+  }
+  async revoke(req, ip) {
+    const noStore = { "cache-control": "no-store" };
+    try {
+      if (!this.#tokenPerIp.take(ip)) {
+        throw new OAuthError(429, "temporarily_unavailable", "too many requests; try again shortly");
+      }
+      const params = await this.#formParams(req);
+      const p = single(params, ["token", "client_id", "token_type_hint"]);
+      if ("duplicate" in p) {
+        throw new OAuthError(400, "invalid_request", `${p.duplicate} was sent more than once`);
+      }
+      const token = p["token"];
+      const clientId = p["client_id"];
+      if (token === undefined || clientId === undefined) {
+        throw new OAuthError(400, "invalid_request", "token and client_id are required");
+      }
+      const record = await this.#host.store.get(hashToken(token));
+      if (record === undefined)
+        return new Response(null, {
+          status: 200,
+          headers: { ...this.#cors(), ...noStore }
+        });
+      if (!constantTimeEqual(clientId, record.clientId)) {
+        throw new OAuthError(400, "invalid_client", "the token was issued to another client");
+      }
+      await this.#revokeGrant(record.addressId, record.grantId, "revoked");
+      this.#host.logger.info("oauth.revoked", {
+        address: shortAddress(record.addressId),
+        client: hostOf(record.clientId),
+        by: "client"
+      });
+      return new Response(null, {
+        status: 200,
+        headers: { ...this.#cors(), ...noStore }
+      });
+    } catch (error) {
+      return this.#oauthErrorResponse(error, noStore);
+    }
+  }
+  #sweepPending() {
+    const now = Date.now();
+    for (const p of this.#pending.values()) {
+      if (p.expiresAt > now)
+        break;
+      this.#dropPending(p);
+    }
+  }
+  #sweepCodes(force = false) {
+    const now = Date.now();
+    for (const [key, c] of this.#codes) {
+      if (c.expiresAt <= now)
+        this.#codes.delete(key);
+    }
+    if (force && this.#codes.size >= MAX_CODES) {
+      const drop = this.#codes.size - MAX_CODES + 1;
+      for (const key of [...this.#codes.keys()].slice(0, drop)) {
+        this.#codes.delete(key);
+      }
+    }
+  }
+  sweep() {
+    this.#sweepPending();
+    this.#sweepCodes();
+    const now = Date.now();
+    this.#viewsPerIp.sweep(now);
+    this.#attemptsPerIp.sweep(now);
+    this.#guessesPerAddressIp.sweep(now);
+    this.#guessesPerAddress.sweep(now);
+    this.#tokenPerIp.sweep(now);
+  }
+}
+
+// src/session.ts
+function limitsOf(limits) {
+  return {
+    maxMessageBytes: limits.maxMessageBytes,
+    maxBodyBytes: limits.maxMessageBytes,
+    requestTimeoutMs: limits.requestTimeoutMs,
+    idleTimeoutMs: limits.idleTimeoutMs,
+    heartbeatMs: limits.heartbeatMs,
+    keepAliveMs: limits.keepAliveMs,
+    maxConcurrentRequests: limits.maxConcurrentRequests
+  };
+}
+function clientHost(clientId) {
+  try {
+    return new URL(clientId).host;
+  } catch {
+    return "";
+  }
+}
+function messageId(parsed) {
+  if ("message" in parsed) {
+    return "id" in parsed.message ? parsed.message.id : undefined;
+  }
+  return parsed.id;
+}
+
+class TabSession {
+  sessionId = newId("s");
+  ip;
+  origin;
+  site;
+  openedAt = Date.now();
+  addressId;
+  appName;
+  codes;
+  pending = new Map;
+  #ws;
+  #host;
+  #state = "new";
+  #lastRequestAt = Date.now();
+  #missedPongs = 0;
+  #nextRequest = 0;
+  #helloTimer;
+  #heartbeatTimer;
+  #lifetimeTimer;
+  constructor(ws, ip, origin, site, host) {
+    this.#ws = ws;
+    this.ip = ip;
+    this.origin = origin;
+    this.site = site;
+    this.#host = host;
+    this.codes = new PairingCodes((code, expiresAt) => {
+      this.send({
+        type: "pairing.code",
+        code,
+        expiresAt: new Date(expiresAt).toISOString()
+      });
+    }, host.pairingCodeTtlMs === undefined ? {} : { ttlMs: host.pairingCodeTtlMs });
+    this.#helloTimer = setTimeout(() => {
+      if (this.#state === "new") {
+        this.#protocolError("bad_message", "no hello in time");
+      }
+    }, host.config.helloTimeoutMs);
+  }
+  get ready() {
+    return this.#state === "ready";
+  }
+  get limits() {
+    return this.site.limits;
+  }
+  send(message) {
+    if (this.#state === "ended")
+      return false;
+    let sent;
+    try {
+      sent = this.#ws.send(JSON.stringify(message));
+    } catch {
+      return false;
+    }
+    if (sent === 0) {
+      this.#host.logger.warn("tab.send_dropped", {
+        session: this.sessionId,
+        type: message.type
+      });
+      return false;
+    }
+    return true;
+  }
+  handleFrame(data) {
+    if (this.#state === "ended")
+      return;
+    if (typeof data !== "string") {
+      this.#protocolError("bad_message", "binary frames are not allowed");
+      return;
+    }
+    const tooLarge = Buffer.byteLength(data) > this.limits.maxMessageBytes;
+    const parsed = parseTabMessage(data);
+    if (tooLarge) {
+      const id = messageId(parsed);
+      this.#sendError("too_large", "message exceeds maxMessageBytes", id);
+      const exchange = id === undefined ? undefined : this.pending.get(id);
+      exchange?.fail(502, RelayErrorCode.tooLarge, "The page sent a response that is too large.", true);
+      return;
+    }
+    if (!parsed.ok) {
+      if (this.#state === "new") {
+        this.#protocolError("bad_message", parsed.error);
+        return;
+      }
+      this.#sendError("bad_message", parsed.error, parsed.id);
+      const exchange = parsed.id === undefined ? undefined : this.pending.get(parsed.id);
+      exchange?.fail(502, RelayErrorCode.badResponse, "The page sent an invalid response.", true);
+      return;
+    }
+    if ("unknown" in parsed) {
+      if (this.#state === "new") {
+        this.#protocolError("bad_message", "hello expected");
+      } else if (parsed.id !== undefined) {
+        this.#sendError("unknown_type", `unknown type ${parsed.type}`, parsed.id);
+      }
+      return;
+    }
+    this.#handle(parsed.message).catch((error) => {
+      this.#host.logger.error("tab.handler_error", {
+        session: this.sessionId,
+        type: parsed.message.type,
+        message: error instanceof Error ? error.name : "unknown"
+      });
+      this.#sendError("bad_message", "the relay could not handle this message");
+    });
+  }
+  async#handle(msg) {
+    if (this.#state === "new") {
+      if (msg.type !== "hello") {
+        this.#protocolError("bad_message", "hello expected");
+        return;
+      }
+      await this.#hello(msg.secret, msg.library, msg.app?.name);
+      return;
+    }
+    if (this.#state === "hello")
+      return;
+    switch (msg.type) {
+      case "hello":
+        this.#sendError("bad_message", "hello was already sent");
+        return;
+      case "pong":
+        this.#missedPongs = 0;
+        return;
+      case "bye":
+        this.end(CloseCode.normal, "bye");
+        return;
+      case "pairing.start":
+        if (this.site.pairing === "code")
+          this.codes.start();
+        return;
+      case "pairing.stop":
+        this.codes.stop();
+        return;
+      case "grant.revoke":
+        if (!await this.#host.revokeGrant(this, msg.grantId)) {
+          this.#sendError("unknown_id", "unknown grant");
+        }
+        return;
+      case "grants.revokeAll":
+        await this.#host.revokeAll(this);
+        return;
+      case "error":
+        this.#host.logger.debug("tab.error", {
+          session: this.sessionId,
+          code: msg.code
+        });
+        return;
+      case "http.response":
+      case "http.response.start":
+      case "http.response.chunk":
+      case "http.response.end": {
+        const exchange = this.pending.get(msg.id);
+        if (exchange === undefined)
+          return;
+        if (msg.type === "http.response")
+          exchange.onResponse(msg);
+        else if (msg.type === "http.response.start")
+          exchange.onStart(msg);
+        else if (msg.type === "http.response.chunk")
+          exchange.onChunk(msg.data);
+        else
+          exchange.onEnd();
+        if (exchange.badResponseReason !== undefined) {
+          this.#sendError("bad_message", exchange.badResponseReason, msg.id);
+        }
+        return;
+      }
+    }
+  }
+  async#hello(secret, library, appName) {
+    if (!isWellFormedSecret(secret)) {
+      this.#protocolError("bad_message", "secret must be 43 base64url characters");
+      return;
+    }
+    clearTimeout(this.#helloTimer);
+    this.#state = "hello";
+    this.addressId = addressIdFromSecret(secret);
+    this.appName = this.site.name ?? appName;
+    const replaced = this.#host.claimAddress(this);
+    if (replaced !== undefined) {
+      replaced.end(CloseCode.replaced, "replaced by a newer session", "replaced");
+    }
+    let grants = [];
+    try {
+      const list = await this.#host.store.listGrants(this.addressId, Date.now());
+      grants = list.map((g) => ({
+        grantId: g.grantId,
+        client: {
+          id: g.clientId,
+          name: g.clientName,
+          host: clientHost(g.clientId)
+        },
+        createdAt: new Date(g.createdAt).toISOString()
+      }));
+    } catch (error) {
+      this.#host.logger.error("store.error", {
+        op: "listGrants",
+        message: error instanceof Error ? error.message : "unknown"
+      });
+    }
+    if (this.#state !== "hello")
+      return;
+    const limits = this.limits;
+    const expiresAt = this.openedAt + limits.sessionLifetimeMs;
+    this.#state = "ready";
+    const sent = this.send({
+      type: "session",
+      sessionId: this.sessionId,
+      address: `${this.#host.publicUrl()}/a/${this.addressId}/mcp`,
+      origin: this.origin,
+      ...this.appName === undefined ? {} : { appName: this.appName },
+      expiresAt: new Date(expiresAt).toISOString(),
+      limits: limitsOf(limits),
+      grants
+    });
+    if (!sent) {
+      this.end(CloseCode.policyViolation, "send failed");
+      return;
+    }
+    this.#heartbeatTimer = setInterval(() => this.#tick(), limits.heartbeatMs);
+    this.#lifetimeTimer = setTimeout(() => this.end(CloseCode.sessionExpired, "session lifetime reached", "expired"), Math.max(0, expiresAt - Date.now()));
+    this.#host.logger.info("tab.session", {
+      session: this.sessionId,
+      address: shortAddress(this.addressId),
+      origin: this.origin,
+      library: `${library.name}@${library.version}`,
+      replaced: replaced !== undefined
+    });
+  }
+  #tick() {
+    if (this.#state !== "ready")
+      return;
+    if (this.#missedPongs >= 2) {
+      this.end(CloseCode.heartbeatLost, "heartbeat lost");
+      return;
+    }
+    if (this.pending.size === 0 && Date.now() - this.#lastRequestAt >= this.limits.idleTimeoutMs) {
+      this.end(CloseCode.idleTimeout, "idle", "idle");
+      return;
+    }
+    this.#missedPongs++;
+    this.send({ type: "ping", t: Date.now() });
+  }
+  forward(input) {
+    this.#lastRequestAt = Date.now();
+    const id = `r${++this.#nextRequest}`;
+    const limits = this.limits;
+    const exchange = new Exchange({
+      id,
+      rpcId: input.rpcId,
+      isListen: input.isListen,
+      requestTimeoutMs: limits.requestTimeoutMs,
+      keepAliveMs: limits.keepAliveMs,
+      maxBodyBytes: limitsOf(limits).maxBodyBytes,
+      extraHeaders: input.extraHeaders,
+      cancel: (reason) => {
+        if (!this.send({ type: "http.cancel", id, reason })) {
+          this.#host.logger.debug("tab.cancel_not_sent", {
+            session: this.sessionId
+          });
+        }
+      },
+      onDone: (e) => {
+        this.pending.delete(id);
+        this.#lastRequestAt = Date.now();
+        input.onDone(e);
+      }
+    });
+    this.pending.set(id, exchange);
+    const sent = this.send({
+      type: "http.request",
+      id,
+      method: input.method,
+      path: "/mcp",
+      headers: input.headers,
+      body: input.body,
+      grant: input.grant
+    });
+    if (!sent) {
+      exchange.fail(503, RelayErrorCode.sendFailed, "The connection to the page is overloaded. Try again.", false);
+    }
+    return exchange;
+  }
+  end(code, reason, bye) {
+    if (this.#state === "ended")
+      return;
+    if (bye !== undefined)
+      this.send({ type: "bye", reason: bye });
+    this.#cleanup(code, reason);
+    try {
+      this.#ws.close(code, reason);
+    } catch {}
+  }
+  closed(code) {
+    this.#cleanup(code, "closed");
+  }
+  #cleanup(code, reason) {
+    if (this.#state === "ended")
+      return;
+    const wasReady = this.#state === "ready" || this.#state === "hello";
+    this.#state = "ended";
+    this.codes.stop();
+    clearTimeout(this.#helloTimer);
+    clearInterval(this.#heartbeatTimer);
+    clearTimeout(this.#lifetimeTimer);
+    for (const exchange of [...this.pending.values()]) {
+      exchange.fail(503, RelayErrorCode.tabGone, "The page closed its connection to the relay.", false);
+    }
+    this.#host.released(this);
+    if (wasReady) {
+      this.#host.logger.info("tab.closed", {
+        session: this.sessionId,
+        code,
+        reason,
+        durationMs: Date.now() - this.openedAt
+      });
+    }
+  }
+  #sendError(code, message, id) {
+    this.send(id === undefined ? { type: "error", code, message } : { type: "error", code, message, id });
+  }
+  #protocolError(code, message) {
+    this.#sendError(code, message);
+    this.end(CloseCode.policyViolation, message);
+  }
+}
+
+// src/store/memory.ts
+function copy(record) {
+  return { ...record, scopes: [...record.scopes] };
+}
+function matches(record, selector) {
+  return "grantId" in selector ? record.grantId === selector.grantId : record.addressId === selector.addressId;
+}
+function isLive(record, now) {
+  return record.expiresAt > now && (record.kind === "access" || record.usedAt === undefined);
+}
+function summarizeGrants(records, now) {
+  const grants = new Map;
+  for (const r of records) {
+    if (!isLive(r, now) || grants.has(r.grantId))
+      continue;
+    grants.set(r.grantId, {
+      grantId: r.grantId,
+      clientId: r.clientId,
+      clientName: r.clientName,
+      scopes: [...r.scopes],
+      createdAt: r.grantCreatedAt
+    });
+  }
+  return [...grants.values()].sort((a, b) => a.createdAt - b.createdAt || a.grantId.localeCompare(b.grantId));
+}
+
+class MemoryTokenStore {
+  #records = new Map;
+  #revokedGrants = new Map;
+  #revokedAddresses = new Map;
+  async put(record) {
+    if (this.#revokedGrants.has(record.grantId))
+      return false;
+    const address = this.#revokedAddresses.get(record.addressId);
+    if (address !== undefined && record.grantCreatedAt <= address.at) {
+      return false;
+    }
+    this.#records.set(record.hash, copy(record));
+    return true;
+  }
+  async get(hash) {
+    const r = this.#records.get(hash);
+    return r === undefined ? undefined : copy(r);
+  }
+  async markUsed(hash, now) {
+    const r = this.#records.get(hash);
+    if (r === undefined || r.usedAt !== undefined)
+      return false;
+    r.usedAt = now;
+    return true;
+  }
+  async revoke(selector, options) {
+    if ("grantId" in selector) {
+      this.#revokedGrants.set(selector.grantId, options.keepUntil);
+    } else {
+      const old = this.#revokedAddresses.get(selector.addressId);
+      this.#revokedAddresses.set(selector.addressId, {
+        at: Math.max(old?.at ?? 0, options.now),
+        until: Math.max(old?.until ?? 0, options.keepUntil)
+      });
+    }
+    let n = 0;
+    for (const [hash, r] of this.#records) {
+      if (matches(r, selector)) {
+        this.#records.delete(hash);
+        n++;
+      }
+    }
+    return n;
+  }
+  async listGrants(addressId, now) {
+    const own = [...this.#records.values()].filter((r) => r.addressId === addressId);
+    return summarizeGrants(own, now);
+  }
+  async deleteExpired(now) {
+    for (const [id, until] of this.#revokedGrants) {
+      if (until <= now)
+        this.#revokedGrants.delete(id);
+    }
+    for (const [id, t] of this.#revokedAddresses) {
+      if (t.until <= now)
+        this.#revokedAddresses.delete(id);
+    }
+    let n = 0;
+    for (const [hash, r] of this.#records) {
+      if (r.expiresAt <= now) {
+        this.#records.delete(hash);
+        n++;
+      }
+    }
+    return n;
+  }
+  async close() {
+    this.#records.clear();
+    this.#revokedGrants.clear();
+    this.#revokedAddresses.clear();
+  }
+}
+
+// src/store/sqlite.ts
+import { Database } from "bun:sqlite";
+var SCHEMA_VERSION = 2;
+function toRecord(row) {
+  const record = {
+    hash: row.hash,
+    kind: row.kind,
+    grantId: row.grant_id,
+    addressId: row.address_id,
+    clientId: row.client_id,
+    clientName: row.client_name,
+    scopes: JSON.parse(row.scopes),
+    grantCreatedAt: row.grant_created_at,
+    issuedAt: row.issued_at,
+    expiresAt: row.expires_at
+  };
+  if (row.used_at !== null)
+    record.usedAt = row.used_at;
+  return record;
+}
+
+class SqliteTokenStore {
+  #db;
+  constructor(path) {
+    this.#db = new Database(path, { create: true, strict: true });
+    this.#db.run("PRAGMA busy_timeout = 5000");
+    if (path !== ":memory:")
+      this.#db.run("PRAGMA journal_mode = WAL");
+    this.#migrate();
+  }
+  #migrate() {
+    const row = this.#db.query("PRAGMA user_version").get();
+    if (row.user_version >= SCHEMA_VERSION)
+      return;
+    this.#db.transaction(() => {
+      this.#db.run(`CREATE TABLE IF NOT EXISTS revocations (
+				kind TEXT NOT NULL CHECK (kind IN ('grant', 'address')),
+				id TEXT NOT NULL,
+				at INTEGER NOT NULL,
+				keep_until INTEGER NOT NULL,
+				PRIMARY KEY (kind, id)
+			) STRICT`);
+      this.#db.run(`CREATE TABLE IF NOT EXISTS tokens (
+				hash TEXT PRIMARY KEY,
+				kind TEXT NOT NULL CHECK (kind IN ('access', 'refresh')),
+				grant_id TEXT NOT NULL,
+				address_id TEXT NOT NULL,
+				client_id TEXT NOT NULL,
+				client_name TEXT NOT NULL,
+				scopes TEXT NOT NULL,
+				grant_created_at INTEGER NOT NULL,
+				issued_at INTEGER NOT NULL,
+				expires_at INTEGER NOT NULL,
+				used_at INTEGER
+			) STRICT`);
+      this.#db.run("CREATE INDEX IF NOT EXISTS tokens_grant ON tokens (grant_id)");
+      this.#db.run("CREATE INDEX IF NOT EXISTS tokens_address ON tokens (address_id)");
+      this.#db.run("CREATE INDEX IF NOT EXISTS tokens_expires ON tokens (expires_at)");
+      this.#db.run(`PRAGMA user_version = ${SCHEMA_VERSION}`);
+    })();
+  }
+  async put(r) {
+    return this.#db.transaction(() => {
+      const revoked = this.#db.query(`SELECT 1 FROM revocations WHERE (kind = 'grant' AND id = $grant_id)
+					OR (kind = 'address' AND id = $address_id AND at >= $created)`).get({
+        grant_id: r.grantId,
+        address_id: r.addressId,
+        created: r.grantCreatedAt
+      });
+      if (revoked !== null)
+        return false;
+      this.#insert(r);
+      return true;
+    })();
+  }
+  #insert(r) {
+    this.#db.query(`INSERT OR REPLACE INTO tokens (hash, kind, grant_id, address_id, client_id,
+				client_name, scopes, grant_created_at, issued_at, expires_at, used_at)
+				VALUES ($hash, $kind, $grant_id, $address_id, $client_id, $client_name,
+				$scopes, $grant_created_at, $issued_at, $expires_at, $used_at)`).run({
+      hash: r.hash,
+      kind: r.kind,
+      grant_id: r.grantId,
+      address_id: r.addressId,
+      client_id: r.clientId,
+      client_name: r.clientName,
+      scopes: JSON.stringify(r.scopes),
+      grant_created_at: r.grantCreatedAt,
+      issued_at: r.issuedAt,
+      expires_at: r.expiresAt,
+      used_at: r.usedAt ?? null
+    });
+  }
+  async get(hash) {
+    const row = this.#db.query("SELECT * FROM tokens WHERE hash = $hash").get({ hash });
+    return row === null ? undefined : toRecord(row);
+  }
+  async markUsed(hash, now) {
+    const result = this.#db.query("UPDATE tokens SET used_at = $now WHERE hash = $hash AND used_at IS NULL").run({ hash, now });
+    return result.changes === 1;
+  }
+  async revoke(selector, options) {
+    return this.#db.transaction(() => {
+      this.#db.query(`INSERT INTO revocations (kind, id, at, keep_until) VALUES ($kind, $id, $at, $until)
+					ON CONFLICT (kind, id) DO UPDATE SET at = max(at, excluded.at),
+					keep_until = max(keep_until, excluded.keep_until)`).run({
+        kind: "grantId" in selector ? "grant" : "address",
+        id: "grantId" in selector ? selector.grantId : selector.addressId,
+        at: options.now,
+        until: options.keepUntil
+      });
+      return this.#delete(selector);
+    })();
+  }
+  #delete(selector) {
+    const result = "grantId" in selector ? this.#db.query("DELETE FROM tokens WHERE grant_id = $id").run({ id: selector.grantId }) : this.#db.query("DELETE FROM tokens WHERE address_id = $id").run({ id: selector.addressId });
+    return result.changes;
+  }
+  async listGrants(addressId, now) {
+    const rows = this.#db.query(`SELECT * FROM tokens WHERE address_id = $addressId AND expires_at > $now
+				AND (kind = 'access' OR used_at IS NULL)`).all({ addressId, now });
+    return summarizeGrants(rows.map(toRecord), now);
+  }
+  async deleteExpired(now) {
+    this.#db.query("DELETE FROM revocations WHERE keep_until <= $now").run({ now });
+    return this.#db.query("DELETE FROM tokens WHERE expires_at <= $now").run({ now }).changes;
+  }
+  async close() {
+    this.#db.close();
+  }
+}
+
+// src/relay.ts
+var VERSION = version;
+var CLAUDE_MISMATCHED_HEADER = "2025-11-25";
+var FORWARDED_HEADERS = new Set([
+  "content-type",
+  "accept",
+  "mcp-method",
+  "mcp-name",
+  "traceparent",
+  "tracestate"
+]);
+function json(status, value, headers) {
+  const h = new Headers(headers);
+  h.set("content-type", "application/json");
+  return new Response(JSON.stringify(value), { status, headers: h });
+}
+function rpcError(status, rpcId, code, message, headers, data) {
+  return new Response(rpcErrorBody(rpcId, code, message, data), {
+    status,
+    headers: { ...headers, "content-type": "application/json" }
+  });
+}
+function rpcIdOf(body) {
+  if (!("id" in body))
+    return;
+  const id = body["id"];
+  return typeof id === "string" || typeof id === "number" ? id : null;
+}
+function methodForLog(body) {
+  const m = body["method"];
+  return typeof m === "string" && /^[A-Za-z0-9_/.-]{1,64}$/.test(m) ? m : "?";
+}
+function metaVersion(body) {
+  const params = body["params"];
+  if (typeof params !== "object" || params === null)
+    return;
+  const meta = params["_meta"];
+  if (typeof meta !== "object" || meta === null)
+    return;
+  return meta[PROTOCOL_VERSION_META_KEY];
+}
+var INDEX_HTML = `<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1">
+<title>tab-mcp relay</title></head>
+<body><h1>tab-mcp relay</h1>
+<p>This server relays AI apps' MCP requests to tools offered by web pages open in a browser tab.
+It does not log request contents. Source and documentation:
+<a href="https://github.com/ractive/tab-mcp">github.com/ractive/tab-mcp</a>.</p>
+</body></html>`;
+function createRelay(options = {}) {
+  return startRelay(options, undefined);
+}
+function startRelay(options, hooks) {
+  const { store: storeOption, logger: givenLogger, ...partial } = options;
+  const tokenStore = typeof storeOption === "object" ? storeOption : undefined;
+  const config = resolveConfig(typeof storeOption === "string" ? { ...partial, store: storeOption } : partial);
+  const logger = givenLogger ?? createLogger(config.logLevel);
+  const ownsStore = tokenStore === undefined;
+  const store = tokenStore ?? (config.store === "sqlite" ? new SqliteTokenStore(config.sqlitePath) : new MemoryTokenStore);
+  const sessions = new Map;
+  const allSessions = new Set;
+  const perIp = new Map;
+  let claudeWorkarounds = 0;
+  let publicUrl = config.publicUrl ?? "";
+  const corsHeaders = config.cors ? {
+    "access-control-allow-origin": "*",
+    "access-control-expose-headers": "www-authenticate, mcp-protocol-version"
+  } : {};
+  const revokeOptions = () => {
+    const now = Date.now();
+    return { now, keepUntil: now + config.grantLifetimeMs };
+  };
+  function grantRemoved(addressId, grantId, reason) {
+    const session = sessions.get(addressId);
+    if (session?.ready)
+      session.send({ type: "grant.removed", grantId, reason });
+  }
+  const host = {
+    config,
+    logger,
+    store,
+    ...hooks?.pairingCodeTtlMs === undefined ? {} : { pairingCodeTtlMs: hooks.pairingCodeTtlMs },
+    publicUrl: () => publicUrl,
+    async revokeGrant(session, grantId) {
+      const addressId = session.addressId;
+      if (addressId === undefined)
+        return false;
+      const grants = await store.listGrants(addressId, Date.now());
+      if (!grants.some((g) => g.grantId === grantId))
+        return false;
+      await store.revoke({ grantId }, revokeOptions());
+      logger.info("oauth.revoked", {
+        address: shortAddress(addressId),
+        by: "tab"
+      });
+      grantRemoved(addressId, grantId, "revoked");
+      return true;
+    },
+    async revokeAll(session) {
+      const addressId = session.addressId;
+      if (addressId === undefined)
+        return;
+      const grants = await store.listGrants(addressId, Date.now());
+      await store.revoke({ addressId }, revokeOptions());
+      logger.info("oauth.revoked_all", {
+        address: shortAddress(addressId),
+        grants: grants.length
+      });
+      for (const g of grants)
+        grantRemoved(addressId, g.grantId, "revoked");
+    },
+    claimAddress(session) {
+      const id = session.addressId;
+      if (id === undefined)
+        return;
+      const previous = sessions.get(id);
+      sessions.set(id, session);
+      return previous === session ? undefined : previous;
+    },
+    released(session) {
+      allSessions.delete(session);
+      if (session.addressId !== undefined && sessions.get(session.addressId) === session) {
+        sessions.delete(session.addressId);
+      }
+      releaseIp(session.ip);
+    }
+  };
+  function releaseIp(ip) {
+    const n = (perIp.get(ip) ?? 1) - 1;
+    if (n <= 0)
+      perIp.delete(ip);
+    else
+      perIp.set(ip, n);
+  }
+  function clientIp(req, server) {
+    if (config.trustProxy === "x-real-ip") {
+      const v = req.headers.get("x-real-ip")?.trim();
+      if (v)
+        return v;
+    } else if (config.trustProxy === "x-forwarded-for") {
+      const parts = (req.headers.get("x-forwarded-for") ?? "").split(",").map((s) => s.trim()).filter((s) => s !== "");
+      const last = parts.at(-1);
+      if (last !== undefined)
+        return last;
+    }
+    return server.requestIP(req)?.address ?? "unknown";
+  }
+  const auth = new AuthorizationServer({
+    config,
+    logger,
+    store,
+    publicUrl: () => publicUrl,
+    session: (addressId) => {
+      const s = sessions.get(addressId);
+      return s?.ready === true ? s : undefined;
+    },
+    grantAdded: (addressId, grant) => {
+      const session = sessions.get(addressId);
+      if (session?.ready)
+        session.send({ type: "grant.added", grant });
+    },
+    grantRemoved: (addressId, grantId, reason) => grantRemoved(addressId, grantId, reason)
+  }, hooks);
+  if (hooks !== undefined) {
+    logger.warn("relay.test_hooks", {
+      message: "test hooks are on: never use this relay outside tests"
+    });
+  }
+  function handleTab(req, server) {
+    const origin = req.headers.get("origin");
+    const site = siteFor(config, origin);
+    if (site === undefined) {
+      logger.info("tab.refused", { reason: "origin" });
+      return json(403, { error: "origin_not_allowed" });
+    }
+    const offered = (req.headers.get("sec-websocket-protocol") ?? "").split(",").map((s) => s.trim());
+    if (!offered.includes(SUBPROTOCOL)) {
+      return json(426, {
+        error: "unsupported_protocol",
+        supported: [SUBPROTOCOL]
+      });
+    }
+    const realIp = clientIp(req, server);
+    const ip = ipPrefixKey(realIp);
+    if (allSessions.size >= config.maxSessions) {
+      logger.warn("tab.refused", { reason: "max_sessions" });
+      return json(429, { error: "too_many_sessions" });
+    }
+    const count = perIp.get(ip) ?? 0;
+    if (count >= config.maxSessionsPerIp) {
+      logger.warn("tab.refused", {
+        reason: "max_sessions_per_ip",
+        ip: truncateIp(realIp)
+      });
+      return json(429, { error: "too_many_sessions" });
+    }
+    perIp.set(ip, count + 1);
+    const ok = server.upgrade(req, {
+      data: { ip, origin: origin ?? "", site },
+      headers: { "Sec-WebSocket-Protocol": SUBPROTOCOL }
+    });
+    if (ok)
+      return;
+    releaseIp(ip);
+    return json(400, { error: "websocket_upgrade_expected" });
+  }
+  function wwwAuthenticate(id, presented) {
+    const metadata = `${publicUrl}/.well-known/oauth-protected-resource/a/${id}/mcp`;
+    const error = presented ? ', error="invalid_token"' : "";
+    return `Bearer resource_metadata="${metadata}", scope="tools"${error}`;
+  }
+  async function authenticate(req, addressId) {
+    const header = req.headers.get("authorization");
+    if (header === null)
+      return "missing";
+    const match = /^Bearer ([A-Za-z0-9._~+/-]+=*)$/i.exec(header.trim());
+    const token = match?.[1];
+    if (token === undefined)
+      return "invalid";
+    let record;
+    try {
+      record = await store.get(hashToken(token));
+    } catch (error) {
+      logger.error("store.error", {
+        op: "get",
+        message: error instanceof Error ? error.message : "unknown"
+      });
+      return "unavailable";
+    }
+    if (record === undefined || record.kind !== "access" || record.addressId !== addressId || record.expiresAt <= Date.now() || !record.scopes.includes("tools")) {
+      return "invalid";
+    }
+    return record;
+  }
+  async function readBody(req, maxBytes) {
+    const length = Number(req.headers.get("content-length") ?? "0");
+    if (length > maxBytes) {
+      return rpcError(413, undefined, -32600, "Request body too large.", corsHeaders);
+    }
+    let bytes;
+    try {
+      const reading = req.arrayBuffer();
+      reading.catch(() => {});
+      let timer;
+      const deadline = new Promise((resolve) => {
+        timer = setTimeout(() => resolve("timeout"), config.bodyTimeoutMs);
+      });
+      const result = await Promise.race([reading, deadline]);
+      clearTimeout(timer);
+      if (result === "timeout") {
+        return rpcError(408, undefined, -32600, "The request body did not arrive in time.", { ...corsHeaders, connection: "close" });
+      }
+      bytes = result;
+    } catch {
+      return rpcError(400, undefined, -32700, "Could not read the request body.", corsHeaders);
+    }
+    if (bytes.byteLength > maxBytes) {
+      return rpcError(413, undefined, -32600, "Request body too large.", corsHeaders);
+    }
+    let text;
+    let value;
+    try {
+      text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+      value = JSON.parse(text);
+    } catch {
+      return rpcError(400, undefined, -32700, "Parse error.", corsHeaders);
+    }
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+      return rpcError(400, undefined, -32600, "The body must be one JSON-RPC message (no batches).", corsHeaders);
+    }
+    return { value, text };
+  }
+  function checkVersion(req, body, rpcId) {
+    const header = req.headers.get("mcp-protocol-version");
+    if (body["method"] === "initialize") {
+      const params = body["params"];
+      const requested = typeof params?.["protocolVersion"] === "string" ? params["protocolVersion"] : header ?? null;
+      return rpcError(400, rpcId, -32022, `Unsupported protocol version: ${String(requested)}. This server supports only ${MCP_PROTOCOL_VERSION}.`, corsHeaders, { supported: [MCP_PROTOCOL_VERSION], requested });
+    }
+    if (header === MCP_PROTOCOL_VERSION)
+      return { forwardVersion: header };
+    if (header === CLAUDE_MISMATCHED_HEADER && metaVersion(body) === MCP_PROTOCOL_VERSION) {
+      if (++claudeWorkarounds === 1) {
+        logger.info("mcp.claude_header_workaround", {
+          message: "accepting MCP-Protocol-Version 2025-11-25 with a 2026-07-28 body (claude-code #93290); counted in /healthz"
+        });
+      }
+      return { forwardVersion: MCP_PROTOCOL_VERSION };
+    }
+    if (header === null) {
+      return rpcError(400, rpcId, -32020, "Missing MCP-Protocol-Version header.", corsHeaders);
+    }
+    return rpcError(400, rpcId, -32022, `Unsupported protocol version: ${header}. This server supports only ${MCP_PROTOCOL_VERSION}.`, corsHeaders, { supported: [MCP_PROTOCOL_VERSION], requested: header });
+  }
+  async function handleMcp(req, server, addressId) {
+    const started = Date.now();
+    const logDone = (status, method, extra = {}) => logger.info("mcp.request", {
+      address: shortAddress(addressId),
+      method,
+      status,
+      durationMs: Date.now() - started,
+      ...extra
+    });
+    const body = await readBody(req, sessions.get(addressId)?.limits.maxMessageBytes ?? config.maxMessageBytes);
+    if (body instanceof Response) {
+      logDone(body.status, "?");
+      return body;
+    }
+    const rpcId = rpcIdOf(body.value);
+    const method = methodForLog(body.value);
+    const version = checkVersion(req, body.value, rpcId);
+    if (version instanceof Response) {
+      logDone(version.status, method);
+      return version;
+    }
+    const auth = await authenticate(req, addressId);
+    if (auth === "unavailable") {
+      logDone(503, method, { reason: "store_unavailable" });
+      return rpcError(503, rpcId, RelayErrorCode.storeUnavailable, "The relay cannot check tokens right now. Try again shortly.", { ...corsHeaders, "retry-after": "5" });
+    }
+    if (typeof auth === "string") {
+      logDone(401, method);
+      return json(401, {
+        error: "invalid_token",
+        error_description: auth === "missing" ? "Authorization required." : "The access token is not valid."
+      }, {
+        ...corsHeaders,
+        "www-authenticate": wwwAuthenticate(addressId, auth === "invalid")
+      });
+    }
+    const session = sessions.get(addressId);
+    if (session === undefined || !session.ready) {
+      logDone(503, method, { reason: "page_not_open" });
+      return rpcError(503, rpcId, RelayErrorCode.pageNotOpen, 'The page is not open. Open the web page that offers these tools and click "Connect your AI tool".', corsHeaders);
+    }
+    if (session.pending.size >= session.limits.maxConcurrentRequests) {
+      logDone(429, method);
+      return rpcError(429, rpcId, RelayErrorCode.overloaded, "Too many requests at once for this page.", corsHeaders);
+    }
+    const headers = {};
+    for (const [k, v] of req.headers) {
+      const key = k.toLowerCase();
+      if (FORWARDED_HEADERS.has(key) || key.startsWith("mcp-param-"))
+        headers[key] = v;
+    }
+    headers["mcp-protocol-version"] = version.forwardVersion;
+    const clientHostName = (() => {
+      try {
+        return new URL(auth.clientId).host;
+      } catch {
+        return "";
+      }
+    })();
+    if (req.signal.aborted) {
+      logDone(499, method, { outcome: "client_closed" });
+      return new Response(null, { status: 499 });
+    }
+    server.timeout(req, 0);
+    const exchange = session.forward({
+      method: "POST",
+      headers,
+      body: body.text,
+      rpcId,
+      isListen: body.value["method"] === "subscriptions/listen",
+      grant: {
+        grantId: auth.grantId,
+        clientId: auth.clientId,
+        scopes: auth.scopes
+      },
+      extraHeaders: corsHeaders,
+      onDone: (e) => logDone(e.status, method, {
+        session: session.sessionId,
+        client: clientHostName,
+        outcome: e.outcome
+      })
+    });
+    req.signal.addEventListener("abort", () => exchange.clientClosed(), {
+      once: true
+    });
+    return exchange.response;
+  }
+  function preflight(req) {
+    if (!config.cors)
+      return new Response(null, { status: 405, headers: { allow: "POST" } });
+    const requested = req.headers.get("access-control-request-headers") ?? "";
+    return new Response(null, {
+      status: 204,
+      headers: {
+        ...corsHeaders,
+        "access-control-allow-methods": "POST, OPTIONS",
+        "access-control-allow-headers": requested !== "" ? requested : "authorization, content-type, accept, mcp-protocol-version, mcp-method, mcp-name",
+        "access-control-max-age": "600"
+      }
+    });
+  }
+  const methodNotAllowed = () => new Response(null, {
+    status: 405,
+    headers: { ...corsHeaders, allow: "POST" }
+  });
+  const postOnly = () => new Response(null, { status: 405, headers: { allow: "POST, OPTIONS" } });
+  const largest = largestMessageBytes(config);
+  const ipOf = (req, srv) => ipPrefixKey(clientIp(req, srv));
+  const server = Bun.serve({
+    port: config.port,
+    hostname: config.host,
+    development: false,
+    maxRequestBodySize: largest + 1024,
+    idleTimeout: config.httpIdleTimeoutS,
+    routes: {
+      "/healthz": {
+        GET: () => json(200, {
+          status: "ok",
+          version: VERSION,
+          counters: { claudeHeaderWorkaround: claudeWorkarounds }
+        })
+      },
+      "/": {
+        GET: () => new Response(INDEX_HTML, {
+          headers: {
+            "content-type": "text/html; charset=utf-8",
+            "content-security-policy": "default-src 'none'; frame-ancestors 'none'",
+            "x-content-type-options": "nosniff"
+          }
+        })
+      },
+      "/tab": (req, srv) => handleTab(req, srv),
+      "/.well-known/oauth-authorization-server": {
+        GET: () => auth.metadata(),
+        OPTIONS: () => auth.preflight("GET")
+      },
+      "/.well-known/oauth-protected-resource/a/:id/mcp": {
+        GET: (req) => auth.protectedResource(req.params.id),
+        OPTIONS: () => auth.preflight("GET")
+      },
+      "/authorize": {
+        GET: (req, srv) => auth.authorize(req, ipOf(req, srv)),
+        POST: (req, srv) => auth.authorizeSubmit(req, ipOf(req, srv))
+      },
+      "/authorize.css": { GET: () => auth.stylesheet() },
+      "/token": {
+        POST: (req, srv) => auth.token(req, ipOf(req, srv)),
+        OPTIONS: () => auth.preflight("POST"),
+        GET: postOnly
+      },
+      "/revoke": {
+        POST: (req, srv) => auth.revoke(req, ipOf(req, srv)),
+        OPTIONS: () => auth.preflight("POST"),
+        GET: postOnly
+      },
+      "/a/:id/mcp": {
+        POST: (req, srv) => {
+          const id = req.params.id;
+          if (!isAddressId(id))
+            return new Response("Not found", { status: 404 });
+          return handleMcp(req, srv, id);
+        },
+        OPTIONS: (req) => preflight(req),
+        GET: methodNotAllowed,
+        DELETE: methodNotAllowed,
+        PUT: methodNotAllowed,
+        PATCH: methodNotAllowed
+      }
+    },
+    fetch: () => new Response("Not found", { status: 404 }),
+    websocket: {
+      data: {},
+      maxPayloadLength: largest * 4,
+      backpressureLimit: config.backpressureLimitBytes,
+      closeOnBackpressureLimit: false,
+      idleTimeout: 120,
+      sendPings: true,
+      perMessageDeflate: false,
+      open(ws) {
+        const session = new TabSession(ws, ws.data.ip, ws.data.origin, ws.data.site, host);
+        ws.data.session = session;
+        allSessions.add(session);
+      },
+      message(ws, message) {
+        ws.data.session?.handleFrame(typeof message === "string" ? message : new Uint8Array(message));
+      },
+      close(ws, code) {
+        ws.data.session?.closed(code);
+      }
+    }
+  });
+  const port = server.port ?? config.port;
+  if (publicUrl === "")
+    publicUrl = `http://localhost:${port}`;
+  const sweep = setInterval(() => {
+    auth.sweep();
+    store.deleteExpired(Date.now()).then((n) => {
+      if (n > 0)
+        logger.debug("store.swept", { deleted: n });
+    }).catch((error) => logger.error("store.error", {
+      op: "deleteExpired",
+      message: error instanceof Error ? error.message : "unknown"
+    }));
+  }, config.sweepIntervalMs);
+  const siteCount = config.allowedOrigins === "*" ? "*" : config.allowedOrigins.length + config.sites.length;
+  if (config.allowedOrigins === "*") {
+    logger.warn("relay.open_relay", {
+      message: "TAB_MCP_ALLOWED_ORIGINS=* lets any website open tab sessions on this relay"
+    });
+  } else if (siteCount === 0) {
+    logger.warn("relay.no_origins", {
+      message: "TAB_MCP_ALLOWED_ORIGINS and TAB_MCP_SITES are empty: no page can connect"
+    });
+  }
+  logger.info("relay.start", {
+    version: VERSION,
+    url: publicUrl,
+    port,
+    store: ownsStore ? config.store : "custom",
+    origins: siteCount
+  });
+  let stopping;
+  return {
+    url: publicUrl,
+    port,
+    config,
+    addressFor: (secret) => `${publicUrl}/a/${addressIdFromSecret(secret)}/mcp`,
+    get sessionCount() {
+      return allSessions.size;
+    },
+    stop() {
+      stopping ??= (async () => {
+        clearInterval(sweep);
+        for (const session of [...allSessions]) {
+          session.end(CloseCode.shuttingDown, "relay shutting down", "shutdown");
+        }
+        await Bun.sleep(20);
+        await server.stop(true);
+        if (ownsStore)
+          await store.close?.();
+        logger.info("relay.stop", {});
+      })();
+      return stopping;
+    }
+  };
+}
+export {
+  ConfigError,
+  DEFAULT_CONFIG,
+  MemoryTokenStore,
+  SUBPROTOCOL,
+  SqliteTokenStore,
+  VERSION,
+  addressIdFromSecret,
+  configFromEnv,
+  createLogger,
+  createRelay,
+  newSecret,
+  resolveConfig
+};
+
+//# debugId=5AAD754DD6F4F7B264756E2164756E21
+//# sourceMappingURL=index.js.map