@claxedo/workspace-relay 0.1.0 → 0.5.0

package/dist/index.mjs

@@ -38,6 +38,9 @@ function roleClaim(payload) {
   const value = stringClaim(payload, "role");
   return value === "viewer" || value === "editor" || value === "admin" || value === "owner" ? value : void 0;
 }
+function isRelayClaimPair(input) {
+  return input.access === "cloud" && input.backing === "cloud-vm" || input.access === "user-hosted" && input.backing === "local-worktree";
+}
 function checkHostTunnelTarget(payload, expected) {
   if (stringClaim(payload, "host_id") !== expected.hostId) {
     throw new WorkspaceRelayAuthError("relay_token_host_mismatch", "Relay token host does not match request");
@@ -97,6 +100,18 @@ async function verifyRuntimeAccessToken(token, key, expected) {
   }
   return claims;
 }
+function validateRuntimeAccessTokenClaims(input, expected) {
+  const payload = input;
+  if (stringClaim(payload, "iss") !== runtimeAccessTokenIssuer || stringClaim(payload, "aud") !== runtimeAccessTokenAudience) {
+    throw new WorkspaceRelayAuthError("relay_token_claims_invalid", "Runtime Access Token issuer or audience is invalid");
+  }
+  checkTarget(payload, expected);
+  const claims = runtimeClaims(payload);
+  if (!claims) {
+    throw new WorkspaceRelayAuthError("relay_token_claims_invalid", "Runtime Access Token claims are incomplete");
+  }
+  return claims;
+}
 async function mintHostTunnelToken(input, key, alg) {
   const now = seconds(input.now);
   return await new SignJWT({
@@ -117,6 +132,9 @@ async function verifyHostTunnelToken(token, key, expected) {
   return claims;
 }
 async function mintRelayHostToken(input, key, alg) {
+  if (!isRelayClaimPair(input)) {
+    throw new WorkspaceRelayAuthError("relay_token_claims_invalid", "Relay Host Token access/backing claims are inconsistent");
+  }
   const now = seconds(input.now);
   const protectedHeader = { alg: requireAlgorithm(alg) };
   if (input.kid) protectedHeader.kid = input.kid;
@@ -172,14 +190,13 @@ function relayHostClaims(payload) {
   });
   const access = stringClaim(payload, "access");
   const backing = stringClaim(payload, "backing");
-  if (!base || access !== "cloud" && access !== "user-hosted") return;
-  if (backing !== "local-worktree" && backing !== "cloud-vm") return;
+  const pair = { access, backing };
+  if (!base || !isRelayClaimPair(pair)) return;
   return {
     ...base,
     iss: relayHostTokenIssuer,
     aud: relayHostTokenAudience,
-    access,
-    backing
+    ...pair
   };
 }
 function hostTunnelClaims(payload) {
@@ -204,9 +221,9 @@ function hostTunnelClaims(payload) {
 
 // src/bun.ts
 import {
-  isTunnelMessage,
   makeTunnelPong,
-  TUNNEL_PROTOCOL_VERSION
+  TUNNEL_PROTOCOL_VERSION,
+  validateTunnelMessage
 } from "@claxedo/workspace-relay-protocol";
 
 // src/server.ts
@@ -230,6 +247,70 @@ function errorBody(code, message) {
 }
 
 // src/server.ts
+var RELAY_HOST_TOKEN_CACHE_MAX_ENTRIES = 4096;
+var RUNTIME_ACCESS_TOKEN_CACHE_MAX_ENTRIES = 8192;
+var RESOLVER_CACHE_MAX_ENTRIES = 8192;
+var RUNTIME_ACCESS_TOKEN_CACHE_TTL_MS_DEFAULT = 1e4;
+var relayHostTokenCaches = /* @__PURE__ */ new WeakMap();
+var runtimeAccessTokenCaches = /* @__PURE__ */ new WeakMap();
+function pruneExpiringCache(cache, now, maxEntries) {
+  for (const [key, entry] of cache) {
+    if (entry.expiresAt <= now) cache.delete(key);
+  }
+  while (cache.size >= maxEntries) {
+    const key = cache.keys().next().value;
+    if (!key) return;
+    cache.delete(key);
+  }
+}
+function createCachedRevocationClient(inner, options = {}) {
+  const ttlMs = options.ttlMs ?? 1e4;
+  const now = options.now ?? Date.now;
+  const cache = /* @__PURE__ */ new Map();
+  return async (args) => {
+    const at = now();
+    const entry = cache.get(args.jti);
+    if (entry && entry.expiresAt > at) {
+      if (entry.result) return entry.result;
+      if (entry.promise) return await entry.promise;
+    }
+    const promise = inner(args).then((result) => {
+      pruneExpiringCache(cache, now(), RESOLVER_CACHE_MAX_ENTRIES);
+      cache.set(args.jti, { result, expiresAt: now() + ttlMs });
+      return result;
+    }).catch((err) => {
+      cache.delete(args.jti);
+      throw err;
+    });
+    cache.set(args.jti, { promise, expiresAt: at + ttlMs });
+    return await promise;
+  };
+}
+function createCachedTargetClient(inner, options = {}) {
+  const ttlMs = options.ttlMs ?? 5e3;
+  const now = options.now ?? Date.now;
+  const cache = /* @__PURE__ */ new Map();
+  return async (args) => {
+    const key = `${args.workspaceId}\0${args.hostId}`;
+    const at = now();
+    const entry = cache.get(key);
+    if (entry && entry.expiresAt > at) {
+      if (entry.result) return entry.result;
+      if (entry.promise) return await entry.promise;
+    }
+    const promise = inner(args).then((result) => {
+      pruneExpiringCache(cache, now(), RESOLVER_CACHE_MAX_ENTRIES);
+      if (result) cache.set(key, { result, expiresAt: now() + ttlMs });
+      else cache.delete(key);
+      return result;
+    }).catch((err) => {
+      cache.delete(key);
+      throw err;
+    });
+    cache.set(key, { promise, expiresAt: at + ttlMs });
+    return await promise;
+  };
+}
 function protocolToken(header) {
   return header?.split(",").map((item) => item.trim()).find((item) => item.startsWith("claxedo-rat."))?.slice("claxedo-rat.".length);
 }
@@ -242,6 +323,16 @@ var DANGEROUS_INBOUND_HEADERS = [
   "x-forwarded-proto",
   "x-real-ip"
 ];
+var HOP_BY_HOP_HEADERS = [
+  "connection",
+  "keep-alive",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade"
+];
 var DANGEROUS_INBOUND_HEADER_PATTERNS = [
   /^x-claxedo-internal-/i,
   /^x-supervisor-/i
@@ -249,6 +340,7 @@ var DANGEROUS_INBOUND_HEADER_PATTERNS = [
 function isDangerousInboundHeader(name) {
   const lower = name.toLowerCase();
   if (DANGEROUS_INBOUND_HEADERS.includes(lower)) return true;
+  if (HOP_BY_HOP_HEADERS.includes(lower)) return true;
   for (const pattern of DANGEROUS_INBOUND_HEADER_PATTERNS) {
     if (pattern.test(lower)) return true;
   }
@@ -264,9 +356,16 @@ function forwardHeaders(input, relayHostToken, workspaceId, options = {}) {
   }
   if (options.userHosted) headers2.delete("cookie");
   headers2.set("accept-encoding", "identity");
-  headers2.set("authorization", `Bearer ${relayHostToken}`);
+  headers2.delete("authorization");
+  headers2.delete("Authorization");
+  headers2.set("Authorization", `Bearer ${relayHostToken}`);
   headers2.set("x-workspace-id", workspaceId);
   headers2.set("X-Daytona-Skip-Preview-Warning", "true");
+  headers2.set("X-Daytona-Skip-Last-Activity-Update", "true");
+  for (const [name, value] of Object.entries(options.upstreamHeaders ?? {})) {
+    const trimmed = value.trim();
+    if (trimmed) headers2.set(name, trimmed);
+  }
   headers2.set("x-forwarded-by", "workspace-relay");
   return headers2;
 }
@@ -276,8 +375,155 @@ function targetUrl(target, path, search) {
   return url;
 }
 function roleAllowsRelayRequest(role, method) {
-  if (role !== "viewer") return true;
-  return method === "GET" || method === "HEAD" || method === "OPTIONS";
+  if (role === "owner" || role === "admin" || role === "editor") return true;
+  if (role === "viewer") return method === "GET" || method === "HEAD" || method === "OPTIONS";
+  return false;
+}
+function relayHostTokenCacheTtlMs(options, claims) {
+  const configured = options.relayHostTokenCacheTtlMs ?? 3e4;
+  if (!Number.isFinite(configured) || configured <= 0) return 0;
+  const tokenRemaining = claims.exp * 1e3 - Date.now() - 5e3;
+  return Math.max(0, Math.min(configured, tokenRemaining));
+}
+function relayHostTokenCacheKey(options, claims, target) {
+  return [
+    claims.jti,
+    claims.sub,
+    claims.org_id,
+    claims.role,
+    claims.workspace_id,
+    claims.host_id,
+    target.access,
+    target.backing,
+    options.relayHostMintKid ?? ""
+  ].join("\0");
+}
+function relayHostTokenCache(options) {
+  let cache = relayHostTokenCaches.get(options);
+  if (cache) return cache;
+  cache = /* @__PURE__ */ new Map();
+  relayHostTokenCaches.set(options, cache);
+  return cache;
+}
+function runtimeAccessTokenCache(options) {
+  let cache = runtimeAccessTokenCaches.get(options);
+  if (cache) return cache;
+  cache = /* @__PURE__ */ new Map();
+  runtimeAccessTokenCaches.set(options, cache);
+  return cache;
+}
+function runtimeAccessTokenCacheTtlMs(options, claims, now) {
+  const configured = options.runtimeAccessTokenCacheTtlMs ?? RUNTIME_ACCESS_TOKEN_CACHE_TTL_MS_DEFAULT;
+  if (!Number.isFinite(configured) || configured <= 0) return 0;
+  const tokenRemaining = claims.exp * 1e3 - now - 5e3;
+  return Math.max(0, Math.min(configured, tokenRemaining));
+}
+function pruneRuntimeAccessTokenCache(cache, now) {
+  for (const [key, entry] of cache) {
+    if (entry.expiresAt <= now) cache.delete(key);
+  }
+  while (cache.size >= RUNTIME_ACCESS_TOKEN_CACHE_MAX_ENTRIES) {
+    const key = cache.keys().next().value;
+    if (!key) return;
+    cache.delete(key);
+  }
+}
+async function verifyRuntimeAccessTokenForRequest(options, token, workspaceId) {
+  const verified = options.tokenVerifier ? await options.tokenVerifier.verify(token).then(
+    (result) => validateRuntimeAccessTokenClaims(result.claims, { workspaceId })
+  ) : await verifyRuntimeAccessToken(token, options.runtimeAccessKey, { workspaceId });
+  return verified;
+}
+async function cachedRuntimeAccessTokenClaims(options, token, workspaceId) {
+  const configured = options.runtimeAccessTokenCacheTtlMs ?? RUNTIME_ACCESS_TOKEN_CACHE_TTL_MS_DEFAULT;
+  if (!Number.isFinite(configured) || configured <= 0) {
+    return await verifyRuntimeAccessTokenForRequest(options, token, workspaceId);
+  }
+  const now = Date.now();
+  const cache = runtimeAccessTokenCache(options);
+  const key = `${workspaceId}\0${token}`;
+  const cached = cache.get(key);
+  if (cached && cached.expiresAt > now) {
+    if (cached.claims) return cached.claims;
+    if (cached.promise) return await cached.promise;
+  }
+  let promise;
+  try {
+    promise = verifyRuntimeAccessTokenForRequest(options, token, workspaceId);
+    pruneRuntimeAccessTokenCache(cache, now);
+    cache.set(key, { promise, expiresAt: now + configured });
+    const claims = await promise;
+    const ttlMs = runtimeAccessTokenCacheTtlMs(options, claims, now);
+    if (ttlMs > 0) cache.set(key, { claims, expiresAt: now + ttlMs });
+    else cache.delete(key);
+    return claims;
+  } catch (err) {
+    if (promise && cache.get(key)?.promise === promise) cache.delete(key);
+    throw err;
+  }
+}
+function pruneRelayHostTokenCache(cache, now) {
+  for (const [key, entry] of cache) {
+    if (entry.expiresAt <= now) cache.delete(key);
+  }
+  while (cache.size >= RELAY_HOST_TOKEN_CACHE_MAX_ENTRIES) {
+    const key = cache.keys().next().value;
+    if (!key) return;
+    cache.delete(key);
+  }
+}
+async function relayHostTokenFor(options, claims, target, trace) {
+  const ttlMs = relayHostTokenCacheTtlMs(options, claims);
+  if (ttlMs <= 0) {
+    return await uncachedRelayHostTokenFor(options, claims, target, trace);
+  }
+  const key = relayHostTokenCacheKey(options, claims, target);
+  const now = Date.now();
+  const cache = relayHostTokenCache(options);
+  const cached = cache.get(key);
+  if (cached && cached.expiresAt > now) {
+    if (cached.promise) {
+      return await trace.span("rht-cache", async () => await cached.promise);
+    }
+    await trace.span("rht-cache", async () => {
+    });
+    return cached.token;
+  }
+  let promise;
+  try {
+    const token = await trace.span("rht-mint", async () => {
+      promise = mintRelayHostToken({
+        subject: claims.sub,
+        orgId: claims.org_id,
+        role: claims.role,
+        ...target,
+        ...options.relayHostMintKid ? { kid: options.relayHostMintKid } : {}
+      }, options.relayHostSigningKey, options.relayHostAlgorithm);
+      pruneRelayHostTokenCache(cache, now);
+      cache.set(key, { promise, expiresAt: now + ttlMs });
+      return await promise;
+    });
+    cache.set(key, {
+      token,
+      expiresAt: now + ttlMs
+    });
+    return token;
+  } catch (err) {
+    if (promise && cache.get(key)?.promise === promise) cache.delete(key);
+    throw err;
+  }
+}
+async function uncachedRelayHostTokenFor(options, claims, target, trace) {
+  return await trace.span(
+    "rht-mint",
+    async () => await mintRelayHostToken({
+      subject: claims.sub,
+      orgId: claims.org_id,
+      role: claims.role,
+      ...target,
+      ...options.relayHostMintKid ? { kid: options.relayHostMintKid } : {}
+    }, options.relayHostSigningKey, options.relayHostAlgorithm)
+  );
 }
 function workspaceRelayTargetUrl(target, path, search) {
   return targetUrl(target, path, search);
@@ -285,6 +531,18 @@ function workspaceRelayTargetUrl(target, path, search) {
 function workspaceRelayForwardHeaders(input, relayHostToken, workspaceId, options = {}) {
   return forwardHeaders(input, relayHostToken, workspaceId, options);
 }
+function workspaceRelayForwardRequestInit(request, relayHostToken, workspaceId, options = {}) {
+  const init = {
+    method: request.method,
+    headers: forwardHeaders(request.headers, relayHostToken, workspaceId, options),
+    body: request.body,
+    duplex: "half",
+    redirect: "manual",
+    ...options.signal ? { signal: options.signal } : {}
+  };
+  if (request.method === "GET" || request.method === "HEAD") delete init.body;
+  return init;
+}
 var auditSamplers = /* @__PURE__ */ new WeakMap();
 function getOrCreateAuditSampler(options) {
   let state = auditSamplers.get(options);
@@ -342,6 +600,38 @@ function disposeAuditSampler(options) {
   flushSuppressedSummary(options, state);
   auditSamplers.delete(options);
 }
+function createWorkspaceRelayTrace() {
+  const phases = [];
+  return {
+    phases,
+    async span(name, run) {
+      const startedAt = performance.now();
+      try {
+        return await run();
+      } finally {
+        phases.push({ name, ms: performance.now() - startedAt });
+      }
+    }
+  };
+}
+function roundedMs(value) {
+  return Math.round(value * 100) / 100;
+}
+function workspaceRelayServerTiming(trace) {
+  return trace.phases.map((phase) => `${phase.name};dur=${roundedMs(phase.ms)}`).join(", ");
+}
+function workspaceRelayTimingResponse(response, trace) {
+  const value = workspaceRelayServerTiming(trace);
+  if (!value) return response;
+  const headers2 = new Headers(response.headers);
+  const prev = headers2.get("server-timing");
+  headers2.set("server-timing", prev ? `${prev}, ${value}` : value);
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: headers2
+  });
+}
 async function audit(options, event) {
   if (event.action === "relay.request.accepted") {
     const state = getOrCreateAuditSampler(options);
@@ -362,7 +652,7 @@ function denyCorsHeaders(request) {
   if (!allowed) return void 0;
   return {
     "access-control-allow-origin": origin,
-    "access-control-allow-headers": "Accept, Authorization, Content-Type, X-Daytona-Skip-Preview-Warning, X-Workspace-Id",
+    "access-control-allow-headers": "Accept, Authorization, Content-Type, Last-Event-ID, X-Fetch-Bypass-Throttle, X-Daytona-Skip-Preview-Warning, X-Workspace-Id, X-OpenCode-Directory, X-Claxedo-Runner, X-Claxedo-Model, X-Claxedo-Draft-Id, X-Claxedo-Binary",
     "access-control-allow-methods": "GET, HEAD, POST, PUT, PATCH, DELETE, OPTIONS"
   };
 }
@@ -384,11 +674,12 @@ async function deny(options, input) {
     headers: denyCorsHeaders(input.request)
   });
 }
-async function authorizeWorkspaceRelayRequest(options, request, workspaceId) {
+async function authorizeWorkspaceRelayRequest(options, request, workspaceId, trace) {
   const token = runtimeAccessToken(request);
   if (!token) {
     return {
       ok: false,
+      code: "runtime_access_token_required",
       response: await deny(options, {
         code: "runtime_access_token_required",
         message: "Runtime Access Token is required",
@@ -398,14 +689,18 @@ async function authorizeWorkspaceRelayRequest(options, request, workspaceId) {
     };
   }
   try {
-    const claims = options.tokenVerifier ? await (async () => {
-      const verified = await options.tokenVerifier.verify(token);
-      return verified.claims;
-    })() : await verifyRuntimeAccessToken(token, options.runtimeAccessKey, { workspaceId });
-    const active = await options.isRuntimeAccessTokenActive?.(claims) ?? { active: true };
+    const span = (name, run) => trace ? trace.span(name, run) : run();
+    const claims = await span(
+      "rat-verify",
+      async () => await cachedRuntimeAccessTokenClaims(options, token, workspaceId)
+    );
+    const active = await span("rat-active", async () => {
+      return await options.isRuntimeAccessTokenActive?.(claims) ?? { active: true };
+    });
     if (!active.active) {
       return {
         ok: false,
+        code: active.code,
         response: await deny(options, {
           code: active.code,
           message: active.reason,
@@ -418,6 +713,7 @@ async function authorizeWorkspaceRelayRequest(options, request, workspaceId) {
     if (!roleAllowsRelayRequest(claims.role, request.method)) {
       return {
         ok: false,
+        code: "relay_role_denied",
         response: await deny(options, {
           code: "relay_role_denied",
           message: "Workspace role does not allow this relay request",
@@ -427,10 +723,11 @@ async function authorizeWorkspaceRelayRequest(options, request, workspaceId) {
         })
       };
     }
-    const target = await options.resolveTarget(claims);
+    const target = await span("target-resolve", async () => await options.resolveTarget(claims));
     if (!target || target.workspaceId !== claims.workspace_id || target.hostId !== claims.host_id) {
       return {
         ok: false,
+        code: "relay_target_unavailable",
         response: await deny(options, {
           code: "relay_target_unavailable",
           message: "Workspace relay target is unavailable",
@@ -443,6 +740,7 @@ async function authorizeWorkspaceRelayRequest(options, request, workspaceId) {
     if (target.access === "user-hosted" && !options.directory?.activeHost({ hostId: target.hostId, workspaceId: target.workspaceId })) {
       return {
         ok: false,
+        code: "user_hosted_app_offline",
         response: await deny(options, {
           code: "user_hosted_app_offline",
           message: "User-hosted workspace is offline",
@@ -452,7 +750,7 @@ async function authorizeWorkspaceRelayRequest(options, request, workspaceId) {
         })
       };
     }
-    await audit(options, {
+    await span("audit", async () => await audit(options, {
       action: "relay.request.accepted",
       result: "allow",
       subject: claims.sub,
@@ -461,22 +759,14 @@ async function authorizeWorkspaceRelayRequest(options, request, workspaceId) {
       hostId: claims.host_id,
       method: request.method,
       path: new URL(request.url).pathname
-    });
+    }));
+    const relayHostToken = await relayHostTokenFor(options, claims, target, { span });
     return {
       ok: true,
       request: {
         claims,
         target,
-        relayHostToken: await mintRelayHostToken({
-          subject: claims.sub,
-          orgId: claims.org_id,
-          workspaceId: claims.workspace_id,
-          hostId: claims.host_id,
-          role: claims.role,
-          access: target.access,
-          backing: target.backing,
-          ...options.relayHostMintKid ? { kid: options.relayHostMintKid } : {}
-        }, options.relayHostSigningKey, options.relayHostAlgorithm),
+        relayHostToken,
         path: new URL(request.url).pathname.replace(/^\/workspaces\/[^/]+\/?/, "/")
       }
     };
@@ -484,6 +774,7 @@ async function authorizeWorkspaceRelayRequest(options, request, workspaceId) {
     const code = err instanceof WorkspaceRelayAuthError ? err.code : "relay_request_failed";
     return {
       ok: false,
+      code,
       response: await deny(options, {
         code,
         message: "Workspace relay request was denied",
@@ -493,28 +784,45 @@ async function authorizeWorkspaceRelayRequest(options, request, workspaceId) {
     };
   }
 }
-async function forwardRequest(request, target, relayHostToken, path, requestFetch) {
-  const init = {
-    method: request.method,
-    headers: forwardHeaders(request.headers, relayHostToken, target.workspaceId),
-    body: request.body,
-    duplex: "half",
-    redirect: "manual"
-  };
-  if (request.method === "GET" || request.method === "HEAD") delete init.body;
-  const upstream = await requestFetch(targetUrl(target, path, new URL(request.url).search), init);
-  const headers2 = new Headers(upstream.headers);
-  headers2.delete("access-control-allow-origin");
-  headers2.delete("access-control-allow-credentials");
-  headers2.delete("access-control-allow-headers");
-  headers2.delete("access-control-allow-methods");
-  headers2.delete("access-control-expose-headers");
-  headers2.delete("access-control-max-age");
-  return new Response(upstream.body, {
-    status: upstream.status,
-    statusText: upstream.statusText,
-    headers: headers2
-  });
+async function forwardWorkspaceRelayRequest(request, target, relayHostToken, path, requestFetch, timeoutMs, trace) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  const span = (name, run) => trace ? trace.span(name, run) : run();
+  try {
+    const upstream = await span("upstream-fetch", async () => await requestFetch(
+      targetUrl(target, path, new URL(request.url).search),
+      workspaceRelayForwardRequestInit(request, relayHostToken, target.workspaceId, {
+        signal: controller.signal,
+        upstreamHeaders: target.upstreamHeaders
+      })
+    ));
+    const headers2 = new Headers(upstream.headers);
+    headers2.delete("access-control-allow-origin");
+    headers2.delete("access-control-allow-credentials");
+    headers2.delete("access-control-allow-headers");
+    headers2.delete("access-control-allow-methods");
+    headers2.delete("access-control-expose-headers");
+    headers2.delete("access-control-max-age");
+    for (const [key, value] of Object.entries(denyCorsHeaders(request) ?? {})) {
+      headers2.set(key, value);
+    }
+    return new Response(upstream.body, {
+      status: upstream.status,
+      statusText: upstream.statusText,
+      headers: headers2
+    });
+  } catch (err) {
+    const aborted = err instanceof Error && err.name === "AbortError";
+    return Response.json(
+      errorBody(
+        aborted ? "upstream_timeout" : "upstream_unavailable",
+        aborted ? "Workspace upstream timed out" : "Workspace upstream is unavailable"
+      ),
+      { status: aborted ? 504 : 503, headers: denyCorsHeaders(request) }
+    );
+  } finally {
+    clearTimeout(timer);
+  }
 }
 function getAuditSuppressedCount(options) {
   return auditSamplers.get(options)?.suppressedCount ?? 0;
@@ -545,7 +853,14 @@ function checkMetricsAuth(options, request) {
     }
     return { ok: true };
   }
-  if (!options.metricsRemoteAddress) return { ok: true };
+  if (!options.metricsRemoteAddress) {
+    return {
+      ok: false,
+      status: 401,
+      code: "metrics_unauthorized",
+      message: "Metrics endpoint is restricted to loopback or bearer-token clients"
+    };
+  }
   const address = options.metricsRemoteAddress(request);
   if (isLoopbackAddress(address)) return { ok: true };
   return {
@@ -584,6 +899,7 @@ function createWorkspaceRelay(options) {
       if (origin.startsWith("http://localhost:")) return origin;
       if (origin.startsWith("http://127.0.0.1:")) return origin;
       if (/^https:\/\/([a-z0-9-]+\.)*opencode\.ai$/.test(origin)) return origin;
+      if (/^https:\/\/([a-z0-9-]+\.)*claxedo\.com$/.test(origin)) return origin;
       return void 0;
     },
     allowHeaders: [
@@ -591,7 +907,12 @@ function createWorkspaceRelay(options) {
       "Authorization",
       "Content-Type",
       "X-Daytona-Skip-Preview-Warning",
-      "X-Workspace-Id"
+      "X-Workspace-Id",
+      "X-OpenCode-Directory",
+      "X-Claxedo-Runner",
+      "X-Claxedo-Model",
+      "X-Claxedo-Draft-Id",
+      "X-Claxedo-Binary"
     ],
     allowMethods: ["GET", "HEAD", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"]
   }));
@@ -655,21 +976,27 @@ function createWorkspaceRelay(options) {
     return c.json(buildMetricsBody(options));
   });
   app.all("/workspaces/:workspaceId/*", async (c) => {
+    const trace = createWorkspaceRelayTrace();
     if (options.isDraining?.()) {
       return Response.json(
         errorBody("relay_draining", "Workspace relay is shutting down; try another instance"),
         { status: 503, headers: denyCorsHeaders(c.req.raw) }
       );
     }
-    const relay = await authorizeWorkspaceRelayRequest(options, c.req.raw, c.req.param("workspaceId"));
-    if (!relay.ok) return relay.response;
-    return await forwardRequest(
-      new Request(c.req.raw),
-      relay.request.target,
-      relay.request.relayHostToken,
-      relay.request.path,
-      options.fetch ?? fetch
-    );
+    const response = await trace.span("relay-total", async () => {
+      const relay = await authorizeWorkspaceRelayRequest(options, c.req.raw, c.req.param("workspaceId"), trace);
+      if (!relay.ok) return relay.response;
+      return await forwardWorkspaceRelayRequest(
+        new Request(c.req.raw),
+        relay.request.target,
+        relay.request.relayHostToken,
+        relay.request.path,
+        options.fetch ?? fetch,
+        options.forwardTimeoutMs ?? 3e4,
+        trace
+      );
+    });
+    return workspaceRelayTimingResponse(response, trace);
   });
   return app;
 }
@@ -677,38 +1004,79 @@ function createWorkspaceRelay(options) {
 // src/bun.ts
 var TUNNEL_PENDING_HTTP_CAP = 32;
 var TUNNEL_CHANNEL_CAP = 16;
-var HOST_TUNNEL_REGISTRATION_CONCURRENT_CAP = 3;
 var HOST_TUNNEL_REGISTRATION_RECONNECT_CAP = 5;
 var HOST_TUNNEL_REGISTRATION_RECONNECT_WINDOW_MS = 6e4;
 var WS_MAX_PAYLOAD_LENGTH_BYTES = 16 * 1024 * 1024;
+var TUNNEL_REQUEST_BODY_MAX_BYTES_DEFAULT = 16 * 1024 * 1024;
+var TUNNEL_HTTP_RESPONSE_TIMEOUT_MS_DEFAULT = 3e4;
+var DIRECT_HTTP_TIMEOUT_MS_DEFAULT = 3e4;
+var UPSTREAM_WS_OPEN_TIMEOUT_MS_DEFAULT = 1e4;
+var UPSTREAM_WS_PRE_OPEN_QUEUE_MAX_FRAMES_DEFAULT = 64;
+var WS_BUFFERED_AMOUNT_MAX_BYTES_DEFAULT = 8 * 1024 * 1024;
+var HOST_TUNNEL_MAX_MISSED_PONGS_DEFAULT = 2;
 var TUNNEL_MESSAGE_BUFFER_CAP_BYTES = 4 * 1024 * 1024;
 var SLOW_CONSUMER_HIGH_WATER_MARK_BYTES_DEFAULT = 8 * 1024 * 1024;
 var SLOW_CONSUMER_TIMEOUT_MS_DEFAULT = 3e4;
 var HOST_TUNNEL_STATE_DEBOUNCE_MS_DEFAULT = 250;
-var fragmentationStats = {
-  fragmentsBuffered: 0,
-  oversizedClosed: 0
-};
-function getFragmentationStats() {
+function createFragmentationStats() {
   return {
-    fragmentsBuffered: fragmentationStats.fragmentsBuffered,
-    oversizedClosed: fragmentationStats.oversizedClosed
+    fragmentsBuffered: 0,
+    oversizedClosed: 0
   };
 }
-function resetFragmentationStats() {
-  fragmentationStats.fragmentsBuffered = 0;
-  fragmentationStats.oversizedClosed = 0;
+function createSlowConsumerStats() {
+  return {
+    overflowEvents: 0,
+    timerFired: 0,
+    droppedRequests: 0
+  };
 }
-var slowConsumerStats = {
-  overflowEvents: 0,
-  timerFired: 0,
-  droppedRequests: 0
-};
-function getSlowConsumerStats() {
-  return { ...slowConsumerStats };
+function readFragmentationStats(stats) {
+  return {
+    fragmentsBuffered: stats.fragmentsBuffered,
+    oversizedClosed: stats.oversizedClosed
+  };
 }
-function resetSlowConsumerStats() {
-  slowConsumerStats = { overflowEvents: 0, timerFired: 0, droppedRequests: 0 };
+function resetFragmentationStats(stats) {
+  stats.fragmentsBuffered = 0;
+  stats.oversizedClosed = 0;
+}
+function readSlowConsumerStats(stats) {
+  return { ...stats };
+}
+function resetSlowConsumerStats(stats) {
+  stats.overflowEvents = 0;
+  stats.timerFired = 0;
+  stats.droppedRequests = 0;
+}
+function createDirectHttpLimiter(limit) {
+  if (!Number.isInteger(limit) || !limit || limit <= 0) return void 0;
+  const max = limit;
+  let active = 0;
+  const queue = [];
+  function drain() {
+    if (active >= max) return;
+    const next = queue.shift();
+    if (!next) return;
+    active++;
+    next();
+  }
+  return {
+    async acquire() {
+      if (active < max) {
+        active++;
+      } else {
+        await new Promise((resolve) => queue.push(resolve));
+      }
+      let released = false;
+      return () => {
+        if (released) return;
+        released = true;
+        active = Math.max(0, active - 1);
+        drain();
+      };
+    }
+  };
 }
 function jsonError(code, message, status) {
   return new Response(JSON.stringify({ error: { code, message } }), {
@@ -716,6 +1084,35 @@ function jsonError(code, message, status) {
     headers: { "content-type": "application/json" }
   });
 }
+function corsJsonError(request, code, message, status) {
+  const headers2 = relayCorsHeaders(request);
+  headers2.set("content-type", "application/json");
+  return new Response(JSON.stringify({ error: { code, message } }), { status, headers: headers2 });
+}
+function safeCloseCode(input, fallback = 1011) {
+  if (!Number.isInteger(input)) return fallback;
+  const code = input;
+  if (code === 1e3) return code;
+  if (code >= 1001 && code <= 1014 && code !== 1004 && code !== 1005 && code !== 1006) return code;
+  if (code >= 3e3 && code <= 4999) return code;
+  return fallback;
+}
+function closeWebSocket(ws, code, reason, fallback = 1011) {
+  try {
+    ws.close(safeCloseCode(code, fallback), reason);
+  } catch {
+    try {
+      ws.close(fallback, reason);
+    } catch {
+    }
+  }
+}
+function upstreamCloseReason(event) {
+  if (event.reason.trim()) return event.reason;
+  if (event.code === 1e3) return "";
+  if (event.code === 1005 || event.code === 1006) return "Upstream WebSocket closed abnormally";
+  return `Upstream WebSocket closed unexpectedly with code ${event.code}`;
+}
 function workspaceIdFromPath(pathname) {
   return /^\/workspaces\/([^/]+)(?:\/|$)/.exec(pathname)?.[1];
 }
@@ -725,6 +1122,23 @@ function hostIdFromTunnelPath(pathname) {
 function websocketRequest(request) {
   return request.headers.get("upgrade")?.toLowerCase() === "websocket";
 }
+function roundedMs2(input) {
+  return Math.round(input * 100) / 100;
+}
+function relayWebSocketTraceEnabled(request) {
+  return request.headers.get("x-claxedo-relay-ws-trace") === "1";
+}
+function sendRelayWebSocketTrace(ws) {
+  const trace = ws.data.trace;
+  if (!trace || trace.emitted) return;
+  trace.emitted = true;
+  ws.send(JSON.stringify({
+    type: "relay.trace",
+    wsUpstreamOpenMs: trace.upstreamOpenMs === void 0 ? void 0 : roundedMs2(trace.upstreamOpenMs),
+    queuedFrames: trace.queuedFrames,
+    maxQueuedDelayMs: roundedMs2(trace.maxQueuedDelayMs)
+  }));
+}
 function relayWebSocketPayload(input) {
   if (typeof input === "string") return input;
   if (input instanceof ArrayBuffer) return input;
@@ -748,6 +1162,11 @@ function headers(input) {
   }
   return result;
 }
+function isEventStream(input) {
+  return Object.entries(input).some(
+    ([key, value]) => key.toLowerCase() === "content-type" && value.toLowerCase().includes("text/event-stream")
+  );
+}
 function allowedCorsOrigin(origin) {
   if (!origin) return;
   if (origin.startsWith("http://localhost:")) return origin;
@@ -774,7 +1193,7 @@ function relayCorsHeaders(request, input = new Headers()) {
   const origin = allowedCorsOrigin(request.headers.get("origin"));
   if (origin) {
     result.set("access-control-allow-origin", origin);
-    result.set("access-control-allow-headers", "Accept, Authorization, Content-Type, X-Daytona-Skip-Preview-Warning, X-Workspace-Id");
+    result.set("access-control-allow-headers", "Accept, Authorization, Content-Type, Last-Event-ID, X-Fetch-Bypass-Throttle, X-Daytona-Skip-Preview-Warning, X-Workspace-Id, X-OpenCode-Directory, X-Claxedo-Runner, X-Claxedo-Model, X-Claxedo-Draft-Id, X-Claxedo-Binary");
     result.set("access-control-allow-methods", "GET, HEAD, POST, PUT, PATCH, DELETE, OPTIONS");
   }
   return result;
@@ -801,7 +1220,7 @@ function decodedFrame(frame) {
   const body = Buffer.from(frame.data_base64, "base64");
   return frame.binary ? new Uint8Array(body) : body.toString("utf8");
 }
-function tunnelMessage(ws, input) {
+function tunnelMessage(ws, input, stats) {
   if (typeof input !== "string") return;
   const combined = ws.data.messageBuffer.length > 0 ? ws.data.messageBuffer + input : input;
   let parsed;
@@ -809,20 +1228,26 @@ function tunnelMessage(ws, input) {
     parsed = JSON.parse(combined);
   } catch {
     if (combined.length > TUNNEL_MESSAGE_BUFFER_CAP_BYTES) {
-      fragmentationStats.oversizedClosed += 1;
+      stats.oversizedClosed += 1;
       ws.data.messageBuffer = "";
       ws.close(1009, "Tunnel message buffer exceeded 4 MB");
       return;
     }
-    fragmentationStats.fragmentsBuffered += 1;
+    stats.fragmentsBuffered += 1;
     ws.data.messageBuffer = combined;
     return;
   }
   ws.data.messageBuffer = "";
-  return isTunnelMessage(parsed) ? parsed : void 0;
+  const validated = validateTunnelMessage(parsed);
+  if (validated.ok) return validated.message;
+  if (validated.reason === "protocol_mismatch") {
+    ws.close(1002, `Tunnel protocol mismatch: expected ${validated.expected_protocol}`);
+  }
+  return;
 }
 function sendTunnelPing(ws) {
   if (ws.readyState !== WebSocket.OPEN) return;
+  ws.data.missedPongs += 1;
   ws.send(JSON.stringify({
     type: "ping",
     protocol: TUNNEL_PROTOCOL_VERSION,
@@ -830,6 +1255,59 @@ function sendTunnelPing(ws) {
     sent_at: Date.now()
   }));
 }
+function clearPendingTimers(entry) {
+  clearTimeout(entry.timeout);
+  if (entry.slowConsumerTimeout) {
+    clearTimeout(entry.slowConsumerTimeout);
+    entry.slowConsumerTimeout = void 0;
+  }
+}
+function failPendingHttpResponse(input) {
+  clearPendingTimers(input.entry);
+  input.entry.pendingChunks.length = 0;
+  input.entry.bytesQueued = 0;
+  try {
+    input.entry.controller.error(input.error);
+  } catch {
+  }
+  if (!input.entry.responseStarted) {
+    if (input.response) {
+      input.entry.resolve(input.response);
+      return;
+    }
+    input.entry.reject(input.error);
+  }
+}
+function cleanupHostTunnelSocket(input) {
+  if (input.ws.data.heartbeat) {
+    clearInterval(input.ws.data.heartbeat);
+    input.ws.data.heartbeat = void 0;
+  }
+  for (const pending of input.ws.data.pending.values()) {
+    failPendingHttpResponse({
+      entry: pending,
+      response: input.request ? corsJsonError(input.request, "user_hosted_app_offline", "User-hosted workspace is offline", 503) : jsonError("user_hosted_app_offline", "User-hosted workspace is offline", 503),
+      error: new Error("User-hosted tunnel disconnected")
+    });
+  }
+  input.ws.data.pending.clear();
+  for (const channel of input.ws.data.channels.values()) {
+    if (input.closeChannels) closeWebSocket(channel, 1011, "User-hosted tunnel disconnected");
+  }
+  input.ws.data.channels.clear();
+  if (!input.disconnectDirectory) return;
+  if (input.hostTunnels.get(input.ws.data.hostId) === input.ws) {
+    input.hostTunnels.delete(input.ws.data.hostId);
+    input.options.directory?.disconnectHost(input.ws.data.hostId);
+    scheduleHostTunnelStateChange(input.hostTunnelStateDebounce, input.options, {
+      hostId: input.ws.data.hostId,
+      workspaceId: input.ws.data.workspaceIds[0],
+      path: `/host-tunnels/${input.ws.data.hostId}`,
+      state: "disconnected",
+      debounceMs: input.bunOptions.hostTunnelStateDebounceMs ?? HOST_TUNNEL_STATE_DEBOUNCE_MS_DEFAULT
+    });
+  }
+}
 async function audit2(options, input) {
   await options.audit?.({
     action: input.action,
@@ -840,9 +1318,8 @@ async function audit2(options, input) {
     path: input.path
   });
 }
-var hostTunnelStateDebounce = /* @__PURE__ */ new Map();
-function scheduleHostTunnelStateChange(options, input) {
-  const existing = hostTunnelStateDebounce.get(input.hostId);
+function scheduleHostTunnelStateChange(state, options, input) {
+  const existing = state.get(input.hostId);
   const entry = existing ?? {
     intendedState: "disconnected",
     lastWritten: "disconnected",
@@ -856,7 +1333,7 @@ function scheduleHostTunnelStateChange(options, input) {
     entry.flushTimer = void 0;
     if (entry.intendedState === entry.lastWritten) {
       if (entry.intendedState === "disconnected") {
-        hostTunnelStateDebounce.delete(input.hostId);
+        state.delete(input.hostId);
       }
       return;
     }
@@ -868,13 +1345,7 @@ function scheduleHostTunnelStateChange(options, input) {
       path: entry.pending.path
     });
   }, input.debounceMs);
-  hostTunnelStateDebounce.set(input.hostId, entry);
-}
-function __resetHostTunnelStateDebounce() {
-  for (const entry of hostTunnelStateDebounce.values()) {
-    if (entry.flushTimer) clearTimeout(entry.flushTimer);
-  }
-  hostTunnelStateDebounce.clear();
+  state.set(input.hostId, entry);
 }
 function drainPendingChunks(entry) {
   while (entry.pendingChunks.length > 0) {
@@ -903,9 +1374,9 @@ function enqueueChunkWithBackpressure(input) {
     entry.pendingChunks.push(chunk);
     entry.bytesQueued += chunk.byteLength;
     if (!entry.slowConsumerTimeout) {
-      slowConsumerStats.overflowEvents += 1;
+      input.slowConsumerStats.overflowEvents += 1;
       entry.slowConsumerTimeout = setTimeout(() => {
-        slowConsumerStats.timerFired += 1;
+        input.slowConsumerStats.timerFired += 1;
         const error = new Error("slow_consumer_timeout: downstream consumer did not drain in time");
         try {
           entry.controller.error(error);
@@ -918,7 +1389,7 @@ function enqueueChunkWithBackpressure(input) {
           entry.resolve(jsonError("slow_consumer_timeout", "Downstream consumer did not drain in time", 503));
         }
         input.ws.data.pending.delete(input.requestId);
-        slowConsumerStats.droppedRequests += 1;
+        input.slowConsumerStats.droppedRequests += 1;
       }, input.slowConsumerTimeoutMs);
     }
     return;
@@ -929,7 +1400,8 @@ function enqueueChunkWithBackpressure(input) {
   }
 }
 var __slowConsumerInternalsForTest = {
-  enqueueChunkWithBackpressure
+  enqueueChunkWithBackpressure,
+  createSlowConsumerStats
 };
 async function tunnelHttpRequest(input) {
   if (input.ws.readyState !== WebSocket.OPEN) {
@@ -952,13 +1424,47 @@ async function tunnelHttpRequest(input) {
       const entry = input.ws.data.pending.get(requestId);
       if (!entry) return;
       drainPendingChunks(entry);
+    },
+    cancel() {
+      const entry = input.ws.data.pending.get(requestId);
+      if (!entry) return;
+      input.ws.data.pending.delete(requestId);
+      clearPendingTimers(entry);
+      entry.pendingChunks.length = 0;
+      entry.bytesQueued = 0;
+      if (input.ws.readyState === WebSocket.OPEN) {
+        input.ws.send(JSON.stringify({
+          type: "http.response.flow",
+          protocol: TUNNEL_PROTOCOL_VERSION,
+          request_id: requestId,
+          paused: false,
+          reason: "closed"
+        }));
+      }
     }
   }, new ByteLengthQueuingStrategy({ highWaterMark: input.slowConsumerHighWaterMarkBytes }));
   const pending = new Promise((resolve, reject) => {
     const timeout = setTimeout(() => {
+      const entry = input.ws.data.pending.get(requestId);
+      if (!entry) return;
       input.ws.data.pending.delete(requestId);
-      reject(new Error("User-hosted tunnel response timed out"));
-    }, 3e4);
+      if (entry.responseStarted) {
+        clearPendingTimers(entry);
+        entry.pendingChunks.length = 0;
+        entry.bytesQueued = 0;
+        try {
+          entry.controller.close();
+        } catch {
+        }
+        return;
+      }
+      const error = new Error("User-hosted tunnel response timed out");
+      failPendingHttpResponse({
+        entry,
+        response: corsJsonError(input.request, "user_hosted_tunnel_timeout", "User-hosted tunnel response timed out", 504),
+        error
+      });
+    }, input.responseTimeoutMs);
     input.ws.data.pending.set(requestId, {
       controller,
       stream,
@@ -970,7 +1476,13 @@ async function tunnelHttpRequest(input) {
       responseStarted: false
     });
   });
-  const body = input.request.method === "GET" || input.request.method === "HEAD" ? void 0 : encoded(await input.request.arrayBuffer());
+  const body = input.request.method === "GET" || input.request.method === "HEAD" ? void 0 : await readBoundedBody(input.request, input.requestBodyMaxBytes);
+  if (body && "response" in body) {
+    const entry = input.ws.data.pending.get(requestId);
+    if (entry) clearPendingTimers(entry);
+    input.ws.data.pending.delete(requestId);
+    return body.response;
+  }
   input.ws.send(JSON.stringify({
     type: "http.request",
     protocol: TUNNEL_PROTOCOL_VERSION,
@@ -986,33 +1498,81 @@ async function tunnelHttpRequest(input) {
       // cookies to the host process running on the user's laptop.
       { userHosted: true }
     )),
-    ...body ? { body_base64: body } : {},
+    ...body?.bodyBase64 ? { body_base64: body.bodyBase64 } : {},
     end: true
   }));
   return await pending;
 }
+async function readBoundedBody(request, maxBytes) {
+  if (!request.body) return void 0;
+  const reader = request.body.getReader();
+  const chunks = [];
+  let total = 0;
+  for (; ; ) {
+    const next = await reader.read();
+    if (next.done) break;
+    total += next.value.byteLength;
+    if (total > maxBytes) {
+      try {
+        await reader.cancel();
+      } catch {
+      }
+      return {
+        response: corsJsonError(request, "request_body_too_large", "Tunnel request body exceeds the relay limit", 413)
+      };
+    }
+    chunks.push(next.value);
+  }
+  const body = new Uint8Array(total);
+  chunks.reduce((offset, chunk) => {
+    body.set(chunk, offset);
+    return offset + chunk.byteLength;
+  }, 0);
+  return { bodyBase64: encoded(body.buffer) };
+}
 async function directHttpRequest(input) {
-  const init = {
-    method: input.request.method,
-    headers: workspaceRelayForwardHeaders(
-      input.request.headers,
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), input.timeoutMs);
+  const span = (name, run) => input.trace ? input.trace.span(name, run) : run();
+  try {
+    const init = workspaceRelayForwardRequestInit(
+      input.request,
       input.relayHostToken,
       input.workspaceId,
-      // T26: cloud-vm direct path. Cookies pass through (default) — workspace
-      // dashboards in the VM may legitimately need session cookies.
-      { userHosted: false }
-    ),
-    body: input.request.body,
-    duplex: "half",
-    redirect: "manual"
-  };
-  if (input.request.method === "GET" || input.request.method === "HEAD") delete init.body;
-  const upstream = await fetch(input.targetUrl, init);
-  return new Response(upstream.body, {
-    status: upstream.status,
-    statusText: upstream.statusText,
-    headers: relayCorsHeaders(input.request, upstream.headers)
-  });
+      {
+        // T26: cloud-vm direct path. Cookies pass through (default) — workspace
+        // dashboards in the VM may legitimately need session cookies.
+        userHosted: false,
+        upstreamHeaders: input.upstreamHeaders,
+        signal: controller.signal
+      }
+    );
+    if (input.request.method !== "GET" && input.request.method !== "HEAD" && input.request.body) {
+      init.body = await input.request.arrayBuffer();
+    }
+    const limiter = input.limiter;
+    const release = limiter ? await span("direct-http-queue", () => limiter.acquire()) : void 0;
+    try {
+      const upstream = await span("upstream-fetch", async () => await fetch(input.targetUrl, init));
+      return new Response(upstream.body, {
+        status: upstream.status,
+        statusText: upstream.statusText,
+        headers: relayCorsHeaders(input.request, upstream.headers)
+      });
+    } finally {
+      release?.();
+    }
+  } catch (err) {
+    const aborted = err instanceof Error && err.name === "AbortError";
+    return corsJsonError(
+      input.request,
+      aborted ? "upstream_timeout" : "upstream_unavailable",
+      aborted ? "Workspace upstream timed out" : "Workspace upstream is unavailable",
+      aborted ? 504 : 503
+    );
+  } finally {
+    clearTimeout(timer);
+  }
 }
 function hostTunnel(hostTunnels, hostId) {
   const tunnel = hostTunnels.get(hostId);
@@ -1033,12 +1593,30 @@ async function authorizeHostTunnel(options, bunOptions, request, input) {
 }
 function createWorkspaceRelayBun(options, bunOptions = {}) {
   const hostTunnels = /* @__PURE__ */ new Map();
+  const relayClients = /* @__PURE__ */ new Set();
   const hostTunnelRegistrations = /* @__PURE__ */ new Map();
+  const directHttpLimiter = createDirectHttpLimiter(bunOptions.directHttpConcurrency);
+  const hostTunnelStateDebounce = /* @__PURE__ */ new Map();
+  const fragmentationStats = createFragmentationStats();
+  const slowConsumerStats = createSlowConsumerStats();
+  const telemetry = {
+    getFragmentationStats: () => readFragmentationStats(fragmentationStats),
+    resetFragmentationStats: () => resetFragmentationStats(fragmentationStats),
+    getSlowConsumerStats: () => readSlowConsumerStats(slowConsumerStats),
+    resetSlowConsumerStats: () => resetSlowConsumerStats(slowConsumerStats)
+  };
   let draining = false;
   const drainController = {
     isDraining: () => draining,
     setDraining: (value) => {
       draining = value;
+      if (!value) return;
+      for (const tunnel of hostTunnels.values()) {
+        closeWebSocket(tunnel, 1012, "Workspace relay is draining", 1012);
+      }
+      for (const client of relayClients) {
+        closeWebSocket(client, 1012, "Workspace relay is draining", 1012);
+      }
     },
     pendingCount: () => {
       let total = 0;
@@ -1061,8 +1639,8 @@ function createWorkspaceRelayBun(options, bunOptions = {}) {
     }
   };
   const mergedMetricsSources = {
-    fragmentation: options.metricsSources?.fragmentation ?? getFragmentationStats,
-    slowConsumer: options.metricsSources?.slowConsumer ?? getSlowConsumerStats,
+    fragmentation: options.metricsSources?.fragmentation ?? telemetry.getFragmentationStats,
+    slowConsumer: options.metricsSources?.slowConsumer ?? telemetry.getSlowConsumerStats,
     drainPending: options.metricsSources?.drainPending ?? drainController.pendingCount
   };
   const requestRemoteAddress = /* @__PURE__ */ new WeakMap();
@@ -1076,7 +1654,7 @@ function createWorkspaceRelayBun(options, bunOptions = {}) {
   function getRegistrationTracker(hostId) {
     let tracker = hostTunnelRegistrations.get(hostId);
     if (!tracker) {
-      tracker = { current: 0, recent: [] };
+      tracker = { recent: [] };
       hostTunnelRegistrations.set(hostId, tracker);
     }
     return tracker;
@@ -1097,6 +1675,12 @@ function createWorkspaceRelayBun(options, bunOptions = {}) {
         if (ip) requestRemoteAddress.set(request, ip);
       } catch {
       }
+      if (url.pathname === "/health") {
+        return Response.json(
+          draining ? { ok: false, service: "workspace-relay", draining: true } : { ok: true, service: "workspace-relay" },
+          { status: draining ? 503 : 200 }
+        );
+      }
       if (draining && websocketRequest(request) && hostId) {
         return jsonError(
           "relay_draining",
@@ -1126,13 +1710,6 @@ function createWorkspaceRelayBun(options, bunOptions = {}) {
         const tracker = getRegistrationTracker(hostId);
         const now = Date.now();
         pruneReconnects(tracker, now);
-        if (tracker.current >= HOST_TUNNEL_REGISTRATION_CONCURRENT_CAP) {
-          return jsonError(
-            "too_many_concurrent_host_tunnels",
-            "Too many concurrent host-tunnel registrations for this host",
-            429
-          );
-        }
         if (tracker.recent.length >= HOST_TUNNEL_REGISTRATION_RECONNECT_CAP) {
           return jsonError(
             "too_many_host_tunnel_reconnects",
@@ -1147,10 +1724,10 @@ function createWorkspaceRelayBun(options, bunOptions = {}) {
             workspaceIds,
             pending: /* @__PURE__ */ new Map(),
             channels: /* @__PURE__ */ new Map(),
+            missedPongs: 0,
             messageBuffer: ""
           }
         })) {
-          tracker.current += 1;
           tracker.recent.push(now);
           return;
         }
@@ -1163,32 +1740,45 @@ function createWorkspaceRelayBun(options, bunOptions = {}) {
           headers: relayCorsHeaders(request)
         });
       }
-      const relay = await authorizeWorkspaceRelayRequest(options, request, workspaceId);
-      if (!relay.ok) return relay.response;
-      if (!websocketRequest(request) && relay.request.target.access === "user-hosted") {
-        const tunnel = hostTunnel(hostTunnels, relay.request.target.hostId);
-        return tunnel ? await tunnelHttpRequest({
-          ws: tunnel,
-          request,
-          workspaceId: relay.request.target.workspaceId,
-          path: `${relay.request.path}${url.search}`,
-          relayHostToken: relay.request.relayHostToken,
-          slowConsumerHighWaterMarkBytes: bunOptions.slowConsumerHighWaterMarkBytes ?? SLOW_CONSUMER_HIGH_WATER_MARK_BYTES_DEFAULT,
-          slowConsumerTimeoutMs: bunOptions.slowConsumerTimeoutMs ?? SLOW_CONSUMER_TIMEOUT_MS_DEFAULT
-        }) : new Response("User-hosted workspace is offline", { status: 503 });
-      }
       if (!websocketRequest(request)) {
-        return await directHttpRequest({
-          request,
-          targetUrl: workspaceRelayTargetUrl(
-            relay.request.target,
-            relay.request.path,
-            url.search
-          ).toString(),
-          relayHostToken: relay.request.relayHostToken,
-          workspaceId: relay.request.target.workspaceId
+        const trace = createWorkspaceRelayTrace();
+        const response = await trace.span("relay-total", async () => {
+          const relay2 = await authorizeWorkspaceRelayRequest(options, request, workspaceId, trace);
+          if (!relay2.ok) return relay2.response;
+          if (relay2.request.target.access === "user-hosted") {
+            const tunnel = hostTunnel(hostTunnels, relay2.request.target.hostId);
+            return tunnel ? await trace.span("tunnel-http", async () => await tunnelHttpRequest({
+              ws: tunnel,
+              request,
+              workspaceId: relay2.request.target.workspaceId,
+              path: `${relay2.request.path}${url.search}`,
+              relayHostToken: relay2.request.relayHostToken,
+              slowConsumerHighWaterMarkBytes: bunOptions.slowConsumerHighWaterMarkBytes ?? SLOW_CONSUMER_HIGH_WATER_MARK_BYTES_DEFAULT,
+              slowConsumerTimeoutMs: bunOptions.slowConsumerTimeoutMs ?? SLOW_CONSUMER_TIMEOUT_MS_DEFAULT,
+              slowConsumerStats,
+              requestBodyMaxBytes: bunOptions.tunnelRequestBodyMaxBytes ?? TUNNEL_REQUEST_BODY_MAX_BYTES_DEFAULT,
+              responseTimeoutMs: bunOptions.tunnelHttpResponseTimeoutMs ?? TUNNEL_HTTP_RESPONSE_TIMEOUT_MS_DEFAULT
+            })) : new Response("User-hosted workspace is offline", { status: 503 });
+          }
+          return await directHttpRequest({
+            request,
+            targetUrl: workspaceRelayTargetUrl(
+              relay2.request.target,
+              relay2.request.path,
+              url.search
+            ).toString(),
+            relayHostToken: relay2.request.relayHostToken,
+            workspaceId: relay2.request.target.workspaceId,
+            upstreamHeaders: relay2.request.target.upstreamHeaders,
+            timeoutMs: bunOptions.directHttpTimeoutMs ?? DIRECT_HTTP_TIMEOUT_MS_DEFAULT,
+            limiter: directHttpLimiter,
+            trace
+          });
         });
+        return workspaceRelayTimingResponse(response, trace);
       }
+      const relay = await authorizeWorkspaceRelayRequest(options, request, workspaceId);
+      if (!relay.ok) return relay.response;
       const originDenied = requireAllowedOrigin(request);
       if (originDenied) return originDenied;
       if (relay.request.target.access === "user-hosted") {
@@ -1230,9 +1820,17 @@ function createWorkspaceRelayBun(options, bunOptions = {}) {
             relay.request.relayHostToken,
             relay.request.target.workspaceId,
             // T26: cloud-vm WS upgrade. Cookies pass through (default).
-            { userHosted: false }
+            { userHosted: false, upstreamHeaders: relay.request.target.upstreamHeaders }
           )),
-          queue: []
+          queue: [],
+          ...relayWebSocketTraceEnabled(request) ? {
+            trace: {
+              acceptedAt: performance.now(),
+              queuedFrames: 0,
+              maxQueuedDelayMs: 0,
+              emitted: false
+            }
+          } : {}
         }
       })) {
         return;
@@ -1245,22 +1843,39 @@ function createWorkspaceRelayBun(options, bunOptions = {}) {
         if (ws.data.kind === "host-tunnel") {
           const parsed = tunnelMessage(
             ws,
-            message
+            message,
+            fragmentationStats
           );
           if (parsed?.type === "ping") {
             options.directory?.recordPong(ws.data.hostId);
             ws.send(JSON.stringify(makeTunnelPong(parsed)));
           }
           if (parsed?.type === "pong") {
+            ws.data.missedPongs = 0;
             options.directory?.recordPong(ws.data.hostId);
           }
+          if (parsed?.type === "error") {
+            if (parsed.request_id) {
+              const pending = ws.data.pending.get(parsed.request_id);
+              if (pending) {
+                ws.data.pending.delete(parsed.request_id);
+                failPendingHttpResponse({
+                  entry: pending,
+                  response: jsonError(parsed.code, parsed.message, 502),
+                  error: new Error(parsed.message)
+                });
+              }
+            }
+          }
           if (parsed?.type === "http.response.start") {
             const pending = ws.data.pending.get(parsed.request_id);
             if (pending) {
+              const response = parsed;
               pending.responseStarted = true;
+              if (isEventStream(response.headers)) clearTimeout(pending.timeout);
               pending.resolve(new Response(pending.stream, {
-                status: parsed.status,
-                headers: headers(parsed.headers)
+                status: response.status,
+                headers: headers(response.headers)
               }));
             }
           }
@@ -1272,7 +1887,8 @@ function createWorkspaceRelayBun(options, bunOptions = {}) {
                 requestId: parsed.request_id,
                 entry,
                 chunk: decoded(parsed.body_base64),
-                slowConsumerTimeoutMs: bunOptions.slowConsumerTimeoutMs ?? SLOW_CONSUMER_TIMEOUT_MS_DEFAULT
+                slowConsumerTimeoutMs: bunOptions.slowConsumerTimeoutMs ?? SLOW_CONSUMER_TIMEOUT_MS_DEFAULT,
+                slowConsumerStats
               });
             }
           }
@@ -1305,14 +1921,24 @@ function createWorkspaceRelayBun(options, bunOptions = {}) {
           }
           if (parsed?.type === "ws.frame") {
             const frame = parsed;
-            ws.data.channels.get(frame.channel_id)?.send(decodedFrame(frame));
+            const channel = ws.data.channels.get(frame.channel_id);
+            if (!channel || channel.readyState !== WebSocket.OPEN) {
+              ws.data.channels.delete(frame.channel_id);
+              return;
+            }
+            if (channel.bufferedAmount > (bunOptions.webSocketBufferedAmountMaxBytes ?? WS_BUFFERED_AMOUNT_MAX_BYTES_DEFAULT)) {
+              ws.data.channels.delete(frame.channel_id);
+              closeWebSocket(channel, 1011, "Client WebSocket backpressure limit exceeded");
+              return;
+            }
+            channel.send(decodedFrame(frame));
           }
           if (parsed?.type === "ws.close") {
             const close = parsed;
             const channel = ws.data.channels.get(close.channel_id);
             if (channel) {
               ws.data.channels.delete(close.channel_id);
-              channel.close(close.code, close.reason);
+              closeWebSocket(channel, close.code, close.reason);
             }
           }
           return;
@@ -1323,6 +1949,10 @@ function createWorkspaceRelayBun(options, bunOptions = {}) {
             ws.close(1011, "User-hosted tunnel disconnected");
             return;
           }
+          if (tunnel.bufferedAmount > (bunOptions.webSocketBufferedAmountMaxBytes ?? WS_BUFFERED_AMOUNT_MAX_BYTES_DEFAULT)) {
+            closeWebSocket(ws, 1011, "Host tunnel backpressure limit exceeded");
+            return;
+          }
           tunnel.send(JSON.stringify({
             type: "ws.frame",
             protocol: TUNNEL_PROTOCOL_VERSION,
@@ -1335,19 +1965,41 @@ function createWorkspaceRelayBun(options, bunOptions = {}) {
           ws.data.upstream.send(message);
           return;
         }
-        ws.data.queue.push(message);
+        if (ws.data.queue.length >= (bunOptions.upstreamWebSocketPreOpenQueueMaxFrames ?? UPSTREAM_WS_PRE_OPEN_QUEUE_MAX_FRAMES_DEFAULT)) {
+          closeWebSocket(ws, 1011, "Upstream WebSocket queue limit exceeded");
+          return;
+        }
+        ws.data.queue.push({ payload: message, queuedAt: performance.now() });
       },
       open(ws) {
         if (ws.data.kind === "host-tunnel") {
+          const previous = hostTunnels.get(ws.data.hostId);
+          if (previous && previous !== ws) {
+            cleanupHostTunnelSocket({
+              ws: previous,
+              hostTunnels,
+              hostTunnelStateDebounce,
+              options,
+              bunOptions,
+              disconnectDirectory: false,
+              closeChannels: true
+            });
+            closeWebSocket(previous, 1012, "Host tunnel replaced by a newer connection", 1012);
+          }
           hostTunnels.set(ws.data.hostId, ws);
           options.directory?.registerHostTunnel({
             hostId: ws.data.hostId,
             workspaceIds: ws.data.workspaceIds
           });
           ws.data.heartbeat = setInterval(() => {
-            sendTunnelPing(ws);
+            const hostWs = ws;
+            if (hostWs.data.missedPongs > (bunOptions.hostTunnelMaxMissedPongs ?? HOST_TUNNEL_MAX_MISSED_PONGS_DEFAULT)) {
+              closeWebSocket(ws, 1001, "Host tunnel heartbeat timed out", 1001);
+              return;
+            }
+            sendTunnelPing(hostWs);
           }, bunOptions.hostTunnelPingIntervalMs ?? 15e3);
-          scheduleHostTunnelStateChange(options, {
+          scheduleHostTunnelStateChange(hostTunnelStateDebounce, options, {
             hostId: ws.data.hostId,
             workspaceId: ws.data.workspaceIds[0],
             path: `/host-tunnels/${ws.data.hostId}`,
@@ -1363,6 +2015,10 @@ function createWorkspaceRelayBun(options, bunOptions = {}) {
             return;
           }
           tunnel.data.channels.set(ws.data.channelId, ws);
+          if (tunnel.readyState !== WebSocket.OPEN) {
+            closeWebSocket(ws, 1011, "User-hosted tunnel disconnected");
+            return;
+          }
           tunnel.send(JSON.stringify({
             type: "ws.open",
             protocol: TUNNEL_PROTOCOL_VERSION,
@@ -1381,76 +2037,105 @@ function createWorkspaceRelayBun(options, bunOptions = {}) {
           }));
           return;
         }
+        relayClients.add(ws);
         const data = ws.data;
-        const upstream = new WebSocket(data.upstreamUrl, {
+        const UpstreamWebSocket = bunOptions.upstreamWebSocket ?? WebSocket;
+        if (data.trace) data.trace.upstreamStartedAt = performance.now();
+        const upstream = new UpstreamWebSocket(data.upstreamUrl, {
           headers: data.headers
         });
         upstream.binaryType = "arraybuffer";
         data.upstream = upstream;
+        data.upstreamOpenTimer = setTimeout(() => {
+          if (upstream.readyState === WebSocket.OPEN) return;
+          closeWebSocket(upstream, 1001, "Upstream WebSocket open timed out", 1001);
+          closeWebSocket(ws, 1011, "Upstream WebSocket open timed out");
+        }, bunOptions.upstreamWebSocketOpenTimeoutMs ?? UPSTREAM_WS_OPEN_TIMEOUT_MS_DEFAULT);
         upstream.onopen = () => {
-          for (const item of data.queue.splice(0)) upstream.send(item);
+          const openedAt = performance.now();
+          if (data.upstreamOpenTimer) {
+            clearTimeout(data.upstreamOpenTimer);
+            data.upstreamOpenTimer = void 0;
+          }
+          if (data.trace) {
+            data.trace.upstreamOpenMs = openedAt - (data.trace.upstreamStartedAt ?? data.trace.acceptedAt);
+            data.trace.queuedFrames = data.queue.length;
+            data.trace.maxQueuedDelayMs = data.queue.reduce(
+              (max, item) => Math.max(max, openedAt - item.queuedAt),
+              0
+            );
+            sendRelayWebSocketTrace(ws);
+          }
+          for (const item of data.queue.splice(0)) upstream.send(item.payload);
         };
         upstream.onmessage = (event) => {
           const payload = relayWebSocketPayload(event.data);
           if (payload !== void 0) ws.send(payload);
         };
         upstream.onclose = (event) => {
-          ws.close(event.code, event.reason);
+          if (data.upstreamOpenTimer) {
+            clearTimeout(data.upstreamOpenTimer);
+            data.upstreamOpenTimer = void 0;
+          }
+          closeWebSocket(ws, event.code, upstreamCloseReason(event));
         };
         upstream.onerror = () => {
-          ws.close(1011, "Upstream WebSocket connection failed");
+          if (data.upstreamOpenTimer) {
+            clearTimeout(data.upstreamOpenTimer);
+            data.upstreamOpenTimer = void 0;
+          }
+          closeWebSocket(ws, 1011, "Upstream WebSocket connection failed");
         };
       },
       close(ws, code, reason) {
         if (ws.data.kind === "host-tunnel") {
-          if (ws.data.heartbeat) clearInterval(ws.data.heartbeat);
-          hostTunnels.delete(ws.data.hostId);
+          cleanupHostTunnelSocket({
+            ws,
+            hostTunnels,
+            hostTunnelStateDebounce,
+            options,
+            bunOptions,
+            disconnectDirectory: true,
+            closeChannels: true
+          });
           const tracker = hostTunnelRegistrations.get(ws.data.hostId);
           if (tracker) {
-            tracker.current = Math.max(0, tracker.current - 1);
             pruneReconnects(tracker, Date.now());
-            if (tracker.current === 0 && tracker.recent.length === 0) {
-              hostTunnelRegistrations.delete(ws.data.hostId);
-            }
-          }
-          for (const pending of ws.data.pending.values()) {
-            clearTimeout(pending.timeout);
-            pending.reject(new Error("User-hosted tunnel disconnected"));
-          }
-          ws.data.pending.clear();
-          for (const channel of ws.data.channels.values()) {
-            channel.close(1011, "User-hosted tunnel disconnected");
+            if (tracker.recent.length === 0) hostTunnelRegistrations.delete(ws.data.hostId);
           }
-          ws.data.channels.clear();
-          options.directory?.disconnectHost(ws.data.hostId);
-          scheduleHostTunnelStateChange(options, {
-            hostId: ws.data.hostId,
-            workspaceId: ws.data.workspaceIds[0],
-            path: `/host-tunnels/${ws.data.hostId}`,
-            state: "disconnected",
-            debounceMs: bunOptions.hostTunnelStateDebounceMs ?? HOST_TUNNEL_STATE_DEBOUNCE_MS_DEFAULT
-          });
           return;
         }
         if (ws.data.kind === "user-hosted-client") {
           const tunnel = hostTunnel(hostTunnels, ws.data.hostId);
           tunnel?.data.channels.delete(ws.data.channelId);
-          tunnel?.send(JSON.stringify({
-            type: "ws.close",
-            protocol: TUNNEL_PROTOCOL_VERSION,
-            channel_id: ws.data.channelId,
-            code,
-            reason
-          }));
+          if (tunnel?.readyState === WebSocket.OPEN) {
+            tunnel.send(JSON.stringify({
+              type: "ws.close",
+              protocol: TUNNEL_PROTOCOL_VERSION,
+              channel_id: ws.data.channelId,
+              code: safeCloseCode(code, 1e3),
+              reason
+            }));
+          }
           return;
         }
-        ws.data.upstream?.close(code, reason);
+        relayClients.delete(ws);
+        if (ws.data.upstreamOpenTimer) clearTimeout(ws.data.upstreamOpenTimer);
+        if (ws.data.upstream) closeWebSocket(ws.data.upstream, code, reason, 1e3);
       }
     },
-    drain: drainController
+    drain: drainController,
+    telemetry
   };
 }
 
+// src/cloudflare.ts
+import {
+  makeTunnelPong as makeTunnelPong2,
+  TUNNEL_PROTOCOL_VERSION as TUNNEL_PROTOCOL_VERSION2,
+  validateTunnelMessage as validateTunnelMessage2
+} from "@claxedo/workspace-relay-protocol";
+
 // src/directory.ts
 function createWorkspaceRelayDirectory(options = {}) {
   const ttlMs = Math.max(1, options.ttlMs ?? 45e3);
@@ -1532,32 +2217,1288 @@ function createWorkspaceRelayDirectory(options = {}) {
 function disposeWorkspaceRelayDirectory(directory) {
   directory.dispose();
 }
+
+// src/cloudflare.ts
+var DEFAULT_RELAY_LOCATION_HINT = "apac";
+var TUNNEL_PENDING_HTTP_CAP_DEFAULT = 32;
+var TUNNEL_STARTED_STREAM_CAP_DEFAULT = 16;
+var TUNNEL_CHANNEL_CAP_DEFAULT = 16;
+var TUNNEL_REQUEST_BODY_MAX_BYTES_DEFAULT2 = 16 * 1024 * 1024;
+var TUNNEL_RESPONSE_BODY_MAX_BYTES_DEFAULT = 16 * 1024 * 1024;
+var SLOW_CONSUMER_HIGH_WATER_MARK_BYTES_DEFAULT2 = 8 * 1024 * 1024;
+var SLOW_CONSUMER_TIMEOUT_MS_DEFAULT2 = 3e4;
+var UPSTREAM_WS_PRE_OPEN_QUEUE_MAX_FRAMES_DEFAULT2 = 64;
+var RUNTIME_ACCESS_TOKEN_ACTIVE_CHECK_INTERVAL_MS_DEFAULT = 3e4;
+var WORKSPACE_TARGET_ACTIVE_CHECK_INTERVAL_MS_DEFAULT = 3e4;
+var TRACE_ID_HEADER = "x-claxedo-trace-id";
+var TRACE_FORCE_HEADER = "x-claxedo-relay-trace";
+function clean(input) {
+  const value = input?.trim();
+  return value ? value : void 0;
+}
+function clampRate(input) {
+  if (input === void 0 || !Number.isFinite(input)) return 0;
+  if (input <= 0) return 0;
+  if (input >= 1) return 1;
+  return input;
+}
+function traceRequest(request, routeKind, options) {
+  const id = clean(request.headers.get(TRACE_ID_HEADER)) ?? crypto.randomUUID();
+  const forced = request.headers.get(TRACE_FORCE_HEADER) === "1";
+  const rate = clampRate(options.traceSampleRate);
+  return {
+    id,
+    sampled: forced || rate > 0 && (options.random ?? Math.random)() < rate,
+    startedAt: performance.now(),
+    routeKind,
+    phases: []
+  };
+}
+async function traceSpan(trace, name, fn) {
+  const startedAt = performance.now();
+  try {
+    return await fn();
+  } finally {
+    trace?.phases.push({ name, ms: performance.now() - startedAt });
+  }
+}
+function tracedRequest(request, trace) {
+  const headers2 = new Headers(request.headers);
+  headers2.set(TRACE_ID_HEADER, trace.id);
+  if (trace.sampled) headers2.set("x-claxedo-trace-sampled", "1");
+  return new Request(request.url, {
+    method: request.method,
+    headers: headers2,
+    body: request.method === "GET" || request.method === "HEAD" ? void 0 : request.body,
+    redirect: request.redirect,
+    duplex: "half"
+  });
+}
+function roundedMs3(value) {
+  return Math.round(value * 100) / 100;
+}
+function serverTiming(trace) {
+  return trace.phases.map((phase) => `${phase.name};dur=${roundedMs3(phase.ms)}`).join(", ");
+}
+function withTraceHeaders(response, trace) {
+  const headers2 = new Headers(response.headers);
+  headers2.set(TRACE_ID_HEADER, trace.id);
+  const timing = serverTiming(trace);
+  if (timing) {
+    const existing = headers2.get("server-timing");
+    headers2.set("server-timing", existing ? `${existing}, ${timing}` : timing);
+  }
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: headers2
+  });
+}
+function logTrace(options, request, workspaceId, trace, response) {
+  if (!trace.sampled) return;
+  const url = new URL(request.url);
+  const totalMs = performance.now() - trace.startedAt;
+  const event = {
+    event: "workspace_relay_request",
+    traceId: trace.id,
+    workspaceId,
+    routeKind: trace.routeKind,
+    method: request.method,
+    path: url.pathname,
+    status: response.status,
+    totalMs: roundedMs3(totalMs),
+    phases: Object.fromEntries(trace.phases.map((phase) => [phase.name, roundedMs3(phase.ms)]))
+  };
+  if (options.traceLog) {
+    options.traceLog(event);
+    return;
+  }
+  console.log(JSON.stringify(event));
+}
+function workspaceIdFromRelayPath(pathname) {
+  return /^\/workspaces\/([^/]+)(?:\/|$)/.exec(pathname)?.[1];
+}
+function hostIdFromTunnelPath2(pathname) {
+  return /^\/host-tunnels\/([^/]+)(?:\/|$)/.exec(pathname)?.[1];
+}
+function websocketRequest2(request) {
+  return request.headers.get("upgrade")?.toLowerCase() === "websocket";
+}
+function workspaceIdsFromSearch(url) {
+  return [...new Set([
+    ...url.searchParams.getAll("workspaceId"),
+    ...url.searchParams.getAll("workspace_id")
+  ].map(clean).filter((item) => !!item))];
+}
+function randomToken() {
+  return crypto.randomUUID();
+}
+function headerRecord(headers2) {
+  const result = {};
+  headers2.forEach((value, key) => {
+    result[key] = value;
+  });
+  return result;
+}
+function headersFromRecord(input) {
+  const headers2 = new Headers();
+  for (const [key, value] of Object.entries(input)) headers2.set(key, value);
+  return headers2;
+}
+function bytesToBase64(bytes) {
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary);
+}
+function base64ToBytes(input) {
+  return Uint8Array.from(atob(input), (char) => char.charCodeAt(0));
+}
+function socketFrame(input) {
+  if (typeof input === "string") {
+    return {
+      binary: false,
+      data_base64: bytesToBase64(new TextEncoder().encode(input))
+    };
+  }
+  if (input instanceof ArrayBuffer) {
+    return {
+      binary: true,
+      data_base64: bytesToBase64(new Uint8Array(input))
+    };
+  }
+  if (input instanceof Uint8Array) {
+    return {
+      binary: true,
+      data_base64: bytesToBase64(input)
+    };
+  }
+}
+function socketPayload(input) {
+  if (typeof input === "string") return input;
+  if (input instanceof ArrayBuffer) return input;
+  if (input instanceof Uint8Array) return input;
+  if (ArrayBuffer.isView(input)) {
+    return new Uint8Array(input.buffer.slice(input.byteOffset, input.byteOffset + input.byteLength));
+  }
+}
+function tunnelFrame(input) {
+  const bytes = base64ToBytes(input.data_base64);
+  return input.binary ? bytes : new TextDecoder().decode(bytes);
+}
+function concatBytes(chunks) {
+  const length = chunks.reduce((sum, chunk) => sum + chunk.byteLength, 0);
+  const result = new Uint8Array(length);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return result;
+}
+function responseMustNotHaveBody(status) {
+  return status === 204 || status === 205 || status === 304;
+}
+async function readRequestBodyCapped(request, maxBytes) {
+  if (!request.body) return new Uint8Array(0);
+  const reader = request.body.getReader();
+  const chunks = [];
+  let total = 0;
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    total += value.byteLength;
+    if (total > maxBytes) {
+      await reader.cancel().catch(() => {
+      });
+      return "too_large";
+    }
+    chunks.push(value);
+  }
+  return concatBytes(chunks);
+}
+function safeCloseCode2(code, fallback = 1011) {
+  if (code === void 0) return fallback;
+  if (code >= 1e3 && code <= 4999 && ![1004, 1005, 1006].includes(code)) return code;
+  return fallback;
+}
+function workspaceRelayDurableObjectRoomName(workspaceId) {
+  return `workspace:${workspaceId}`;
+}
+function workspaceRelayDurableObjectWorkspaceId(request) {
+  const url = new URL(request.url);
+  const workspaceId = clean(workspaceIdFromRelayPath(url.pathname));
+  if (workspaceId) return decodeURIComponent(workspaceId);
+  if (!hostIdFromTunnelPath2(url.pathname)) return;
+  return clean(url.searchParams.get("workspaceId")) ?? clean(url.searchParams.get("workspace_id"));
+}
+function namespaceFromEnv(env, options) {
+  if (options.namespace) return options.namespace;
+  const binding = env[options.bindingName ?? "WORKSPACE_RELAY_ROOM"];
+  return binding && typeof binding === "object" ? binding : void 0;
+}
+function json(code, message, status) {
+  return Response.json(errorBody(code, message), { status });
+}
+var configuredAppOriginAllowed = () => false;
+function setWorkspaceRelayAppOrigins(raw) {
+  const entries = (raw ?? "").split(",").map((item) => item.trim()).filter(Boolean);
+  const exact = /* @__PURE__ */ new Set();
+  const suffixes = [];
+  for (const entry of entries) {
+    if (entry.startsWith("https://*.")) suffixes.push(entry.slice("https://*".length));
+    else exact.add(entry);
+  }
+  configuredAppOriginAllowed = (origin) => {
+    if (exact.has(origin)) return true;
+    if (!origin.startsWith("https://")) return false;
+    return suffixes.some((suffix) => origin.endsWith(suffix) && origin.length > "https://".length + suffix.length);
+  };
+}
+function allowedCorsOrigin2(origin) {
+  if (!origin) return;
+  if (origin.startsWith("http://localhost:")) return origin;
+  if (origin.startsWith("http://127.0.0.1:")) return origin;
+  if (/^https:\/\/([a-z0-9-]+\.)*opencode\.ai$/.test(origin)) return origin;
+  if (/^https:\/\/([a-z0-9-]+\.)*claxedo\.com$/.test(origin)) return origin;
+  if (configuredAppOriginAllowed(origin)) return origin;
+}
+function corsHeaders(request) {
+  const origin = allowedCorsOrigin2(request.headers.get("origin"));
+  if (!origin) return;
+  return {
+    "access-control-allow-origin": origin,
+    "access-control-allow-methods": "GET, HEAD, POST, PUT, PATCH, DELETE, OPTIONS",
+    "access-control-allow-headers": "Accept, Authorization, Content-Type, Last-Event-ID, X-Fetch-Bypass-Throttle, X-Daytona-Skip-Preview-Warning, X-Workspace-Id, X-OpenCode-Directory, X-Claxedo-Runner, X-Claxedo-Model, X-Claxedo-Draft-Id, X-Claxedo-Binary",
+    "access-control-max-age": "86400",
+    vary: "Origin"
+  };
+}
+function corsPreflight(request) {
+  const headers2 = corsHeaders(request);
+  return new Response(null, { status: headers2 ? 204 : 403, ...headers2 ? { headers: headers2 } : {} });
+}
+function withCors(request, response) {
+  const headers2 = corsHeaders(request);
+  if (!headers2) return response;
+  if (response.status === 101 || response.webSocket) return response;
+  const next = new Headers(response.headers);
+  for (const [key, value] of Object.entries(headers2)) next.set(key, value);
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: next
+  });
+}
+function defaultWebSocketPair() {
+  const pair = new globalThis.WebSocketPair();
+  return {
+    client: pair[0],
+    server: pair[1]
+  };
+}
+function selectedSubprotocol(request) {
+  const offered = request.headers.get("sec-websocket-protocol")?.split(",").map((item) => item.trim()).filter(Boolean);
+  if (!offered?.length) return;
+  return offered.find((item) => item.startsWith("claxedo-rat.")) ?? offered[0];
+}
+function upgradeResponse(socket, request) {
+  const protocol = selectedSubprotocol(request);
+  return new Response(null, {
+    status: 101,
+    ...protocol ? { headers: { "sec-websocket-protocol": protocol } } : {},
+    webSocket: socket
+  });
+}
+async function defaultConnectWebSocket(url, init) {
+  const res = await fetch(url, {
+    headers: {
+      ...init.headers,
+      Upgrade: "websocket"
+    }
+  });
+  const socket = res.webSocket;
+  if (!socket) throw new Error("Upstream WebSocket upgrade was not accepted");
+  socket.accept?.();
+  return socket;
+}
+function createWorkspaceRelayDurableObjectGateway(options = {}) {
+  return {
+    async fetch(request, env = {}) {
+      const gatewayStartedAt = performance.now();
+      const gatewayTraceId = clean(request.headers.get(TRACE_ID_HEADER)) ?? crypto.randomUUID();
+      const url = new URL(request.url);
+      if (request.method === "OPTIONS" && (url.pathname.startsWith("/workspaces/") || url.pathname.startsWith("/host-tunnels/"))) {
+        return corsPreflight(request);
+      }
+      if (url.pathname === "/health") {
+        return Response.json({ ok: true, service: "workspace-relay", mode: "cloudflare-durable-object" });
+      }
+      const relayLocationHint = typeof env.CLAXEDO_RELAY_LOCATION_HINT === "string" && env.CLAXEDO_RELAY_LOCATION_HINT ? env.CLAXEDO_RELAY_LOCATION_HINT : DEFAULT_RELAY_LOCATION_HINT;
+      const namespace = namespaceFromEnv(env, options);
+      if (!namespace) {
+        return json(
+          "relay_durable_object_unconfigured",
+          "Workspace Relay Durable Object binding is not configured",
+          503
+        );
+      }
+      if (url.pathname.startsWith("/host-tunnels/") && workspaceIdsFromSearch(url).length > 1) {
+        return json(
+          "host_tunnel_single_workspace_required",
+          "Durable Object relay rooms are per-workspace; host tunnels must register exactly one workspaceId per connection",
+          400
+        );
+      }
+      const workspaceId = workspaceRelayDurableObjectWorkspaceId(request);
+      if (!workspaceId) {
+        return json(
+          "relay_workspace_required",
+          "Workspace Relay requests must include a workspace id",
+          url.pathname.startsWith("/workspaces/") || url.pathname.startsWith("/host-tunnels/") ? 400 : 404
+        );
+      }
+      const routeFinishedAt = performance.now();
+      const response = await namespace.get(namespace.idFromName(workspaceRelayDurableObjectRoomName(workspaceId)), {
+        locationHint: relayLocationHint
+      }).fetch(tracedRequest(request, {
+        id: gatewayTraceId,
+        sampled: request.headers.get("x-claxedo-trace-sampled") === "1",
+        startedAt: gatewayStartedAt,
+        routeKind: "gateway",
+        phases: []
+      }));
+      const fetchFinishedAt = performance.now();
+      if (response.status === 101 || response.webSocket) {
+        return url.pathname.startsWith("/workspaces/") ? withCors(request, response) : response;
+      }
+      const headers2 = new Headers(response.headers);
+      headers2.set(TRACE_ID_HEADER, headers2.get(TRACE_ID_HEADER) ?? gatewayTraceId);
+      headers2.set("x-claxedo-relay-location-hint", relayLocationHint);
+      const gatewayResponseStartedAt = performance.now();
+      const tracedResponse = new Response(response.body, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: headers2
+      });
+      const gatewayFinishedAt = performance.now();
+      const gatewayTiming = [
+        `relay-gateway-route;dur=${roundedMs3(routeFinishedAt - gatewayStartedAt)}`,
+        `relay-gateway-do-fetch;dur=${roundedMs3(fetchFinishedAt - routeFinishedAt)}`,
+        `relay-gateway-response;dur=${roundedMs3(gatewayFinishedAt - gatewayResponseStartedAt)}`,
+        `relay-gateway;dur=${roundedMs3(gatewayFinishedAt - gatewayStartedAt)}`
+      ].join(", ");
+      tracedResponse.headers.set(
+        "server-timing",
+        tracedResponse.headers.get("server-timing") ? `${tracedResponse.headers.get("server-timing")}, ${gatewayTiming}` : gatewayTiming
+      );
+      return url.pathname.startsWith("/workspaces/") ? withCors(request, tracedResponse) : tracedResponse;
+    }
+  };
+}
+function createWorkspaceRelayDurableObjectRoom(options) {
+  const directory = options.directory ?? createWorkspaceRelayDirectory({ sweepIntervalMs: 0 });
+  const relayOptions = { ...options, directory };
+  const hostTunnels = /* @__PURE__ */ new Map();
+  const clients = /* @__PURE__ */ new Set();
+  const pairFactory = options.createWebSocketPair ?? defaultWebSocketPair;
+  const connectWebSocket = options.connectWebSocket ?? defaultConnectWebSocket;
+  const hibernation = options.hibernation;
+  let draining = false;
+  let hibernatedSocketsRebuilt = false;
+  const socketAttachment = (socket) => {
+    try {
+      return socket.deserializeAttachment?.();
+    } catch {
+      return void 0;
+    }
+  };
+  const acceptSocket = (attachment) => {
+    const pair = pairFactory();
+    if (hibernation && attachment) {
+      hibernation.acceptWebSocket(pair.server);
+      pair.server.serializeAttachment?.(attachment);
+    } else {
+      pair.server.accept?.();
+    }
+    return pair;
+  };
+  const closeSocket = (socket, code, reason) => {
+    try {
+      socket.close?.(code, reason);
+    } catch {
+    }
+  };
+  const sendSocket = (socket, message) => {
+    try {
+      socket.send?.(message);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  const cleanupTunnelResources = (tunnel, reason) => {
+    for (const pending of tunnel.pending.values()) {
+      clearTimeout(pending.timeout);
+      if (pending.stream?.slowConsumerTimeout) clearTimeout(pending.stream.slowConsumerTimeout);
+      const error = new Error(reason);
+      if (pending.stream && !pending.stream.closed) {
+        pending.stream.closed = true;
+        pending.stream.controller.error(error);
+      } else {
+        pending.reject(error);
+      }
+    }
+    tunnel.pending.clear();
+    for (const client of tunnel.channels.values()) {
+      clients.delete(client);
+      closeSocket(client.socket, 1011, reason);
+    }
+    tunnel.channels.clear();
+  };
+  const rebuildHibernatedSockets = () => {
+    if (!hibernation) return;
+    hibernatedSocketsRebuilt = true;
+    hostTunnels.clear();
+    clients.clear();
+    const clientRows = [];
+    for (const socket of hibernation.getWebSockets()) {
+      const attachment = socketAttachment(socket);
+      if (!attachment) continue;
+      if (attachment.kind === "host-tunnel") {
+        hostTunnels.set(attachment.hostId, {
+          hostId: attachment.hostId,
+          workspaceIds: attachment.workspaceIds,
+          socket,
+          pending: /* @__PURE__ */ new Map(),
+          channels: /* @__PURE__ */ new Map()
+        });
+        directory.registerHostTunnel({
+          hostId: attachment.hostId,
+          workspaceIds: attachment.workspaceIds
+        });
+        continue;
+      }
+      clientRows.push({ socket, attachment });
+    }
+    for (const row of clientRows) {
+      const tunnel = hostTunnels.get(row.attachment.target.hostId);
+      if (!tunnel) {
+        closeSocket(row.socket, 1011, "User-hosted tunnel unavailable");
+        continue;
+      }
+      const client = {
+        request: {
+          claims: row.attachment.claims,
+          target: row.attachment.target,
+          path: row.attachment.path,
+          relayHostToken: ""
+        },
+        socket: row.socket,
+        channelId: row.attachment.channelId
+      };
+      clients.add(client);
+      tunnel.channels.set(row.attachment.channelId, client);
+    }
+  };
+  const ensureHibernatedSocketsRebuilt = () => {
+    if (!hibernation || hibernatedSocketsRebuilt) return;
+    rebuildHibernatedSockets();
+  };
+  const watchRuntimeAccessToken = (client, onInactive) => {
+    const intervalMs = options.runtimeAccessTokenActiveCheckIntervalMs ?? RUNTIME_ACCESS_TOKEN_ACTIVE_CHECK_INTERVAL_MS_DEFAULT;
+    if (intervalMs <= 0) return;
+    const now = options.now ?? Date.now;
+    const timer = setInterval(() => {
+      if (client.request.claims.exp * 1e3 <= now()) {
+        clearInterval(timer);
+        onInactive("Runtime Access Token expired");
+        return;
+      }
+      if (!options.isRuntimeAccessTokenActive) return;
+      void Promise.resolve(options.isRuntimeAccessTokenActive(client.request.claims)).then((active) => {
+        if (active.active) return;
+        clearInterval(timer);
+        onInactive(active.reason);
+      }).catch(() => {
+        clearInterval(timer);
+        onInactive("Runtime Access Token active check failed");
+      });
+    }, intervalMs);
+    if (typeof timer.unref === "function") {
+      timer.unref();
+    }
+    return timer;
+  };
+  const watchUserHostedTarget = (client, onInactive) => {
+    const intervalMs = options.workspaceTargetActiveCheckIntervalMs ?? WORKSPACE_TARGET_ACTIVE_CHECK_INTERVAL_MS_DEFAULT;
+    if (intervalMs <= 0) return;
+    const target = client.request.target;
+    const timer = setInterval(() => {
+      void Promise.resolve(options.resolveTarget(client.request.claims)).then((activeTarget) => {
+        if (activeTarget?.access === "user-hosted" && activeTarget.workspaceId === target.workspaceId && activeTarget.hostId === target.hostId && directory.activeHost({ hostId: target.hostId, workspaceId: target.workspaceId })) {
+          return;
+        }
+        clearInterval(timer);
+        onInactive("User-hosted workspace is offline");
+      }).catch(() => {
+        clearInterval(timer);
+        onInactive("Workspace relay target active check failed");
+      });
+    }, intervalMs);
+    if (typeof timer.unref === "function") {
+      timer.unref();
+    }
+    return timer;
+  };
+  const clearSlowConsumerTimer = (pending) => {
+    if (!pending.stream?.slowConsumerTimeout) return;
+    clearTimeout(pending.stream.slowConsumerTimeout);
+    pending.stream.slowConsumerTimeout = void 0;
+  };
+  const sendHttpResponseFlow = (tunnel, requestId, pending, paused, reason) => {
+    if (!pending.stream || pending.stream.flowPaused === paused) return;
+    if (!paused && pending.stream.flowPaused === void 0) {
+      pending.stream.flowPaused = false;
+      return;
+    }
+    pending.stream.flowPaused = paused;
+    tunnel.socket.send?.(JSON.stringify({
+      type: "http.response.flow",
+      protocol: TUNNEL_PROTOCOL_VERSION2,
+      request_id: requestId,
+      paused,
+      reason
+    }));
+  };
+  const failSlowConsumer = (tunnel, requestId, pending) => {
+    sendHttpResponseFlow(tunnel, requestId, pending, false, "closed");
+    tunnel.pending.delete(requestId);
+    clearTimeout(pending.timeout);
+    clearSlowConsumerTimer(pending);
+    pending.chunks.length = 0;
+    if (!pending.stream || pending.stream.closed) return;
+    pending.stream.bytesQueued = 0;
+    pending.stream.closed = true;
+    pending.stream.controller.error(new Error("slow_consumer_timeout: downstream consumer did not drain in time"));
+  };
+  const armSlowConsumerTimer = (tunnel, requestId, pending) => {
+    if (pending.stream?.slowConsumerTimeout) return;
+    pending.stream.slowConsumerTimeout = setTimeout(
+      () => failSlowConsumer(tunnel, requestId, pending),
+      options.slowConsumerTimeoutMs ?? SLOW_CONSUMER_TIMEOUT_MS_DEFAULT2
+    );
+  };
+  const drainPendingStreamChunks = (tunnel, requestId, pending) => {
+    if (!pending.stream || pending.stream.closed) return;
+    while (pending.chunks.length > 0) {
+      const desired = pending.stream.controller.desiredSize;
+      if (desired !== null && desired <= 0) {
+        sendHttpResponseFlow(tunnel, requestId, pending, true, "slow_consumer");
+        armSlowConsumerTimer(tunnel, requestId, pending);
+        return;
+      }
+      const chunk = pending.chunks.shift();
+      pending.stream.bytesQueued -= chunk.byteLength;
+      try {
+        pending.stream.controller.enqueue(chunk);
+      } catch {
+        pending.chunks.length = 0;
+        pending.stream.bytesQueued = 0;
+        return;
+      }
+    }
+    clearSlowConsumerTimer(pending);
+    sendHttpResponseFlow(tunnel, requestId, pending, false, "drained");
+  };
+  const enqueuePendingStreamChunk = (tunnel, requestId, pending, chunk) => {
+    if (!pending.stream || pending.stream.closed) {
+      pending.chunks.push(chunk);
+      return;
+    }
+    const desired = pending.stream.controller.desiredSize;
+    if (desired !== null && desired <= 0 || pending.chunks.length > 0) {
+      pending.chunks.push(chunk);
+      pending.stream.bytesQueued += chunk.byteLength;
+      sendHttpResponseFlow(tunnel, requestId, pending, true, "slow_consumer");
+      armSlowConsumerTimer(tunnel, requestId, pending);
+      return;
+    }
+    try {
+      pending.stream.controller.enqueue(chunk);
+    } catch {
+      pending.stream.closed = true;
+    }
+  };
+  let startedSeqCounter = 0;
+  const evictOldestStartedStream = (tunnel, keepRequestId) => {
+    const cap = options.tunnelStartedStreamCap ?? TUNNEL_STARTED_STREAM_CAP_DEFAULT;
+    while (true) {
+      const started = [...tunnel.pending.entries()].filter(([id, entry]) => entry.startedSeq !== void 0 && id !== keepRequestId).sort((a, b) => (a[1].startedSeq ?? 0) - (b[1].startedSeq ?? 0));
+      if (started.length + 1 <= cap) return;
+      const [oldestId, oldest] = started[0];
+      failPendingTunnelResponse(tunnel, oldestId, oldest, new Error("stream_evicted: tunnel started-stream cap reached"));
+    }
+  };
+  const resolvePendingTunnelStream = (tunnel, requestId, pending, status, headers2) => {
+    if (pending.stream) return;
+    pending.startedSeq = ++startedSeqCounter;
+    evictOldestStartedStream(tunnel, requestId);
+    clearTimeout(pending.timeout);
+    const stream = new ReadableStream({
+      start(controller) {
+        pending.stream = { controller, closed: false, bytesQueued: 0 };
+        drainPendingStreamChunks(tunnel, requestId, pending);
+      },
+      pull() {
+        drainPendingStreamChunks(tunnel, requestId, pending);
+      },
+      cancel() {
+        tunnel.pending.delete(requestId);
+        clearTimeout(pending.timeout);
+        clearSlowConsumerTimer(pending);
+        pending.chunks.length = 0;
+        if (pending.stream) {
+          pending.stream.closed = true;
+          pending.stream.bytesQueued = 0;
+        }
+        tunnel.socket.send?.(JSON.stringify({
+          type: "http.response.flow",
+          protocol: TUNNEL_PROTOCOL_VERSION2,
+          request_id: requestId,
+          paused: false,
+          reason: "closed"
+        }));
+      }
+    }, new ByteLengthQueuingStrategy({
+      highWaterMark: options.slowConsumerHighWaterMarkBytes ?? SLOW_CONSUMER_HIGH_WATER_MARK_BYTES_DEFAULT2
+    }));
+    pending.resolve(new Response(stream, {
+      status,
+      headers: headers2
+    }));
+  };
+  const failPendingTunnelResponse = (tunnel, requestId, pending, error) => {
+    tunnel.pending.delete(requestId);
+    clearTimeout(pending.timeout);
+    clearSlowConsumerTimer(pending);
+    sendHttpResponseFlow(tunnel, requestId, pending, false, "closed");
+    if (pending.stream && !pending.stream.closed) {
+      pending.stream.closed = true;
+      pending.stream.controller.error(error);
+      return;
+    }
+    pending.reject(error);
+  };
+  const pendingCount = () => [...hostTunnels.values()].reduce((sum, tunnel) => sum + tunnel.pending.size, 0);
+  const closeActiveSocketsForDrain = () => {
+    for (const tunnel of hostTunnels.values()) closeSocket(tunnel.socket, 1012, "Workspace relay is draining");
+    for (const client of clients) closeSocket(client.socket, 1012, "Workspace relay is draining");
+  };
+  const drainController = {
+    isDraining: () => draining,
+    setDraining(value) {
+      draining = value;
+      if (draining) closeActiveSocketsForDrain();
+    },
+    pendingCount,
+    async waitForDrain(timeoutMs) {
+      const deadline = Date.now() + timeoutMs;
+      while (true) {
+        const remaining = pendingCount();
+        if (remaining === 0) return { drained: true, remaining: 0 };
+        if (Date.now() >= deadline) return { drained: false, remaining };
+        await new Promise((resolve) => setTimeout(resolve, 10));
+      }
+    }
+  };
+  const runtimeAccessTokenActive = async (client) => {
+    const now = options.now ?? Date.now;
+    if (client.request.claims.exp * 1e3 <= now()) {
+      return { active: false, reason: "Runtime Access Token expired" };
+    }
+    if (!options.isRuntimeAccessTokenActive) return { active: true };
+    const active = await options.isRuntimeAccessTokenActive(client.request.claims);
+    return active.active ? { active: true } : { active: false, reason: active.reason };
+  };
+  const userHostedTargetActive = async (client) => {
+    const target = client.request.target;
+    const activeTarget = await options.resolveTarget(client.request.claims);
+    return !!(activeTarget?.access === "user-hosted" && activeTarget.workspaceId === target.workspaceId && activeTarget.hostId === target.hostId && directory.activeHost({ hostId: target.hostId, workspaceId: target.workspaceId }));
+  };
+  const activeUserHostedClient = (channelId, socket) => {
+    for (const tunnel of hostTunnels.values()) {
+      const client = tunnel.channels.get(channelId);
+      if (client?.socket === socket) return { tunnel, client };
+    }
+  };
+  const handleUserHostedClientMessage = async (channelId, socket, data) => {
+    const active = activeUserHostedClient(channelId, socket);
+    if (!active) return;
+    const token = await runtimeAccessTokenActive(active.client);
+    if (!token.active) {
+      closeSocket(socket, 1008, token.reason);
+      return;
+    }
+    if (!await userHostedTargetActive(active.client)) {
+      closeSocket(socket, 1011, "User-hosted workspace is offline");
+      return;
+    }
+    const frame = socketFrame(data);
+    if (!frame) return;
+    const sent = sendSocket(active.tunnel.socket, JSON.stringify({
+      type: "ws.frame",
+      protocol: TUNNEL_PROTOCOL_VERSION2,
+      channel_id: channelId,
+      ...frame
+    }));
+    if (!sent) closeSocket(socket, 1011, "User-hosted tunnel unavailable");
+  };
+  const handleTunnelMessage = async (hostId, event) => {
+    const row = parseTunnelMessageData(event.data);
+    if (!row.ok) return;
+    const parsed = validateTunnelMessage2(row.value);
+    const tunnel = hostTunnels.get(hostId);
+    if (!parsed.ok || !tunnel) return;
+    if (parsed.message.type === "ping") {
+      directory.recordPong(tunnel.hostId);
+      tunnel.socket.send?.(JSON.stringify(makeTunnelPong2(parsed.message)));
+      return;
+    }
+    if (parsed.message.type === "error" && parsed.message.request_id) {
+      const pending = tunnel.pending.get(parsed.message.request_id);
+      if (!pending) return;
+      failPendingTunnelResponse(tunnel, parsed.message.request_id, pending, new Error(parsed.message.message));
+      return;
+    }
+    if (parsed.message.type === "http.response.start") {
+      const message = parsed.message;
+      const pending = tunnel.pending.get(message.request_id);
+      if (!pending) return;
+      pending.status = message.status;
+      pending.headers = headersFromRecord(message.headers);
+      if (responseMustNotHaveBody(pending.status)) return;
+      resolvePendingTunnelStream(tunnel, message.request_id, pending, pending.status, pending.headers);
+      return;
+    }
+    if (parsed.message.type === "http.response.chunk") {
+      const message = parsed.message;
+      const pending = tunnel.pending.get(message.request_id);
+      if (!pending) return;
+      const chunk = base64ToBytes(message.body_base64);
+      if (pending.bytes + chunk.byteLength > (options.tunnelResponseBodyMaxBytes ?? TUNNEL_RESPONSE_BODY_MAX_BYTES_DEFAULT)) {
+        failPendingTunnelResponse(tunnel, message.request_id, pending, new Error("User-hosted response body exceeds the relay limit"));
+        return;
+      }
+      pending.bytes += chunk.byteLength;
+      enqueuePendingStreamChunk(tunnel, message.request_id, pending, chunk);
+      return;
+    }
+    if (parsed.message.type === "http.response.end") {
+      const message = parsed.message;
+      const pending = tunnel.pending.get(message.request_id);
+      if (!pending) return;
+      tunnel.pending.delete(message.request_id);
+      clearTimeout(pending.timeout);
+      clearSlowConsumerTimer(pending);
+      sendHttpResponseFlow(tunnel, message.request_id, pending, false, "closed");
+      if (pending.stream) {
+        if (!pending.stream.closed) {
+          drainPendingStreamChunks(tunnel, message.request_id, pending);
+          while (pending.chunks.length > 0) {
+            const chunk = pending.chunks.shift();
+            pending.stream.bytesQueued -= chunk.byteLength;
+            pending.stream.controller.enqueue(chunk);
+          }
+          pending.stream.closed = true;
+          pending.stream.controller.close();
+        }
+        return;
+      }
+      pending.resolve(new Response(responseMustNotHaveBody(pending.status ?? 200) ? null : concatBytes(pending.chunks), {
+        status: pending.status ?? 200,
+        headers: pending.headers
+      }));
+      return;
+    }
+    if (parsed.message.type === "ws.frame") {
+      const message = parsed.message;
+      const channel = tunnel.channels.get(message.channel_id);
+      if (!channel) return;
+      const token = await runtimeAccessTokenActive(channel);
+      if (!token.active) {
+        tunnel.channels.delete(message.channel_id);
+        clients.delete(channel);
+        closeSocket(channel.socket, 1008, token.reason);
+        return;
+      }
+      sendSocket(channel.socket, tunnelFrame(message));
+      return;
+    }
+    if (parsed.message.type === "ws.close") {
+      const message = parsed.message;
+      const channel = tunnel.channels.get(message.channel_id);
+      if (!channel) return;
+      tunnel.channels.delete(message.channel_id);
+      clients.delete(channel);
+      closeSocket(channel.socket, safeCloseCode2(message.code), message.reason ?? "");
+      return;
+    }
+    if (parsed.message.type === "error" && parsed.message.channel_id) {
+      const message = parsed.message;
+      const channelId = parsed.message.channel_id;
+      const channel = tunnel.channels.get(channelId);
+      if (!channel) return;
+      tunnel.channels.delete(channelId);
+      clients.delete(channel);
+      closeSocket(channel.socket, 1011, message.message);
+    }
+  };
+  const parseTunnelMessageData = (data) => {
+    if (typeof data !== "string") return { ok: true, value: data };
+    try {
+      return { ok: true, value: JSON.parse(data) };
+    } catch {
+      return { ok: false };
+    }
+  };
+  const cleanupHostTunnel = (hostId, socket, reason) => {
+    const tunnel = hostTunnels.get(hostId);
+    if (tunnel?.socket !== socket) return;
+    cleanupTunnelResources(tunnel, reason);
+    hostTunnels.delete(hostId);
+    directory.disconnectHost(hostId);
+  };
+  const cleanupUserHostedClient = (channelId, socket, event) => {
+    for (const tunnel of hostTunnels.values()) {
+      const active = tunnel.channels.get(channelId);
+      if (!active || active.socket !== socket) continue;
+      tunnel.channels.delete(channelId);
+      clients.delete(active);
+      sendSocket(tunnel.socket, JSON.stringify({
+        type: "ws.close",
+        protocol: TUNNEL_PROTOCOL_VERSION2,
+        channel_id: channelId,
+        code: safeCloseCode2(event?.code, 1e3),
+        reason: event?.reason ?? "Client WebSocket closed"
+      }));
+      return;
+    }
+  };
+  const admitHostTunnel = async (request, roomWorkspaceId, url) => {
+    if (!websocketRequest2(request)) return json("websocket_upgrade_required", "Workspace Relay requires a WebSocket upgrade", 426);
+    const hostId = clean(hostIdFromTunnelPath2(url.pathname));
+    if (!hostId) return json("host_tunnel_host_required", "Host tunnel id is required", 400);
+    const workspaceIds = workspaceIdsFromSearch(url);
+    if (!workspaceIds.includes(roomWorkspaceId)) {
+      return json("host_tunnel_workspace_mismatch", "Host tunnel must include the room workspace id", 403);
+    }
+    const token = bearerToken(request.headers.get("authorization"));
+    if (!token) return json("host_tunnel_token_required", "Host Tunnel Token is required", 401);
+    try {
+      await verifyHostTunnelToken(token, options.runtimeAccessKey, { hostId, workspaceIds });
+    } catch (err) {
+      if (err instanceof WorkspaceRelayAuthError) {
+        return json(err.code, "Host Tunnel Token was denied", 403);
+      }
+      throw err;
+    }
+    const pair = acceptSocket({
+      kind: "host-tunnel",
+      hostId,
+      workspaceIds,
+      connectedAt: options.now?.() ?? Date.now()
+    });
+    const previous = hostTunnels.get(hostId);
+    if (previous) {
+      cleanupTunnelResources(previous, "Host tunnel replaced");
+      closeSocket(previous.socket, 1012, "Host tunnel replaced");
+    }
+    hostTunnels.set(hostId, {
+      hostId,
+      workspaceIds,
+      socket: pair.server,
+      pending: /* @__PURE__ */ new Map(),
+      channels: /* @__PURE__ */ new Map()
+    });
+    directory.registerHostTunnel({ hostId, workspaceIds });
+    if (!hibernation) {
+      pair.server.addEventListener?.("message", (event) => {
+        if (event && event.data !== void 0) void handleTunnelMessage(hostId, { data: event.data });
+      });
+      pair.server.addEventListener?.("close", () => cleanupHostTunnel(hostId, pair.server, "User-hosted tunnel disconnected"));
+      pair.server.addEventListener?.("error", () => cleanupHostTunnel(hostId, pair.server, "User-hosted tunnel disconnected"));
+    }
+    return upgradeResponse(pair.client, request);
+  };
+  const admitClient = async (request, workspaceId) => {
+    if (!websocketRequest2(request)) return json("websocket_upgrade_required", "Workspace Relay requires a WebSocket upgrade", 426);
+    const authorized = await authorizeWorkspaceRelayRequest(relayOptions, request, workspaceId);
+    if (!authorized.ok) return authorized.response;
+    if (authorized.request.target.access !== "cloud") return admitUserHostedClient(request, authorized.request);
+    return await admitCloudClient(request, authorized.request);
+  };
+  const admitCloudClient = async (request, authorized) => {
+    let upstream;
+    try {
+      upstream = await connectWebSocket(
+        workspaceRelayTargetUrl(
+          authorized.target,
+          authorized.path,
+          new URL(request.url).search
+        ).toString(),
+        {
+          headers: headerRecord(workspaceRelayForwardHeaders(
+            new Headers(),
+            authorized.relayHostToken,
+            authorized.target.workspaceId,
+            { userHosted: false, upstreamHeaders: authorized.target.upstreamHeaders }
+          ))
+        }
+      );
+    } catch {
+      return json("upstream_unavailable", "Workspace upstream is unavailable", 503);
+    }
+    const pair = acceptSocket();
+    const client = { request: authorized, socket: pair.server };
+    clients.add(client);
+    let closed = false;
+    let upstreamOpen = upstream.readyState === void 0 || upstream.readyState === 1;
+    const queue = [];
+    const activeTokenTimer = watchRuntimeAccessToken(client, (reason) => {
+      closeSocket(pair.server, 1008, reason);
+    });
+    const cleanupClient = (event) => {
+      if (closed) return;
+      closed = true;
+      if (activeTokenTimer) clearInterval(activeTokenTimer);
+      clients.delete(client);
+      closeSocket(upstream, safeCloseCode2(event?.code, 1e3), event?.reason ?? "Client WebSocket closed");
+    };
+    const cleanupUpstream = (event) => {
+      if (closed) return;
+      closed = true;
+      if (activeTokenTimer) clearInterval(activeTokenTimer);
+      clients.delete(client);
+      closeSocket(pair.server, safeCloseCode2(event?.code), event?.reason ?? "");
+    };
+    const flushQueue = () => {
+      upstreamOpen = true;
+      for (const item of queue.splice(0)) {
+        if (!sendSocket(upstream, item)) {
+          closeSocket(pair.server, 1011, "Upstream WebSocket connection failed");
+          return;
+        }
+      }
+    };
+    pair.server.addEventListener?.("message", (event) => {
+      const payload = socketPayload(event?.data);
+      if (payload === void 0) return;
+      if (!upstreamOpen) {
+        if (queue.length >= (options.upstreamWebSocketPreOpenQueueMaxFrames ?? UPSTREAM_WS_PRE_OPEN_QUEUE_MAX_FRAMES_DEFAULT2)) {
+          closeSocket(pair.server, 1011, "Upstream WebSocket queue limit exceeded");
+          cleanupClient({ code: 1011, reason: "Upstream WebSocket queue limit exceeded" });
+          return;
+        }
+        queue.push(payload);
+        return;
+      }
+      if (!sendSocket(upstream, payload)) closeSocket(pair.server, 1011, "Upstream WebSocket connection failed");
+    });
+    pair.server.addEventListener?.("close", cleanupClient);
+    pair.server.addEventListener?.("error", cleanupClient);
+    upstream.addEventListener?.("open", flushQueue);
+    upstream.addEventListener?.("message", (event) => {
+      const payload = socketPayload(event?.data);
+      if (payload !== void 0) sendSocket(pair.server, payload);
+    });
+    upstream.addEventListener?.("close", cleanupUpstream);
+    upstream.addEventListener?.("error", () => cleanupUpstream({ code: 1011, reason: "Upstream WebSocket connection failed" }));
+    return upgradeResponse(pair.client, request);
+  };
+  const admitUserHostedClient = (request, authorized) => {
+    const tunnel = hostTunnels.get(authorized.target.hostId);
+    if (!tunnel || !directory.activeHost({ hostId: authorized.target.hostId, workspaceId: authorized.target.workspaceId })) {
+      return json("user_hosted_app_offline", "User-hosted workspace is offline", 503);
+    }
+    if (tunnel.channels.size >= (options.tunnelChannelCap ?? TUNNEL_CHANNEL_CAP_DEFAULT)) {
+      return json("too_many_channels", "User-hosted tunnel has too many active WebSocket channels", 503);
+    }
+    const channelId = randomToken();
+    const pair = acceptSocket({
+      kind: "user-hosted-client",
+      channelId,
+      claims: authorized.claims,
+      target: authorized.target,
+      path: authorized.path,
+      connectedAt: options.now?.() ?? Date.now()
+    });
+    const client = {
+      request: authorized,
+      socket: pair.server,
+      channelId
+    };
+    clients.add(client);
+    tunnel.channels.set(channelId, client);
+    const activeTokenTimer = hibernation ? void 0 : watchRuntimeAccessToken(client, (reason) => {
+      closeSocket(pair.server, 1008, reason);
+    });
+    const activeTargetTimer = hibernation ? void 0 : watchUserHostedTarget(client, (reason) => {
+      closeSocket(pair.server, 1011, reason);
+    });
+    if (!hibernation) {
+      const cleanup = (event) => {
+        if (activeTokenTimer) clearInterval(activeTokenTimer);
+        if (activeTargetTimer) clearInterval(activeTargetTimer);
+        cleanupUserHostedClient(channelId, pair.server, event);
+      };
+      pair.server.addEventListener?.("message", (event) => {
+        if (!event) return;
+        void handleUserHostedClientMessage(channelId, pair.server, event.data);
+      });
+      pair.server.addEventListener?.("close", cleanup);
+      pair.server.addEventListener?.("error", cleanup);
+    }
+    sendSocket(tunnel.socket, JSON.stringify({
+      type: "ws.open",
+      protocol: TUNNEL_PROTOCOL_VERSION2,
+      channel_id: channelId,
+      workspace_id: authorized.target.workspaceId,
+      path: authorized.path,
+      headers: headerRecord(workspaceRelayForwardHeaders(
+        new Headers(),
+        authorized.relayHostToken,
+        authorized.target.workspaceId,
+        { userHosted: true }
+      ))
+    }));
+    return upgradeResponse(pair.client, request);
+  };
+  const forwardCloudHttp = async (request, workspaceId, trace) => {
+    const authorized = await traceSpan(
+      trace,
+      "relay-auth",
+      () => authorizeWorkspaceRelayRequest(relayOptions, request, workspaceId, {
+        span: (name, run) => traceSpan(trace, name, run)
+      })
+    );
+    if (!authorized.ok) return authorized.response;
+    if (authorized.request.target.access !== "cloud") {
+      trace && (trace.routeKind = "user-hosted-http");
+      return forwardUserHostedHttp(request, authorized.request, trace);
+    }
+    trace && (trace.routeKind = "cloud-http");
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), options.forwardTimeoutMs ?? 3e4);
+    try {
+      const upstream = await traceSpan(trace, "upstream-fetch", () => (options.fetch ?? fetch)(
+        workspaceRelayTargetUrl(
+          authorized.request.target,
+          authorized.request.path,
+          new URL(request.url).search
+        ),
+        workspaceRelayForwardRequestInit(request, authorized.request.relayHostToken, workspaceId, {
+          signal: controller.signal,
+          upstreamHeaders: authorized.request.target.upstreamHeaders
+        })
+      ));
+      return new Response(upstream.body, {
+        status: upstream.status,
+        statusText: upstream.statusText,
+        headers: upstream.headers
+      });
+    } catch (err) {
+      const aborted = err instanceof Error && err.name === "AbortError";
+      return Response.json(
+        errorBody(
+          aborted ? "upstream_timeout" : "upstream_unavailable",
+          aborted ? "Workspace upstream timed out" : "Workspace upstream is unavailable"
+        ),
+        { status: aborted ? 504 : 503 }
+      );
+    } finally {
+      clearTimeout(timer);
+    }
+  };
+  const forwardUserHostedHttp = async (request, authorized, trace) => {
+    const tunnel = hostTunnels.get(authorized.target.hostId);
+    if (!tunnel || !directory.activeHost({ hostId: authorized.target.hostId, workspaceId: authorized.target.workspaceId })) {
+      return json("user_hosted_app_offline", "User-hosted workspace is offline", 503);
+    }
+    const awaitingStart = [...tunnel.pending.values()].filter((entry) => entry.startedSeq === void 0).length;
+    if (awaitingStart >= (options.tunnelPendingHttpCap ?? TUNNEL_PENDING_HTTP_CAP_DEFAULT)) {
+      return json("too_many_pending_requests", "User-hosted tunnel has too many pending HTTP requests", 503);
+    }
+    const requestId = randomToken();
+    const init = workspaceRelayForwardRequestInit(request, authorized.relayHostToken, authorized.target.workspaceId, {
+      userHosted: true
+    });
+    const bodyMaxBytes = options.tunnelRequestBodyMaxBytes ?? TUNNEL_REQUEST_BODY_MAX_BYTES_DEFAULT2;
+    const contentLength = Number(request.headers.get("content-length") ?? Number.NaN);
+    if (Number.isFinite(contentLength) && contentLength > bodyMaxBytes) {
+      return json("request_body_too_large", "User-hosted request body exceeds the relay limit", 413);
+    }
+    const bodyBytes = request.method === "GET" || request.method === "HEAD" ? void 0 : await traceSpan(trace, "request-body", () => readRequestBodyCapped(request, bodyMaxBytes));
+    if (bodyBytes === "too_large") {
+      return json("request_body_too_large", "User-hosted request body exceeds the relay limit", 413);
+    }
+    const body = bodyBytes ? bytesToBase64(bodyBytes) : void 0;
+    const pending = new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        tunnel.pending.delete(requestId);
+        tunnel.socket.send?.(JSON.stringify({
+          type: "http.response.flow",
+          protocol: TUNNEL_PROTOCOL_VERSION2,
+          request_id: requestId,
+          paused: false,
+          reason: "closed"
+        }));
+        reject(new Error("User-hosted tunnel timed out"));
+      }, options.forwardTimeoutMs ?? 3e4);
+      tunnel.pending.set(requestId, {
+        chunks: [],
+        bytes: 0,
+        timeout,
+        resolve,
+        reject
+      });
+    });
+    tunnel.socket.send?.(JSON.stringify({
+      type: "http.request",
+      protocol: TUNNEL_PROTOCOL_VERSION2,
+      request_id: requestId,
+      workspace_id: authorized.target.workspaceId,
+      method: request.method,
+      path: `${authorized.path}${new URL(request.url).search}`,
+      headers: headerRecord(init.headers instanceof Headers ? init.headers : new Headers(init.headers)),
+      ...body ? { body_base64: body } : {},
+      end: true
+    }));
+    try {
+      return await traceSpan(trace, "tunnel-wait", () => pending);
+    } catch (err) {
+      const timeout = err instanceof Error && err.message.includes("timed out");
+      const responseTooLarge = err instanceof Error && err.message.includes("response body exceeds");
+      return Response.json(
+        errorBody(
+          timeout ? "user_hosted_tunnel_timeout" : responseTooLarge ? "user_hosted_response_body_too_large" : "user_hosted_tunnel_unavailable",
+          timeout ? "User-hosted tunnel timed out" : responseTooLarge ? "User-hosted response body exceeds the relay limit" : "User-hosted tunnel is unavailable"
+        ),
+        { status: responseTooLarge ? 413 : 503 }
+      );
+    }
+  };
+  return {
+    async fetch(request) {
+      ensureHibernatedSocketsRebuilt();
+      const url = new URL(request.url);
+      const roomWorkspaceId = workspaceRelayDurableObjectWorkspaceId(request);
+      if (request.method === "OPTIONS" && (url.pathname.startsWith("/workspaces/") || url.pathname.startsWith("/host-tunnels/"))) {
+        return corsPreflight(request);
+      }
+      if (url.pathname === "/health") {
+        return Response.json({
+          ok: !draining,
+          service: "workspace-relay-room",
+          mode: "cloudflare-durable-object",
+          workspaceId: roomWorkspaceId,
+          hostTunnelCount: hostTunnels.size,
+          clientCount: clients.size,
+          draining
+        }, { status: draining ? 503 : 200 });
+      }
+      if (draining) return json("relay_draining", "Workspace relay is shutting down; try another instance", 503);
+      if (!roomWorkspaceId) return json("relay_workspace_required", "Workspace Relay requests must include a workspace id", 400);
+      if (url.pathname.startsWith("/host-tunnels/")) return admitHostTunnel(request, roomWorkspaceId, url);
+      if (url.pathname.startsWith("/workspaces/")) {
+        if (websocketRequest2(request)) return admitClient(request, roomWorkspaceId);
+        const trace = traceRequest(request, "workspace-http", options);
+        const roomTotalStartedAt = performance.now();
+        const nextRequest = tracedRequest(request, trace);
+        const response = await traceSpan(trace, "relay-room", () => forwardCloudHttp(nextRequest, roomWorkspaceId, trace));
+        trace.phases.push({ name: "relay-room-total", ms: performance.now() - roomTotalStartedAt });
+        const tracedResponse = withTraceHeaders(response, trace);
+        logTrace(options, nextRequest, roomWorkspaceId, trace, tracedResponse);
+        return withCors(request, tracedResponse);
+      }
+      return json("relay_route_not_found", "Workspace Relay route not found", 404);
+    },
+    async webSocketMessage(socket, message) {
+      ensureHibernatedSocketsRebuilt();
+      const attachment = socketAttachment(socket);
+      if (!attachment) return;
+      if (attachment.kind === "host-tunnel") {
+        await handleTunnelMessage(attachment.hostId, { data: message });
+        return;
+      }
+      await handleUserHostedClientMessage(attachment.channelId, socket, message);
+    },
+    webSocketClose(socket, code, reason) {
+      ensureHibernatedSocketsRebuilt();
+      const attachment = socketAttachment(socket);
+      if (!attachment) return;
+      if (attachment.kind === "host-tunnel") {
+        cleanupHostTunnel(attachment.hostId, socket, "User-hosted tunnel disconnected");
+        return;
+      }
+      cleanupUserHostedClient(attachment.channelId, socket, { code, reason });
+    },
+    webSocketError(socket) {
+      ensureHibernatedSocketsRebuilt();
+      const attachment = socketAttachment(socket);
+      if (!attachment) return;
+      if (attachment.kind === "host-tunnel") {
+        cleanupHostTunnel(attachment.hostId, socket, "User-hosted tunnel disconnected");
+        return;
+      }
+      cleanupUserHostedClient(attachment.channelId, socket, { code: 1011, reason: "WebSocket error" });
+    },
+    state() {
+      ensureHibernatedSocketsRebuilt();
+      return {
+        hostTunnelCount: hostTunnels.size,
+        clientCount: clients.size,
+        hostIds: [...hostTunnels.keys()]
+      };
+    },
+    drain: drainController
+  };
+}
 export {
+  DEFAULT_RELAY_LOCATION_HINT,
   WorkspaceRelayAuthError,
-  __resetHostTunnelStateDebounce,
   __slowConsumerInternalsForTest,
   authorizeWorkspaceRelayRequest,
+  createCachedRevocationClient,
+  createCachedTargetClient,
   createWorkspaceRelay,
   createWorkspaceRelayBun,
   createWorkspaceRelayDirectory,
+  createWorkspaceRelayDurableObjectGateway,
+  createWorkspaceRelayDurableObjectRoom,
+  createWorkspaceRelayTrace,
   disposeAuditSampler,
   disposeWorkspaceRelayDirectory,
+  forwardWorkspaceRelayRequest,
   getAuditSuppressedCount,
-  getFragmentationStats,
-  getSlowConsumerStats,
   hostTunnelTokenAudience,
+  isRelayClaimPair,
   mintHostTunnelToken,
   mintRelayHostToken,
   mintRuntimeAccessToken,
   relayHostTokenAudience,
   relayHostTokenIssuer,
-  resetFragmentationStats,
-  resetSlowConsumerStats,
   runtimeAccessTokenAudience,
   runtimeAccessTokenIssuer,
+  setWorkspaceRelayAppOrigins,
+  validateRuntimeAccessTokenClaims,
   verifyHostTunnelToken,
   verifyRelayHostToken,
   verifyRuntimeAccessToken,
+  workspaceRelayDurableObjectRoomName,
+  workspaceRelayDurableObjectWorkspaceId,
   workspaceRelayForwardHeaders,
-  workspaceRelayTargetUrl
+  workspaceRelayForwardRequestInit,
+  workspaceRelayServerTiming,
+  workspaceRelayTargetUrl,
+  workspaceRelayTimingResponse
 };